@aigne/afs-did-space 1.12.0-beta.5

package/dist/data-backend.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-backend.mjs","names":[],"sources":["../src/data-backend.ts"],"sourcesContent":["/**\n * DIDSpaceBlockletDataBackend — BlockletDataBackend backed by DID Space.\n *\n * Storage layout per blocklet app space ({blockletId}):\n *   system/  — blocklet content tree (role root, mounted at `/`)\n *   config/mounts.toml  — per-instance mount overrides (sibling fragment via getConfigSpace)\n */\n\nimport type { AFS, BlockletDataBackend, MountOverride } from \"@aigne/afs\";\nimport type { DIDSpaceLike } from \"./did-space-like.js\";\nimport { normalizeId } from \"./did-utils.js\";\n\nexport interface DIDSpaceBlockletDataBackendOptions {\n  didSpace: DIDSpaceLike;\n}\n\nexport class DIDSpaceBlockletDataBackend implements BlockletDataBackend {\n  private readonly didSpace: DIDSpaceLike;\n\n  constructor(options: DIDSpaceBlockletDataBackendOptions) {\n    this.didSpace = options.didSpace;\n  }\n\n  /** Resolve the system-role instance space (content tree, mounted at `/`). */\n  private instanceSpace(blockletDid: string): Promise<AFS> {\n    return this.didSpace.getInstanceSpace({\n      instanceDid: normalizeId(blockletDid),\n      role: \"system\",\n    });\n  }\n\n  /**\n   * Resolve the runtime-internal config fragment root (`/`), or null if the\n   * backend has none. /files-prefix-removal: config moved out of the role-AFS\n   * into a sibling fragment, reached via `getConfigSpace` instead of the old\n   * `system/config` sub-mount.\n   */\n  private async configSpace(blockletDid: string): Promise<AFS | null> {\n    if (typeof this.didSpace.getConfigSpace !== \"function\") return null;\n    return this.didSpace.getConfigSpace(normalizeId(blockletDid));\n  }\n\n  // ── Data management ──\n\n  async getInstanceAFS(blockletDid: string): Promise<AFS> {\n    return this.instanceSpace(blockletDid);\n  }\n\n  async removeData(blockletDid: string): Promise<void> {\n    const appAFS = await this.instanceSpace(blockletDid);\n\n    try {\n      const result = await appAFS.list(\"/\", { maxDepth: 99 });\n      const files = result.data.filter(\n        (e) => e.meta?.childrenCount === undefined || e.meta.childrenCount === null,\n      );\n      for (const file of files) {\n        try {\n          await appAFS.delete!(file.path);\n        } catch {\n          // Best-effort\n        }\n      }\n    } catch {\n      // No files — ok\n    }\n  }\n\n  // ── Mount overrides ──\n\n  async readMountOverrides(blockletDid: string): Promise<MountOverride[]> {\n    const cfg = await this.configSpace(blockletDid);\n    if (!cfg) return [];\n    const configPath = \"/mounts.toml\";\n\n    try {\n      const result = await cfg.read!(configPath);\n      const content = String(result.data?.content ?? \"\");\n      if (!content.trim()) return [];\n\n      return this.parseMountsToml(content);\n    } catch {\n      return [];\n    }\n  }\n\n  async writeMountOverrides(blockletDid: string, overrides: MountOverride[]): Promise<void> {\n    if (overrides.length === 0) return;\n\n    const cfg = await this.configSpace(blockletDid);\n    if (!cfg) return;\n    const configPath = \"/mounts.toml\";\n\n    // Merge with existing\n    const existing = await this.readMountOverrides(blockletDid);\n    const byTarget = new Map(existing.map((o) => [o.target, o]));\n\n    for (const override of overrides) {\n      const entry: MountOverride = { target: override.target, uri: override.uri };\n      if (override.options && Object.keys(override.options).length > 0) {\n        entry.options = { ...override.options };\n      }\n      byTarget.set(override.target, entry);\n    }\n\n    const content = this.stringifyMountsToml([...byTarget.values()]);\n    await cfg.write!(configPath, { content });\n  }\n\n  async removeMountOverrides(blockletDid: string, targets: string[]): Promise<void> {\n    if (targets.length === 0) return;\n\n    const targetSet = new Set(targets);\n    const remaining = (await this.readMountOverrides(blockletDid)).filter(\n      (override) => !targetSet.has(override.target),\n    );\n    const cfg = await this.configSpace(blockletDid);\n    if (!cfg) return;\n    const configPath = \"/mounts.toml\";\n\n    if (remaining.length === 0) {\n      try {\n        await cfg.delete!(configPath);\n        return;\n      } catch {\n        // Some backends may not support delete; an empty file is equivalent.\n      }\n    }\n\n    await cfg.write!(configPath, { content: this.stringifyMountsToml(remaining) });\n  }\n\n  // ── Private helpers ──\n\n  private parseMountsToml(content: string): MountOverride[] {\n    try {\n      const result: MountOverride[] = [];\n      const lines = content.split(\"\\n\");\n      let current: Partial<MountOverride> | null = null;\n      let inOptions = false;\n\n      for (const line of lines) {\n        const trimmed = line.trim();\n        if (trimmed === \"[[mounts]]\") {\n          if (current?.target && current.uri) {\n            result.push({\n              target: current.target,\n              uri: current.uri,\n              ...(current.options ? { options: current.options } : {}),\n            });\n          }\n          current = {};\n          inOptions = false;\n          continue;\n        }\n        if (!current) continue;\n        if (trimmed === \"[mounts.options]\") {\n          inOptions = true;\n          if (!current.options) current.options = {};\n          continue;\n        }\n\n        // Parse key = value (string, number, boolean, array)\n        const match = trimmed.match(/^(\\w+)\\s*=\\s*(.+)$/);\n        if (match) {\n          const [, key, rawVal] = match;\n          let value: unknown;\n          const v = rawVal!.trim();\n          if (v.startsWith('\"') && v.endsWith('\"')) value = v.slice(1, -1);\n          else if (v === \"true\") value = true;\n          else if (v === \"false\") value = false;\n          else if (v.startsWith(\"[\") && v.endsWith(\"]\")) {\n            value = v\n              .slice(1, -1)\n              .split(\",\")\n              .map((s) => s.trim().replace(/^\"|\"$/g, \"\"))\n              .filter(Boolean);\n          } else if (!Number.isNaN(Number(v))) value = Number(v);\n          else value = v;\n\n          if (inOptions && current.options) {\n            current.options[key!] = value;\n          } else {\n            if (key === \"path\") current.target = value as string;\n            else if (key === \"uri\") current.uri = value as string;\n          }\n        }\n      }\n      if (current?.target && current.uri) {\n        result.push({\n          target: current.target,\n          uri: current.uri,\n          ...(current.options ? { options: current.options } : {}),\n        });\n      }\n      return result;\n    } catch {\n      return [];\n    }\n  }\n\n  private stringifyMountsToml(overrides: MountOverride[]): string {\n    return overrides\n      .map((o) => {\n        let block = `[[mounts]]\\npath = \"${o.target}\"\\nuri = \"${o.uri}\"`;\n        if (o.options && Object.keys(o.options).length > 0) {\n          block += \"\\n\\n[mounts.options]\";\n          for (const [k, v] of Object.entries(o.options)) {\n            if (typeof v === \"string\") block += `\\n${k} = \"${v}\"`;\n            else if (typeof v === \"number\" || typeof v === \"boolean\") block += `\\n${k} = ${v}`;\n            else if (Array.isArray(v)) block += `\\n${k} = [${v.map((i) => `\"${i}\"`).join(\", \")}]`;\n          }\n        }\n        return block;\n      })\n      .join(\"\\n\\n\");\n  }\n}\n"],"mappings":";;;AAgBA,IAAa,8BAAb,MAAwE;CACtE,AAAiB;CAEjB,YAAY,SAA6C;AACvD,OAAK,WAAW,QAAQ;;;CAI1B,AAAQ,cAAc,aAAmC;AACvD,SAAO,KAAK,SAAS,iBAAiB;GACpC,aAAa,YAAY,YAAY;GACrC,MAAM;GACP,CAAC;;;;;;;;CASJ,MAAc,YAAY,aAA0C;AAClE,MAAI,OAAO,KAAK,SAAS,mBAAmB,WAAY,QAAO;AAC/D,SAAO,KAAK,SAAS,eAAe,YAAY,YAAY,CAAC;;CAK/D,MAAM,eAAe,aAAmC;AACtD,SAAO,KAAK,cAAc,YAAY;;CAGxC,MAAM,WAAW,aAAoC;EACnD,MAAM,SAAS,MAAM,KAAK,cAAc,YAAY;AAEpD,MAAI;GAEF,MAAM,SADS,MAAM,OAAO,KAAK,KAAK,EAAE,UAAU,IAAI,CAAC,EAClC,KAAK,QACvB,MAAM,EAAE,MAAM,kBAAkB,UAAa,EAAE,KAAK,kBAAkB,KACxE;AACD,QAAK,MAAM,QAAQ,MACjB,KAAI;AACF,UAAM,OAAO,OAAQ,KAAK,KAAK;WACzB;UAIJ;;CAOV,MAAM,mBAAmB,aAA+C;EACtE,MAAM,MAAM,MAAM,KAAK,YAAY,YAAY;AAC/C,MAAI,CAAC,IAAK,QAAO,EAAE;EACnB,MAAM,aAAa;AAEnB,MAAI;GACF,MAAM,SAAS,MAAM,IAAI,KAAM,WAAW;GAC1C,MAAM,UAAU,OAAO,OAAO,MAAM,WAAW,GAAG;AAClD,OAAI,CAAC,QAAQ,MAAM,CAAE,QAAO,EAAE;AAE9B,UAAO,KAAK,gBAAgB,QAAQ;UAC9B;AACN,UAAO,EAAE;;;CAIb,MAAM,oBAAoB,aAAqB,WAA2C;AACxF,MAAI,UAAU,WAAW,EAAG;EAE5B,MAAM,MAAM,MAAM,KAAK,YAAY,YAAY;AAC/C,MAAI,CAAC,IAAK;EACV,MAAM,aAAa;EAGnB,MAAM,WAAW,MAAM,KAAK,mBAAmB,YAAY;EAC3D,MAAM,WAAW,IAAI,IAAI,SAAS,KAAK,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;AAE5D,OAAK,MAAM,YAAY,WAAW;GAChC,MAAM,QAAuB;IAAE,QAAQ,SAAS;IAAQ,KAAK,SAAS;IAAK;AAC3E,OAAI,SAAS,WAAW,OAAO,KAAK,SAAS,QAAQ,CAAC,SAAS,EAC7D,OAAM,UAAU,EAAE,GAAG,SAAS,SAAS;AAEzC,YAAS,IAAI,SAAS,QAAQ,MAAM;;EAGtC,MAAM,UAAU,KAAK,oBAAoB,CAAC,GAAG,SAAS,QAAQ,CAAC,CAAC;AAChE,QAAM,IAAI,MAAO,YAAY,EAAE,SAAS,CAAC;;CAG3C,MAAM,qBAAqB,aAAqB,SAAkC;AAChF,MAAI,QAAQ,WAAW,EAAG;EAE1B,MAAM,YAAY,IAAI,IAAI,QAAQ;EAClC,MAAM,aAAa,MAAM,KAAK,mBAAmB,YAAY,EAAE,QAC5D,aAAa,CAAC,UAAU,IAAI,SAAS,OAAO,CAC9C;EACD,MAAM,MAAM,MAAM,KAAK,YAAY,YAAY;AAC/C,MAAI,CAAC,IAAK;EACV,MAAM,aAAa;AAEnB,MAAI,UAAU,WAAW,EACvB,KAAI;AACF,SAAM,IAAI,OAAQ,WAAW;AAC7B;UACM;AAKV,QAAM,IAAI,MAAO,YAAY,EAAE,SAAS,KAAK,oBAAoB,UAAU,EAAE,CAAC;;CAKhF,AAAQ,gBAAgB,SAAkC;AACxD,MAAI;GACF,MAAM,SAA0B,EAAE;GAClC,MAAM,QAAQ,QAAQ,MAAM,KAAK;GACjC,IAAI,UAAyC;GAC7C,IAAI,YAAY;AAEhB,QAAK,MAAM,QAAQ,OAAO;IACxB,MAAM,UAAU,KAAK,MAAM;AAC3B,QAAI,YAAY,cAAc;AAC5B,SAAI,SAAS,UAAU,QAAQ,IAC7B,QAAO,KAAK;MACV,QAAQ,QAAQ;MAChB,KAAK,QAAQ;MACb,GAAI,QAAQ,UAAU,EAAE,SAAS,QAAQ,SAAS,GAAG,EAAE;MACxD,CAAC;AAEJ,eAAU,EAAE;AACZ,iBAAY;AACZ;;AAEF,QAAI,CAAC,QAAS;AACd,QAAI,YAAY,oBAAoB;AAClC,iBAAY;AACZ,SAAI,CAAC,QAAQ,QAAS,SAAQ,UAAU,EAAE;AAC1C;;IAIF,MAAM,QAAQ,QAAQ,MAAM,qBAAqB;AACjD,QAAI,OAAO;KACT,MAAM,GAAG,KAAK,UAAU;KACxB,IAAI;KACJ,MAAM,IAAI,OAAQ,MAAM;AACxB,SAAI,EAAE,WAAW,KAAI,IAAI,EAAE,SAAS,KAAI,CAAE,SAAQ,EAAE,MAAM,GAAG,GAAG;cACvD,MAAM,OAAQ,SAAQ;cACtB,MAAM,QAAS,SAAQ;cACvB,EAAE,WAAW,IAAI,IAAI,EAAE,SAAS,IAAI,CAC3C,SAAQ,EACL,MAAM,GAAG,GAAG,CACZ,MAAM,IAAI,CACV,KAAK,MAAM,EAAE,MAAM,CAAC,QAAQ,UAAU,GAAG,CAAC,CAC1C,OAAO,QAAQ;cACT,CAAC,OAAO,MAAM,OAAO,EAAE,CAAC,CAAE,SAAQ,OAAO,EAAE;SACjD,SAAQ;AAEb,SAAI,aAAa,QAAQ,QACvB,SAAQ,QAAQ,OAAQ;cAEpB,QAAQ,OAAQ,SAAQ,SAAS;cAC5B,QAAQ,MAAO,SAAQ,MAAM;;;AAI5C,OAAI,SAAS,UAAU,QAAQ,IAC7B,QAAO,KAAK;IACV,QAAQ,QAAQ;IAChB,KAAK,QAAQ;IACb,GAAI,QAAQ,UAAU,EAAE,SAAS,QAAQ,SAAS,GAAG,EAAE;IACxD,CAAC;AAEJ,UAAO;UACD;AACN,UAAO,EAAE;;;CAIb,AAAQ,oBAAoB,WAAoC;AAC9D,SAAO,UACJ,KAAK,MAAM;GACV,IAAI,QAAQ,uBAAuB,EAAE,OAAO,YAAY,EAAE,IAAI;AAC9D,OAAI,EAAE,WAAW,OAAO,KAAK,EAAE,QAAQ,CAAC,SAAS,GAAG;AAClD,aAAS;AACT,SAAK,MAAM,CAAC,GAAG,MAAM,OAAO,QAAQ,EAAE,QAAQ,CAC5C,KAAI,OAAO,MAAM,SAAU,UAAS,KAAK,EAAE,MAAM,EAAE;aAC1C,OAAO,MAAM,YAAY,OAAO,MAAM,UAAW,UAAS,KAAK,EAAE,KAAK;aACtE,MAAM,QAAQ,EAAE,CAAE,UAAS,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,IAAI,EAAE,GAAG,CAAC,KAAK,KAAK,CAAC;;AAGvF,UAAO;IACP,CACD,KAAK,OAAO"}

