@prisma-next/sql-contract 0.14.0 → 0.15.0-dev.1

package/dist/canonicalization-hooks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"canonicalization-hooks.d.mts","names":[],"sources":["../src/canonicalization-hooks.ts"],"mappings":";;;cAwBa,gCAAA;EAAA,SACF,mBAAA,EAAqB,sBAAA;EAAA,SACrB,WAAA,EAAa,WAAW;AAAA"}
+{"version":3,"file":"canonicalization-hooks.d.mts","names":[],"sources":["../src/canonicalization-hooks.ts"],"mappings":";;;cAoDa,gCAAA;EAAA,SACF,mBAAA,EAAqB,sBAAA;EAAA,SACrB,WAAA,EAAa,WAAW;AAAA"}

package/dist/canonicalization-hooks.mjs

@@ -1,55 +1,75 @@
-import { createPreserveEmptyPredicate, createStorageSort } from "@prisma-next/contract/hashing-utils";
-const sqlContractCanonicalizationHooks = {
-	shouldPreserveEmpty: createPreserveEmptyPredicate([
-		[
-			"storage",
-			"namespaces",
-			"*",
-			"entries",
-			"table"
-		],
-		[
-			"storage",
-			"namespaces",
-			"*",
-			"entries",
-			"table",
-			"*"
-		],
+import { createPreserveEmptyPredicate, createStorageSort, matchesPathPattern } from "@prisma-next/contract/hashing-utils";
+//#region src/canonicalization-hooks.ts
+const preserveEmptyPatterns = [
+	[
+		"storage",
+		"namespaces",
+		"*",
+		"entries",
+		"table"
+	],
+	[
+		"storage",
+		"namespaces",
+		"*",
+		"entries",
+		"table",
+		"*"
+	],
+	[
+		"storage",
+		"namespaces",
+		"*",
+		"entries",
+		"table",
+		"*",
 		[
-			"storage",
-			"namespaces",
-			"*",
-			"entries",
-			"table",
-			"*",
-			[
-				"uniques",
-				"indexes",
-				"foreignKeys"
-			]
-		],
-		[
-			"storage",
-			"namespaces",
-			"*",
-			"entries",
-			"table",
-			"*",
-			"foreignKeys",
-			["constraint", "index"]
+			"uniques",
+			"indexes",
+			"foreignKeys"
 		]
-	]),
-	sortStorage: createStorageSort([{
-		path: [
-			"namespaces",
-			"*",
-			"entries",
-			"table",
-			"*"
-		],
-		arrayKeys: ["indexes", "uniques"]
-	}])
+	],
+	[
+		"storage",
+		"namespaces",
+		"*",
+		"entries",
+		"table",
+		"*",
+		"columns",
+		"*",
+		"default",
+		"value"
+	]
+];
+const columnDefaultValuePrefix = [
+	"storage",
+	"namespaces",
+	"*",
+	"entries",
+	"table",
+	"*",
+	"columns",
+	"*",
+	"default",
+	"value"
+];
+const isColumnDefaultValuePath = (path) => path.length >= columnDefaultValuePrefix.length && matchesPathPattern(path.slice(0, columnDefaultValuePrefix.length), columnDefaultValuePrefix);
+const sortTargets = [{
+	path: [
+		"namespaces",
+		"*",
+		"entries",
+		"table",
+		"*"
+	],
+	arrayKeys: ["indexes", "uniques"]
+}];
+const matchesPreserveEmptyPattern = createPreserveEmptyPredicate(preserveEmptyPatterns);
+const shouldPreserveEmpty = (path) => isColumnDefaultValuePath(path) || matchesPreserveEmptyPattern(path);
+const sqlContractCanonicalizationHooks = {
+	shouldPreserveEmpty,
+	sortStorage: createStorageSort(sortTargets)
 };
 //#endregion
 export { sqlContractCanonicalizationHooks };

package/dist/canonicalization-hooks.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"canonicalization-hooks.mjs","names":[],"sources":["../src/canonicalization-hooks.ts"],"sourcesContent":["import type { PreserveEmptyPredicate, StorageSort } from '@prisma-next/contract/hashing';\nimport {\n  createPreserveEmptyPredicate,\n  createStorageSort,\n  type NamedArraySortTarget,\n  type PathPattern,\n} from '@prisma-next/contract/hashing-utils';\n\nconst preserveEmptyPatterns = [\n  ['storage', 'namespaces', '*', 'entries', 'table'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', ['uniques', 'indexes', 'foreignKeys']],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'foreignKeys', ['constraint', 'index']],\n] as const satisfies readonly PathPattern[];\n\nconst sortTargets = [\n  { path: ['namespaces', '*', 'entries', 'table', '*'], arrayKeys: ['indexes', 'uniques'] },\n] as const satisfies readonly NamedArraySortTarget[];\n\nconst shouldPreserveEmpty: PreserveEmptyPredicate =\n  createPreserveEmptyPredicate(preserveEmptyPatterns);\n\nconst sortStorage: StorageSort = createStorageSort(sortTargets);\n\nexport const sqlContractCanonicalizationHooks: {\n  readonly shouldPreserveEmpty: PreserveEmptyPredicate;\n  readonly sortStorage: StorageSort;\n} = {\n  shouldPreserveEmpty,\n  sortStorage,\n};\n"],"mappings":";AAwBA,MAAa,mCAGT;CACF,qBARA,6BAA6B;EAX7B;GAAC;GAAW;GAAc;GAAK;GAAW;EAAO;EACjD;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;EAAG;EACtD;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;GAAK;IAAC;IAAW;IAAW;GAAa;EAAC;EAC7F;GAAC;GAAW;GAAc;GAAK;GAAW;GAAS;GAAK;GAAe,CAAC,cAAc,OAAO;EAAC;CAQjE,CAQ7B;CACA,aAP+B,kBAAkB,CANjD;EAAE,MAAM;GAAC;GAAc;GAAK;GAAW;GAAS;EAAG;EAAG,WAAW,CAAC,WAAW,SAAS;CAAE,CAMvC,CAOjD;AACF"}
+{"version":3,"file":"canonicalization-hooks.mjs","names":[],"sources":["../src/canonicalization-hooks.ts"],"sourcesContent":["import type { PreserveEmptyPredicate, StorageSort } from '@prisma-next/contract/hashing';\nimport {\n  createPreserveEmptyPredicate,\n  createStorageSort,\n  matchesPathPattern,\n  type NamedArraySortTarget,\n  type PathPattern,\n} from '@prisma-next/contract/hashing-utils';\n\nconst preserveEmptyPatterns = [\n  ['storage', 'namespaces', '*', 'entries', 'table'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*'],\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', ['uniques', 'indexes', 'foreignKeys']],\n  // A column default's literal payload is data, not shape — `{ kind:\n  // 'literal', value: false }` (or `value: []`) must survive the\n  // default-omission walk or the emitted contract fails its own\n  // validation on the next read (PN-CLI-4003 on `Boolean @default(false)`).\n  ['storage', 'namespaces', '*', 'entries', 'table', '*', 'columns', '*', 'default', 'value'],\n] as const satisfies readonly PathPattern[];\n\n// A literal column default's value is user data, not omittable structure:\n// `@default(false)` (and empty objects/arrays at any depth inside the value)\n// must survive canonicalization, or the emitted contract fails the runtime's\n// structural validation with `default.value … (was missing)`.\nconst columnDefaultValuePrefix = [\n  'storage',\n  'namespaces',\n  '*',\n  'entries',\n  'table',\n  '*',\n  'columns',\n  '*',\n  'default',\n  'value',\n] as const satisfies PathPattern;\n\nconst isColumnDefaultValuePath = (path: readonly string[]): boolean =>\n  path.length >= columnDefaultValuePrefix.length &&\n  matchesPathPattern(path.slice(0, columnDefaultValuePrefix.length), columnDefaultValuePrefix);\n\nconst sortTargets = [\n  { path: ['namespaces', '*', 'entries', 'table', '*'], arrayKeys: ['indexes', 'uniques'] },\n] as const satisfies readonly NamedArraySortTarget[];\n\nconst matchesPreserveEmptyPattern = createPreserveEmptyPredicate(preserveEmptyPatterns);\n\nconst shouldPreserveEmpty: PreserveEmptyPredicate = (path) =>\n  isColumnDefaultValuePath(path) || matchesPreserveEmptyPattern(path);\n\nconst sortStorage: StorageSort = createStorageSort(sortTargets);\n\nexport const sqlContractCanonicalizationHooks: {\n  readonly shouldPreserveEmpty: PreserveEmptyPredicate;\n  readonly sortStorage: StorageSort;\n} = {\n  shouldPreserveEmpty,\n  sortStorage,\n};\n"],"mappings":";;AASA,MAAM,wBAAwB;CAC5B;EAAC;EAAW;EAAc;EAAK;EAAW;CAAO;CACjD;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;CAAG;CACtD;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;GAAC;GAAW;GAAW;EAAa;CAAC;CAK7F;EAAC;EAAW;EAAc;EAAK;EAAW;EAAS;EAAK;EAAW;EAAK;EAAW;CAAO;AAC5F;AAMA,MAAM,2BAA2B;CAC/B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,4BAA4B,SAChC,KAAK,UAAU,yBAAyB,UACxC,mBAAmB,KAAK,MAAM,GAAG,yBAAyB,MAAM,GAAG,wBAAwB;AAE7F,MAAM,cAAc,CAClB;CAAE,MAAM;EAAC;EAAc;EAAK;EAAW;EAAS;CAAG;CAAG,WAAW,CAAC,WAAW,SAAS;AAAE,CAC1F;AAEA,MAAM,8BAA8B,6BAA6B,qBAAqB;AAEtF,MAAM,uBAA+C,SACnD,yBAAyB,IAAI,KAAK,4BAA4B,IAAI;AAIpE,MAAa,mCAGT;CACF;CACA,aAP+B,kBAAkB,WAOjD;AACF"}

