@prisma-next/target-mongo 0.7.0 → 0.8.0-dev.1

package/src/core/mongo-target-schema-verifier.ts

@@ -0,0 +1,54 @@
+import {
+  canonicalizeSchemasForVerification,
+  contractToMongoSchemaIR,
+  diffMongoSchemas,
+} from '@prisma-next/family-mongo/control';
+import { MongoSchemaVerifierBase } from '@prisma-next/family-mongo/ir';
+import type { SchemaIssue, SchemaVerifyOptions } from '@prisma-next/framework-components/control';
+import type { Namespace } from '@prisma-next/framework-components/ir';
+import type { MongoSchemaIR } from '@prisma-next/mongo-schema-ir';
+import type { MongoTargetContract } from './mongo-target-contract';
+
+/**
+ * Mongo target `SchemaVerifier` concretion. Extends the family base's
+ * namespace-walk scaffolding and contributes the per-namespace diff via
+ * `verifyNamespace`; the diff body reuses the existing target-side
+ * helpers (`contractToMongoSchemaIR`, `canonicalizeSchemasForVerification`,
+ * `diffMongoSchemas`) so production verification behaviour is unchanged.
+ *
+ * Today's invariant: every Mongo contract carries exactly one
+ * namespace (the unspecified singleton, materialised as
+ * `MongoTargetUnspecifiedDatabase`), so the family-base namespace walk
+ * dispatches exactly once and the per-namespace body runs the existing
+ * whole-schema diff. Future per-collection namespace assignment will
+ * have this hook project the diff to the namespace's owned collections.
+ *
+ * `verifyTargetExtensions` returns the empty list — Mongo has no
+ * target-only kinds today.
+ *
+ * Strict diff mode is `false` for SPI-routed calls; production
+ * verification today still goes through `verifyMongoSchema` which
+ * receives strict from the CLI.
+ */
+export class MongoTargetSchemaVerifier extends MongoSchemaVerifierBase<
+  MongoTargetContract,
+  MongoSchemaIR
+> {
+  protected verifyNamespace(options: {
+    readonly contract: MongoTargetContract;
+    readonly schema: MongoSchemaIR;
+    readonly namespaceId: string;
+    readonly namespace: Namespace;
+  }): readonly SchemaIssue[] {
+    const expectedIR = contractToMongoSchemaIR(options.contract);
+    const { live, expected } = canonicalizeSchemasForVerification(options.schema, expectedIR);
+    const { issues } = diffMongoSchemas(live, expected, false);
+    return issues;
+  }
+
+  protected verifyTargetExtensions(
+    _options: SchemaVerifyOptions<MongoTargetContract, MongoSchemaIR>,
+  ): readonly SchemaIssue[] {
+    return [];
+  }
+}

package/src/exports/control.ts

@@ -1,13 +1,5 @@
-export { contractToMongoSchemaIR } from '../core/contract-to-schema';
-export { formatMongoOperations } from '../core/ddl-formatter';
+export { mongoTargetDescriptor } from '../core/control-target';
 export { FilterEvaluator } from '../core/filter-evaluator';
