@prisma-next/family-mongo 0.12.0-dev.16 → 0.12.0-dev.17

package/dist/control.d.mts

@@ -1,7 +1,7 @@
 import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
 import { ContractSerializer, ContractSpace, ControlExtensionDescriptor, ControlFamilyDescriptor, ControlFamilyInstance, ControlStack, MigratableTargetDescriptor, MigrationPlanOperation, OperationPreview, OperationPreviewCapable, SchemaIssue, SchemaVerificationNode, SchemaVerifier, SchemaViewCapable } from "@prisma-next/framework-components/control";
 import { MongoContract, MongoStorageShape } from "@prisma-next/mongo-contract";
-import { Contract } from "@prisma-next/contract/types";
+import { Contract, ControlPolicy } from "@prisma-next/contract/types";
 
 //#region src/core/contract-to-schema.d.ts
 declare function contractToMongoSchemaIR(contract: MongoContract | null): MongoSchemaIR;
@@ -73,7 +73,7 @@ declare function formatMongoOperations(operations: readonly MigrationPlanOperati
 declare function mongoOperationsToPreview(operations: readonly MigrationPlanOperation[]): OperationPreview;
 //#endregion
 //#region src/core/schema-diff.d.ts
-declare function diffMongoSchemas(live: MongoSchemaIR, expected: MongoSchemaIR, strict: boolean): {
+declare function diffMongoSchemas(live: MongoSchemaIR, expected: MongoSchemaIR, strict: boolean, collectionControlPolicy: (collectionName: string) => ControlPolicy): {
   root: SchemaVerificationNode;
   issues: SchemaIssue[];
   counts: {

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/contract-to-schema.ts","../src/core/control-instance.ts","../src/core/control-descriptor.ts","../src/core/control-target-descriptor.ts","../src/core/control-types.ts","../src/core/operation-preview.ts","../src/core/schema-diff.ts","../src/core/schema-verify/canonicalize-introspection.ts"],"mappings":";;;;;;iBAyEgB,uBAAA,CAAwB,QAAA,EAAU,aAAA,UAAuB,aAAa;;;UCpCrE,0BAAA,SACP,qBAAA,UAA+B,aAAA,GACrC,iBAAA,CAAkB,aAAA,GAClB,uBAAA;;;ADiCJ;;;;;;;;ECtBE,mBAAA,CAAoB,YAAA,YAAwB,QAAA;AAAA;AAAA,iBAsE9B,yBAAA,CAA0B,YAAA,EAAc,YAAA,GAAe,0BAA0B;;;cClGpF,qBAAA,EAAuB,uBAAuB,UAAU,0BAAA;;;;;AFkDrE;;;;;;;;AAAsF;;UGpDrE,4BAAA,mBAA+C,aAAA,GAAgB,aAAA,UACtE,0BAAA,mBAA6C,0BAAA;EAAA,SAC5C,kBAAA,EAAoB,kBAAA,CAAmB,SAAA;EAAA,SACvC,cAAA,EAAgB,cAAA,CAAe,SAAA,EAAW,aAAA;AAAA;;;;;;;AHiDrD;;;;;;;;AAAsF;;;UIpDrE,+BAAA,SACP,0BAAA;EAAA,SACC,aAAA,GAAgB,aAAA,CAAc,aAAA,CAAc,iBAAA;AAAA;;;iBC6EvC,qBAAA,CAAsB,UAA6C,WAAxB,sBAAsB;;;;;AL3BjF;iBKgDgB,wBAAA,CACd,UAAA,WAAqB,sBAAA,KACpB,gBAAgB;;;iBC/GH,gBAAA,CACd,IAAA,EAAM,aAAA,EACN,QAAA,EAAU,aAAA,EACV,MAAA;EAEA,IAAA,EAAM,sBAAA;EACN,MAAA,EAAQ,WAAA;EACR,MAAA;IAAU,IAAA;IAAc,IAAA;IAAc,IAAA;IAAc,UAAA;EAAA;AAAA;;;UCWrC,oBAAA;EAAA,SACN,IAAA,EAAM,aAAA;EAAA,SACN,QAAA,EAAU,aAAa;AAAA;AAAA,iBAGlB,kCAAA,CACd,IAAA,EAAM,aAAA,EACN,QAAA,EAAU,aAAA,GACT,oBAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/contract-to-schema.ts","../src/core/control-instance.ts","../src/core/control-descriptor.ts","../src/core/control-target-descriptor.ts","../src/core/control-types.ts","../src/core/operation-preview.ts","../src/core/schema-diff.ts","../src/core/schema-verify/canonicalize-introspection.ts"],"mappings":";;;;;;iBAyEgB,uBAAA,CAAwB,QAAA,EAAU,aAAA,UAAuB,aAAa;;;UCpCrE,0BAAA,SACP,qBAAA,UAA+B,aAAA,GACrC,iBAAA,CAAkB,aAAA,GAClB,uBAAA;;;ADiCJ;;;;;;;;ECtBE,mBAAA,CAAoB,YAAA,YAAwB,QAAA;AAAA;AAAA,iBAsE9B,yBAAA,CAA0B,YAAA,EAAc,YAAA,GAAe,0BAA0B;;;cClGpF,qBAAA,EAAuB,uBAAuB,UAAU,0BAAA;;;;;AFkDrE;;;;;;;;AAAsF;;UGpDrE,4BAAA,mBAA+C,aAAA,GAAgB,aAAA,UACtE,0BAAA,mBAA6C,0BAAA;EAAA,SAC5C,kBAAA,EAAoB,kBAAA,CAAmB,SAAA;EAAA,SACvC,cAAA,EAAgB,cAAA,CAAe,SAAA,EAAW,aAAA;AAAA;;;;;;;AHiDrD;;;;;;;;AAAsF;;;UIpDrE,+BAAA,SACP,0BAAA;EAAA,SACC,aAAA,GAAgB,aAAA,CAAc,aAAA,CAAc,iBAAA;AAAA;;;iBC6EvC,qBAAA,CAAsB,UAA6C,WAAxB,sBAAsB;;;;;AL3BjF;iBKgDgB,wBAAA,CACd,UAAA,WAAqB,sBAAA,KACpB,gBAAgB;;;iBC7GH,gBAAA,CACd,IAAA,EAAM,aAAA,EACN,QAAA,EAAU,aAAA,EACV,MAAA,WACA,uBAAA,GAA0B,cAAA,aAA2B,aAAA;EAErD,IAAA,EAAM,sBAAA;EACN,MAAA,EAAQ,WAAA;EACR,MAAA;IAAU,IAAA;IAAc,IAAA;IAAc,IAAA;IAAc,UAAA;EAAA;AAAA;;;UCQrC,oBAAA;EAAA,SACN,IAAA,EAAM,aAAA;EAAA,SACN,QAAA,EAAU,aAAa;AAAA;AAAA,iBAGlB,kCAAA,CACd,IAAA,EAAM,aAAA,EACN,QAAA,EAAU,aAAA,GACT,oBAAA"}

package/dist/control.mjs

@@ -1,4 +1,4 @@
-import { i as contractToMongoSchemaIR, n as canonicalizeSchemasForVerification, r as diffMongoSchemas, t as verifyMongoSchema } from "./verify-mongo-schema-Bhxvdah3.mjs";
+import { i as contractToMongoSchemaIR, n as canonicalizeSchemasForVerification, r as diffMongoSchemas, t as verifyMongoSchema } from "./verify-mongo-schema-BXJqoE59.mjs";
 import { t as MongoContractSerializer } from "./mongo-contract-serializer-DAoKJxiP.mjs";
 import { mongoEmission } from "@prisma-next/mongo-emitter";
 import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH } from "@prisma-next/framework-components/control";

package/dist/ir.d.mts

@@ -1,6 +1,7 @@
 import { ContractSerializer, SchemaIssue, SchemaVerifier, SchemaVerifyOptions, SchemaVerifyResult } from "@prisma-next/framework-components/control";
-import { MongoContract, MongoStorage } from "@prisma-next/mongo-contract";
+import { MongoCollection, MongoContract, MongoStorage } from "@prisma-next/mongo-contract";
 import { Type } from "arktype";
+import { ControlPolicy } from "@prisma-next/contract/types";
 import { Namespace } from "@prisma-next/framework-components/ir";
 import * as _$_prisma_next_contract_hashing0 from "@prisma-next/contract/hashing";
 import { JsonObject } from "@prisma-next/utils/json";
@@ -113,8 +114,11 @@ declare class MongoContractSerializer extends MongoContractSerializerBase<MongoC
  */
 declare abstract class MongoSchemaVerifierBase<TContract extends {
   readonly storage: MongoStorage;
+  readonly defaultControl?: ControlPolicy;
 }, TSchema> implements SchemaVerifier<TContract, TSchema> {
   verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult;
+  protected effectiveCollectionControlPolicy(contract: TContract, collection: MongoCollection | undefined): ControlPolicy;
+  protected collectionControlPolicyForName(contract: TContract, collectionName: string): ControlPolicy;
   protected verifyCommonMongoSchema(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaIssue[];
   /**
    * Per-namespace verification hook. Receives the namespace metadata plus

package/dist/ir.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/mongo-contract-serializer-base.ts","../src/core/ir/mongo-contract-serializer.ts","../src/core/ir/mongo-schema-verifier-base.ts"],"mappings":";;;;;;;;;;;;AAmCA;;;;;;;;;;;;;;;;;uBAAsB,2BAAA,uBACT,kBAAA,CAAmB,SAAA;EAAA,iBAEb,cAAA;cAEL,kBAAA,GAAqB,WAAA,SAAoB,IAAA;EAUrD,mBAAA,WAA8B,SAAA,GAAY,SAAA,CAAA,CAAW,IAAA,YAAgB,CAAA;EAKrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;EAnBV;;;;;;EAgC9B,mBAAA,EAbkD,gCAAA,CAa/B,sBAAA;EAlBC;;;;;;;;;;;;;;;;EAAA,UAoCV,2BAAA,CAA4B,IAAA,YAAgB,aAAA;EAmCG;;;;;;EAAA,UAA/C,oBAAA,CAAqB,QAAA,EAAU,aAAA,GAAgB,aAAA;;;;AC5G3D;;;;;qBDkJqB,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,SAAA;AAAA;;;;;;;;;AA5HxE;;;;cCtBa,uBAAA,SAAgC,2BAAA,CAA4B,aAAA;EAAA,UAC7D,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,aAAA;AAAA;;;;;;;;ADqB/D;;;;;;;;;;;;;;;;uBELsB,uBAAA;EAAA,SACS,OAAA,EAAS,YAAA;AAAA,uBAE3B,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EAAA,UAOtD,uBAAA,CACR,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;EFRD;;;;;;;;EAAA,mBEmCQ,eAAA,CAAgB,OAAA;IAAA,SACxB,QAAA,EAAU,SAAA;IAAA,SACV,MAAA,EAAQ,OAAA;IAAA,SACR,WAAA;IAAA,SACA,SAAA,EAAW,SAAA;EAAA,aACT,WAAA;EFrBe;;;;;EAAA,mBE4BT,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;AAAA"}
+{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/mongo-contract-serializer-base.ts","../src/core/ir/mongo-contract-serializer.ts","../src/core/ir/mongo-schema-verifier-base.ts"],"mappings":";;;;;;;;;;;;;;AAmCA;;;;;;;;;;;;;;;;uBAAsB,2BAAA,uBACT,kBAAA,CAAmB,SAAA;EAAA,iBAEb,cAAA;cAEL,kBAAA,GAAqB,WAAA,SAAoB,IAAA;EAUrD,mBAAA,WAA8B,SAAA,GAAY,SAAA,CAAA,CAAW,IAAA,YAAgB,CAAA;EAKrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;EAnB7B;;;;;;EAgCX,mBAAA,EAbkD,gCAAA,CAa/B,sBAAA;EAlBnB;;;;;;;;;;;;;;;;EAAA,UAoCU,2BAAA,CAA4B,IAAA,YAAgB,aAAA;EAmCvB;;;;;;EAAA,UAArB,oBAAA,CAAqB,QAAA,EAAU,aAAA,GAAgB,aAAA;EAsCsB;;;;AClJjF;;;;EDkJiF,mBAA5D,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,SAAA;AAAA;;;;;;;;;;AA5HxE;;;cCtBa,uBAAA,SAAgC,2BAAA,CAA4B,aAAA;EAAA,UAC7D,uBAAA,CAAwB,SAAA,EAAW,aAAA,GAAgB,aAAA;AAAA;;;;;;;;ADqB/D;;;;;;;;;;;;;;;;uBEFsB,uBAAA;EAAA,SACS,OAAA,EAAS,YAAA;EAAA,SAAuB,cAAA,GAAiB,aAAA;AAAA,uBAEnE,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EAAA,UAOtD,gCAAA,CACR,QAAA,EAAU,SAAA,EACV,UAAA,EAAY,eAAA,eACX,aAAA;EAAA,UAIO,8BAAA,CACR,QAAA,EAAU,SAAA,EACV,cAAA,WACC,aAAA;EAAA,UAMO,uBAAA,CACR,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;;;;;;;;;qBA2BO,eAAA,CAAgB,OAAA;IAAA,SACxB,QAAA,EAAU,SAAA;IAAA,SACV,MAAA,EAAQ,OAAA;IAAA,SACR,WAAA;IAAA,SACA,SAAA,EAAW,SAAA;EAAA,aACT,WAAA;EF3Bb;;;;;EAAA,mBEkCmB,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;AAAA"}

package/dist/ir.mjs

@@ -1,4 +1,6 @@
 import { n as MongoContractSerializerBase, t as MongoContractSerializer } from "./mongo-contract-serializer-DAoKJxiP.mjs";
+import { effectiveControlPolicy } from "@prisma-next/contract/types";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 //#region src/core/ir/mongo-schema-verifier-base.ts
 /**
 * Mongo family `SchemaVerifier` abstract base. Commits the Mongo family
@@ -31,6 +33,13 @@ var MongoSchemaVerifierBase = class {
 			issues
 		};
 	}
+	effectiveCollectionControlPolicy(contract, collection) {
+		return effectiveControlPolicy(collection?.control, contract.defaultControl);
+	}
+	collectionControlPolicyForName(contract, collectionName) {
+		const collection = contract.storage.namespaces[UNBOUND_NAMESPACE_ID]?.collections[collectionName];
+		return this.effectiveCollectionControlPolicy(contract, collection);
+	}
 	verifyCommonMongoSchema(options) {
 		const issues = [];
 		const { namespaces } = options.contract.storage;

package/dist/ir.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ir.mjs","names":[],"sources":["../src/core/ir/mongo-schema-verifier-base.ts"],"sourcesContent":["import type {\n  SchemaIssue,\n  SchemaVerifier,\n  SchemaVerifyOptions,\n  SchemaVerifyResult,\n} from '@prisma-next/framework-components/control';\nimport type { Namespace } from '@prisma-next/framework-components/ir';\nimport type { MongoStorage } from '@prisma-next/mongo-contract';\n\n/**\n * Mongo family `SchemaVerifier` abstract base. Commits the Mongo family\n * to namespace-keyed verification: the family-shared walk iterates\n * `storage.namespaces` in sorted order and dispatches per-namespace\n * through the protected `verifyNamespace` hook, then aggregates\n * target-extension issues from `verifyTargetExtensions`.\n *\n * Per-element diff work (collection / index / validator comparisons)\n * lives on the target inside `verifyNamespace`. The family's structural\n * commitment is \"verification is namespaced\"; the target's commitment is\n * \"verification of a given namespace's collections is the existing\n * diff/canonicalize pipeline\". The split keeps target-mongo's\n * introspection-side helpers (`contractToMongoSchemaIR`,\n * `canonicalizeSchemasForVerification`, `diffMongoSchemas`) in the target\n * layer where they belong, while the family base owns the iteration\n * scaffolding that makes namespaces a first-class verifier concept.\n *\n * Target-specific issue kinds (Atlas-only, future RLS-equivalents)\n * surface through `verifyTargetExtensions`; that hook returns the empty\n * list when no extensions exist over the Mongo family alphabet.\n */\nexport abstract class MongoSchemaVerifierBase<\n  TContract extends { readonly storage: MongoStorage },\n  TSchema,\n> implements SchemaVerifier<TContract, TSchema>\n{\n  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult {\n    const issues: SchemaIssue[] = [];\n    issues.push(...this.verifyCommonMongoSchema(options));\n    issues.push(...this.verifyTargetExtensions(options));\n    return { ok: issues.length === 0, issues };\n  }\n\n  protected verifyCommonMongoSchema(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[] {\n    const issues: SchemaIssue[] = [];\n    const { namespaces } = options.contract.storage;\n    const namespaceIds = Object.keys(namespaces).sort();\n    for (const namespaceId of namespaceIds) {\n      const namespace = namespaces[namespaceId];\n      if (!namespace) continue;\n      issues.push(\n        ...this.verifyNamespace({\n          contract: options.contract,\n          schema: options.schema,\n          namespaceId,\n          namespace,\n        }),\n      );\n    }\n    return issues;\n  }\n\n  /**\n   * Per-namespace verification hook. Receives the namespace metadata plus\n   * the full contract + schema pair; the target's implementation owns the\n   * per-collection diff using its existing introspection-side helpers.\n   * Slice the schema by namespace at the call site (or compute the full\n   * diff once and dispatch per namespace) — the family base does not\n   * prescribe the per-namespace shape.\n   */\n  protected abstract verifyNamespace(options: {\n    readonly contract: TContract;\n    readonly schema: TSchema;\n    readonly namespaceId: string;\n    readonly namespace: Namespace;\n  }): readonly SchemaIssue[];\n\n  /**\n   * Target-specific extensions — Atlas-only kinds, target-only\n   * namespace-mismatch issues that don't fit the family-shared walk.\n   * Returns the empty list when the target ships no extensions.\n   */\n  protected abstract verifyTargetExtensions(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAsB,0BAAtB,MAIA;CACE,aAAa,SAAsE;EACjF,MAAM,SAAwB,CAAC;EAC/B,OAAO,KAAK,GAAG,KAAK,wBAAwB,OAAO,CAAC;EACpD,OAAO,KAAK,GAAG,KAAK,uBAAuB,OAAO,CAAC;EACnD,OAAO;GAAE,IAAI,OAAO,WAAW;GAAG;EAAO;CAC3C;CAEA,wBACE,SACwB;EACxB,MAAM,SAAwB,CAAC;EAC/B,MAAM,EAAE,eAAe,QAAQ,SAAS;EACxC,MAAM,eAAe,OAAO,KAAK,UAAU,EAAE,KAAK;EAClD,KAAK,MAAM,eAAe,cAAc;GACtC,MAAM,YAAY,WAAW;GAC7B,IAAI,CAAC,WAAW;GAChB,OAAO,KACL,GAAG,KAAK,gBAAgB;IACtB,UAAU,QAAQ;IAClB,QAAQ,QAAQ;IAChB;IACA;GACF,CAAC,CACH;EACF;EACA,OAAO;CACT;AAyBF"}
+{"version":3,"file":"ir.mjs","names":[],"sources":["../src/core/ir/mongo-schema-verifier-base.ts"],"sourcesContent":["import type { ControlPolicy } from '@prisma-next/contract/types';\nimport { effectiveControlPolicy } from '@prisma-next/contract/types';\nimport type {\n  SchemaIssue,\n  SchemaVerifier,\n  SchemaVerifyOptions,\n  SchemaVerifyResult,\n} from '@prisma-next/framework-components/control';\nimport type { Namespace } from '@prisma-next/framework-components/ir';\nimport { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { MongoCollection, MongoStorage } from '@prisma-next/mongo-contract';\n\n/**\n * Mongo family `SchemaVerifier` abstract base. Commits the Mongo family\n * to namespace-keyed verification: the family-shared walk iterates\n * `storage.namespaces` in sorted order and dispatches per-namespace\n * through the protected `verifyNamespace` hook, then aggregates\n * target-extension issues from `verifyTargetExtensions`.\n *\n * Per-element diff work (collection / index / validator comparisons)\n * lives on the target inside `verifyNamespace`. The family's structural\n * commitment is \"verification is namespaced\"; the target's commitment is\n * \"verification of a given namespace's collections is the existing\n * diff/canonicalize pipeline\". The split keeps target-mongo's\n * introspection-side helpers (`contractToMongoSchemaIR`,\n * `canonicalizeSchemasForVerification`, `diffMongoSchemas`) in the target\n * layer where they belong, while the family base owns the iteration\n * scaffolding that makes namespaces a first-class verifier concept.\n *\n * Target-specific issue kinds (Atlas-only, future RLS-equivalents)\n * surface through `verifyTargetExtensions`; that hook returns the empty\n * list when no extensions exist over the Mongo family alphabet.\n */\nexport abstract class MongoSchemaVerifierBase<\n  TContract extends { readonly storage: MongoStorage; readonly defaultControl?: ControlPolicy },\n  TSchema,\n> implements SchemaVerifier<TContract, TSchema>\n{\n  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult {\n    const issues: SchemaIssue[] = [];\n    issues.push(...this.verifyCommonMongoSchema(options));\n    issues.push(...this.verifyTargetExtensions(options));\n    return { ok: issues.length === 0, issues };\n  }\n\n  protected effectiveCollectionControlPolicy(\n    contract: TContract,\n    collection: MongoCollection | undefined,\n  ): ControlPolicy {\n    return effectiveControlPolicy(collection?.control, contract.defaultControl);\n  }\n\n  protected collectionControlPolicyForName(\n    contract: TContract,\n    collectionName: string,\n  ): ControlPolicy {\n    const namespace = contract.storage.namespaces[UNBOUND_NAMESPACE_ID];\n    const collection = namespace?.collections[collectionName];\n    return this.effectiveCollectionControlPolicy(contract, collection);\n  }\n\n  protected verifyCommonMongoSchema(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[] {\n    const issues: SchemaIssue[] = [];\n    const { namespaces } = options.contract.storage;\n    const namespaceIds = Object.keys(namespaces).sort();\n    for (const namespaceId of namespaceIds) {\n      const namespace = namespaces[namespaceId];\n      if (!namespace) continue;\n      issues.push(\n        ...this.verifyNamespace({\n          contract: options.contract,\n          schema: options.schema,\n          namespaceId,\n          namespace,\n        }),\n      );\n    }\n    return issues;\n  }\n\n  /**\n   * Per-namespace verification hook. Receives the namespace metadata plus\n   * the full contract + schema pair; the target's implementation owns the\n   * per-collection diff using its existing introspection-side helpers.\n   * Slice the schema by namespace at the call site (or compute the full\n   * diff once and dispatch per namespace) — the family base does not\n   * prescribe the per-namespace shape.\n   */\n  protected abstract verifyNamespace(options: {\n    readonly contract: TContract;\n    readonly schema: TSchema;\n    readonly namespaceId: string;\n    readonly namespace: Namespace;\n  }): readonly SchemaIssue[];\n\n  /**\n   * Target-specific extensions — Atlas-only kinds, target-only\n   * namespace-mismatch issues that don't fit the family-shared walk.\n   * Returns the empty list when the target ships no extensions.\n   */\n  protected abstract verifyTargetExtensions(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,IAAsB,0BAAtB,MAIA;CACE,aAAa,SAAsE;EACjF,MAAM,SAAwB,CAAC;EAC/B,OAAO,KAAK,GAAG,KAAK,wBAAwB,OAAO,CAAC;EACpD,OAAO,KAAK,GAAG,KAAK,uBAAuB,OAAO,CAAC;EACnD,OAAO;GAAE,IAAI,OAAO,WAAW;GAAG;EAAO;CAC3C;CAEA,iCACE,UACA,YACe;EACf,OAAO,uBAAuB,YAAY,SAAS,SAAS,cAAc;CAC5E;CAEA,+BACE,UACA,gBACe;EAEf,MAAM,aADY,SAAS,QAAQ,WAAW,uBAChB,YAAY;EAC1C,OAAO,KAAK,iCAAiC,UAAU,UAAU;CACnE;CAEA,wBACE,SACwB;EACxB,MAAM,SAAwB,CAAC;EAC/B,MAAM,EAAE,eAAe,QAAQ,SAAS;EACxC,MAAM,eAAe,OAAO,KAAK,UAAU,EAAE,KAAK;EAClD,KAAK,MAAM,eAAe,cAAc;GACtC,MAAM,YAAY,WAAW;GAC7B,IAAI,CAAC,WAAW;GAChB,OAAO,KACL,GAAG,KAAK,gBAAgB;IACtB,UAAU,QAAQ;IAClB,QAAQ,QAAQ;IAChB;IACA;GACF,CAAC,CACH;EACF;EACA,OAAO;CACT;AAyBF"}

package/dist/schema-verify.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-verify.d.mts","names":[],"sources":["../src/core/schema-verify/verify-mongo-schema.ts"],"mappings":";;;;;;UAaiB,wBAAA;EAAA,SACN,QAAA,EAAU,aAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,MAAA;EAAA,SACA,OAAA,GAAU,gBAAA;EAHA;;;;;EAAA,SASV,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA;AAAA,iBAG9B,iBAAA,CAAkB,OAAA,EAAS,wBAAA,GAA2B,0BAA0B"}
+{"version":3,"file":"schema-verify.d.mts","names":[],"sources":["../src/core/schema-verify/verify-mongo-schema.ts"],"mappings":";;;;;;UAeiB,wBAAA;EAAA,SACN,QAAA,EAAU,aAAA;EAAA,SACV,MAAA,EAAQ,aAAA;EAAA,SACR,MAAA;EAAA,SACA,OAAA,GAAU,gBAAA;EAHA;;;;;EAAA,SASV,mBAAA,EAAqB,aAAA,CAAc,8BAAA;AAAA;AAAA,iBAG9B,iBAAA,CAAkB,OAAA,EAAS,wBAAA,GAA2B,0BAA0B"}

package/dist/schema-verify.mjs

@@ -1,2 +1,2 @@
-import { t as verifyMongoSchema } from "./verify-mongo-schema-Bhxvdah3.mjs";
+import { t as verifyMongoSchema } from "./verify-mongo-schema-BXJqoE59.mjs";
 export { verifyMongoSchema };

package/dist/{verify-mongo-schema-Bhxvdah3.mjs → verify-mongo-schema-BXJqoE59.mjs}

@@ -1,6 +1,7 @@
 import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
-import { VERIFY_CODE_SCHEMA_FAILURE } from "@prisma-next/framework-components/control";
+import { VERIFY_CODE_SCHEMA_FAILURE, dispositionForCategory } from "@prisma-next/framework-components/control";
 import { ifDefined } from "@prisma-next/utils/defined";
+import { effectiveControlPolicy } from "@prisma-next/contract/types";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 //#region src/core/contract-to-schema.ts
 function stripIrKind(node) {
@@ -56,8 +57,72 @@ function contractToMongoSchemaIR(contract) {
 	return new MongoSchemaIR(collections);
 }
 //#endregion
+//#region src/core/schema-verify/verifier-disposition.ts
+/**
+* Classifies the verifier issue kinds the Mongo schema differ emits into the
+* target-neutral categories the framework grades. Mongo only emits the kinds
+* listed below (missing/extra collections, missing/extra indexes, missing/extra
+* validators, and validator/options mismatches coded as `type_mismatch`); any
+* other kind never reaches this classifier and is graded conservatively as a
+* declared-incompatible divergence. Mongo owns this mapping rather than
+* importing the SQL classifier — the two families share only the framework's
+* category grading.
+*/
+function classifyMongoVerifierIssueKind(kind) {
+	switch (kind) {
+		case "extra_table": return "extraTopLevelObject";
+		case "extra_index":
+		case "extra_validator": return "extraAuxiliary";
+		case "missing_table":
+		case "type_missing": return "declaredMissing";
+		case "index_mismatch":
+		case "type_mismatch": return "declaredIncompatible";
+		default: return "declaredIncompatible";
+	}
+}
+function verifierDisposition(controlPolicy, issueKind) {
+	return dispositionForCategory(controlPolicy, classifyMongoVerifierIssueKind(issueKind));
+}
+//#endregion
+//#region src/core/schema-verify/mongo-control-verify-emit.ts
+/**
+* Reconciles a control-policy disposition with the Mongo family's strict-mode
+* contract for live-only extras — the single point where `strict` and the
+* control policy meet.
+*
+* The control policy decides first; only a `fail` is reconciled against the
+* caller's base node status. Call sites stamp a live-only extra with
+* `strict ? 'fail' : 'warn'` and a declared missing/mismatch with `fail`, so
+* this one step encodes the whole matrix:
+*
+* | live-vs-declared                    | strict   | non-strict |
+* |-------------------------------------|----------|------------|
+* | declared missing / mismatch         | fail     | fail       |
+* | live-only extra (managed/tolerated) | fail     | warn       |
+* | live-only extra (external)          | suppress (extras ignored, both modes) |
+* | anything (observed)                 | warn (both modes)     |
+*
+* `tolerated` no longer diverges from `managed` on a non-strict extra index:
+* both soften to `warn`, because the softening comes from the base status the
+* caller already computed from `strict`, not from per-policy special-casing.
+*/
+function reconcileMongoOutcome(controlPolicy, issueKind, baseStatus) {
+	const disposition = verifierDisposition(controlPolicy, issueKind);
+	return disposition === "fail" ? baseStatus : disposition;
+}
+function emitMongoIssueAndNodeUnderControlPolicy(controlPolicy, issue, node, issues, nodes) {
+	const outcome = reconcileMongoOutcome(controlPolicy, issue.kind, node.status);
+	if (outcome === "suppress") return "suppress";
+	issues.push(issue);
+	nodes.push({
+		...node,
+		status: outcome
+	});
+	return outcome;
+}
+//#endregion
 //#region src/core/schema-diff.ts
-function diffMongoSchemas(live, expected, strict) {
+function diffMongoSchemas(live, expected, strict, collectionControlPolicy) {
 	const issues = [];
 	const collectionChildren = [];
 	let pass = 0;
@@ -68,12 +133,11 @@ function diffMongoSchemas(live, expected, strict) {
 		const liveColl = live.collection(name);
 		const expectedColl = expected.collection(name);
 		if (!liveColl && expectedColl) {
-			issues.push({
+			const disposition = emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy(name), {
 				kind: "missing_table",
 				table: name,
 				message: `Collection "${name}" is missing from the database`
-			});
-			collectionChildren.push({
+			}, {
 				status: "fail",
 				kind: "collection",
 				name,
@@ -83,19 +147,18 @@ function diffMongoSchemas(live, expected, strict) {
 				expected: name,
 				actual: null,
 				children: []
-			});
-			fail++;
+			}, issues, collectionChildren);
+			if (disposition === "fail") fail++;
+			else if (disposition === "warn") warn++;
 			continue;
 		}
 		if (liveColl && !expectedColl) {
-			const status = strict ? "fail" : "warn";
-			issues.push({
+			const disposition = emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy(name), {
 				kind: "extra_table",
 				table: name,
 				message: `Extra collection "${name}" exists in the database but not in the contract`
-			});
-			collectionChildren.push({
-				status,
+			}, {
+				status: strict ? "fail" : "warn",
 				kind: "collection",
 				name,
 				contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${name}`,
@@ -104,16 +167,17 @@ function diffMongoSchemas(live, expected, strict) {
 				expected: null,
 				actual: name,
 				children: []
-			});
-			if (status === "fail") fail++;
-			else warn++;
+			}, issues, collectionChildren);
+			if (disposition === "fail") fail++;
+			else if (disposition === "warn") warn++;
 			continue;
 		}
 		const lc = liveColl;
 		const ec = expectedColl;
-		const indexChildren = diffIndexes(name, lc, ec, strict, issues);
-		const validatorChildren = diffValidator(name, lc, ec, strict, issues);
-		const optionsChildren = diffOptions(name, lc, ec, strict, issues);
+		const controlPolicy = collectionControlPolicy(name);
+		const indexChildren = diffIndexes(name, lc, ec, strict, controlPolicy, issues);
+		const validatorChildren = diffValidator(name, lc, ec, strict, controlPolicy, issues);
+		const optionsChildren = diffOptions(name, lc, ec, strict, controlPolicy, issues);
 		const children = [
 			...indexChildren,
 			...validatorChildren,
@@ -177,7 +241,7 @@ function buildIndexLookupKey(index) {
 function formatIndexName(index) {
 	return index.keys.map((k) => `${k.field}:${k.direction}`).join(", ");
 }
-function diffIndexes(collName, live, expected, strict, issues) {
+function diffIndexes(collName, live, expected, strict, collectionControlPolicy, issues) {
 	const nodes = [];
 	const liveLookup = /* @__PURE__ */ new Map();
 	for (const idx of live.indexes) liveLookup.set(buildIndexLookupKey(idx), idx);
@@ -194,56 +258,50 @@ function diffIndexes(collName, live, expected, strict, issues) {
 		actual: key,
 		children: []
 	});
-	else {
-		issues.push({
-			kind: "index_mismatch",
-			table: collName,
-			indexOrConstraint: formatIndexName(idx),
-			message: `Index ${formatIndexName(idx)} missing on collection "${collName}"`
-		});
-		nodes.push({
-			status: "fail",
-			kind: "index",
-			name: formatIndexName(idx),
-			contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
-			code: "MISSING_INDEX",
-			message: `Index ${formatIndexName(idx)} missing`,
-			expected: key,
-			actual: null,
-			children: []
-		});
-	}
-	for (const [key, idx] of liveLookup) if (!expectedLookup.has(key)) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
-			kind: "extra_index",
-			table: collName,
-			indexOrConstraint: formatIndexName(idx),
-			message: `Extra index ${formatIndexName(idx)} on collection "${collName}"`
-		});
-		nodes.push({
-			status,
-			kind: "index",
-			name: formatIndexName(idx),
-			contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
-			code: "EXTRA_INDEX",
-			message: `Extra index ${formatIndexName(idx)}`,
-			expected: null,
-			actual: key,
-			children: []
-		});
-	}
+	else emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy, {
+		kind: "index_mismatch",
+		table: collName,
+		indexOrConstraint: formatIndexName(idx),
+		message: `Index ${formatIndexName(idx)} missing on collection "${collName}"`
+	}, {
+		status: "fail",
+		kind: "index",
+		name: formatIndexName(idx),
+		contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
+		code: "MISSING_INDEX",
+		message: `Index ${formatIndexName(idx)} missing`,
+		expected: key,
+		actual: null,
+		children: []
+	}, issues, nodes);
+	for (const [key, idx] of liveLookup) if (!expectedLookup.has(key)) emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy, {
+		kind: "extra_index",
+		table: collName,
+		indexOrConstraint: formatIndexName(idx),
+		message: `Extra index ${formatIndexName(idx)} on collection "${collName}"`
+	}, {
+		status: strict ? "fail" : "warn",
+		kind: "index",
+		name: formatIndexName(idx),
+		contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.indexes`,
+		code: "EXTRA_INDEX",
+		message: `Extra index ${formatIndexName(idx)}`,
+		expected: null,
+		actual: key,
+		children: []
+	}, issues, nodes);
 	return nodes;
 }
-function diffValidator(collName, live, expected, strict, issues) {
+function diffValidator(collName, live, expected, strict, collectionControlPolicy, issues) {
 	if (!live.validator && !expected.validator) return [];
 	if (expected.validator && !live.validator) {
-		issues.push({
+		const issue = {
 			kind: "type_missing",
 			table: collName,
 			message: `Validator missing on collection "${collName}"`
-		});
-		return [{
+		};
+		const nodes = [];
+		emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy, issue, {
 			status: "fail",
 			kind: "validator",
 			name: "validator",
@@ -253,17 +311,18 @@ function diffValidator(collName, live, expected, strict, issues) {
 			expected: canonicalize(expected.validator.jsonSchema),
 			actual: null,
 			children: []
-		}];
+		}, issues, nodes);
+		return nodes;
 	}
 	if (!expected.validator && live.validator) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
+		const issue = {
 			kind: "extra_validator",
 			table: collName,
 			message: `Extra validator on collection "${collName}"`
-		});
-		return [{
-			status,
+		};
+		const nodes = [];
+		emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy, issue, {
+			status: strict ? "fail" : "warn",
 			kind: "validator",
 			name: "validator",
 			contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.validator`,
@@ -272,21 +331,23 @@ function diffValidator(collName, live, expected, strict, issues) {
 			expected: null,
 			actual: canonicalize(live.validator.jsonSchema),
 			children: []
-		}];
+		}, issues, nodes);
+		return nodes;
 	}
 	const liveVal = live.validator;
 	const expectedVal = expected.validator;
 	const liveSchema = canonicalize(liveVal.jsonSchema);
 	const expectedSchema = canonicalize(expectedVal.jsonSchema);
 	if (liveSchema !== expectedSchema || liveVal.validationLevel !== expectedVal.validationLevel || liveVal.validationAction !== expectedVal.validationAction) {
-		issues.push({
+		const issue = {
 			kind: "type_mismatch",
 			table: collName,
 			expected: expectedSchema,
 			actual: liveSchema,
 			message: `Validator mismatch on collection "${collName}"`
-		});
-		return [{
+		};
+		const nodes = [];
+		emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy, issue, {
 			status: "fail",
 			kind: "validator",
 			name: "validator",
@@ -304,7 +365,8 @@ function diffValidator(collName, live, expected, strict, issues) {
 				validationAction: liveVal.validationAction
 			},
 			children: []
-		}];
+		}, issues, nodes);
+		return nodes;
 	}
 	return [{
 		status: "pass",
@@ -318,18 +380,18 @@ function diffValidator(collName, live, expected, strict, issues) {
 		children: []
 	}];
 }
-function diffOptions(collName, live, expected, strict, issues) {
+function diffOptions(collName, live, expected, strict, collectionControlPolicy, issues) {
 	if (!live.options && !expected.options) return [];
 	if (!expected.options && live.options) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
+		const issue = {
 			kind: "type_mismatch",
 			table: collName,
 			actual: canonicalize(live.options),
 			message: `Extra collection options on "${collName}"`
-		});
-		return [{
-			status,
+		};
+		const nodes = [];
+		emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy, issue, {
+			status: strict ? "fail" : "warn",
 			kind: "options",
 			name: "options",
 			contractPath: `storage.namespaces.${UNBOUND_NAMESPACE_ID}.collections.${collName}.options`,
@@ -338,7 +400,8 @@ function diffOptions(collName, live, expected, strict, issues) {
 			expected: null,
 			actual: live.options,
 			children: []
-		}];
+		}, issues, nodes);
+		return nodes;
 	}
 	if (deepEqual(live.options, expected.options)) return [{
 		status: "pass",
@@ -351,14 +414,15 @@ function diffOptions(collName, live, expected, strict, issues) {
 		actual: canonicalize(live.options),
 		children: []
 	}];
-	issues.push({
+	const issue = {
 		kind: "type_mismatch",
 		table: collName,
 		expected: canonicalize(expected.options),
 		actual: canonicalize(live.options),
 		message: `Collection options mismatch on "${collName}"`
-	});
-	return [{
+	};
+	const nodes = [];
+	emitMongoIssueAndNodeUnderControlPolicy(collectionControlPolicy, issue, {
 		status: "fail",
 		kind: "options",
 		name: "options",
@@ -368,7 +432,8 @@ function diffOptions(collName, live, expected, strict, issues) {
 		expected: expected.options,
 		actual: live.options,
 		children: []
-	}];
+	}, issues, nodes);
+	return nodes;
 }
 //#endregion
 //#region src/core/schema-verify/canonicalize-introspection.ts
@@ -564,7 +629,7 @@ function verifyMongoSchema(options) {
 	const { contract, schema, strict, context } = options;
 	const startTime = Date.now();
 	const { live: canonicalLive, expected: canonicalExpected } = canonicalizeSchemasForVerification(schema, contractToMongoSchemaIR(contract));
-	const { root, issues, counts } = diffMongoSchemas(canonicalLive, canonicalExpected, strict);
+	const { root, issues, counts } = diffMongoSchemas(canonicalLive, canonicalExpected, strict, resolveMongoCollectionControlPolicy(contract));
 	const ok = counts.fail === 0;
 	const profileHash = typeof contract.profileHash === "string" ? contract.profileHash : "";
 	return {
@@ -589,7 +654,12 @@ function verifyMongoSchema(options) {
 		timings: { total: Date.now() - startTime }
 	};
 }
+function resolveMongoCollectionControlPolicy(contract) {
+	const collections = contract.storage.namespaces[UNBOUND_NAMESPACE_ID]?.collections ?? {};
+	const defaultControl = contract.defaultControl;
+	return (collectionName) => effectiveControlPolicy(collections[collectionName]?.control, defaultControl);
+}
 //#endregion
 export { contractToMongoSchemaIR as i, canonicalizeSchemasForVerification as n, diffMongoSchemas as r, verifyMongoSchema as t };
 
-//# sourceMappingURL=verify-mongo-schema-Bhxvdah3.mjs.map
+//# sourceMappingURL=verify-mongo-schema-BXJqoE59.mjs.map