@prisma/orm-mongo 8.0.0-rc.14-dev.4 → 8.0.0-rc.14-dev.6

package/README.md

@@ -2,9 +2,8 @@
 
 The one package a MongoDB application installs. It wires the framework, the Mongo family, and the Mongo target into a single lazy client, and brings the rest of the stack along as exact-pinned dependencies:
 
-```jsonc
-// package.json
-{ "dependencies": { "@prisma/orm-mongo": "0.16.0", "mongodb": "^7.0.0" } }
+```sh
+pnpm add @prisma/orm-mongo mongodb
 ```
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/orm-mongo",
-  "version": "8.0.0-rc.14-dev.4",
+  "version": "8.0.0-rc.14-dev.6",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -10,18 +10,18 @@
     "skills"
   ],
   "dependencies": {
-    "@prisma/orm-family-mongo": "8.0.0-rc.14-dev.4",
-    "@prisma/orm-framework": "8.0.0-rc.14-dev.4",
-    "@prisma/orm-target-mongo": "8.0.0-rc.14-dev.4",
-    "@prisma/orm-toolchain": "8.0.0-rc.14-dev.4",
+    "@prisma/orm-family-mongo": "8.0.0-rc.14-dev.6",
+    "@prisma/orm-framework": "8.0.0-rc.14-dev.6",
+    "@prisma/orm-target-mongo": "8.0.0-rc.14-dev.6",
+    "@prisma/orm-toolchain": "8.0.0-rc.14-dev.6",
     "mongodb-connection-string-url": "^7.0.1",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.17"
   },
   "devDependencies": {
-    "@internal/mongo": "8.0.0-rc.14-dev.4",
-    "@repo/tsconfig": "8.0.0-rc.14-dev.4",
-    "@repo/tsdown": "8.0.0-rc.14-dev.4",
+    "@internal/mongo": "8.0.0-rc.14-dev.6",
+    "@repo/tsconfig": "8.0.0-rc.14-dev.6",
+    "@repo/tsdown": "8.0.0-rc.14-dev.6",
     "tsdown": "0.22.14",
     "typescript": "5.9.3"
   },

package/skills/prisma-8/SKILL.md

@@ -15,7 +15,7 @@ description: >-
   ORM 7 or earlier (schema.prisma + @prisma/client).
 metadata:
   library: '@prisma/orm-mongo'
-  library_version: '8.0.0-rc.14-dev.4'
+  library_version: '8.0.0-rc.14-dev.6'
   version: '2026-09-12'
 ---
 

package/skills/prisma-8/references/upgrade-app.md

@@ -68,7 +68,8 @@ For each `(from, to)` step in the chain:
 3. **Read the upgrade instructions.** Re-sync the skills (`prisma skills sync`) so the tree matches the version just installed, then load `../upgrading/app/upgrades/<from>-to-<to>/instructions.md`. Parse the YAML frontmatter and pay particular attention to its `changes[]` array.
 
 4. **Apply each change.** For each entry in `changes[]`:
-   - If the entry has a `detection` block (glob + content predicate), run it; skip the change if no files match. No `detection` → apply unconditionally.
+   - If the entry has a `detection` block (glob + content predicate), run it; skip the change if no files match. No `detection` → apply unconditionally. Run the glob over the project's own files: skip `node_modules`, and build output such as `dist`, `build`, `.next` or `out` (whatever directories the project's build writes). A match there is generated code, which the next build rewrites; editing it changes nothing. Migration snapshots under `migrations/snapshots/` are committed files, not build output, so keep them.
+   - How a `detection` block runs: `glob` selects files relative to the project root. Each `matches` entry, once read from the YAML, is a JavaScript regular expression, built as `new RegExp(pattern)` with no flags and tested against the whole content of one file at a time; each `contains` entry is a plain substring. A file is a hit when any entry matches it. Patterns may span lines, and some look at the whole file (for example, to skip a file that declares something elsewhere in it), so a line-by-line search such as `grep` or `rg` without `-U` is not the same test and can report files the pattern excludes. From a shell, `rg -U --pcre2 -l -e '<pattern>' <files>` tests whole files and gives the same hits.
    - If the entry names a `script:` (a relative path next to `instructions.md`), invoke it from the project root:
      - `*.ts` → `pnpm exec tsx <skill>/upgrading/app/upgrades/<from>-to-<to>/<script>`
      - `*.sh` → `bash <skill>/upgrading/app/upgrades/<from>-to-<to>/<script>`

package/skills/prisma-8/references/upgrade-extension.md

@@ -64,7 +64,8 @@ For each `(from, to)` step in the chain:
 4. **Read the upgrade instructions.** Re-sync the skills (`prisma skills sync`) so the tree matches the version just installed, then load `../upgrading/extension/upgrades/<from>-to-<to>/instructions.md`. Parse the YAML frontmatter and pay particular attention to its `changes[]` array.
 
 5. **Apply each change.** For each entry in `changes[]`:
-   - If the entry has a `detection` block (a glob + content predicate), run it. If no files match, skip this change.
+   - If the entry has a `detection` block (a glob + content predicate), run it. If no files match, skip this change. Run the glob over the project's own files: skip `node_modules`, and build output such as `dist`, `build`, `.next` or `out` (whatever directories the project's build writes). A match there is generated code, which the next build rewrites; editing it changes nothing. Migration snapshots under `migrations/snapshots/` are committed files, not build output, so keep them.
+   - How a `detection` block runs: `glob` selects files relative to the project root. Each `matches` entry, once read from the YAML, is a JavaScript regular expression, built as `new RegExp(pattern)` with no flags and tested against the whole content of one file at a time; each `contains` entry is a plain substring. A file is a hit when any entry matches it. Patterns may span lines, and some look at the whole file (for example, to skip a file that declares something elsewhere in it), so a line-by-line search such as `grep` or `rg` without `-U` is not the same test and can report files the pattern excludes. From a shell, `rg -U --pcre2 -l -e '<pattern>' <files>` tests whole files and gives the same hits.
    - If the entry has no `detection`, apply unconditionally.
    - If the entry names a `script:` (a relative path next to `instructions.md`), invoke it from the project root:
      - `*.ts` → `pnpm exec tsx <skill>/upgrading/extension/upgrades/<from>-to-<to>/<script>`

package/skills/prisma-8/upgrading/app/upgrades/8.0.0-rc.12-to-8.0.0-rc.13/instructions.md

@@ -39,8 +39,9 @@ changes:
       The Mongo codec subpaths moved from the adapter to the target:
       `adapter/codec-types`, `adapter/codecs`, `adapter/codec-ids` and `adapter/data-types` under
       `@prisma/orm-mongo` and `@prisma/orm-target-mongo` are now `target/...`. Emitted
-      `contract.d.ts` files, including migration snapshots, import `adapter/codec-types` and no
-      longer compile until rewritten or re-emitted.
+      `contract.d.ts` files, including migration snapshots, import `adapter/codec-types` until
+      rewritten or re-emitted. Under `skipLibCheck: true` that import fails silently and the
+      contract's field types turn wrong where they are used, instead of failing to compile.
     detection:
       glob: "**/*.{ts,mts,cts,md}"
       matches:
@@ -78,23 +79,18 @@ changes:
       Four Mongo PSL scalar names are deprecated in favour of the name of the BSON type they store:
       `Int` → `Int32`, `Float` → `Double`, `Boolean` → `Bool`, `DateTime` → `Date`. The old names
       are still accepted, with a `PSL_DEPRECATED_SCALAR_NAME` warning, and will be removed in a later
-      release; rename them now. Codec ids, `contract.json` and every hash are unchanged.
+      release; rename them now. Codec ids, `contract.json` and every hash are unchanged. Rename only
+      in the Prisma 8 contract source and its `migrations/app/*/contract.prisma` copies, never in a
+      Prisma 6 `schema.prisma`.
     detection:
       glob: "**/*.prisma"
       matches:
-        - '(?:^|\n)[ \t]*[A-Za-z_][A-Za-z0-9_]*[ \t]+(?:Int|Float|Boolean|DateTime)(?:\[\])?\??(?![ \t]*\{)(?=\s|$)'
-  - id: mongo-json-field-semantics
-    summary: |
-      A Mongo `Json` field now admits only JSON values. Its collection validator lists the
-      JSON-representable BSON types, which changes the validator and `storageHash` of every Mongo
-      contract with a `Json` field, and a document whose `Json` field holds a `Date`, `ObjectId`,
-      `Decimal128`, `Binary`, or another non-JSON BSON value at any depth fails to decode.
+        - '(?<![\s\S])(?![\s\S]*\bprovider\s*=\s*"mongodb")[\s\S]*?(?:^|\n)[ \t]*[A-Za-z_][A-Za-z0-9_]*[ \t]+(?:Int|Float|Boolean|DateTime)(?:\[\])?\??(?![ \t]*\{)(?=\s|$)'
   - id: mongo-variant-field-codecs
     summary: |
       Through `.variant(...)`, a field declared only on the variant model is now written and read
       through its codec, as base-model fields always were. An `ObjectId` field there is stored as
-      an `ObjectId` and read back as a hex string; an `Int64`, `Decimal128` or `Binary` field reads
-      back as its application type; `Json` and `Bson` fields refuse values outside their type.
+      an `ObjectId` and read back as a hex string, and a where filter on it encodes a hex string.
   - id: contract-artifacts-restamp
     summary: |
       The emitted `contract.json` / `contract.d.ts` embed the toolchain version, which moves