package/dist/contract-view.d.mts

@@ -0,0 +1,61 @@
+import { s as SqlStorage } from "./sql-storage-p-Wzt_MO.mjs";
+import { DefaultNamespaceEntries, NamespacedEntities, SingleNamespaceView } from "@prisma-next/framework-components/ir";
+import { Contract } from "@prisma-next/contract/types";
+
+//#region src/contract-view.d.ts
+/**
+ * The SQL family's statically-named built-in entity kinds. `table` and
+ * `valueSet` are promoted to top-level view accessors; pack-contributed kinds
+ * (e.g. `policy`) stay under `.entries`.
+ */
+declare const SQL_BUILTIN_KINDS: readonly ["table", "valueSet"];
+type SqlBuiltinKind = (typeof SQL_BUILTIN_KINDS)[number];
+type SqlEntries<TContract extends Contract<SqlStorage>> = DefaultNamespaceEntries<TContract['storage']>;
+/**
+ * The single-namespace SQL accessors: `table`/`valueSet` top-level, pack kinds
+ * under `entries`. A target that never emits a built-in kind (SQLite has
+ * `sql.enums: false`, so it emits no `valueSet`) resolves that slot to an empty
+ * map.
+ */
+type SqlSingleNamespaceAccessors<TContract extends Contract<SqlStorage>> = SingleNamespaceView<SqlEntries<TContract>, SqlBuiltinKind>;
+/**
+ * Single-namespace SQL view: the deserialized contract intersected with the
+ * by-name accessors, so the value is substitutable for `Contract` while also
+ * exposing:
+ *  - `view.table.<name>` / `view.valueSet.<name>` — built-in kinds, sole
+ *    namespace unwrapped to the root; pack kinds under `view.entries.<kind>`.
+ *  - `view.namespace.<id>` — the namespace-keyed entity map (SQLite's sole
+ *    namespace is `__unbound__`). Mirrors the runtime `db.enums` pattern.
+ */
+type SqlSingleNamespaceView<TContract extends Contract<SqlStorage>> = TContract & SqlSingleNamespaceAccessors<TContract> & {
+  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+};
+/**
+ * Builds the single-namespace SQL view: unwraps the sole namespace's SQL
+ * built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed
+ * `namespace` map, and layers both over the deserialized contract. Targets with
+ * one default namespace (SQLite) call this directly; Postgres qualifies by
+ * schema.
+ */
+declare function buildSqlSingleNamespaceView<TContract extends Contract<SqlStorage>>(contract: TContract): SqlSingleNamespaceView<TContract>;
+/**
+ * Schema-qualified SQL view: the deserialized contract intersected with a single
+ * `view.namespace.<id>` member — every schema reached by raw id
+ * (`view.namespace.public.table.users`), mirroring the runtime `db.enums.<ns>`
+ * keying exactly (the default schema keeps its literal `__unbound__` id). There
+ * is NO root schema-name promotion, so there is no collision with contract
+ * envelope fields — `view.storage` is always the contract's `storage`. Postgres
+ * uses this; SQLite (single default namespace) uses
+ * {@link buildSqlSingleNamespaceView}.
+ */
+type SqlSchemaQualifiedView<TContract extends Contract<SqlStorage>> = TContract & {
+  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;
+};
+/**
+ * Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`
+ * map over the deserialized contract. Postgres uses this.
+ */
+declare function buildSqlSchemaQualifiedView<TContract extends Contract<SqlStorage>>(contract: TContract): SqlSchemaQualifiedView<TContract>;
+//#endregion
+export { SQL_BUILTIN_KINDS, type SqlBuiltinKind, type SqlSchemaQualifiedView, type SqlSingleNamespaceAccessors, type SqlSingleNamespaceView, buildSqlSchemaQualifiedView, buildSqlSingleNamespaceView };
+//# sourceMappingURL=contract-view.d.mts.map

