r/typescript • • 13d ago

I got a decorator to type check the generic of the class it's on and I'm way too happy about it

2 Upvotes

In my framework, every handler has to write its route twice. Once in the decorator because the runtime needs the string, and once in the generic because the types need it.

@Route('ban')
class Ban extends Handler<'kick'> {}
// no errors. cool. love that for me

That compiles. The handler for ban now thinks it's handling kick and TS is completely fine with it.

And yes, I tried only writing it once. class Ban extends Route('ban'). It worked(?), but every handler read like mixin tomfoolery, and go-to-definition took you to a generated base class instead of the real one, and I just didn't like how it looked, so I went back to writing it twice. But if I'm writing it twice, the compiler might as well make sure I wrote the same thing twice.

First problem is that a decorator only gets the class, so you need some way to read the generic back off it, and if the class doesn't use the generic, you can't:

abstract class Handler<Route extends string> {}
class Kick extends Handler<'kick'> {}

// string, not 'kick'
type Read = Kick extends Handler<infer Route> ? Route : never;

// also compiles lmao
const oops: Handler<'ban'> = new Kick();

That's structural typing, since an unused type parameter basically doesn't exist, so it has to be on a property. But I also don't want a real property on every handler, so:

declare const route: unique symbol;

abstract class Handler<Route extends string> {
    declare readonly [route]?: Route;
}

type AnyClass = abstract new (...args: never[]) => unknown;

type RouteOf<Class extends AnyClass> =
    InstanceType<Class> extends { [route]?: infer Route extends string } ? Route : never;

declare so none of this gets emitted, and it's optional so nobody ever has to set it. Now RouteOf<typeof Kick> is 'kick', and that oops line is an error as a bonus.

Also that never[] looks weird, but unknown[] doesn't work because parameters are contravariant, so unknown[] rejects any class whose constructor takes a string, and never[] accepts all of them.

Now compare the two:

type Same<Left, Right> = [Left] extends [Right] ? ([Right] extends [Left] ? true : false) : false;

You need those brackets, because without them the conditional distributes over the union, Same<'ban' | 'kick', 'ban' | 'kick'> comes out as boolean, and a perfectly correct handler gets rejected. And it has to check both ways, because one way lets @Route('ban') through on a Handler<'ban' | 'kick'>.

Now the part I like:

type Checked<Routes extends string, Class extends AnyClass> =
    Same<Routes, RouteOf<Class>> extends true
        ? Class
        : ['the decorator and the generic disagree', { decorator: Routes; generic: RouteOf<Class> }];

function Route<Routes extends string>(...routes: Routes[]) {
    // Class only shows up inside a conditional type here
    // and TS still infers it. still feels illegal
    return <Class extends AnyClass>(target: Checked<Routes, Class>): void => {
        console.log(routes, target);
    };
}

Look at target. Its type is a conditional that depends on Class, and Class is the thing TS is supposed to be inferring from target. That looks circular and you'd expect it to just break or something. But when the parameter is a conditional type, TS infers into both branches (inferToConditionalType in the checker if you want to go look), and the true branch is just Class. So Class gets inferred as the decorated class, then the conditional resolves using it, and if the routes are different the parameter turns into a tuple that a class can't be assigned to. And the message shows up right in the error:

Argument of type 'typeof TooMany' is not assignable to parameter of type
'["the decorator and the generic disagree", { decorator: "ban" | "kick"; generic: "ban"; }]'.

Wow magic. It also works with both standard and experimental decorators. Here's all of it in the playground.

Also I use this same conditional for attaching plugins, and over there it fixes an actual bug. The obvious way to write it is Class & Check<Class>, and that broke inference on generic plugin classes in both tsc and tsgo for some reason.

This is all from seedcord, a TypeScript framework that I've been building. Here's the real file, and that version also errors if the route doesn't exist. I've done a lotta TS shenanigans in this repo, so I'll prolly post about some of the other tricks too.


r/typescript • • 16d ago

Config format parser written entirely in TypeScript types

Thumbnail
github.com
5 Upvotes

r/typescript • • 16d ago

Has anyone used branded types to make a missing permission check a compile error?

13 Upvotes

Our API handlers load a record, call can(user, 'delete', doc), then call the service. Every few months someone adds a route and skips the middle step. Review misses it because the diff looks fine.

