@prisma-next-idb/target-idb 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Prisma IDB
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/apply-ddl-op-DZAoihY0.d.mts

@@ -0,0 +1,129 @@
+import { a as IdbIndexDefinition, u as IdbStoreDefinition } from "./idb-contract-types-DndrdtW0.mjs";
+import { MigrationPlanOperation } from "@prisma-next/framework-components/control";
+import { ContractMarkerRecord } from "@prisma-next/contract/types";
+
+//#region src/core/migration-factories.d.ts
+/** DDL operation that creates a new object store. Always `additive`. */
+type CreateObjectStoreOp = MigrationPlanOperation & {
+  readonly kind: "createObjectStore";
+  readonly storeName: string;
+  readonly def: IdbStoreDefinition;
+};
+/** DDL operation that drops an existing object store and all its indexes. Always `destructive`. */
+type DropObjectStoreOp = MigrationPlanOperation & {
+  readonly kind: "dropObjectStore";
+  readonly storeName: string;
+};
+/** DDL operation that creates a secondary index on an object store. Always `additive`. */
+type CreateIndexOp = MigrationPlanOperation & {
+  readonly kind: "createIndex";
+  readonly storeName: string;
+  readonly indexName: string;
+  readonly def: IdbIndexDefinition;
+};
+/** DDL operation that drops a secondary index from an object store. Always `destructive`. */
+type DropIndexOp = MigrationPlanOperation & {
+  readonly kind: "dropIndex";
+  readonly storeName: string;
+  readonly indexName: string;
+};
+/** Union of all IDB DDL plan operations. */
+type IdbDdlOp = CreateObjectStoreOp | DropObjectStoreOp | CreateIndexOp | DropIndexOp;
+/** Returns `true` if `op` is one of the four IDB DDL op kinds. */
+declare function isIdbDdlOp(op: MigrationPlanOperation): op is IdbDdlOp;
+declare function createObjectStoreOp(storeName: string, def: IdbStoreDefinition): CreateObjectStoreOp;
+declare function dropObjectStoreOp(storeName: string): DropObjectStoreOp;
+declare function createIndexOp(storeName: string, indexName: string, def: IdbIndexDefinition): CreateIndexOp;
+declare function dropIndexOp(storeName: string, indexName: string): DropIndexOp;
+//#endregion
+//#region src/core/apply-ddl-op.d.ts
+/**
+ * Execute a single DDL operation against an open `upgradeneeded` transaction.
+ *
+ * All IndexedDB DDL (createObjectStore, deleteObjectStore, createIndex,
+ * deleteIndex) MUST happen inside the version-change transaction that fires
+ * in `upgradeneeded`. The `db` and `tx` references are valid only for the
+ * duration of that callback.
+ *
+ * Shared by the runner (target-idb), the browser auto-migrate path
+ * (client-idb), and the preflight CLI (family-idb) so all three apply paths
+ * use a single, byte-identical implementation.
+ *
+ * **Idempotency.** Each op is guarded by an existence check so re-applying an
+ * already-applied op is a no-op rather than a throw. This is the load-bearing
+ * guarantee behind the two-phase marker write (ADR 002): if a tab is killed in
+ * the window between the version-change transaction committing and the marker
+ * `put` landing, the schema is advanced but the marker still points at the old
+ * hash. On the next open, the chain walk re-collects the already-applied ops
+ * and replays them here. Without the guards, `createObjectStore` /
+ * `createIndex` throw `ConstraintError` on the existing store/index, the
+ * version-change transaction aborts, and the database is permanently wedged
+ * (every subsequent open repeats the failed upgrade). Contrary to a common
+ * assumption, IndexedDB itself offers **no** "already exists" tolerance — these
+ * guards are what make replay safe. (Was PLAN Issue #25.)
+ */
+declare function applyOneDdlOp(db: IDBDatabase, tx: IDBTransaction, op: IdbDdlOp): void;
+/**
+ * Marker write input. The `space` field is the contract-space identifier
+ * (`"app"` for the single app space; per-extension callers pass their own
+ * space id when extensions land on IDB). All other fields mirror
+ * {@link ContractMarkerRecord} exactly so the in-DB record has full parity
+ * with the framework's canonical marker shape.
+ */
+interface MarkerWriteInput {
+  readonly space: string;
+  readonly storageHash: string;
+  readonly profileHash?: string;
+  readonly invariants?: readonly string[];
+  readonly contractJson?: unknown;
+  readonly canonicalVersion?: number | null;
+  readonly appTag?: string | null;
+  readonly meta?: Record<string, unknown>;
+}
+/**
+ * In-DB marker record shape stored in `_prisma_next_marker`.
+ *
+ * Identical to {@link ContractMarkerRecord} plus the keying `space` field;
+ * `updatedAt` is a `Date` (not an ISO string) because IndexedDB serialises
+ * Dates natively via structured-clone.
+ */
+type IdbMarkerRecord = ContractMarkerRecord & {
+  readonly space: string;
+};
+/**
+ * Write the contract marker into the `_prisma_next_marker` store using a
+ * separate `readwrite` transaction. The marker store is created inside the
+ * version-change transaction during the migration's first run (see
+ * `createMarkerStoreOp`); subsequent runs reuse it.
+ *
+ * Keyed by `space` (defaulting to `"app"` at the caller layer) so the
+ * storage layout doesn't have to be migrated when IDB eventually grows
+ * extension support (see ADR 021 + feedback issue #5).
+ */
+declare function writeMarker(db: IDBDatabase, input: MarkerWriteInput): Promise<void>;
+/**
+ * Read the marker record for a given space from the `_prisma_next_marker`
+ * store. Returns `null` when the store doesn't exist (fresh DB) or the
+ * record is absent.
+ */
+declare function readMarker(db: IDBDatabase, space: string): Promise<IdbMarkerRecord | null>;
+/**
+ * Open `dbName` at `targetVersion`, apply `ops` inside the `upgradeneeded`
+ * callback, optionally write the contract marker (in a separate readwrite
+ * tx after `onsuccess`), then close the connection.
+ *
+ * Returns the number of ops applied. Throws on open-request error or DDL
+ * application error.
+ */
+declare function openAndUpgrade(input: {
+  readonly factory: IDBFactory;
+  readonly dbName: string;
+  readonly targetVersion: number;
+  readonly ops: readonly IdbDdlOp[];
+  readonly marker?: MarkerWriteInput;
+  readonly onOperationStart?: (op: IdbDdlOp) => void;
+  readonly onOperationComplete?: (op: IdbDdlOp) => void;
+}): Promise<number>;
+//#endregion
+export { readMarker as a, CreateObjectStoreOp as c, IdbDdlOp as d, createIndexOp as f, isIdbDdlOp as g, dropObjectStoreOp as h, openAndUpgrade as i, DropIndexOp as l, dropIndexOp as m, MarkerWriteInput as n, writeMarker as o, createObjectStoreOp as p, applyOneDdlOp as r, CreateIndexOp as s, IdbMarkerRecord as t, DropObjectStoreOp as u };
+//# sourceMappingURL=apply-ddl-op-DZAoihY0.d.mts.map