package/dist/dedup-backfill.cjs

@@ -0,0 +1,278 @@
+const require_url_normalize = require('./url-normalize.cjs');
+
+//#region src/dedup-backfill.ts
+/**
+* dedup-backfill — one-time backfill of the dedup-on-write secondary index
+* (`ds_entries.dedup_scope` / `dedup_key`) for records written BEFORE #1159
+* landed (planning: dedup-on-write, issue #1159).
+*
+* Pre-#1159 the dedup entry lived at `{collection}/{cid(url)}.json` and had no
+* `dedup_key` column; older layouts (`{slug}.json`, `{uuid}/item.json`) never
+* had one either. After #1159 dedup resolves through the
+* `(scope, dedup_scope, dedup_key)` UNIQUE index, so those historical rows are
+* INVISIBLE to `findByDedupKey` — an already-saved URL's first re-save creates
+* a duplicate. This sweep populates their columns so a re-save merges in place.
+*
+* Design (mirrors ctime-backfill / inline-content-migration):
+*  - OFFLINE, code-driven. The core loop {@link backfillDedup} is backend-
+*    agnostic; the SQL lives in {@link DedupBackfillBackend} adapters (D1 binding
+*    vs Node SQLite vs the CF D1 HTTP API) so it is unit-testable against a mock.
+*  - **Host-language normalization** — the `dedup_key` is
+*    `normalizeItemUrl(record[dedupBy])`, computed in JS with the SAME function
+*    the write path uses. It CANNOT be done in SQL (`json_extract` would store
+*    the RAW url, which would never match the Worker's normalized lookups), so
+*    the sweep MUST read the record body (`content` column) and normalize here.
+*  - **JS uniqueness pre-filter, never DB rejection.** The `(scope, dedup_scope,
+*    dedup_key)` UNIQUE index means two rows can't share a key. A `seen` set —
+*    seeded from the keys ALREADY indexed (e.g. entries a post-#1159 client
+*    already wrote) and grown as the sweep assigns — decides the winner in JS so
+*    NO `UPDATE` ever violates the constraint. This matters over the D1 HTTP
+*    channel where a constraint error is a 4xx that would abort the whole run.
+*    A genuine pre-existing duplicate is left un-indexed (reported), NEVER merged
+*    (the tool does not touch content).
+*  - **WHERE pins `scope` + the collection prefix**, binds everything as
+*    parameters — never a cross-scope / cross-collection UPDATE.
+*  - **Deterministic `ORDER BY path ASC` keyset cursor** — resumable across
+*    invocations; among genuine duplicates the FIRST in path order wins the key.
+*  - **Idempotent**: `UPDATE … WHERE dedup_key IS NULL` — a re-run never
+*    re-touches an already-populated row (0 write). The cursor advances past
+*    EVERY scanned row so one invocation can't loop.
+*  - **Only dedup_scope/dedup_key change** — never cid/size/content/mtime/ctime
+*    (index-only; no changelog / no sync fan-out).
+*/
+/** Extract the record body's `dedupBy` field as a non-empty string, or null. */
+function extractKeyField(content, dedupBy) {
+	if (content == null) return null;
+	let body;
+	try {
+		body = JSON.parse(content);
+	} catch {
+		return null;
+	}
+	if (body === null || typeof body !== "object" || Array.isArray(body)) return null;
+	const v = body[dedupBy];
+	return typeof v === "string" && v.length > 0 ? v : null;
+}
+/**
+* Page over NULL-`dedup_key` FILE rows in one `(scope, collection)` and populate
+* their dedup columns. Returns stats; resumable across calls (a fresh call
+* re-seeds `seen` from the DB, so previously-indexed keys stay winners).
+*/
+async function backfillDedup(backend, opts) {
+	const pageSize = opts.pageSize ?? 100;
+	const maxPages = opts.maxPages ?? Number.POSITIVE_INFINITY;
+	const dryRun = opts.dryRun ?? false;
+	const log = opts.log ?? (() => {});
+	const stats = {
+		scanned: 0,
+		indexed: 0,
+		skippedNoContent: 0,
+		skippedNoField: 0,
+		skippedDuplicate: 0,
+		pages: 0,
+		lastCursor: "",
+		done: false
+	};
+	const seen = new Set(await backend.existingKeys());
+	let cursor = "";
+	while (stats.pages < maxPages) {
+		const rows = await backend.selectCandidates(cursor, pageSize);
+		if (rows.length === 0) {
+			stats.done = true;
+			break;
+		}
+		stats.pages++;
+		for (const row of rows) {
+			stats.scanned++;
+			cursor = row.path;
+			const raw = extractKeyField(row.content, opts.dedupBy);
+			if (raw === null) {
+				if (row.content == null) stats.skippedNoContent++;
+				else stats.skippedNoField++;
+				continue;
+			}
+			const key = require_url_normalize.normalizeItemUrl(raw);
+			if (seen.has(key)) {
+				stats.skippedDuplicate++;
+				continue;
+			}
+			seen.add(key);
+			if (dryRun) {
+				stats.indexed++;
+				continue;
+			}
+			if (await backend.setDedupKey(row.path, key) > 0) stats.indexed++;
+		}
+		stats.lastCursor = cursor;
+		log(`[dedup-backfill] page ${stats.pages}: scanned=${stats.scanned} indexed=${stats.indexed} dup=${stats.skippedDuplicate} cursor=${cursor}`);
+	}
+	return stats;
+}
+const SELECT_SQL = "SELECT path, content FROM ds_entries WHERE scope = ? AND kind = 'file' AND dedup_key IS NULL AND path > ? AND substr(path, 1, ?) = ? ORDER BY path ASC LIMIT ?";
+const EXISTING_KEYS_SQL = "SELECT dedup_key FROM ds_entries WHERE scope = ? AND dedup_scope = ? AND dedup_key IS NOT NULL";
+const UPDATE_SQL = "UPDATE ds_entries SET dedup_scope = ?, dedup_key = ? WHERE scope = ? AND path = ? AND kind = 'file' AND dedup_key IS NULL";
+const DISTINCT_SCOPES_SQL = "SELECT DISTINCT scope FROM ds_entries WHERE kind = 'file' AND dedup_key IS NULL AND substr(path, 1, ?) = ?";
+/** The `path` prefix (`{collection}/`) + its length, for the substr filter. */
+function collectionPrefix(collection) {
+	const prefix = collection.endsWith("/") ? collection : `${collection}/`;
+	return {
+		prefix,
+		len: prefix.length
+	};
+}
+/** D1 (Cloudflare binding) backend adapter for one (scope, collection). */
+function makeD1DedupBackfillBackend(db, scope, collection) {
+	const { prefix, len } = collectionPrefix(collection);
+	return {
+		async existingKeys() {
+			return ((await db.prepare(EXISTING_KEYS_SQL).bind(scope, collection).all()).results ?? []).map((r) => String(r.dedup_key));
+		},
+		async selectCandidates(cursor, limit) {
+			return ((await db.prepare(SELECT_SQL).bind(scope, cursor, len, prefix, limit).all()).results ?? []).map((r) => ({
+				path: String(r.path),
+				content: r.content === null || r.content === void 0 ? null : String(r.content)
+			}));
+		},
+		async setDedupKey(path, dedupKey) {
+			return (await db.prepare(UPDATE_SQL).bind(collection, dedupKey, scope, path).run()).meta?.changes ?? 0;
+		}
+	};
+}
+/** Node SQLite (libsql) backend adapter for one (scope, collection). */
+function makeSqliteDedupBackfillBackend(db, scope, collection) {
+	const { prefix, len } = collectionPrefix(collection);
+	return {
+		async existingKeys() {
+			return (await db.execute({
+				sql: EXISTING_KEYS_SQL,
+				args: [scope, collection]
+			})).rows.map((r) => String(r.dedup_key));
+		},
+		async selectCandidates(cursor, limit) {
+			return (await db.execute({
+				sql: SELECT_SQL,
+				args: [
+					scope,
+					cursor,
+					len,
+					prefix,
+					limit
+				]
+			})).rows.map((r) => ({
+				path: String(r.path),
+				content: r.content === null || r.content === void 0 ? null : String(r.content)
+			}));
+		},
+		async setDedupKey(path, dedupKey) {
+			return (await db.execute({
+				sql: UPDATE_SQL,
+				args: [
+					collection,
+					dedupKey,
+					scope,
+					path
+				]
+			})).rowsAffected ?? 0;
+		}
+	};
+}
+/** Enumerate scopes with any NULL-dedup_key file row under the collection (D1). */
+async function distinctScopesWithDedupCandidatesD1(db, collection) {
+	const { prefix, len } = collectionPrefix(collection);
+	return ((await db.prepare(DISTINCT_SCOPES_SQL).bind(len, prefix).all()).results ?? []).map((r) => String(r.scope));
+}
+/** Enumerate candidate scopes under the collection (Node SQLite). */
+async function distinctScopesWithDedupCandidatesSqlite(db, collection) {
+	const { prefix, len } = collectionPrefix(collection);
+	return (await db.execute({
+		sql: DISTINCT_SCOPES_SQL,
+		args: [len, prefix]
+	})).rows.map((r) => String(r.scope));
+}
+const defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function d1HttpQuery(cfg, sql, params) {
+	const f = cfg.fetchImpl ?? fetch;
+	const sleep = cfg.sleep ?? defaultSleep;
+	const maxRetries = cfg.maxRetries ?? 4;
+	const url = `https://api.cloudflare.com/client/v4/accounts/${cfg.accountId}/d1/database/${cfg.databaseId}/query`;
+	for (let attempt = 0;; attempt++) {
+		let status = 0;
+		let json;
+		let networkErr;
+		try {
+			const res = await f(url, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${cfg.apiToken}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify({
+					sql,
+					params
+				})
+			});
+			status = res.status;
+			json = await res.json();
+		} catch (e) {
+			networkErr = e;
+		}
+		if (!networkErr && status >= 200 && status < 300 && json?.success !== false) {
+			const r = json?.result?.[0];
+			return {
+				results: r?.results ?? [],
+				changes: r?.meta?.changes ?? 0
+			};
+		}
+		const transient = networkErr != null || status >= 500 || status === 429;
+		const msg = networkErr ? `D1 HTTP network error: ${String(networkErr).slice(0, 160)}` : `D1 HTTP ${status}: ${JSON.stringify(json?.errors ?? json).slice(0, 200)}`;
+		if (!transient || attempt >= maxRetries) throw new Error(msg);
+		await sleep(Math.min(2e3, 200 * 2 ** attempt));
+	}
+}
+/** CF D1 HTTP-API backend adapter for one (scope, collection) — offline channel. */
+function makeD1HttpDedupBackfillBackend(cfg, scope, collection) {
+	const { prefix, len } = collectionPrefix(collection);
+	return {
+		async existingKeys() {
+			const { results } = await d1HttpQuery(cfg, EXISTING_KEYS_SQL, [scope, collection]);
+			return results.map((r) => String(r.dedup_key));
+		},
+		async selectCandidates(cursor, limit) {
+			const { results } = await d1HttpQuery(cfg, SELECT_SQL, [
+				scope,
+				cursor,
+				len,
+				prefix,
+				limit
+			]);
+			return results.map((r) => ({
+				path: String(r.path),
+				content: r.content === null || r.content === void 0 ? null : String(r.content)
+			}));
+		},
+		async setDedupKey(path, dedupKey) {
+			const { changes } = await d1HttpQuery(cfg, UPDATE_SQL, [
+				collection,
+				dedupKey,
+				scope,
+				path
+			]);
+			return changes;
+		}
+	};
+}
+/** List distinct candidate scopes under the collection on a CF D1 over HTTP. */
+async function distinctScopesWithDedupCandidatesD1Http(cfg, collection) {
+	const { prefix, len } = collectionPrefix(collection);
+	const { results } = await d1HttpQuery(cfg, DISTINCT_SCOPES_SQL, [len, prefix]);
+	return results.map((r) => String(r.scope));
+}
+
+//#endregion
+exports.backfillDedup = backfillDedup;
+exports.distinctScopesWithDedupCandidatesD1 = distinctScopesWithDedupCandidatesD1;
+exports.distinctScopesWithDedupCandidatesD1Http = distinctScopesWithDedupCandidatesD1Http;
+exports.distinctScopesWithDedupCandidatesSqlite = distinctScopesWithDedupCandidatesSqlite;
+exports.makeD1DedupBackfillBackend = makeD1DedupBackfillBackend;
+exports.makeD1HttpDedupBackfillBackend = makeD1HttpDedupBackfillBackend;
+exports.makeSqliteDedupBackfillBackend = makeSqliteDedupBackfillBackend;

