@prisma/orm-framework 0.16.0

package/dist/ir-ChmSSAhX.mjs

@@ -0,0 +1,200 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+import { t as isPlainRecord } from "./is-plain-record-CUofyVQ7-DWEzdhIx.mjs";
+import { t as InternalError } from "./internal-error-BIc-ehme-ouBQPoEL.mjs";
+import { n as runtimeError } from "./runtime-error-BA9d7XjZ-BlT8t6LB.mjs";
+//#region ../../../1-framework/1-core/framework-components/dist/ir.mjs
+var IRNodeBase = class {};
+/**
+* Seal an IR class instance after its constructor has assigned all
+* fields. The free-helper form (rather than a `protected freeze()`
+* instance method) keeps the class type structurally narrow so emitted
+* contract literal types remain assignable to their class types.
+*
+* The helper name stays `freezeNode` — it operates on IR nodes
+* regardless of root naming.
+*/
+function freezeNode(node) {
+	Object.freeze(node);
+	return node;
+}
+/**
+* Reserved sentinel namespace id for the late-bound storage slot —
+* the slot whose binding the target resolves at connection time
+* rather than at authoring time. Postgres uses it for `search_path`
+* late binding; SQLite uses it for the trivial singleton; Mongo uses
+* it for the connection's `db` binding.
+*
+* Materialised target-side as a singleton subclass of the target's
+* `NamespaceBase` concretion that overrides the namespace's
+* qualifier-emission methods to elide the prefix entirely. Call sites
+* stay polymorphic and never branch on `id === UNBOUND_NAMESPACE_ID`
+* — the singleton's overrides drop the qualifier so emitted SQL / Mongo
+* commands look unqualified.
+*
+* The double-underscore decoration marks the id as a framework-reserved
+* coordinate when it appears in a JSON envelope (cold-read-as-reserved
+* — no realistic collision with user-declared namespace names).
+*
+* Encoded as an exported const (rather than scattered string literals)
+* so the sentinel-id invariant is single-sourced: any production-source
+* site that constructs an unbound-namespace singleton imports this
+* constant.
+*/
+const UNBOUND_NAMESPACE_ID = "__unbound__";
+var NamespaceBase = class extends IRNodeBase {
+	/**
+	* Answers "am I the unbound namespace" as node behavior, so consumers
+	* never compare ids against the sentinel. This getter is the single
+	* encapsulated place the {@link UNBOUND_NAMESPACE_ID} comparison lives.
+	*/
+	get isUnbound() {
+		return this.id === UNBOUND_NAMESPACE_ID;
+	}
+};
+/**
+* Projects one namespace's `entries` into the view shape: each built-in kind
+* becomes a top-level slot (materialized empty if absent), and the remaining
+* pack-contributed kinds sit under `.entries`. Shared by the single-namespace
+* builder and the namespace-map builder.
+*/
+function promoteBuiltinKinds(entries, builtinKinds) {
+	const view = {};
+	const rest = {};
+	for (const [kind, kindMap] of Object.entries(entries)) if (builtinKinds.includes(kind)) view[kind] = kindMap;
+	else rest[kind] = kindMap;
+	for (const kind of builtinKinds) if (!(kind in view)) view[kind] = {};
+	view["entries"] = rest;
+	return blindCast(view);
+}
+/**
+* Builds one namespace's entity view: promotes the given built-in kind slots to
+* top-level for the default (`UNBOUND_NAMESPACE_ID`) namespace. Single-namespace
+* targets (Mongo, SQLite) use this to unwrap their sole namespace to the root.
+*
+* Throws if the contract has no default (`UNBOUND_NAMESPACE_ID`) namespace.
+*/
+function buildSingleNamespaceView(storage, builtinKinds) {
+	const defaultNs = storage.namespaces[UNBOUND_NAMESPACE_ID];
+	if (defaultNs === void 0) throw new InternalError(`ContractView: contract has no default namespace (${UNBOUND_NAMESPACE_ID})`);
+	return promoteBuiltinKinds(blindCast(defaultNs.entries), builtinKinds);
+}
+/**
+* Builds the namespace-keyed entity-view map (`{ <nsId>: SingleNamespaceView }`)
+* for every namespace in the storage, keyed by raw namespace id. Mirrors
+* `buildNamespacedEnums(domain)` — the storage-side twin.
+*/
+function buildNamespacedEntities(storage, builtinKinds) {
+	const out = {};
+	for (const [nsId, ns] of Object.entries(storage.namespaces)) out[nsId] = promoteBuiltinKinds(blindCast(ns.entries), builtinKinds);
+	return blindCast(out);
+}
+/**
+* Lazy walk over every named domain entity in a {@link ApplicationDomain},
+* yielded as {@link EntityCoordinate} tuples with `plane: 'domain'`.
+*
+* Same structural rules as {@link elementCoordinates} over storage: skip
+* scalar `id`; each other object-valued property is an entity-kind slot.
+*/
+function* domainElementCoordinates(domain) {
+	for (const [namespaceId, ns] of Object.entries(domain.namespaces)) for (const [entityKind, slot] of Object.entries(ns)) {
+		if (entityKind === "id") continue;
+		if (slot === null || typeof slot !== "object") continue;
+		for (const entityName of Object.keys(slot)) yield {
+			plane: "domain",
+			namespaceId,
+			entityKind,
+			entityName
+		};
+	}
+}
+/**
+* Hydrates a namespace's entities from raw JSON maps into IR class instances.
+*
+* For each kind in `entries`: if the descriptor map has a descriptor,
+* construct each inner-map value; otherwise freeze-and-carry (`'carry'`)
+* or throw naming the kind and nsId (`'fail'`).
+*
+* The single boundary cast hands `value` to `descriptor.construct` as its
+* `Input`. The value satisfies the kind's `Input` either by the
+* entries-input contract at authoring time or by prior `validateStorage`
+* validation at hydration time.
+*/
+function hydrateNamespaceEntities(entries, kinds, onUnknown, nsId) {
+	const result = {};
+	for (const [kind, rawMap] of Object.entries(entries)) {
+		const descriptor = kinds.get(kind);
+		if (descriptor !== void 0) {
+			const built = {};
+			for (const [name, value] of Object.entries(rawMap)) built[name] = descriptor.construct(blindCast(value));
+			result[kind] = Object.freeze(built);
+		} else if (onUnknown === "carry") result[kind] = Object.freeze(rawMap);
+		else throw runtimeError("CONTRACT.ENTITY_KIND_UNKNOWN", `Unknown entries key "${kind}" in namespace "${nsId ?? "?"}"; no hydration factory registered for this entity kind`);
+	}
+	return result;
+}
+/**
+* Lazy walk over every named storage entity in a `Storage`-shaped
+* value, yielded as {@link EntityCoordinate} tuples with
+* `plane: 'storage'` (the parameter type binds the plane).
+*
+* Iterates each namespace's `entries` kind maps structurally. Skips
+* non-object `entries`; `id` and `kind` are not walked (`kind` is
+* non-enumerable on concretions). For every entity-kind key under
+* `entries` whose value is a non-null object, yields one coordinate per
+* entity name in that map. No family-specific kind vocabulary is required.
+*/
+function* elementCoordinates(storage) {
+	for (const [namespaceId, ns] of Object.entries(storage.namespaces)) {
+		const entries = ns.entries;
+		if (entries === null || typeof entries !== "object") continue;
+		for (const [entityKind, kindMap] of Object.entries(entries)) {
+			if (kindMap === null || typeof kindMap !== "object") continue;
+			for (const entityName of Object.keys(kindMap)) yield {
+				plane: "storage",
+				namespaceId,
+				entityKind,
+				entityName
+			};
+		}
+	}
+}
+/**
+* Canonical, collision-safe key for an {@link EntityCoordinate}. Encodes each
+* axis individually with `JSON.stringify` before joining with `-`, so no
+* namespace id, entity kind, or entity name can forge a collision by
+* embedding the delimiter itself (e.g. a delimiter of `:` would let
+* `('a', 'b:c', 'd')` collide with `('a:b', 'c', 'd')`) — each component is
+* quoted, and any `-` or `"` inside it is escaped or safely inside those
+* quotes.
+*
+* The single shared key every coordinate-driven ownership/omission/collision
+* check should use — `contract infer`'s pack-described-element omission and
+* the migration tools' cross-space disjointness check both key on this.
+*/
+function coordinateKey(coordinate) {
+	return [
+		coordinate.namespaceId,
+		coordinate.entityKind,
+		coordinate.entityName
+	].map((value) => JSON.stringify(value)).join("-");
+}
+/**
+* Looks up a single entity in a `Storage`-shaped value by its full coordinate.
+* Returns `undefined` if the namespace, entity kind, or entity name is absent.
+* The type parameter is a caller assertion — the walk itself is structural
+* and cannot verify the entity's shape.
+*/
+function entityAt(storage, coord) {
+	const ns = storage.namespaces[coord.namespaceId];
+	if (ns === void 0) return void 0;
+	const entries = ns.entries;
+	if (!isPlainRecord(entries)) return void 0;
+	const kindMap = entries[coord.entityKind];
+	if (!isPlainRecord(kindMap)) return void 0;
+	if (!Object.hasOwn(kindMap, coord.entityName)) return void 0;
+	return blindCast(kindMap[coord.entityName]);
+}
+//#endregion
+export { buildSingleNamespaceView as a, elementCoordinates as c, hydrateNamespaceEntities as d, promoteBuiltinKinds as f, buildNamespacedEntities as i, entityAt as l, NamespaceBase as n, coordinateKey as o, UNBOUND_NAMESPACE_ID as r, domainElementCoordinates as s, IRNodeBase as t, freezeNode as u };
+
+//# sourceMappingURL=ir-ChmSSAhX.mjs.map