package/dist/apply-ddl-op-DZAoihY0.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-ddl-op-DZAoihY0.d.mts","names":[],"sources":["../src/core/migration-factories.ts","../src/core/apply-ddl-op.ts"],"mappings":";;;;;;KAqBY,mBAAA,GAAsB,sBAAA;EAAA,SACvB,IAAA;EAAA,SACA,SAAA;EAAA,SACA,GAAA,EAAK,kBAAkB;AAAA;;KAItB,iBAAA,GAAoB,sBAAsB;EAAA,SAC3C,IAAA;EAAA,SACA,SAAA;AAAA;AANuB;AAAA,KAUtB,aAAA,GAAgB,sBAAA;EAAA,SACjB,IAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;EAAA,SACA,GAAA,EAAK,kBAAkB;AAAA;;KAItB,WAAA,GAAc,sBAAsB;EAAA,SACrC,IAAA;EAAA,SACA,SAAA;EAAA,SACA,SAAA;AAAA;;KAIC,QAAA,GAAW,mBAAA,GAAsB,iBAAA,GAAoB,aAAA,GAAgB,WAAA;;iBAKjE,UAAA,CAAW,EAAA,EAAI,sBAAA,GAAyB,EAAA,IAAM,QAAQ;AAAA,iBAYtD,mBAAA,CAAoB,SAAA,UAAmB,GAAA,EAAK,kBAAA,GAAqB,mBAAmB;AAAA,iBAWpF,iBAAA,CAAkB,SAAA,WAAoB,iBAAiB;AAAA,iBAUvD,aAAA,CAAc,SAAA,UAAmB,SAAA,UAAmB,GAAA,EAAK,kBAAA,GAAqB,aAAa;AAAA,iBAY3F,WAAA,CAAY,SAAA,UAAmB,SAAA,WAAoB,WAAW;;;;;;AA9E9E;;;;;;;;;;AAGkC;AAIlC;;;;;;;;AAEoB;AAIpB;;iBCNgB,aAAA,CAAc,EAAA,EAAI,WAAA,EAAa,EAAA,EAAI,cAAA,EAAgB,EAAA,EAAI,QAAA;;;;;;;;UAwCtD,gBAAA;EAAA,SACN,KAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA;EAAA,SACA,UAAA;EAAA,SACA,YAAA;EAAA,SACA,gBAAA;EAAA,SACA,MAAA;EAAA,SACA,IAAA,GAAO,MAAM;AAAA;;AD/BJ;AAIpB;;;;;KCqCY,eAAA,GAAkB,oBAAoB;EAAA,SAAc,KAAK;AAAA;;;;;;;ADrCuB;AAK5F;;;iBC4CgB,WAAA,CAAY,EAAA,EAAI,WAAA,EAAa,KAAA,EAAO,gBAAA,GAAmB,OAAA;;;;;;iBAqCvD,UAAA,CAAW,EAAA,EAAI,WAAA,EAAa,KAAA,WAAgB,OAAA,CAAQ,eAAA;ADrEpE;;;;;;;;AAAA,iBC8FgB,cAAA,CAAe,KAAA;EAAA,SACpB,OAAA,EAAS,UAAA;EAAA,SACT,MAAA;EAAA,SACA,aAAA;EAAA,SACA,GAAA,WAAc,QAAA;EAAA,SACd,MAAA,GAAS,gBAAA;EAAA,SACT,gBAAA,IAAoB,EAAA,EAAI,QAAA;EAAA,SACxB,mBAAA,IAAuB,EAAA,EAAI,QAAA;AAAA,IAClC,OAAA"}

