@@ -579,9 +579,14 @@ a registered `attr.properties` bag, for example `"@mongo": { "collection": "orde
 A sourceless entity gets no table, queries, routes or migration. It still gets its wire
 contract in every port: the create and PATCH schemas and the filter allowlist. Keep the
 `identity.primary`, because it is what makes the record addressable. Without it the object
-is a shape only. The data access layer is a generator the adopter owns. The recipe, with a
-MongoDB repository generator run end to end, is
-<https://github.com/metaobjectsdev/metaobjects/blob/main/docs/recipes/document-graph-and-wide-column-stores.md>.
+is a shape only. The data access layer is a generator you own: the procedure is in the
+`metaobjects-codegen` skill, `references/any-stack.md`, and on TypeScript
+`references/typescript-document-store.md` carries a complete, tested MongoDB repository
+generator to copy.
+
+**The database dialect is codegen config, not metadata.** MySQL, Postgres, SQLite and D1
+entities are all modeled with `source.rdb`; `dialect` in the codegen config picks the target.
+Do not encode the database in the model.
 
 ### Derived/computed columns: reach for an ENTITY READ-VIEW first
 
 
@@ -33,6 +33,7 @@ exact config, generator names and commands for this project; read it. The other
 
 | File | Open it when |
 |---|---|
+| `references/any-stack.md` | **the database, data store, HTTP framework or UI framework is not one a reference generator targets** — MySQL, MongoDB, DynamoDB, Express, NestJS, Next.js, Vue, … |
 | `references/owning-generators.md` | generated output is wrong; your framework is not the one a reference emits for; you write or review a generator (the `own*()` accessor table) |
 | `references/choosing-layers.md` | the generated API does not fit, you need joined or derived data, or you are adopting onto existing code |
 | `references/template-or-code.md` | choosing between a code generator and a Mustache template |
 
@@ -0,0 +1,118 @@
+# Your database, store or framework is not built in — work it out
+
+> Part of the `metaobjects-codegen` skill. Read it when the app's database, data store, HTTP
+> framework or UI framework is not one a reference generator targets. That is a normal
+> situation with a known procedure, not a dead end and not a reason to hand-write the app.
+
+MetaObjects is a **core** (the model, the loader, `verify`, prompt render and reply extract,
+and `meta migrate` for Postgres/SQLite/D1) plus **generators you own**. The reference
+generators cover some stacks. Every other stack is reached the same way: keep the model as the
+source of truth, generate what is built in, and write or retarget a generator for the rest.
+Nothing below needs a new MetaObjects release, a new metamodel attribute, or permission.
+
+## 1. Find out what is built in — do not guess
+
+```bash
+npx meta gen --list --format json --probe   # every generator: layer, framework, what it emits for YOUR model
+npx meta types --type source --kind subtype # the registered sources: only source.rdb
+```
+
+The dialects are `postgres`, `sqlite`, `d1` (TypeScript only) and `mysql` (codegen and runtime
+only). The HTTP reference generators are `routes` (Fastify) and `routes-hono` (Hono). The UI
+reference generators target React and TanStack. Anything else is this page.
+
+## 2. Split the app into layers and decide each one
+
+| Layer | Always available | When your target is not built in |
+|---|---|---|
+| **model** — types, create/PATCH validation, filter and sort allowlists | yes, in every port, for every store | — |
+| **persistence** — how rows are read and written | Postgres, SQLite, D1; MySQL (TypeScript, Java) | §3 |
+| **api** — the HTTP surface | Fastify, Hono | §4 |
+| **client** — hooks, forms, grids | React, TanStack | §5 |
+
+The model layer never depends on the store or the framework. Generate it first
+(`meta eject entity`, wire `entityFile()`); everything you write later imports it.
+
+## 3. Persistence
+
+**MySQL (TypeScript).** Set `dialect: "mysql"`. The generated tables, queries and routes
+target `drizzle-orm/mysql-core`, and the ObjectManager runs over `kyselyDriver` or
+`drizzleDriver`. `meta migrate` does not own a MySQL schema, so you write the DDL. Setup,
+the column-type table and the behaviour differences are in `typescript-mysql.md`. On Java,
+OMDB's `MySQLDriver` reads and writes MySQL; the generated DTOs and controllers are
+dialect-neutral.
+
+**A SQL database that speaks another dialect's protocol.** Use that dialect: CockroachDB,
+Neon, Supabase, AlloyDB and Aurora PostgreSQL are `postgres`; Turso and libSQL are `sqlite`
+(or `d1` on Cloudflare); MariaDB and PlanetScale are `mysql`. Test the generated queries
+against the real server before relying on them.
+
+**Any other store** — MongoDB, Cassandra, DynamoDB, Firestore, Neo4j, Redis, Elasticsearch,
+a SQL database no dialect covers, or a remote API. Model each stored record as a
+**sourceless entity** and generate its data access with a generator you own:
+
+1. An `object.entity` with an `identity.primary` and **no `source.*` child**. With no source,
+   nothing generates a table, queries or routes for it, and `meta migrate` ignores it. It still
+   gets its whole wire contract in every port: the type, the create and PATCH schemas, and the
+   filter allowlist.
+2. Store-specific settings go in a property bag of your own: any `@name` whose value is a JSON
+   object is accepted, for example `"@mongo": { "collection": "orders" }` or
+   `"@dynamo": { "table": "orders", "partitionKey": "customerId" }`. Your generator reads it.
+   **Do not invent a document or graph source subtype, or a `@collection` attribute** — the loader
+   refuses unregistered vocabulary (`ERR_UNKNOWN_ATTR`), and a bag needs no registration.
+3. Embedded documents are value objects: `field.object` + `@objectRef` to an `object.value`,
+   `isArray: true` for a list. They validate as part of the parent.
+4. Write a repository generator: select objects with the port's sourceless predicate, and emit
+   create / findById / list / patch / delete over the store's driver, validating with the
+   generated schemas and checking filters against the generated allowlist. A complete,
+   tested MongoDB generator for TypeScript is in `typescript-document-store.md`; for
+   Cassandra, DynamoDB or an HTTP API only the driver calls change.
+
+| Port | Sourceless predicate | Build the repository on |
+|---|---|---|
+| TypeScript | `isSourcelessEntity` (`@metaobjectsdev/codegen-ts`) | `<E>InsertSchema`, `<E>UpdateSchema`, `<E>FilterAllowlist` |
+| Python | `is_sourceless_entity` | `<E>Create`, `<E>Patch`, `<e>_filter_allowlist` |
+| Java / Kotlin | `RestSurfaceGate.isSourcelessEntity` | `<E>Dto`, `<E>Patch`, `<E>FilterAllowlist` |
+| C# | `InstanceArtifacts.IsSourcelessEntity` | the entity POCO, `<E>FilterAllowlist` |
+
+What a non-relational store does not get: schema management (create collections and indexes
+the store's own way — or write a generator for its optional schema, such as a MongoDB
+`$jsonSchema`), generated routes and client hooks (your repository is the seam; see §4), and
+join traversal (`identity.reference` loads and documents, but nothing follows it across stores).
+
+## 4. An HTTP framework that is not built in
+
+Try these in order:
+
+1. **Config first.** Several apparent framework mismatches are one setting: `apiPrefix`,
+   `extStyle` (`"none"` for Turbopack and other bundlers that do not rewrite `.js`
+   specifiers), `clientDirective` (React Server Components), `outDir`, per-target output.
+2. **Hono reaches most hosts.** `routes-hono` emits Hono handlers that take the database as an
+   injected dependency, and Hono runs on Node, Bun, Deno, Cloudflare Workers and inside a
+   Next.js route handler (`hono/vercel`). Mount the generated Hono app inside your framework
+   rather than rewriting routes.
+3. **Eject the nearest reference and retarget it.** `meta eject routes` (or `routes-hono`)
+   copies the generator and its HTTP adapter into your repo; change the emit to your
+   framework's handler shape (Express, Koa, NestJS, Elysia, tRPC, …). The handlers call
+   the generated queries, which carry no framework coupling. The TypeScript procedure is in
+   `typescript-retargeting.md`.
+4. **Or write a routes generator** from scratch over the generated queries or your
+   repository — the same ~20-line generator shape as any other (the top of this skill).
+
+Never hand-write per-entity routes the model describes: a generator gives every entity the
+same surface, and `meta verify --codegen` keeps it in step with the model.
+
+## 5. A UI framework that is not built in
+
+`@metaobjectsdev/runtime-web` is framework-free: the fetch contract, filter query strings,
+currency and grid config. Write a generator that emits your framework's hooks or components
+(Vue composables, Svelte stores, Solid resources, Angular services) over it and over the
+generated types. Angular has source-only reference packages in the MetaObjects repository.
+
+## 6. Prove it works
+
+- `meta verify --codegen` fails when committed output is stale — it re-runs your generator.
+- Typecheck the generator (`npx tsc -p tsconfig.codegen.json`); `meta gen` loads it untyped.
+- Write a test that **executes the generated code against the real store or framework** —
+  create, read back, patch, a refused filter, a validation failure. A generator that emits
+  plausible text is not proven until its output runs.
@@ -58,6 +58,8 @@ that generator and retarget it instead; see "Your framework isn't the default" b
 
 ## Your framework isn't the default — the retargeting procedure
 
+(Database or store not built in either? `any-stack.md` covers persistence, API and client together.)
+
 If the shipped templates do not emit for your stack, retargeting is the **normal first
 move** — not a workaround and not a sign of a bug. Owning a generator is the supported
 path to any framework; MetaObjects does not ship a codegen package per framework and is
 
@@ -0,0 +1,154 @@
+# A document store on TypeScript — the MongoDB repository generator
+
+> Part of the `metaobjects-codegen` skill's TypeScript reference. Read it when records live
+> in MongoDB — or in any store MetaObjects does not manage (Cassandra, DynamoDB, Firestore,
+> an HTTP API): the shape is the same and only the driver calls change. The modeling rules
+> are in `any-stack.md` §3.
+
+This generator emits `<Entity>.repository.ts` for every **sourceless entity** (an
+`object.entity` with an `identity.primary` and no `source.*`). It was run end to end against
+MongoDB 7 with the `mongodb` 7.x Node driver: create, list by an enum value and by `in`, patch,
+and delete work; a filter on an undeclared field is refused; a create with a value outside the
+enum fails Zod validation.
+
+## Use it
+
+1. Save the file below as `codegen/generators/mongo-repository.ts` — it is yours to edit.
+2. `npx meta eject entity`, then wire both generators:
+
+   ```ts
+   import { entityFile } from "./codegen/generators/entity.js";
+   import { mongoRepositoryGenerator } from "./codegen/generators/mongo-repository.js";
+
+   export default defineConfig({
+     outDir: "src/generated",
+     generators: [entityFile(), mongoRepositoryGenerator()],
+   });
+   ```
+
+3. `npm install mongodb`, then `npx meta gen`. Use the repository from your routes:
+   `const orders = orderRepository(client.db("shop")); await orders.create(body);`
+
+What the repository does, built on the generated contract:
+
+- `create` validates with `<E>InsertSchema` and mints the id when the identity has
+  `@generation: uuid`. The identity is stored as the document's `_id`.
+- `patch` validates with `<E>UpdateSchema`: an absent key is left unchanged, and an explicit
+  `null` unsets the field.
+- `list` accepts `{ field: value }` or `{ field: { op: value } }` and refuses any field or
+  operator `<E>FilterAllowlist` does not allow.
+- The collection name comes from the entity's `"@mongo": { "collection": "…" }` bag, and
+  defaults to the camel-cased plural of the entity name.
+
+## The generator
+
+```ts
+// A MongoDB repository per SOURCELESS entity: an object.entity with an identity.primary and
+// no source.* — a record MetaObjects models but does not store. The entity generator emits
+// its wire contract (<E>InsertSchema, <E>UpdateSchema, <E>FilterAllowlist); this emits the
+// data access over it. The collection name comes from an author-supplied `@mongo` property
+// bag on the entity: `"@mongo": { "collection": "orders" }`.
+import { isSourcelessEntity, perEntity, type Generator } from "@metaobjectsdev/codegen-ts";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+
+function collectionOf(obj: MetaObject): string {
+  const bag = obj.attr("mongo");
+  if (bag !== null && typeof bag === "object" && "collection" in bag && typeof bag.collection === "string") {
+    return bag.collection;
+  }
+  return `${obj.name.charAt(0).toLowerCase()}${obj.name.slice(1)}s`;
+}
+
+function render(obj: MetaObject): string {
+  const E = obj.name;
+  const e = `${E.charAt(0).toLowerCase()}${E.slice(1)}`;
+  const pk = obj.primaryIdentity()?.fields[0] ?? "id";
+  const generated = obj.primaryIdentity()?.attr("generation") === "uuid";
+  const newId = generated ? `crypto.randomUUID()` : `(input as { ${pk}: string }).${pk}`;
+  return `// GENERATED by codegen/generators/mongo-repository.ts — edit the generator, not this file.
+import type { Collection, Db, Filter } from "mongodb";
+import {
+  ${E}InsertSchema, ${E}UpdateSchema, ${E}FilterAllowlist,
+  type ${E}, type ${E}Create, type ${E}Patch,
+} from "./${E}.js";
+
+type ${E}Doc = Omit<${E}, "${pk}"> & { _id: string };
+
+const OPS = { eq: "$eq", ne: "$ne", gt: "$gt", gte: "$gte", lt: "$lt", lte: "$lte", in: "$in" } as const;
+
+function toEntity({ _id, ...rest }: ${E}Doc): ${E} {
+  return { ${pk}: _id, ...rest } as ${E};
+}
+
+/** A query \`{ field: value }\` or \`{ field: { op: value } }\`, checked against ${E}FilterAllowlist. */
+export type ${E}Query = Record<string, unknown>;
+
+function toMongoFilter(query: ${E}Query): Filter<${E}Doc> {
+  const out: Record<string, unknown> = {};
+  for (const [field, raw] of Object.entries(query)) {
+    const rule = (${E}FilterAllowlist as Record<string, { ops: readonly string[] }>)[field];
+    if (rule === undefined) throw new Error(\`${E}: "\${field}" is not filterable\`);
+    const clauses = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : { eq: raw };
+    const mongo: Record<string, unknown> = {};
+    for (const [op, value] of Object.entries(clauses)) {
+      if (!rule.ops.includes(op) || !(op in OPS)) throw new Error(\`${E}: "\${op}" is not allowed on "\${field}"\`);
+      mongo[OPS[op as keyof typeof OPS]] = value;
+    }
+    out[field === "${pk}" ? "_id" : field] = mongo;
+  }
+  return out as Filter<${E}Doc>;
+}
+
+export function ${e}Repository(db: Db) {
+  const docs: Collection<${E}Doc> = db.collection<${E}Doc>(${JSON.stringify(collectionOf(obj))});
+  return {
+    async create(input: ${E}Create): Promise<${E}> {
+      const row = ${E}InsertSchema.parse(input);
+      const _id = ${newId};
+      await docs.insertOne({ ...row, _id } as ${E}Doc);
+      return toEntity({ ...row, _id } as ${E}Doc);
+    },
+
+    async findById(id: string): Promise<${E} | null> {
+      const doc = await docs.findOne({ _id: id } as Filter<${E}Doc>);
+      return doc === null ? null : toEntity(doc);
+    },
+
+    async list(query: ${E}Query = {}): Promise<${E}[]> {
+      return (await docs.find(toMongoFilter(query)).toArray()).map(toEntity);
+    },
+
+    /** PATCH: an absent key is untouched, an explicit null clears the field. */
+    async patch(id: string, patch: ${E}Patch): Promise<${E} | null> {
+      const changes = ${E}UpdateSchema.parse(patch) as Record<string, unknown>;
+      const $set: Record<string, unknown> = {};
+      const $unset: Record<string, ""> = {};
+      for (const [k, v] of Object.entries(changes)) {
+        if (v === undefined) continue;
+        if (v === null) $unset[k] = "";
+        else $set[k] = v;
+      }
+      const doc = await docs.findOneAndUpdate(
+        { _id: id } as Filter<${E}Doc>,
+        { $set, $unset },
+        { returnDocument: "after" },
+      );
+      return doc === null ? null : toEntity(doc);
+    },
+
+    async delete(id: string): Promise<boolean> {
+      return (await docs.deleteOne({ _id: id } as Filter<${E}Doc>)).deletedCount === 1;
+    },
+  };
+}
+`;
+}
+
+export function mongoRepositoryGenerator(): Generator {
+  return {
+    name: "mongo-repository",
+    filter: isSourcelessEntity,
+    generate: perEntity((obj) => ({ path: `${obj.name}.repository.ts`, content: render(obj) })),
+  };
+}
+```