package/dist/contract-view.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-view.d.mts","names":[],"sources":["../src/contract-view.ts"],"mappings":";;;;;;;AAeA;;;cAAa,iBAAA;AAAA,KACD,cAAA,WAAyB,iBAAiB;AAAA,KAEjD,UAAA,mBAA6B,QAAA,CAAS,UAAA,KAAe,uBAAA,CACxD,SAAA;;;;AAHoD;AAAU;;KAYpD,2BAAA,mBAA8C,QAAA,CAAS,UAAA,KACjE,mBAAA,CAAoB,UAAA,CAAW,SAAA,GAAY,cAAA;;;;;;;;;;KAWjC,sBAAA,mBAAyC,QAAA,CAAS,UAAA,KAAe,SAAA,GAC3E,2BAAA,CAA4B,SAAA;EAAA,SACjB,SAAA,EAAW,kBAAA,CAAmB,SAAA,aAAsB,cAAA;AAAA;AAvBtD;AASX;;;;;;AATW,iBAiCK,2BAAA,mBAA8C,QAAA,CAAS,UAAA,GACrE,QAAA,EAAU,SAAA,GACT,sBAAA,CAAuB,SAAA;;;;;;;;;;;KAyBd,sBAAA,mBAAyC,QAAA,CAAS,UAAA,KAAe,SAAA;EAAA,SAClE,SAAA,EAAW,kBAAA,CAAmB,SAAA,aAAsB,cAAA;AAAA;AAxC/D;;;;AAAA,iBA+CgB,2BAAA,mBAA8C,QAAA,CAAS,UAAA,GACrE,QAAA,EAAU,SAAA,GACT,sBAAA,CAAuB,SAAA"}

package/dist/contract-view.mjs

@@ -0,0 +1,39 @@
+import { buildNamespacedEntities, buildSingleNamespaceView } from "@prisma-next/framework-components/ir";
+//#region src/contract-view.ts
+/**
+* The SQL family's statically-named built-in entity kinds. `table` and
+* `valueSet` are promoted to top-level view accessors; pack-contributed kinds
+* (e.g. `policy`) stay under `.entries`.
+*/
+const SQL_BUILTIN_KINDS = ["table", "valueSet"];
+/**
+* Builds the single-namespace SQL view: unwraps the sole namespace's SQL
+* built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed
+* `namespace` map, and layers both over the deserialized contract. Targets with
+* one default namespace (SQLite) call this directly; Postgres qualifies by
+* schema.
+*/
+function buildSqlSingleNamespaceView(contract) {
+	const rootAccessors = buildSingleNamespaceView(contract.storage, SQL_BUILTIN_KINDS);
+	const namespace = buildNamespacedEntities(contract.storage, SQL_BUILTIN_KINDS);
+	return {
+		...contract,
+		...rootAccessors,
+		namespace
+	};
+}
+/**
+* Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`
+* map over the deserialized contract. Postgres uses this.
+*/
+function buildSqlSchemaQualifiedView(contract) {
+	const namespace = buildNamespacedEntities(contract.storage, SQL_BUILTIN_KINDS);
+	return {
+		...contract,
+		namespace
+	};
+}
+//#endregion
+export { SQL_BUILTIN_KINDS, buildSqlSchemaQualifiedView, buildSqlSingleNamespaceView };
+
+//# sourceMappingURL=contract-view.mjs.map

package/dist/contract-view.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-view.mjs","names":[],"sources":["../src/contract-view.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  buildNamespacedEntities,\n  buildSingleNamespaceView,\n  type DefaultNamespaceEntries,\n  type NamespacedEntities,\n  type SingleNamespaceView,\n} from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from './ir/sql-storage';\n\n/**\n * The SQL family's statically-named built-in entity kinds. `table` and\n * `valueSet` are promoted to top-level view accessors; pack-contributed kinds\n * (e.g. `policy`) stay under `.entries`.\n */\nexport const SQL_BUILTIN_KINDS = ['table', 'valueSet'] as const;\nexport type SqlBuiltinKind = (typeof SQL_BUILTIN_KINDS)[number];\n\ntype SqlEntries<TContract extends Contract<SqlStorage>> = DefaultNamespaceEntries<\n  TContract['storage']\n>;\n\n/**\n * The single-namespace SQL accessors: `table`/`valueSet` top-level, pack kinds\n * under `entries`. A target that never emits a built-in kind (SQLite has\n * `sql.enums: false`, so it emits no `valueSet`) resolves that slot to an empty\n * map.\n */\nexport type SqlSingleNamespaceAccessors<TContract extends Contract<SqlStorage>> =\n  SingleNamespaceView<SqlEntries<TContract>, SqlBuiltinKind>;\n\n/**\n * Single-namespace SQL view: the deserialized contract intersected with the\n * by-name accessors, so the value is substitutable for `Contract` while also\n * exposing:\n *  - `view.table.<name>` / `view.valueSet.<name>` — built-in kinds, sole\n *    namespace unwrapped to the root; pack kinds under `view.entries.<kind>`.\n *  - `view.namespace.<id>` — the namespace-keyed entity map (SQLite's sole\n *    namespace is `__unbound__`). Mirrors the runtime `db.enums` pattern.\n */\nexport type SqlSingleNamespaceView<TContract extends Contract<SqlStorage>> = TContract &\n  SqlSingleNamespaceAccessors<TContract> & {\n    readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;\n  };\n\n/**\n * Builds the single-namespace SQL view: unwraps the sole namespace's SQL\n * built-in kinds (`table`, `valueSet`) to the root, attaches the namespace-keyed\n * `namespace` map, and layers both over the deserialized contract. Targets with\n * one default namespace (SQLite) call this directly; Postgres qualifies by\n * schema.\n */\nexport function buildSqlSingleNamespaceView<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): SqlSingleNamespaceView<TContract> {\n  const rootAccessors = buildSingleNamespaceView<SqlSingleNamespaceAccessors<TContract>>(\n    contract.storage,\n    SQL_BUILTIN_KINDS,\n  );\n  const namespace = buildNamespacedEntities<\n    NamespacedEntities<TContract['storage'], SqlBuiltinKind>\n  >(contract.storage, SQL_BUILTIN_KINDS);\n  return {\n    ...contract,\n    ...rootAccessors,\n    namespace,\n  };\n}\n\n/**\n * Schema-qualified SQL view: the deserialized contract intersected with a single\n * `view.namespace.<id>` member — every schema reached by raw id\n * (`view.namespace.public.table.users`), mirroring the runtime `db.enums.<ns>`\n * keying exactly (the default schema keeps its literal `__unbound__` id). There\n * is NO root schema-name promotion, so there is no collision with contract\n * envelope fields — `view.storage` is always the contract's `storage`. Postgres\n * uses this; SQLite (single default namespace) uses\n * {@link buildSqlSingleNamespaceView}.\n */\nexport type SqlSchemaQualifiedView<TContract extends Contract<SqlStorage>> = TContract & {\n  readonly namespace: NamespacedEntities<TContract['storage'], SqlBuiltinKind>;\n};\n\n/**\n * Builds the schema-qualified SQL view: attaches the namespace-keyed `namespace`\n * map over the deserialized contract. Postgres uses this.\n */\nexport function buildSqlSchemaQualifiedView<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n): SqlSchemaQualifiedView<TContract> {\n  const namespace = buildNamespacedEntities<\n    NamespacedEntities<TContract['storage'], SqlBuiltinKind>\n  >(contract.storage, SQL_BUILTIN_KINDS);\n  return {\n    ...contract,\n    namespace,\n  };\n}\n"],"mappings":";;;;;;;AAeA,MAAa,oBAAoB,CAAC,SAAS,UAAU;;;;;;;;AAqCrD,SAAgB,4BACd,UACmC;CACnC,MAAM,gBAAgB,yBACpB,SAAS,SACT,iBACF;CACA,MAAM,YAAY,wBAEhB,SAAS,SAAS,iBAAiB;CACrC,OAAO;EACL,GAAG;EACH,GAAG;EACH;CACF;AACF;;;;;AAoBA,SAAgB,4BACd,UACmC;CACnC,MAAM,YAAY,wBAEhB,SAAS,SAAS,iBAAiB;CACrC,OAAO;EACL,GAAG;EACH;CACF;AACF"}