package/dist/apply-ddl-op-LP-l0o4O.mjs

@@ -0,0 +1,232 @@
+//#region src/core/migration-factories.ts
+/** Name of the internal marker store. Must match {@link MARKER_STORE_NAME} in driver-idb. */
+const IDB_MARKER_STORE = "_prisma_next_marker";
+/**
+* Default keyPath for the marker store.
+*
+* Keyed by `space` (per-contract-space, defaulting to `"app"`) rather than
+* the legacy `"id"`/`"default"` shape so the storage layout doesn't need to
+* be migrated later if IDB grows extension support. See ADR 021 +
+* feedback issue #5.
+*/
+const MARKER_KEYPATH = "space";
+/** Returns `true` if `op` is one of the four IDB DDL op kinds. */
+function isIdbDdlOp(op) {
+	return "kind" in op && (op.kind === "createObjectStore" || op.kind === "dropObjectStore" || op.kind === "createIndex" || op.kind === "dropIndex");
+}
+function createObjectStoreOp(storeName, def) {
+	return {
+		kind: "createObjectStore",
+		id: `object-store.${storeName}.create`,
+		label: `Create object store "${storeName}"`,
+		operationClass: "additive",
+		storeName,
+		def
+	};
+}
+function dropObjectStoreOp(storeName) {
+	return {
+		kind: "dropObjectStore",
+		id: `object-store.${storeName}.drop`,
+		label: `Drop object store "${storeName}"`,
+		operationClass: "destructive",
+		storeName
+	};
+}
+function createIndexOp(storeName, indexName, def) {
+	return {
+		kind: "createIndex",
+		id: `index.${storeName}.${indexName}.create`,
+		label: `Create index "${indexName}" on "${storeName}"`,
+		operationClass: "additive",
+		storeName,
+		indexName,
+		def
+	};
+}
+function dropIndexOp(storeName, indexName) {
+	return {
+		kind: "dropIndex",
+		id: `index.${storeName}.${indexName}.drop`,
+		label: `Drop index "${indexName}" on "${storeName}"`,
+		operationClass: "destructive",
+		storeName,
+		indexName
+	};
+}
+/**
+* Create the internal `_prisma_next_marker` object store.
+*
+* This store holds the contract marker (`storageHash` + `profileHash`) that
+* the runtime verifies before executing queries. It is always additive and
+* should be the first op in any migration plan.
+*/
+function createMarkerStoreOp() {
+	return {
+		kind: "createObjectStore",
+		id: `object-store.${IDB_MARKER_STORE}.create`,
+		label: `Create internal marker store "${IDB_MARKER_STORE}"`,
+		operationClass: "additive",
+		storeName: IDB_MARKER_STORE,
+		def: { keyPath: MARKER_KEYPATH }
+	};
+}
+//#endregion
+//#region src/core/apply-ddl-op.ts
+/**
+* Execute a single DDL operation against an open `upgradeneeded` transaction.
+*
+* All IndexedDB DDL (createObjectStore, deleteObjectStore, createIndex,
+* deleteIndex) MUST happen inside the version-change transaction that fires
+* in `upgradeneeded`. The `db` and `tx` references are valid only for the
+* duration of that callback.
+*
+* Shared by the runner (target-idb), the browser auto-migrate path
+* (client-idb), and the preflight CLI (family-idb) so all three apply paths
+* use a single, byte-identical implementation.
+*
+* **Idempotency.** Each op is guarded by an existence check so re-applying an
+* already-applied op is a no-op rather than a throw. This is the load-bearing
+* guarantee behind the two-phase marker write (ADR 002): if a tab is killed in
+* the window between the version-change transaction committing and the marker
+* `put` landing, the schema is advanced but the marker still points at the old
+* hash. On the next open, the chain walk re-collects the already-applied ops
+* and replays them here. Without the guards, `createObjectStore` /
+* `createIndex` throw `ConstraintError` on the existing store/index, the
+* version-change transaction aborts, and the database is permanently wedged
+* (every subsequent open repeats the failed upgrade). Contrary to a common
+* assumption, IndexedDB itself offers **no** "already exists" tolerance — these
+* guards are what make replay safe. (Was PLAN Issue #25.)
+*/
+function applyOneDdlOp(db, tx, op) {
+	switch (op.kind) {
+		case "createObjectStore":
+			if (db.objectStoreNames.contains(op.storeName)) return;
+			db.createObjectStore(op.storeName, {
+				keyPath: op.def.keyPath,
+				...op.def.autoIncrement !== void 0 && { autoIncrement: op.def.autoIncrement }
+			});
+			return;
+		case "dropObjectStore":
+			if (!db.objectStoreNames.contains(op.storeName)) return;
+			db.deleteObjectStore(op.storeName);
+			return;
+		case "createIndex": {
+			const store = tx.objectStore(op.storeName);
+			if (store.indexNames.contains(op.indexName)) return;
+			store.createIndex(op.indexName, op.def.keyPath, {
+				unique: op.def.unique,
+				...op.def.multiEntry !== void 0 && { multiEntry: op.def.multiEntry }
+			});
+			return;
+		}
+		case "dropIndex": {
+			const store = tx.objectStore(op.storeName);
+			if (!store.indexNames.contains(op.indexName)) return;
+			store.deleteIndex(op.indexName);
+			return;
+		}
+	}
+}
+/**
+* Write the contract marker into the `_prisma_next_marker` store using a
+* separate `readwrite` transaction. The marker store is created inside the
+* version-change transaction during the migration's first run (see
+* `createMarkerStoreOp`); subsequent runs reuse it.
+*
+* Keyed by `space` (defaulting to `"app"` at the caller layer) so the
+* storage layout doesn't have to be migrated when IDB eventually grows
+* extension support (see ADR 021 + feedback issue #5).
+*/
+function writeMarker(db, input) {
+	return new Promise((resolve, reject) => {
+		if (!db.objectStoreNames.contains("_prisma_next_marker")) {
+			console.warn("[prisma-next] _prisma_next_marker store not found after DDL — this indicates a bug in the migration planner.");
+			resolve();
+			return;
+		}
+		const tx = db.transaction(IDB_MARKER_STORE, "readwrite");
+		const store = tx.objectStore(IDB_MARKER_STORE);
+		const record = {
+			space: input.space,
+			storageHash: input.storageHash,
+			profileHash: input.profileHash ?? "",
+			updatedAt: /* @__PURE__ */ new Date(),
+			invariants: input.invariants ?? [],
+			contractJson: input.contractJson ?? null,
+			canonicalVersion: input.canonicalVersion ?? null,
+			appTag: input.appTag ?? null,
+			meta: input.meta ?? {}
+		};
+		const putReq = store.put(record);
+		putReq.onerror = () => reject(putReq.error);
+		tx.oncomplete = () => resolve();
+		tx.onerror = () => reject(tx.error);
+	});
+}
+/**
+* Read the marker record for a given space from the `_prisma_next_marker`
+* store. Returns `null` when the store doesn't exist (fresh DB) or the
+* record is absent.
+*/
+function readMarker(db, space) {
+	return new Promise((resolve, reject) => {
+		if (!db.objectStoreNames.contains("_prisma_next_marker")) {
+			resolve(null);
+			return;
+		}
+		const req = db.transaction(IDB_MARKER_STORE, "readonly").objectStore(IDB_MARKER_STORE).get(space);
+		req.onsuccess = () => {
+			const result = req.result;
+			resolve(result ?? null);
+		};
+		req.onerror = () => reject(req.error);
+	});
+}
+/**
+* Open `dbName` at `targetVersion`, apply `ops` inside the `upgradeneeded`
+* callback, optionally write the contract marker (in a separate readwrite
+* tx after `onsuccess`), then close the connection.
+*
+* Returns the number of ops applied. Throws on open-request error or DDL
+* application error.
+*/
+function openAndUpgrade(input) {
+	return new Promise((resolve, reject) => {
+		const request = input.factory.open(input.dbName, input.targetVersion);
+		request.onupgradeneeded = (event) => {
+			const target = event.target;
+			const db = target.result;
+			const tx = target.transaction;
+			if (tx === null) {
+				reject(/* @__PURE__ */ new Error("IDB: upgradeneeded fired with null version-change transaction"));
+				return;
+			}
+			for (const op of input.ops) {
+				input.onOperationStart?.(op);
+				applyOneDdlOp(db, tx, op);
+				input.onOperationComplete?.(op);
+			}
+		};
+		request.onsuccess = async (event) => {
+			const db = event.target.result;
+			try {
+				if (input.marker !== void 0) await writeMarker(db, input.marker);
+			} finally {
+				db.close();
+			}
+			resolve(input.ops.length);
+		};
+		request.onerror = (event) => {
+			const err = event.target.error;
+			reject(err ?? /* @__PURE__ */ new Error("IDB: migration open request failed without an error object"));
+		};
+		request.onblocked = () => {
+			reject(/* @__PURE__ */ new Error(`IDB: migration of "${input.dbName}" is blocked — another connection is open at an older version and did not close. Close other tabs/connections to this database and retry.`));
+		};
+	});
+}
+//#endregion
+export { createIndexOp as a, dropIndexOp as c, writeMarker as i, dropObjectStoreOp as l, openAndUpgrade as n, createMarkerStoreOp as o, readMarker as r, createObjectStoreOp as s, applyOneDdlOp as t, isIdbDdlOp as u };
+
+//# sourceMappingURL=apply-ddl-op-LP-l0o4O.mjs.map

