@prisma-next-idb/target-idb 0.1.0

package/dist/descriptor-meta-CKLekROR.mjs

@@ -0,0 +1,237 @@
+//#region src/core/codecs.ts
+/**
+* IDB codec descriptors — the registry of type→IDB mapping metadata.
+*
+* Each descriptor declares its `codecId`, `traits`, `targetTypes`, and a
+* `factory` that returns a `Codec` instance. This is consumed by the
+* emitter to generate `contract.d.ts` type maps, and by the adapter at
+* runtime to resolve encode/decode per field.
+*/
+const codecDescriptors = [
+	{
+		codecId: "idb/string@1",
+		traits: ["equality", "textual"],
+		targetTypes: ["string"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/string@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => value,
+			decodeJson: (value) => value
+		})
+	},
+	{
+		codecId: "idb/double@1",
+		traits: [
+			"equality",
+			"numeric",
+			"order"
+		],
+		targetTypes: ["number"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/double@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => value,
+			decodeJson: (value) => value
+		})
+	},
+	{
+		codecId: "idb/int32@1",
+		traits: [
+			"equality",
+			"numeric",
+			"order"
+		],
+		targetTypes: ["number"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/int32@1",
+			encode: async (value) => {
+				if (!Number.isInteger(value)) throw new Error(`Value ${value} is not an integer and cannot be encoded as int32.`);
+				if (value < -Math.pow(2, 31) || value > Math.pow(2, 31) - 1) throw new Error(`Value ${value} is out of range for int32 and cannot be encoded.`);
+				return value;
+			},
+			decode: async (value) => value,
+			encodeJson: (value) => value,
+			decodeJson: (value) => value
+		})
+	},
+	{
+		codecId: "idb/bool@1",
+		traits: ["equality", "boolean"],
+		targetTypes: ["boolean"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/bool@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => value,
+			decodeJson: (value) => value
+		})
+	},
+	{
+		codecId: "idb/date@1",
+		traits: ["equality", "order"],
+		targetTypes: ["Date"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/date@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => value.toISOString(),
+			decodeJson: (value) => new Date(value)
+		})
+	},
+	{
+		codecId: "idb/bigint@1",
+		traits: [
+			"equality",
+			"numeric",
+			"order"
+		],
+		targetTypes: ["bigint"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/bigint@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => value.toString(),
+			decodeJson: (value) => BigInt(value)
+		})
+	},
+	{
+		codecId: "idb/decimal@1",
+		traits: ["equality", "numeric"],
+		targetTypes: ["string"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/decimal@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => value,
+			decodeJson: (value) => value
+		})
+	},
+	{
+		codecId: "idb/json@1",
+		traits: ["equality"],
+		targetTypes: ["unknown"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/json@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => value,
+			decodeJson: (value) => value
+		})
+	},
+	{
+		codecId: "idb/bytes@1",
+		traits: ["equality"],
+		targetTypes: ["Uint8Array"],
+		paramsSchema: void 0,
+		isParameterized: false,
+		factory: () => () => ({
+			id: "idb/bytes@1",
+			encode: async (value) => value,
+			decode: async (value) => value,
+			encodeJson: (value) => {
+				const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+				let result = "", i = 0;
+				while (i < value.length) {
+					const a = value[i++] ?? 0, b = value[i++] ?? 0, c = value[i++] ?? 0;
+					result += chars[a >> 2] + chars[(a & 3) << 4 | b >> 4] + (i - 1 < value.length || i - 2 < value.length ? chars[(b & 15) << 2 | c >> 6] : "=") + (i - 1 < value.length ? chars[c & 63] : "=");
+				}
+				return result;
+			},
+			decodeJson: (value) => {
+				const b64 = value;
+				const lookup = /* @__PURE__ */ new Uint8Array(128);
+				"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("").forEach((c, i) => {
+					lookup[c.charCodeAt(0)] = i;
+				});
+				const stripped = b64.replace(/=+$/, "");
+				const out = new Uint8Array(Math.floor(stripped.length * 3 / 4));
+				let o = 0;
+				for (let i = 0; i < stripped.length; i += 4) {
+					const a = lookup[stripped.charCodeAt(i)] ?? 0;
+					const b = lookup[stripped.charCodeAt(i + 1)] ?? 0;
+					const c = lookup[stripped.charCodeAt(i + 2)] ?? 0;
+					const d = lookup[stripped.charCodeAt(i + 3)] ?? 0;
+					out[o++] = a << 2 | b >> 4;
+					if (i + 2 < stripped.length) out[o++] = (b & 15) << 4 | c >> 2;
+					if (i + 3 < stripped.length) out[o++] = (c & 3) << 6 | d;
+				}
+				return out;
+			}
+		})
+	}
+];
+/**
+* Pre-built CodecLookup for all IDB codecs.
+*
+* All IDB codecs are currently identity transforms, but using the real lookup
+* ensures per-field encoding works automatically when non-identity codecs are
+* added (e.g. idb/date@1 already encodes/decodes Date objects).
+*/
+const idbCodecLookup = (() => {
+	const codecMap = new Map(codecDescriptors.map((desc) => {
+		const ctx = { name: `<codec:${desc.codecId}>` };
+		const codec = desc.factory(void 0)(ctx);
+		return [desc.codecId, codec];
+	}));
+	const targetTypesMap = new Map(codecDescriptors.map((desc) => [desc.codecId, desc.targetTypes]));
+	return {
+		get: (id) => codecMap.get(id),
+		targetTypesFor: (id) => targetTypesMap.get(id),
+		metaFor: () => void 0,
+		renderOutputTypeFor: () => void 0
+	};
+})();
+//#endregion
+//#region src/core/descriptor-meta.ts
+/**
+* Descriptor metadata for the IndexedDB target.
+*
+* This is the identity record for the `idb` target within the `idb` family.
+* It is consumed by:
+* - The family descriptor (`family-idb`) to register this target in the control stack.
+* - The emitter during contract generation to stamp `contract.target = 'idb'`.
+*
+* `types.codecTypes.import` tells the emitter where to import `CodecTypes`
+* when generating `contract.d.ts`. The named export `CodecTypes` must be
+* re-exported from the `pack` entrypoint of this package.
+*
+* Targets are identifiers/descriptors — they do NOT declare capabilities.
+* Capabilities belong on the adapter descriptor.
+*/
+const idbTargetDescriptorMeta = {
+	kind: "target",
+	familyId: "idb",
+	targetId: "idb",
+	id: "idb",
+	version: "0.0.1",
+	types: { codecTypes: {
+		import: {
+			package: "@prisma-next-idb/target-idb/pack",
+			named: "CodecTypes",
+			alias: "IdbCodecTypes"
+		},
+		codecDescriptors
+	} }
+};
+//#endregion
+export { idbCodecLookup as n, idbTargetDescriptorMeta as t };
+
+//# sourceMappingURL=descriptor-meta-CKLekROR.mjs.map