package/dist/dedup-backfill.d.cts

@@ -0,0 +1,165 @@
+//#region src/dedup-backfill.d.ts
+/**
+ * dedup-backfill — one-time backfill of the dedup-on-write secondary index
+ * (`ds_entries.dedup_scope` / `dedup_key`) for records written BEFORE #1159
+ * landed (planning: dedup-on-write, issue #1159).
+ *
+ * Pre-#1159 the dedup entry lived at `{collection}/{cid(url)}.json` and had no
+ * `dedup_key` column; older layouts (`{slug}.json`, `{uuid}/item.json`) never
+ * had one either. After #1159 dedup resolves through the
+ * `(scope, dedup_scope, dedup_key)` UNIQUE index, so those historical rows are
+ * INVISIBLE to `findByDedupKey` — an already-saved URL's first re-save creates
+ * a duplicate. This sweep populates their columns so a re-save merges in place.
+ *
+ * Design (mirrors ctime-backfill / inline-content-migration):
+ *  - OFFLINE, code-driven. The core loop {@link backfillDedup} is backend-
+ *    agnostic; the SQL lives in {@link DedupBackfillBackend} adapters (D1 binding
+ *    vs Node SQLite vs the CF D1 HTTP API) so it is unit-testable against a mock.
+ *  - **Host-language normalization** — the `dedup_key` is
+ *    `normalizeItemUrl(record[dedupBy])`, computed in JS with the SAME function
+ *    the write path uses. It CANNOT be done in SQL (`json_extract` would store
+ *    the RAW url, which would never match the Worker's normalized lookups), so
+ *    the sweep MUST read the record body (`content` column) and normalize here.
+ *  - **JS uniqueness pre-filter, never DB rejection.** The `(scope, dedup_scope,
+ *    dedup_key)` UNIQUE index means two rows can't share a key. A `seen` set —
+ *    seeded from the keys ALREADY indexed (e.g. entries a post-#1159 client
+ *    already wrote) and grown as the sweep assigns — decides the winner in JS so
+ *    NO `UPDATE` ever violates the constraint. This matters over the D1 HTTP
+ *    channel where a constraint error is a 4xx that would abort the whole run.
+ *    A genuine pre-existing duplicate is left un-indexed (reported), NEVER merged
+ *    (the tool does not touch content).
+ *  - **WHERE pins `scope` + the collection prefix**, binds everything as
+ *    parameters — never a cross-scope / cross-collection UPDATE.
+ *  - **Deterministic `ORDER BY path ASC` keyset cursor** — resumable across
+ *    invocations; among genuine duplicates the FIRST in path order wins the key.
+ *  - **Idempotent**: `UPDATE … WHERE dedup_key IS NULL` — a re-run never
+ *    re-touches an already-populated row (0 write). The cursor advances past
+ *    EVERY scanned row so one invocation can't loop.
+ *  - **Only dedup_scope/dedup_key change** — never cid/size/content/mtime/ctime
+ *    (index-only; no changelog / no sync fan-out).
+ */
+/** A dedup-index candidate: a FILE row with a NULL `dedup_key`. */
+interface DedupBackfillCandidate {
+  path: string;
+  /** Raw `entries.content` inline record body (host-parsed here, never in SQL). */
+  content: string | null;
+}
+/**
+ * Backend-specific SQL for the sweep (D1 binding vs Node SQLite vs D1 HTTP).
+ * One `(scope, collection)` per adapter — `collection` is the full stored
+ * collection path (e.g. `blocklets/aside/user/items`), which is BOTH the value
+ * written to `dedup_scope` and the `path` prefix that scopes the sweep.
+ */
+interface DedupBackfillBackend {
+  /**
+   * `dedup_key`s already claimed within this `(scope, collection)` — seeds the
+   * uniqueness `seen` set so the sweep never collides with a row a post-#1159
+   * client already indexed.
+   */
+  existingKeys(): Promise<string[]>;
+  /**
+   * Select up to `limit` FILE rows with `dedup_key IS NULL` under the collection
+   * and `path > cursor`, ordered `path ASC` (the keyset cursor). Empty ⇒ done.
+   */
+  selectCandidates(cursor: string, limit: number): Promise<DedupBackfillCandidate[]>;
+  /**
+   * Set `dedup_scope` (= the collection) + `dedup_key` on the row, guarded
+   * `AND dedup_key IS NULL` so an already-populated row is a 0-row no-op.
+   * Returns the number of rows actually changed (0 or 1).
+   */
+  setDedupKey(path: string, dedupKey: string): Promise<number>;
+}
+interface DedupBackfillOptions {
+  /** Record field to dedup by (e.g. `"url"`). Required. */
+  dedupBy: string;
+  /** Rows per page. Default 100 (content is heavier than a metadata blob). */
+  pageSize?: number;
+  /** Cap pages this invocation (cross-invocation paging). Default unbounded. */
+  maxPages?: number;
+  /**
+   * Preview only — scan + count, run NO UPDATE. `indexed` then reports rows that
+   * WOULD be indexed; all skip counts are exact in both modes.
+   */
+  dryRun?: boolean;
+  log?: (msg: string) => void;
+}
+interface DedupBackfillStats {
+  /** FILE rows examined (dedup_key IS NULL under the collection). */
+  scanned: number;
+  /** Rows whose dedup columns were populated (or WOULD be, in dryRun). */
+  indexed: number;
+  /** Rows with no inline `content` — cannot extract the field, left as-is. */
+  skippedNoContent: number;
+  /** Rows whose body lacked a usable `dedupBy` field — not dedup-able. */
+  skippedNoField: number;
+  /** Rows whose key was already claimed — a genuine duplicate, left un-indexed. */
+  skippedDuplicate: number;
+  pages: number;
+  lastCursor: string;
+  /** True when a page came back empty (the sweep reached the end). */
+  done: boolean;
+}
+/**
+ * Page over NULL-`dedup_key` FILE rows in one `(scope, collection)` and populate
+ * their dedup columns. Returns stats; resumable across calls (a fresh call
+ * re-seeds `seen` from the DB, so previously-indexed keys stay winners).
+ */
+declare function backfillDedup(backend: DedupBackfillBackend, opts: DedupBackfillOptions): Promise<DedupBackfillStats>;
+/** Minimal D1 shape used by the sweep (subset of `D1Database`). */
+interface D1Like {
+  prepare(sql: string): {
+    bind(...args: (string | number)[]): {
+      all(): Promise<{
+        results?: unknown[];
+      }>;
+      run(): Promise<{
+        meta?: {
+          changes?: number;
+        };
+      }>;
+    };
+  };
+}
+/** D1 (Cloudflare binding) backend adapter for one (scope, collection). */
+declare function makeD1DedupBackfillBackend(db: D1Like, scope: string, collection: string): DedupBackfillBackend;
+/**
+ * Minimal libsql client shape (Node `_metadata.db`). `args` narrowed to the
+ * exact bound types so a real `@libsql/client` `Client` is assignable.
+ */
+interface LibsqlLike {
+  execute(stmt: {
+    sql: string;
+    args: (string | number)[];
+  }): Promise<{
+    rows: Array<Record<string, unknown>>;
+    rowsAffected?: number;
+  }>;
+}
+/** Node SQLite (libsql) backend adapter for one (scope, collection). */
+declare function makeSqliteDedupBackfillBackend(db: LibsqlLike, scope: string, collection: string): DedupBackfillBackend;
+/** Enumerate scopes with any NULL-dedup_key file row under the collection (D1). */
+declare function distinctScopesWithDedupCandidatesD1(db: D1Like, collection: string): Promise<string[]>;
+/** Enumerate candidate scopes under the collection (Node SQLite). */
+declare function distinctScopesWithDedupCandidatesSqlite(db: LibsqlLike, collection: string): Promise<string[]>;
+/**
+ * Config for the offline CF D1 HTTP backend: a local Node process holding a
+ * Cloudflare API token with D1-edit runs the SAME paged sweep SQL the Worker
+ * would. No R2 — dedup backfill is pure index UPDATEs (record bodies come from
+ * the inline `content` column). `fetchImpl` / `sleep` are injectable for tests.
+ */
+interface DedupBackfillD1HttpConfig {
+  accountId: string;
+  databaseId: string;
+  apiToken: string;
+  fetchImpl?: typeof fetch;
+  /** Bounded retries for TRANSIENT failures (5xx / 429 / network). Default 4. */
+  maxRetries?: number;
+  sleep?: (ms: number) => Promise<void>;
+}
+/** CF D1 HTTP-API backend adapter for one (scope, collection) — offline channel. */
+declare function makeD1HttpDedupBackfillBackend(cfg: DedupBackfillD1HttpConfig, scope: string, collection: string): DedupBackfillBackend;
+/** List distinct candidate scopes under the collection on a CF D1 over HTTP. */
+declare function distinctScopesWithDedupCandidatesD1Http(cfg: DedupBackfillD1HttpConfig, collection: string): Promise<string[]>;
+//#endregion
+export { D1Like, DedupBackfillBackend, DedupBackfillCandidate, DedupBackfillD1HttpConfig, DedupBackfillOptions, DedupBackfillStats, LibsqlLike, backfillDedup, distinctScopesWithDedupCandidatesD1, distinctScopesWithDedupCandidatesD1Http, distinctScopesWithDedupCandidatesSqlite, makeD1DedupBackfillBackend, makeD1HttpDedupBackfillBackend, makeSqliteDedupBackfillBackend };
+//# sourceMappingURL=dedup-backfill.d.cts.map