package/dist/apply-ddl-op-LP-l0o4O.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-ddl-op-LP-l0o4O.mjs","names":[],"sources":["../src/core/migration-factories.ts","../src/core/apply-ddl-op.ts"],"sourcesContent":["import type { MigrationOperationClass, MigrationPlanOperation } from \"@prisma-next/framework-components/control\";\nimport type { IdbIndexDefinition, IdbStoreDefinition } from \"./idb-contract-types\";\n\n// ── Marker store ─────────────────────────────────────────────────────────────\n\n/** Name of the internal marker store. Must match {@link MARKER_STORE_NAME} in driver-idb. */\nexport const IDB_MARKER_STORE = \"_prisma_next_marker\";\n\n/**\n * Default keyPath for the marker store.\n *\n * Keyed by `space` (per-contract-space, defaulting to `\"app\"`) rather than\n * the legacy `\"id\"`/`\"default\"` shape so the storage layout doesn't need to\n * be migrated later if IDB grows extension support. See ADR 021 +\n * feedback issue #5.\n */\nconst MARKER_KEYPATH = \"space\";\n\n// ── Op kinds ──────────────────────────────────────────────────────────────────\n\n/** DDL operation that creates a new object store. Always `additive`. */\nexport type CreateObjectStoreOp = MigrationPlanOperation & {\n  readonly kind: \"createObjectStore\";\n  readonly storeName: string;\n  readonly def: IdbStoreDefinition;\n};\n\n/** DDL operation that drops an existing object store and all its indexes. Always `destructive`. */\nexport type DropObjectStoreOp = MigrationPlanOperation & {\n  readonly kind: \"dropObjectStore\";\n  readonly storeName: string;\n};\n\n/** DDL operation that creates a secondary index on an object store. Always `additive`. */\nexport type CreateIndexOp = MigrationPlanOperation & {\n  readonly kind: \"createIndex\";\n  readonly storeName: string;\n  readonly indexName: string;\n  readonly def: IdbIndexDefinition;\n};\n\n/** DDL operation that drops a secondary index from an object store. Always `destructive`. */\nexport type DropIndexOp = MigrationPlanOperation & {\n  readonly kind: \"dropIndex\";\n  readonly storeName: string;\n  readonly indexName: string;\n};\n\n/** Union of all IDB DDL plan operations. */\nexport type IdbDdlOp = CreateObjectStoreOp | DropObjectStoreOp | CreateIndexOp | DropIndexOp;\n\n// ── Type guard ────────────────────────────────────────────────────────────────\n\n/** Returns `true` if `op` is one of the four IDB DDL op kinds. */\nexport function isIdbDdlOp(op: MigrationPlanOperation): op is IdbDdlOp {\n  return (\n    \"kind\" in op &&\n    (op.kind === \"createObjectStore\" ||\n      op.kind === \"dropObjectStore\" ||\n      op.kind === \"createIndex\" ||\n      op.kind === \"dropIndex\")\n  );\n}\n\n// ── Factories ─────────────────────────────────────────────────────────────────\n\nexport function createObjectStoreOp(storeName: string, def: IdbStoreDefinition): CreateObjectStoreOp {\n  return {\n    kind: \"createObjectStore\",\n    id: `object-store.${storeName}.create`,\n    label: `Create object store \"${storeName}\"`,\n    operationClass: \"additive\" as MigrationOperationClass,\n    storeName,\n    def,\n  };\n}\n\nexport function dropObjectStoreOp(storeName: string): DropObjectStoreOp {\n  return {\n    kind: \"dropObjectStore\",\n    id: `object-store.${storeName}.drop`,\n    label: `Drop object store \"${storeName}\"`,\n    operationClass: \"destructive\" as MigrationOperationClass,\n    storeName,\n  };\n}\n\nexport function createIndexOp(storeName: string, indexName: string, def: IdbIndexDefinition): CreateIndexOp {\n  return {\n    kind: \"createIndex\",\n    id: `index.${storeName}.${indexName}.create`,\n    label: `Create index \"${indexName}\" on \"${storeName}\"`,\n    operationClass: \"additive\" as MigrationOperationClass,\n    storeName,\n    indexName,\n    def,\n  };\n}\n\nexport function dropIndexOp(storeName: string, indexName: string): DropIndexOp {\n  return {\n    kind: \"dropIndex\",\n    id: `index.${storeName}.${indexName}.drop`,\n    label: `Drop index \"${indexName}\" on \"${storeName}\"`,\n    operationClass: \"destructive\" as MigrationOperationClass,\n    storeName,\n    indexName,\n  };\n}\n\n/**\n * Create the internal `_prisma_next_marker` object store.\n *\n * This store holds the contract marker (`storageHash` + `profileHash`) that\n * the runtime verifies before executing queries. It is always additive and\n * should be the first op in any migration plan.\n */\nexport function createMarkerStoreOp(): CreateObjectStoreOp {\n  return {\n    kind: \"createObjectStore\",\n    id: `object-store.${IDB_MARKER_STORE}.create`,\n    label: `Create internal marker store \"${IDB_MARKER_STORE}\"`,\n    operationClass: \"additive\" as MigrationOperationClass,\n    storeName: IDB_MARKER_STORE,\n    def: { keyPath: MARKER_KEYPATH },\n  };\n}\n","import type { ContractMarkerRecord } from \"@prisma-next/contract/types\";\nimport { IDB_MARKER_STORE, type IdbDdlOp } from \"./migration-factories\";\n\n/**\n * Execute a single DDL operation against an open `upgradeneeded` transaction.\n *\n * All IndexedDB DDL (createObjectStore, deleteObjectStore, createIndex,\n * deleteIndex) MUST happen inside the version-change transaction that fires\n * in `upgradeneeded`. The `db` and `tx` references are valid only for the\n * duration of that callback.\n *\n * Shared by the runner (target-idb), the browser auto-migrate path\n * (client-idb), and the preflight CLI (family-idb) so all three apply paths\n * use a single, byte-identical implementation.\n *\n * **Idempotency.** Each op is guarded by an existence check so re-applying an\n * already-applied op is a no-op rather than a throw. This is the load-bearing\n * guarantee behind the two-phase marker write (ADR 002): if a tab is killed in\n * the window between the version-change transaction committing and the marker\n * `put` landing, the schema is advanced but the marker still points at the old\n * hash. On the next open, the chain walk re-collects the already-applied ops\n * and replays them here. Without the guards, `createObjectStore` /\n * `createIndex` throw `ConstraintError` on the existing store/index, the\n * version-change transaction aborts, and the database is permanently wedged\n * (every subsequent open repeats the failed upgrade). Contrary to a common\n * assumption, IndexedDB itself offers **no** \"already exists\" tolerance — these\n * guards are what make replay safe. (Was PLAN Issue #25.)\n */\nexport function applyOneDdlOp(db: IDBDatabase, tx: IDBTransaction, op: IdbDdlOp): void {\n  switch (op.kind) {\n    case \"createObjectStore\": {\n      if (db.objectStoreNames.contains(op.storeName)) return;\n      db.createObjectStore(op.storeName, {\n        keyPath: op.def.keyPath,\n        ...(op.def.autoIncrement !== undefined && { autoIncrement: op.def.autoIncrement }),\n      });\n      return;\n    }\n    case \"dropObjectStore\": {\n      if (!db.objectStoreNames.contains(op.storeName)) return;\n      db.deleteObjectStore(op.storeName);\n      return;\n    }\n    case \"createIndex\": {\n      const store = tx.objectStore(op.storeName);\n      if (store.indexNames.contains(op.indexName)) return;\n      store.createIndex(op.indexName, op.def.keyPath, {\n        unique: op.def.unique,\n        ...(op.def.multiEntry !== undefined && { multiEntry: op.def.multiEntry }),\n      });\n      return;\n    }\n    case \"dropIndex\": {\n      const store = tx.objectStore(op.storeName);\n      if (!store.indexNames.contains(op.indexName)) return;\n      store.deleteIndex(op.indexName);\n      return;\n    }\n  }\n}\n\n/**\n * Marker write input. The `space` field is the contract-space identifier\n * (`\"app\"` for the single app space; per-extension callers pass their own\n * space id when extensions land on IDB). All other fields mirror\n * {@link ContractMarkerRecord} exactly so the in-DB record has full parity\n * with the framework's canonical marker shape.\n */\nexport interface MarkerWriteInput {\n  readonly space: string;\n  readonly storageHash: string;\n  readonly profileHash?: string;\n  readonly invariants?: readonly string[];\n  readonly contractJson?: unknown;\n  readonly canonicalVersion?: number | null;\n  readonly appTag?: string | null;\n  readonly meta?: Record<string, unknown>;\n}\n\n/**\n * In-DB marker record shape stored in `_prisma_next_marker`.\n *\n * Identical to {@link ContractMarkerRecord} plus the keying `space` field;\n * `updatedAt` is a `Date` (not an ISO string) because IndexedDB serialises\n * Dates natively via structured-clone.\n */\nexport type IdbMarkerRecord = ContractMarkerRecord & { readonly space: string };\n\n/**\n * Write the contract marker into the `_prisma_next_marker` store using a\n * separate `readwrite` transaction. The marker store is created inside the\n * version-change transaction during the migration's first run (see\n * `createMarkerStoreOp`); subsequent runs reuse it.\n *\n * Keyed by `space` (defaulting to `\"app\"` at the caller layer) so the\n * storage layout doesn't have to be migrated when IDB eventually grows\n * extension support (see ADR 021 + feedback issue #5).\n */\nexport function writeMarker(db: IDBDatabase, input: MarkerWriteInput): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (!db.objectStoreNames.contains(IDB_MARKER_STORE)) {\n      // Marker store missing — should never happen because the planner emits\n      // its creation as the first op. Non-fatal so the runner can still\n      // report DDL success, but worth surfacing as a planner invariant bug.\n      console.warn(\n        \"[prisma-next] _prisma_next_marker store not found after DDL — this indicates a bug in the migration planner.\"\n      );\n      resolve();\n      return;\n    }\n    const tx = db.transaction(IDB_MARKER_STORE, \"readwrite\");\n    const store = tx.objectStore(IDB_MARKER_STORE);\n    const record: IdbMarkerRecord = {\n      space: input.space,\n      storageHash: input.storageHash,\n      profileHash: input.profileHash ?? \"\",\n      updatedAt: new Date(),\n      invariants: input.invariants ?? [],\n      contractJson: input.contractJson ?? null,\n      canonicalVersion: input.canonicalVersion ?? null,\n      appTag: input.appTag ?? null,\n      meta: input.meta ?? {},\n    };\n    const putReq = store.put(record);\n    putReq.onerror = () => reject(putReq.error);\n    tx.oncomplete = () => resolve();\n    tx.onerror = () => reject(tx.error);\n  });\n}\n\n/**\n * Read the marker record for a given space from the `_prisma_next_marker`\n * store. Returns `null` when the store doesn't exist (fresh DB) or the\n * record is absent.\n */\nexport function readMarker(db: IDBDatabase, space: string): Promise<IdbMarkerRecord | null> {\n  return new Promise((resolve, reject) => {\n    if (!db.objectStoreNames.contains(IDB_MARKER_STORE)) {\n      resolve(null);\n      return;\n    }\n    const tx = db.transaction(IDB_MARKER_STORE, \"readonly\");\n    const store = tx.objectStore(IDB_MARKER_STORE);\n    const req = store.get(space);\n    req.onsuccess = () => {\n      const result = req.result as IdbMarkerRecord | undefined;\n      resolve(result ?? null);\n    };\n    req.onerror = () => reject(req.error);\n  });\n}\n\n/**\n * Open `dbName` at `targetVersion`, apply `ops` inside the `upgradeneeded`\n * callback, optionally write the contract marker (in a separate readwrite\n * tx after `onsuccess`), then close the connection.\n *\n * Returns the number of ops applied. Throws on open-request error or DDL\n * application error.\n */\nexport function openAndUpgrade(input: {\n  readonly factory: IDBFactory;\n  readonly dbName: string;\n  readonly targetVersion: number;\n  readonly ops: readonly IdbDdlOp[];\n  readonly marker?: MarkerWriteInput;\n  readonly onOperationStart?: (op: IdbDdlOp) => void;\n  readonly onOperationComplete?: (op: IdbDdlOp) => void;\n}): Promise<number> {\n  return new Promise((resolve, reject) => {\n    const request = input.factory.open(input.dbName, input.targetVersion);\n\n    request.onupgradeneeded = (event) => {\n      const target = event.target as IDBOpenDBRequest;\n      const db = target.result;\n      const tx = target.transaction;\n      if (tx === null) {\n        reject(new Error(\"IDB: upgradeneeded fired with null version-change transaction\"));\n        return;\n      }\n      for (const op of input.ops) {\n        input.onOperationStart?.(op);\n        applyOneDdlOp(db, tx, op);\n        input.onOperationComplete?.(op);\n      }\n    };\n\n    request.onsuccess = async (event) => {\n      const db = (event.target as IDBOpenDBRequest).result;\n      try {\n        if (input.marker !== undefined) {\n          await writeMarker(db, input.marker);\n        }\n      } finally {\n        db.close();\n      }\n      resolve(input.ops.length);\n    };\n\n    request.onerror = (event) => {\n      const err = (event.target as IDBOpenDBRequest).error;\n      reject(err ?? new Error(\"IDB: migration open request failed without an error object\"));\n    };\n\n    // Another open connection at an older version is holding the upgrade back.\n    // Runtime connections self-close on `versionchange` (see driver-idb), so\n    // this should be unreachable in normal operation — but a stray third-party\n    // connection on the same database name would otherwise hang the upgrade\n    // forever. Fail fast with an actionable message instead.\n    request.onblocked = () => {\n      reject(\n        new Error(\n          `IDB: migration of \"${input.dbName}\" is blocked — another connection is open at an older ` +\n            \"version and did not close. Close other tabs/connections to this database and retry.\"\n        )\n      );\n    };\n  });\n}\n"],"mappings":"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"}