package/dist/ir-ChmSSAhX.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-ChmSSAhX.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/ir.mjs"],"sourcesContent":["import { n as runtimeError } from \"./runtime-error-BA9d7XjZ.mjs\";\nimport { blindCast } from \"@internal/utils/casts\";\nimport { InternalError } from \"@internal/utils/internal-error\";\nimport { isPlainRecord } from \"@internal/contract/is-plain-record\";\n//#region src/ir/ir-node.ts\nvar IRNodeBase = class {};\n/**\n* Seal an IR class instance after its constructor has assigned all\n* fields. The free-helper form (rather than a `protected freeze()`\n* instance method) keeps the class type structurally narrow so emitted\n* contract literal types remain assignable to their class types.\n*\n* The helper name stays `freezeNode` — it operates on IR nodes\n* regardless of root naming.\n*/\nfunction freezeNode(node) {\n\tObject.freeze(node);\n\treturn node;\n}\n//#endregion\n//#region src/ir/namespace.ts\n/**\n* Reserved sentinel namespace id for the late-bound storage slot —\n* the slot whose binding the target resolves at connection time\n* rather than at authoring time. Postgres uses it for `search_path`\n* late binding; SQLite uses it for the trivial singleton; Mongo uses\n* it for the connection's `db` binding.\n*\n* Materialised target-side as a singleton subclass of the target's\n* `NamespaceBase` concretion that overrides the namespace's\n* qualifier-emission methods to elide the prefix entirely. Call sites\n* stay polymorphic and never branch on `id === UNBOUND_NAMESPACE_ID`\n* — the singleton's overrides drop the qualifier so emitted SQL / Mongo\n* commands look unqualified.\n*\n* The double-underscore decoration marks the id as a framework-reserved\n* coordinate when it appears in a JSON envelope (cold-read-as-reserved\n* — no realistic collision with user-declared namespace names).\n*\n* Encoded as an exported const (rather than scattered string literals)\n* so the sentinel-id invariant is single-sourced: any production-source\n* site that constructs an unbound-namespace singleton imports this\n* constant.\n*/\nconst UNBOUND_NAMESPACE_ID = \"__unbound__\";\nvar NamespaceBase = class extends IRNodeBase {\n\t/**\n\t* Answers \"am I the unbound namespace\" as node behavior, so consumers\n\t* never compare ids against the sentinel. This getter is the single\n\t* encapsulated place the {@link UNBOUND_NAMESPACE_ID} comparison lives.\n\t*/\n\tget isUnbound() {\n\t\treturn this.id === UNBOUND_NAMESPACE_ID;\n\t}\n};\n//#endregion\n//#region src/ir/contract-view.ts\n/**\n* Projects one namespace's `entries` into the view shape: each built-in kind\n* becomes a top-level slot (materialized empty if absent), and the remaining\n* pack-contributed kinds sit under `.entries`. Shared by the single-namespace\n* builder and the namespace-map builder.\n*/\nfunction promoteBuiltinKinds(entries, builtinKinds) {\n\tconst view = {};\n\tconst rest = {};\n\tfor (const [kind, kindMap] of Object.entries(entries)) if (builtinKinds.includes(kind)) view[kind] = kindMap;\n\telse rest[kind] = kindMap;\n\tfor (const kind of builtinKinds) if (!(kind in view)) view[kind] = {};\n\tview[\"entries\"] = rest;\n\treturn blindCast(view);\n}\n/**\n* Builds one namespace's entity view: promotes the given built-in kind slots to\n* top-level for the default (`UNBOUND_NAMESPACE_ID`) namespace. Single-namespace\n* targets (Mongo, SQLite) use this to unwrap their sole namespace to the root.\n*\n* Throws if the contract has no default (`UNBOUND_NAMESPACE_ID`) namespace.\n*/\nfunction buildSingleNamespaceView(storage, builtinKinds) {\n\tconst defaultNs = storage.namespaces[UNBOUND_NAMESPACE_ID];\n\tif (defaultNs === void 0) throw new InternalError(`ContractView: contract has no default namespace (${UNBOUND_NAMESPACE_ID})`);\n\treturn promoteBuiltinKinds(blindCast(defaultNs.entries), builtinKinds);\n}\n/**\n* Builds the namespace-keyed entity-view map (`{ <nsId>: SingleNamespaceView }`)\n* for every namespace in the storage, keyed by raw namespace id. Mirrors\n* `buildNamespacedEnums(domain)` — the storage-side twin.\n*/\nfunction buildNamespacedEntities(storage, builtinKinds) {\n\tconst out = {};\n\tfor (const [nsId, ns] of Object.entries(storage.namespaces)) out[nsId] = promoteBuiltinKinds(blindCast(ns.entries), builtinKinds);\n\treturn blindCast(out);\n}\n//#endregion\n//#region src/ir/domain.ts\n/**\n* Lazy walk over every named domain entity in a {@link ApplicationDomain},\n* yielded as {@link EntityCoordinate} tuples with `plane: 'domain'`.\n*\n* Same structural rules as {@link elementCoordinates} over storage: skip\n* scalar `id`; each other object-valued property is an entity-kind slot.\n*/\nfunction* domainElementCoordinates(domain) {\n\tfor (const [namespaceId, ns] of Object.entries(domain.namespaces)) for (const [entityKind, slot] of Object.entries(ns)) {\n\t\tif (entityKind === \"id\") continue;\n\t\tif (slot === null || typeof slot !== \"object\") continue;\n\t\tfor (const entityName of Object.keys(slot)) yield {\n\t\t\tplane: \"domain\",\n\t\t\tnamespaceId,\n\t\t\tentityKind,\n\t\t\tentityName\n\t\t};\n\t}\n}\n//#endregion\n//#region src/ir/entity-kind.ts\n/**\n* Hydrates a namespace's entities from raw JSON maps into IR class instances.\n*\n* For each kind in `entries`: if the descriptor map has a descriptor,\n* construct each inner-map value; otherwise freeze-and-carry (`'carry'`)\n* or throw naming the kind and nsId (`'fail'`).\n*\n* The single boundary cast hands `value` to `descriptor.construct` as its\n* `Input`. The value satisfies the kind's `Input` either by the\n* entries-input contract at authoring time or by prior `validateStorage`\n* validation at hydration time.\n*/\nfunction hydrateNamespaceEntities(entries, kinds, onUnknown, nsId) {\n\tconst result = {};\n\tfor (const [kind, rawMap] of Object.entries(entries)) {\n\t\tconst descriptor = kinds.get(kind);\n\t\tif (descriptor !== void 0) {\n\t\t\tconst built = {};\n\t\t\tfor (const [name, value] of Object.entries(rawMap)) built[name] = descriptor.construct(blindCast(value));\n\t\t\tresult[kind] = Object.freeze(built);\n\t\t} else if (onUnknown === \"carry\") result[kind] = Object.freeze(rawMap);\n\t\telse throw runtimeError(\"CONTRACT.ENTITY_KIND_UNKNOWN\", `Unknown entries key \"${kind}\" in namespace \"${nsId ?? \"?\"}\"; no hydration factory registered for this entity kind`);\n\t}\n\treturn result;\n}\n//#endregion\n//#region src/ir/storage.ts\n/**\n* Lazy walk over every named storage entity in a `Storage`-shaped\n* value, yielded as {@link EntityCoordinate} tuples with\n* `plane: 'storage'` (the parameter type binds the plane).\n*\n* Iterates each namespace's `entries` kind maps structurally. Skips\n* non-object `entries`; `id` and `kind` are not walked (`kind` is\n* non-enumerable on concretions). For every entity-kind key under\n* `entries` whose value is a non-null object, yields one coordinate per\n* entity name in that map. No family-specific kind vocabulary is required.\n*/\nfunction* elementCoordinates(storage) {\n\tfor (const [namespaceId, ns] of Object.entries(storage.namespaces)) {\n\t\tconst entries = ns.entries;\n\t\tif (entries === null || typeof entries !== \"object\") continue;\n\t\tfor (const [entityKind, kindMap] of Object.entries(entries)) {\n\t\t\tif (kindMap === null || typeof kindMap !== \"object\") continue;\n\t\t\tfor (const entityName of Object.keys(kindMap)) yield {\n\t\t\t\tplane: \"storage\",\n\t\t\t\tnamespaceId,\n\t\t\t\tentityKind,\n\t\t\t\tentityName\n\t\t\t};\n\t\t}\n\t}\n}\n/**\n* Canonical, collision-safe key for an {@link EntityCoordinate}. Encodes each\n* axis individually with `JSON.stringify` before joining with `-`, so no\n* namespace id, entity kind, or entity name can forge a collision by\n* embedding the delimiter itself (e.g. a delimiter of `:` would let\n* `('a', 'b:c', 'd')` collide with `('a:b', 'c', 'd')`) — each component is\n* quoted, and any `-` or `\"` inside it is escaped or safely inside those\n* quotes.\n*\n* The single shared key every coordinate-driven ownership/omission/collision\n* check should use — `contract infer`'s pack-described-element omission and\n* the migration tools' cross-space disjointness check both key on this.\n*/\nfunction coordinateKey(coordinate) {\n\treturn [\n\t\tcoordinate.namespaceId,\n\t\tcoordinate.entityKind,\n\t\tcoordinate.entityName\n\t].map((value) => JSON.stringify(value)).join(\"-\");\n}\n/**\n* Looks up a single entity in a `Storage`-shaped value by its full coordinate.\n* Returns `undefined` if the namespace, entity kind, or entity name is absent.\n* The type parameter is a caller assertion — the walk itself is structural\n* and cannot verify the entity's shape.\n*/\nfunction entityAt(storage, coord) {\n\tconst ns = storage.namespaces[coord.namespaceId];\n\tif (ns === void 0) return void 0;\n\tconst entries = ns.entries;\n\tif (!isPlainRecord(entries)) return void 0;\n\tconst kindMap = entries[coord.entityKind];\n\tif (!isPlainRecord(kindMap)) return void 0;\n\tif (!Object.hasOwn(kindMap, coord.entityName)) return void 0;\n\treturn blindCast(kindMap[coord.entityName]);\n}\n//#endregion\nexport { IRNodeBase, NamespaceBase, UNBOUND_NAMESPACE_ID, buildNamespacedEntities, buildSingleNamespaceView, coordinateKey, domainElementCoordinates, elementCoordinates, entityAt, freezeNode, hydrateNamespaceEntities, isPlainRecord, promoteBuiltinKinds };\n\n//# sourceMappingURL=ir.mjs.map"],"mappings":"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"}

