@prisma-next/family-sql 0.5.0-dev.67 → 0.5.0-dev.68

package/dist/control-adapter.d.mts

@@ -28,6 +28,14 @@ interface SqlControlAdapter<TTarget extends string = string> extends ControlAdap
    * @returns Resolved marker record, or `null` if not yet stamped.
    */
   readMarker(driver: ControlDriverInstance<'sql', TTarget>, space: string): Promise<ContractMarkerRecord | null>;
+  /**
+   * Reads every marker row from `prisma_contract.marker` (one per
+   * contract space) and returns them keyed by `space`. Used by the
+   * per-space verifier to detect marker-vs-on-disk drift and orphan
+   * marker rows. Returns an empty map when the marker table does not
+   * yet exist (fresh database / never-signed project).
+   */
+  readAllMarkers(driver: ControlDriverInstance<'sql', TTarget>): Promise<ReadonlyMap<string, ContractMarkerRecord>>;
   /**
    * Introspects a database schema and returns a raw SqlSchemaIR.
    *

package/dist/control-adapter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control-adapter.d.mts","names":[],"sources":["../src/core/control-adapter.ts"],"mappings":";;;;;;;;;AAoBA;;;;UAAiB,iBAAA,0CACP,sBAAA,QAA8B,OAAA;EAiB5B;;;;;;;;;;;;;;;EADV,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,KAAA,WACC,OAAA,CAAQ,oBAAA;EAnBH;;;;;;;;;;;;EAiCR,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,WAAA;EAFT;;;;;EAAA,SASO,gBAAA,GAAmB,iBAAA;EAOnB;;;;;EAAA,SAAA,mBAAA,GAAsB,oBAAA;EAWP;;;;AAS1B;;;;;EATE,KAAA,CAAM,GAAA,EAAK,WAAA,EAAa,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;;;;;;;UAS5C,2BAAA;EAO8B;;;;;;EAA7C,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}
+{"version":3,"file":"control-adapter.d.mts","names":[],"sources":["../src/core/control-adapter.ts"],"mappings":";;;;;;;;;AAoBA;;;;UAAiB,iBAAA,0CACP,sBAAA,QAA8B,OAAA;EAiB5B;;;;;;;;;;;;;;;EADV,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,KAAA,WACC,OAAA,CAAQ,oBAAA;EAsDgD;;;;;;;EA7C3D,cAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,IACpC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EAbrB;;;;;;;;;;;;EA2BV,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,WAAA;EAJX;;;;;EAAA,SAWS,gBAAA,GAAmB,iBAAA;EAPzB;;;;;EAAA,SAcM,mBAAA,GAAsB,oBAAA;EAW/B;;;;;;;;AASF;EATE,KAAA,CAAM,GAAA,EAAK,WAAA,EAAa,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;;;;;;;UAS5C,2BAAA;EAOf;;;;;;EAAA,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}

package/dist/control.d.mts

@@ -1,4 +1,4 @@
-import { A as SqlPlannerResult, C as SqlMigrationRunnerResult, D as SqlPlannerConflictKind, E as SqlPlannerConflict, F as SchemaVerifyOptions, I as SqlControlFamilyInstance, M as StorageTypePlanResult, N as collectInitDependencies, O as SqlPlannerConflictLocation, P as isDatabaseDependencyProvider, S as SqlMigrationRunnerFailure, T as SqlPlanTargetDetails, _ as SqlMigrationPlannerPlanOptions, a as CreateSqlMigrationPlanOptions, b as SqlMigrationRunnerExecuteCallbacks, c as SqlControlAdapterDescriptor, d as SqlMigrationPlan, f as SqlMigrationPlanContractInfo, g as SqlMigrationPlanner, h as SqlMigrationPlanOperationTarget, i as ComponentDatabaseDependency, j as SqlPlannerSuccessResult, k as SqlPlannerFailureResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationStep, n as CodecControlHooks, o as ExpandNativeTypeInput, p as SqlMigrationPlanOperation, r as ComponentDatabaseDependencies, s as ResolveIdentityValueInput, t as AnyRecord, u as SqlControlTargetDescriptor, v as SqlMigrationRunner, w as SqlMigrationRunnerSuccessValue, x as SqlMigrationRunnerExecuteOptions, y as SqlMigrationRunnerErrorCode } from "./types-Ds4dJyTI.mjs";
+import { A as SqlPlanTargetDetails, B as SchemaVerifyOptions, C as SqlMigrationRunner, D as SqlMigrationRunnerFailure, E as SqlMigrationRunnerExecuteOptions, F as SqlPlannerResult, I as SqlPlannerSuccessResult, L as StorageTypePlanResult, M as SqlPlannerConflictKind, N as SqlPlannerConflictLocation, O as SqlMigrationRunnerResult, P as SqlPlannerFailureResult, R as collectInitDependencies, S as SqlMigrationPlannerPlanOptions, T as SqlMigrationRunnerExecuteCallbacks, V as SqlControlFamilyInstance, _ as SqlMigrationPlanContractInfo, a as CreateSqlMigrationPlanOptions, b as SqlMigrationPlanOperationTarget, c as FieldEventContext, d as MultiSpaceRunnerSuccessValue, f as ResolveIdentityValueInput, g as SqlMigrationPlan, h as SqlControlTargetDescriptor, i as ComponentDatabaseDependency, j as SqlPlannerConflict, k as SqlMigrationRunnerSuccessValue, l as MultiSpaceRunnerFailure, m as SqlControlExtensionDescriptor, n as CodecControlHooks, o as ExpandNativeTypeInput, p as SqlControlAdapterDescriptor, r as ComponentDatabaseDependencies, s as FieldEvent, t as AnyRecord, u as MultiSpaceRunnerResult, v as SqlMigrationPlanOperation, w as SqlMigrationRunnerErrorCode, x as SqlMigrationPlanner, y as SqlMigrationPlanOperationStep, z as isDatabaseDependencyProvider } from "./types-CIdiS2QK.mjs";
 import { ControlFamilyDescriptor, ControlStack, MigrationOperationClass, MigrationOperationPolicy, MigrationOperationPolicy as MigrationOperationPolicy$1, MigrationPlan, MigrationPlanOperation, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerConflict as MigrationPlannerConflict$1, MigrationPlannerResult, MutationDefaultGeneratorDescriptor, TargetMigrationsCapability, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
 import { NotOk, Ok } from "@prisma-next/utils/result";
 import { ColumnDefault, Contract } from "@prisma-next/contract/types";
@@ -304,6 +304,30 @@ interface ContractToSchemaIROptions {
  */
 declare function contractToSchemaIR(contract: Contract<SqlStorage> | null, options: ContractToSchemaIROptions): SqlSchemaIR;
 //#endregion