package/dist/control.d.mts

@@ -0,0 +1,33 @@
+import { c as IdbMigrationControlDriverDescriptor, i as IdbMigrationPlanner, l as extractMigrationDriver, o as IdbMigrationRunner, s as IdbMigrationControlDriver, u as IdbSchemaDiffInput } from "./migration-B43yOFXO.mjs";
+import { ContractSerializer, ControlAdapterInstance, ControlFamilyInstance, ControlTargetInstance } from "@prisma-next/framework-components/control";
+import { Contract } from "@prisma-next/contract/types";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+
+//#region src/exports/control.d.ts
+declare const idbControlTargetDescription: {
+  contractSerializer: ContractSerializer<Contract<import("@prisma-next/contract/types").StorageBase<string>>>;
+  migrations: {
+    createPlanner(_adapter: ControlAdapterInstance<"idb", "idb">): IdbMigrationPlanner;
+    createRunner(_family: ControlFamilyInstance<"idb", unknown>): IdbMigrationRunner;
+    contractToSchema(contract: Contract | null, _frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<"idb", "idb">>): IdbSchemaDiffInput | null;
+  };
+  create(): ControlTargetInstance<"idb", "idb">;
+  kind: "target";
+  familyId: "idb";
+  targetId: "idb";
+  id: "idb";
+  version: "0.0.1";
+  types: {
+    readonly codecTypes: {
+      readonly import: {
+        readonly package: "@prisma-next-idb/target-idb/pack";
+        readonly named: "CodecTypes";
+        readonly alias: "IdbCodecTypes";
+      };
+      readonly codecDescriptors: readonly import("@prisma-next/framework-components/codec").AnyCodecDescriptor[];
+    };
+  };
+};
+//#endregion
+export { type IdbMigrationControlDriver, IdbMigrationControlDriverDescriptor, idbControlTargetDescription as default, extractMigrationDriver };
+//# sourceMappingURL=control.d.mts.map