package/dist/is-plain-record-C9BWiqcw.d.mts

@@ -0,0 +1,12 @@
+//#region ../../../1-framework/0-foundation/contract/dist/is-plain-record.d.mts
+//#region src/is-plain-record.d.ts
+/**
+ * Strict plain-object guard: accepts only objects with `Object.prototype`
+ * or `null` as their prototype. Rejects arrays, class instances, and other
+ * non-plain objects. Used to distinguish raw-data records from IR class
+ * instances in validation and hydration paths.
+ */
+declare function isPlainRecord(value: unknown): value is Readonly<Record<string, unknown>>;
+//#endregion
+export { isPlainRecord as t };
+//# sourceMappingURL=is-plain-record-C9BWiqcw.d.mts.map

package/dist/is-plain-record-C9BWiqcw.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-record-C9BWiqcw.d.mts","names":[],"sources":["../../../../1-framework/0-foundation/contract/dist/is-plain-record.d.mts"],"mappings":";;;;;;;;iBAOiB,cAAc,iBAAiB,SAAS,SAAS"}

package/dist/is-plain-record-CUofyVQ7-DWEzdhIx.mjs

@@ -0,0 +1,16 @@
+//#region ../../../1-framework/0-foundation/contract/dist/is-plain-record-CUofyVQ7.mjs
+/**
+* Strict plain-object guard: accepts only objects with `Object.prototype`
+* or `null` as their prototype. Rejects arrays, class instances, and other
+* non-plain objects. Used to distinguish raw-data records from IR class
+* instances in validation and hydration paths.
+*/
+function isPlainRecord(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+//#endregion
+export { isPlainRecord as t };
+
+//# sourceMappingURL=is-plain-record-CUofyVQ7-DWEzdhIx.mjs.map

package/dist/is-plain-record-CUofyVQ7-DWEzdhIx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-record-CUofyVQ7-DWEzdhIx.mjs","names":[],"sources":["../../../../1-framework/0-foundation/contract/dist/is-plain-record-CUofyVQ7.mjs"],"sourcesContent":["//#region src/is-plain-record.ts\n/**\n* Strict plain-object guard: accepts only objects with `Object.prototype`\n* or `null` as their prototype. Rejects arrays, class instances, and other\n* non-plain objects. Used to distinguish raw-data records from IR class\n* instances in validation and hydration paths.\n*/\nfunction isPlainRecord(value) {\n\tif (typeof value !== \"object\" || value === null || Array.isArray(value)) return false;\n\tconst proto = Object.getPrototypeOf(value);\n\treturn proto === Object.prototype || proto === null;\n}\n//#endregion\nexport { isPlainRecord as t };\n\n//# sourceMappingURL=is-plain-record-CUofyVQ7.mjs.map"],"mappings":";;;;;;;AAOA,SAAS,cAAc,OAAO;CAC7B,IAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GAAG,OAAO;CAChF,MAAM,QAAQ,OAAO,eAAe,KAAK;CACzC,OAAO,UAAU,OAAO,aAAa,UAAU;AAChD"}

package/dist/json-Dkqr3say.d.mts

@@ -0,0 +1,26 @@
+//#region ../../../1-framework/0-foundation/utils/dist/json.d.mts
+//#region src/json.d.ts
+/**
+ * Structural types for values that can be losslessly round-tripped through
+ * `JSON.stringify` / `JSON.parse`.
+ *
+ * These are *structural* (no nominal brand): a value satisfying `JsonObject`
+ * is guaranteed only to have JSON-stringifiable shape, not to carry any
+ * particular semantic identity. Use these as the type of opaque "JSON-shaped"
+ * data crossing API boundaries when the consumer needs the JSON-cleanness
+ * promise but does not need a domain-specific shape.
+ *
+ * Notable consumers of `JsonObject` include the framework's
+ * `ContractSerializer` SPI: `serializeContract` returns `JsonObject` so that
+ * call sites can stringify, hash, or feed the result into another SPI without
+ * re-asserting JSON-cleanness.
+ */
+type JsonPrimitive = string | number | boolean | null;
+type JsonArray = readonly JsonValue[];
+type JsonObject = {
+  readonly [key: string]: JsonValue;
+};
+type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+//#endregion
+export { JsonValue as i, JsonObject as n, JsonPrimitive as r, JsonArray as t };
+//# sourceMappingURL=json-Dkqr3say.d.mts.map

package/dist/json-Dkqr3say.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-Dkqr3say.d.mts","names":[],"sources":["../../../../1-framework/0-foundation/utils/dist/json.d.mts"],"mappings":";;;;;;;;;;;;;;;;;KAgBK;KACA,qBAAqB;KACrB;YACO,cAAc;;KAErB,YAAY,gBAAgB,YAAY"}

package/dist/migration-4VOHVEzx.mjs

@@ -0,0 +1,118 @@
+import { t as CliStructuredError } from "./control-Ftiau058-CCeJcAVQ.mjs";
+//#region ../../../1-framework/1-core/errors/dist/migration.mjs
+/**
+* A scaffolded migration contains a placeholder slot that was never filled in.
+*
+* Thrown at emit time (when `check.source()` or `run()` is invoked) via the
+* `placeholder(...)` utility. The `slot` identifies the exact location the
+* author still needs to edit, e.g. `"backfill-product-status:check.source"`.
+*/
+function errorUnfilledPlaceholder(slot) {
+	return new CliStructuredError("MIGRATION.UNFILLED_PLACEHOLDER", "Unfilled migration placeholder", {
+		why: `The migration contains a placeholder that has not been filled in: ${slot}`,
+		fix: "Open migration.ts and replace the `placeholder(...)` call with your actual query.",
+		meta: { slot }
+	});
+}
+/**
+* Scaffolded `migration.ts` files call this wherever the scaffolder couldn't
+* emit a real query and the author is expected to fill one in. Always throws
+* a structured migration error (`MIGRATION.UNFILLED_PLACEHOLDER`).
+*
+* The return type `never` makes it assignable to any expected return type, so
+* a scaffolded `() => placeholder('...')` satisfies signatures like
+* `() => MongoQueryPlan` without polluting them with a sentinel union arm.
+*/
+function placeholder(slot) {
+	throw errorUnfilledPlaceholder(slot);
+}
+/**
+* A `dataTransform(endContract, …)` factory was handed a `SqlQueryPlan` whose
+* `meta.storageHash` does not match the `endContract.storage.storageHash` it
+* was configured with. This almost always means the user's query-builder
+* (`sql({ context: createExecutionContext({ contract: endContract, … }) })`)
+* was instantiated from a different contract reference than the one passed
+* to `dataTransform(endContract, …)`.
+*
+* Distinct from `errorHashMismatch` (`CONTRACT.MARKER_MISMATCH`) which
+* rejects a plan at runtime execution; this is an authoring-time rejection
+* so it lives in the `MIGRATION` namespace.
+*/
+function errorDataTransformContractMismatch(options) {
+	return new CliStructuredError("MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH", "dataTransform query plan built against wrong contract", {
+		why: `Data transform "${options.dataTransformName}" produced a query plan whose storage hash (${options.actual}) does not match the migration's contract (${options.expected}). The query builder was configured with a different contract than the one passed to dataTransform(endContract, ...).`,
+		fix: "Ensure the `endContract` imported at module scope (used for both `dataTransform(endContract, …)` and `sql({ context: createExecutionContext({ contract: endContract, … }) })`) is the same reference.",
+		meta: {
+			dataTransformName: options.dataTransformName,
+			expected: options.expected,
+			actual: options.actual
+		}
+	});
+}
+/**
+* `migration.ts` was expected at the given package directory but could not be
+* located. Thrown when consumers attempt to read a migration package that is
+* missing its source file.
+*/
+function errorMigrationFileMissing(dir) {
+	return new CliStructuredError("MIGRATION.FILE_MISSING", "migration.ts not found", {
+		why: `No migration.ts file was found at "${dir}"`,
+		fix: "Scaffold one with `prisma-next migration new` or `prisma-next migration plan`.",
+		meta: { dir }
+	});
+}
+/**
+* The `migration.ts` at the given package directory does not default-export a
+* valid migration shape. Two shapes are accepted: a `Migration` subclass, or a
+* factory function returning a `MigrationPlan`-shaped object (with at least
+* an `operations` array, plus `targetId` and `destination`). Thrown when the
+* default export is missing, is not a constructor/function, does not extend
+* `Migration`, or (for factory functions) returns a value that is not
+* `MigrationPlan`-shaped.
+*/
+function errorMigrationInvalidDefaultExport(dir, actualExportDescription) {
+	return new CliStructuredError("MIGRATION.INVALID_DEFAULT_EXPORT", "migration.ts default export is not a valid migration", {
+		why: actualExportDescription !== void 0 ? `migration.ts at "${dir}" must default-export a Migration subclass or a factory function returning a MigrationPlan-shaped object; got ${actualExportDescription}` : `migration.ts at "${dir}" must default-export a Migration subclass or a factory function returning a MigrationPlan-shaped object.`,
+		fix: "Use `export default class extends Migration { ... }` or `export default () => ({ targetId, destination, operations })`.",
+		meta: {
+			dir,
+			...actualExportDescription !== void 0 ? { actualExport: actualExportDescription } : {}
+		}
+	});
+}
+/**
+* The migration class declares one `targetId` but the loaded
+* `prisma-next.config.ts` declares another. Thrown by `MigrationCLI.run`
+* when a migration script is invoked against a config whose target
+* descriptor disagrees with the migration's own `targetId`. Distinct from generic
+* config-validation errors because the mismatch is between two valid
+* artifacts (the script and the config), not a malformed input.
+*/
+function errorMigrationTargetMismatch(options) {
+	return new CliStructuredError("MIGRATION.TARGET_MISMATCH", "Migration target does not match config target", {
+		why: `This migration is for target "${options.migrationTargetId}" but the loaded prisma-next.config.ts declares target "${options.configTargetId}". The migration script can only be run against a config that targets the same database.`,
+		fix: "Switch to a config whose `target` matches the migration's target, or pass `--config <path>` to point at the right config file.",
+		meta: {
+			migrationTargetId: options.migrationTargetId,
+			configTargetId: options.configTargetId
+		}
+	});
+}
+/**
+* A `Migration.operations` getter returned a value that is not an array. Used
+* by emit capabilities after instantiating the authored migration.
+*/
+function errorMigrationPlanNotArray(dir, actualValueDescription) {
+	return new CliStructuredError("MIGRATION.PLAN_NOT_ARRAY", "Migration.operations must be an array of operations", {
+		why: actualValueDescription !== void 0 ? `Migration.operations for migration.ts at "${dir}" was ${actualValueDescription}; an array of operations is required.` : `Migration.operations for migration.ts at "${dir}" is not an array of operations.`,
+		fix: "Ensure your `operations` getter returns an array of operations; see the data-migrations authoring guide.",
+		meta: {
+			dir,
+			...actualValueDescription !== void 0 ? { actualValue: actualValueDescription } : {}
+		}
+	});
+}
+//#endregion
+export { errorMigrationTargetMismatch as a, errorMigrationPlanNotArray as i, errorMigrationFileMissing as n, errorUnfilledPlaceholder as o, errorMigrationInvalidDefaultExport as r, placeholder as s, errorDataTransformContractMismatch as t };
+
+//# sourceMappingURL=migration-4VOHVEzx.mjs.map

package/dist/migration-4VOHVEzx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-4VOHVEzx.mjs","names":[],"sources":["../../../../1-framework/1-core/errors/dist/migration.mjs"],"sourcesContent":["import { t as CliStructuredError } from \"./control-Ftiau058.mjs\";\n//#region src/migration.ts\n/**\n* A scaffolded migration contains a placeholder slot that was never filled in.\n*\n* Thrown at emit time (when `check.source()` or `run()` is invoked) via the\n* `placeholder(...)` utility. The `slot` identifies the exact location the\n* author still needs to edit, e.g. `\"backfill-product-status:check.source\"`.\n*/\nfunction errorUnfilledPlaceholder(slot) {\n\treturn new CliStructuredError(\"MIGRATION.UNFILLED_PLACEHOLDER\", \"Unfilled migration placeholder\", {\n\t\twhy: `The migration contains a placeholder that has not been filled in: ${slot}`,\n\t\tfix: \"Open migration.ts and replace the `placeholder(...)` call with your actual query.\",\n\t\tmeta: { slot }\n\t});\n}\n/**\n* Scaffolded `migration.ts` files call this wherever the scaffolder couldn't\n* emit a real query and the author is expected to fill one in. Always throws\n* a structured migration error (`MIGRATION.UNFILLED_PLACEHOLDER`).\n*\n* The return type `never` makes it assignable to any expected return type, so\n* a scaffolded `() => placeholder('...')` satisfies signatures like\n* `() => MongoQueryPlan` without polluting them with a sentinel union arm.\n*/\nfunction placeholder(slot) {\n\tthrow errorUnfilledPlaceholder(slot);\n}\n/**\n* A `dataTransform(endContract, …)` factory was handed a `SqlQueryPlan` whose\n* `meta.storageHash` does not match the `endContract.storage.storageHash` it\n* was configured with. This almost always means the user's query-builder\n* (`sql({ context: createExecutionContext({ contract: endContract, … }) })`)\n* was instantiated from a different contract reference than the one passed\n* to `dataTransform(endContract, …)`.\n*\n* Distinct from `errorHashMismatch` (`CONTRACT.MARKER_MISMATCH`) which\n* rejects a plan at runtime execution; this is an authoring-time rejection\n* so it lives in the `MIGRATION` namespace.\n*/\nfunction errorDataTransformContractMismatch(options) {\n\treturn new CliStructuredError(\"MIGRATION.DATA_TRANSFORM_CONTRACT_MISMATCH\", \"dataTransform query plan built against wrong contract\", {\n\t\twhy: `Data transform \"${options.dataTransformName}\" produced a query plan whose storage hash (${options.actual}) does not match the migration's contract (${options.expected}). The query builder was configured with a different contract than the one passed to dataTransform(endContract, ...).`,\n\t\tfix: \"Ensure the `endContract` imported at module scope (used for both `dataTransform(endContract, …)` and `sql({ context: createExecutionContext({ contract: endContract, … }) })`) is the same reference.\",\n\t\tmeta: {\n\t\t\tdataTransformName: options.dataTransformName,\n\t\t\texpected: options.expected,\n\t\t\tactual: options.actual\n\t\t}\n\t});\n}\n/**\n* `migration.ts` was expected at the given package directory but could not be\n* located. Thrown when consumers attempt to read a migration package that is\n* missing its source file.\n*/\nfunction errorMigrationFileMissing(dir) {\n\treturn new CliStructuredError(\"MIGRATION.FILE_MISSING\", \"migration.ts not found\", {\n\t\twhy: `No migration.ts file was found at \"${dir}\"`,\n\t\tfix: \"Scaffold one with `prisma-next migration new` or `prisma-next migration plan`.\",\n\t\tmeta: { dir }\n\t});\n}\n/**\n* The `migration.ts` at the given package directory does not default-export a\n* valid migration shape. Two shapes are accepted: a `Migration` subclass, or a\n* factory function returning a `MigrationPlan`-shaped object (with at least\n* an `operations` array, plus `targetId` and `destination`). Thrown when the\n* default export is missing, is not a constructor/function, does not extend\n* `Migration`, or (for factory functions) returns a value that is not\n* `MigrationPlan`-shaped.\n*/\nfunction errorMigrationInvalidDefaultExport(dir, actualExportDescription) {\n\treturn new CliStructuredError(\"MIGRATION.INVALID_DEFAULT_EXPORT\", \"migration.ts default export is not a valid migration\", {\n\t\twhy: actualExportDescription !== void 0 ? `migration.ts at \"${dir}\" must default-export a Migration subclass or a factory function returning a MigrationPlan-shaped object; got ${actualExportDescription}` : `migration.ts at \"${dir}\" must default-export a Migration subclass or a factory function returning a MigrationPlan-shaped object.`,\n\t\tfix: \"Use `export default class extends Migration { ... }` or `export default () => ({ targetId, destination, operations })`.\",\n\t\tmeta: {\n\t\t\tdir,\n\t\t\t...actualExportDescription !== void 0 ? { actualExport: actualExportDescription } : {}\n\t\t}\n\t});\n}\n/**\n* The migration class declares one `targetId` but the loaded\n* `prisma-next.config.ts` declares another. Thrown by `MigrationCLI.run`\n* when a migration script is invoked against a config whose target\n* descriptor disagrees with the migration's own `targetId`. Distinct from generic\n* config-validation errors because the mismatch is between two valid\n* artifacts (the script and the config), not a malformed input.\n*/\nfunction errorMigrationTargetMismatch(options) {\n\treturn new CliStructuredError(\"MIGRATION.TARGET_MISMATCH\", \"Migration target does not match config target\", {\n\t\twhy: `This migration is for target \"${options.migrationTargetId}\" but the loaded prisma-next.config.ts declares target \"${options.configTargetId}\". The migration script can only be run against a config that targets the same database.`,\n\t\tfix: \"Switch to a config whose `target` matches the migration's target, or pass `--config <path>` to point at the right config file.\",\n\t\tmeta: {\n\t\t\tmigrationTargetId: options.migrationTargetId,\n\t\t\tconfigTargetId: options.configTargetId\n\t\t}\n\t});\n}\n/**\n* A `Migration.operations` getter returned a value that is not an array. Used\n* by emit capabilities after instantiating the authored migration.\n*/\nfunction errorMigrationPlanNotArray(dir, actualValueDescription) {\n\treturn new CliStructuredError(\"MIGRATION.PLAN_NOT_ARRAY\", \"Migration.operations must be an array of operations\", {\n\t\twhy: actualValueDescription !== void 0 ? `Migration.operations for migration.ts at \"${dir}\" was ${actualValueDescription}; an array of operations is required.` : `Migration.operations for migration.ts at \"${dir}\" is not an array of operations.`,\n\t\tfix: \"Ensure your `operations` getter returns an array of operations; see the data-migrations authoring guide.\",\n\t\tmeta: {\n\t\t\tdir,\n\t\t\t...actualValueDescription !== void 0 ? { actualValue: actualValueDescription } : {}\n\t\t}\n\t});\n}\n//#endregion\nexport { errorDataTransformContractMismatch, errorMigrationFileMissing, errorMigrationInvalidDefaultExport, errorMigrationPlanNotArray, errorMigrationTargetMismatch, errorUnfilledPlaceholder, placeholder };\n\n//# sourceMappingURL=migration.mjs.map"],"mappings":";;;;;;;;;AASA,SAAS,yBAAyB,MAAM;CACvC,OAAO,IAAI,mBAAmB,kCAAkC,kCAAkC;EACjG,KAAK,qEAAqE;EAC1E,KAAK;EACL,MAAM,EAAE,KAAK;CACd,CAAC;AACF;;;;;;;;;;AAUA,SAAS,YAAY,MAAM;CAC1B,MAAM,yBAAyB,IAAI;AACpC;;;;;;;;;;;;;AAaA,SAAS,mCAAmC,SAAS;CACpD,OAAO,IAAI,mBAAmB,8CAA8C,yDAAyD;EACpI,KAAK,mBAAmB,QAAQ,kBAAkB,8CAA8C,QAAQ,OAAO,6CAA6C,QAAQ,SAAS;EAC7K,KAAK;EACL,MAAM;GACL,mBAAmB,QAAQ;GAC3B,UAAU,QAAQ;GAClB,QAAQ,QAAQ;EACjB;CACD,CAAC;AACF;;;;;;AAMA,SAAS,0BAA0B,KAAK;CACvC,OAAO,IAAI,mBAAmB,0BAA0B,0BAA0B;EACjF,KAAK,sCAAsC,IAAI;EAC/C,KAAK;EACL,MAAM,EAAE,IAAI;CACb,CAAC;AACF;;;;;;;;;;AAUA,SAAS,mCAAmC,KAAK,yBAAyB;CACzE,OAAO,IAAI,mBAAmB,oCAAoC,wDAAwD;EACzH,KAAK,4BAA4B,KAAK,IAAI,oBAAoB,IAAI,gHAAgH,4BAA4B,oBAAoB,IAAI;EACtO,KAAK;EACL,MAAM;GACL;GACA,GAAG,4BAA4B,KAAK,IAAI,EAAE,cAAc,wBAAwB,IAAI,CAAC;EACtF;CACD,CAAC;AACF;;;;;;;;;AASA,SAAS,6BAA6B,SAAS;CAC9C,OAAO,IAAI,mBAAmB,6BAA6B,iDAAiD;EAC3G,KAAK,iCAAiC,QAAQ,kBAAkB,0DAA0D,QAAQ,eAAe;EACjJ,KAAK;EACL,MAAM;GACL,mBAAmB,QAAQ;GAC3B,gBAAgB,QAAQ;EACzB;CACD,CAAC;AACF;;;;;AAKA,SAAS,2BAA2B,KAAK,wBAAwB;CAChE,OAAO,IAAI,mBAAmB,4BAA4B,uDAAuD;EAChH,KAAK,2BAA2B,KAAK,IAAI,6CAA6C,IAAI,QAAQ,uBAAuB,yCAAyC,6CAA6C,IAAI;EACnN,KAAK;EACL,MAAM;GACL;GACA,GAAG,2BAA2B,KAAK,IAAI,EAAE,aAAa,uBAAuB,IAAI,CAAC;EACnF;CACD,CAAC;AACF"}

