@prisma-next/sql-contract 0.3.0-dev.3 → 0.3.0-dev.31

package/dist/exports/factories.d.ts

@@ -1,41 +1,2 @@
-import { StorageColumn, SqlStorage, ModelDefinition, SqlMappings, SqlContract, ForeignKey, Index, ModelField, PrimaryKey, StorageTable, UniqueConstraint } from './types.js';
-import '@prisma-next/contract/types';
-
-/**
- * Creates a StorageColumn with nativeType and codecId.
- *
- * @param nativeType - Native database type identifier (e.g., 'int4', 'text', 'vector')
- * @param codecId - Codec identifier (e.g., 'pg/int4@1', 'pg/text@1')
- * @param nullable - Whether the column is nullable (default: false)
- * @returns StorageColumn with nativeType and codecId
- */
-declare function col(nativeType: string, codecId: string, nullable?: boolean): StorageColumn;
-declare function pk(...columns: readonly string[]): PrimaryKey;
-declare function unique(...columns: readonly string[]): UniqueConstraint;
-declare function index(...columns: readonly string[]): Index;
-declare function fk(columns: readonly string[], refTable: string, refColumns: readonly string[], name?: string): ForeignKey;
-declare function table(columns: Record<string, StorageColumn>, opts?: {
-    pk?: PrimaryKey;
-    uniques?: readonly UniqueConstraint[];
-    indexes?: readonly Index[];
-    fks?: readonly ForeignKey[];
-}): StorageTable;
-declare function model(table: string, fields: Record<string, ModelField>, relations?: Record<string, unknown>): ModelDefinition;
-declare function storage(tables: Record<string, StorageTable>): SqlStorage;
-declare function contract(opts: {
-    target: string;
-    coreHash: string;
-    storage: SqlStorage;
-    models?: Record<string, ModelDefinition>;
-    relations?: Record<string, unknown>;
-    mappings?: Partial<SqlMappings>;
-    schemaVersion?: '1';
-    targetFamily?: 'sql';
-    profileHash?: string;
-    capabilities?: Record<string, Record<string, boolean>>;
-    extensionPacks?: Record<string, unknown>;
-    meta?: Record<string, unknown>;
-    sources?: Record<string, unknown>;
-}): SqlContract;
-
-export { col, contract, fk, index, model, pk, storage, table, unique };
+export { col, contract, fk, index, model, pk, storage, table, unique, } from '../factories';
+//# sourceMappingURL=factories.d.ts.map

package/dist/exports/factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../src/exports/factories.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,QAAQ,EACR,EAAE,EACF,KAAK,EACL,KAAK,EACL,EAAE,EACF,OAAO,EACP,KAAK,EACL,MAAM,GACP,MAAM,cAAc,CAAC"}

package/dist/exports/pack-types.d.ts

@@ -1,11 +1,2 @@
-/**
- * Storage type metadata for pack refs.
- */
-interface StorageTypeMetadata {
-    readonly typeId: string;
-    readonly familyId: string;
-    readonly targetId: string;
-    readonly nativeType?: string;
-}
-
-export type { StorageTypeMetadata };
+export type { StorageTypeMetadata } from '../pack-types';
+//# sourceMappingURL=pack-types.d.ts.map

package/dist/exports/pack-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-types.d.ts","sourceRoot":"","sources":["../../src/exports/pack-types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC"}

package/dist/exports/types.d.ts

@@ -1,70 +1,2 @@
-import { ContractBase } from '@prisma-next/contract/types';
-
-type StorageColumn = {
-    readonly nativeType: string;
-    readonly codecId: string;
-    readonly nullable: boolean;
-};
-type PrimaryKey = {
-    readonly columns: readonly string[];
-    readonly name?: string;
-};
-type UniqueConstraint = {
-    readonly columns: readonly string[];
-    readonly name?: string;
-};
-type Index = {
-    readonly columns: readonly string[];
-    readonly name?: string;
-};
-type ForeignKeyReferences = {
-    readonly table: string;
-    readonly columns: readonly string[];
-};
-type ForeignKey = {
-    readonly columns: readonly string[];
-    readonly references: ForeignKeyReferences;
-    readonly name?: string;
-};
-type StorageTable = {
-    readonly columns: Record<string, StorageColumn>;
-    readonly primaryKey?: PrimaryKey;
-    readonly uniques: ReadonlyArray<UniqueConstraint>;
-    readonly indexes: ReadonlyArray<Index>;
-    readonly foreignKeys: ReadonlyArray<ForeignKey>;
-};
-type SqlStorage = {
-    readonly tables: Record<string, StorageTable>;
-};
-type ModelField = {
-    readonly column: string;
-};
-type ModelStorage = {
-    readonly table: string;
-};
-type ModelDefinition = {
-    readonly storage: ModelStorage;
-    readonly fields: Record<string, ModelField>;
-    readonly relations: Record<string, unknown>;
-};
-type SqlMappings = {
-    readonly modelToTable?: Record<string, string>;
-    readonly tableToModel?: Record<string, string>;
-    readonly fieldToColumn?: Record<string, Record<string, string>>;
-    readonly columnToField?: Record<string, Record<string, string>>;
-    readonly codecTypes: Record<string, {
-        readonly output: unknown;
-    }>;
-    readonly operationTypes: Record<string, Record<string, unknown>>;
-};
-type SqlContract<S extends SqlStorage = SqlStorage, M extends Record<string, unknown> = Record<string, unknown>, R extends Record<string, unknown> = Record<string, unknown>, Map extends SqlMappings = SqlMappings> = ContractBase & {
-    readonly targetFamily: string;
-    readonly storage: S;
-    readonly models: M;
-    readonly relations: R;
-    readonly mappings: Map;
-};
-type ExtractCodecTypes<TContract extends SqlContract<SqlStorage>> = TContract['mappings']['codecTypes'];
-type ExtractOperationTypes<TContract extends SqlContract<SqlStorage>> = TContract['mappings']['operationTypes'];
-
-export type { ExtractCodecTypes, ExtractOperationTypes, ForeignKey, ForeignKeyReferences, Index, ModelDefinition, ModelField, ModelStorage, PrimaryKey, SqlContract, SqlMappings, SqlStorage, StorageColumn, StorageTable, UniqueConstraint };
+export type { ExtractCodecTypes, ExtractOperationTypes, ForeignKey, ForeignKeyReferences, Index, ModelDefinition, ModelField, ModelStorage, PrimaryKey, SqlContract, SqlMappings, SqlStorage, StorageColumn, StorageTable, StorageTypeInstance, UniqueConstraint, } from '../types';
+//# sourceMappingURL=types.d.ts.map