package/dist/entity-handle-lowering-hook.d.mts

@@ -0,0 +1,91 @@
+//#region src/entity-handle-lowering-hook.d.ts
+/**
+ * SQL-family extension to the pack authoring contributions: a pack whose
+ * `entityTypes` registers entity kinds may implement a batch lowering hook
+ * that turns author-declared pack-entity handles (the generic `entities`
+ * list on the TS contract input) into `entries` rows.
+ *
+ * The generic contract build (`contract-ts`) owns the kind-agnostic walk: it
+ * groups handles by the pack that registered each `entityKind`, resolves
+ * each handle's declared model refs to storage table coordinates using the
+ * same model→table maps the relation lowering uses, and calls the owning
+ * pack's hook once with all of its claimed handles — batch, so the hook's
+ * diagnostics can see sibling handles. Neither the walk nor these types name
+ * any specific entity kind.
+ *
+ * SQL-family concept — the resolved-ref shape is a table coordinate, so the
+ * hook lives here beside {@link ../value-set-derivation-hook} instead of on
+ * the framework contributions type.
+ */
+/**
+ * An authored pack-entity handle: branded by the `entityKind` its owning
+ * pack registered, optionally declaring model refs under `refs` (actual
+ * model-handle objects, resolved by the generic walk before lowering).
+ */
+interface PackEntityHandle {
+  readonly entityKind: string;
+  readonly refs?: Readonly<Record<string, unknown>>;
+}
+/**
+ * A declared model ref after the generic walk resolved it: a storage table
+ * coordinate for a model of this contract, the coordinate plus `spaceId` for
+ * a cross-space (extensionModel) handle, or `unresolved` when the handle
+ * does not correspond to any model in the contract. `modelName` is carried
+ * for diagnostics where the handle declares one.
+ */
+type ResolvedEntityHandleRef = {
+  readonly kind: 'resolved';
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly modelName?: string;
+} | {
+  readonly kind: 'cross-space';
+  readonly spaceId: string;
+  readonly namespaceId: string;
+  readonly tableName: string;
+  readonly modelName?: string;
+} | {
+  readonly kind: 'unresolved';
+  readonly modelName?: string;
+};
+/** One claimed handle paired with its resolved declared refs. */
+interface ResolvedPackEntityHandle {
+  readonly handle: PackEntityHandle;
+  readonly refs: Readonly<Record<string, ResolvedEntityHandleRef>>;
+}
+interface EntityHandleLoweringInput {
+  /** Every handle in the `entities` list whose `entityKind` this pack registered, in authored order. */
+  readonly handles: readonly ResolvedPackEntityHandle[];
+  readonly defaultNamespaceId: string;
+}
+/** One lowered entity row: filed into `storage.namespaces[namespaceId].entries[entityKind][key]`. */
+interface LoweredPackEntity {
+  readonly namespaceId: string;
+  readonly entityKind: string;
+  readonly key: string;
+  readonly entity: unknown;
+}
+interface SqlEntityHandleLoweringContribution {
+  /**
+   * Method syntax keeps the declaration bivariant, so a pack's concretely
+   * typed implementation stays structurally compatible (the same convention
+   * as `SqlValueSetDerivingEntityTypeOutput.deriveValueSet`).
+   */
+  lowerEntityHandles(input: EntityHandleLoweringInput): readonly LoweredPackEntity[];
+}
+/** Structural check for {@link SqlEntityHandleLoweringContribution}: no casts. */
+declare function providesEntityHandleLowering(authoring: unknown): authoring is SqlEntityHandleLoweringContribution;
+/**
+ * PSL-side twin of {@link ResolvedEntityHandleRef}: the family interpreter
+ * resolves an extension block's descriptor-declared model ref parameters
+ * (`{ kind: 'ref', refKind: 'model' }`) to storage table names and annotates
+ * the block with this map (keyed by parameter name) before invoking the
+ * entity factory. An unresolved required ref is the interpreter's
+ * diagnostic; a factory never sees one.
+ */
+type ResolvedPslModelRefs = Readonly<Record<string, {
+  readonly tableName: string;
+}>>;
+//#endregion
+export { type EntityHandleLoweringInput, type LoweredPackEntity, type PackEntityHandle, type ResolvedEntityHandleRef, type ResolvedPackEntityHandle, type ResolvedPslModelRefs, type SqlEntityHandleLoweringContribution, providesEntityHandleLowering };
+//# sourceMappingURL=entity-handle-lowering-hook.d.mts.map

package/dist/entity-handle-lowering-hook.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-handle-lowering-hook.d.mts","names":[],"sources":["../src/entity-handle-lowering-hook.ts"],"mappings":";;AAwBA;;;;;;;;;AAEiC;AAUjC;;;;;;;;;;;;UAZiB,gBAAA;EAAA,SACN,UAAA;EAAA,SACA,IAAA,GAAO,QAAQ,CAAC,MAAA;AAAA;AA0BH;AAIxB;;;;;;AAJwB,KAhBZ,uBAAA;EAAA,SAEG,IAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,OAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;AAAA;EAAA,SAGA,IAAA;EAAA,SACA,SAAA;AAAA;;UAIE,wBAAA;EAAA,SACN,MAAA,EAAQ,gBAAA;EAAA,SACR,IAAA,EAAM,QAAA,CAAS,MAAA,SAAe,uBAAA;AAAA;AAAA,UAGxB,yBAAA;EAOiB;EAAA,SALvB,OAAA,WAAkB,wBAAwB;EAAA,SAC1C,kBAAA;AAAA;;UAIM,iBAAA;EAAA,SACN,WAAA;EAAA,SACA,UAAA;EAAA,SACA,GAAA;EAAA,SACA,MAAA;AAAA;AAAA,UAGM,mCAAA;EAMiE;;;;;EAAhF,kBAAA,CAAmB,KAAA,EAAO,yBAAA,YAAqC,iBAAiB;AAAA;AAIlF;AAAA,iBAAgB,4BAAA,CACd,SAAA,YACC,SAAA,IAAa,mCAAmC;;;;;;;AAAA;AAgBnD;KAAY,oBAAA,GAAuB,QAAQ,CAAC,MAAA;EAAA,SAA0B,SAAA;AAAA"}