package/dist/control.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.mts","names":[],"sources":["../src/exports/control.ts"],"mappings":";;;;;;cA+CM,2BAAA;;;4BAdoB,sBAAA,iBAAoC,mBAAA;0BAGtC,qBAAA,mBAAqC,kBAAA;+BAI/C,QAAA,SAAe,oBAAA,GACF,aAAA,CAAc,8BAAA,kBAAD,kBAAA;EAAA;YAU5B,qBAAA"}

package/dist/control.mjs

@@ -0,0 +1,44 @@
+import { t as idbTargetDescriptorMeta } from "./descriptor-meta-CKLekROR.mjs";
+import { a as contractToIdbSchema, i as IdbMigrationPlanner, n as extractMigrationDriver, r as IdbMigrationRunner, t as IdbMigrationControlDriverDescriptor } from "./migration-driver-4T8Hk1vu.mjs";
+//#region src/exports/control.ts
+/**
+* IDB contract serializer — validates on input, passes through on output.
+*
+* IDB contracts are TypeScript-first (`defineContract`), so they are
+* already plain objects with no class instances. Serialization is identity;
+* deserialization runs validation.
+*/
+const idbContractSerializer = {
+	deserializeContract(json) {
+		return json;
+	},
+	serializeContract(_contract) {
+		return _contract;
+	}
+};
+const idbMigrationsCapability = {
+	createPlanner(_adapter) {
+		return new IdbMigrationPlanner();
+	},
+	createRunner(_family) {
+		return new IdbMigrationRunner();
+	},
+	contractToSchema(contract, _frameworkComponents) {
+		return contractToIdbSchema(contract);
+	}
+};
+const idbControlTargetDescription = {
+	...idbTargetDescriptorMeta,
+	contractSerializer: idbContractSerializer,
+	migrations: idbMigrationsCapability,
+	create() {
+		return {
+			familyId: "idb",
+			targetId: "idb"
+		};
+	}
+};
+//#endregion
+export { IdbMigrationControlDriverDescriptor, idbControlTargetDescription as default, extractMigrationDriver };
+
+//# sourceMappingURL=control.mjs.map