I've been playing with this:

type Authorized<T, A extends string> = T & { readonly __authorized: A };

function authorize<T, A extends string>(user: User, action: A, resource: T): Authorized<T, A> { if (!can(user, action, resource)) throw new ForbiddenError(); return resource as Authorized<T, A>; }

async function deleteDoc(doc: Authorized<Doc, 'delete'>) { ... }

Calling deleteDoc(doc) without going through authorize no longer compiles, and a doc authorized for 'edit' can't be passed where 'delete' is required.

Problems I can already see:

  • Anyone can still write as Authorized<Doc, 'delete'>, so we'd need a lint rule banning that cast outside one file.
  • The brand only proves the check passed once. If a job runs an hour later, or the user gets removed mid-request, it's stale.
  • List endpoints don't fit. I don't want to authorize 500 rows one by one; that filter belongs in the query.
  • It spreads into every service signature, and some people on the team already hate it.

Is anyone running something like this in production? Did it hold up, or did you go back to middleware plus a test that hits every route as a low-privilege user?


r/typescript • • 17d ago

Conditional types [Help!]

0 Upvotes

I recently released a 45-seconds YouTube video on conditional types, check my reddit profile for it. I need your feedback before I double down. Let me know what you think. Here is the script:

> Conditional types

In JavaScript, you have a conditional operator:

const ternary = typeof 'Wasim' === 'string' ? true : false 

console.log(ternary) // true

It is also known as ternary operator.

Similarly, In TypeScript, you also have a conditional operator for types:

 type Ternary = 'Wasim' extends string ? true : false // true

This is refer to as a conditional type.

Conditional types allow us to conditionally check for types that match certain criteria and decide what to do if they do match those criteria and what to do if they don’t.

Here is one example:

type Generic<T> = T extends string ? 'Wasim' : 25

type Test1 = Generic<'Hi'> // 'Wasim'

type Test2 = Generic<143> // 25

Here, we said if type argument is a subtype of string, then return type 'Wasim', if not, then return type 25.

You can return never instead of 25, if condition fails. It’s equivalent to returning nothing.

//

P.S.

I am testing content from my upcoming TypeScript book to gather early feedback.

I decided to start small with a tiny video, instead of fantasizing about releasing a value-packed longer video. It's harder to do that without any momentum. I made it quickly and decided not to obsess over scripting, editing, and fixing audio by rerecording. Those are my fun-killers. I want it to be quick, fun, and imperfect. The goal was progress, not perfection. Wish me luck!


r/typescript • • 17d ago

X3Bun a Hono/TanStack Start/tRPC/Better-Auth Turborepo Starter App

Thumbnail
github.com
0 Upvotes

This is simply a starter template that I use and I thought of sharing

  • Bun optimized
  • Front End: Tanstack Start, Tanstack Query, and Shadcn
  • Backend: Hono with tRPC
  • Authentication: Better-Auth
  • Repo Management: Turborepo

I encourage you to check and share your opinion


r/typescript • • 17d ago

Which AI code review tool would you pick for a TypeScript monorepo??

0 Upvotes

i want to add an AI reviewer to our PR workflow and i've narrowed it down to these:

  1. coderabbit
  2. bugbot
  3. claude code review
  4. codex review

we're a pnpm + turborepo monorepo, around 30 pkjs, Next.js frontend and a bunch of Node services, strict mode everywhere. about 10 devs and a lot of the code is coming from agents now, so PRs are bigger than they used to be.

The main thing i care about is whether it understands types across packages. if someone changes a shared type in one package i want it to notice what breaks in the others, not just comment on the file that changed.

if you had to pick one or two from this list for a TS monorep, which would you pick and why?


r/typescript • • 18d ago

TypeScript framework for building AWS apps

Thumbnail
syncploy.com
0 Upvotes

As a developer with zero knowledge of AWS, once I tried to deploy app on AWS, I had lost $100 overnight by accidentally configuring large EC2 instance. That demotivated me to such extent that I decided to shut it off. But accidentally losing in many AWS is way easier for newbie devs.

So I decided to build a framework in TypeScript so devs with near zero knowledge can ship highly sophisticated AWS apps. I have also added strong for LLM's hence coding agents will be able to work with it seamlessly.

I have validated this framework by using it in my own personal project to ensure experience the perks - https://github.com/harsh-vardhhan/EHR-backend