package/dist/entity-handle-lowering-hook.mjs

@@ -0,0 +1,11 @@
+//#region src/entity-handle-lowering-hook.ts
+/** Structural check for {@link SqlEntityHandleLoweringContribution}: no casts. */
+function providesEntityHandleLowering(authoring) {
+	if (typeof authoring !== "object" || authoring === null || !("lowerEntityHandles" in authoring)) return false;
+	const { lowerEntityHandles } = authoring;
+	return typeof lowerEntityHandles === "function";
+}
+//#endregion
+export { providesEntityHandleLowering };
+
+//# sourceMappingURL=entity-handle-lowering-hook.mjs.map

package/dist/entity-handle-lowering-hook.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-handle-lowering-hook.mjs","names":[],"sources":["../src/entity-handle-lowering-hook.ts"],"sourcesContent":["/**\n * SQL-family extension to the pack authoring contributions: a pack whose\n * `entityTypes` registers entity kinds may implement a batch lowering hook\n * that turns author-declared pack-entity handles (the generic `entities`\n * list on the TS contract input) into `entries` rows.\n *\n * The generic contract build (`contract-ts`) owns the kind-agnostic walk: it\n * groups handles by the pack that registered each `entityKind`, resolves\n * each handle's declared model refs to storage table coordinates using the\n * same model→table maps the relation lowering uses, and calls the owning\n * pack's hook once with all of its claimed handles — batch, so the hook's\n * diagnostics can see sibling handles. Neither the walk nor these types name\n * any specific entity kind.\n *\n * SQL-family concept — the resolved-ref shape is a table coordinate, so the\n * hook lives here beside {@link ../value-set-derivation-hook} instead of on\n * the framework contributions type.\n */\n\n/**\n * An authored pack-entity handle: branded by the `entityKind` its owning\n * pack registered, optionally declaring model refs under `refs` (actual\n * model-handle objects, resolved by the generic walk before lowering).\n */\nexport interface PackEntityHandle {\n  readonly entityKind: string;\n  readonly refs?: Readonly<Record<string, unknown>>;\n}\n\n/**\n * A declared model ref after the generic walk resolved it: a storage table\n * coordinate for a model of this contract, the coordinate plus `spaceId` for\n * a cross-space (extensionModel) handle, or `unresolved` when the handle\n * does not correspond to any model in the contract. `modelName` is carried\n * for diagnostics where the handle declares one.\n */\nexport type ResolvedEntityHandleRef =\n  | {\n      readonly kind: 'resolved';\n      readonly namespaceId: string;\n      readonly tableName: string;\n      readonly modelName?: string;\n    }\n  | {\n      readonly kind: 'cross-space';\n      readonly spaceId: string;\n      readonly namespaceId: string;\n      readonly tableName: string;\n      readonly modelName?: string;\n    }\n  | {\n      readonly kind: 'unresolved';\n      readonly modelName?: string;\n    };\n\n/** One claimed handle paired with its resolved declared refs. */\nexport interface ResolvedPackEntityHandle {\n  readonly handle: PackEntityHandle;\n  readonly refs: Readonly<Record<string, ResolvedEntityHandleRef>>;\n}\n\nexport interface EntityHandleLoweringInput {\n  /** Every handle in the `entities` list whose `entityKind` this pack registered, in authored order. */\n  readonly handles: readonly ResolvedPackEntityHandle[];\n  readonly defaultNamespaceId: string;\n}\n\n/** One lowered entity row: filed into `storage.namespaces[namespaceId].entries[entityKind][key]`. */\nexport interface LoweredPackEntity {\n  readonly namespaceId: string;\n  readonly entityKind: string;\n  readonly key: string;\n  readonly entity: unknown;\n}\n\nexport interface SqlEntityHandleLoweringContribution {\n  /**\n   * Method syntax keeps the declaration bivariant, so a pack's concretely\n   * typed implementation stays structurally compatible (the same convention\n   * as `SqlValueSetDerivingEntityTypeOutput.deriveValueSet`).\n   */\n  lowerEntityHandles(input: EntityHandleLoweringInput): readonly LoweredPackEntity[];\n}\n\n/** Structural check for {@link SqlEntityHandleLoweringContribution}: no casts. */\nexport function providesEntityHandleLowering(\n  authoring: unknown,\n): authoring is SqlEntityHandleLoweringContribution {\n  if (typeof authoring !== 'object' || authoring === null || !('lowerEntityHandles' in authoring)) {\n    return false;\n  }\n  const { lowerEntityHandles } = authoring;\n  return typeof lowerEntityHandles === 'function';\n}\n\n/**\n * PSL-side twin of {@link ResolvedEntityHandleRef}: the family interpreter\n * resolves an extension block's descriptor-declared model ref parameters\n * (`{ kind: 'ref', refKind: 'model' }`) to storage table names and annotates\n * the block with this map (keyed by parameter name) before invoking the\n * entity factory. An unresolved required ref is the interpreter's\n * diagnostic; a factory never sees one.\n */\nexport type ResolvedPslModelRefs = Readonly<Record<string, { readonly tableName: string }>>;\n"],"mappings":";;AAqFA,SAAgB,6BACd,WACkD;CAClD,IAAI,OAAO,cAAc,YAAY,cAAc,QAAQ,EAAE,wBAAwB,YACnF,OAAO;CAET,MAAM,EAAE,uBAAuB;CAC/B,OAAO,OAAO,uBAAuB;AACvC"}

package/dist/entity-kinds-CVg6HzG2.mjs