package/dist/migration-DKbDzBwy.d.mts

@@ -0,0 +1,74 @@
+import { r as CliStructuredError } from "./control-B87KWI_K-C_R8WfEr.mjs";
+//#region ../../../1-framework/1-core/errors/dist/migration.d.mts
+//#region src/migration.d.ts
+/**
+ * A scaffolded migration contains a placeholder slot that was never filled in.
+ *
+ * Thrown at emit time (when `check.source()` or `run()` is invoked) via the
+ * `placeholder(...)` utility. The `slot` identifies the exact location the
+ * author still needs to edit, e.g. `"backfill-product-status:check.source"`.
+ */
+declare function errorUnfilledPlaceholder(slot: string): CliStructuredError;
+/**
+ * Scaffolded `migration.ts` files call this wherever the scaffolder couldn't
+ * emit a real query and the author is expected to fill one in. Always throws
+ * a structured migration error (`MIGRATION.UNFILLED_PLACEHOLDER`).
+ *
+ * The return type `never` makes it assignable to any expected return type, so
+ * a scaffolded `() => placeholder('...')` satisfies signatures like
+ * `() => MongoQueryPlan` without polluting them with a sentinel union arm.
+ */
+declare function placeholder(slot: string): never;
+/**
+ * A `dataTransform(endContract, …)` factory was handed a `SqlQueryPlan` whose
+ * `meta.storageHash` does not match the `endContract.storage.storageHash` it
+ * was configured with. This almost always means the user's query-builder
+ * (`sql({ context: createExecutionContext({ contract: endContract, … }) })`)
+ * was instantiated from a different contract reference than the one passed
+ * to `dataTransform(endContract, …)`.
+ *
+ * Distinct from `errorHashMismatch` (`CONTRACT.MARKER_MISMATCH`) which
+ * rejects a plan at runtime execution; this is an authoring-time rejection
+ * so it lives in the `MIGRATION` namespace.
+ */
+declare function errorDataTransformContractMismatch(options: {
+  readonly dataTransformName: string;
+  readonly expected: string;
+  readonly actual: string;
+}): CliStructuredError;
+/**
+ * `migration.ts` was expected at the given package directory but could not be
+ * located. Thrown when consumers attempt to read a migration package that is
+ * missing its source file.
+ */
+declare function errorMigrationFileMissing(dir: string): CliStructuredError;
+/**
+ * The `migration.ts` at the given package directory does not default-export a
+ * valid migration shape. Two shapes are accepted: a `Migration` subclass, or a
+ * factory function returning a `MigrationPlan`-shaped object (with at least
+ * an `operations` array, plus `targetId` and `destination`). Thrown when the
+ * default export is missing, is not a constructor/function, does not extend
+ * `Migration`, or (for factory functions) returns a value that is not
+ * `MigrationPlan`-shaped.
+ */
+declare function errorMigrationInvalidDefaultExport(dir: string, actualExportDescription?: string): CliStructuredError;
+/**
+ * The migration class declares one `targetId` but the loaded
+ * `prisma-next.config.ts` declares another. Thrown by `MigrationCLI.run`
+ * when a migration script is invoked against a config whose target
+ * descriptor disagrees with the migration's own `targetId`. Distinct from generic
+ * config-validation errors because the mismatch is between two valid
+ * artifacts (the script and the config), not a malformed input.
+ */
+declare function errorMigrationTargetMismatch(options: {
+  readonly migrationTargetId: string;
+  readonly configTargetId: string;
+}): CliStructuredError;
+/**
+ * A `Migration.operations` getter returned a value that is not an array. Used
+ * by emit capabilities after instantiating the authored migration.
+ */
+declare function errorMigrationPlanNotArray(dir: string, actualValueDescription?: string): CliStructuredError;
+//#endregion
+export { errorMigrationTargetMismatch as a, errorMigrationPlanNotArray as i, errorMigrationFileMissing as n, errorUnfilledPlaceholder as o, errorMigrationInvalidDefaultExport as r, placeholder as s, errorDataTransformContractMismatch as t };
+//# sourceMappingURL=migration-DKbDzBwy.d.mts.map