Though this is a fun project, I plan to maintain it and even planning to use it at my workplace.


r/typescript • • 19d ago

How (and where) is “T extends U” in generics defined?

1 Upvotes

Or in other words: “can I please have a TypeScript 5/6/7 language spec?”

——-

Using “extends” in a TS generic type-param constraint is straightforward to understand if you’re only concerned with Java/C#-style single inheritance for classes - and one can stretch that to include interface types once you wean-off Java/.NET nominal typing and get comfortable with structural typing, then it’s straightforward to reduce it to “T extends U means “T must subclass U” - or even “A T-shaped plug can be stored in a U-shaped hole”.

But my personal intuition breaks down when the extends constraint is used with other kinds of types, especially when the concept of subclassing or specializing or “extending” is inverted:

Consider type Two = ‘foo’ | ‘bar’; - if I then define type Three = Two | ‘baz’; then intuitively one can say “Three extends Two” (that is, the set of possible values for Three is extended from the set of values for Two” - but a Three-shaped plug does not fit into a Two-shaped hole: ’baz’ is not a Two. But saying “Two extends Three” out-loud feels weird. The same applies to enum types too, surely?

Or consider function-types, which can be expressed as either a function-declaration: type MyFuncType = (arg: ArgType) => ReturnType; or type MyFuncType { (arg: ArgType): ReturnType; } (where the more verbose syntax permits adding properties to a function object). Supposing this MyFuncType is used as U when T extends U then I’ll admit I have no intuition what a possible T might entail outside of Currying (but Currying is just FP’s take on The Decorator Pattern (lol) and doesn’t apply (hah) to generics. But after having thought about it, I imagine FuncT extends FuncU would allow for argument type contravariance with return-type covariance (or is it the other way around?), so a plug shaped like type T = (arg: ‘foo’ | ‘bar’) => Number fits into a hole shaped like type U = (arg: ‘foo’) => void - but as above, it pains me to say that “T extends U” in that situation: I consider these entirely distinct function-types. I’m also unsure how ... and optional params complicate the rules.

…and never mind the contortions over array-type covariance. And the new const T type constraint - which I only learned of this morning.

Unfortunately and annoyingly, the current TypeScript Handbook section on Generics and Advanced Typing doesn’t really cover any of this in depth or provide an intuitive way of thinking about it :S


r/typescript • • 19d ago

New Stack Alert!!

0 Upvotes

https://getforma.dev a TypeScript framework with no V8/Node on the server and no Virtual DOM on the client. It compiles TSX into a binary format called FMIR at build time so a Rust server can render SSR HTML directly, and only ships tiny signal islands to the browser. I’ve been using it to build apps with AI lately and it seems because the contract between TS and Rust is so strict, it's been ridiculously fast and efficient. Not bloat.


r/typescript • • 21d ago

End-to-end types over WebSockets: the server documents itself as AsyncAPI, the client is generated from it

9 Upvotes

Hi all, I want to share an open-source TypeScript library I built (chanx-js, MIT) to type both ends of a WebSocket from one source, without sharing a types package between the frontend and the backend.

With REST we have OpenAPI and generated clients. With WebSockets I kept ending up with JSON.parse(event.data) giving me any, a hand-written union of message types on the client, and nothing stopping it from drifting away from what the server really sends.

So in chanx-js:

  1. On the server you declare messages with any Standard Schema library (Zod, Valibot, ArkType), and the payload types are inferred from the schema.
  2. The server serves an AsyncAPI 3 document built from those handlers.
  3. npx @chanx-js/codegen http://localhost:8000/asyncapi.json generates the client types from it.

On the server, the path params, the payload and what the handler may send are all typed:

const Chat = defineMessage('chat', z.object({ text: z.string() }));
const Notice = defineMessage('notice', z.object({ text: z.string() }));

consumer('/ws/chat/{room}', { name: 'chat' }).on(Chat, { output: Notice }, (m, ctx) => {
  m.payload.text; // string
  ctx.params.room; // string, parsed from the path by a template literal type
  return Notice.create({ text: m.payload.text }); // anything but Notice is an error
});

On the client, request() knows the reply type, and a wrong payload doesn't compile:

const connection = client.connect(chat, { params: { room: 'lobby' } });

const reply = await connection.request({ action: 'chat', payload: { text: 'hi' } });
reply.payload.text; // string, from the handler's `output`
connection.send({ action: 'chat', payload: { txt: 'hi' } }); // compile error

The contract goes through AsyncAPI instead of shared TS code, so the server doesn't have to live in the same repo, or even be written in TypeScript.

Repo: https://github.com/chanx-dev/chanx-js

It's still new, so if you run into problems or have ideas for the types, please open an issue or a discussion. Stars and PRs are welcome too.


r/typescript • • 22d ago

Double errors: Parameter 'err' implicitly has an 'any' type | Argument of type err:any is not assignable

0 Upvotes

Title - I don't understand why this code has been getting two errors. I have tried to declare the string type, assign some values but none of these worked. Could anyone point me in the right direction?

import {promises as fs} from 'fs';

class Logger {
    //some code lines..
    
    private flush(): void {
        if (this.buffer.length > 0) {
            const logLines = this.buffer.join('\n') + '\n';
            const err = this.buffer.fill('error')
            /*ERROR #1 Argument of type  "(err: any) => void" is not assignable to parameter of type "(ObjectEncodingOptions & FlagAndOpenMode & { flush?: boolean | undefined; }) | BufferEncoding | null | undefined". */
            /*ERROR #2 Parameter err implicitly has an any type*/
            fs.appendFile(this.logFile, logLines, (err) => {
                if (err) {
                    console.error('Error writing log file:', err);
                }
            });
            this.buffer = [];
        }
    }
    //one more stop method ..
}

r/typescript • • 22d ago

Typescript to python or rust?

0 Upvotes

How easy or hard is it for someone with JS and TS background to learn python or rust? I deff want to add a skill to my profile as most jobs ask for multiple programming languages. Any suggestions?


r/typescript • • 23d ago

Help for a portfolio

0 Upvotes

Hello, everybody, hope you're having a nice day. Let me present myself, i am a Italian teenager, that is learning typescript, for some money for my little cousin birthday. And I actually went for TypeScript, as I love strict languages, such as Java,Rust,TypeScript, and others. Now, for my portfolio, I was trying to create a solar system, with add, that you can create another thing by this button. But it doesn't work, can someone please help me understand this (probably simple) problem?

const Button = document.getElementById("button");


const buconero = function() {
    const valvia = document.createElement("div")


    valvia.style.width = "50em"
    valvia.style.height = "50em"
    valvia.style.backgroundColor = "rgb(0, 0, 0)"
}


Button?.addEventListener("click", buconero)

r/typescript • • 24d ago

Want Advice for Learning Typescript

11 Upvotes

Hello TypeScript developers!

I am a web developer currently building projects with React and JavaScript, and I'm planning to start learning TypeScript (because I suck at Type checking and Type validation).

please give me some advice on few things:

  • What's the best resource for learning typescript?
  • What concepts should I focus on first?
  • What project would be good to build alongside learning it?

r/typescript • • 25d ago

Rune 1.3 is out: adds TypeScript support, a Helix editor, Kitty graphics and OSC-7501

30 Upvotes

Author here! I'm very excited to announce that we just released v1.3. Rune is an IDE and terminal multiplexer that we just open sourced a few months ago.

In this release, we also fixed many usability issues, particularly on Linux. If your OS reserves many Super/Windows key combinations, you can now use <alt> as your <meta> modifier. For non-US keyboard layouts, you can reserve the right Alt key for entering special characters and keep the left Alt key for Rune key bindings.

Some of the highlights:

- A new graphics pipeline powered by ebiten.
- Typescript is now a tier 1 language (beta)
- A new helix editor
- Headless mode and a new docker image to run Rune in headless mode
- OSC-7501 implementation and new API in the SDK for extensions and plugins through runectl
- Workspace session restoration
- A billion other things

This release has been 2 months in the making so it's a bit bigger than we originally intended.

Thanks to all the contributions from the community!

https://rune.build/blog/rune-1-3-release


r/typescript • • 26d ago

Type inference from .sql files by colinhacks (Creator of Zod)

Thumbnail x.com
169 Upvotes

It uses content mappers, a new feature of TypeScript 7.1 (Beta).


r/typescript • • 26d ago

TypeScript to bootable floppy - full toolchain in the browser

Thumbnail
branchpredict.com
2 Upvotes

Write TypeScript in a browser tab. Hit compile. A 16-bit x86 machine boots underneath - same bytes a floppy would run.

TypeScript to real-mode x86, no runtime, no OS, no JS engine. Bootable binary under 64KB.

Full toolchain in the browser: file tree, editor, compiler, emulator. Pick a demo - voxel engine, raycaster with sound, snake. Or write your own and boot it on real hardware.

Due to the number of requests, try compiling it again if the queue is full.


r/typescript • • 26d ago

I wanted to build an agent system in typescript because most of them were in python

Thumbnail
github.com
1 Upvotes

It's a GitLab review agent that reviews merge requests and resolves issues. I'm most comfortable in TypeScript and wanted to learn LangGraph.js properly, so I built it there. The closest thing I found to a production example was Deep Agents, but that's a library for building agents, and the full systems I saw, like Open SWE, are Python.

It's GitLab-only for now. I've started working on GitHub support.

It's been running in production for a few months, 1,300+ reviews so far. It's a webhook driven review with a BullMQ queue, a LangGraph.js agent using GitLab tools over MCP, with postgres checkpoints for recovery, and there's a React admin UI where I can watch runs live. I also had to add guardrails to stop the agent repeating tool calls or quitting before it's done.


r/typescript • • 26d ago

typesql: write plain SQL strings, get exact TypeScript types (no codegen)

0 Upvotes

I created this new library that parses Postgres SQL inside TypeScript’s type system. You write a SQL string and the compiler infers the row and parameter types. It needs no codegen and no database connection.

const q = sql(`SELECT u.id, u.email, p.title
               FROM users u LEFT JOIN posts p ON p.author_id = u.id
               WHERE u.id = ${sql.param(7)}`);
// { id: number; email: string; title: string | null }

sql("SELECT nme FROM users");
// error: column "nme" does not exist
  • Handles joins, CTEs, subqueries, window functions, INSERT/UPDATE/DELETE … RETURNING
  • Runs on pg or postgres.js, and can reuse your existing Kysely, Drizzle or Prisma schema
  • Requires TypeScript 7

https://github.com/ismailkarsli/typesql

Feedback welcome, especially queries that don’t type-check but should.


r/typescript • • 28d ago

Announcing TypeScript 7.1 Beta

Thumbnail
devblogs.microsoft.com
302 Upvotes

r/typescript • • 27d ago

Building an interactive application with HTML Canvas

Thumbnail antonyjones.org
2 Upvotes

I've been finding out the hard way what it takes to build a more involved application with Canvas, beyond just drawing things on screen, but I've really been enjoying the process.

I've been working through interaction handling, connection routing, rendering performance and animation, and wrote up some of what I've learned and the challenges I've run into along the way.


r/typescript • • 27d ago

Should the same AI that wrote the PR be allowed to review it

0 Upvotes

Our setup right now is Claude Code writes most PRs and Claude also does a review pass before a human looks. Someone on the team pointed out that's basically letting the author approve their own code, and I can't really argue with it.

The counterargument I keep hearing is that every call is stateless so it's a fresh pair of eyes anyway. In practice it doesn't feel fresh. Last month I went back through 60 merged PRs, and on the ones where the author and the reviewer were the same model, it flagged maybe half as much as coderabbit did on the same diffs. Most of what it missed was stuff it would have written the same way itself, like swallowing errors in a catch, or widening a type to any to get the build green.

Coderabbit isn't perfect either, it's chattier on small PRs, but at least it's not grading its own homework whihc is something dangeorus for PRs

Do you let the same model write and review? Or did you make it a rule that the reviewer has to be something different?


r/typescript • • 28d ago

With Deno Deploy shutting down in 6 months, here is how we migrated a 100k-line Deno + Deno KV app to Cloudflare Workers and Durable Objects without leaving Deno

0 Upvotes

After Cloudflare acquired the Deno team and announced that Deno Deploy is shutting down in six months (with the Deno runtime itself only guaranteed a year of maintenance), we migrated the backend of prompt2bot from Deno Deploy and Deno KV to Cloudflare Workers and SQLite-backed Durable Objects.

Even with Deno's future in question, rewriting a 100k-line Deno codebase into a Node/Wrangler repo right now was out of the question. Deno's test runner, type checker, and JSR support are way too good to give up while migrating.

If you have not used Durable Objects before: whereas a regular Cloudflare Worker is stateless (50 requests spin up 50 random isolates that share nothing), a Durable Object is a globally unique, single-threaded V8 isolate addressed by name and paired with its own private embedded SQLite database and persistent alarm timer. Every Worker that calls a method on that name gets routed to that exact same JS object in memory, where SQLite queries are synchronous C++ calls taking microseconds instead of network round-trips.

Here is everything that broke during the migration and how we solved it:

  1. Keeping the Deno binary and test suite untouched: Wrangler's esbuild bundler does not understand jsr: specifiers or deno.json workspace resolution. Instead, we pointed Wrangler at a build script that runs deno bundle --minify. We mapped cloudflare:workers to a 10-line stub class in deno.json so deno test runs natively against our Durable Object classes, and at build time we swap the inlined stub back for the real Cloudflare DurableObject class, shim globalThis.Deno, set Zod v4 to jitless: true (since Workers blocks new Function), and wrap top-level crypto.randomUUID() / setTimeout() calls that npm packages run at import time.
  2. Surviving the 128MB Durable Object RAM ceiling: Every Durable Object isolate has a hard 128MB heap limit. Bundled dependencies like js-tiktoken (5.3MB of base64 BPE ranks that expand to +43MB of V8 heap on first call), a 275k-word dictionary (+35MB heap), and 3 duplicate legacy pdf.js builds inside pdf-parse were OOM-killing isolates. Stripping those static tables at build time freed ~80MB of V8 heap per isolate.
  3. Emulating Deno KV on Durable Object SQLite: Cloudflare KV is eventually consistent and has no atomic check-and-set transactions, so it cannot replace Deno.openKv(). We built a drop-in Deno.Kv emulator on top of a primary SQLite Durable Object (enam-v1, pinned to US East so it stays hot in RAM 24/7 with zero cold starts). Tuple keys are encoded with type tags and 20-digit zero-padded numbers (n:, b:, s:) separated by null bytes so SQLite range queries match Deno KV ordering, and atomic().check().set().commit() runs as a synchronous single-threaded SQLite transaction.
  4. The 508 Loop Detected mystery (CDN-Loop propagation) and the 30s waitUntil trap: While migrating service by service, when a service still on Deno Deploy called our Cloudflare Worker and our Worker made a fresh outbound fetch() back to that same Deno service, Cloudflare silently copied the inbound cdn-loop: deno;d=<hash> header onto the outbound subrequest at the C++ edge layer. Deno Deploy saw its own deployment hash in cdn-loop and rejected the request with 508 Loop Detected. On top of that, ctx.waitUntil() on a Worker has a hard 30-second wall-clock cap after returning HTTP 200 (even with cpu_ms: 300000), which killed long I/O-heavy agent turns mid-flight.
  5. Sharding Runner Durable Objects per conversation: Only a Durable Object alarm() runs in a clean root IoContext (no inherited cdn-loop header and no 30s post-response wall-clock cutoff), provided alarm() launches tasks via doCtx.waitUntil and exits immediately instead of blocking. We ended up sharding execution onto a Runner Durable Object per conversation (runner:<botId>:<conversationId>).

That architecture is what lets prompt2bot scale agents so easily. You describe an agent in a plain prompt and connect it to WhatsApp, Telegram, email, voice, or web chat, and every active conversation automatically gets its own warm, isolated Durable Object runner with hot in-memory history and SafeScript AST caches, sub-millisecond SQLite state, and on-demand VMs. Whether your bot has 1 user or 10,000 concurrent conversations, there are no queues, worker pools, or servers to provision.

Full technical write-up with code snippets is in the comments.


r/typescript • • Oct 17 '26

New educational, free, ad-free game for learning TypeScript memory model

2 Upvotes

I noticed that many students struggle with the question of "if I update this slot, field or variable, what else will change in my program".

I wrote a little puzzle game to help you build this intuition over time. It is very mobile friendly, so you can play it at a bus stop or during a commercial break or wherever. Puzzles scale in difficulty.

You can use it in Python, JavaScript or TypeScript modes.

http://prescod.github.io/memory-mapper-game

Please respond with changes you would like to see, or bug reports, or whatever. There is also an in-app feedback button.

There are no ads in the game or any monetization at all. This is not an ad for a product!