@@ -0,0 +1,130 @@
+import { t as StorageTable } from "./storage-table-DBpYBmty.mjs";
+import { t as StorageValueSet } from "./storage-value-set-3BKuha5q.mjs";
+import { type } from "arktype";
+//#region src/ir/storage-entry-schemas.ts
+const literalKindSchema = type("'literal'");
+const functionKindSchema = type("'function'");
+const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
+const ColumnDefaultLiteralSchema = type.declare().type({
+	kind: literalKindSchema,
+	value: "string | number | boolean | null | unknown[] | Record<string, unknown>"
+});
+const ColumnDefaultFunctionSchema = type.declare().type({
+	kind: functionKindSchema,
+	expression: "string"
+});
+const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);
+const StorageValueSetRefSchema = type({
+	plane: "'storage'",
+	namespaceId: "string",
+	entityKind: "'valueSet'",
+	entityName: "string",
+	"spaceId?": "string"
+});
+const StorageColumnSchema = type({
+	"+": "reject",
+	nativeType: "string",
+	codecId: "string",
+	nullable: "boolean",
+	"many?": "boolean",
+	"typeParams?": "Record<string, unknown>",
+	"typeRef?": "string",
+	"default?": ColumnDefaultSchema,
+	"control?": ControlPolicySchema,
+	"valueSet?": StorageValueSetRefSchema
+}).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;
+});
+/**
+* Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.
+* Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an
+* ordered `values` array of codec-encoded permitted values.
+*/
+const StorageValueSetSchema = type({
+	kind: "'valueSet'",
+	values: type("string | number | boolean | null | unknown[] | Record<string, unknown>").array().readonly()
+});
+const PrimaryKeySchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const UniqueConstraintSchema = type.declare().type({
+	columns: type.string.array().readonly(),
+	"name?": "string"
+});
+const IndexSchema = type({
+	columns: type.string.array().readonly(),
+	"name?": "string",
+	"type?": "string",
+	"options?": "Record<string, unknown>"
+});
+const ForeignKeyReferenceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly(),
+	"spaceId?": "string"
+});
+const ForeignKeySourceSchema = type({
+	"+": "reject",
+	namespaceId: "string",
+	tableName: "string",
+	columns: type.string.array().readonly()
+});
+const ReferentialActionSchema = type.declare().type("'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'");
+const ForeignKeySchema = type.declare().type({
+	source: ForeignKeySourceSchema,
+	target: ForeignKeyReferenceSchema,
+	"name?": "string",
+	"onDelete?": ReferentialActionSchema,
+	"onUpdate?": ReferentialActionSchema
+});
+const CheckConstraintSchema = type({
+	"+": "reject",
+	name: "string",
+	column: "string",
+	valueSet: StorageValueSetRefSchema
+});
+const StorageTableSchema = type({
+	"+": "reject",
+	columns: type({ "[string]": StorageColumnSchema }),
+	"primaryKey?": PrimaryKeySchema,
+	uniques: UniqueConstraintSchema.array().readonly(),
+	indexes: IndexSchema.array().readonly(),
+	foreignKeys: ForeignKeySchema.array().readonly(),
+	"control?": ControlPolicySchema,
+	"checks?": CheckConstraintSchema.array().readonly()
+});
+//#endregion
+//#region src/entity-kinds.ts
+const tableEntityKind = {
+	kind: "table",
+	schema: StorageTableSchema,
+	construct: (input) => new StorageTable(input)
+};
+const valueSetEntityKind = {
+	kind: "valueSet",
+	schema: StorageValueSetSchema,
+	construct: (input) => new StorageValueSet(input)
+};
+/**
+* Assembles the `kind → descriptor` registry for SQL namespaces: the built-in
+* `table` and `valueSet` kinds plus any target `packKinds`. This builds the
+* lookup table — it does not touch contract data. `hydrateNamespaceEntities`
+* later consumes this registry to turn a namespace's raw entries into IR
+* instances, and `createSqlContractSchema` derives validation from the same
+* registry. Throws on a duplicate kind.
+*/
+function composeSqlEntityKinds(packKinds = []) {
+	const kinds = /* @__PURE__ */ new Map([["table", tableEntityKind], ["valueSet", valueSetEntityKind]]);
+	for (const descriptor of packKinds) {
+		if (kinds.has(descriptor.kind)) throw new Error(`composeSqlEntityKinds: duplicate entity kind "${descriptor.kind}" — each kind may be registered only once`);
+		kinds.set(descriptor.kind, descriptor);
+	}
+	return kinds;
+}
+//#endregion
+export { ColumnDefaultFunctionSchema as a, ForeignKeyReferenceSchema as c, IndexSchema as d, ReferentialActionSchema as f, CheckConstraintSchema as i, ForeignKeySchema as l, StorageValueSetSchema as m, tableEntityKind as n, ColumnDefaultLiteralSchema as o, StorageTableSchema as p, valueSetEntityKind as r, ColumnDefaultSchema as s, composeSqlEntityKinds as t, ForeignKeySourceSchema as u };
+
+//# sourceMappingURL=entity-kinds-CVg6HzG2.mjs.map