package/dist/migration-DKbDzBwy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-DKbDzBwy.d.mts","names":[],"sources":["../../../../1-framework/1-core/errors/dist/migration.d.mts"],"mappings":";;;;;;;;;;iBASiB,yBAAyB,eAAe;;;;;;;;;;iBAUxC,YAAY;;;;;;;;;;;;;iBAaZ,mCAAmC;WACzC;WACA;WACA;IACP;;;;;;iBAMa,0BAA0B,cAAc;;;;;;;;;;iBAUxC,mCAAmC,aAAa,mCAAmC;;;;;;;;;iBASnF,6BAA6B;WACnC;WACA;IACP;;;;;iBAKa,2BAA2B,aAAa,kCAAkC"}

package/dist/namespace-id-asbWpwMw-3yxn-tRe.mjs

@@ -0,0 +1,9 @@
+import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
+//#region ../../../1-framework/0-foundation/contract/dist/namespace-id-asbWpwMw.mjs
+function asNamespaceId(value) {
+	return blindCast(value);
+}
+//#endregion
+export { asNamespaceId as t };
+
+//# sourceMappingURL=namespace-id-asbWpwMw-3yxn-tRe.mjs.map

package/dist/namespace-id-asbWpwMw-3yxn-tRe.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-id-asbWpwMw-3yxn-tRe.mjs","names":[],"sources":["../../../../1-framework/0-foundation/contract/dist/namespace-id-asbWpwMw.mjs"],"sourcesContent":["import { blindCast } from \"@internal/utils/casts\";\n//#region src/namespace-id.ts\nfunction asNamespaceId(value) {\n\treturn blindCast(value);\n}\n//#endregion\nexport { asNamespaceId as t };\n\n//# sourceMappingURL=namespace-id-asbWpwMw.mjs.map"],"mappings":";;AAEA,SAAS,cAAc,OAAO;CAC7B,OAAO,UAAU,KAAK;AACvB"}