package/dist/descriptor-meta-CKLekROR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-CKLekROR.mjs","names":[],"sources":["../src/core/codecs.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import { JsonValue } from \"@prisma-next/contract/types\";\nimport type { AnyCodecDescriptor, CodecInstanceContext, CodecLookup } from \"@prisma-next/framework-components/codec\";\n\n/**\n * IDB codec descriptors — the registry of type→IDB mapping metadata.\n *\n * Each descriptor declares its `codecId`, `traits`, `targetTypes`, and a\n * `factory` that returns a `Codec` instance. This is consumed by the\n * emitter to generate `contract.d.ts` type maps, and by the adapter at\n * runtime to resolve encode/decode per field.\n */\nexport const codecDescriptors: readonly AnyCodecDescriptor[] = [\n  {\n    codecId: \"idb/string@1\",\n    traits: [\"equality\", \"textual\"],\n    targetTypes: [\"string\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/string@1\",\n      encode: async (value: string) => value,\n      decode: async (value: string) => value,\n      encodeJson: (value: string) => value,\n      decodeJson: (value: string) => value,\n    }),\n  },\n  {\n    codecId: \"idb/double@1\",\n    traits: [\"equality\", \"numeric\", \"order\"],\n    targetTypes: [\"number\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/double@1\",\n      encode: async (value: number) => value,\n      decode: async (value: number) => value,\n      encodeJson: (value: number) => value,\n      decodeJson: (value: number) => value,\n    }),\n  },\n  {\n    codecId: \"idb/int32@1\",\n    traits: [\"equality\", \"numeric\", \"order\"],\n    targetTypes: [\"number\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/int32@1\",\n      encode: async (value: number) => {\n        if (!Number.isInteger(value)) {\n          throw new Error(`Value ${value} is not an integer and cannot be encoded as int32.`);\n        }\n        if (value < -Math.pow(2, 31) || value > Math.pow(2, 31) - 1) {\n          throw new Error(`Value ${value} is out of range for int32 and cannot be encoded.`);\n        }\n        return value;\n      },\n      decode: async (value: number) => value,\n      encodeJson: (value: number) => value,\n      decodeJson: (value: number) => value,\n    }),\n  },\n  {\n    codecId: \"idb/bool@1\",\n    traits: [\"equality\", \"boolean\"],\n    targetTypes: [\"boolean\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/bool@1\",\n      encode: async (value: boolean) => value,\n      decode: async (value: boolean) => value,\n      encodeJson: (value: boolean) => value,\n      decodeJson: (value: boolean) => value,\n    }),\n  },\n  {\n    codecId: \"idb/date@1\",\n    traits: [\"equality\", \"order\"],\n    targetTypes: [\"Date\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/date@1\",\n      encode: async (value: Date) => value,\n      decode: async (value: Date) => value,\n      encodeJson: (value: Date) => value.toISOString(),\n      decodeJson: (value: string) => new Date(value),\n    }),\n  },\n  {\n    codecId: \"idb/bigint@1\",\n    traits: [\"equality\", \"numeric\", \"order\"],\n    targetTypes: [\"bigint\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/bigint@1\",\n      encode: async (value: bigint) => value,\n      decode: async (value: bigint) => value,\n      encodeJson: (value: bigint) => value.toString(),\n      decodeJson: (value: string) => BigInt(value),\n    }),\n  },\n  {\n    codecId: \"idb/decimal@1\",\n    traits: [\"equality\", \"numeric\"],\n    targetTypes: [\"string\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/decimal@1\",\n      encode: async (value: string) => value,\n      decode: async (value: string) => value,\n      encodeJson: (value: string) => value,\n      decodeJson: (value: string) => value,\n    }),\n  },\n  {\n    codecId: \"idb/json@1\",\n    traits: [\"equality\"],\n    targetTypes: [\"unknown\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/json@1\",\n      encode: async (value: unknown) => value,\n      decode: async (value: unknown) => value,\n      encodeJson: (value: JsonValue) => value as JsonValue,\n      decodeJson: (value: JsonValue) => value,\n    }),\n  },\n  {\n    codecId: \"idb/bytes@1\",\n    traits: [\"equality\"],\n    targetTypes: [\"Uint8Array\"],\n    paramsSchema: undefined as never,\n    isParameterized: false,\n    factory: () => () => ({\n      id: \"idb/bytes@1\",\n      encode: async (value: Uint8Array) => value,\n      decode: async (value: Uint8Array) => value,\n      encodeJson: (value: Uint8Array) => {\n        const chars = \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";\n        let result = \"\",\n          i = 0;\n        while (i < value.length) {\n          const a = value[i++] ?? 0,\n            b = value[i++] ?? 0,\n            c = value[i++] ?? 0;\n          result +=\n            chars[a >> 2]! +\n            chars[((a & 3) << 4) | (b >> 4)]! +\n            (i - 1 < value.length || i - 2 < value.length ? chars[((b & 15) << 2) | (c >> 6)]! : \"=\") +\n            (i - 1 < value.length ? chars[c & 63]! : \"=\");\n        }\n        return result;\n      },\n      decodeJson: (value: string) => {\n        const b64 = value as string;\n        const lookup = new Uint8Array(128);\n        \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\".split(\"\").forEach((c, i) => {\n          lookup[c.charCodeAt(0)!] = i;\n        });\n        const stripped = b64.replace(/=+$/, \"\");\n        const out = new Uint8Array(Math.floor((stripped.length * 3) / 4));\n        let o = 0;\n        for (let i = 0; i < stripped.length; i += 4) {\n          const a = lookup[stripped.charCodeAt(i)!]! ?? 0;\n          const b = lookup[stripped.charCodeAt(i + 1)!]! ?? 0;\n          const c = lookup[stripped.charCodeAt(i + 2)!]! ?? 0;\n          const d = lookup[stripped.charCodeAt(i + 3)!]! ?? 0;\n          out[o++] = (a << 2) | (b >> 4);\n          if (i + 2 < stripped.length) out[o++] = ((b & 15) << 4) | (c >> 2);\n          if (i + 3 < stripped.length) out[o++] = ((c & 3) << 6) | d;\n        }\n        return out;\n      },\n    }),\n  },\n] as const;\n\n// ── Codec lookup ──────────────────────────────────────────────────────────────\n\n/**\n * Pre-built CodecLookup for all IDB codecs.\n *\n * All IDB codecs are currently identity transforms, but using the real lookup\n * ensures per-field encoding works automatically when non-identity codecs are\n * added (e.g. idb/date@1 already encodes/decodes Date objects).\n */\nexport const idbCodecLookup: CodecLookup = (() => {\n  const codecMap = new Map(\n    codecDescriptors.map((desc) => {\n      const ctx: CodecInstanceContext = { name: `<codec:${desc.codecId}>` };\n      const codec = (desc as AnyCodecDescriptor).factory(undefined)(ctx);\n      return [desc.codecId, codec] as const;\n    })\n  );\n  const targetTypesMap = new Map(codecDescriptors.map((desc) => [desc.codecId, desc.targetTypes]));\n  return {\n    get: (id) => codecMap.get(id),\n    targetTypesFor: (id) => targetTypesMap.get(id),\n    metaFor: () => undefined,\n    renderOutputTypeFor: () => undefined,\n  };\n})();\n","import type { TargetDescriptor } from \"@prisma-next/framework-components/components\";\nimport { codecDescriptors } from \"./codecs\";\n\n/**\n * Descriptor metadata for the IndexedDB target.\n *\n * This is the identity record for the `idb` target within the `idb` family.\n * It is consumed by:\n * - The family descriptor (`family-idb`) to register this target in the control stack.\n * - The emitter during contract generation to stamp `contract.target = 'idb'`.\n *\n * `types.codecTypes.import` tells the emitter where to import `CodecTypes`\n * when generating `contract.d.ts`. The named export `CodecTypes` must be\n * re-exported from the `pack` entrypoint of this package.\n *\n * Targets are identifiers/descriptors — they do NOT declare capabilities.\n * Capabilities belong on the adapter descriptor.\n */\nexport const idbTargetDescriptorMeta = {\n  kind: \"target\",\n  familyId: \"idb\",\n  targetId: \"idb\",\n  id: \"idb\",\n  version: \"0.0.1\",\n  types: {\n    codecTypes: {\n      import: {\n        package: \"@prisma-next-idb/target-idb/pack\",\n        named: \"CodecTypes\",\n        alias: \"IdbCodecTypes\",\n      },\n      codecDescriptors,\n    },\n  },\n} as const satisfies TargetDescriptor<\"idb\", \"idb\">;\n"],"mappings":"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"}

