skillwiki 0.10.110 → 0.10.111

package/dist/watcher-MHG46J3R.js

@@ -0,0 +1,616 @@
+#!/usr/bin/env node
+import {
+  sha256Hex
+} from "./chunk-ZRGZBAVS.js";
+import {
+  buildReadyHint
+} from "./chunk-OSL4J7GF.js";
+import {
+  runFetchGuardSync
+} from "./chunk-I2J3IJB7.js";
+import "./chunk-QESNTTVY.js";
+import {
+  readJournal,
+  upsertJournal,
+  writeJournal
+} from "./chunk-KWEYA3OE.js";
+import "./chunk-GQWCTJTU.js";
+import {
+  ipv4InCidr,
+  isBlockedHost
+} from "./chunk-UIEQIJXP.js";
+
+// src/clip-outbox/watcher.ts
+import { createRequire } from "module";
+import { randomBytes as randomBytes2 } from "crypto";
+import { mkdir as mkdir2, readdir, rmdir, unlink, writeFile } from "fs/promises";
+import { basename, join as join2, resolve as resolve3 } from "path";
+
+// src/clip-outbox/seal.ts
+import { randomBytes } from "crypto";
+import { mkdir, open as open2 } from "fs/promises";
+import { dirname, join, relative as relative3 } from "path";
+import yaml from "js-yaml";
+
+// src/clip-outbox/localize.ts
+import { randomUUID } from "crypto";
+import { readFile } from "fs/promises";
+import { isAbsolute, relative, resolve } from "path";
+
+// src/clip-outbox/images.ts
+var MD_IMAGE = /!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+var HTML_IMAGE = /<img\b[^>]*\bsrc=["']([^"']+)["'][^>]*>/gi;
+var WIKI_EMBED = /!\[\[([^\]]+)\]\]/g;
+var REF_DEF = /^\[([^\]]+)\]:\s+(\S+)/gm;
+var REF_IMAGE = /!\[([^\]]*)\]\[([^\]]+)\]/g;
+function parseImageDependencies(markdown, sourceUrl) {
+  const refs = [];
+  const definitions = /* @__PURE__ */ new Map();
+  for (const m of markdown.matchAll(REF_DEF)) {
+    definitions.set(m[1].toLowerCase(), m[2]);
+  }
+  for (const m of markdown.matchAll(MD_IMAGE)) {
+    refs.push(makeRef(m[0], m[2], "markdown", sourceUrl));
+  }
+  for (const m of markdown.matchAll(REF_IMAGE)) {
+    const href = definitions.get(m[2].toLowerCase());
+    if (!href) continue;
+    refs.push(makeRef(m[0], href, "markdown", sourceUrl));
+  }
+  for (const m of markdown.matchAll(HTML_IMAGE)) {
+    refs.push(makeRef(m[0], m[1], "html", sourceUrl));
+  }
+  for (const m of markdown.matchAll(WIKI_EMBED)) {
+    refs.push(makeRef(m[0], m[1].split("|")[0].trim(), "wikilink", sourceUrl));
+  }
+  return refs;
+}
+function makeRef(raw, target, kind, sourceUrl) {
+  const trimmed = target.trim();
+  const local = kind === "wikilink" || trimmed.startsWith("raw/assets/") || !/^[a-z][a-z0-9+.-]*:/i.test(trimmed);
+  let resolved = trimmed;
+  if (!local && sourceUrl) {
+    try {
+      resolved = new URL(trimmed, sourceUrl).toString();
+    } catch {
+      resolved = trimmed;
+    }
+  }
+  return { raw, kind, target: resolved, local };
+}
+function sniffImageKind(bytes) {
+  if (bytes.length >= 8 && bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) {
+    return "png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "jpeg";
+  }
+  if (bytes.length >= 6 && bytes.subarray(0, 6).toString("ascii") === "GIF87a") return "gif";
+  if (bytes.length >= 6 && bytes.subarray(0, 6).toString("ascii") === "GIF89a") return "gif";
+  if (bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "webp";
+  }
+  return void 0;
+}
+function extensionForKind(kind) {
+  return kind === "jpeg" ? "jpg" : kind;
+}
+function pngPixelCount(bytes) {
+  if (sniffImageKind(bytes) !== "png" || bytes.length < 24) return void 0;
+  const width = bytes.readUInt32BE(16);
+  const height = bytes.readUInt32BE(20);
+  return width * height;
+}
+function localAssetRelPath(target) {
+  const cleaned = target.replace(/\\/g, "/").replace(/^\.\//, "");
+  if (cleaned.startsWith("raw/assets/")) return cleaned;
+  if (cleaned.startsWith("/raw/assets/")) return cleaned.slice(1);
+  return void 0;
+}
+
+// src/clip-outbox/ssrf.ts
+import { isIP } from "net";
+import { lookup as dnsLookup } from "dns/promises";
+var extraBlockedV4 = [
+  ["0.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["192.0.2.0", 24],
+  ["198.18.0.0", 15],
+  ["198.51.100.0", 24],
+  ["203.0.113.0", 24],
+  ["224.0.0.0", 4],
+  ["240.0.0.0", 4]
+];
+function isBlockedAddress(address) {
+  if (isBlockedHost(address)) return true;
+  const version = isIP(address);
+  if (version === 4) {
+    return extraBlockedV4.some(([base, prefix]) => ipv4InCidr(address, base, prefix));
+  }
+  if (version === 6) {
+    const lower = address.toLowerCase();
+    return lower === "::" || lower === "::1" || lower.startsWith("fc") || lower.startsWith("fd") || lower.startsWith("fe80:");
+  }
+  return false;
+}
+async function assertPublicHttpsUrl(url, lookup = defaultLookup) {
+  const guard = runFetchGuardSync({ url });
+  if (!guard.result.ok) {
+    return { ok: false, reason: guard.result.error };
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return { ok: false, reason: "MALFORMED_URL" };
+  }
+  if (isBlockedAddress(parsed.hostname)) {
+    return { ok: false, reason: "HOST_BLOCKED" };
+  }
+  try {
+    const addresses = await lookup(parsed.hostname);
+    if (addresses.length === 0) return { ok: false, reason: "DNS_EMPTY" };
+    if (addresses.some(isBlockedAddress)) return { ok: false, reason: "HOST_BLOCKED" };
+  } catch {
+    return { ok: false, reason: "DNS_FAILED" };
+  }
+  return { ok: true, href: parsed.href };
+}
+async function defaultLookup(hostname) {
+  if (isIP(hostname)) return [hostname];
+  const v4 = await dnsLookup(hostname, { all: true, verbatim: true });
+  return v4.map((row) => row.address);
+}
+
+// src/clip-outbox/localize.ts
+var LocalizeError = class extends Error {
+  constructor(message, code = "LOCALIZE_HELD") {
+    super(message);
+    this.code = code;
+    this.name = "LocalizeError";
+  }
+  code;
+};
+function isInsideDir(root, candidate) {
+  const rel = relative(resolve(root), resolve(candidate));
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+async function localizeCapture(markdown, opts, deps = {}) {
+  const captureId = opts.captureId ?? randomUUID().replace(/-/g, "").slice(0, 16);
+  const refs = parseImageDependencies(markdown, opts.sourceUrl);
+  if (refs.length > opts.config.maxImages) {
+    throw new LocalizeError(`too many images: ${refs.length}`);
+  }
+  const fetchImpl = deps.fetch ?? fetch;
+  const now = deps.now ?? Date.now;
+  const assets = [];
+  const seenUrl = /* @__PURE__ */ new Map();
+  const replacements = /* @__PURE__ */ new Map();
+  const deadline = now() + opts.config.localizeTimeoutMs;
+  let bundleBytes = Buffer.byteLength(markdown);
+  for (const ref of refs) {
+    if (now() > deadline) throw new LocalizeError("localize deadline exceeded");
+    let asset = seenUrl.get(ref.target);
+    if (!asset) {
+      if (ref.local) {
+        const rel = localAssetRelPath(ref.target);
+        if (!rel) throw new LocalizeError(`unsafe or missing local image: ${ref.target}`);
+        const abs = resolve(opts.outboxRoot, rel);
+        if (!isInsideDir(resolve(opts.outboxRoot, "raw/assets"), abs)) {
+          throw new LocalizeError("local image outside raw/assets");
+        }
+        const reader = deps.readLocal ?? ((p) => readFile(p));
+        const bytes = await reader(abs);
+        asset = sealAsset(captureId, bytes, ref.target, opts.config);
+        asset.captureRel = rel;
+      } else {
+        const bytes = await downloadImage(ref.target, opts.config, fetchImpl, deps.lookup);
+        asset = sealAsset(captureId, bytes, ref.target, opts.config);
+      }
+      bundleBytes += asset.bytes.length;
+      if (bundleBytes > opts.config.maxBundleBytes) throw new LocalizeError("bundle too large");
+      assets.push(asset);
+      seenUrl.set(ref.target, asset);
+    }
+    replacements.set(ref.raw, `![[${asset.captureRel}]]`);
+  }
+  let rewritten = markdown;
+  for (const [raw, embed] of replacements) {
+    rewritten = rewritten.replaceAll(raw, embed);
+  }
+  const indexMarkdown = [
+    "---",
+    `title: clip assets ${captureId}`,
+    "---",
+    "",
+    ...assets.map((a) => `- ![[${a.captureRel}]]`),
+    ""
+  ].join("\n");
+  bundleBytes += Buffer.byteLength(indexMarkdown);
+  if (bundleBytes > opts.config.maxBundleBytes) throw new LocalizeError("bundle too large");
+  return { captureId, markdown: rewritten, assets, indexMarkdown };
+}
+function sealAsset(captureId, bytes, source, config) {
+  if (bytes.length > config.maxImageBytes) throw new LocalizeError("image too large");
+  const kind = sniffImageKind(bytes);
+  if (!kind || !config.imageTypes.includes(kind)) throw new LocalizeError("unsupported image type");
+  const pixels = pngPixelCount(bytes);
+  if (pixels !== void 0 && pixels > config.maxPixels) throw new LocalizeError("image pixel budget exceeded");
+  const sha256 = sha256Hex(bytes);
+  return {
+    captureRel: `raw/assets/${captureId}/${sha256}.${extensionForKind(kind)}`,
+    sha256,
+    bytes,
+    kind,
+    source
+  };
+}
+async function downloadImage(href, config, fetchImpl, lookup) {
+  let current = href;
+  for (let hop = 0; hop <= config.maxRedirects; hop++) {
+    const guarded = await assertPublicHttpsUrl(current, lookup);
+    if (!guarded.ok) {
+      throw new LocalizeError(
+        hop === 0 ? `blocked image URL: ${guarded.reason}` : `redirect blocked: ${guarded.reason}`
+      );
+    }
+    const res = await fetchImpl(current, {
+      method: "GET",
+      redirect: "manual",
+      headers: { Accept: "image/*" },
+      signal: AbortSignal.timeout(config.requestTimeoutMs)
+    });
+    if (res.status >= 300 && res.status < 400) {
+      const loc = res.headers.get("location");
+      if (!loc) throw new LocalizeError("redirect without location");
+      current = new URL(loc, current).toString();
+      continue;
+    }
+    if (!res.ok || !res.body) throw new LocalizeError(`image HTTP ${res.status}`);
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of res.body) {
+      total += chunk.byteLength;
+      if (total > config.maxImageBytes) throw new LocalizeError("image too large");
+      chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+  throw new LocalizeError("too many redirects");
+}
+
+// src/clip-outbox/files.ts
+import { constants } from "fs";
+import { lstat, open, realpath } from "fs/promises";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2, sep } from "path";
+async function readRegular(root, path, maxBytes) {
+  const rel = relative2(root, path);
+  if (!rel || rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute2(rel)) throw new Error("unsafe input path");
+  let current = resolve2(root);
+  for (const part of ["", ...rel.split(sep)]) {
+    current = resolve2(current, part);
+    const st = await lstat(current);
+    if (st.isSymbolicLink()) throw new Error("symlink input refused");
+    if (current !== path && !st.isDirectory()) throw new Error("invalid input parent");
+  }
+  const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const before = await handle.stat();
+    if (!before.isFile() || before.size > maxBytes) throw new Error("input type or size refused");
+    const bytes = Buffer.alloc(before.size + 1);
+    let bytesRead = 0;
+    while (bytesRead < bytes.length) {
+      const chunk = await handle.read(bytes, bytesRead, bytes.length - bytesRead, bytesRead);
+      if (chunk.bytesRead === 0) break;
+      bytesRead += chunk.bytesRead;
+    }
+    const after = await handle.stat();
+    if (await realpath(path) !== path) throw new Error("input path changed during read");
+    const leaf = await lstat(path);
+    if (leaf.ino !== before.ino || leaf.dev !== before.dev) throw new Error("input identity changed during read");
+    if (bytesRead !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs) throw new Error("input changed during read");
+    return bytes.subarray(0, bytesRead);
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/clip-outbox/seal.ts
+var UnstableCapture = class extends Error {
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function snapshotPath(config, entry, key) {
+  if (!/^(raw\/articles\/|raw\/assets\/)[A-Za-z0-9._/-]+$/.test(key) || key.split("/").some((p) => !p || p === "." || p === "..")) throw new Error("unsafe snapshot key");
+  return join(config.stateRoot, entry.captureId, entry.snapshotId ?? "legacy", "files", key);
+}
+async function durableFile(root, path, bytes) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const f = await open2(path, "wx", 384);
+  try {
+    await f.writeFile(bytes);
+    await f.sync();
+  } finally {
+    await f.close();
+  }
+  let dir = dirname(path);
+  while (true) {
+    const handle = await open2(dir, "r");
+    try {
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    if (dir === root) break;
+    const parent = dirname(dir);
+    if (parent === dir) throw new Error("snapshot directory outside state root");
+    dir = parent;
+  }
+}
+async function sealCapture(config, entry, deps = {}) {
+  entry = { ...entry, snapshotId: randomBytes(8).toString("hex") };
+  const source = entry.source;
+  const inputs = /* @__PURE__ */ new Map();
+  const article = await readRegular(config.root, source, config.maxArticleBytes);
+  inputs.set(source, article);
+  let sourceUrl;
+  const fm = article.toString("utf8").match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  if (fm) {
+    const metadata = yaml.load(fm[1]);
+    const url = metadata?.source_url ?? metadata?.source;
+    if (typeof url === "string") sourceUrl = url;
+  }
+  const localized = await localizeCapture(article.toString("utf8"), { config, sourceUrl, outboxRoot: config.root, captureId: entry.captureId }, {
+    ...deps,
+    readLocal: async (path) => {
+      const bytes = await readRegular(config.root, path, config.maxImageBytes);
+      inputs.set(path, bytes);
+      return bytes;
+    }
+  });
+  await (deps.delay ?? sleep)(config.stableHashMs);
+  for (const [path, bytes] of inputs) {
+    const next = await readRegular(config.root, path, path === source ? config.maxArticleBytes : config.maxImageBytes);
+    if (sha256Hex(bytes) !== sha256Hex(next)) throw new UnstableCapture("capture changed before seal");
+  }
+  const finalArticle = Buffer.from(localized.markdown);
+  if (finalArticle.length > config.maxArticleBytes) throw new Error("localized article too large");
+  const objects = new Map(localized.assets.map((a) => [a.captureRel, a.bytes]));
+  objects.set(`raw/assets/${entry.captureId}/note.md`, Buffer.from(localized.indexMarkdown));
+  objects.set(entry.articleKey, finalArticle);
+  if ([...objects.values()].reduce((n, b) => n + b.length, 0) > config.maxBundleBytes) throw new Error("sealed bundle too large");
+  await durableFile(config.stateRoot, join(config.stateRoot, entry.captureId, entry.snapshotId, "original.md"), article);
+  for (const [key, bytes] of objects) await durableFile(config.stateRoot, snapshotPath(config, entry, key), bytes);
+  return { ...entry, sourceSha256: sha256Hex(article), assetKeys: [...objects.keys()].filter((k) => k !== entry.articleKey), sha256: Object.fromEntries([...objects].map(([k, b]) => [k, sha256Hex(b)])), sizes: Object.fromEntries([...objects].map(([k, b]) => [k, b.length])), receipts: {}, state: "sealed", reason: void 0, attempts: 0, retryAt: void 0, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+}
+function admittedArticle(root, path) {
+  const rel = relative3(root, path).replaceAll("\\", "/");
+  if (!rel.startsWith("raw/articles/") || !rel.endsWith(".md")) return false;
+  return rel.split("/").every((part) => part !== "." && part !== ".." && !part.startsWith(".") && !/[\x00-\x1f]/.test(part) && !part.endsWith("~"));
+}
+
+// src/clip-outbox/watcher.ts
+var RESCAN_FLAGS = 1 | 2 | 4 | 8 | 32 | 64 | 128 | 131072;
+var nativeEvents = async (root, onEvent) => {
+  if (process.platform !== "darwin") throw new Error("clip-outbox watch requires macOS FSEvents");
+  const fsevents = createRequire(import.meta.url)("fsevents");
+  return fsevents.watch(root, onEvent);
+};
+async function workerLock(root) {
+  const path = join2(root, ".skillwiki-clip-worker.lock");
+  const owner = `owner-${process.pid}-${randomBytes2(12).toString("hex")}`;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      await mkdir2(path, { mode: 448 });
+      await writeFile(join2(path, owner), "", { mode: 384, flag: "wx" });
+      return async () => {
+        await unlink(join2(path, owner));
+        await rmdir(path);
+      };
+    } catch (e) {
+      if (e.code !== "EEXIST") throw e;
+      const files = await readdir(path);
+      if (files.length !== 1 || !/^owner-[0-9]+-[a-f0-9]+$/.test(files[0])) throw new Error("invalid worker lock");
+      const pid = Number(files[0].split("-")[1]);
+      if (!Number.isSafeInteger(pid) || pid < 1) throw new Error("invalid worker lock");
+      try {
+        process.kill(pid, 0);
+        throw new Error("clip worker already running");
+      } catch (error) {
+        if (error.code !== "ESRCH") throw error;
+      }
+      try {
+        await unlink(join2(path, files[0]));
+        await rmdir(path);
+      } catch (error) {
+        if (!["ENOENT", "ENOTEMPTY"].includes(error.code ?? "")) throw error;
+      }
+    }
+  }
+  throw new Error("clip worker lock unavailable");
+}
+async function startClipWorker(config, deps) {
+  const release = await workerLock(config.root);
+  let stopEvents;
+  let entries = [];
+  const timers = /* @__PURE__ */ new Map();
+  const queued = /* @__PURE__ */ new Set();
+  let chain = Promise.resolve();
+  let stopped = false;
+  let fallback;
+  const save = async (entry) => {
+    entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    entries = upsertJournal(entries, entry);
+    await writeJournal(config.stateRoot, entries);
+  };
+  const submit = (fn) => {
+    chain = chain.then(async () => {
+      if (!stopped) await fn();
+    }).catch(() => {
+      stopped = true;
+      deps.onError?.("WORKER_STOPPED");
+    });
+  };
+  const schedule = (path, delay = config.debounceMs) => {
+    if (stopped) return;
+    clearTimeout(timers.get(path));
+    timers.set(path, setTimeout(() => {
+      timers.delete(path);
+      if (queued.has(path)) return;
+      queued.add(path);
+      submit(async () => {
+        queued.delete(path);
+        await processPath(path);
+      });
+    }, Math.max(0, delay)));
+  };
+  const processPath = async (path) => {
+    if (!admittedArticle(config.root, path)) return;
+    let entry = entries.find((e) => e.source === path);
+    if (entry?.state === "conflict") return;
+    if (!entry) {
+      const captureId = randomBytes2(16).toString("hex");
+      const title = basename(path, ".md").replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 100);
+      entry = { captureId, source: path, articleKey: `raw/articles/${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}-${title}-${captureId}.md`, assetKeys: [], sha256: {}, state: "discovered" };
+      await save(entry);
+    }
+    if (entry.sourceSha256) {
+      try {
+        const input = await readRegular(config.root, path, config.maxArticleBytes);
+        if (sha256Hex(input) !== entry.sourceSha256 && entry.reason !== "SEALED_SOURCE_CHANGED") {
+          entry.reason = "SEALED_SOURCE_CHANGED";
+          await save(entry);
+        }
+      } catch {
+        if (entry.reason !== "SEALED_SOURCE_UNAVAILABLE") {
+          entry.reason = "SEALED_SOURCE_UNAVAILABLE";
+          await save(entry);
+        }
+      }
+    }
+    if (entry.state === "central-visible" || entry.state === "mirrored") return;
+    if (entry.state === "held" && entry.sourceSha256) return;
+    await deps.validate?.();
+    try {
+      if (!entry.sourceSha256) {
+        entry.state = "preparing";
+        await save(entry);
+        entry = await (deps.seal ?? sealCapture)(config, entry);
+        await save(entry);
+      }
+      await deps.validate?.();
+      if (entry.state !== "notify-pending" && entry.state !== "article-verified") {
+        for (const key of [...entry.assetKeys, entry.articleKey]) {
+          if (entry.receipts?.[key]) continue;
+          const body = await readRegular(join2(config.stateRoot, entry.captureId), snapshotPath(config, entry, key), config.maxBundleBytes);
+          if (sha256Hex(body) !== entry.sha256[key] || body.length !== entry.sizes?.[key]) throw new Error("SNAPSHOT_CHANGED");
+          await deps.validate?.();
+          const receipt = await deps.put(key, body);
+          if (receipt.status === "conflict") {
+            entry.state = "conflict";
+            entry.reason = "REMOTE_CONFLICT";
+            await save(entry);
+            return;
+          }
+          entry.receipts = { ...entry.receipts, [key]: receipt.status };
+          if (key === entry.articleKey) entry.state = "article-verified";
+          else if (entry.assetKeys.every((k) => entry.receipts?.[k])) entry.state = "assets-verified";
+          await save(entry);
+        }
+      }
+      entry.state = "notify-pending";
+      await save(entry);
+      const result = await deps.ready(buildReadyHint(config.vaultId, [...entry.assetKeys, entry.articleKey].map((key) => ({ path: key, sha256: entry.sha256[key] }))));
+      if (!result.ok) {
+        if ([400, 401, 403, 404, 409, 413].includes(result.status ?? 0)) {
+          entry.state = "held";
+          entry.reason = `READY_HTTP_${result.status}`;
+          await save(entry);
+          return;
+        }
+        throw new Error("READY_RETRY");
+      }
+      entry.state = "central-visible";
+      entry.attempts = 0;
+      entry.retryAt = void 0;
+      await save(entry);
+    } catch (e) {
+      entry.attempts = (entry.attempts ?? 0) + 1;
+      const status = e.$metadata?.httpStatusCode;
+      const unstable = e instanceof UnstableCapture;
+      const persistent = [400, 401, 403].includes(status ?? 0) || e instanceof Error && /SNAPSHOT_CHANGED|TOMBSTONE_HOLD|DELETE_INTENT_UNAVAILABLE/.test(e.message);
+      entry.reason = unstable ? "INPUT_UNSTABLE" : persistent ? "DELIVERY_HELD" : entry.sourceSha256 ? "DELIVERY_RETRY" : "PREPARATION_HELD";
+      if (!entry.sourceSha256 || persistent) entry.state = "held";
+      const delay = Math.min(6e4, 1e3 * 2 ** Math.min(entry.attempts - 1, 6)) * (0.8 + (deps.random ?? Math.random)() * 0.2);
+      entry.retryAt = persistent ? void 0 : Date.now() + delay;
+      await save(entry);
+      if (!persistent) schedule(path, unstable ? config.debounceMs : delay);
+    }
+  };
+  const scan = async () => {
+    await deps.validate?.();
+    const walk = async (dir) => {
+      let children;
+      try {
+        children = await readdir(dir, { withFileTypes: true });
+      } catch (e) {
+        if (e.code === "ENOENT") return;
+        throw e;
+      }
+      for (const child of children) {
+        const path = join2(dir, child.name);
+        if (child.isDirectory() && !child.name.startsWith(".")) await walk(path);
+        else if (child.isFile() && admittedArticle(config.root, path)) schedule(path);
+      }
+    };
+    await walk(join2(config.root, "raw/articles"));
+  };
+  let scanQueued = false;
+  const requestScan = () => {
+    if (scanQueued) return;
+    scanQueued = true;
+    submit(async () => {
+      scanQueued = false;
+      await scan();
+    });
+  };
+  try {
+    entries = await readJournal(config.stateRoot);
+    stopEvents = await (deps.events ?? nativeEvents)(config.root, (path, flags) => {
+      if (flags & RESCAN_FLAGS) {
+        requestScan();
+        return;
+      }
+      const absolute = resolve3(path);
+      if (admittedArticle(config.root, absolute)) schedule(absolute);
+      else if (absolute.startsWith(join2(config.root, "raw/assets") + "/")) {
+        for (const entry of entries) if (!entry.sourceSha256 && entry.source) schedule(entry.source);
+      }
+    });
+    for (const entry of entries) if (entry.source) schedule(entry.source, Math.max(0, (entry.retryAt ?? Date.now()) - Date.now()));
+    await scan();
+    if (config.pollFallbackEnabled) fallback = setInterval(requestScan, config.reconcileSeconds * 1e3);
+    return {
+      entries: () => structuredClone(entries),
+      stop: async () => {
+        stopped = true;
+        for (const timer of timers.values()) clearTimeout(timer);
+        timers.clear();
+        if (fallback) clearInterval(fallback);
+        await stopEvents?.();
+        await chain;
+        await release();
+      }
+    };
+  } catch (e) {
+    stopped = true;
+    for (const timer of timers.values()) clearTimeout(timer);
+    await stopEvents?.();
+    await release();
+    throw e;
+  }
+}
+export {
+  RESCAN_FLAGS,
+  nativeEvents,
+  startClipWorker
+};