package/dist/operations.d.mts

@@ -0,0 +1,46 @@
+//#region ../../../1-framework/1-core/operations/dist/index.d.mts
+//#region src/index.d.ts
+interface ParamSpec {
+  readonly codecId?: string;
+  readonly traits?: readonly string[];
+  readonly nullable: boolean;
+}
+interface ReturnSpec {
+  readonly codecId: string;
+  readonly nullable: boolean;
+}
+/**
+ * What an operation attaches to: a concrete codec identity, a set of codec
+ * traits the field's codec must carry, or list-typed (`many`) fields.
+ *
+ * Families refine this structurally — a family self spec may add its own
+ * members (for example element-level trait gating on the list variant) as
+ * long as every variant stays assignable to one here.
+ */
+type SelfSpec = {
+  readonly codecId: string;
+  readonly traits?: never;
+  readonly many?: never;
+} | {
+  readonly traits: readonly string[];
+  readonly codecId?: never;
+  readonly many?: never;
+} | {
+  readonly many: true;
+  readonly codecId?: never;
+  readonly traits?: never;
+};
+interface OperationEntry {
+  readonly self?: SelfSpec;
+  readonly impl: (...args: never[]) => unknown;
+}
+type OperationDescriptor<T extends OperationEntry = OperationEntry> = T;
+type OperationDescriptors<T extends OperationEntry = OperationEntry> = Readonly<Record<string, OperationDescriptor<T>>>;
+interface OperationRegistry<T extends OperationEntry = OperationEntry> {
+  register(name: string, descriptor: OperationDescriptor<T>): void;
+  entries(): Readonly<Record<string, T>>;
+}
+declare function createOperationRegistry<T extends OperationEntry = OperationEntry>(): OperationRegistry<T>;
+//#endregion
+export { OperationDescriptor, OperationDescriptors, OperationEntry, OperationRegistry, ParamSpec, ReturnSpec, SelfSpec, createOperationRegistry };
+//# sourceMappingURL=operations.d.mts.map