package/dist/exports/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/exports/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,iBAAiB,EACjB,qBAAqB,EACrB,UAAU,EACV,oBAAoB,EACpB,KAAK,EACL,eAAe,EACf,UAAU,EACV,YAAY,EACZ,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,UAAU,CAAC"}

package/dist/exports/validators.d.ts

@@ -1,38 +1,2 @@
-import { ModelDefinition, SqlContract, SqlStorage } from './types.js';
-import '@prisma-next/contract/types';
-
-/**
- * Validates the structural shape of SqlStorage using Arktype.
- *
- * @param value - The storage value to validate
- * @returns The validated storage if structure is valid
- * @throws Error if the storage structure is invalid
- */
-declare function validateStorage(value: unknown): SqlStorage;
-/**
- * Validates the structural shape of ModelDefinition using Arktype.
- *
- * @param value - The model value to validate
- * @returns The validated model if structure is valid
- * @throws Error if the model structure is invalid
- */
-declare function validateModel(value: unknown): ModelDefinition;
-/**
- * Validates the structural shape of a SqlContract using Arktype.
- *
- * **Responsibility: Validation Only**
- * This function validates that the contract has the correct structure and types.
- * It does NOT normalize the contract - normalization must happen in the contract builder.
- *
- * The contract passed to this function must already be normalized (all required fields present).
- * If normalization is needed, it should be done by the contract builder before calling this function.
- *
- * This ensures all required fields are present and have the correct types.
- *
- * @param value - The contract value to validate (typically from a JSON import)
- * @returns The validated contract if structure is valid
- * @throws Error if the contract structure is invalid
- */
-declare function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T;
-
-export { validateModel, validateSqlContract, validateStorage };
+export { validateModel, validateSqlContract, validateStorage } from '../validators';
+//# sourceMappingURL=validators.d.ts.map

package/dist/exports/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../src/exports/validators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/dist/exports/validators.js