package/dist/idb-contract-types-DndrdtW0.d.mts

@@ -0,0 +1,111 @@
+import { StorageBase } from "@prisma-next/contract/types";
+
+//#region src/core/idb-contract-types.d.ts
+/**
+ * Full storage shape for an IDB contract.
+ *
+ * Extends the framework {@link StorageBase} to carry the `storageHash` alongside
+ * IDB-specific data: a map of object store names to their {@link IdbStoreDefinition}s.
+ *
+ * @template THash - Literal hash string embedded in the `storageHash` branded type.
+ */
+type IdbStorage<THash extends string = string> = StorageBase<THash> & {
+  readonly stores: Record<string, IdbStoreDefinition>;
+};
+/**
+ * Configuration for a single IndexedDB object store.
+ *
+ * Mirrors the options accepted by `IDBDatabase.createObjectStore()`:
+ * - `keyPath` — the property path used as the primary key (e.g. `"id"`).
+ * - `autoIncrement` — when `true` IDB auto-generates integer keys. Omit (or `false`)
+ *   for client-generated keys (UUID / CUID), which is the common case for syncable models.
+ * - `indexes` — named secondary indexes on this store.
+ */
+type IdbStoreDefinition = {
+  readonly keyPath: string;
+  readonly autoIncrement?: boolean;
+  readonly indexes?: Record<string, IdbIndexDefinition>;
+};
+/**
+ * Configuration for a single secondary index on an object store.
+ *
+ * Mirrors the options accepted by `IDBObjectStore.createIndex()`.
+ */
+type IdbIndexDefinition = {
+  readonly keyPath: string;
+  readonly unique: boolean;
+  readonly multiEntry?: boolean;
+};
+/** Referential action executed on child rows when a parent row is deleted. */
+type IdbReferentialAction = "cascade" | "setNull" | "setDefault" | "restrict" | "noAction";
+/** Per-relation storage metadata attached to {@link IdbModelStorage}. */
+type IdbRelationStorage = {
+  readonly onDelete?: IdbReferentialAction;
+};
+/**
+ * Per-model storage metadata stored in `contract.models[ModelName].storage`.
+ *
+ * Tells the runtime (and the generated client) which object store owns this model
+ * and which field is its primary key. `relations` carries per-relation enforcement
+ * metadata (e.g. `onDelete`) mirroring the SQL target's FK constraint metadata.
+ */
+type IdbModelStorage = {
+  readonly storeName: string;
+  readonly keyPath: string;
+  readonly relations?: Record<string, IdbRelationStorage>;
+};
+/**
+ * Type-maps structure for IDB contracts.
+ *
+ * IDB has no SQL-style operation types or query-operation types — those slots are
+ * fixed to `Record<string, never>`. Only codec types and field I/O types vary.
+ *
+ * @template TCodecTypes          - Codec input/output pairs keyed by codec ID.
+ * @template TFieldOutputTypes    - Per-model, per-field TypeScript output types.
+ * @template TFieldInputTypes     - Per-model, per-field TypeScript input types.
+ */
+type IdbTypeMaps<TCodecTypes extends Record<string, {
+  output: unknown;
+}> = Record<string, never>, TFieldOutputTypes extends Record<string, Record<string, unknown>> = Record<string, never>, TFieldInputTypes extends Record<string, Record<string, unknown>> = Record<string, never>> = {
+  readonly codecTypes: TCodecTypes;
+  readonly operationTypes: Record<string, never>;
+  readonly queryOperationTypes: Record<string, never>;
+  readonly fieldOutputTypes: TFieldOutputTypes;
+  readonly fieldInputTypes: TFieldInputTypes;
+};
+/** @internal Phantom key used to attach {@link IdbTypeMaps} to a contract without widening the contract shape. */
+type IdbTypeMapsPhantomKey = "__@prisma-next-idb/family-idb/typeMaps@__";
+/**
+ * Intersects a contract type with its type-maps via a phantom property.
+ *
+ * Mirrors `ContractWithTypeMaps` from `@prisma-next/sql-contract/types`. The phantom
+ * property is optional and carries no runtime value — it exists solely so that
+ * TypeScript-level utilities can extract `TTypeMaps` from a `Contract` type parameter.
+ *
+ * @template TContract  - The base contract type.
+ * @template TTypeMaps  - The {@link IdbTypeMaps} instantiation to attach.
+ */
+type IdbContractWithTypeMaps<TContract, TTypeMaps> = TContract & { readonly [K in IdbTypeMapsPhantomKey]?: TTypeMaps };
+/**
+ * Extract the full {@link IdbTypeMaps} from a contract wrapped with
+ * {@link IdbContractWithTypeMaps}. Returns `never` if the contract does not
+ * carry type maps (e.g. a plain `Contract<IdbStorage>` without the phantom key).
+ */
+type ExtractIdbTypeMaps<TContract> = TContract extends { readonly [K in IdbTypeMapsPhantomKey]?: infer TM } ? TM : never;
+/**
+ * Extract the `fieldOutputTypes` slot from a contract's type maps.
+ *
+ * Used by the IDB ORM client to resolve per-model, per-field TypeScript output
+ * types from the emitted `IdbTypeMaps<CodecTypes, FieldOutputTypes, FieldInputTypes>`.
+ */
+type ExtractIdbFieldOutputTypes<TContract> = ExtractIdbTypeMaps<TContract> extends IdbTypeMaps<any, infer FO, any> ? FO : never;
+/**
+ * Extract the `fieldInputTypes` slot from a contract's type maps.
+ *
+ * Used by the IDB ORM client to resolve per-model, per-field TypeScript input
+ * types (for `create()`, `where()`, etc.).
+ */
+type ExtractIdbFieldInputTypes<TContract> = ExtractIdbTypeMaps<TContract> extends IdbTypeMaps<any, any, infer FI> ? FI : never;
+//#endregion
+export { IdbIndexDefinition as a, IdbRelationStorage as c, IdbTypeMaps as d, IdbContractWithTypeMaps as i, IdbStorage as l, ExtractIdbFieldOutputTypes as n, IdbModelStorage as o, ExtractIdbTypeMaps as r, IdbReferentialAction as s, ExtractIdbFieldInputTypes as t, IdbStoreDefinition as u };
+//# sourceMappingURL=idb-contract-types-DndrdtW0.d.mts.map

