@mediamonks/canopy-cli 0.0.1

package/dist/local-DhufX0eJ.mjs

@@ -0,0 +1,563 @@
+import { t as apiRequest } from "./api-BEY4O4ap.mjs";
+import { n as rewriteApiPath } from "./dev-BB7CwqoI.mjs";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { Hono } from "hono";
+//#region ../data-plane/src/blob.ts
+/**
+* /:slug/blob — the SDK's file storage over an injectable BlobStore (a bucket
+* plus the project's isolated key prefix). Same single-implementation deal as
+* db.ts: canopy-api and the CLI's local sandbox mount this exact router.
+*
+* Authorization is the HOST's job (canopy-api enforces session-or-signature
+* ahead of this router; the local sandbox has no auth wall). This router only
+* mints download URLs via the injected signer — verification lives with the
+* host's auth middleware (see signing.ts).
+*/
+const MAX_BLOB_BYTES = 25 * 1024 * 1024;
+const MAX_LIST_KEYS = 1e3;
+const URL_TTL_SECONDS = 600;
+/** Keys may nest with `/`, but never escape the prefix or surprise a URL. */
+function safeBlobKey(raw) {
+	if (raw.length === 0 || raw.length > 512) return null;
+	if (raw.includes("\\") || raw.includes("\0")) return null;
+	if (raw.split("/").some((seg) => seg === "" || seg === "." || seg === "..")) return null;
+	return raw;
+}
+function blobRouter(config) {
+	const blob = new Hono();
+	const resolve = async (c) => config.store(c, c.req.param("slug") ?? "");
+	blob.put("/:slug/blob/:key", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const key = safeBlobKey(c.req.param("key"));
+		if (!key) return c.json({ error: "invalid_key" }, 400);
+		if (Number(c.req.header("content-length") ?? 0) > MAX_BLOB_BYTES) return c.json({
+			error: "blob_too_large",
+			maxBytes: MAX_BLOB_BYTES
+		}, 413);
+		const body = await c.req.raw.arrayBuffer();
+		if (body.byteLength > MAX_BLOB_BYTES) return c.json({
+			error: "blob_too_large",
+			maxBytes: MAX_BLOB_BYTES
+		}, 413);
+		const contentType = c.req.header("content-type") ?? "application/octet-stream";
+		await store.bucket.put(store.prefix + key, body, { httpMetadata: { contentType } });
+		return c.json({
+			key,
+			size: body.byteLength,
+			contentType,
+			uploadedAt: (/* @__PURE__ */ new Date()).toISOString()
+		}, 201);
+	});
+	blob.get("/:slug/blob", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const prefix = c.req.query("prefix") ?? "";
+		if (prefix.length > 512 || prefix.includes("\0")) return c.json({ error: "invalid_prefix" }, 400);
+		const base = store.prefix;
+		const objects = [];
+		let cursor;
+		do {
+			const page = await store.bucket.list({
+				prefix: base + prefix,
+				cursor,
+				include: ["httpMetadata"]
+			});
+			for (const o of page.objects) objects.push({
+				key: o.key.slice(base.length),
+				size: o.size,
+				contentType: o.httpMetadata?.contentType ?? "application/octet-stream",
+				uploadedAt: o.uploaded.toISOString()
+			});
+			cursor = page.truncated && objects.length < MAX_LIST_KEYS ? page.cursor : void 0;
+		} while (cursor);
+		return c.json(objects.slice(0, MAX_LIST_KEYS));
+	});
+	blob.get("/:slug/blob/:key/url", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const key = safeBlobKey(c.req.param("key"));
+		if (!key) return c.json({ error: "invalid_key" }, 400);
+		if (!await store.bucket.head(store.prefix + key)) return c.json({ error: "not_found" }, 404);
+		const exp = Math.floor(Date.now() / 1e3) + URL_TTL_SECONDS;
+		const sig = await config.signDownload(c, c.req.param("slug"), key, exp);
+		return c.json({
+			url: `/_api/v1/blob/${encodeURIComponent(key)}?exp=${exp}&sig=${sig}`,
+			expiresAt: (/* @__PURE__ */ new Date(exp * 1e3)).toISOString()
+		});
+	});
+	blob.get("/:slug/blob/:key", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const key = safeBlobKey(c.req.param("key"));
+		if (!key) return c.json({ error: "invalid_key" }, 400);
+		const object = await store.bucket.get(store.prefix + key);
+		if (!object) return c.json({ error: "not_found" }, 404);
+		return new Response(object.body, { headers: {
+			"content-type": object.httpMetadata?.contentType ?? "application/octet-stream",
+			"cache-control": "private, no-store"
+		} });
+	});
+	blob.delete("/:slug/blob/:key", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const key = safeBlobKey(c.req.param("key"));
+		if (!key) return c.json({ error: "invalid_key" }, 400);
+		const fullKey = store.prefix + key;
+		const existed = await store.bucket.head(fullKey) !== null;
+		await store.bucket.delete(fullKey);
+		return c.json({ deleted: existed });
+	});
+	return blob;
+}
+//#endregion
+//#region ../data-plane/src/db.ts
+/**
+* /:slug/db — the SDK's document API + raw-SQL escape hatch, over an
+* injectable DocStore. This is THE data-plane implementation: canopy-api
+* mounts it against project D1s (HTTP query API), and `canopy dev --local`
+* mounts the very same router against a Miniflare D1 — one place to change
+* when the API surface moves.
+*
+* Hosts wrap it with their own auth/scope middleware and resolve the project
+* in `config.store` (returning a Response for not-found/paused/etc.).
+*/
+const COLLECTION_RE = /^[a-z][a-z0-9_]{0,63}$/;
+const FIELD_RE = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
+const META_COLUMNS = {
+	_id: "id",
+	_createdAt: "created_at",
+	_updatedAt: "updated_at"
+};
+const MAX_DOC_BYTES = 256 * 1024;
+const MAX_LIMIT = 1e3;
+const DOC_COLUMNS = "id, data, created_at, updated_at";
+function toDoc(row) {
+	return {
+		...JSON.parse(row.data),
+		_id: row.id,
+		_createdAt: row.created_at,
+		_updatedAt: row.updated_at
+	};
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** User fields only — `_`-prefixed keys are platform-managed. */
+function stripMetaKeys(doc) {
+	return Object.fromEntries(Object.entries(doc).filter(([key]) => !key.startsWith("_")));
+}
+function isScalar(value) {
+	return value === null || [
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof value);
+}
+var BadQuery = class extends Error {};
+/**
+* WHERE fragments for a field filter. All params are strings: the value rides
+* as JSON text and `json_extract(?, '$')` rehydrates its SQLite type, so 5
+* matches 5 and false matches false. `IS` makes null match JSON null (and
+* absent fields).
+*/
+function fieldFilters(where, table = "") {
+	const sql = [];
+	const params = [];
+	for (const [field, value] of Object.entries(where)) {
+		if (!isScalar(value)) throw new BadQuery(`where.${field}: only string/number/boolean/null values are supported`);
+		const column = META_COLUMNS[field];
+		if (column) {
+			sql.push(`${table}${column} IS json_extract(?, '$')`);
+			params.push(JSON.stringify(value));
+		} else if (FIELD_RE.test(field)) {
+			sql.push(`json_extract(${table}data, ?) IS json_extract(?, '$')`);
+			params.push(`$.${field}`, JSON.stringify(value));
+		} else throw new BadQuery(`where.${field}: invalid field name`);
+	}
+	return {
+		sql,
+		params
+	};
+}
+function intParam(raw, name, fallback, max) {
+	if (raw === void 0) return fallback;
+	if (!/^\d{1,9}$/.test(raw)) throw new BadQuery(`${name} must be a non-negative integer`);
+	return Math.min(Number(raw), max);
+}
+/** Query text → FTS5 MATCH expression: quoted tokens, implicit AND. */
+function ftsMatch(text) {
+	return text.split(/\s+/).filter(Boolean).map((token) => `"${token.replaceAll("\"", "\"\"")}"`).join(" ");
+}
+function dbRouter(config) {
+	const db = new Hono();
+	const resolve = async (c) => config.store(c, c.req.param("slug") ?? "");
+	db.post("/:slug/db/sql", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const body = await c.req.json().catch(() => ({}));
+		const params = body.params ?? [];
+		if (typeof body.query !== "string" || body.query.trim() === "" || !Array.isArray(params) || !params.every(isScalar)) return c.json({
+			error: "invalid_query",
+			detail: "expected { query: string, params?: (string|number|boolean|null)[] }"
+		}, 400);
+		const result = await store.query(body.query, params).catch((err) => err);
+		if (result instanceof Error) return c.json({
+			error: "sql_error",
+			detail: result.message
+		}, 400);
+		return c.json(result.results);
+	});
+	db.post("/:slug/db/:collection", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const collection = c.req.param("collection");
+		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
+		const body = await c.req.json().catch(() => void 0);
+		if (!isPlainObject(body)) return c.json({
+			error: "invalid_document",
+			detail: "expected a JSON object"
+		}, 400);
+		const fields = stripMetaKeys(body);
+		const data = JSON.stringify(fields);
+		if (data.length > MAX_DOC_BYTES) return c.json({
+			error: "document_too_large",
+			maxBytes: MAX_DOC_BYTES
+		}, 413);
+		const id = crypto.randomUUID();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		await store.query("INSERT INTO _canopy_docs (collection, id, data, created_at, updated_at) VALUES (?, ?, ?, ?, ?)", [
+			collection,
+			id,
+			data,
+			now,
+			now
+		]);
+		return c.json({
+			...fields,
+			_id: id,
+			_createdAt: now,
+			_updatedAt: now
+		}, 201);
+	});
+	db.get("/:slug/db/:collection", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const collection = c.req.param("collection");
+		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
+		const q = c.req.query();
+		try {
+			const limit = intParam(q.limit, "limit", 100, MAX_LIMIT);
+			const offset = intParam(q.offset, "offset", 0, 1e9);
+			let where = {};
+			if (q.where !== void 0) {
+				try {
+					where = JSON.parse(q.where);
+				} catch {
+					throw new BadQuery("where must be a JSON object");
+				}
+				if (!isPlainObject(where)) throw new BadQuery("where must be a JSON object");
+			}
+			let sql;
+			let params;
+			if (q.search !== void 0) {
+				const match = ftsMatch(q.search);
+				if (!match) return c.json([]);
+				const filters = fieldFilters(where, "d.");
+				sql = `SELECT d.id, d.data, d.created_at, d.updated_at
+          FROM _canopy_docs_fts
+          JOIN _canopy_docs d ON d.rowid = _canopy_docs_fts.rowid
+          WHERE _canopy_docs_fts MATCH ? AND d.collection = ?
+          ${filters.sql.map((f) => `AND ${f}`).join(" ")}
+          ORDER BY _canopy_docs_fts.rank
+          LIMIT ${limit} OFFSET ${offset}`;
+				params = [
+					match,
+					collection,
+					...filters.params
+				];
+			} else {
+				const filters = fieldFilters(where);
+				params = [collection, ...filters.params];
+				let orderExpr = "created_at";
+				if (q.orderBy !== void 0) {
+					const column = META_COLUMNS[q.orderBy];
+					if (column) orderExpr = column;
+					else if (FIELD_RE.test(q.orderBy)) {
+						orderExpr = "json_extract(data, ?)";
+						params.push(`$.${q.orderBy}`);
+					} else throw new BadQuery("orderBy: invalid field name");
+				}
+				if (q.order !== void 0 && q.order !== "asc" && q.order !== "desc") throw new BadQuery("order must be 'asc' or 'desc'");
+				sql = `SELECT ${DOC_COLUMNS} FROM _canopy_docs
+          WHERE collection = ? ${filters.sql.map((f) => `AND ${f}`).join(" ")}
+          ORDER BY ${orderExpr} ${q.order === "desc" ? "DESC" : "ASC"}
+          LIMIT ${limit} OFFSET ${offset}`;
+			}
+			const result = await store.query(sql, params);
+			return c.json(result.results.map(toDoc));
+		} catch (err) {
+			if (err instanceof BadQuery) return c.json({
+				error: "invalid_query",
+				detail: err.message
+			}, 400);
+			throw err;
+		}
+	});
+	db.get("/:slug/db/:collection/:id", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const collection = c.req.param("collection");
+		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
+		const row = (await store.query(`SELECT ${DOC_COLUMNS} FROM _canopy_docs WHERE collection = ? AND id = ?`, [collection, c.req.param("id")])).results[0];
+		return c.json(row ? toDoc(row) : null);
+	});
+	db.patch("/:slug/db/:collection/:id", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const collection = c.req.param("collection");
+		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
+		const body = await c.req.json().catch(() => void 0);
+		if (!isPlainObject(body)) return c.json({
+			error: "invalid_patch",
+			detail: "expected a JSON object"
+		}, 400);
+		const row = (await store.query(`UPDATE _canopy_docs SET data = json_patch(data, ?), updated_at = ?
+        WHERE collection = ? AND id = ?
+        RETURNING ${DOC_COLUMNS}`, [
+			JSON.stringify(stripMetaKeys(body)),
+			(/* @__PURE__ */ new Date()).toISOString(),
+			collection,
+			c.req.param("id")
+		])).results[0];
+		if (!row) return c.json({ error: "not_found" }, 404);
+		return c.json(toDoc(row));
+	});
+	db.delete("/:slug/db/:collection/:id", async (c) => {
+		const store = await resolve(c);
+		if (store instanceof Response) return store;
+		const collection = c.req.param("collection");
+		if (!COLLECTION_RE.test(collection)) return c.json({ error: "invalid_collection" }, 400);
+		const result = await store.query("DELETE FROM _canopy_docs WHERE collection = ? AND id = ?", [collection, c.req.param("id")]);
+		return c.json({ deleted: (result.meta.changes ?? 0) > 0 });
+	});
+	return db;
+}
+//#endregion
+//#region ../data-plane/src/doc-store.ts
+const DOC_STORE_DDL = [
+	`CREATE TABLE IF NOT EXISTS _canopy_docs (
+    collection TEXT NOT NULL,
+    id TEXT NOT NULL,
+    data TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    PRIMARY KEY (collection, id)
+  )`,
+	`CREATE INDEX IF NOT EXISTS _canopy_docs_created ON _canopy_docs (collection, created_at)`,
+	`CREATE VIRTUAL TABLE IF NOT EXISTS _canopy_docs_fts
+    USING fts5(data, content='_canopy_docs', content_rowid='rowid')`,
+	`CREATE TRIGGER IF NOT EXISTS _canopy_docs_fts_insert AFTER INSERT ON _canopy_docs BEGIN
+    INSERT INTO _canopy_docs_fts (rowid, data) VALUES (new.rowid, new.data);
+  END`,
+	`CREATE TRIGGER IF NOT EXISTS _canopy_docs_fts_delete AFTER DELETE ON _canopy_docs BEGIN
+    INSERT INTO _canopy_docs_fts (_canopy_docs_fts, rowid, data) VALUES ('delete', old.rowid, old.data);
+  END`,
+	`CREATE TRIGGER IF NOT EXISTS _canopy_docs_fts_update AFTER UPDATE ON _canopy_docs BEGIN
+    INSERT INTO _canopy_docs_fts (_canopy_docs_fts, rowid, data) VALUES ('delete', old.rowid, old.data);
+    INSERT INTO _canopy_docs_fts (rowid, data) VALUES (new.rowid, new.data);
+  END`
+];
+/** Creates the doc store if missing. Idempotent; hosts decide when to memoize. */
+async function ensureDocStore(store) {
+	for (const ddl of DOC_STORE_DDL) await store.query(ddl);
+}
+/** Recreates the doc store's FTS index and re-indexes every document. */
+async function rebuildFtsIndex(store) {
+	await ensureDocStore(store);
+	await store.query("INSERT INTO _canopy_docs_fts (_canopy_docs_fts) VALUES ('rebuild')");
+}
+//#endregion
+//#region src/local.ts
+/**
+* canopy dev --local — the offline sandbox (docs/02-decisions.md D12,
+* docs/04-roadmap.md Phase 2 item 6): Miniflare-backed D1 + R2 living under
+* the project's .canopy/local/, answering the SDK's data plane with THE SAME
+* routers canopy-api mounts (@mediamonks/canopy-data-plane) — the sandbox can't
+* drift from the platform because they share the implementation.
+*
+* Sync is pull-only: `--pull` hydrates the local database from a fresh prod
+* export; nothing ever pushes back. ai/services aren't data — dev.ts proxies
+* them to the real platform when logged in (metered as usual), and only the
+* offline case lands on the 501 stub here.
+*/
+/**
+* Splits a SQL dump into statements: quote- and comment-aware, and a
+* CREATE TRIGGER statement only ends at its `END;` (BEGIN…END bodies carry
+* semicolons of their own).
+*/
+function splitSqlStatements(dump) {
+	const statements = [];
+	let current = "";
+	let i = 0;
+	while (i < dump.length) {
+		const ch = dump[i];
+		const pair = dump.slice(i, i + 2);
+		if (ch === "'" || ch === "\"" || ch === "`" || ch === "[") {
+			const close = ch === "[" ? "]" : ch;
+			current += ch;
+			i++;
+			while (i < dump.length) {
+				current += dump[i];
+				if (dump[i] === close) {
+					if (close !== "]" && dump[i + 1] === close) {
+						current += close;
+						i += 2;
+						continue;
+					}
+					i++;
+					break;
+				}
+				i++;
+			}
+		} else if (pair === "--") while (i < dump.length && dump[i] !== "\n") i++;
+		else if (pair === "/*") {
+			const end = dump.indexOf("*/", i + 2);
+			i = end === -1 ? dump.length : end + 2;
+		} else if (ch === ";") {
+			if (/^\s*CREATE\s+(TEMP(ORARY)?\s+)?TRIGGER/i.test(current) && !/\bEND\s*$/i.test(current)) current += ch;
+			else {
+				if (current.trim()) statements.push(current.trim());
+				current = "";
+			}
+			i++;
+		} else {
+			current += ch;
+			i++;
+		}
+	}
+	if (current.trim()) statements.push(current.trim());
+	return statements;
+}
+/** Locate the built browser SDK, served as /_api/v1/sdk.js in the sandbox. */
+function resolveSdkBundle() {
+	const bundle = join(dirname(createRequire(import.meta.url).resolve("@mediamonks/canopy/package.json")), "dist/index.mjs");
+	if (!existsSync(bundle)) throw new Error("The local sandbox serves the SDK from @mediamonks/canopy/dist, which is not built — run `pnpm --filter @mediamonks/canopy build` once.");
+	return bundle;
+}
+/** Downloads a fresh SQL dump of the project's production D1 (pull-only sync). */
+async function fetchProjectDump(slug) {
+	const { url } = await apiRequest("POST", `/projects/${slug}/export`);
+	const download = await fetch(url);
+	if (!download.ok) throw new Error(`Dump download failed (HTTP ${download.status}).`);
+	return download.text();
+}
+async function createSandbox(options) {
+	const { Miniflare } = await import("miniflare");
+	const mf = new Miniflare({
+		modules: true,
+		script: "export default { fetch: () => new Response(null, { status: 404 }) };",
+		d1Databases: { DB: "canopy-local-db" },
+		r2Buckets: { BLOBS: "canopy-local-blobs" },
+		...options.persistDir ? {
+			d1Persist: join(options.persistDir, "d1"),
+			r2Persist: join(options.persistDir, "blob")
+		} : {}
+	});
+	const d1 = await mf.getD1Database("DB");
+	const bucket = await mf.getR2Bucket("BLOBS");
+	const store = { query: async (sql, params = []) => {
+		return await d1.prepare(sql).bind(...params.map((p) => typeof p === "boolean" ? p ? 1 : 0 : p)).all();
+	} };
+	await ensureDocStore(store);
+	const app = new Hono();
+	const ownProject = (c, slug) => slug === options.slug ? null : c.json({ error: "project_not_found" }, 404);
+	app.route("/v1/projects", dbRouter({ store: async (c, slug) => ownProject(c, slug) ?? store }));
+	app.route("/v1/projects", blobRouter({
+		store: async (c, slug) => ownProject(c, slug) ?? {
+			bucket,
+			prefix: ""
+		},
+		signDownload: async () => "local"
+	}));
+	app.get("/v1/sdk.js", () => {
+		return new Response(readFileSync(resolveSdkBundle(), "utf8"), { headers: {
+			"content-type": "text/javascript",
+			"cache-control": "no-store"
+		} });
+	});
+	app.get("/v1/auth/me", (c) => c.json({
+		id: "local-dev",
+		email: options.email ?? "dev@localhost",
+		name: "Local Dev",
+		kind: "monk"
+	}));
+	app.all("/v1/projects/:slug/ai/*", (c) => c.json({
+		error: "not_available_in_local_dev",
+		detail: "ai needs the platform — log in (`canopy login`) so --local can proxy it."
+	}, 501));
+	app.all("/v1/projects/:slug/services/*", (c) => c.json({
+		error: "not_available_in_local_dev",
+		detail: "services need the platform — log in (`canopy login`) so --local can proxy them."
+	}, 501));
+	app.notFound((c) => c.json({
+		error: "not_available_in_local_dev",
+		detail: "the local sandbox serves the data plane only (db, blob, auth.user, sdk.js) — control-plane calls need `canopy dev` against the platform."
+	}, 501));
+	async function handle(request) {
+		const url = new URL(request.url);
+		if (!url.pathname.startsWith("/_api/")) return Response.json({ error: "not_found" }, { status: 404 });
+		const pathname = rewriteApiPath(url.pathname, options.slug);
+		return app.fetch(new Request(`http://sandbox${pathname}${url.search}`, request));
+	}
+	/**
+	* Drops every user object so a dump lands on a clean slate (the local
+	* counterpart of apps/api/src/routes/data.ts resetProjectDb). Statements
+	* run one by one here, so instead of deferring foreign keys the loop
+	* retries failed drops until nothing is left — child tables fall first.
+	*/
+	async function resetLocal() {
+		for (;;) {
+			const objects = (await store.query("SELECT type, name, sql FROM sqlite_master ORDER BY name")).results.filter((row) => !row.name.startsWith("sqlite_") && !row.name.startsWith("_cf_"));
+			const virtualTables = objects.filter((row) => row.type === "table" && /^\s*CREATE\s+VIRTUAL\s+TABLE/i.test(row.sql ?? ""));
+			const isShadow = (name) => virtualTables.some((v) => name.startsWith(`${v.name}_`));
+			const quote = (name) => `"${name.replaceAll("\"", "\"\"")}"`;
+			const drops = [];
+			for (const row of objects.filter((r) => r.type === "trigger")) drops.push(`DROP TRIGGER ${quote(row.name)}`);
+			for (const row of virtualTables) drops.push(`DROP TABLE ${quote(row.name)}`);
+			for (const row of objects.filter((r) => r.type === "view")) drops.push(`DROP VIEW ${quote(row.name)}`);
+			for (const row of objects.filter((r) => r.type === "table")) if (!virtualTables.includes(row) && !isShadow(row.name)) drops.push(`DROP TABLE ${quote(row.name)}`);
+			if (drops.length === 0) return;
+			let progressed = false;
+			let lastError;
+			for (const drop of drops) try {
+				await store.query(drop);
+				progressed = true;
+			} catch (err) {
+				lastError = err;
+			}
+			if (!progressed) throw lastError;
+		}
+	}
+	async function applyDump(sql) {
+		await resetLocal();
+		for (const statement of splitSqlStatements(sql)) {
+			if (/^(BEGIN|COMMIT|ROLLBACK|PRAGMA)\b/i.test(statement)) continue;
+			try {
+				await store.query(statement);
+			} catch (err) {
+				throw new Error(`Dump statement failed: ${err instanceof Error ? err.message : String(err)}\n  in: ${statement.slice(0, 120)}${statement.length > 120 ? "…" : ""}`);
+			}
+		}
+		await rebuildFtsIndex(store);
+	}
+	return {
+		handle,
+		applyDump,
+		dispose: () => mf.dispose()
+	};
+}
+//#endregion
+export { createSandbox, fetchProjectDump };