package/dist/dedup-backfill.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup-backfill.d.cts","names":[],"sources":["../src/dedup-backfill.ts"],"mappings":";;AA2CA;;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;AAoBA;;;;;;;;;;;;UAhCiB,sBAAA;EACf,IAAA;;EAEA,OAAA;AAAA;;;;;;;UASe,oBAAA;EAiDX;;AAsBN;;;EAjEE,YAAA,IAAgB,OAAA;EAmEV;;;;EA9DN,gBAAA,CAAiB,MAAA,UAAgB,KAAA,WAAgB,OAAA,CAAQ,sBAAA;EA6DhD;;;;;EAvDT,WAAA,CAAY,IAAA,UAAc,QAAA,WAAmB,OAAA;AAAA;AAAA,UAG9B,oBAAA;EA2IA;EAzIf,OAAA;;EAEA,QAAA;EAwIA;EAtIA,QAAA;EAuIE;;;;EAlIF,MAAA;EACA,GAAA,IAAO,GAAA;AAAA;AAAA,UAGQ,kBAAA;EAgIe;EA9H9B,OAAA;EA8HqC;EA5HrC,OAAA;EAkIwC;EAhIxC,gBAAA;EAoIqB;EAlIrB,cAAA;EA+HA;EA7HA,gBAAA;EACA,KAAA;EACA,UAAA;EA8HqB;EA5HrB,IAAA;AAAA;;;;;;iBAsBoB,aAAA,CACpB,OAAA,EAAS,oBAAA,EACT,IAAA,EAAM,oBAAA,GACL,OAAA,CAAQ,kBAAA;;UAqFM,MAAA;EACf,OAAA,CAAQ,GAAA;IACN,IAAA,IAAQ,IAAA;MACN,GAAA,IAAO,OAAA;QAAU,OAAA;MAAA;MACjB,GAAA,IAAO,OAAA;QAAU,IAAA;UAAS,OAAA;QAAA;MAAA;IAAA;EAAA;AAAA;;iBAMhB,0BAAA,CACd,EAAA,EAAI,MAAA,EACJ,KAAA,UACA,UAAA,WACC,oBAAA;;;;;UA2Bc,UAAA;EACf,OAAA,CAAQ,IAAA;IAAQ,GAAA;IAAa,IAAA;EAAA,IAA8B,OAAA;IACzD,IAAA,EAAM,KAAA,CAAM,MAAA;IACZ,YAAA;EAAA;AAAA;;iBAKY,8BAAA,CACd,EAAA,EAAI,UAAA,EACJ,KAAA,UACA,UAAA,WACC,oBAAA;;iBAsBmB,mCAAA,CACpB,EAAA,EAAI,MAAA,EACJ,UAAA,WACC,OAAA;;iBAOmB,uCAAA,CACpB,EAAA,EAAI,UAAA,EACJ,UAAA,WACC,OAAA;;;;;;;UAac,yBAAA;EACf,SAAA;EACA,UAAA;EACA,QAAA;EACA,SAAA,UAAmB,KAAA;EAHnB;EAKA,UAAA;EACA,KAAA,IAAS,EAAA,aAAe,OAAA;AAAA;;iBAkDV,8BAAA,CACd,GAAA,EAAK,yBAAA,EACL,KAAA,UACA,UAAA,WACC,oBAAA;;iBAsBmB,uCAAA,CACpB,GAAA,EAAK,yBAAA,EACL,UAAA,WACC,OAAA"}