package/dist/idb-contract-types-DndrdtW0.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-contract-types-DndrdtW0.d.mts","names":[],"sources":["../src/core/idb-contract-types.ts"],"mappings":";;;;;AAUA;;;;;;KAAY,UAAA,kCAA4C,WAAA,CAAY,KAAA;EAAA,SACzD,MAAA,EAAQ,MAAA,SAAe,kBAAA;AAAA;;;;;;;;AAAkB;AAYpD;KAAY,kBAAA;EAAA,SACD,OAAA;EAAA,SACA,aAAA;EAAA,SACA,OAAA,GAAU,MAAM,SAAS,kBAAA;AAAA;;;;;AAAkB;KAQ1C,kBAAA;EAAA,SACD,OAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;AAAA;;KAIC,oBAAA;;KAGA,kBAAA;EAAA,SACD,QAAA,GAAW,oBAAoB;AAAA;;;AAJV;AAGhC;;;;KAWY,eAAA;EAAA,SACD,SAAA;EAAA,SACA,OAAA;EAAA,SACA,SAAA,GAAY,MAAM,SAAS,kBAAA;AAAA;;;;;;;AAAkB;AAaxD;;;KAAY,WAAA,qBACU,MAAA;EAAiB,MAAA;AAAA,KAAqB,MAAA,2CAChC,MAAA,SAAe,MAAA,qBAA2B,MAAA,0CAC3C,MAAA,SAAe,MAAA,qBAA2B,MAAA;EAAA,SAE1D,UAAA,EAAY,WAAA;EAAA,SACZ,cAAA,EAAgB,MAAA;EAAA,SAChB,mBAAA,EAAqB,MAAA;EAAA,SACrB,gBAAA,EAAkB,iBAAA;EAAA,SAClB,eAAA,EAAiB,gBAAA;AAAA;;KAIvB,qBAAA;;;;;;;;;;;KAYO,uBAAA,yBAAgD,SAAA,oBAC3C,qBAAA,IAAyB,SAAA;;;;;;KAU9B,kBAAA,cAAgC,SAAA,0BAC3B,qBAAqB,iBAElC,EAAA;;;;;;;KASQ,0BAAA,cAEV,kBAAA,CAAmB,SAAA,UAAmB,WAAA,uBAAkC,EAAA;AAxCxE;;;;AAGwB;AAY1B;AAfE,KAgDU,yBAAA,cAEV,kBAAA,CAAmB,SAAA,UAAmB,WAAA,uBAAkC,EAAA"}