@@ -236,6 +232,8 @@ The Mongo target package owns the codecs now. Rewrite each specifier, in every f
 
 The exported names are unchanged. For the application's own `contract.d.ts`, running `prisma contract emit` produces the same result as the rewrite. Snapshot `contract.d.ts` files under `migrations/snapshots/` are not re-emitted, so rewrite them. The contract JSON and every hash stay the same.
 
+Do not rely on `tsc` to find the `contract.d.ts` files. They are declaration files, and a project with `skipLibCheck: true` (the `tsconfig.json` that `prisma orm init` writes sets it) gets no error for their stale import. Instead the contract's field types stop resolving to the codec types, so type errors appear where the contract is used, such as a seed script or a query, rather than at the import, and some fields are no longer type-checked. Rewrite or re-emit every file the detection finds, whether or not `tsc` complains.
+
 ## `create-mongo-runner-deps-removed`
 
 ```ts
@@ -280,7 +278,9 @@ Code that goes through the CLI or `defineConfig` already has the adapter on the
 
 `Int`, `Float`, `Boolean` and `DateTime` are deprecated in Mongo schemas. They are still accepted, and they produce the same contract as the new names, but `prisma contract emit` and the language server report a `PSL_DEPRECATED_SCALAR_NAME` warning for each use, and a later release removes them. Rename them now.
 
-Apply this only in a schema whose `prisma.config.ts` uses `@prisma/orm-mongo`. The detection pattern also matches Postgres and SQLite schemas, whose scalar names do not change in this release.
+Apply this only to the Prisma 8 Mongo contract source, the `.prisma` file that `prisma.config.ts` passes to `defineConfig` from `@prisma/orm-mongo/config`, and to its copies under `migrations/app/<migration>/contract.prisma`. The detection pattern also matches Postgres and SQLite schemas, whose scalar names do not change in this release; leave them alone.
+
+Never rename in a Prisma 6 `schema.prisma`, such as one kept beside the Prisma 8 contract in a project that still runs Prisma 6: Prisma 6 has no `Int32`, `Double`, `Bool` or `Date`, and would reject the schema. The detection skips a file that declares `provider = "mongodb"`, which every Prisma 6 MongoDB schema does, but a multi-file Prisma 6 schema declares it in one file only, so also skip the other `.prisma` files of a Prisma 6 schema directory.
 
 In each field whose type is one of the deprecated names, replace the type name, keeping any `[]` and `?`:
 
@@ -317,40 +317,14 @@ This includes the `contract.prisma` copies under `migrations/app/<migration>/`.
 
 Docs: list only `Int32`, `Double`, `Bool`, `Date`; the old names must not appear in the scalar tables.
 
-## `mongo-json-field-semantics`
-
-This change has no detection pattern: which `Json` fields hold non-JSON values depends on the data, which a search of the source cannot see.
-
-A Mongo `Json` field (`field.json()` in TypeScript) means a JSON value, no more. Its validator admits BSON `object`, `array`, `string`, `double`, `int`, `long`, `bool` and `null`. Reading a document fails with `RUNTIME.DECODE_FAILED` when the field holds a `Date`, `ObjectId`, `Decimal128`, `Binary`, regular expression, timestamp, or a 64-bit integer outside the safe-integer range, at any depth; the message names the path inside the field. Writing such a value fails with `RUNTIME.ENCODE_FAILED`.
-
-To find the affected fields, query each collection with a `Json` field for documents whose field holds a non-JSON value at its top level or as a direct element of an array: a BSON type outside the JSON types, a `long` outside the safe-integer range, or a `NaN` or infinite `double`:
-
-```js
-db.<collection>.find({
-  $or: [
-    { <field>: { $exists: true, $not: { $type: ['object', 'array', 'string', 'double', 'int', 'long', 'bool', 'null'] } } },
-    { <field>: { $elemMatch: { $not: { $type: ['object', 'array', 'string', 'double', 'int', 'long', 'bool', 'null'] } } } },
-    { <field>: { $type: 'long', $gt: 9007199254740991 } },
-    { <field>: { $type: 'long', $lt: -9007199254740991 } },
-    { <field>: { $in: [NaN, Infinity, -Infinity] } },
-  ],
-})
-```
-
-The first clause checks the field's own value, and the second checks each direct element when the value is an array. The last three clauses match at both levels. A non-JSON value nested deeper, inside an object or an array of objects, is not visible to this query; reading every document through the ORM finds it, because the read fails with the path of the first such value.
-
-1. For each Mongo `Json` field whose documents hold such values, change its type to `Bson` in PSL (`field.bson()` in TypeScript), which admits any BSON value. A project whose contract source is a Prisma 6 schema (`prisma6Schema`) cannot declare `Bson`: keep its `Json` fields JSON-only, or move the contract source to a Prisma 8 schema and change the type there.
-2. Run `prisma contract emit`. Every Mongo contract written in Prisma 8 PSL with a `Json` field changes: its validator lists the JSON types and its `storageHash` moves, whether or not step 1 changed anything. A contract built with the TypeScript builder or read from a Prisma 6 schema has no validator, so it does not change; the codec's checks on read and write still apply to it.
-3. If the contract changed in step 2, run `prisma db update` so each collection's validator matches the contract. It reports the validator change as destructive and asks for confirmation: type the database name, or pass `--confirm <database>` when nobody is there to ask. A project that deploys with migrations runs `prisma migration plan` instead and applies the new migration the way it applies any other.
-
 ## `mongo-variant-field-codecs`
 
-This change has no detection pattern: it applies to every model with `@@base` whose own fields are written or read through `.variant(...)`, and the effect depends on the field types.
+This change has no detection pattern: it applies to every model with `@@base` whose own `ObjectId` fields are written or read through `.variant(...)`.
 
-Before, a field declared only on a variant model (`model Photo { ownerId ObjectId  @@base(Asset, "photo") }`) was passed to the driver as the application wrote it and returned as the driver read it. An `ObjectId` field written as a hex string was refused by the collection validator when the contract was written in Prisma 8 PSL; a contract built with the TypeScript builder or read from a Prisma 6 schema has no validator, so there the hex string was stored as a string. A where filter on such a field passed its value unencoded, so a hex string matched nothing where an `ObjectId` was stored; it is now encoded and matches. A stored `ObjectId`, `Long`, `Decimal128` or `Binary` came back as the driver's class instead of the application type.
+Before, a field declared only on a variant model (`model Photo { ownerId ObjectId  @@base(Asset, "photo") }`) was passed to the driver as the application wrote it and returned as the driver read it. An `ObjectId` field written as a hex string was refused by the collection validator when the contract was written in Prisma 8 PSL; a contract built with the TypeScript builder has no validator, so there the hex string was stored as a string. A stored `ObjectId` came back as the driver's `ObjectId` class instead of a hex string. A where filter on such a field passed its value unencoded, so a hex string matched nothing where an `ObjectId` was stored; it is now encoded and matches.
 
-1. Remove any workaround that converted such values by hand, for example passing `new ObjectId(hex)` for a variant `ObjectId` field or calling `.toHexString()` on what a read returned; pass and expect the application types listed in the scalar types reference instead.
-2. Documents written before this change by a TypeScript-builder or Prisma 6 contract may hold a variant `ObjectId` field as a string; a filter with a hex string now looks for an `ObjectId` and does not match them. Convert the ones that are 24-character hex strings with `db.<collection>.updateMany({ <field>: { $type: 'string', $regex: /^[0-9a-fA-F]{24}$/ } }, [{ $set: { <field>: { $toObjectId: '$<field>' } } }])`. The regex matters: without it, one string that is not an `ObjectId` in hex makes `$toObjectId` fail the whole command. Other strings, `ObjectId` values and documents without the field are left as they are.
+1. Remove any workaround that converted such values by hand, for example passing `new ObjectId(hex)` for a variant `ObjectId` field or calling `.toHexString()` on what a read returned; pass and expect hex strings, as for any other `ObjectId` field.
+2. Documents written before this change through a TypeScript-builder contract may hold a variant `ObjectId` field as a string; a filter with a hex string now looks for an `ObjectId` and does not match them. Convert the ones that are 24-character hex strings with `db.<collection>.updateMany({ <field>: { $type: 'string', $regex: /^[0-9a-fA-F]{24}$/ } }, [{ $set: { <field>: { $toObjectId: '$<field>' } } }])`. The regex matters: without it, one string that is not an `ObjectId` in hex makes `$toObjectId` fail the whole command. Other strings, `ObjectId` values and documents without the field are left as they are.
 3. A read through the base collection (without `.variant(...)`) still returns variant-only fields as the driver read them.
 
 ## `contract-artifacts-restamp`

package/skills/prisma-8/upgrading/extension/upgrades/8.0.0-rc.12-to-8.0.0-rc.13/instructions.md

@@ -67,9 +67,9 @@ changes:
   - id: prisma7-schema-source-declares-psl
     summary: The prisma7Schema() contract source declares format 'psl' instead of 'prisma7'.
   - id: print-psl-description-option
-    summary: printPsl() from @internal/psl-printer opens every file with only the // use prisma-8 marker unless the caller passes description.
+    summary: printPsl() from @internal/psl-printer (@prisma/orm-framework/psl-printer) opens every file with only the // use prisma-8 marker unless the caller passes description.
   - id: family-sql-psl-build-export
-    summary: mapDefault, its option types, the PslTypeMap types and toEnumMemberName moved from @internal/family-sql/psl-infer to @internal/family-sql/psl-build.
+    summary: mapDefault, its option types, the PslTypeMap types and toEnumMemberName moved from @internal/family-sql/psl-infer to @internal/family-sql/psl-build (published as family/psl-infer and family/psl-build of @prisma/orm-family-sql).
   - id: cursor-rejects-expression-orders
     summary: "cursor() now throws ORM.ARGUMENT_INVALID when an active orderBy item is not a plain column (extension-operation orders such as vector distance were previously dropped from the keyset silently)"
     detection:
@@ -77,7 +77,7 @@ changes:
       matches:
         - '\.cursor\('
   - id: order-by-item-nulls
-    summary: "OrderByItem from @internal/sql-relational-core/ast carries a nulls placement: its constructor takes a required third argument, withExpr rebuilds an item around a new expression, and every renderer must emit nulls wherever it emits dir"
+    summary: "OrderByItem from @internal/sql-relational-core/ast (@prisma/orm-family-sql/relational-core/ast) carries a nulls placement: its constructor takes a required third argument, withExpr rebuilds an item around a new expression, and every renderer must emit nulls wherever it emits dir"
     detection:
       glob: "**/*.{ts,mts,cts}"
       matches:
@@ -105,7 +105,8 @@ changes:
         - '@prisma/orm-(?:target-)?mongo/adapter/(?:codec-types|codecs|codec-ids|data-types)(?![\w-])'
   - id: create-mongo-runner-deps-removed
     summary: |
-      `createMongoRunnerDeps(...)` is removed from `@internal/adapter-mongo/control`. Build the
+      `createMongoRunnerDeps(...)` is removed from `@internal/adapter-mongo/control`
+      (`@prisma/orm-mongo/adapter/control`). Build the
       runner dependencies with `new MongoControlAdapterImpl().createRunnerDependencies(controlDriver)`.
     detection:
       glob: "**/*.{ts,mts,cts}"
@@ -114,8 +115,9 @@ changes:
   - id: mongo-runner-dependency-types-move-to-family
     summary: |
       `MongoRunnerDependencies` and `MarkerOperations` are exported from
-      `@internal/family-mongo/control-adapter`, no longer from `@internal/adapter-mongo/control` or
-      `@internal/target-mongo/control`.
+      `@internal/family-mongo/control-adapter` (`@prisma/orm-mongo/family/control-adapter`), no
+      longer from `@internal/adapter-mongo/control` or `@internal/target-mongo/control` (the
+      `adapter/control` and `target/control` subpaths of `@prisma/orm-mongo`).
     detection:
       glob: "**/*.{ts,mts,cts}"
       matches:
@@ -159,12 +161,16 @@ changes:
       defaulting to `undefined`, so a bare `FieldBuilder` constraint rejects preset fields such as
       `field.temporal.createdAt()`; widen it to
       `FieldBuilder<ContractFieldType, boolean, boolean, EnumTypeHandle | undefined, ExecutionMutationDefaultPhases | undefined>`.
+      `ContractFieldType` and `ExecutionMutationDefaultPhases` come from
+      `@prisma/orm-mongo/contract/types`; `FieldBuilder` and `EnumTypeHandle` from
+      `@prisma/orm-mongo/contract-builder`.
   - id: mongo-bson-codec-added
     summary: |
-      The Mongo target gains the codec `mongo/bson@1` for any BSON value, typed `BsonInputValue`
-      on write and `BsonValue` on read in `CodecTypes`; `mongo/json@1` now admits only JSON values.
-      Collection validators now read a codec's whole `targetTypes` list, not only its first entry,
-      and an enum's codec must declare exactly one.
+      The Mongo target gains the codecs `mongo/int64@1`, `mongo/decimal128@1`, `mongo/binary@1`,
+      `mongo/json@1` (JSON values only) and `mongo/bson@1` (any BSON value, typed `BsonInputValue`
+      on write and `BsonValue` on read in `CodecTypes`). Collection validators now read a codec's
+      whole `targetTypes` list, not only its first entry, and an enum's codec must declare exactly
+      one.
     detection:
       glob: "**/*.{ts,mts,cts}"
       matches:
@@ -201,7 +207,7 @@ A contract with generated defaults (`temporal.createdAt()`, `temporal.updatedAt(
 
 ### For extension authors
 
-- The framework type `ExecutionMutationDefault['ref']` from `@internal/contract/types` is `{ namespace: string; entry: string; field: string }`. A type that matches refs by shape (for example a create-input type that checks whether a column has a generated default) matches `entry` and `field`.
+- The framework type `ExecutionMutationDefault['ref']` from `@internal/contract/types` (`@prisma/orm-framework/contract/types`) is `{ namespace: string; entry: string; field: string }`. A type that matches refs by shape (for example a create-input type that checks whether a column has a generated default) matches `entry` and `field`.
 - A pack that ships a contract with generated defaults re-emits it with `prisma contract emit`, and updates its pinned contract-space snapshots as in step 2.
 - The options passed to `applyMutationDefaults` change separately: see `mutation-defaults-options-entry-field` below for the rename of `table` to `entry`.
 
@@ -261,7 +267,7 @@ import {
 import { timestampNowControlDescriptor } from '@prisma/orm-framework/components/control';
 ```
 
-The same applies to the `family/control` subpaths of `@prisma/orm-postgres` and `@prisma/orm-sqlite` (move to their `components/authoring` and `components/control` subpaths), and to `@internal/family-sql/control` (move to `@internal/framework-components/authoring` and `@internal/framework-components/control`). Keep importing `temporalCodecPresetWithPrecision` and `temporalStringAuthoringPresets` from `family/control`.
+The same applies to the `family/control` subpaths of `@prisma/orm-postgres` and `@prisma/orm-sqlite` (move to their `components/authoring` and `components/control` subpaths), and to `@internal/family-sql/control` (move to `@internal/framework-components/authoring` and `@internal/framework-components/control`, published as the `components/authoring` and `components/control` subpaths of `@prisma/orm-framework`). Keep importing `temporalCodecPresetWithPrecision` and `temporalStringAuthoringPresets` from `family/control`.
 
 ## `temporal-preset-builders-take-storage-template`
 
@@ -331,7 +337,7 @@ A literal default on a column whose codec no pack in the contract declares now f
 
 ## `contract-source-format-is-psl-or-typescript`
 
-`ContractSourceProvider` from `@internal/config/config-types` is now the union of `PslContractSourceProvider` (`format: 'psl'`) and `TypeScriptContractSourceProvider` (`format: 'typescript'`). `format` is required on both. `OpaqueContractSourceProvider` and every other `format` value are gone, and config validation reports a source with no `format`, or any other value, as an issue on `contract.source.format`.
+`ContractSourceProvider` from `@internal/config/config-types` (`@prisma/orm-framework/config/config-types`) is now the union of `PslContractSourceProvider` (`format: 'psl'`) and `TypeScriptContractSourceProvider` (`format: 'typescript'`). `format` is required on both. `OpaqueContractSourceProvider` and every other `format` value are gone, and config validation reports a source with no `format`, or any other value, as an issue on `contract.source.format`.
 
 Give every contract source an extension defines a `format`: `'psl'` when its inputs are PSL text, and `'typescript'` when it builds the contract in TypeScript. Replace imports of `OpaqueContractSourceProvider` with `ContractSourceProvider`.
 
@@ -341,7 +347,7 @@ The source returned by `prisma7Schema()` now declares `format: 'psl'`, because a
 
 ## `print-psl-description-option`
 
-`printPsl()` from `@internal/psl-printer` used to open every file with the `// use prisma-8` marker and a line saying the contract was inferred from the live database. It now writes only the marker, and a second comment line only when the caller passes `description`. Code that prints an inferred contract and wants the old second line passes it:
+`printPsl()` from `@internal/psl-printer` (`@prisma/orm-framework/psl-printer`) used to open every file with the `// use prisma-8` marker and a line saying the contract was inferred from the live database. It now writes only the marker, and a second comment line only when the caller passes `description`. Code that prints an inferred contract and wants the old second line passes it:
 
 ```ts
 printPsl(ast, {
@@ -353,7 +359,7 @@ printPsl(ast, {
 
 ## `family-sql-psl-build-export`
 
-`contract print` uses some of what `@internal/family-sql/psl-infer` exported, so those exports moved to the new subpath `@internal/family-sql/psl-build`: `mapDefault`, `DefaultMappingOptions`, `DefaultMappingResult`, `PslTypeMap`, `PslTypeReference`, `PslTypeResolution` and `toEnumMemberName`. Import them from `@internal/family-sql/psl-build`. Everything else stays in `@internal/family-sql/psl-infer`.
+`contract print` uses some of what `@internal/family-sql/psl-infer` exported, so those exports moved to the new subpath `@internal/family-sql/psl-build`: `mapDefault`, `DefaultMappingOptions`, `DefaultMappingResult`, `PslTypeMap`, `PslTypeReference`, `PslTypeResolution` and `toEnumMemberName`. Import them from `@internal/family-sql/psl-build` (`@prisma/orm-family-sql/family/psl-build`, or the same subpath of `@prisma/orm-postgres` and `@prisma/orm-sqlite`). Everything else stays in `@internal/family-sql/psl-infer` (`family/psl-infer`).
 
 ## `cursor-rejects-expression-orders`
 
@@ -408,28 +414,30 @@ Rewrite each specifier. The exported names are unchanged.
 | `@prisma/orm-mongo/adapter/<same four>` | `@prisma/orm-mongo/target/<same four>` |
 | `@prisma/orm-target-mongo/adapter/<same four>` | `@prisma/orm-target-mongo/target/<same four>` |
 
-Then re-sort the import block with the package's formatter (the new specifier sorts after `@internal/mongo-*`). A package that imports from `@internal/target-mongo` for the first time needs it in `dependencies`. A pack that emits a Mongo `contract.d.ts` re-emits it with `prisma contract emit`, or applies the same rewrite to the committed file; the contract JSON and hashes do not change.
+An extension outside this repository imports the published forms in the last two rows. Then re-sort the import block with the package's formatter (the new specifier sorts after `@internal/mongo-*`). A package that imports from `@internal/target-mongo` for the first time needs it in `dependencies`. A pack that emits a Mongo `contract.d.ts` re-emits it with `prisma contract emit`, or applies the same rewrite to the committed file; the contract JSON and hashes do not change.
 
-`@internal/target-mongo/codecs` also exports `mongoStandardCodecs` and `buildStandardCodecRegistry`, which the adapter used internally before.
+`@internal/target-mongo/codecs` (`@prisma/orm-mongo/target/codecs`) also exports `mongoStandardCodecs` and `buildStandardCodecRegistry`, which the adapter used internally before.
 
 ## `create-mongo-runner-deps-removed`
 
 ```ts
 // before
-import { createMongoRunnerDeps, extractDb } from '@internal/adapter-mongo/control';
-import { MongoDriverImpl } from '@internal/driver-mongo';
+import { createMongoRunnerDeps, extractDb } from '@prisma/orm-mongo/adapter/control';
+import { MongoDriverImpl } from '@prisma/orm-mongo/driver';
 const deps = createMongoRunnerDeps(controlDriver, MongoDriverImpl.fromDb(extractDb(controlDriver)), family);
 
 // after
-import { MongoControlAdapterImpl } from '@internal/adapter-mongo/control';
+import { MongoControlAdapterImpl } from '@prisma/orm-mongo/adapter/control';
 const deps = new MongoControlAdapterImpl().createRunnerDependencies(controlDriver);
 ```
 
+Inside this repository the same imports are `@internal/adapter-mongo/control` and `@internal/driver-mongo`.
+
 Drop imports that are now unused and any family instance built only to pass as the third argument.
 
 ## `mongo-runner-dependency-types-move-to-family`
 
-Change the import of `MongoRunnerDependencies` or `MarkerOperations` to `@internal/family-mongo/control-adapter`. The shapes are unchanged.
+Change the import of `MongoRunnerDependencies` or `MarkerOperations` to `@prisma/orm-mongo/family/control-adapter` (`@internal/family-mongo/control-adapter` inside this repository). The shapes are unchanged.
 
 ## `mongo-control-adapter-creates-runner-dependencies`
 
@@ -467,11 +475,25 @@ const context: MongoExecutionContext = { contract, codecs, stack, applyMutationD
 
 ## `mongo-field-builder-execution-defaults-parameter`
 
-Code that constrains on a bare `FieldBuilder` (for example `Fields extends Record<string, FieldBuilder>`) accepts only builders without execution defaults; pass `ExecutionMutationDefaultPhases | undefined` as the fifth type argument to accept preset fields. There is no detection pattern: a bare `FieldBuilder` reference is too common to tell which uses need the wider type.
+Code that constrains on a bare `FieldBuilder` (for example `Fields extends Record<string, FieldBuilder>`) accepts only builders without execution defaults; pass `ExecutionMutationDefaultPhases | undefined` as the fifth type argument to accept preset fields:
+
+```ts
+import type { ContractFieldType, ExecutionMutationDefaultPhases } from '@prisma/orm-mongo/contract/types';
+import type { EnumTypeHandle, FieldBuilder } from '@prisma/orm-mongo/contract-builder';
+
+type AnyField = FieldBuilder<
+  ContractFieldType,
+  boolean,
+  boolean,
+  EnumTypeHandle | undefined,
+  ExecutionMutationDefaultPhases | undefined
+>;
+```
+ There is no detection pattern: a bare `FieldBuilder` reference is too common to tell which uses need the wider type.
 
 ## `mongo-bson-codec-added`
 
-The Mongo target adds the codec `mongo/bson@1` (data type `mongo/bson`, PSL `Bson`, `field.bson()`), whose `CodecTypes` entry reads `BsonValue` and writes `BsonInputValue` (a `BsonValue`, or a `Uint8Array` at any depth), both exported from `@internal/target-mongo/codec-types` (declared in `@internal/mongo-value`, where the Mongo TypeScript builder reads them). `BsonValue` covers every value the driver returns with its default settings, `Code`, `MinKey`, `MaxKey`, `BSONSymbol` and a native `RegExp` (what a stored regex reads back as) included; `BSONRegExp` appears only with a driver configured with `bsonRegExp: true`. A `DBRef` is never returned, because decode turns it back into its `{ $ref, $id[, $db], ...fields }` document. It declares an empty `targetTypes`, so the validator does not constrain its value: a single field gets `{}`, and a list field still must be an array, `{ bsonType: 'array', items: {} }`. An extension that lists every Mongo codec id, or keys a map by `CodecTypes`, adds `mongo/bson@1`. An extension that stores arbitrary BSON in a field of its own contract types it `mongo/bson@1`, because `mongo/json@1` now refuses non-JSON values on encode and decode.
+The Mongo target adds five codecs, none of which existed in 8.0.0-rc.12: `mongo/int64@1` (PSL `Int64`, `bigint`), `mongo/decimal128@1` (PSL `Decimal128`, a decimal string), `mongo/binary@1` (PSL `Binary`, `Uint8Array`), `mongo/json@1` (PSL `Json`, JSON values only, refused on encode and decode otherwise) and `mongo/bson@1` (PSL `Bson`, `field.bson()`, any BSON value). The `mongo/bson@1` entry of `CodecTypes` reads `BsonValue` and writes `BsonInputValue` (a `BsonValue`, or a `Uint8Array` at any depth), both exported from `@prisma/orm-mongo/target/codec-types` (`@internal/target-mongo/codec-types` inside this repository) and declared in `@prisma/orm-mongo/value` (`@internal/mongo-value`), where the Mongo TypeScript builder reads them. `BsonValue` covers every value the driver returns with its default settings, `Code`, `MinKey`, `MaxKey`, `BSONSymbol` and a native `RegExp` (what a stored regex reads back as) included; `BSONRegExp` appears only with a driver configured with `bsonRegExp: true`. A `DBRef` is never returned, because decode turns it back into its `{ $ref, $id[, $db], ...fields }` document. It declares an empty `targetTypes`, so the validator does not constrain its value: a single field gets `{}`, and a list field still must be an array, `{ bsonType: 'array', items: {} }`. An extension that lists every Mongo codec id, or keys a map by `CodecTypes`, adds the five new ones. An extension that stores arbitrary BSON in a field of its own contract types it `mongo/bson@1`, not `mongo/json@1`, which refuses non-JSON values.
 
 The detection pattern finds a descriptor whose `targetTypes` lists two or more entries, quoted strings or named constants, on one line or several. It does not see a list built elsewhere and referenced by name (`targetTypes: TYPES`); check those descriptors by hand.