package/dist/control.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control.mjs","names":[],"sources":["../src/exports/control.ts"],"sourcesContent":["import type { Contract } from \"@prisma-next/contract/types\";\nimport type { TargetBoundComponentDescriptor } from \"@prisma-next/framework-components/components\";\nimport type {\n  ContractSerializer,\n  ControlAdapterInstance,\n  ControlFamilyInstance,\n  ControlTargetInstance,\n  MigratableTargetDescriptor,\n  TargetMigrationsCapability,\n} from \"@prisma-next/framework-components/control\";\nimport { idbTargetDescriptorMeta } from \"../core/descriptor-meta\";\nimport { IdbMigrationPlanner, contractToIdbSchema } from \"../core/migration-planner\";\nimport { IdbMigrationRunner } from \"../core/migration-runner\";\n\n/**\n * IDB contract serializer — validates on input, passes through on output.\n *\n * IDB contracts are TypeScript-first (`defineContract`), so they are\n * already plain objects with no class instances. Serialization is identity;\n * deserialization runs validation.\n */\nconst idbContractSerializer: ContractSerializer<Contract> = {\n  deserializeContract<T extends Contract = Contract>(json: unknown): T {\n    return json as T;\n  },\n  serializeContract(_contract: Contract) {\n    // IDB contracts are plain JSON-safe objects. Serialization is identity.\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return _contract as any;\n  },\n};\n\nconst idbMigrationsCapability = {\n  createPlanner(_adapter: ControlAdapterInstance<\"idb\", \"idb\">) {\n    return new IdbMigrationPlanner();\n  },\n  createRunner(_family: ControlFamilyInstance<\"idb\", unknown>) {\n    return new IdbMigrationRunner();\n  },\n  contractToSchema(\n    contract: Contract | null,\n    _frameworkComponents?: ReadonlyArray<TargetBoundComponentDescriptor<\"idb\", \"idb\">>\n  ) {\n    return contractToIdbSchema(contract);\n  },\n} satisfies TargetMigrationsCapability<\"idb\", \"idb\">;\n\nconst idbControlTargetDescription = {\n  ...idbTargetDescriptorMeta,\n  contractSerializer: idbContractSerializer,\n  migrations: idbMigrationsCapability,\n  create(): ControlTargetInstance<\"idb\", \"idb\"> {\n    return { familyId: \"idb\", targetId: \"idb\" };\n  },\n} satisfies MigratableTargetDescriptor<\"idb\", \"idb\">;\n\nexport default idbControlTargetDescription;\nexport { IdbMigrationControlDriverDescriptor, extractMigrationDriver } from \"../core/migration-driver\";\nexport type { IdbMigrationControlDriver } from \"../core/migration-driver\";\n"],"mappings":";;;;;;;;;;AAqBA,MAAM,wBAAsD;CAC1D,oBAAmD,MAAkB;EACnE,OAAO;CACT;CACA,kBAAkB,WAAqB;EAGrC,OAAO;CACT;AACF;AAEA,MAAM,0BAA0B;CAC9B,cAAc,UAAgD;EAC5D,OAAO,IAAI,oBAAoB;CACjC;CACA,aAAa,SAAgD;EAC3D,OAAO,IAAI,mBAAmB;CAChC;CACA,iBACE,UACA,sBACA;EACA,OAAO,oBAAoB,QAAQ;CACrC;AACF;AAEA,MAAM,8BAA8B;CAClC,GAAG;CACH,oBAAoB;CACpB,YAAY;CACZ,SAA8C;EAC5C,OAAO;GAAE,UAAU;GAAO,UAAU;EAAM;CAC5C;AACF"}