package/dist/dedup-backfill.d.mts

@@ -0,0 +1,165 @@
+//#region src/dedup-backfill.d.ts
+/**
+ * dedup-backfill — one-time backfill of the dedup-on-write secondary index
+ * (`ds_entries.dedup_scope` / `dedup_key`) for records written BEFORE #1159
+ * landed (planning: dedup-on-write, issue #1159).
+ *
+ * Pre-#1159 the dedup entry lived at `{collection}/{cid(url)}.json` and had no
+ * `dedup_key` column; older layouts (`{slug}.json`, `{uuid}/item.json`) never
+ * had one either. After #1159 dedup resolves through the
+ * `(scope, dedup_scope, dedup_key)` UNIQUE index, so those historical rows are
+ * INVISIBLE to `findByDedupKey` — an already-saved URL's first re-save creates
+ * a duplicate. This sweep populates their columns so a re-save merges in place.
+ *
+ * Design (mirrors ctime-backfill / inline-content-migration):
+ *  - OFFLINE, code-driven. The core loop {@link backfillDedup} is backend-
+ *    agnostic; the SQL lives in {@link DedupBackfillBackend} adapters (D1 binding
+ *    vs Node SQLite vs the CF D1 HTTP API) so it is unit-testable against a mock.
+ *  - **Host-language normalization** — the `dedup_key` is
+ *    `normalizeItemUrl(record[dedupBy])`, computed in JS with the SAME function
+ *    the write path uses. It CANNOT be done in SQL (`json_extract` would store
+ *    the RAW url, which would never match the Worker's normalized lookups), so
+ *    the sweep MUST read the record body (`content` column) and normalize here.
+ *  - **JS uniqueness pre-filter, never DB rejection.** The `(scope, dedup_scope,
+ *    dedup_key)` UNIQUE index means two rows can't share a key. A `seen` set —
+ *    seeded from the keys ALREADY indexed (e.g. entries a post-#1159 client
+ *    already wrote) and grown as the sweep assigns — decides the winner in JS so
+ *    NO `UPDATE` ever violates the constraint. This matters over the D1 HTTP
+ *    channel where a constraint error is a 4xx that would abort the whole run.
+ *    A genuine pre-existing duplicate is left un-indexed (reported), NEVER merged
+ *    (the tool does not touch content).
+ *  - **WHERE pins `scope` + the collection prefix**, binds everything as
+ *    parameters — never a cross-scope / cross-collection UPDATE.
+ *  - **Deterministic `ORDER BY path ASC` keyset cursor** — resumable across
+ *    invocations; among genuine duplicates the FIRST in path order wins the key.
+ *  - **Idempotent**: `UPDATE … WHERE dedup_key IS NULL` — a re-run never
+ *    re-touches an already-populated row (0 write). The cursor advances past
+ *    EVERY scanned row so one invocation can't loop.
+ *  - **Only dedup_scope/dedup_key change** — never cid/size/content/mtime/ctime
+ *    (index-only; no changelog / no sync fan-out).
+ */
+/** A dedup-index candidate: a FILE row with a NULL `dedup_key`. */
+interface DedupBackfillCandidate {
+  path: string;
+  /** Raw `entries.content` inline record body (host-parsed here, never in SQL). */
+  content: string | null;
+}
+/**
+ * Backend-specific SQL for the sweep (D1 binding vs Node SQLite vs D1 HTTP).
+ * One `(scope, collection)` per adapter — `collection` is the full stored
+ * collection path (e.g. `blocklets/aside/user/items`), which is BOTH the value
+ * written to `dedup_scope` and the `path` prefix that scopes the sweep.
+ */
+interface DedupBackfillBackend {
+  /**
+   * `dedup_key`s already claimed within this `(scope, collection)` — seeds the
+   * uniqueness `seen` set so the sweep never collides with a row a post-#1159
+   * client already indexed.
+   */
+  existingKeys(): Promise<string[]>;
+  /**
+   * Select up to `limit` FILE rows with `dedup_key IS NULL` under the collection
+   * and `path > cursor`, ordered `path ASC` (the keyset cursor). Empty ⇒ done.
+   */
+  selectCandidates(cursor: string, limit: number): Promise<DedupBackfillCandidate[]>;
+  /**
+   * Set `dedup_scope` (= the collection) + `dedup_key` on the row, guarded
+   * `AND dedup_key IS NULL` so an already-populated row is a 0-row no-op.
+   * Returns the number of rows actually changed (0 or 1).
+   */
+  setDedupKey(path: string, dedupKey: string): Promise<number>;
+}
+interface DedupBackfillOptions {
+  /** Record field to dedup by (e.g. `"url"`). Required. */
+  dedupBy: string;
+  /** Rows per page. Default 100 (content is heavier than a metadata blob). */
+  pageSize?: number;
+  /** Cap pages this invocation (cross-invocation paging). Default unbounded. */
+  maxPages?: number;
+  /**
+   * Preview only — scan + count, run NO UPDATE. `indexed` then reports rows that
+   * WOULD be indexed; all skip counts are exact in both modes.
+   */
+  dryRun?: boolean;
+  log?: (msg: string) => void;
+}
+interface DedupBackfillStats {
+  /** FILE rows examined (dedup_key IS NULL under the collection). */
+  scanned: number;
+  /** Rows whose dedup columns were populated (or WOULD be, in dryRun). */
+  indexed: number;
+  /** Rows with no inline `content` — cannot extract the field, left as-is. */
+  skippedNoContent: number;
+  /** Rows whose body lacked a usable `dedupBy` field — not dedup-able. */
+  skippedNoField: number;
+  /** Rows whose key was already claimed — a genuine duplicate, left un-indexed. */
+  skippedDuplicate: number;
+  pages: number;
+  lastCursor: string;
+  /** True when a page came back empty (the sweep reached the end). */
+  done: boolean;
+}
+/**
+ * Page over NULL-`dedup_key` FILE rows in one `(scope, collection)` and populate
+ * their dedup columns. Returns stats; resumable across calls (a fresh call
+ * re-seeds `seen` from the DB, so previously-indexed keys stay winners).
+ */
+declare function backfillDedup(backend: DedupBackfillBackend, opts: DedupBackfillOptions): Promise<DedupBackfillStats>;
+/** Minimal D1 shape used by the sweep (subset of `D1Database`). */
+interface D1Like {
+  prepare(sql: string): {
+    bind(...args: (string | number)[]): {
+      all(): Promise<{
+        results?: unknown[];
+      }>;
+      run(): Promise<{
+        meta?: {
+          changes?: number;
+        };
+      }>;
+    };
+  };
+}
+/** D1 (Cloudflare binding) backend adapter for one (scope, collection). */
+declare function makeD1DedupBackfillBackend(db: D1Like, scope: string, collection: string): DedupBackfillBackend;
+/**
+ * Minimal libsql client shape (Node `_metadata.db`). `args` narrowed to the
+ * exact bound types so a real `@libsql/client` `Client` is assignable.
+ */
+interface LibsqlLike {
+  execute(stmt: {
+    sql: string;
+    args: (string | number)[];
+  }): Promise<{
+    rows: Array<Record<string, unknown>>;
+    rowsAffected?: number;
+  }>;
+}
+/** Node SQLite (libsql) backend adapter for one (scope, collection). */
+declare function makeSqliteDedupBackfillBackend(db: LibsqlLike, scope: string, collection: string): DedupBackfillBackend;
+/** Enumerate scopes with any NULL-dedup_key file row under the collection (D1). */
+declare function distinctScopesWithDedupCandidatesD1(db: D1Like, collection: string): Promise<string[]>;
+/** Enumerate candidate scopes under the collection (Node SQLite). */
+declare function distinctScopesWithDedupCandidatesSqlite(db: LibsqlLike, collection: string): Promise<string[]>;
+/**
+ * Config for the offline CF D1 HTTP backend: a local Node process holding a
+ * Cloudflare API token with D1-edit runs the SAME paged sweep SQL the Worker
+ * would. No R2 — dedup backfill is pure index UPDATEs (record bodies come from
+ * the inline `content` column). `fetchImpl` / `sleep` are injectable for tests.
+ */
+interface DedupBackfillD1HttpConfig {
+  accountId: string;
+  databaseId: string;
+  apiToken: string;
+  fetchImpl?: typeof fetch;
+  /** Bounded retries for TRANSIENT failures (5xx / 429 / network). Default 4. */
+  maxRetries?: number;
+  sleep?: (ms: number) => Promise<void>;
+}
+/** CF D1 HTTP-API backend adapter for one (scope, collection) — offline channel. */
+declare function makeD1HttpDedupBackfillBackend(cfg: DedupBackfillD1HttpConfig, scope: string, collection: string): DedupBackfillBackend;
+/** List distinct candidate scopes under the collection on a CF D1 over HTTP. */
+declare function distinctScopesWithDedupCandidatesD1Http(cfg: DedupBackfillD1HttpConfig, collection: string): Promise<string[]>;
+//#endregion
+export { D1Like, DedupBackfillBackend, DedupBackfillCandidate, DedupBackfillD1HttpConfig, DedupBackfillOptions, DedupBackfillStats, LibsqlLike, backfillDedup, distinctScopesWithDedupCandidatesD1, distinctScopesWithDedupCandidatesD1Http, distinctScopesWithDedupCandidatesSqlite, makeD1DedupBackfillBackend, makeD1HttpDedupBackfillBackend, makeSqliteDedupBackfillBackend };
+//# sourceMappingURL=dedup-backfill.d.mts.map