+//#region src/core/migrations/field-event-planner.d.ts
+interface PlanFieldEventOperationsOptions {
+  /**
+   * Prior contract the planner is diffing against. `null` for first emits
+   * (every field is treated as added).
+   */
+  readonly priorContract: Contract<SqlStorage> | null;
+  /**
+   * New contract the user just authored.
+   */
+  readonly newContract: Contract<SqlStorage>;
+  /**
+   * Codec-id keyed map of control hooks, as produced by
+   * {@link import('./assembly').extractCodecControlHooks}. Hooks carry
+   * `unknown` target details after extraction; the caller casts the
+   * helper's returned ops to its target's `SqlMigrationPlanOperation`
+   * specialisation at the integration boundary, mirroring how
+   * `storageTypePlanCallStrategy` lifts `planTypeOperations` results into
+   * `RawSqlCall`.
+   */
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+declare function planFieldEventOperations(options: PlanFieldEventOperationsOptions): readonly SqlMigrationPlanOperation<unknown>[];
+//#endregion
 //#region src/core/migrations/plan-helpers.d.ts
 declare function createMigrationPlan<TTargetDetails>(options: CreateSqlMigrationPlanOptions<TTargetDetails>): SqlMigrationPlan<TTargetDetails>;
 declare function plannerSuccess<TTargetDetails>(plan: SqlMigrationPlan<TTargetDetails>): SqlPlannerSuccessResult<TTargetDetails>;
@@ -389,5 +413,5 @@ declare function temporalAuthoringPresets<const CodecId extends string, const Na
 //#region src/exports/control.d.ts
 declare const _default: SqlFamilyDescriptor;
 //#endregion
-export { type CodecControlHooks, type ComponentDatabaseDependencies, type ComponentDatabaseDependency, type ContractToSchemaIROptions, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type ExpandNativeTypeInput, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type NativeTypeExpander, type ResolveIdentityValueInput, type SchemaVerifyOptions, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type StorageTypePlanResult, type TargetMigrationsCapability, assembleAuthoringContributions, collectInitDependencies, contractToSchemaIR, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, isDatabaseDependencyProvider, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { type CodecControlHooks, type ComponentDatabaseDependencies, type ComponentDatabaseDependency, type ContractToSchemaIROptions, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type MultiSpaceRunnerFailure, type MultiSpaceRunnerResult, type MultiSpaceRunnerSuccessValue, type NativeTypeExpander, type PlanFieldEventOperationsOptions, type ResolveIdentityValueInput, type SchemaVerifyOptions, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type StorageTypePlanResult, type TargetMigrationsCapability, assembleAuthoringContributions, collectInitDependencies, contractToSchemaIR, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, isDatabaseDependencyProvider, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 //# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-descriptor.ts","../src/core/assembly.ts","../src/core/migrations/contract-to-schema-ir.ts","../src/core/migrations/plan-helpers.ts","../src/core/migrations/policies.ts","../src/core/timestamp-now-generator.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;cAUa,mBAAA,YACA,uBAAA,QAA+B,wBAAA;EAAA,SAEjC,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,EAAU,WAAA;EAAA,SACV,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKT,MAAA,0BAAA,CACE,KAAA,EAAO,YAAA,QAAoB,SAAA,IAC1B,wBAAA;AAAA;;;iBCHW,wBAAA,CACd,WAAA,EAAa,aAAA,CAAc,8BAAA,mBAC1B,GAAA,SAAY,iBAAA;;;;;;;;ADdf;;;;;KE0BY,kBAAA,IAAsB,KAAA;EAAA,SACvB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;;;;;;;;KAYZ,eAAA,IAAmB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAA;;;;;;;;;;iBAuI3C,wBAAA,CACd,IAAA,EAAM,UAAA,SACN,EAAA,EAAI,UAAA,YACM,0BAAA;AAAA,UAiCK,yBAAA;EAAA,SACN,mBAAA;EAAA,SACA,gBAAA,GAAmB,kBAAA;EAAA,SACnB,aAAA,GAAgB,eAAA;EAAA,SAChB,mBAAA,GAAsB,aAAA,CAAc,8BAAA;AAAA;;;;;;;;;;;;;;;;iBAkB/B,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,UACnB,OAAA,EAAS,yBAAA,GACR,WAAA;;;iBCxJa,mBAAA,gBAAA,CACd,OAAA,EAAS,6BAAA,CAA8B,cAAA,IACtC,gBAAA,CAAiB,cAAA;AAAA,iBAcJ,cAAA,gBAAA,CACd,IAAA,EAAM,gBAAA,CAAiB,cAAA,IACtB,uBAAA,CAAwB,cAAA;AAAA,iBAOX,cAAA,CAAe,SAAA,WAAoB,kBAAA,KAAuB,uBAAA;;;;iBAoB1D,aAAA,CAAc,KAAA;EAC5B,iBAAA;EACA,kBAAA;AAAA,IACE,EAAA,CAAG,8BAAA;;;;iBAYS,aAAA,CACd,IAAA,EAAM,2BAAA,EACN,OAAA,UACA,OAAA;EAAY,GAAA;EAAc,IAAA,GAAO,SAAA;AAAA,IAChC,KAAA,CAAM,yBAAA;;;;;;cC1JI,oBAAA,EAAsB,0BAAA;;;;;;;;;;;;;;iBCsBnB,6BAAA,CAAA,GAAiC,kCAAA;;;;;;;;;;;iBAoBjC,wBAAA,+DAAA,CAGd,KAAA;EAAA,SAAkB,OAAA,EAAS,OAAA;EAAA,SAAkB,UAAA,EAAY,UAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCqBlB,QAAA"}
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/core/control-descriptor.ts","../src/core/assembly.ts","../src/core/migrations/contract-to-schema-ir.ts","../src/core/migrations/field-event-planner.ts","../src/core/migrations/plan-helpers.ts","../src/core/migrations/policies.ts","../src/core/timestamp-now-generator.ts","../src/exports/control.ts"],"mappings":";;;;;;;;;;cAUa,mBAAA,YACA,uBAAA,QAA+B,wBAAA;EAAA,SAEjC,IAAA;EAAA,SACA,EAAA;EAAA,SACA,QAAA;EAAA,SACA,OAAA;EAAA,SACA,QAAA,EAAU,WAAA;EAAA,SACV,SAAA;IAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKT,MAAA,0BAAA,CACE,KAAA,EAAO,YAAA,QAAoB,SAAA,IAC1B,wBAAA;AAAA;;;iBCHW,wBAAA,CACd,WAAA,EAAa,aAAA,CAAc,8BAAA,mBAC1B,GAAA,SAAY,iBAAA;;;;;;;;ADdf;;;;;KE0BY,kBAAA,IAAsB,KAAA;EAAA,SACvB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAA;AAAA;;;;;;;;;;KAYZ,eAAA,IAAmB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAA;;;;;;;;;;iBAuI3C,wBAAA,CACd,IAAA,EAAM,UAAA,SACN,EAAA,EAAI,UAAA,YACM,0BAAA;AAAA,UAiCK,yBAAA;EAAA,SACN,mBAAA;EAAA,SACA,gBAAA,GAAmB,kBAAA;EAAA,SACnB,aAAA,GAAgB,eAAA;EAAA,SAChB,mBAAA,GAAsB,aAAA,CAAc,8BAAA;AAAA;;;;;;;;;;;;;;;;iBAkB/B,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,UACnB,OAAA,EAAS,yBAAA,GACR,WAAA;;;UCxNc,+BAAA;EHhBN;;;;EAAA,SGqBA,aAAA,EAAe,QAAA,CAAS,UAAA;;;;WAIxB,WAAA,EAAa,QAAA,CAAS,UAAA;;;;;;;;;;WAUtB,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAAA,iBAY3B,wBAAA,CACd,OAAA,EAAS,+BAAA,YACC,yBAAA;;;iBC+BI,mBAAA,gBAAA,CACd,OAAA,EAAS,6BAAA,CAA8B,cAAA,IACtC,gBAAA,CAAiB,cAAA;AAAA,iBAcJ,cAAA,gBAAA,CACd,IAAA,EAAM,gBAAA,CAAiB,cAAA,IACtB,uBAAA,CAAwB,cAAA;AAAA,iBAOX,cAAA,CAAe,SAAA,WAAoB,kBAAA,KAAuB,uBAAA;;;;iBAoB1D,aAAA,CAAc,KAAA;EAC5B,iBAAA;EACA,kBAAA;AAAA,IACE,EAAA,CAAG,8BAAA;;;;iBAYS,aAAA,CACd,IAAA,EAAM,2BAAA,EACN,OAAA,UACA,OAAA;EAAY,GAAA;EAAc,IAAA,GAAO,SAAA;AAAA,IAChC,KAAA,CAAM,yBAAA;;;;;;cC1JI,oBAAA,EAAsB,0BAAA;;;;;;;;;;;;;;iBCsBnB,6BAAA,CAAA,GAAiC,kCAAA;;;;;;;;;;;iBAoBjC,wBAAA,+DAAA,CAGd,KAAA;EAAA,SAAkB,OAAA,EAAS,OAAA;EAAA,SAAkB,UAAA,EAAY,UAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cC4BlB,QAAA"}

package/dist/control.mjs

@@ -5,6 +5,7 @@ import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } fro
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
 import { emptyCodecLookup } from "@prisma-next/framework-components/codec";
 import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
+import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
 import { validateContract } from "@prisma-next/sql-contract/validate";
 import { ensureSchemaStatement, ensureTableStatement, writeContractMarker } from "@prisma-next/sql-runtime";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
@@ -1047,7 +1048,7 @@ function createVerifyResult(options) {
 	return result;
 }
 function isSqlControlAdapter(value) {
-	return typeof value === "object" && value !== null && "introspect" in value && typeof value.introspect === "function" && "readMarker" in value && typeof value.readMarker === "function";
+	return typeof value === "object" && value !== null && "introspect" in value && typeof value.introspect === "function" && "readMarker" in value && typeof value.readMarker === "function" && "readAllMarkers" in value && typeof value.readAllMarkers === "function";
 }
 function buildSqlTypeMetadataRegistry(options) {
 	const { target, adapter, extensionPacks: extensions } = options;
@@ -1075,6 +1076,16 @@ function createSqlFamilyInstance(stack) {
 	const target = stack.target;
 	const adapter = stack.adapter;
 	const extensions = stack.extensionPacks;
+	for (const extension of extensions) if (extension.contractSpace) {
+		const { contractJson, headRef } = extension.contractSpace;
+		assertDescriptorSelfConsistency({
+			extensionId: extension.id,
+			target: contractJson.target,
+			targetFamily: contractJson.targetFamily,
+			storage: contractJson.storage,
+			headRefHash: headRef.hash
+		});
+	}
 	const { codecTypeImports, operationTypeImports, extensionIds } = stack;
 	const typeMetadataRegistry = buildSqlTypeMetadataRegistry({
 		target,
@@ -1083,7 +1094,7 @@ function createSqlFamilyInstance(stack) {
 	});
 	const getControlAdapter = () => {
 		const controlAdapter = adapter.create(stack);
-		if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter (missing introspect or readMarker)");
+		if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter (missing introspect, readMarker, or readAllMarkers)");
 		return controlAdapter;
 	};
 	return {
@@ -1201,6 +1212,19 @@ function createSqlFamilyInstance(stack) {
 				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType)
 			});
 		},
+		schemaVerifyAgainstSchema(options) {
+			const contract = validateContract(options.contract, emptyCodecLookup);
+			const controlAdapter = getControlAdapter();
+			return verifySqlSchema({
+				contract,
+				schema: options.schema,
+				strict: options.strict,
+				typeMetadataRegistry,
+				frameworkComponents: options.frameworkComponents,
+				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
+				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType)
+			});
+		},
 		async sign(options) {
 			const { driver, contract: contractInput, contractPath, configPath } = options;
 			const startTime = Date.now();
@@ -1274,6 +1298,9 @@ function createSqlFamilyInstance(stack) {
 		async readMarker(options) {
 			return getControlAdapter().readMarker(options.driver, options.space);
 		},
+		async readAllMarkers(options) {
+			return getControlAdapter().readAllMarkers(options.driver);
+		},
 		async introspect(options) {
 			return getControlAdapter().introspect(options.driver, options.contract);
 		},
@@ -1552,6 +1579,119 @@ function deriveAnnotations(storage, annotationNamespace) {
 	return { [annotationNamespace]: { storageTypes: byNativeType } };
 }
 //#endregion
+//#region src/core/migrations/field-event-planner.ts
+function planFieldEventOperations(options) {
+	const priorTables = options.priorContract?.storage.tables ?? {};
+	const newTables = options.newContract.storage.tables;
+	const added = [];
+	const dropped = [];
+	const altered = [];
+	const tableNames = unionSorted(Object.keys(priorTables), Object.keys(newTables));
+	for (const tableName of tableNames) {
+		const priorTable = priorTables[tableName];
+		const newTable = newTables[tableName];
+		const fieldNames = unionSorted(priorTable ? Object.keys(priorTable.columns) : [], newTable ? Object.keys(newTable.columns) : []);
+		for (const fieldName of fieldNames) {
+			const priorField = priorTable?.columns[fieldName];
+			const newField = newTable?.columns[fieldName];
+			const entry = {
+				tableName,
+				fieldName,
+				priorTable,
+				newTable,
+				priorField,
+				newField
+			};
+			if (priorField === void 0 && newField !== void 0) added.push(entry);
+			else if (priorField !== void 0 && newField === void 0) dropped.push(entry);
+			else if (priorField !== void 0 && newField !== void 0) {
+				if (isAlteration(priorField, newField)) altered.push(entry);
+			}
+		}
+	}
+	const ops = [];
+	appendOps("added", added, options.codecHooks, ops, (e) => e.newField?.codecId);
+	appendOps("dropped", dropped, options.codecHooks, ops, (e) => e.priorField?.codecId);
+	appendOps("altered", altered, options.codecHooks, ops, (e) => e.newField?.codecId);
+	return ops;
+}
+function appendOps(event, entries, codecHooks, ops, pickCodecId) {
+	for (const entry of entries) {
+		const codecId = pickCodecId(entry);
+		if (codecId === void 0) continue;
+		const hook = codecHooks.get(codecId);
+		if (!hook?.onFieldEvent) continue;
+		const ctx = buildContext(event, entry);
+		const emitted = hook.onFieldEvent(event, ctx);
+		for (const op of emitted) ops.push(op);
+	}
+}
+/**
+* The context's prior/new sides are scoped to the event:
+*
+* - `'added'`   — only `newTable` / `newField` populated.
+* - `'dropped'` — only `priorTable` / `priorField` populated.
+* - `'altered'` — both sides populated.
+*/
+function buildContext(event, entry) {
+	const base = {
+		tableName: entry.tableName,
+		fieldName: entry.fieldName
+	};
+	if (event === "added") return {
+		...base,
+		...entry.newTable !== void 0 ? { newTable: entry.newTable } : {},
+		...entry.newField !== void 0 ? { newField: entry.newField } : {}
+	};
+	if (event === "dropped") return {
+		...base,
+		...entry.priorTable !== void 0 ? { priorTable: entry.priorTable } : {},
+		...entry.priorField !== void 0 ? { priorField: entry.priorField } : {}
+	};
+	return {
+		...base,
+		...entry.priorTable !== void 0 ? { priorTable: entry.priorTable } : {},
+		...entry.newTable !== void 0 ? { newTable: entry.newTable } : {},
+		...entry.priorField !== void 0 ? { priorField: entry.priorField } : {},
+		...entry.newField !== void 0 ? { newField: entry.newField } : {}
+	};
+}
+/**
+* `'altered'` predicate. Returns `false` whenever `codecId` differs —
+* any codec change suppresses the `altered` event entirely, including
+* cases where another property also differs in the same diff. Codec
+* rotation is a v1 non-goal (project spec § Non-goals); avoiding the
+* mixed event keeps the migration semantics for codec changes explicit
+* (out of scope) rather than smuggling them through as `altered`.
+*
+* For non-`codecId` diffs, returns `true` iff any other column property
+* differs.
+*/
+function isAlteration(prior, current) {
+	if (prior.codecId !== current.codecId) return false;
+	return !sameStorageColumn(prior, current);
+}
+function sameStorageColumn(a, b) {
+	if (a === b) return true;
+	if (a.nativeType !== b.nativeType) return false;
+	if (a.nullable !== b.nullable) return false;
+	if (a.typeRef !== b.typeRef) return false;
+	if (!sameJson(a.typeParams, b.typeParams)) return false;
+	if (!sameJson(a.default, b.default)) return false;
+	return true;
+}
+function sameJson(a, b) {
+	if (a === b) return true;
+	if (a === void 0 || b === void 0) return false;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function unionSorted(a, b) {
+	const set = /* @__PURE__ */ new Set();
+	for (const name of a) set.add(name);
+	for (const name of b) set.add(name);
+	return [...set].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
+}
+//#endregion
 //#region src/core/migrations/plan-helpers.ts
 const readOnlyEmptyObject = Object.freeze({});
 function cloneRecord(value) {
@@ -1656,6 +1796,6 @@ const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.fre
 //#region src/exports/control.ts
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, collectInitDependencies, contractToSchemaIR, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, isDatabaseDependencyProvider, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, collectInitDependencies, contractToSchemaIR, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, isDatabaseDependencyProvider, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map