package/dist/entity-kinds-CVg6HzG2.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-kinds-CVg6HzG2.mjs","names":[],"sources":["../src/ir/storage-entry-schemas.ts","../src/entity-kinds.ts"],"sourcesContent":["import { type Type, type } from 'arktype';\nimport type { ForeignKeyInput, ReferentialAction } from './foreign-key';\nimport type { ForeignKeyReferenceInput } from './foreign-key-reference';\nimport type { PrimaryKeyInput } from './primary-key';\nimport type { UniqueConstraintInput } from './unique-constraint';\n\ntype ColumnDefaultLiteral = {\n  readonly kind: 'literal';\n  readonly value: string | number | boolean | Record<string, unknown> | unknown[] | null;\n};\ntype ColumnDefaultFunction = { readonly kind: 'function'; readonly expression: string };\n\nconst literalKindSchema = type(\"'literal'\");\nconst functionKindSchema = type(\"'function'\");\nconst ControlPolicySchema = type(\"'managed' | 'tolerated' | 'external' | 'observed'\");\n\nexport const ColumnDefaultLiteralSchema = type.declare<ColumnDefaultLiteral>().type({\n  kind: literalKindSchema,\n  value: 'string | number | boolean | null | unknown[] | Record<string, unknown>',\n});\n\nexport const ColumnDefaultFunctionSchema = type.declare<ColumnDefaultFunction>().type({\n  kind: functionKindSchema,\n  expression: 'string',\n});\n\nexport const ColumnDefaultSchema = ColumnDefaultLiteralSchema.or(ColumnDefaultFunctionSchema);\n\nconst StorageValueSetRefSchema = type({\n  plane: \"'storage'\",\n  namespaceId: 'string',\n  entityKind: \"'valueSet'\",\n  entityName: 'string',\n  'spaceId?': 'string',\n});\n\nconst StorageColumnSchema = type({\n  '+': 'reject',\n  nativeType: 'string',\n  codecId: 'string',\n  nullable: 'boolean',\n  'many?': 'boolean',\n  'typeParams?': 'Record<string, unknown>',\n  'typeRef?': 'string',\n  'default?': ColumnDefaultSchema,\n  'control?': ControlPolicySchema,\n  'valueSet?': StorageValueSetRefSchema,\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\n/**\n * Storage value-set entry under `storage.namespaces[id].entries.valueSet[name]`.\n * Carries a `kind: 'valueSet'` discriminator (enumerable, survives JSON) and an\n * ordered `values` array of codec-encoded permitted values.\n */\nexport const StorageValueSetSchema = type({\n  kind: \"'valueSet'\",\n  values: type('string | number | boolean | null | unknown[] | Record<string, unknown>')\n    .array()\n    .readonly(),\n});\n\nconst PrimaryKeySchema = type.declare<PrimaryKeyInput>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nconst UniqueConstraintSchema = type.declare<UniqueConstraintInput>().type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n});\n\nexport const IndexSchema = type({\n  columns: type.string.array().readonly(),\n  'name?': 'string',\n  'type?': 'string',\n  'options?': 'Record<string, unknown>',\n});\n\nexport const ForeignKeyReferenceSchema = type({\n  '+': 'reject',\n  namespaceId: 'string',\n  tableName: 'string',\n  columns: type.string.array().readonly(),\n  'spaceId?': 'string',\n}) satisfies Type<ForeignKeyReferenceInput>;\n\nexport const ForeignKeySourceSchema = type({\n  '+': 'reject',\n  namespaceId: 'string',\n  tableName: 'string',\n  columns: type.string.array().readonly(),\n}) satisfies Type<ForeignKeyReferenceInput>;\n\nexport const ReferentialActionSchema = type\n  .declare<ReferentialAction>()\n  .type(\"'noAction' | 'restrict' | 'cascade' | 'setNull' | 'setDefault'\");\n\nexport const ForeignKeySchema = type.declare<ForeignKeyInput>().type({\n  source: ForeignKeySourceSchema,\n  target: ForeignKeyReferenceSchema,\n  'name?': 'string',\n  'onDelete?': ReferentialActionSchema,\n  'onUpdate?': ReferentialActionSchema,\n});\n\nexport const CheckConstraintSchema = type({\n  '+': 'reject',\n  name: 'string',\n  column: 'string',\n  valueSet: StorageValueSetRefSchema,\n});\n\nexport const StorageTableSchema = type({\n  '+': 'reject',\n  columns: type({ '[string]': StorageColumnSchema }),\n  'primaryKey?': PrimaryKeySchema,\n  uniques: UniqueConstraintSchema.array().readonly(),\n  indexes: IndexSchema.array().readonly(),\n  foreignKeys: ForeignKeySchema.array().readonly(),\n  'control?': ControlPolicySchema,\n  'checks?': CheckConstraintSchema.array().readonly(),\n});\n","import type {\n  AnyEntityKindDescriptor,\n  EntityKindDescriptor,\n} from '@prisma-next/framework-components/ir';\nimport { StorageTableSchema, StorageValueSetSchema } from './ir/storage-entry-schemas';\nimport { StorageTable, type StorageTableInput } from './ir/storage-table';\nimport { StorageValueSet, type StorageValueSetInput } from './ir/storage-value-set';\n\nexport const tableEntityKind: EntityKindDescriptor<StorageTableInput, StorageTable> = {\n  kind: 'table',\n  schema: StorageTableSchema,\n  construct: (input) => new StorageTable(input),\n};\n\nexport const valueSetEntityKind: EntityKindDescriptor<StorageValueSetInput, StorageValueSet> = {\n  kind: 'valueSet',\n  schema: StorageValueSetSchema,\n  construct: (input) => new StorageValueSet(input),\n};\n\n/**\n * Assembles the `kind → descriptor` registry for SQL namespaces: the built-in\n * `table` and `valueSet` kinds plus any target `packKinds`. This builds the\n * lookup table — it does not touch contract data. `hydrateNamespaceEntities`\n * later consumes this registry to turn a namespace's raw entries into IR\n * instances, and `createSqlContractSchema` derives validation from the same\n * registry. Throws on a duplicate kind.\n */\nexport function composeSqlEntityKinds(\n  packKinds: readonly AnyEntityKindDescriptor[] = [],\n): ReadonlyMap<string, AnyEntityKindDescriptor> {\n  const kinds = new Map<string, AnyEntityKindDescriptor>([\n    ['table', tableEntityKind],\n    ['valueSet', valueSetEntityKind],\n  ]);\n  for (const descriptor of packKinds) {\n    if (kinds.has(descriptor.kind)) {\n      throw new Error(\n        `composeSqlEntityKinds: duplicate entity kind \"${descriptor.kind}\" — each kind may be registered only once`,\n      );\n    }\n    kinds.set(descriptor.kind, descriptor);\n  }\n  return kinds;\n}\n"],"mappings":"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"}

package/dist/entity-kinds.d.mts

@@ -1,4 +1,5 @@
-import { i as StorageTableInput, n as StorageValueSetInput, r as StorageTable, t as StorageValueSet } from "./storage-value-set-WnYsIFM8.mjs";
+import { n as StorageTableInput, t as StorageTable } from "./storage-table-CE-Ns6wa.mjs";
+import { n as StorageValueSetInput, t as StorageValueSet } from "./storage-value-set-D-jww77l.mjs";
 import { AnyEntityKindDescriptor, EntityKindDescriptor } from "@prisma-next/framework-components/ir";
 
 //#region src/entity-kinds.d.ts

package/dist/entity-kinds.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-kinds.d.mts","names":[],"sources":["../src/entity-kinds.ts"],"mappings":";;;;cAQa,eAAA,EAAiB,oBAAA,CAAqB,iBAAA,EAAmB,YAAA;AAAA,cAMzD,kBAAA,EAAoB,oBAAA,CAAqB,oBAAA,EAAsB,eAAA;;;;;;;;;iBAc5D,qBAAA,CACd,SAAA,YAAoB,uBAAA,KACnB,WAAA,SAAoB,uBAAA"}
+{"version":3,"file":"entity-kinds.d.mts","names":[],"sources":["../src/entity-kinds.ts"],"mappings":";;;;;cAQa,eAAA,EAAiB,oBAAA,CAAqB,iBAAA,EAAmB,YAAA;AAAA,cAMzD,kBAAA,EAAoB,oBAAA,CAAqB,oBAAA,EAAsB,eAAA;AAN5E;;;;;;;;AAAA,iBAoBgB,qBAAA,CACd,SAAA,YAAoB,uBAAA,KACnB,WAAA,SAAoB,uBAAA"}

package/dist/entity-kinds.mjs

@@ -1,2 +1,2 @@
-import { n as tableEntityKind, r as valueSetEntityKind, t as composeSqlEntityKinds } from "./entity-kinds-Cl36zL5j.mjs";
+import { n as tableEntityKind, r as valueSetEntityKind, t as composeSqlEntityKinds } from "./entity-kinds-CVg6HzG2.mjs";
 export { composeSqlEntityKinds, tableEntityKind, valueSetEntityKind };

package/dist/factories.d.mts