package/dist/dedup-backfill.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup-backfill.d.mts","names":[],"sources":["../src/dedup-backfill.ts"],"mappings":";;AA2CA;;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;AAoBA;;;;;;;;;;;;UAhCiB,sBAAA;EACf,IAAA;;EAEA,OAAA;AAAA;;;;;;;UASe,oBAAA;EAiDX;;AAsBN;;;EAjEE,YAAA,IAAgB,OAAA;EAmEV;;;;EA9DN,gBAAA,CAAiB,MAAA,UAAgB,KAAA,WAAgB,OAAA,CAAQ,sBAAA;EA6DhD;;;;;EAvDT,WAAA,CAAY,IAAA,UAAc,QAAA,WAAmB,OAAA;AAAA;AAAA,UAG9B,oBAAA;EA2IA;EAzIf,OAAA;;EAEA,QAAA;EAwIA;EAtIA,QAAA;EAuIE;;;;EAlIF,MAAA;EACA,GAAA,IAAO,GAAA;AAAA;AAAA,UAGQ,kBAAA;EAgIe;EA9H9B,OAAA;EA8HqC;EA5HrC,OAAA;EAkIwC;EAhIxC,gBAAA;EAoIqB;EAlIrB,cAAA;EA+HA;EA7HA,gBAAA;EACA,KAAA;EACA,UAAA;EA8HqB;EA5HrB,IAAA;AAAA;;;;;;iBAsBoB,aAAA,CACpB,OAAA,EAAS,oBAAA,EACT,IAAA,EAAM,oBAAA,GACL,OAAA,CAAQ,kBAAA;;UAqFM,MAAA;EACf,OAAA,CAAQ,GAAA;IACN,IAAA,IAAQ,IAAA;MACN,GAAA,IAAO,OAAA;QAAU,OAAA;MAAA;MACjB,GAAA,IAAO,OAAA;QAAU,IAAA;UAAS,OAAA;QAAA;MAAA;IAAA;EAAA;AAAA;;iBAMhB,0BAAA,CACd,EAAA,EAAI,MAAA,EACJ,KAAA,UACA,UAAA,WACC,oBAAA;;;;;UA2Bc,UAAA;EACf,OAAA,CAAQ,IAAA;IAAQ,GAAA;IAAa,IAAA;EAAA,IAA8B,OAAA;IACzD,IAAA,EAAM,KAAA,CAAM,MAAA;IACZ,YAAA;EAAA;AAAA;;iBAKY,8BAAA,CACd,EAAA,EAAI,UAAA,EACJ,KAAA,UACA,UAAA,WACC,oBAAA;;iBAsBmB,mCAAA,CACpB,EAAA,EAAI,MAAA,EACJ,UAAA,WACC,OAAA;;iBAOmB,uCAAA,CACpB,EAAA,EAAI,UAAA,EACJ,UAAA,WACC,OAAA;;;;;;;UAac,yBAAA;EACf,SAAA;EACA,UAAA;EACA,QAAA;EACA,SAAA,UAAmB,KAAA;EAHnB;EAKA,UAAA;EACA,KAAA,IAAS,EAAA,aAAe,OAAA;AAAA;;iBAkDV,8BAAA,CACd,GAAA,EAAK,yBAAA,EACL,KAAA,UACA,UAAA,WACC,oBAAA;;iBAsBmB,uCAAA,CACpB,GAAA,EAAK,yBAAA,EACL,UAAA,WACC,OAAA"}