package/dist/operations.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.mts","names":[],"sources":["../../../../1-framework/1-core/operations/dist/index.d.mts"],"mappings":";;UACU;WACC;WACA;WACA;;UAED;WACC;WACA;;;;;;;;;;KAUN;WACM;WACA;WACA;;WAEA;WACA;WACA;;WAEA;WACA;WACA;;UAED;WACC,OAAO;WACP,UAAU;;KAEhB,oBAAoB,UAAU,iBAAiB,kBAAkB;KACjE,qBAAqB,UAAU,iBAAiB,kBAAkB,SAAS,eAAe,oBAAoB;UACzG,kBAAkB,UAAU,iBAAiB;EACrD,SAAS,cAAc,YAAY,oBAAoB;EACvD,WAAW,SAAS,eAAe;;iBAEpB,wBAAwB,UAAU,iBAAiB,mBAAmB,kBAAkB"}

package/dist/operations.mjs

@@ -0,0 +1,28 @@
+import { a as structuredError } from "./structured-error-H6WU9Kjt.mjs";
+//#region ../../../1-framework/1-core/operations/dist/index.mjs
+function contractError(code, message, options) {
+	return structuredError(code, message, options);
+}
+function createOperationRegistry() {
+	const operations = Object.create(null);
+	return {
+		register(name, descriptor) {
+			if (name in operations) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Operation "${name}" is already registered`, { meta: { operation: name } });
+			if (descriptor.self) {
+				const hasCodecId = descriptor.self.codecId !== void 0;
+				const hasTraits = descriptor.self.traits !== void 0 && descriptor.self.traits.length > 0;
+				const targetsMany = descriptor.self.many === true;
+				if (!hasCodecId && !hasTraits && !targetsMany) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Operation "${name}" self has none of codecId, traits, or many`, { meta: { operation: name } });
+				if (hasCodecId && hasTraits) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Operation "${name}" self has both codecId and traits`, { meta: { operation: name } });
+			}
+			operations[name] = descriptor;
+		},
+		entries() {
+			return Object.freeze({ ...operations });
+		}
+	};
+}
+//#endregion
+export { createOperationRegistry };
+
+//# sourceMappingURL=operations.mjs.map

package/dist/operations.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.mjs","names":[],"sources":["../../../../1-framework/1-core/operations/dist/index.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\n//#region src/contract-errors.ts\nfunction contractError(code, message, options) {\n\treturn structuredError(code, message, options);\n}\n//#endregion\n//#region src/index.ts\nfunction createOperationRegistry() {\n\tconst operations = Object.create(null);\n\treturn {\n\t\tregister(name, descriptor) {\n\t\t\tif (name in operations) throw contractError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Operation \"${name}\" is already registered`, { meta: { operation: name } });\n\t\t\tif (descriptor.self) {\n\t\t\t\tconst hasCodecId = descriptor.self.codecId !== void 0;\n\t\t\t\tconst hasTraits = descriptor.self.traits !== void 0 && descriptor.self.traits.length > 0;\n\t\t\t\tconst targetsMany = descriptor.self.many === true;\n\t\t\t\tif (!hasCodecId && !hasTraits && !targetsMany) throw contractError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Operation \"${name}\" self has none of codecId, traits, or many`, { meta: { operation: name } });\n\t\t\t\tif (hasCodecId && hasTraits) throw contractError(\"CONTRACT.PACK_CONTRIBUTION_INVALID\", `Operation \"${name}\" self has both codecId and traits`, { meta: { operation: name } });\n\t\t\t}\n\t\t\toperations[name] = descriptor;\n\t\t},\n\t\tentries() {\n\t\t\treturn Object.freeze({ ...operations });\n\t\t}\n\t};\n}\n//#endregion\nexport { createOperationRegistry };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":";;AAEA,SAAS,cAAc,MAAM,SAAS,SAAS;CAC9C,OAAO,gBAAgB,MAAM,SAAS,OAAO;AAC9C;AAGA,SAAS,0BAA0B;CAClC,MAAM,aAAa,OAAO,OAAO,IAAI;CACrC,OAAO;EACN,SAAS,MAAM,YAAY;GAC1B,IAAI,QAAQ,YAAY,MAAM,cAAc,sCAAsC,cAAc,KAAK,0BAA0B,EAAE,MAAM,EAAE,WAAW,KAAK,EAAE,CAAC;GAC5J,IAAI,WAAW,MAAM;IACpB,MAAM,aAAa,WAAW,KAAK,YAAY,KAAK;IACpD,MAAM,YAAY,WAAW,KAAK,WAAW,KAAK,KAAK,WAAW,KAAK,OAAO,SAAS;IACvF,MAAM,cAAc,WAAW,KAAK,SAAS;IAC7C,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,aAAa,MAAM,cAAc,sCAAsC,cAAc,KAAK,8CAA8C,EAAE,MAAM,EAAE,WAAW,KAAK,EAAE,CAAC;IACvM,IAAI,cAAc,WAAW,MAAM,cAAc,sCAAsC,cAAc,KAAK,qCAAqC,EAAE,MAAM,EAAE,WAAW,KAAK,EAAE,CAAC;GAC7K;GACA,WAAW,QAAQ;EACpB;EACA,UAAU;GACT,OAAO,OAAO,OAAO,EAAE,GAAG,WAAW,CAAC;EACvC;CACD;AACD"}