-export {
-  initMarker,
-  readAllMarkers,
-  readMarker,
-  updateMarker,
-  writeLedgerEntry,
-} from '../core/marker-ledger';
 export {
   deserializeMongoOp,
   deserializeMongoOps,
@@ -20,6 +12,13 @@ export {
   MongoMigrationRunner,
   type MongoMigrationRunnerExecuteOptions,
 } from '../core/mongo-runner';
+export type { MongoTargetContract } from '../core/mongo-target-contract';
+export { MongoTargetContractSerializer } from '../core/mongo-target-contract-serializer';
+export {
+  MongoTargetDatabase,
+  MongoTargetUnspecifiedDatabase,
+} from '../core/mongo-target-database';
+export { MongoTargetSchemaVerifier } from '../core/mongo-target-schema-verifier';
 export type { CollModMeta, OpFactoryCall } from '../core/op-factory-call';
 export {
   CollModCall,

package/dist/schema-verify.d.mts

@@ -1,22 +0,0 @@
-import { MongoSchemaIR } from "@prisma-next/mongo-schema-ir";
-import { OperationContext, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
-import { MongoContract } from "@prisma-next/mongo-contract";
-import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
-
-//#region src/core/schema-verify/verify-mongo-schema.d.ts
-interface VerifyMongoSchemaOptions {
-  readonly contract: MongoContract;
-  readonly schema: MongoSchemaIR;
-  readonly strict: boolean;
-  readonly context?: OperationContext;
-  /**
-   * Active framework components participating in this composition. Mongo
-   * verification does not currently consult them, but the parameter exists
-   * for parity with `verifySqlSchema` so callers can pass the same envelope.
-   */
-  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'mongo', string>>;
-}
-declare function verifyMongoSchema(options: VerifyMongoSchemaOptions): VerifyDatabaseSchemaResult;
-//#endregion
-export { type VerifyMongoSchemaOptions, verifyMongoSchema };
-//# sourceMappingURL=schema-verify.d.mts.map

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

@@ -1 +0,0 @@
-{"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,0BAAA"}

package/dist/schema-verify.mjs

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

package/dist/verify-mongo-schema-DlPXaotB.mjs

@@ -1,578 +0,0 @@
-import { MongoSchemaCollection, MongoSchemaCollectionOptions, MongoSchemaIR, MongoSchemaIndex, MongoSchemaValidator, canonicalize, deepEqual } from "@prisma-next/mongo-schema-ir";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { VERIFY_CODE_SCHEMA_FAILURE } from "@prisma-next/framework-components/control";
-//#region src/core/contract-to-schema.ts
-function convertIndex(index) {
-	return new MongoSchemaIndex({
-		keys: index.keys,
-		unique: index.unique,
-		sparse: index.sparse,
-		expireAfterSeconds: index.expireAfterSeconds,
-		partialFilterExpression: index.partialFilterExpression,
-		wildcardProjection: index.wildcardProjection,
-		collation: index.collation,
-		weights: index.weights,
-		default_language: index.default_language,
-		language_override: index.language_override
-	});
-}
-function convertValidator(v) {
-	return new MongoSchemaValidator({
-		jsonSchema: v.jsonSchema,
-		validationLevel: v.validationLevel,
-		validationAction: v.validationAction
-	});
-}
-function convertOptions(o) {
-	return new MongoSchemaCollectionOptions(o);
-}
-function convertCollection(name, def) {
-	return new MongoSchemaCollection({
-		name,
-		indexes: (def.indexes ?? []).map(convertIndex),
-		...def.validator != null && { validator: convertValidator(def.validator) },
-		...def.options != null && { options: convertOptions(def.options) }
-	});
-}
-function contractToMongoSchemaIR(contract) {
-	if (!contract) return new MongoSchemaIR([]);
-	return new MongoSchemaIR(Object.entries(contract.storage.collections).map(([name, def]) => convertCollection(name, def)));
-}
-//#endregion
-//#region src/core/schema-diff.ts
-function diffMongoSchemas(live, expected, strict) {
-	const issues = [];
-	const collectionChildren = [];
-	let pass = 0;
-	let warn = 0;
-	let fail = 0;
-	const allNames = new Set([...live.collectionNames, ...expected.collectionNames]);
-	for (const name of [...allNames].sort()) {
-		const liveColl = live.collection(name);
-		const expectedColl = expected.collection(name);
-		if (!liveColl && expectedColl) {
-			issues.push({
-				kind: "missing_table",
-				table: name,
-				message: `Collection "${name}" is missing from the database`
-			});
-			collectionChildren.push({
-				status: "fail",
-				kind: "collection",
-				name,
-				contractPath: `storage.collections.${name}`,
-				code: "MISSING_COLLECTION",
-				message: `Collection "${name}" is missing`,
-				expected: name,
-				actual: null,
-				children: []
-			});
-			fail++;
-			continue;
-		}
-		if (liveColl && !expectedColl) {
-			const status = strict ? "fail" : "warn";
-			issues.push({
-				kind: "extra_table",
-				table: name,
-				message: `Extra collection "${name}" exists in the database but not in the contract`
-			});
-			collectionChildren.push({
-				status,
-				kind: "collection",
-				name,
-				contractPath: `storage.collections.${name}`,
-				code: "EXTRA_COLLECTION",
-				message: `Extra collection "${name}" found`,
-				expected: null,
-				actual: name,
-				children: []
-			});
-			if (status === "fail") fail++;
-			else 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 children = [
-			...indexChildren,
-			...validatorChildren,
-			...optionsChildren
-		];
-		const worstStatus = children.reduce((s, c) => c.status === "fail" ? "fail" : c.status === "warn" && s !== "fail" ? "warn" : s, "pass");
-		for (const c of children) if (c.status === "pass") pass++;
-		else if (c.status === "warn") warn++;
-		else fail++;
-		if (children.length === 0) pass++;
-		collectionChildren.push({
-			status: worstStatus,
-			kind: "collection",
-			name,
-			contractPath: `storage.collections.${name}`,
-			code: worstStatus === "pass" ? "MATCH" : "DRIFT",
-			message: worstStatus === "pass" ? `Collection "${name}" matches` : `Collection "${name}" has drift`,
-			expected: name,
-			actual: name,
-			children
-		});
-	}
-	const rootStatus = fail > 0 ? "fail" : warn > 0 ? "warn" : "pass";
-	const totalNodes = pass + warn + fail + collectionChildren.length;
-	return {
-		root: {
-			status: rootStatus,
-			kind: "root",
-			name: "mongo-schema",
-			contractPath: "storage",
-			code: rootStatus === "pass" ? "MATCH" : "DRIFT",
-			message: rootStatus === "pass" ? "Schema matches" : "Schema has drift",
-			expected: null,
-			actual: null,
-			children: collectionChildren
-		},
-		issues,
-		counts: {
-			pass,
-			warn,
-			fail,
-			totalNodes
-		}
-	};
-}
-function buildIndexLookupKey(index) {
-	const keys = index.keys.map((k) => `${k.field}:${k.direction}`).join(",");
-	const opts = [
-		index.unique ? "unique" : "",
-		index.sparse ? "sparse" : "",
-		index.expireAfterSeconds != null ? `ttl:${index.expireAfterSeconds}` : "",
-		index.partialFilterExpression ? `pfe:${canonicalize(index.partialFilterExpression)}` : "",
-		index.wildcardProjection ? `wp:${canonicalize(index.wildcardProjection)}` : "",
-		index.collation ? `col:${canonicalize(index.collation)}` : "",
-		index.weights ? `wt:${canonicalize(index.weights)}` : "",
-		index.default_language ? `dl:${index.default_language}` : "",
-		index.language_override ? `lo:${index.language_override}` : ""
-	].filter(Boolean).join(";");
-	return opts ? `${keys}|${opts}` : keys;
-}
-function formatIndexName(index) {
-	return index.keys.map((k) => `${k.field}:${k.direction}`).join(", ");
-}
-function diffIndexes(collName, live, expected, strict, issues) {
-	const nodes = [];
-	const liveLookup = /* @__PURE__ */ new Map();
-	for (const idx of live.indexes) liveLookup.set(buildIndexLookupKey(idx), idx);
-	const expectedLookup = /* @__PURE__ */ new Map();
-	for (const idx of expected.indexes) expectedLookup.set(buildIndexLookupKey(idx), idx);
-	for (const [key, idx] of expectedLookup) if (liveLookup.has(key)) nodes.push({
-		status: "pass",
-		kind: "index",
-		name: formatIndexName(idx),
-		contractPath: `storage.collections.${collName}.indexes`,
-		code: "MATCH",
-		message: `Index ${formatIndexName(idx)} matches`,
-		expected: key,
-		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.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.collections.${collName}.indexes`,
-			code: "EXTRA_INDEX",
-			message: `Extra index ${formatIndexName(idx)}`,
-			expected: null,
-			actual: key,
-			children: []
-		});
-	}
-	return nodes;
-}
-function diffValidator(collName, live, expected, strict, issues) {
-	if (!live.validator && !expected.validator) return [];
-	if (expected.validator && !live.validator) {
-		issues.push({
-			kind: "type_missing",
-			table: collName,
-			message: `Validator missing on collection "${collName}"`
-		});
-		return [{
-			status: "fail",
-			kind: "validator",
-			name: "validator",
-			contractPath: `storage.collections.${collName}.validator`,
-			code: "MISSING_VALIDATOR",
-			message: "Validator missing",
-			expected: canonicalize(expected.validator.jsonSchema),
-			actual: null,
-			children: []
-		}];
-	}
-	if (!expected.validator && live.validator) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
-			kind: "extra_validator",
-			table: collName,
-			message: `Extra validator on collection "${collName}"`
-		});
-		return [{
-			status,
-			kind: "validator",
-			name: "validator",
-			contractPath: `storage.collections.${collName}.validator`,
-			code: "EXTRA_VALIDATOR",
-			message: "Extra validator found",
-			expected: null,
-			actual: canonicalize(live.validator.jsonSchema),
-			children: []
-		}];
-	}
-	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({
-			kind: "type_mismatch",
-			table: collName,
-			expected: expectedSchema,
-			actual: liveSchema,
-			message: `Validator mismatch on collection "${collName}"`
-		});
-		return [{
-			status: "fail",
-			kind: "validator",
-			name: "validator",
-			contractPath: `storage.collections.${collName}.validator`,
-			code: "VALIDATOR_MISMATCH",
-			message: "Validator mismatch",
-			expected: {
-				jsonSchema: expectedVal.jsonSchema,
-				validationLevel: expectedVal.validationLevel,
-				validationAction: expectedVal.validationAction
-			},
-			actual: {
-				jsonSchema: liveVal.jsonSchema,
-				validationLevel: liveVal.validationLevel,
-				validationAction: liveVal.validationAction
-			},
-			children: []
-		}];
-	}
-	return [{
-		status: "pass",
-		kind: "validator",
-		name: "validator",
-		contractPath: `storage.collections.${collName}.validator`,
-		code: "MATCH",
-		message: "Validator matches",
-		expected: expectedSchema,
-		actual: liveSchema,
-		children: []
-	}];
-}
-function diffOptions(collName, live, expected, strict, issues) {
-	if (!live.options && !expected.options) return [];
-	if (!expected.options && live.options) {
-		const status = strict ? "fail" : "warn";
-		issues.push({
-			kind: "type_mismatch",
-			table: collName,
-			actual: canonicalize(live.options),
-			message: `Extra collection options on "${collName}"`
-		});
-		return [{
-			status,
-			kind: "options",
-			name: "options",
-			contractPath: `storage.collections.${collName}.options`,
-			code: "EXTRA_OPTIONS",
-			message: "Extra collection options found",
-			expected: null,
-			actual: live.options,
-			children: []
-		}];
-	}
-	if (deepEqual(live.options, expected.options)) return [{
-		status: "pass",
-		kind: "options",
-		name: "options",
-		contractPath: `storage.collections.${collName}.options`,
-		code: "MATCH",
-		message: "Collection options match",
-		expected: canonicalize(expected.options),
-		actual: canonicalize(live.options),
-		children: []
-	}];
-	issues.push({
-		kind: "type_mismatch",
-		table: collName,
-		expected: canonicalize(expected.options),
-		actual: canonicalize(live.options),
-		message: `Collection options mismatch on "${collName}"`
-	});
-	return [{
-		status: "fail",
-		kind: "options",
-		name: "options",
-		contractPath: `storage.collections.${collName}.options`,
-		code: "OPTIONS_MISMATCH",
-		message: "Collection options mismatch",
-		expected: expected.options,
-		actual: live.options,
-		children: []
-	}];
-}
-//#endregion
-//#region src/core/schema-verify/canonicalize-introspection.ts
-function canonicalizeSchemasForVerification(live, expected) {
-	const expectedByName = /* @__PURE__ */ new Map();
-	for (const c of expected.collections) expectedByName.set(c.name, c);
-	const liveByName = /* @__PURE__ */ new Map();
-	for (const c of live.collections) liveByName.set(c.name, c);
-	const canonicalLive = live.collections.map((c) => canonicalizeLiveCollection(c, expectedByName.get(c.name)));
-	const canonicalExpected = expected.collections.map((c) => canonicalizeExpectedCollection(c, liveByName.get(c.name)));
-	return {
-		live: new MongoSchemaIR(canonicalLive),
-		expected: new MongoSchemaIR(canonicalExpected)
-	};
-}
-function canonicalizeLiveCollection(liveColl, expectedColl) {
-	const expectedIndexes = expectedColl?.indexes ?? [];
-	const indexes = liveColl.indexes.map((idx) => canonicalizeLiveIndex(idx, findExpectedIndexCounterpart(idx, expectedIndexes)));
-	const options = liveColl.options ? canonicalizeLiveOptions(liveColl.options, expectedColl?.options) : void 0;
-	return new MongoSchemaCollection({
-		name: liveColl.name,
-		indexes,
-		...ifDefined("validator", liveColl.validator),
-		...ifDefined("options", options)
-	});
-}
-function canonicalizeExpectedCollection(expectedColl, liveColl) {
-	const indexes = expectedColl.indexes.map(canonicalizeTextIndexKeyOrder);
-	const options = expectedColl.options ? canonicalizeExpectedOptions(expectedColl.options, liveColl?.options) : void 0;
-	return new MongoSchemaCollection({
-		name: expectedColl.name,
-		indexes,
-		...ifDefined("validator", expectedColl.validator),
-		...ifDefined("options", options)
-	});
-}
-function canonicalizeTextIndexKeyOrder(index) {
-	if (!index.keys.some((k) => k.direction === "text")) return index;
-	return new MongoSchemaIndex({
-		keys: sortTextKeys(index.keys),
-		unique: index.unique,
-		...ifDefined("sparse", index.sparse),
-		...ifDefined("expireAfterSeconds", index.expireAfterSeconds),
-		...ifDefined("partialFilterExpression", index.partialFilterExpression),
-		...ifDefined("wildcardProjection", index.wildcardProjection),
-		...ifDefined("collation", index.collation),
-		...ifDefined("weights", index.weights),
-		...ifDefined("default_language", index.default_language),
-		...ifDefined("language_override", index.language_override)
-	});
-}
-/**
-* Returns a copy of `keys` with text-direction entries sorted alphabetically
-* while preserving the relative position of non-text entries. Compound text
-* indexes (`{a: 1, _fts: 'text', _ftsx: 1, b: 1}`) keep their scalar
-* prefix/suffix layout; only the contiguous text block is reordered.
-*/
-function sortTextKeys(keys) {
-	const textEntries = keys.filter((k) => k.direction === "text");
-	if (textEntries.length <= 1) return keys;
-	const sortedText = [...textEntries].sort((a, b) => a.field.localeCompare(b.field));
-	let textIdx = 0;
-	return keys.map((k) => {
-		if (k.direction !== "text") return k;
-		const next = sortedText[textIdx++];
-		/* v8 ignore next 3 -- @preserve invariant guard: textIdx is always < sortedText.length here because we only consume sortedText for text-direction entries and sortedText is built from the same filter. */
-		if (next === void 0) throw new Error("sortTextKeys: text-key counts mismatched");
-		return next;
-	});
-}
-function canonicalizeLiveIndex(liveIndex, expectedIndex) {
-	const projectedKeys = sortTextKeys(projectTextIndexKeys(liveIndex));
-	const collation = liveIndex.collation ? stripUnspecifiedFields(liveIndex.collation, expectedIndex?.collation) : liveIndex.collation;
-	const weights = expectedIndex?.weights === void 0 && hasDefaultTextWeights(projectedKeys, liveIndex.weights) ? void 0 : liveIndex.weights;
-	const default_language = expectedIndex?.default_language === void 0 && liveIndex.default_language === "english" ? void 0 : liveIndex.default_language;
-	const language_override = expectedIndex?.language_override === void 0 && liveIndex.language_override === "language" ? void 0 : liveIndex.language_override;
-	return new MongoSchemaIndex({
-		keys: projectedKeys,
-		unique: liveIndex.unique,
-		...ifDefined("sparse", liveIndex.sparse),
-		...ifDefined("expireAfterSeconds", liveIndex.expireAfterSeconds),
-		...ifDefined("partialFilterExpression", liveIndex.partialFilterExpression),
-		...ifDefined("wildcardProjection", liveIndex.wildcardProjection),
-		...ifDefined("collation", collation),
-		...ifDefined("weights", weights),
-		...ifDefined("default_language", default_language),
-		...ifDefined("language_override", language_override)
-	});
-}
-/**
-* Locate the contract-side index that corresponds to a live index for the
-* purpose of contract-aware normalization. We deliberately match by the
-* *projected* (contract-shaped) key list — so a live `_fts/_ftsx` index
-* resolves to a contract `{title: 'text', body: 'text'}` index — and pick
-* the first match. Contracts very rarely contain duplicate-key indexes; if
-* we have no counterpart we fall back to no normalization for that index.
-*/
-function findExpectedIndexCounterpart(liveIndex, expectedIndexes) {
-	const liveKeySig = sortTextKeys(projectTextIndexKeys(liveIndex)).map((k) => `${k.field}:${k.direction}`).join(",");
-	for (const expected of expectedIndexes) if (sortTextKeys(expected.keys).map((k) => `${k.field}:${k.direction}`).join(",") === liveKeySig) return expected;
-}
-/**
-* MongoDB expands a contract-shaped text index like
-* `[{title: 'text'}, {body: 'text'}]` into its internal weighted vector
-* representation `[{_fts: 'text'}, {_ftsx: 1}]`. We project back to
-* contract-shaped keys via `weights`, iterating in whatever order MongoDB
-* returns them (alphabetical, in practice). `sortTextKeys` is applied
-* downstream to canonicalize the order on both sides, so this projection
-* does not depend on a specific iteration order.
-*/
-function projectTextIndexKeys(liveIndex) {
-	if (!(liveIndex.keys.length >= 1 && liveIndex.keys.some((k) => k.field === "_fts" && k.direction === "text")) || !liveIndex.weights) return liveIndex.keys;
-	const textKeys = Object.keys(liveIndex.weights).map((field) => ({
-		field,
-		direction: "text"
-	}));
-	const projectedKeys = [];
-	for (const key of liveIndex.keys) {
-		if (key.field === "_ftsx") continue;
-		if (key.field === "_fts") {
-			projectedKeys.push(...textKeys);
-			continue;
-		}
-		projectedKeys.push(key);
-	}
-	return projectedKeys;
-}
-/**
-* MongoDB's server-default `weights` for an authored-without-weights text
-* index assigns `1` to every text-direction field. Returns `true` only when
-* `liveWeights` is exactly that uniform shape (every projected text-direction
-* key weighted at `1`) so the canonicalizer leaves non-default weights —
-* including out-of-band relevance tweaks — visible to the verifier.
-*
-* `projectTextIndexKeys` derives text-direction keys from the live weights
-* map, so the count is guaranteed to match; we only have to check the value
-* shape.
-*/
-function hasDefaultTextWeights(projectedKeys, liveWeights) {
-	if (liveWeights === void 0) return false;
-	return projectedKeys.filter((k) => k.direction === "text").map((k) => k.field).every((field) => liveWeights[field] === 1);
-}
-function canonicalizeLiveOptions(liveOptions, expectedOptions) {
-	const collation = liveOptions.collation ? stripUnspecifiedFields(liveOptions.collation, expectedOptions?.collation) : void 0;
-	const timeseries = liveOptions.timeseries ? stripUnspecifiedFields(liveOptions.timeseries, expectedOptions?.timeseries) : void 0;
-	const clusteredIndex = liveOptions.clusteredIndex ? stripUnspecifiedFields(liveOptions.clusteredIndex, expectedOptions?.clusteredIndex) : void 0;
-	const changeStreamPreAndPostImages = isDisabledChangeStream(liveOptions.changeStreamPreAndPostImages) ? void 0 : liveOptions.changeStreamPreAndPostImages;
-	if (!(liveOptions.capped || timeseries || collation || changeStreamPreAndPostImages || clusteredIndex)) return void 0;
-	return new MongoSchemaCollectionOptions({
-		...ifDefined("capped", liveOptions.capped),
-		...ifDefined("timeseries", timeseries),
-		...ifDefined("collation", collation),
-		...ifDefined("changeStreamPreAndPostImages", changeStreamPreAndPostImages),
-		...ifDefined("clusteredIndex", clusteredIndex)
-	});
-}
-function canonicalizeExpectedOptions(expectedOptions, _liveOptions) {
-	const changeStreamPreAndPostImages = isDisabledChangeStream(expectedOptions.changeStreamPreAndPostImages) ? void 0 : expectedOptions.changeStreamPreAndPostImages;
-	if (!(expectedOptions.capped || expectedOptions.timeseries || expectedOptions.collation || changeStreamPreAndPostImages || expectedOptions.clusteredIndex)) return void 0;
-	return new MongoSchemaCollectionOptions({
-		...ifDefined("capped", expectedOptions.capped),
-		...ifDefined("timeseries", expectedOptions.timeseries),
-		...ifDefined("collation", expectedOptions.collation),
-		...ifDefined("changeStreamPreAndPostImages", changeStreamPreAndPostImages),
-		...ifDefined("clusteredIndex", expectedOptions.clusteredIndex)
-	});
-}
-function isDisabledChangeStream(value) {
-	return value !== void 0 && value.enabled === false;
-}
-/**
-* Returns a copy of `live` containing only the keys that `expected` defines.
-* Used for option families whose individual sub-fields are server-extended
-* with platform defaults (collation, timeseries, clusteredIndex), so the
-* verifier should compare only what the contract actually authored.
-*
-* When `expected` is `undefined` — i.e. the contract authored nothing for
-* this whole option family but the live IR has it — we return `live`
-* unchanged so the verifier still sees the entire live block and can
-* surface it as drift. (Returning `undefined` here would silently strip a
-* server-attached collation/timeseries/clusteredIndex that the contract
-* never asked for, hiding real drift.)
-*/
-function stripUnspecifiedFields(live, expected) {
-	if (expected === void 0) return live;
-	const out = {};
-	for (const key of Object.keys(expected)) if (Object.hasOwn(live, key)) out[key] = live[key];
-	return out;
-}
-//#endregion
-//#region src/core/schema-verify/verify-mongo-schema.ts
-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 ok = counts.fail === 0;
-	const profileHash = typeof contract.profileHash === "string" ? contract.profileHash : "";
-	return {
-		ok,
-		...ifDefined("code", ok ? void 0 : VERIFY_CODE_SCHEMA_FAILURE),
-		summary: ok ? "Schema matches contract" : `Schema verification found ${counts.fail} issue(s)`,
-		contract: {
-			storageHash: contract.storage.storageHash,
-			...profileHash ? { profileHash } : {}
-		},
-		target: { expected: contract.target },
-		schema: {
-			issues,
-			root,
-			counts
-		},
-		meta: {
-			strict,
-			...ifDefined("contractPath", context?.contractPath),
-			...ifDefined("configPath", context?.configPath)
-		},
-		timings: { total: Date.now() - startTime }
-	};
-}
-//#endregion
-export { contractToMongoSchemaIR as n, verifyMongoSchema as t };
-
-//# sourceMappingURL=verify-mongo-schema-DlPXaotB.mjs.map