package/dist/migration-B43yOFXO.d.mts

@@ -0,0 +1,227 @@
+import { u as IdbStoreDefinition } from "./idb-contract-types-DndrdtW0.mjs";
+import { d as IdbDdlOp } from "./apply-ddl-op-DZAoihY0.mjs";
+import { ControlDriverInstance, MigrationOperationPolicy, MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationPlannerResult, MigrationRunner, MigrationRunnerPerSpaceOptions, MigrationRunnerResult, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
+import { Migration } from "@prisma-next/migration-tools/migration";
+import { Contract } from "@prisma-next/contract/types";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+
+//#region src/core/schema-diff.d.ts
+/**
+ * Minimal schema shape used for diffing.
+ *
+ * Structurally identical to `IdbSchemaIR` in `family-idb` — compatible by
+ * TypeScript's structural typing. The contract's `storage.stores` map
+ * (which uses `IdbStoreDefinition`) has the same shape as `IdbStoreIR`, so
+ * both can be passed here without conversion.
+ */
+type IdbSchemaDiffInput = {
+  readonly stores: Record<string, IdbStoreDefinition>;
+};
+/**
+ * Compute an ordered set of DDL operations to migrate from `from` to `to`.
+ *
+ * Safe execution order (important for a single `upgradeneeded` transaction):
+ * 1. Create new stores — additive
+ * 2. Create indexes on those new stores — additive
+ * 3. Create new indexes on existing stores — additive
+ * 4. Replace mutated indexes on surviving stores — destructive + additive
+ *    (IDB cannot alter an existing index in place, so this is drop+create)
+ * 5. Drop removed indexes from surviving stores — destructive
+ * 6. Drop removed stores — destructive
+ *
+ * @param from - Current schema, or `null` for a fresh (empty) database.
+ * @param to   - Desired target schema.
+ *
+ * **Note on store-level mutations.** IDB cannot alter an object store's
+ * `keyPath` or `autoIncrement` after creation. When those change between
+ * `from` and `to` for the same store name, this function throws — silent
+ * no-op is worse than an explicit error. The recovery path is a manual
+ * migration that drops the store and re-creates it (with whatever data
+ * preservation strategy the caller wants).
+ */
+declare function diffIdbSchema(from: IdbSchemaDiffInput | null, to: IdbSchemaDiffInput): IdbDdlOp[];
+//#endregion
+//#region src/core/migration-driver.d.ts
+/**
+ * Extended IDB control driver for migrations.
+ *
+ * Carries the `IDBFactory`, database name, and target version number so
+ * the migration runner can open the database and perform DDL inside the
+ * `upgradeneeded` callback.
+ *
+ * The `targetVersion` is the IDB database version to upgrade **to**. The
+ * caller is responsible for computing this value — typically by reading
+ * `manifest.idbVersion ?? 0` and adding 1.
+ *
+ * After a successful `IdbMigrationRunner.execute()` call, the caller must
+ * write the new `idbVersion` (= `targetVersion`) back to the manifest.
+ * The runner itself does not touch the manifest.
+ */
+type IdbMigrationControlDriver = ControlDriverInstance<"idb", "idb"> & {
+  readonly dbName: string;
+  readonly factory: IDBFactory;
+  readonly targetVersion: number;
+};
+/**
+ * Factory descriptor for `IdbMigrationControlDriver`.
+ *
+ * Usage:
+ * ```ts
+ * const driver = IdbMigrationControlDriverDescriptor.create({
+ *   dbName: "my-app",
+ *   factory: window.indexedDB,   // or new IDBFactory() from fake-indexeddb
+ *   targetVersion: (manifest.idbVersion ?? 0) + 1,
+ * });
+ * ```
+ */
+declare const IdbMigrationControlDriverDescriptor: {
+  readonly version: "1.0.0";
+  readonly create: ({
+    dbName,
+    factory,
+    targetVersion
+  }: {
+    readonly dbName: string;
+    readonly factory: IDBFactory;
+    readonly targetVersion: number;
+  }) => IdbMigrationControlDriver;
+};
+/**
+ * Narrows a `ControlDriverInstance<"idb","idb">` to `IdbMigrationControlDriver`.
+ *
+ * Throws a descriptive error if the driver was not created by
+ * {@link IdbMigrationControlDriverDescriptor}.
+ */
+declare function extractMigrationDriver(driver: ControlDriverInstance<"idb", "idb">): IdbMigrationControlDriver;
+//#endregion
+//#region src/core/migration-runner.d.ts
+/**
+ * IDB migration runner.
+ *
+ * `execute()` returns a structured refusal — IndexedDB only exists in the
+ * browser, so the framework's CLI control plane (`db init`, `db update`,
+ * `migration apply`) has no live database to talk to. The refusal points users
+ * at `prisma-next-idb preflight` for chain validation. The browser apply path
+ * goes through `openAndUpgrade()` directly via `auto-migrate.ts` in client-idb.
+ *
+ * v0.12.0 merged the former single-space `execute({plan, …})` and
+ * `executeAcrossSpaces({perSpaceOptions})` into one multi-space
+ * `execute({driver, perSpaceOptions})`; the `MultiSpaceCapableRunner` interface
+ * and `MultiSpace*` types were removed.
+ */
+declare class IdbMigrationRunner implements MigrationRunner<"idb", "idb"> {
+  /**
+   * Apply one or more per-space migration plans. IDB cannot be applied from
+   * the CLI — `IndexedDB` is a browser API — so this always returns a
+   * structured refusal. Authoring stays in `prisma-next migration new` /
+   * `prisma-next migration plan`; validation lives in `prisma-next-idb
+   * preflight`; apply happens in the browser the next time the user opens the
+   * app via `createAutoMigratingIdbClient`.
+   */
+  execute(options: {
+    readonly driver: ControlDriverInstance<"idb", "idb">;
+    readonly perSpaceOptions: ReadonlyArray<MigrationRunnerPerSpaceOptions<"idb", "idb">>;
+  }): Promise<MigrationRunnerResult>;
+}
+//#endregion
+//#region src/core/migration-planner.d.ts
+/**
+ * IDB-specific migration plan.
+ *
+ * Extends `MigrationPlanWithAuthoringSurface` by narrowing `operations` to
+ * `readonly IdbDdlOp[]`. This is a valid covariant narrowing because
+ * `IdbDdlOp extends MigrationPlanOperation`.
+ *
+ * The runner re-casts `plan.operations` back to `readonly IdbDdlOp[]` via
+ * `isIdbDdlOp` validation.
+ */
+interface IdbMigrationPlanWithAuthoring extends MigrationPlanWithAuthoringSurface {
+  readonly operations: readonly IdbDdlOp[];
+}
+/**
+ * Extract an `IdbSchemaDiffInput` from a raw contract object.
+ *
+ * Returns `null` for a null contract (fresh database — no prior schema).
+ * The extraction is dynamic because contracts arrive as `unknown` / `Contract`
+ * at planner call sites.
+ */
+declare function contractToIdbSchema(contract: Contract | null | unknown): IdbSchemaDiffInput | null;
+/**
+ * IDB migration planner.
+ *
+ * `plan()` converts `fromContract` and `contract` into `IdbSchemaDiffInput`s,
+ * diffs them using {@link diffIdbSchema}, and returns an
+ * {@link IdbMigrationPlanWithAuthoring} that can be executed by
+ * {@link IdbMigrationRunner} or rendered to a TypeScript migration file via
+ * the class-based scaffold matching vendor's Postgres/Mongo authoring surface.
+ *
+ * The planner does NOT apply the policy — it always returns the full op set.
+ * Policy enforcement happens in the runner and in the browser-side
+ * auto-migrate path.
+ */
+declare class IdbMigrationPlanner implements MigrationPlanner<"idb", "idb"> {
+  plan(options: {
+    readonly contract: unknown;
+    readonly schema: unknown;
+    readonly policy: MigrationOperationPolicy;
+    readonly fromContract: Contract | null;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<"idb", "idb">>;
+    /**
+     * Contract space this plan applies to.
+     *
+     * Stamped onto the produced plan so the runner keys the marker row
+     * by the right space. IDB only has a single space (`"app"`), but
+     * the parameter is required by the framework's
+     * {@link MigrationPlanner} interface (added for multi-space support
+     * in contract-spaces ADR 212). Ignored by the IDB planner — all
+     * IDB schemas are single-space.
+     */
+    readonly spaceId: string;
+  }): MigrationPlannerResult;
+  emptyMigration(context: MigrationScaffoldContext, _spaceId: string): MigrationPlanWithAuthoringSurface;
+}
+//#endregion
+//#region src/core/idb-migration.d.ts
+/**
+ * Target-owned base class for IDB migrations.
+ *
+ * Fixes the framework's `Migration` generic to IDB target identity (operations
+ * narrowed to `IdbDdlOp`, family/target ids both `'idb'`) so user-authored
+ * migrations and renderer-generated scaffolds can `extends Migration` against
+ * the facade re-export from `@prisma-next-idb/target-idb/migration` without
+ * redeclaring target-local identity.
+ *
+ * Unlike SQL/Mongo, IDB has no per-instance control adapter to materialize —
+ * IDB DDL ops are pure data. The base constructor signature still accepts the
+ * `ControlStack` so the framework's `MigrationCLI` orchestration can pass one
+ * uniformly, but it is unused inside an IDB migration.
+ */
+declare abstract class IdbMigration extends Migration<IdbDdlOp, "idb", "idb"> {
+  readonly targetId: "idb";
+}
+//#endregion
+//#region src/core/migration-cli.d.ts
+type IdbMigrationConstructor = new () => IdbMigration;
+/**
+ * Self-emit CLI invoked by an authored `migration.ts` file:
+ *
+ *   `MigrationCLI.run(import.meta.url, M);`
+ *
+ * When the file is run as a node entrypoint (`node migration.ts`), regenerates
+ * `ops.json` and `migration.json` next to the file from the migration class's
+ * current `operations` getter and `describe()` output. When the file is merely
+ * imported (e.g. by `contract-space.generated.ts`), returns 0 without side
+ * effects.
+ *
+ * IDB migrations are pure data — no SQL string compilation, no adapter-driven
+ * materialization — so this shim deliberately skips config loading and
+ * `ControlStack` assembly. That keeps the shim free of the workspace-internal
+ * `@prisma-next/cli` package (which is what vendor's `MigrationCLI.run`
+ * depends on).
+ */
+declare class MigrationCLI {
+  static run(importMetaUrl: string, MigrationClass: IdbMigrationConstructor): Promise<number>;
+}
+//#endregion
+export { contractToIdbSchema as a, IdbMigrationControlDriverDescriptor as c, diffIdbSchema as d, IdbMigrationPlanner as i, extractMigrationDriver as l, IdbMigration as n, IdbMigrationRunner as o, IdbMigrationPlanWithAuthoring as r, IdbMigrationControlDriver as s, MigrationCLI as t, IdbSchemaDiffInput as u };
+//# sourceMappingURL=migration-B43yOFXO.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration-B43yOFXO.d.mts","names":[],"sources":["../src/core/schema-diff.ts","../src/core/migration-driver.ts","../src/core/migration-runner.ts","../src/core/migration-planner.ts","../src/core/idb-migration.ts","../src/core/migration-cli.ts"],"mappings":";;;;;;;;;;;;;;AAiBA;;KAAY,kBAAA;EAAA,SACD,MAAA,EAAQ,MAAM,SAAS,kBAAA;AAAA;;;;AAAkB;AAwCpD;;;;;;;;;;;;;;AAAgG;;;;iBAAhF,aAAA,CAAc,IAAA,EAAM,kBAAA,SAA2B,EAAA,EAAI,kBAAA,GAAqB,QAAA;;;;;;;;;;AAzCxF;;;;;;;;KCAY,yBAAA,GAA4B,qBAAA;EAAA,SAC7B,MAAA;EAAA,SACA,OAAA,EAAS,UAAU;EAAA,SACnB,aAAA;AAAA;;;;;;;;;;;ADsCqF;;cCrBnF,mCAAA;EAAA;;;;;;aAOA,MAAA;IAAA,SACA,OAAA,EAAS,UAAA;IAAA,SACT,aAAA;EAAA,MACP,yBAAA;AAAA;;;;;AA3BkB;AAiBxB;iBA8BgB,sBAAA,CAAuB,MAAA,EAAQ,qBAAA,iBAAsC,yBAAyB;;;;;;;;;;ADlD9G;;;;;;;cEyBa,kBAAA,YAA8B,eAAA;EFxBS;AAwCpD;;;;;;;EEPQ,OAAA,CAAQ,OAAA;IAAA,SACH,MAAA,EAAQ,qBAAA;IAAA,SACR,eAAA,EAAiB,aAAA,CAAc,8BAAA;EAAA,IACtC,OAAA,CAAQ,qBAAA;AAAA;;;;;;AFrCd;;;;;;;UGSiB,6BAAA,SAAsC,iCAAiC;EAAA,SAC7E,UAAA,WAAqB,QAAA;AAAA;;;;;;;;iBAYhB,mBAAA,CAAoB,QAAA,EAAU,QAAA,oBAA4B,kBAAkB;;;;;;AHmBI;;;;ACzChG;;;;cE0Ja,mBAAA,YAA+B,gBAAA;EAC1C,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IAAA,SACR,YAAA,EAAc,QAAA;IAAA,SACd,mBAAA,EAAqB,aAAA,CAAc,8BAAA;IF5InC;;;;;;;;;;IAAA,SEuJA,OAAA;EAAA,IACP,sBAAA;EAgDJ,cAAA,CAAe,OAAA,EAAS,wBAAA,EAA0B,QAAA,WAAmB,iCAAA;AAAA;;;;;;;;;AH5NvE;;;;;;;;uBIAsB,YAAA,SAAqB,SAAS,CAAC,QAAA;EAAA,SAC1C,QAAA;AAAA;;;KCVN,uBAAA,aAAoC,YAAY;;;;;;;ALSrD;;;;;;;;AACoD;AAwCpD;;cK/Ba,YAAA;EAAA,OACE,GAAA,CAAI,aAAA,UAAuB,cAAA,EAAgB,uBAAA,GAA0B,OAAO;AAAA"}