@prisma-next/family-sql 0.12.0-dev.2 → 0.12.0-dev.21

package/dist/control-adapter-8tV9WgWK.d.mts

@@ -0,0 +1,134 @@
+import { n as DefaultNormalizer, r as NativeTypeNormalizer, t as ColumnsCompatible } from "./verify-sql-schema-Cj3c2t5Z.mjs";
+import { ControlAdapterInstance, ControlDriverInstance, ControlStack } from "@prisma-next/framework-components/control";
+import { PostgresEnumStorageEntry, SqlStorage } from "@prisma-next/sql-contract/types";
+import { Contract, ContractMarkerRecord, LedgerEntryRecord } from "@prisma-next/contract/types";
+import { AnyQueryAst, DdlNode, LoweredStatement, LowererContext } from "@prisma-next/sql-relational-core/ast";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/control-adapter.d.ts
+/**
+ * SQL control adapter interface for control-plane operations.
+ * Implemented by target-specific adapters (e.g., Postgres, MySQL).
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+interface SqlControlAdapter<TTarget extends string = string> extends ControlAdapterInstance<'sql', TTarget> {
+  /**
+   * Reads the contract marker for `space` from the database, returning
+   * `null` if no marker row exists for that space (or if the marker
+   * table itself is missing). Implementations are responsible for the
+   * dialect-specific existence probe (e.g. Postgres
+   * `information_schema.tables` vs SQLite `sqlite_master`) and parameter
+   * placeholders.
+   *
+   * `space` is required so callers cannot accidentally fall through to
+   * the app's marker row when reading per-extension markers.
+   *
+   * @param driver - ControlDriverInstance for executing queries (target-specific)
+   * @param space - Contract space id whose marker row to read (e.g. `'app'`)
+   * @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>>;
+  /**
+   * Reads the per-migration ledger journal for `space` in apply order.
+   * Returns an empty array when the ledger store does not yet exist or
+   * has no rows for that space.
+   */
+  readLedger(driver: ControlDriverInstance<'sql', TTarget>, space: string): Promise<readonly LedgerEntryRecord[]>;
+  /**
+   * Introspects a database schema and returns a raw SqlSchemaIR.
+   *
+   * This is a pure schema discovery operation that queries the database catalog
+   * and returns the schema structure without type mapping or contract enrichment.
+   * Type mapping and enrichment are handled separately by enrichment helpers.
+   *
+   * @param driver - ControlDriverInstance instance for executing queries (target-specific)
+   * @param contract - Optional contract for contract-guided introspection (filtering, optimization)
+   * @param schema - Schema name to introspect (defaults to 'public')
+   * @returns Promise resolving to SqlSchemaIR representing the live database schema
+   */
+  introspect(driver: ControlDriverInstance<'sql', TTarget>, contract?: unknown, schema?: string): Promise<SqlSchemaIR>;
+  /**
+   * Optional target-specific normalizer for raw database default expressions.
+   * When provided, schema defaults (raw strings) are normalized before comparison
+   * with contract defaults (ColumnDefault objects) during schema verification.
+   */
+  readonly normalizeDefault?: DefaultNormalizer;
+  /**
+   * Optional target-specific normalizer for schema native type names.
+   * When provided, schema native types (from introspection) are normalized
+   * before comparison with contract native types during schema verification.
+   */
+  readonly normalizeNativeType?: NativeTypeNormalizer;
+  /**
+   * Optional target-supplied compatible-shape relation for column native types.
+   * When provided, schema verification uses it under the `external` control
+   * policy to decide whether a declared column type is compatible with the
+   * live type (instead of exact equality). Threading the same relation the
+   * migration planner/runner use keeps runtime verify and migration verify in
+   * agreement; when omitted, verification falls back to exact equality.
+   */
+  readonly columnsCompatible?: ColumnsCompatible;
+  /**
+   * Optional bridging adapter for resolving the existing values of a
+   * native enum type from the introspected schema IR. Targets supply
+   * this so the family-level schema verifier can walk
+   * `PostgresEnumStorageEntry` entries natively without needing to
+   * know the target-specific `schema.annotations` shape
+   * (e.g. `schema.annotations.pg.storageTypes`).
+   */
+  readonly resolveExistingEnumValues?: (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
+  /**
+   * Optional contract-scoped factory for {@link resolveExistingEnumValues}.
+   * Targets that need the contract storage to resolve namespace → DDL schema
+   * supply this; the family control instance prefers it over the bare adapter
+   * hook when present.
+   */
+  readonly resolveExistingEnumValuesForContract?: (contract: Contract<SqlStorage>) => (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
+  /**
+   * Ordered DDL queries that bootstrap marker/ledger control tables for migration
+   * runners. Postgres includes `CREATE SCHEMA`; SQLite does not.
+   */
+  bootstrapControlTableQueries(): readonly DdlNode[];
+  /**
+   * Ordered DDL queries that bootstrap the marker table (and Postgres schema) for
+   * `sign` — excludes the ledger table.
+   */
+  bootstrapSignMarkerQueries(): readonly DdlNode[];
+  /**
+   * Lower a SQL query AST into a target-flavored `{ sql, params }` payload.
+   *
+   * Migration tooling (e.g. the `dataTransform` operation) needs to materialize
+   * SQL at emit/plan time without instantiating the runtime adapter. The control
+   * adapter's `lower` is byte-equivalent to the runtime adapter's `lower` for the
+   * same AST and contract, ensuring planned SQL matches what the runtime would
+   * emit.
+   */
+  lower(ast: AnyQueryAst | DdlNode, context: LowererContext<unknown>): LoweredStatement;
+}
+/**
+ * SQL control adapter descriptor interface.
+ * Provides a factory method to create control adapter instances.
+ *
+ * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
+ */
+interface SqlControlAdapterDescriptor<TTarget extends string = string> {
+  /**
+   * Creates a SQL control adapter instance for control-plane operations.
+   *
+   * Receives the assembled `ControlStack` so adapters can read aggregated
+   * metadata (codec lookup, extension contributions) when materializing.
+   */
+  create(stack: ControlStack<'sql', TTarget>): SqlControlAdapter<TTarget>;
+}
+//#endregion
+export { SqlControlAdapterDescriptor as n, SqlControlAdapter as t };
+//# sourceMappingURL=control-adapter-8tV9WgWK.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control-adapter-8tV9WgWK.d.mts","names":[],"sources":["../src/core/control-adapter.ts"],"mappings":";;;;;;;;;;AA8BA;;;;UAAiB,iBAAA,0CACP,sBAAA,QAA8B,OAAA;EAiB5B;;;;;;;;;;;;;;;EADV,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,KAAA,WACC,OAAA,CAAQ,oBAAA;EA8CiB;;;;;;;EArC5B,cAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,IACpC,OAAA,CAAQ,WAAA,SAAoB,oBAAA;EA6EnB;;;;;EAtEZ,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,KAAA,WACC,OAAA,UAAiB,iBAAA;EA4FiD;;;;;;;;;;;;EA9ErE,UAAA,CACE,MAAA,EAAQ,qBAAA,QAA6B,OAAA,GACrC,QAAA,YACA,MAAA,YACC,OAAA,CAAQ,WAAA;EAvCA;;;;;EAAA,SA8CF,gBAAA,GAAmB,iBAAA;EAnCjB;;;;;EAAA,SA0CF,mBAAA,GAAsB,oBAAA;EAjC7B;;;;;;;;EAAA,SA2CO,iBAAA,GAAoB,iBAAA;EAxB1B;;;;;;;;EAAA,SAkCM,yBAAA,IACP,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA,EACV,WAAA;EAFQ;;;;;;EAAA,SAUD,oCAAA,IACP,QAAA,EAAU,QAAA,CAAS,UAAA,OAEnB,MAAA,EAAQ,WAAA,EACR,QAAA,EAAU,wBAAA,EACV,WAAA;EAJmB;;;;EAWrB,4BAAA,aAAyC,OAAA;EARvC;;;;EAcF,0BAAA,aAAuC,OAAA;EAAA;;;;;;;;;EAWvC,KAAA,CAAM,GAAA,EAAK,WAAA,GAAc,OAAA,EAAS,OAAA,EAAS,cAAA,YAA0B,gBAAA;AAAA;;;;;;;UAStD,2BAAA;EAO+C;;;;;;EAA9D,MAAA,CAAO,KAAA,EAAO,YAAA,QAAoB,OAAA,IAAW,iBAAA,CAAkB,OAAA;AAAA"}

package/dist/control-adapter.d.mts

@@ -1,109 +1,2 @@
-import { n as NativeTypeNormalizer, t as DefaultNormalizer } from "./verify-sql-schema-CN7pPoTC.mjs";
-import { ControlAdapterInstance, ControlDriverInstance, ControlStack } from "@prisma-next/framework-components/control";
-import { PostgresEnumStorageEntry, SqlStorage } from "@prisma-next/sql-contract/types";
-import { Contract, ContractMarkerRecord } from "@prisma-next/contract/types";
-import { AnyQueryAst, LoweredStatement, LowererContext } from "@prisma-next/sql-relational-core/ast";
-import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
-
-//#region src/core/control-adapter.d.ts
-/**
- * SQL control adapter interface for control-plane operations.
- * Implemented by target-specific adapters (e.g., Postgres, MySQL).
- *
- * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
- */
-interface SqlControlAdapter<TTarget extends string = string> extends ControlAdapterInstance<'sql', TTarget> {
-  /**
-   * Reads the contract marker for `space` from the database, returning
-   * `null` if no marker row exists for that space (or if the marker
-   * table itself is missing). Implementations are responsible for the
-   * dialect-specific existence probe (e.g. Postgres
-   * `information_schema.tables` vs SQLite `sqlite_master`) and parameter
-   * placeholders.
-   *
-   * `space` is required so callers cannot accidentally fall through to
-   * the app's marker row when reading per-extension markers.
-   *
-   * @param driver - ControlDriverInstance for executing queries (target-specific)
-   * @param space - Contract space id whose marker row to read (e.g. `'app'`)
-   * @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.
-   *
-   * This is a pure schema discovery operation that queries the database catalog
-   * and returns the schema structure without type mapping or contract enrichment.
-   * Type mapping and enrichment are handled separately by enrichment helpers.
-   *
-   * @param driver - ControlDriverInstance instance for executing queries (target-specific)
-   * @param contract - Optional contract for contract-guided introspection (filtering, optimization)
-   * @param schema - Schema name to introspect (defaults to 'public')
-   * @returns Promise resolving to SqlSchemaIR representing the live database schema
-   */
-  introspect(driver: ControlDriverInstance<'sql', TTarget>, contract?: unknown, schema?: string): Promise<SqlSchemaIR>;
-  /**
-   * Optional target-specific normalizer for raw database default expressions.
-   * When provided, schema defaults (raw strings) are normalized before comparison
-   * with contract defaults (ColumnDefault objects) during schema verification.
-   */
-  readonly normalizeDefault?: DefaultNormalizer;
-  /**
-   * Optional target-specific normalizer for schema native type names.
-   * When provided, schema native types (from introspection) are normalized
-   * before comparison with contract native types during schema verification.
-   */
-  readonly normalizeNativeType?: NativeTypeNormalizer;
-  /**
-   * Optional bridging adapter for resolving the existing values of a
-   * native enum type from the introspected schema IR. Targets supply
-   * this so the family-level schema verifier can walk
-   * `PostgresEnumStorageEntry` entries natively without needing to
-   * know the target-specific `schema.annotations` shape
-   * (e.g. `schema.annotations.pg.storageTypes`).
-   */
-  readonly resolveExistingEnumValues?: (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
-  /**
-   * Optional contract-scoped factory for {@link resolveExistingEnumValues}.
-   * Targets that need the contract storage to resolve namespace → DDL schema
-   * supply this; the family control instance prefers it over the bare adapter
-   * hook when present.
-   */
-  readonly resolveExistingEnumValuesForContract?: (contract: Contract<SqlStorage>) => (schema: SqlSchemaIR, enumType: PostgresEnumStorageEntry, namespaceId: string) => readonly string[] | null;
-  /**
-   * Lower a SQL query AST into a target-flavored `{ sql, params }` payload.
-   *
-   * Migration tooling (e.g. the `dataTransform` operation) needs to materialize
-   * SQL at emit/plan time without instantiating the runtime adapter. The control
-   * adapter's `lower` is byte-equivalent to the runtime adapter's `lower` for the
-   * same AST and contract, ensuring planned SQL matches what the runtime would
-   * emit.
-   */
-  lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement;
-}
-/**
- * SQL control adapter descriptor interface.
- * Provides a factory method to create control adapter instances.
- *
- * @template TTarget - The target ID (e.g., 'postgres', 'mysql')
- */
-interface SqlControlAdapterDescriptor<TTarget extends string = string> {
-  /**
-   * Creates a SQL control adapter instance for control-plane operations.
-   *
-   * Receives the assembled `ControlStack` so adapters can read aggregated
-   * metadata (codec lookup, extension contributions) when materializing.
-   */
-  create(stack: ControlStack<'sql', TTarget>): SqlControlAdapter<TTarget>;
-}
-//#endregion
-export { type SqlControlAdapter, type SqlControlAdapterDescriptor };
-//# sourceMappingURL=control-adapter.d.mts.map
+import { n as SqlControlAdapterDescriptor, t as SqlControlAdapter } from "./control-adapter-8tV9WgWK.mjs";
+export { type SqlControlAdapter, type SqlControlAdapterDescriptor };

package/dist/control.d.mts

@@ -1,8 +1,8 @@
-import { A as SqlPlannerResult, C as SqlMigrationRunnerResult, D as SqlPlannerConflictKind, E as SqlPlannerConflict, M as StorageTypePlanResult, N as SqlControlFamilyInstance, O as SqlPlannerConflictLocation, S as SqlMigrationRunnerFailure, T as SqlPlanTargetDetails, _ as SqlMigrationPlannerPlanOptions, a as FieldEvent, b as SqlMigrationRunnerExecuteCallbacks, c as SqlControlAdapterDescriptor, d as SqlMigrationPlan, f as SqlMigrationPlanContractInfo, g as SqlMigrationPlanner, h as SqlMigrationPlanOperationTarget, i as ExpandNativeTypeInput, j as SqlPlannerSuccessResult, k as SqlPlannerFailureResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationStep, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperation, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, t as AnyRecord, u as SqlControlTargetDescriptor, v as SqlMigrationRunner, w as SqlMigrationRunnerSuccessValue, x as SqlMigrationRunnerExecuteOptions, y as SqlMigrationRunnerErrorCode } from "./types-CeeCStqw.mjs";
+import { A as SqlPlannerResult, C as SqlMigrationRunnerResult, D as SqlPlannerConflictKind, E as SqlPlannerConflict, M as StorageTypePlanResult, N as SqlControlFamilyInstance, O as SqlPlannerConflictLocation, S as SqlMigrationRunnerFailure, T as SqlPlanTargetDetails, _ as SqlMigrationPlannerPlanOptions, a as FieldEvent, b as SqlMigrationRunnerExecuteCallbacks, c as SqlControlAdapterDescriptor, d as SqlMigrationPlan, f as SqlMigrationPlanContractInfo, g as SqlMigrationPlanner, h as SqlMigrationPlanOperationTarget, i as ExpandNativeTypeInput, j as SqlPlannerSuccessResult, k as SqlPlannerFailureResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationStep, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperation, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, t as AnyRecord, u as SqlControlTargetDescriptor, v as SqlMigrationRunner, w as SqlMigrationRunnerSuccessValue, x as SqlMigrationRunnerExecuteOptions, y as SqlMigrationRunnerErrorCode } from "./types-BQiqw6kR.mjs";
 import { ControlFamilyDescriptor, ControlStack, MigrationOperationClass, MigrationOperationPolicy, MigrationOperationPolicy as MigrationOperationPolicy$1, MigrationPlan, MigrationPlanOperation, MigrationPlanner, MigrationPlannerConflict, MigrationPlannerConflict as MigrationPlannerConflict$1, MigrationPlannerResult, MutationDefaultGeneratorDescriptor, OpFactoryCall, TargetMigrationsCapability, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
 import { SqlStorage, StorageColumn } from "@prisma-next/sql-contract/types";
+import { ColumnDefault, Contract, ControlPolicy } from "@prisma-next/contract/types";
 import { NotOk, Ok } from "@prisma-next/utils/result";
-import { ColumnDefault, Contract } from "@prisma-next/contract/types";
 import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 import { EmissionSpi } from "@prisma-next/framework-components/emission";
@@ -325,6 +325,34 @@ interface ContractToSchemaIROptions {
  */
 declare function contractToSchemaIR(contract: Contract<SqlStorage> | null, options: ContractToSchemaIROptions): SqlSchemaIR;
 //#endregion
+//#region src/core/migrations/control-policy.d.ts
+/**
+ * The target object a control policy governs for a single planner call,
+ * resolved from the target's own IR. `undefined` means the call's target
+ * object could not be positively established — a fail-closed signal: any
+ * policy stricter than `managed` drops such a call rather than emitting it.
+ */
+interface ControlPolicySubject {
+  readonly namespaceId: string;
+  readonly explicitNodeControlPolicy?: ControlPolicy;
+  readonly table?: string;
+  readonly column?: string;
+  readonly typeName?: string;
+  /**
+   * Whether the call creates a whole, previously-absent top-level storage
+   * object (e.g. a table or an enum/type), as opposed to modifying an
+   * existing object. This is the only thing `tolerated` permits: it is a
+   * create-if-absent policy, so an op that touches an existing object — add
+   * column, add index/constraint, alter, drop — is never allowed under it.
+   */
+  readonly createsNewObject: boolean;
+}
+declare function filterCallsByControlPolicy<TCall>(options: {
+  readonly calls: readonly TCall[];
+  readonly contract: Contract<SqlStorage>;
+  readonly resolveControlPolicySubject: (call: TCall) => ControlPolicySubject | undefined;
+}): readonly TCall[];
+//#endregion
 //#region src/core/migrations/field-event-planner.d.ts
 interface PlanFieldEventOperationsOptions {
   /**
@@ -434,5 +462,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 ContractToSchemaIROptions, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type EnumStorageKeyResolver, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type NativeTypeExpander, type PlanFieldEventOperationsOptions, type ResolveIdentityValueInput, 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, contractToSchemaIR, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { type CodecControlHooks, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type EnumStorageKeyResolver, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type NativeTypeExpander, type PlanFieldEventOperationsOptions, type ResolveIdentityValueInput, 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, contractToSchemaIR, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, filterCallsByControlPolicy, 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/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;;;;KE4BY,kBAAA,IAAsB,KAAA;EAAA,SACvB,UAAA;EAAA,SACA,OAAA;EAAA,SACA,UAAA,GAAa,MAAM;AAAA;;;;;;;;;;KAYlB,eAAA,IAAmB,GAAA,EAAK,aAAA,EAAe,MAAA,EAAQ,aAAa;;;;;;;;;;;;;;;KAgB5D,sBAAA,IACV,OAAA,EAAS,UAAU,EACnB,WAAA,UACA,UAAA;;;;;;;;;;iBAmKc,wBAAA,CACd,IAAA,EAAM,UAAA,SACN,EAAA,EAAI,UAAA,YACM,0BAAA;AAAA,UA8CK,yBAAA;EAAA,SACN,mBAAA;EAAA,SACA,gBAAA,GAAmB,kBAAA;EAAA,SACnB,aAAA,GAAgB,eAAA;;;;;;;;WAQhB,qBAAA,GAAwB,sBAAA;AAAA;;;;;;;;;;;;;;;iBAiBnB,kBAAA,CACd,QAAA,EAAU,QAAA,CAAS,UAAA,UACnB,OAAA,EAAS,yBAAA,GACR,WAAA;;;UC9Rc,+BAAA;EHZI;;;;EAAA,SGiBV,aAAA,EAAe,QAAA,CAAS,UAAA;;;;WAIxB,WAAA,EAAa,QAAA,CAAS,UAAA;;;;;;;;;;WAUtB,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;AAAA,iBAa3B,wBAAA,CACd,OAAA,EAAS,+BAAA,YACC,aAAa;;;iBCgCT,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,uBAAuB;;;;iBAoBjF,aAAA,CAAc,KAAA;EAC5B,iBAAA;EACA,kBAAA;AAAA,IACE,EAAE,CAAC,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,0BAEjC;;;;;;;;;;;;;;iBCoBc,6BAAA,CAAA,GAAiC,kCAAkC;;;;;;;;;;;iBAqBnE,wBAAA,+DAAA,CAGd,KAAA;EAAA,SAAkB,OAAA,EAAS,OAAA;EAAA,SAAkB,UAAA,EAAY,UAAA;AAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCsBlB,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/control-policy.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":"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"}

package/dist/control.mjs

@@ -1,18 +1,19 @@
 import { n as sqlFamilyAuthoringFieldPresets, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-F4JpCJl7.mjs";
 import { t as SqlContractSerializer } from "./sql-contract-serializer-8axtK4lg.mjs";
-import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-CYLsGCFO.mjs";
+import { a as extractCodecControlHooks, t as verifySqlSchema } from "./verify-sql-schema-fljAiO-C.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-Crewz6hG.mjs";
 import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-BkjCQIde.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
 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 { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
-import { ensureSchemaStatement, ensureTableStatement, writeContractMarker } from "@prisma-next/sql-runtime";
+import { writeContractMarker } from "@prisma-next/sql-runtime";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { StorageTable, isPostgresEnumStorageEntry, isStorageTypeInstance, toStorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma-next/framework-components/psl-ast";
+import { effectiveControlPolicy } from "@prisma-next/contract/types";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -1057,9 +1058,6 @@ function createVerifyResult(options) {
 	if (options.codecCoverageSkipped) result.codecCoverageSkipped = options.codecCoverageSkipped;
 	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" && "readAllMarkers" in value && typeof value.readAllMarkers === "function" && "lower" in value && typeof value.lower === "function";
-}
 function buildSqlTypeMetadataRegistry(options) {
 	const { target, adapter, extensionPacks: extensions } = options;
 	const registry = /* @__PURE__ */ new Map();
@@ -1103,11 +1101,7 @@ function createSqlFamilyInstance(stack) {
 		adapter,
 		extensionPacks: extensions
 	});
-	const getControlAdapter = () => {
-		const controlAdapter = adapter.create(stack);
-		if (!isSqlControlAdapter(controlAdapter)) throw new Error("Adapter does not implement SqlControlAdapter (missing introspect, readMarker, or readAllMarkers)");
-		return controlAdapter;
-	};
+	const getControlAdapter = () => adapter.create(stack);
 	const targetSerializer = target.contractSerializer;
 	const deserializeWithTargetSerializer = (contractJson) => {
 		return (targetSerializer ?? new SqlContractSerializer()).deserializeContract(contractJson);
@@ -1223,6 +1217,7 @@ function createSqlFamilyInstance(stack) {
 				frameworkComponents: options.frameworkComponents,
 				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
 				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType),
+				...ifDefined("columnsCompatible", controlAdapter.columnsCompatible),
 				...ifDefined("resolveExistingEnumValues", resolveExistingEnumValues)
 			});
 		},
@@ -1233,9 +1228,13 @@ function createSqlFamilyInstance(stack) {
 			const contractStorageHash = contract.storage.storageHash;
 			const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : contractStorageHash;
 			const contractTarget = contract.target;
-			await driver.query(ensureSchemaStatement.sql, ensureSchemaStatement.params);
-			await driver.query(ensureTableStatement.sql, ensureTableStatement.params);
-			const existingMarker = await getControlAdapter().readMarker(driver, APP_SPACE_ID);
+			const controlAdapter = getControlAdapter();
+			const lowererContext = { contract };
+			for (const query of controlAdapter.bootstrapSignMarkerQueries()) {
+				const lowered = controlAdapter.lower(query, lowererContext);
+				await driver.query(lowered.sql, lowered.params);
+			}
+			const existingMarker = await controlAdapter.readMarker(driver, APP_SPACE_ID);
 			let markerCreated = false;
 			let markerUpdated = false;
 			let previousHashes;
@@ -1302,6 +1301,9 @@ function createSqlFamilyInstance(stack) {
 		async readAllMarkers(options) {
 			return getControlAdapter().readAllMarkers(options.driver);
 		},
+		async readLedger(options) {
+			return getControlAdapter().readLedger(options.driver, options.space);
+		},
 		async introspect(options) {
 			return getControlAdapter().introspect(options.driver, options.contract);
 		},
@@ -1311,6 +1313,12 @@ function createSqlFamilyInstance(stack) {
 		lowerAst(ast, context) {
 			return getControlAdapter().lower(ast, context);
 		},
+		bootstrapControlTableQueries() {
+			return getControlAdapter().bootstrapControlTableQueries();
+		},
+		bootstrapSignMarkerQueries() {
+			return getControlAdapter().bootstrapSignMarkerQueries();
+		},
 		toOperationPreview(operations) {
 			return sqlOperationsToPreview(operations);
 		},
@@ -1616,6 +1624,46 @@ function deriveAnnotations(storage, annotationNamespace, resolveEnumStorageKey)
 	return { [annotationNamespace]: { storageTypes } };
 }
 //#endregion
+//#region src/core/migrations/control-policy.ts
+/**
+* The control policy that governs a single call. The `external` default is an
+* un-overridable namespace floor: when the contract default is `external`, no
+* per-object `managed` override can escalate DDL above the floor, so the
+* policy is forced to `external` regardless of the node's own declaration.
+* Every other default defers to the node's effective control policy.
+*/
+function controlPolicyForCall(subject, defaultControlPolicy) {
+	if (defaultControlPolicy === "external") return "external";
+	return effectiveControlPolicy(subject?.explicitNodeControlPolicy, defaultControlPolicy);
+}
+/**
+* Whether a call is allowed to emit under a given control policy.
+*
+* - `managed` — full lifecycle, every op allowed.
+* - `tolerated` — create-if-absent only: allowed iff the call creates a whole
+*   new top-level object (and its subject was positively resolved). Anything
+*   that modifies an existing object, and anything whose subject could not be
+*   resolved, is suppressed.
+* - `external` / `observed` — no DDL at all.
+*/
+function callAllowedUnderControlPolicy(policy, subject) {
+	switch (policy) {
+		case "managed": return true;
+		case "tolerated": return subject?.createsNewObject === true;
+		case "external":
+		case "observed": return false;
+	}
+}
+function filterCallsByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const kept = [];
+	for (const call of options.calls) {
+		const subject = options.resolveControlPolicySubject(call);
+		if (callAllowedUnderControlPolicy(controlPolicyForCall(subject, defaultControlPolicy), subject)) kept.push(call);
+	}
+	return Object.freeze(kept);
+}
+//#endregion
 //#region src/core/migrations/field-event-planner.ts
 function planFieldEventOperations(options) {
 	const priorContract = options.priorContract;
@@ -1844,6 +1892,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, contractToSchemaIR, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractToSchemaIR, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, filterCallsByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map