@@ -3,7 +3,19 @@ import { type } from "arktype";
 var StorageColumnSchema = type.declare().type({
   nativeType: "string",
   codecId: "string",
-  nullable: "boolean"
+  nullable: "boolean",
+  "typeParams?": "Record<string, unknown>",
+  "typeRef?": "string"
+}).narrow((col, ctx) => {
+  if (col.typeParams !== void 0 && col.typeRef !== void 0) {
+    return ctx.mustBe("a column with either typeParams or typeRef, not both");
+  }
+  return true;
+});
+var StorageTypeInstanceSchema = type.declare().type({
+  codecId: "string",
+  nativeType: "string",
+  typeParams: "Record<string, unknown>"
 });
 var PrimaryKeySchema = type.declare().type({
   columns: type.string.array().readonly(),
@@ -34,7 +46,8 @@ var StorageTableSchema = type.declare().type({
   foreignKeys: ForeignKeySchema.array().readonly()
 });
 var StorageSchema = type.declare().type({
-  tables: type({ "[string]": StorageTableSchema })
+  tables: type({ "[string]": StorageTableSchema }),
+  "types?": type({ "[string]": StorageTypeInstanceSchema })
 });
 var ModelFieldSchema = type.declare().type({
   column: "string"

package/dist/exports/validators.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/validators.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type {\n  ForeignKey,\n  ForeignKeyReferences,\n  Index,\n  ModelDefinition,\n  ModelField,\n  ModelStorage,\n  PrimaryKey,\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n  UniqueConstraint,\n} from './types';\n\nconst StorageColumnSchema = type.declare<StorageColumn>().type({\n  nativeType: 'string',\n  codecId: 'string',\n  nullable: 'boolean',\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKey>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraint>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst IndexSchema = type.declare<Index>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({\n  table: 'string',\n  columns: type.string.array().readonly(),\n});\n\nconst ForeignKeySchema = type.declare<ForeignKey>().type({\n  columns: type.string.array().readonly(),\n  references: ForeignKeyReferencesSchema,\n  'name?': 'string',\n});\n\nconst StorageTableSchema = type.declare<StorageTable>().type({\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n});\n\nconst StorageSchema = type.declare<SqlStorage>().type({\n  tables: type({ '[string]': StorageTableSchema }),\n});\n\nconst ModelFieldSchema = type.declare<ModelField>().type({\n  column: 'string',\n});\n\nconst ModelStorageSchema = type.declare<ModelStorage>().type({\n  table: 'string',\n});\n\nconst ModelSchema = type.declare<ModelDefinition>().type({\n  storage: ModelStorageSchema,\n  fields: type({ '[string]': ModelFieldSchema }),\n  relations: type({ '[string]': 'unknown' }),\n});\n\nconst SqlContractSchema = type({\n  'schemaVersion?': \"'1'\",\n  target: 'string',\n  targetFamily: \"'sql'\",\n  coreHash: 'string',\n  'profileHash?': 'string',\n  'capabilities?': 'Record<string, Record<string, boolean>>',\n  'extensionPacks?': 'Record<string, unknown>',\n  'meta?': 'Record<string, unknown>',\n  'sources?': 'Record<string, unknown>',\n  models: type({ '[string]': ModelSchema }),\n  storage: StorageSchema,\n});\n\n/**\n * Validates the structural shape of SqlStorage using Arktype.\n *\n * @param value - The storage value to validate\n * @returns The validated storage if structure is valid\n * @throws Error if the storage structure is invalid\n */\nexport function validateStorage(value: unknown): SqlStorage {\n  const result = StorageSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Storage validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of ModelDefinition using Arktype.\n *\n * @param value - The model value to validate\n * @returns The validated model if structure is valid\n * @throws Error if the model structure is invalid\n */\nexport function validateModel(value: unknown): ModelDefinition {\n  const result = ModelSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Model validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of a SqlContract using Arktype.\n *\n * **Responsibility: Validation Only**\n * This function validates that the contract has the correct structure and types.\n * It does NOT normalize the contract - normalization must happen in the contract builder.\n *\n * The contract passed to this function must already be normalized (all required fields present).\n * If normalization is needed, it should be done by the contract builder before calling this function.\n *\n * This ensures all required fields are present and have the correct types.\n *\n * @param value - The contract value to validate (typically from a JSON import)\n * @returns The validated contract if structure is valid\n * @throws Error if the contract structure is invalid\n */\nexport function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {\n  // Check targetFamily first to provide a clear error message for unsupported target families\n  const rawValue = value as { targetFamily?: string };\n  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {\n    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);\n  }\n\n  const contractResult = SqlContractSchema(value);\n\n  if (contractResult instanceof type.errors) {\n    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Contract structural validation failed: ${messages}`);\n  }\n\n  // After validation, contractResult matches the schema and preserves the input structure\n  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences\n  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible\n  return contractResult as T;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/validators.ts"],"sourcesContent":["import { type } from 'arktype';\nimport type {\n  ForeignKey,\n  ForeignKeyReferences,\n  Index,\n  ModelDefinition,\n  ModelField,\n  ModelStorage,\n  PrimaryKey,\n  SqlContract,\n  SqlStorage,\n  StorageColumn,\n  StorageTable,\n  StorageTypeInstance,\n  UniqueConstraint,\n} from './types';\n\nconst StorageColumnSchema = type\n  .declare<StorageColumn>()\n  .type({\n    nativeType: 'string',\n    codecId: 'string',\n    nullable: 'boolean',\n    'typeParams?': 'Record<string, unknown>',\n    'typeRef?': 'string',\n  })\n  .narrow((col, ctx) => {\n    if (col.typeParams !== undefined && col.typeRef !== undefined) {\n      return ctx.mustBe('a column with either typeParams or typeRef, not both');\n    }\n    return true;\n  });\n\nconst StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({\n  codecId: 'string',\n  nativeType: 'string',\n  typeParams: 'Record<string, unknown>',\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKey>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraint>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst IndexSchema = type.declare<Index>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({\n  table: 'string',\n  columns: type.string.array().readonly(),\n});\n\nconst ForeignKeySchema = type.declare<ForeignKey>().type({\n  columns: type.string.array().readonly(),\n  references: ForeignKeyReferencesSchema,\n  'name?': 'string',\n});\n\nconst StorageTableSchema = type.declare<StorageTable>().type({\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n});\n\nconst StorageSchema = type.declare<SqlStorage>().type({\n  tables: type({ '[string]': StorageTableSchema }),\n  'types?': type({ '[string]': StorageTypeInstanceSchema }),\n});\n\nconst ModelFieldSchema = type.declare<ModelField>().type({\n  column: 'string',\n});\n\nconst ModelStorageSchema = type.declare<ModelStorage>().type({\n  table: 'string',\n});\n\nconst ModelSchema = type.declare<ModelDefinition>().type({\n  storage: ModelStorageSchema,\n  fields: type({ '[string]': ModelFieldSchema }),\n  relations: type({ '[string]': 'unknown' }),\n});\n\nconst SqlContractSchema = type({\n  'schemaVersion?': \"'1'\",\n  target: 'string',\n  targetFamily: \"'sql'\",\n  coreHash: 'string',\n  'profileHash?': 'string',\n  'capabilities?': 'Record<string, Record<string, boolean>>',\n  'extensionPacks?': 'Record<string, unknown>',\n  'meta?': 'Record<string, unknown>',\n  'sources?': 'Record<string, unknown>',\n  models: type({ '[string]': ModelSchema }),\n  storage: StorageSchema,\n});\n\n/**\n * Validates the structural shape of SqlStorage using Arktype.\n *\n * @param value - The storage value to validate\n * @returns The validated storage if structure is valid\n * @throws Error if the storage structure is invalid\n */\nexport function validateStorage(value: unknown): SqlStorage {\n  const result = StorageSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Storage validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of ModelDefinition using Arktype.\n *\n * @param value - The model value to validate\n * @returns The validated model if structure is valid\n * @throws Error if the model structure is invalid\n */\nexport function validateModel(value: unknown): ModelDefinition {\n  const result = ModelSchema(value);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Model validation failed: ${messages}`);\n  }\n  return result;\n}\n\n/**\n * Validates the structural shape of a SqlContract using Arktype.\n *\n * **Responsibility: Validation Only**\n * This function validates that the contract has the correct structure and types.\n * It does NOT normalize the contract - normalization must happen in the contract builder.\n *\n * The contract passed to this function must already be normalized (all required fields present).\n * If normalization is needed, it should be done by the contract builder before calling this function.\n *\n * This ensures all required fields are present and have the correct types.\n *\n * @param value - The contract value to validate (typically from a JSON import)\n * @returns The validated contract if structure is valid\n * @throws Error if the contract structure is invalid\n */\nexport function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {\n  // Check targetFamily first to provide a clear error message for unsupported target families\n  const rawValue = value as { targetFamily?: string };\n  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {\n    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);\n  }\n\n  const contractResult = SqlContractSchema(value);\n\n  if (contractResult instanceof type.errors) {\n    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Contract structural validation failed: ${messages}`);\n  }\n\n  // After validation, contractResult matches the schema and preserves the input structure\n  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences\n  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible\n  return contractResult as T;\n}\n"],"mappings":"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","names":[]}

package/dist/factories.d.ts

@@ -0,0 +1,38 @@
+import type { ForeignKey, Index, ModelDefinition, ModelField, PrimaryKey, SqlContract, SqlMappings, SqlStorage, StorageColumn, StorageTable, UniqueConstraint } from './types';
+/**
+ * Creates a StorageColumn with nativeType and codecId.
+ *
+ * @param nativeType - Native database type identifier (e.g., 'int4', 'text', 'vector')
+ * @param codecId - Codec identifier (e.g., 'pg/int4@1', 'pg/text@1')
+ * @param nullable - Whether the column is nullable (default: false)
+ * @returns StorageColumn with nativeType and codecId
+ */
+export declare function col(nativeType: string, codecId: string, nullable?: boolean): StorageColumn;
+export declare function pk(...columns: readonly string[]): PrimaryKey;
+export declare function unique(...columns: readonly string[]): UniqueConstraint;
+export declare function index(...columns: readonly string[]): Index;
+export declare function fk(columns: readonly string[], refTable: string, refColumns: readonly string[], name?: string): ForeignKey;
+export declare function table(columns: Record<string, StorageColumn>, opts?: {
+    pk?: PrimaryKey;
+    uniques?: readonly UniqueConstraint[];
+    indexes?: readonly Index[];
+    fks?: readonly ForeignKey[];
+}): StorageTable;
+export declare function model(table: string, fields: Record<string, ModelField>, relations?: Record<string, unknown>): ModelDefinition;
+export declare function storage(tables: Record<string, StorageTable>): SqlStorage;
+export declare function contract(opts: {
+    target: string;
+    coreHash: string;
+    storage: SqlStorage;
+    models?: Record<string, ModelDefinition>;
+    relations?: Record<string, unknown>;
+    mappings?: Partial<SqlMappings>;
+    schemaVersion?: '1';
+    targetFamily?: 'sql';
+    profileHash?: string;
+    capabilities?: Record<string, Record<string, boolean>>;
+    extensionPacks?: Record<string, unknown>;
+    meta?: Record<string, unknown>;
+    sources?: Record<string, unknown>;
+}): SqlContract;
+//# sourceMappingURL=factories.d.ts.map

package/dist/factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../src/factories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EAEV,KAAK,EACL,eAAe,EACf,UAAU,EAEV,UAAU,EACV,WAAW,EACX,WAAW,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,UAAQ,GAAG,aAAa,CAMxF;AAED,wBAAgB,EAAE,CAAC,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,UAAU,CAI5D;AAED,wBAAgB,MAAM,CAAC,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,gBAAgB,CAItE;AAED,wBAAgB,KAAK,CAAC,GAAG,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,KAAK,CAI1D;AAED,wBAAgB,EAAE,CAChB,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,IAAI,CAAC,EAAE,MAAM,GACZ,UAAU,CAUZ;AAED,wBAAgB,KAAK,CACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,EACtC,IAAI,CAAC,EAAE;IACL,EAAE,CAAC,EAAE,UAAU,CAAC;IAChB,OAAO,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,OAAO,CAAC,EAAE,SAAS,KAAK,EAAE,CAAC;IAC3B,GAAG,CAAC,EAAE,SAAS,UAAU,EAAE,CAAC;CAC7B,GACA,YAAY,CAQd;AAED,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,EAClC,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACtC,eAAe,CAOjB;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,UAAU,CAExE;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACzC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAChC,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACzC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,GAAG,WAAW,CAgBd"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './exports/factories';
+export * from './exports/types';
+export * from './exports/validators';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC"}

package/dist/pack-types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Storage type metadata for pack refs.
+ */
+export interface StorageTypeMetadata {
+    readonly typeId: string;
+    readonly familyId: string;
+    readonly targetId: string;
+    readonly nativeType?: string;
+}
+//# sourceMappingURL=pack-types.d.ts.map

package/dist/pack-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack-types.d.ts","sourceRoot":"","sources":["../src/pack-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B"}

package/dist/types.d.ts

@@ -0,0 +1,106 @@
+import type { ContractBase } from '@prisma-next/contract/types';
+/**
+ * A column definition in storage.
+ *
+ * `typeParams` is optional because most columns use non-parameterized types.
+ * Columns with parameterized types can either inline `typeParams` or reference
+ * a named {@link StorageTypeInstance} via `typeRef`.
+ */
+export type StorageColumn = {
+    readonly nativeType: string;
+    readonly codecId: string;
+    readonly nullable: boolean;
+    /**
+     * Opaque, codec-owned JS/type parameters.
+     * The codec that owns `codecId` defines the shape and semantics.
+     * Mutually exclusive with `typeRef`.
+     */
+    readonly typeParams?: Record<string, unknown>;
+    /**
+     * Reference to a named type instance in `storage.types`.
+     * Mutually exclusive with `typeParams`.
+     */
+    readonly typeRef?: string;
+};
+export type PrimaryKey = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+export type UniqueConstraint = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+export type Index = {
+    readonly columns: readonly string[];
+    readonly name?: string;
+};
+export type ForeignKeyReferences = {
+    readonly table: string;
+    readonly columns: readonly string[];
+};
+export type ForeignKey = {
+    readonly columns: readonly string[];
+    readonly references: ForeignKeyReferences;
+    readonly name?: string;
+};
+export type StorageTable = {
+    readonly columns: Record<string, StorageColumn>;
+    readonly primaryKey?: PrimaryKey;
+    readonly uniques: ReadonlyArray<UniqueConstraint>;
+    readonly indexes: ReadonlyArray<Index>;
+    readonly foreignKeys: ReadonlyArray<ForeignKey>;
+};
+/**
+ * A named, parameterized type instance.
+ * These are registered in `storage.types` for reuse across columns
+ * and to enable ergonomic schema surfaces like `schema.types.MyType`.
+ *
+ * Unlike {@link StorageColumn}, `typeParams` is required here because
+ * `StorageTypeInstance` exists specifically to define reusable parameterized types.
+ * A type instance without parameters would be redundant—columns can reference
+ * the codec directly via `codecId`.
+ */
+export type StorageTypeInstance = {
+    readonly codecId: string;
+    readonly nativeType: string;
+    readonly typeParams: Record<string, unknown>;
+};
+export type SqlStorage = {
+    readonly tables: Record<string, StorageTable>;
+    /**
+     * Named type instances for parameterized/custom types.
+     * Columns can reference these via `typeRef`.
+     */
+    readonly types?: Record<string, StorageTypeInstance>;
+};
+export type ModelField = {
+    readonly column: string;
+};
+export type ModelStorage = {
+    readonly table: string;
+};
+export type ModelDefinition = {
+    readonly storage: ModelStorage;
+    readonly fields: Record<string, ModelField>;
+    readonly relations: Record<string, unknown>;
+};
+export type SqlMappings = {
+    readonly modelToTable?: Record<string, string>;
+    readonly tableToModel?: Record<string, string>;
+    readonly fieldToColumn?: Record<string, Record<string, string>>;
+    readonly columnToField?: Record<string, Record<string, string>>;
+    readonly codecTypes: Record<string, {
+        readonly output: unknown;
+    }>;
+    readonly operationTypes: Record<string, Record<string, unknown>>;
+};
+export type SqlContract<S extends SqlStorage = SqlStorage, M extends Record<string, unknown> = Record<string, unknown>, R extends Record<string, unknown> = Record<string, unknown>, Map extends SqlMappings = SqlMappings> = ContractBase & {
+    readonly targetFamily: string;
+    readonly storage: S;
+    readonly models: M;
+    readonly relations: R;
+    readonly mappings: Map;
+};
+export type ExtractCodecTypes<TContract extends SqlContract<SqlStorage>> = TContract['mappings']['codecTypes'];
+export type ExtractOperationTypes<TContract extends SqlContract<SqlStorage>> = TContract['mappings']['operationTypes'];
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/validators.d.ts

@@ -0,0 +1,35 @@
+import type { ModelDefinition, SqlContract, SqlStorage } from './types';
+/**
+ * Validates the structural shape of SqlStorage using Arktype.
+ *
+ * @param value - The storage value to validate
+ * @returns The validated storage if structure is valid
+ * @throws Error if the storage structure is invalid
+ */
+export declare function validateStorage(value: unknown): SqlStorage;
+/**
+ * Validates the structural shape of ModelDefinition using Arktype.
+ *
+ * @param value - The model value to validate
+ * @returns The validated model if structure is valid
+ * @throws Error if the model structure is invalid
+ */
+export declare function validateModel(value: unknown): ModelDefinition;
+/**
+ * Validates the structural shape of a SqlContract using Arktype.
+ *
+ * **Responsibility: Validation Only**
+ * This function validates that the contract has the correct structure and types.
+ * It does NOT normalize the contract - normalization must happen in the contract builder.
+ *
+ * The contract passed to this function must already be normalized (all required fields present).
+ * If normalization is needed, it should be done by the contract builder before calling this function.
+ *
+ * This ensures all required fields are present and have the correct types.
+ *
+ * @param value - The contract value to validate (typically from a JSON import)
+ * @returns The validated contract if structure is valid
+ * @throws Error if the contract structure is invalid
+ */
+export declare function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T;
+//# sourceMappingURL=validators.d.ts.map

package/dist/validators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../src/validators.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAIV,eAAe,EAIf,WAAW,EACX,UAAU,EAKX,MAAM,SAAS,CAAC;AA2FjB;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAO1D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAO7D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,WAAW,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,OAAO,GAAG,CAAC,CAkBxF"}

package/package.json

@@ -1,22 +1,23 @@
 {
   "name": "@prisma-next/sql-contract",
-  "version": "0.3.0-dev.3",
+  "version": "0.3.0-dev.31",
   "type": "module",
   "sideEffects": false,
   "description": "SQL contract types, validators, and IR factories for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.25",
-    "@prisma-next/contract": "0.3.0-dev.3"
+    "@prisma-next/contract": "0.3.0-dev.31"
   },
   "devDependencies": {
-    "@vitest/coverage-v8": "^4.0.0",
-    "tsup": "^8.3.0",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.16",
-    "@prisma-next/test-utils": "0.0.1"
+    "tsup": "8.5.1",
+    "typescript": "5.9.3",
+    "vitest": "4.0.16",
+    "@prisma-next/test-utils": "0.0.1",
+    "@prisma-next/tsconfig": "0.0.0"
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "exports": {
     "./types": {
@@ -37,13 +38,13 @@
     }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --project tsconfig.json --noEmit",
-    "lint": "biome check . --config-path ../../../../biome.json --error-on-warnings",
-    "lint:fix": "biome check --write . --config-path ../../../biome.json",
-    "lint:fix:unsafe": "biome check --write --unsafe . --config-path ../../../biome.json",
-    "clean": "node ../../../../scripts/clean.mjs"
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
   }
 }

package/src/exports/factories.ts

@@ -0,0 +1,11 @@
+export {
+  col,
+  contract,
+  fk,
+  index,
+  model,
+  pk,
+  storage,
+  table,
+  unique,
+} from '../factories';

package/src/exports/pack-types.ts

@@ -0,0 +1 @@
+export type { StorageTypeMetadata } from '../pack-types';

package/src/exports/types.ts

@@ -0,0 +1,18 @@
+export type {
+  ExtractCodecTypes,
+  ExtractOperationTypes,
+  ForeignKey,
+  ForeignKeyReferences,
+  Index,
+  ModelDefinition,
+  ModelField,
+  ModelStorage,
+  PrimaryKey,
+  SqlContract,
+  SqlMappings,
+  SqlStorage,
+  StorageColumn,
+  StorageTable,
+  StorageTypeInstance,
+  UniqueConstraint,
+} from '../types';

package/src/exports/validators.ts

@@ -0,0 +1 @@
+export { validateModel, validateSqlContract, validateStorage } from '../validators';

package/src/factories.ts

@@ -0,0 +1,133 @@
+import type {
+  ForeignKey,
+  ForeignKeyReferences,
+  Index,
+  ModelDefinition,
+  ModelField,
+  ModelStorage,
+  PrimaryKey,
+  SqlContract,
+  SqlMappings,
+  SqlStorage,
+  StorageColumn,
+  StorageTable,
+  UniqueConstraint,
+} from './types';
+
+/**
+ * Creates a StorageColumn with nativeType and codecId.
+ *
+ * @param nativeType - Native database type identifier (e.g., 'int4', 'text', 'vector')
+ * @param codecId - Codec identifier (e.g., 'pg/int4@1', 'pg/text@1')
+ * @param nullable - Whether the column is nullable (default: false)
+ * @returns StorageColumn with nativeType and codecId
+ */
+export function col(nativeType: string, codecId: string, nullable = false): StorageColumn {
+  return {
+    nativeType,
+    codecId,
+    nullable,
+  };
+}
+
+export function pk(...columns: readonly string[]): PrimaryKey {
+  return {
+    columns,
+  };
+}
+
+export function unique(...columns: readonly string[]): UniqueConstraint {
+  return {
+    columns,
+  };
+}
+
+export function index(...columns: readonly string[]): Index {
+  return {
+    columns,
+  };
+}
+
+export function fk(
+  columns: readonly string[],
+  refTable: string,
+  refColumns: readonly string[],
+  name?: string,
+): ForeignKey {
+  const references: ForeignKeyReferences = {
+    table: refTable,
+    columns: refColumns,
+  };
+  return {
+    columns,
+    references,
+    ...(name !== undefined && { name }),
+  };
+}
+
+export function table(
+  columns: Record<string, StorageColumn>,
+  opts?: {
+    pk?: PrimaryKey;
+    uniques?: readonly UniqueConstraint[];
+    indexes?: readonly Index[];
+    fks?: readonly ForeignKey[];
+  },
+): StorageTable {
+  return {
+    columns,
+    ...(opts?.pk !== undefined && { primaryKey: opts.pk }),
+    uniques: opts?.uniques ?? [],
+    indexes: opts?.indexes ?? [],
+    foreignKeys: opts?.fks ?? [],
+  };
+}
+
+export function model(
+  table: string,
+  fields: Record<string, ModelField>,
+  relations: Record<string, unknown> = {},
+): ModelDefinition {
+  const storage: ModelStorage = { table };
+  return {
+    storage,
+    fields,
+    relations,
+  };
+}
+
+export function storage(tables: Record<string, StorageTable>): SqlStorage {
+  return { tables };
+}
+
+export function contract(opts: {
+  target: string;
+  coreHash: string;
+  storage: SqlStorage;
+  models?: Record<string, ModelDefinition>;
+  relations?: Record<string, unknown>;
+  mappings?: Partial<SqlMappings>;
+  schemaVersion?: '1';
+  targetFamily?: 'sql';
+  profileHash?: string;
+  capabilities?: Record<string, Record<string, boolean>>;
+  extensionPacks?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+  sources?: Record<string, unknown>;
+}): SqlContract {
+  return {
+    schemaVersion: opts.schemaVersion ?? '1',
+    target: opts.target,
+    targetFamily: opts.targetFamily ?? 'sql',
+    coreHash: opts.coreHash,
+    storage: opts.storage,
+    models: opts.models ?? {},
+    relations: opts.relations ?? {},
+    mappings: (opts.mappings ?? {}) as SqlMappings,
+    ...(opts.profileHash !== undefined && { profileHash: opts.profileHash }),
+    ...(opts.capabilities !== undefined && { capabilities: opts.capabilities }),
+    ...(opts.extensionPacks !== undefined && { extensionPacks: opts.extensionPacks }),
+    ...(opts.meta !== undefined && { meta: opts.meta }),
+    ...(opts.sources !== undefined && { sources: opts.sources as Record<string, unknown> }),
+  } as SqlContract;
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './exports/factories';
+export * from './exports/types';
+export * from './exports/validators';

package/src/pack-types.ts

@@ -0,0 +1,9 @@
+/**
+ * Storage type metadata for pack refs.
+ */
+export interface StorageTypeMetadata {
+  readonly typeId: string;
+  readonly familyId: string;
+  readonly targetId: string;
+  readonly nativeType?: string;
+}

package/src/types.ts

@@ -0,0 +1,126 @@
+import type { ContractBase } from '@prisma-next/contract/types';
+
+/**
+ * A column definition in storage.
+ *
+ * `typeParams` is optional because most columns use non-parameterized types.
+ * Columns with parameterized types can either inline `typeParams` or reference
+ * a named {@link StorageTypeInstance} via `typeRef`.
+ */
+export type StorageColumn = {
+  readonly nativeType: string;
+  readonly codecId: string;
+  readonly nullable: boolean;
+  /**
+   * Opaque, codec-owned JS/type parameters.
+   * The codec that owns `codecId` defines the shape and semantics.
+   * Mutually exclusive with `typeRef`.
+   */
+  readonly typeParams?: Record<string, unknown>;
+  /**
+   * Reference to a named type instance in `storage.types`.
+   * Mutually exclusive with `typeParams`.
+   */
+  readonly typeRef?: string;
+};
+
+export type PrimaryKey = {
+  readonly columns: readonly string[];
+  readonly name?: string;
+};
+
+export type UniqueConstraint = {
+  readonly columns: readonly string[];
+  readonly name?: string;
+};
+
+export type Index = {
+  readonly columns: readonly string[];
+  readonly name?: string;
+};
+
+export type ForeignKeyReferences = {
+  readonly table: string;
+  readonly columns: readonly string[];
+};
+
+export type ForeignKey = {
+  readonly columns: readonly string[];
+  readonly references: ForeignKeyReferences;
+  readonly name?: string;
+};
+
+export type StorageTable = {
+  readonly columns: Record<string, StorageColumn>;
+  readonly primaryKey?: PrimaryKey;
+  readonly uniques: ReadonlyArray<UniqueConstraint>;
+  readonly indexes: ReadonlyArray<Index>;
+  readonly foreignKeys: ReadonlyArray<ForeignKey>;
+};
+
+/**
+ * A named, parameterized type instance.
+ * These are registered in `storage.types` for reuse across columns
+ * and to enable ergonomic schema surfaces like `schema.types.MyType`.
+ *
+ * Unlike {@link StorageColumn}, `typeParams` is required here because
+ * `StorageTypeInstance` exists specifically to define reusable parameterized types.
+ * A type instance without parameters would be redundant—columns can reference
+ * the codec directly via `codecId`.
+ */
+export type StorageTypeInstance = {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams: Record<string, unknown>;
+};
+
+export type SqlStorage = {
+  readonly tables: Record<string, StorageTable>;
+  /**
+   * Named type instances for parameterized/custom types.
+   * Columns can reference these via `typeRef`.
+   */
+  readonly types?: Record<string, StorageTypeInstance>;
+};
+
+export type ModelField = {
+  readonly column: string;
+};
+
+export type ModelStorage = {
+  readonly table: string;
+};
+
+export type ModelDefinition = {
+  readonly storage: ModelStorage;
+  readonly fields: Record<string, ModelField>;
+  readonly relations: Record<string, unknown>;
+};
+
+export type SqlMappings = {
+  readonly modelToTable?: Record<string, string>;
+  readonly tableToModel?: Record<string, string>;
+  readonly fieldToColumn?: Record<string, Record<string, string>>;
+  readonly columnToField?: Record<string, Record<string, string>>;
+  readonly codecTypes: Record<string, { readonly output: unknown }>;
+  readonly operationTypes: Record<string, Record<string, unknown>>;
+};
+
+export type SqlContract<
+  S extends SqlStorage = SqlStorage,
+  M extends Record<string, unknown> = Record<string, unknown>,
+  R extends Record<string, unknown> = Record<string, unknown>,
+  Map extends SqlMappings = SqlMappings,
+> = ContractBase & {
+  readonly targetFamily: string;
+  readonly storage: S;
+  readonly models: M;
+  readonly relations: R;
+  readonly mappings: Map;
+};
+
+export type ExtractCodecTypes<TContract extends SqlContract<SqlStorage>> =
+  TContract['mappings']['codecTypes'];
+
+export type ExtractOperationTypes<TContract extends SqlContract<SqlStorage>> =
+  TContract['mappings']['operationTypes'];

package/src/validators.ts

@@ -0,0 +1,173 @@
+import { type } from 'arktype';
+import type {
+  ForeignKey,
+  ForeignKeyReferences,
+  Index,
+  ModelDefinition,
+  ModelField,
+  ModelStorage,
+  PrimaryKey,
+  SqlContract,
+  SqlStorage,
+  StorageColumn,
+  StorageTable,
+  StorageTypeInstance,
+  UniqueConstraint,
+} from './types';
+
+const StorageColumnSchema = type
+  .declare<StorageColumn>()
+  .type({
+    nativeType: 'string',
+    codecId: 'string',
+    nullable: 'boolean',
+    'typeParams?': 'Record<string, unknown>',
+    'typeRef?': 'string',
+  })
+  .narrow((col, ctx) => {
+    if (col.typeParams !== undefined && col.typeRef !== undefined) {
+      return ctx.mustBe('a column with either typeParams or typeRef, not both');
+    }
+    return true;
+  });
+
+const StorageTypeInstanceSchema = type.declare<StorageTypeInstance>().type({
+  codecId: 'string',
+  nativeType: 'string',
+  typeParams: 'Record<string, unknown>',
+});
+
+const PrimaryKeySchema = type.declare<PrimaryKey>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const UniqueConstraintSchema = type.declare<UniqueConstraint>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const IndexSchema = type.declare<Index>().type({
+  columns: type.string.array().readonly(),
+  'name?': 'string',
+});
+
+const ForeignKeyReferencesSchema = type.declare<ForeignKeyReferences>().type({
+  table: 'string',
+  columns: type.string.array().readonly(),
+});
+
+const ForeignKeySchema = type.declare<ForeignKey>().type({
+  columns: type.string.array().readonly(),
+  references: ForeignKeyReferencesSchema,
+  'name?': 'string',
+});
+
+const StorageTableSchema = type.declare<StorageTable>().type({
+  columns: type({ '[string]': StorageColumnSchema }),
+  'primaryKey?': PrimaryKeySchema,
+  uniques: UniqueConstraintSchema.array().readonly(),
+  indexes: IndexSchema.array().readonly(),
+  foreignKeys: ForeignKeySchema.array().readonly(),
+});
+
+const StorageSchema = type.declare<SqlStorage>().type({
+  tables: type({ '[string]': StorageTableSchema }),
+  'types?': type({ '[string]': StorageTypeInstanceSchema }),
+});
+
+const ModelFieldSchema = type.declare<ModelField>().type({
+  column: 'string',
+});
+
+const ModelStorageSchema = type.declare<ModelStorage>().type({
+  table: 'string',
+});
+
+const ModelSchema = type.declare<ModelDefinition>().type({
+  storage: ModelStorageSchema,
+  fields: type({ '[string]': ModelFieldSchema }),
+  relations: type({ '[string]': 'unknown' }),
+});
+
+const SqlContractSchema = type({
+  'schemaVersion?': "'1'",
+  target: 'string',
+  targetFamily: "'sql'",
+  coreHash: 'string',
+  'profileHash?': 'string',
+  'capabilities?': 'Record<string, Record<string, boolean>>',
+  'extensionPacks?': 'Record<string, unknown>',
+  'meta?': 'Record<string, unknown>',
+  'sources?': 'Record<string, unknown>',
+  models: type({ '[string]': ModelSchema }),
+  storage: StorageSchema,
+});
+
+/**
+ * Validates the structural shape of SqlStorage using Arktype.
+ *
+ * @param value - The storage value to validate
+ * @returns The validated storage if structure is valid
+ * @throws Error if the storage structure is invalid
+ */
+export function validateStorage(value: unknown): SqlStorage {
+  const result = StorageSchema(value);
+  if (result instanceof type.errors) {
+    const messages = result.map((p: { message: string }) => p.message).join('; ');
+    throw new Error(`Storage validation failed: ${messages}`);
+  }
+  return result;
+}
+
+/**
+ * Validates the structural shape of ModelDefinition using Arktype.
+ *
+ * @param value - The model value to validate
+ * @returns The validated model if structure is valid
+ * @throws Error if the model structure is invalid
+ */
+export function validateModel(value: unknown): ModelDefinition {
+  const result = ModelSchema(value);
+  if (result instanceof type.errors) {
+    const messages = result.map((p: { message: string }) => p.message).join('; ');
+    throw new Error(`Model validation failed: ${messages}`);
+  }
+  return result;
+}
+
+/**
+ * Validates the structural shape of a SqlContract using Arktype.
+ *
+ * **Responsibility: Validation Only**
+ * This function validates that the contract has the correct structure and types.
+ * It does NOT normalize the contract - normalization must happen in the contract builder.
+ *
+ * The contract passed to this function must already be normalized (all required fields present).
+ * If normalization is needed, it should be done by the contract builder before calling this function.
+ *
+ * This ensures all required fields are present and have the correct types.
+ *
+ * @param value - The contract value to validate (typically from a JSON import)
+ * @returns The validated contract if structure is valid
+ * @throws Error if the contract structure is invalid
+ */
+export function validateSqlContract<T extends SqlContract<SqlStorage>>(value: unknown): T {
+  // Check targetFamily first to provide a clear error message for unsupported target families
+  const rawValue = value as { targetFamily?: string };
+  if (rawValue.targetFamily !== undefined && rawValue.targetFamily !== 'sql') {
+    throw new Error(`Unsupported target family: ${rawValue.targetFamily}`);
+  }
+
+  const contractResult = SqlContractSchema(value);
+
+  if (contractResult instanceof type.errors) {
+    const messages = contractResult.map((p: { message: string }) => p.message).join('; ');
+    throw new Error(`Contract structural validation failed: ${messages}`);
+  }
+
+  // After validation, contractResult matches the schema and preserves the input structure
+  // TypeScript needs an assertion here due to exactOptionalPropertyTypes differences
+  // between Arktype's inferred type and the generic T, but runtime-wise they're compatible
+  return contractResult as T;
+}