@@ -1,16 +1,17 @@
-import { t as ForeignKey } from "./foreign-key-BATxB95l.mjs";
-import { a as UniqueConstraint, c as StorageColumnInput, d as PrimaryKey, l as Index, r as StorageTable, s as StorageColumn } from "./storage-value-set-WnYsIFM8.mjs";
-import { b as SqlModelFieldStorage, f as ForeignKeyOptions, x as SqlModelStorage } from "./types-B1N8w0I2.mjs";
+import { i as StorageColumnInput, r as StorageColumn, t as StorageTable } from "./storage-table-CE-Ns6wa.mjs";
+import { t as ForeignKey } from "./foreign-key-DuCoGJCf.mjs";
+import { a as PrimaryKey, r as Index, t as UniqueConstraint } from "./unique-constraint-C0De4sLU.mjs";
+import { T as SqlModelStorage, m as ForeignKeyOptions, w as SqlModelFieldStorage } from "./types-3vOIrnvp.mjs";
 import { ScalarFieldType } from "@prisma-next/contract/types";
 
 //#region src/factories.d.ts
-declare function col(nativeType: string, codecId: string, nullable?: boolean): StorageColumn;
+declare function col(nativeType: string, codecId: string, nullable?: boolean, opts?: {
+  readonly many?: 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(srcTableName: string, srcColumns: readonly string[], targetTableName: string, targetColumns: readonly string[], opts?: ForeignKeyOptions & {
-  constraint?: boolean;
-  index?: boolean;
   namespaceId?: string;
 }): ForeignKey;
 declare function table(columns: Record<string, StorageColumn | StorageColumnInput>, opts?: {

package/dist/factories.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"factories.d.mts","names":[],"sources":["../src/factories.ts"],"mappings":";;;;;;iBAgBgB,GAAA,CAAI,UAAA,UAAoB,OAAA,UAAiB,QAAA,aAAmB,aAAa;AAAA,iBAIzE,EAAA,IAAM,OAAA,sBAA6B,UAAU;AAAA,iBAI7C,MAAA,IAAU,OAAA,sBAA6B,gBAAgB;AAAA,iBAIvD,KAAA,IAAS,OAAA,sBAA6B,KAAK;AAAA,iBAI3C,EAAA,CACd,YAAA,UACA,UAAA,qBACA,eAAA,UACA,aAAA,qBACA,IAAA,GAAO,iBAAA;EAAsB,UAAA;EAAsB,KAAA;EAAiB,WAAA;AAAA,IACnE,UAAU;AAAA,iBAcG,KAAA,CACd,OAAA,EAAS,MAAA,SAAe,aAAA,GAAgB,kBAAA,GACxC,IAAA;EACE,EAAA,GAAK,UAAA;EACL,OAAA,YAAmB,gBAAA;EACnB,OAAA,YAAmB,KAAA;EACnB,GAAA,YAAe,UAAA;AAAA,IAEhB,YAAA;AAAA,iBAUa,KAAA,CACd,SAAA,UACA,MAAA,EAAQ,MAAA,SAAe,oBAAA,GACvB,SAAA,GAAW,MAAA,mBACX,WAAA;EAEA,OAAA,EAAS,eAAA;EACT,MAAA,EAAQ,MAAA;IAAA,SAA0B,QAAA;IAAA,SAA4B,IAAA,EAAM,eAAA;EAAA;EACpE,SAAA,EAAW,MAAA;AAAA"}
+{"version":3,"file":"factories.d.mts","names":[],"sources":["../src/factories.ts"],"mappings":";;;;;;;iBAegB,GAAA,CACd,UAAA,UACA,OAAA,UACA,QAAA,YACA,IAAA;EAAA,SAAkB,IAAA;AAAA,IACjB,aAAa;AAAA,iBASA,EAAA,IAAM,OAAA,sBAA6B,UAAU;AAAA,iBAI7C,MAAA,IAAU,OAAA,sBAA6B,gBAAgB;AAAA,iBAIvD,KAAA,IAAS,OAAA,sBAA6B,KAAK;AAAA,iBAI3C,EAAA,CACd,YAAA,UACA,UAAA,qBACA,eAAA,UACA,aAAA,qBACA,IAAA,GAAO,iBAAA;EAAsB,WAAA;AAAA,IAC5B,UAAU;AAAA,iBAWG,KAAA,CACd,OAAA,EAAS,MAAA,SAAe,aAAA,GAAgB,kBAAA,GACxC,IAAA;EACE,EAAA,GAAK,UAAA;EACL,OAAA,YAAmB,gBAAA;EACnB,OAAA,YAAmB,KAAA;EACnB,GAAA,YAAe,UAAA;AAAA,IAEhB,YAAA;AAAA,iBAUa,KAAA,CACd,SAAA,UACA,MAAA,EAAQ,MAAA,SAAe,oBAAA,GACvB,SAAA,GAAW,MAAA,mBACX,WAAA;EAEA,OAAA,EAAS,eAAA;EACT,MAAA,EAAQ,MAAA;IAAA,SAA0B,QAAA;IAAA,SAA4B,IAAA,EAAM,eAAA;EAAA;EACpE,SAAA,EAAW,MAAA;AAAA"}

package/dist/factories.mjs

@@ -1,13 +1,13 @@
-import { a as StorageTable, c as Index, l as PrimaryKey, o as UniqueConstraint, s as StorageColumn, u as ForeignKey } from "./entity-kinds-Cl36zL5j.mjs";
-import { r as applyFkDefaults } from "./types-B-eiQXff.mjs";
+import { a as PrimaryKey, i as Index, n as UniqueConstraint, o as ForeignKey, r as StorageColumn, t as StorageTable } from "./storage-table-DBpYBmty.mjs";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { asNamespaceId } from "@prisma-next/contract/types";
 //#region src/factories.ts
-function col(nativeType, codecId, nullable = false) {
+function col(nativeType, codecId, nullable = false, opts) {
 	return new StorageColumn({
 		nativeType,
 		codecId,
-		nullable
+		nullable,
+		...opts?.many !== void 0 && { many: opts.many }
 	});
 }
 function pk(...columns) {
@@ -20,10 +20,6 @@ function index(...columns) {
 	return new Index({ columns });
 }
 function fk(srcTableName, srcColumns, targetTableName, targetColumns, opts) {
-	const defaults = applyFkDefaults({
-		constraint: opts?.constraint,
-		index: opts?.index
-	});
 	const namespaceId = asNamespaceId(opts?.namespaceId ?? UNBOUND_NAMESPACE_ID);
 	return new ForeignKey({
 		source: {
@@ -38,9 +34,7 @@ function fk(srcTableName, srcColumns, targetTableName, targetColumns, opts) {
 		},
 		...opts?.name !== void 0 && { name: opts.name },
 		...opts?.onDelete !== void 0 && { onDelete: opts.onDelete },
-		...opts?.onUpdate !== void 0 && { onUpdate: opts.onUpdate },
-		constraint: defaults.constraint,
-		index: defaults.index
+		...opts?.onUpdate !== void 0 && { onUpdate: opts.onUpdate }
 	});
 }
 function table(columns, opts) {