@olares/lares-core 0.15.0

package/drive/url-download.js

@@ -0,0 +1,314 @@
+import { randomUUID } from "node:crypto";
+import { lookup } from "node:dns/promises";
+import { constants } from "node:fs";
+import { link, open, rename, rm } from "node:fs/promises";
+import http from "node:http";
+import https from "node:https";
+import { BlockList, isIP } from "node:net";
+import { Readable } from "node:stream";
+
+export const MAX_URL_DOWNLOAD_BYTES = 200 * 1024 * 1024;
+const MAX_REDIRECTS = 5;
+const MAX_ATTEMPTS = 3;
+const ATTEMPT_TIMEOUT_MS = 2 * 60 * 1000;
+const RETRYABLE_STATUS = new Set([408, 425, 429, 500, 502, 503, 504]);
+
+const blocked4 = new BlockList();
+for (const [network, prefix] of [
+  ["0.0.0.0", 8],
+  ["10.0.0.0", 8],
+  ["100.64.0.0", 10],
+  ["127.0.0.0", 8],
+  ["169.254.0.0", 16],
+  ["172.16.0.0", 12],
+  ["192.0.0.0", 24],
+  ["192.0.2.0", 24],
+  ["192.168.0.0", 16],
+  ["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],
+]) {
+  blocked4.addSubnet(network, prefix, "ipv4");
+}
+const blocked6 = new BlockList();
+for (const [network, prefix] of [
+  ["::", 128],
+  ["::1", 128],
+  ["::ffff:0:0", 96],
+  ["64:ff9b:1::", 48],
+  ["100::", 64],
+  ["2001:db8::", 32],
+  ["fc00::", 7],
+  ["fe80::", 10],
+  ["ff00::", 8],
+]) {
+  blocked6.addSubnet(network, prefix, "ipv6");
+}
+
+function downloadError(message, retryable = false) {
+  return Object.assign(new Error(message), { retryable });
+}
+
+export function isPublicAddress(address) {
+  const family = isIP(address);
+  if (family === 0) return false;
+  return family === 4
+    ? !blocked4.check(address, "ipv4")
+    : !blocked6.check(address, "ipv6");
+}
+
+export async function assertPublicUrl(value, lookupFn = lookup) {
+  const url = value instanceof URL ? value : new URL(value);
+  if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || !url.hostname) {
+    throw downloadError("url_fetch accepts only public HTTP(S) URLs without embedded credentials");
+  }
+  const hostname = url.hostname.replace(/^\[|\]$/g, "");
+  const literalFamily = isIP(hostname);
+  const addresses = literalFamily
+    ? [{ address: hostname, family: literalFamily }]
+    : await lookupFn(hostname, { all: true, verbatim: true });
+  if (addresses.length === 0 || addresses.some(({ address }) => !isPublicAddress(address))) {
+    throw downloadError(`url_fetch refused non-public host ${url.hostname}`);
+  }
+  return { url, addresses };
+}
+
+/**
+ * The addresses that already passed {@link assertPublicUrl}. Connection uses
+ * this lookup rather than asking DNS again, so a later private answer cannot
+ * replace the public one (DNS rebinding).
+ */
+export function pinLookup(addresses) {
+  const records = addresses.map(({ address, family }) => ({
+    address,
+    family: family === 6 || family === "IPv6" ? 6 : 4,
+  }));
+  return (hostname, options, callback) => {
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    if (options?.all) {
+      callback(null, records);
+      return;
+    }
+    callback(null, records[0].address, records[0].family);
+  };
+}
+
+export function nodeFetch(url, { signal, headers, lookup: lookupOption } = {}) {
+  return new Promise((resolve, reject) => {
+    const target = url instanceof URL ? url : new URL(url);
+    const lib = target.protocol === "https:" ? https : http;
+    const req = lib.request(target, {
+      method: "GET",
+      headers,
+      lookup: lookupOption,
+      signal,
+    }, (incoming) => {
+      const headerBag = new Headers();
+      for (const [name, value] of Object.entries(incoming.headers)) {
+        if (value === undefined) continue;
+        if (Array.isArray(value)) {
+          for (const item of value) headerBag.append(name, item);
+        } else {
+          headerBag.set(name, value);
+        }
+      }
+      const status = incoming.statusCode ?? 500;
+      const noBody = [101, 204, 205, 304].includes(status);
+      resolve(new Response(noBody ? null : Readable.toWeb(incoming), {
+        status,
+        headers: headerBag,
+      }));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+
+async function publicResponse(source, signal, fetchFn, lookupFn) {
+  let url = new URL(source);
+  for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects += 1) {
+    const resolved = await assertPublicUrl(url, lookupFn);
+    const response = await fetchFn(url, {
+      method: "GET",
+      redirect: "manual",
+      signal,
+      lookup: pinLookup(resolved.addresses),
+      headers: {
+        accept: "*/*",
+        "user-agent": "Lares/1.0 workspace-url-fetch",
+      },
+    });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      await response.body?.cancel();
+      if (!location) throw downloadError(`URL redirect ${response.status} has no location`);
+      if (redirects === MAX_REDIRECTS) throw downloadError(`URL exceeded ${MAX_REDIRECTS} redirects`);
+      url = new URL(location, url);
+      continue;
+    }
+    if (!response.ok) {
+      await response.body?.cancel();
+      throw downloadError(
+        `URL returned HTTP ${response.status}`,
+        RETRYABLE_STATUS.has(response.status),
+      );
+    }
+    if (response.body === null) throw downloadError("URL response has no body");
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > MAX_URL_DOWNLOAD_BYTES) {
+      await response.body.cancel();
+      throw downloadError(`URL file exceeds ${MAX_URL_DOWNLOAD_BYTES} bytes`);
+    }
+    return response;
+  }
+  throw downloadError("URL redirect resolution failed");
+}
+
+async function writeResponse(response, absolutePath, overwrite) {
+  const temporary = `${absolutePath}.lares-download-${randomUUID()}.tmp`;
+  let handle;
+  let bytes = 0;
+  try {
+    handle = await open(temporary, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
+    for await (const chunk of response.body) {
+      const body = Buffer.from(chunk);
+      bytes += body.length;
+      if (bytes > MAX_URL_DOWNLOAD_BYTES) {
+        throw downloadError(`URL file exceeds ${MAX_URL_DOWNLOAD_BYTES} bytes`);
+      }
+      await handle.write(body);
+    }
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+    if (overwrite) {
+      await rename(temporary, absolutePath);
+    } else {
+      await link(temporary, absolutePath);
+      await rm(temporary);
+    }
+    return {
+      bytes,
+      mediaType: response.headers.get("content-type")?.split(";", 1)[0] || "application/octet-stream",
+    };
+  } finally {
+    await handle?.close().catch(() => {});
+    await rm(temporary, { force: true }).catch(() => {});
+  }
+}
+
+function attemptSignal(parent) {
+  const controller = new AbortController();
+  const abort = () => controller.abort(parent?.reason);
+  if (parent?.aborted) abort();
+  else parent?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(() => controller.abort(new Error("url_fetch timed out")), ATTEMPT_TIMEOUT_MS);
+  return {
+    signal: controller.signal,
+    dispose() {
+      clearTimeout(timer);
+      parent?.removeEventListener("abort", abort);
+    },
+  };
+}
+
+function wait(ms, signal) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", abort);
+      resolve();
+    }, ms);
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal.reason ?? new Error("url_fetch aborted"));
+    };
+    if (signal.aborted) abort();
+    else signal.addEventListener("abort", abort, { once: true });
+  });
+}
+
+export async function downloadUrl(source, absolutePath, options = {}) {
+  const {
+    signal = new AbortController().signal,
+    overwrite = false,
+    fetchFn = nodeFetch,
+    lookupFn = lookup,
+    retryDelayMs = 250,
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt += 1) {
+    const scoped = attemptSignal(signal);
+    try {
+      const response = await publicResponse(source, scoped.signal, fetchFn, lookupFn);
+      return await writeResponse(response, absolutePath, overwrite);
+    } catch (error) {
+      lastError = error;
+      if (signal.aborted) throw signal.reason ?? error;
+      const retryable = error?.retryable === true
+        || (error instanceof TypeError)
+        || scoped.signal.aborted;
+      if (!retryable || attempt === MAX_ATTEMPTS - 1) throw error;
+    } finally {
+      scoped.dispose();
+    }
+    await wait(retryDelayMs * (2 ** attempt), signal);
+  }
+  throw lastError;
+}
+
+/**
+ * Decode a `data:` URL without touching the network. Router / FlowStudio image
+ * payloads often arrive this way rather than as an HTTP URL.
+ */
+export function decodeDataUrl(value) {
+  const raw = String(value ?? "").trim();
+  if (!raw.toLowerCase().startsWith("data:")) {
+    throw downloadError("url is not a data URL");
+  }
+  const comma = raw.indexOf(",");
+  if (comma < 5) throw downloadError("data URL is missing a payload");
+  const meta = raw.slice(5, comma);
+  const payload = raw.slice(comma + 1);
+  const parts = meta.split(";").map((part) => part.trim()).filter(Boolean);
+  const base64 = parts.some((part) => part.toLowerCase() === "base64");
+  const mediaType = (parts.find((part) => part.includes("/")) || "application/octet-stream")
+    .split(";", 1)[0]
+    .trim()
+    .toLowerCase() || "application/octet-stream";
+  let bytes;
+  try {
+    if (base64) {
+      const encoded = payload.replace(/\s+/g, "");
+      const maxEncoded = Math.ceil(MAX_URL_DOWNLOAD_BYTES / 3) * 4;
+      if (
+        encoded.length > maxEncoded
+        || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(encoded)
+      ) {
+        throw new Error("invalid base64");
+      }
+      bytes = Buffer.from(encoded, "base64");
+    } else {
+      bytes = Buffer.from(decodeURIComponent(payload));
+    }
+  } catch {
+    throw downloadError("data URL payload is not valid");
+  }
+  if (bytes.length === 0) throw downloadError("data URL payload is empty");
+  if (bytes.length > MAX_URL_DOWNLOAD_BYTES) {
+    throw downloadError(`URL file exceeds ${MAX_URL_DOWNLOAD_BYTES} bytes`);
+  }
+  return { bytes, mediaType };
+}
+
+export async function saveDataUrl(source, absolutePath, { overwrite = false } = {}) {
+  const decoded = decodeDataUrl(source);
+  const response = new Response(decoded.bytes, {
+    headers: { "content-type": decoded.mediaType, "content-length": String(decoded.bytes.length) },
+  });
+  return writeResponse(response, absolutePath, overwrite);
+}

package/files/deliverables.js

@@ -0,0 +1,32 @@
+/** Same rule as dsh-client-ui-deliverables: only edit/diff call views produce files. */
+export function producedPathsFromView(view) {
+  if (!view || !Array.isArray(view.locations)) return [];
+  const writable = view.card === "diff" || (view.card === "generic" && view.kind === "edit");
+  if (!writable) return [];
+  const paths = [];
+  const seen = new Set();
+  for (const location of view.locations) {
+    const path = location?.path;
+    if (!path || seen.has(path)) continue;
+    seen.add(path);
+    paths.push(path);
+  }
+  return paths;
+}
+
+export function producedForClosing(owner) {
+  const produced = owner.turn.data.get("deliverables")?.produced ?? [];
+  const paths = [];
+  const seen = new Set();
+  for (const item of produced) {
+    if (item.seq > owner.seq || seen.has(item.path)) continue;
+    seen.add(item.path);
+    paths.push(item.path);
+  }
+  return paths;
+}
+
+export function selectProducedFiles(owner) {
+  const paths = producedForClosing(owner);
+  return paths.length === 0 ? null : paths;
+}

package/files/disposition.js

@@ -0,0 +1,20 @@
+export function filenameFromDisposition(value) {
+  const encoded = /filename\*=(?:UTF-8'')?([^;]+)/i.exec(String(value ?? ""));
+  if (encoded) {
+    try {
+      return decodeURIComponent(encoded[1].trim().replace(/^"(.*)"$/s, "$1"));
+    } catch {
+      // Fall through to the ASCII filename, or the generic save name.
+    }
+  }
+  const plain = /filename="?([^";]+)"?/i.exec(String(value ?? ""));
+  return plain?.[1]?.trim() ?? "";
+}
+
+export async function preflightDownload(url, fetchFn = fetch) {
+  const response = await fetchFn(url, { method: "HEAD" });
+  if (!response.ok) {
+    throw new Error(response.status === 404 ? "file_not_found" : "file_preview_failed");
+  }
+  return filenameFromDisposition(response.headers.get("content-disposition"));
+}

package/files/filename.js

@@ -0,0 +1,22 @@
+export function posixBasename(path) {
+  const raw = String(path ?? "");
+  const trimmed = raw.replace(/\/+$/, "");
+  if (trimmed === "") return raw.includes("/") ? "/" : "";
+  return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
+
+export function posixExtname(path) {
+  const base = posixBasename(path);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(dot) : "";
+}
+
+export function sanitizeFilename(value) {
+  const source = posixBasename(String(value || "file")).normalize("NFC");
+  const safe = source
+    .replace(/[\u0000-\u001f\u007f/\\:*?"<>|]/g, "_")
+    .replace(/\s+/g, "_")
+    .replace(/^\.+/, "")
+    .slice(0, 160);
+  return safe || "file";
+}

package/files/intake.js

@@ -0,0 +1,217 @@
+const IMAGE_TYPES = new Set(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+const MAX_CONCURRENCY = 3;
+
+function freshId() {
+  return globalThis.crypto?.randomUUID?.()
+    ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+function failureCode(error) {
+  if (error?.name === "AbortError") return "file_upload_cancelled";
+  return error instanceof Error ? error.message : "file_upload_failed";
+}
+
+export function splitComposerFiles(files) {
+  const images = [];
+  const documents = [];
+  for (const file of files) {
+    (IMAGE_TYPES.has(file.type) ? images : documents).push(file);
+  }
+  return { images, documents };
+}
+
+export function documentPasteFiles(clipboardData) {
+  const files = Array.from(clipboardData?.files ?? []);
+  return splitComposerFiles(files).documents.length > 0 ? files : null;
+}
+
+export function composerAttachReady({ phase, pending, addImages, sessionId }) {
+  return phase === "plain"
+    && !pending
+    && typeof addImages === "function"
+    && typeof sessionId === "string";
+}
+
+export function claimComposerBlock(registry, sessionId, reason) {
+  const store = registry.storeFor(sessionId);
+  if (store.getSnapshot() !== undefined) return () => {};
+  const block = { reason };
+  registry.set(sessionId, block);
+  return () => {
+    if (store.getSnapshot() === block) registry.set(sessionId, undefined);
+  };
+}
+
+export const COMPOSER_CARD = "[data-composer-card]";
+
+export function composerPasteInCard(target) {
+  return Boolean(target && typeof target.closest === "function" && target.closest(COMPOSER_CARD));
+}
+
+export function composerDropHasDocuments(files) {
+  return files.length > 0 && splitComposerFiles(files).documents.length > 0;
+}
+
+export function draftImageFailureCode(reason) {
+  return reason instanceof Error ? reason.message : "file_upload_failed";
+}
+
+export function commitComposerImages(ports, files, sessionId) {
+  if (files.length === 0) return;
+  let attachments = [];
+  try {
+    attachments = ports.createDraftImages(files);
+    if (!ports.addImages(attachments.map((attachment) => attachment.id))) {
+      ports.releaseDraftImages(attachments);
+      for (const file of files) ports.reportFailure(sessionId, file, "file_input_blocked");
+    }
+  } catch (reason) {
+    if (attachments.length > 0) ports.releaseDraftImages(attachments);
+    const code = draftImageFailureCode(reason);
+    for (const file of files) ports.reportFailure(sessionId, file, code);
+  }
+}
+
+export function processComposerFiles(ports, incoming) {
+  if (!ports.ready || incoming.length === 0) return;
+  const files = [...incoming];
+  const { images, documents } = splitComposerFiles(files);
+  ports.addImages(images);
+  if (documents.length === 0) return;
+  const { accepted, oversized } = partitionDocumentsBySize(documents, ports.maxBytes);
+  for (const file of oversized) ports.reportFailure(ports.sessionId, file, "file_too_large");
+  return ports.uploadFiles(ports.sessionId, accepted, ports.commit);
+}
+
+export function partitionDocumentsBySize(documents, maxBytes) {
+  const accepted = [];
+  const oversized = [];
+  for (const file of documents) {
+    if (file.size > maxBytes) oversized.push(file);
+    else accepted.push(file);
+  }
+  return { accepted, oversized };
+}
+
+export class FileIntake {
+  constructor(upload) {
+    this.upload = upload;
+    this.sessions = new Map();
+  }
+
+  session(sessionId) {
+    let state = this.sessions.get(sessionId);
+    if (state) return state;
+    state = {
+      items: [],
+      listeners: new Set(),
+      snapshot: { pending: 0, failures: [] },
+    };
+    this.sessions.set(sessionId, state);
+    return state;
+  }
+
+  getSnapshot(sessionId) {
+    return this.session(sessionId).snapshot;
+  }
+
+  subscribe(sessionId, listener) {
+    const state = this.session(sessionId);
+    state.listeners.add(listener);
+    return () => state.listeners.delete(listener);
+  }
+
+  publish(state) {
+    state.snapshot = {
+      pending: state.items.filter((item) => item.status === "uploading").length,
+      failures: state.items
+        .filter((item) => item.status === "failed")
+        .map(({ id, file, code }) => ({ id, name: file.name || "file", code })),
+    };
+    for (const listener of state.listeners) listener();
+  }
+
+  reportFailure(sessionId, file, code) {
+    const state = this.session(sessionId);
+    state.items.push({
+      id: freshId(),
+      file,
+      status: "failed",
+      code,
+      controller: null,
+    });
+    this.publish(state);
+  }
+
+  dismiss(sessionId, itemId) {
+    const state = this.session(sessionId);
+    state.items = state.items.filter((item) => item.id !== itemId);
+    this.publish(state);
+  }
+
+  async uploadFiles(sessionId, files, commit) {
+    if (files.length === 0) return;
+    const state = this.session(sessionId);
+    const items = files.map((file) => ({
+      id: freshId(),
+      requestId: freshId(),
+      file,
+      status: "uploading",
+      code: null,
+      controller: new AbortController(),
+    }));
+    state.items.push(...items);
+    this.publish(state);
+
+    let cursor = 0;
+    const successful = new Array(items.length);
+    const worker = async () => {
+      while (cursor < items.length) {
+        const index = cursor++;
+        const item = items[index];
+        try {
+          const result = await this.upload(item.file, sessionId, {
+            signal: item.controller.signal,
+            requestId: item.requestId,
+          });
+          if (!item.controller.signal.aborted) successful[index] = { item, result };
+        } catch (error) {
+          if (!item.controller.signal.aborted) {
+            item.status = "failed";
+            item.code = failureCode(error);
+          }
+        }
+      }
+    };
+    await Promise.all(Array.from({ length: Math.min(MAX_CONCURRENCY, items.length) }, worker));
+
+    const live = this.sessions.get(sessionId);
+    if (live !== state) return;
+    const committed = successful.filter(Boolean);
+    const paths = committed.map(({ result }) => result.path);
+    if (paths.length > 0) commit(paths);
+    const completed = new Set(committed.map(({ item }) => item));
+    state.items = state.items.filter((item) => {
+      if (completed.has(item)) return false;
+      if (item.controller?.signal.aborted) return false;
+      return true;
+    });
+    this.publish(state);
+  }
+
+  retry(sessionId, itemId, commit) {
+    const state = this.session(sessionId);
+    const item = state.items.find((candidate) => candidate.id === itemId && candidate.status === "failed");
+    if (!item) return Promise.resolve();
+    state.items = state.items.filter((candidate) => candidate !== item);
+    return this.uploadFiles(sessionId, [item.file], commit);
+  }
+
+  cancelSession(sessionId) {
+    const state = this.sessions.get(sessionId);
+    if (!state) return;
+    for (const item of state.items) item.controller?.abort();
+    state.items = [];
+    this.publish(state);
+  }
+}

package/files/limits.js

@@ -0,0 +1 @@
+export const DEFAULT_MAX_UPLOAD_BYTES = 100 * 1024 * 1024;

package/files/markdown.js

@@ -0,0 +1,88 @@
+/**
+ * dsh's MarkdownText keeps only http / https / mailto targets: a workspace-relative
+ * or Olares files-path link or image renders as inert text. Rewriting those targets
+ * to the plugin's own same-origin raw URL is what makes them render at all; the view
+ * maps the URL back to a path when a click lands on one.
+ */
+
+import { isFilesPath, parseFilesPath } from "../drive/files-path.js";
+
+const FENCE = /^[ \t]{0,3}(`{3,}|~{3,})/;
+const INLINE_CODE = /(`+).*?\1/g;
+const TARGET = /(!?)\[((?:[^\][\\]|\\.)*)\]\(\s*(<[^>\n]*>|[^\s()]*)([^)]*)\)/g;
+const ABSOLUTE = /^(?:[a-z][a-z0-9+.-]*:|\/\/|#)/i;
+
+function directorySegments(path) {
+  const segments = String(path ?? "").split(/[/\\]/).filter((part) => part !== "");
+  segments.pop();
+  return segments;
+}
+
+/**
+ * Resolve a markdown link or image target against the previewed file.
+ * @returns the workspace-relative or Olares files path, or null when the target
+ * is external, empty, or climbs out of the workspace.
+ */
+export function workspaceTargetPath(fromPath, target) {
+  const raw = String(target ?? "").trim().replace(/^<|>$/g, "");
+  if (raw === "" || ABSOLUTE.test(raw)) return null;
+  const [locator] = raw.split(/[?#]/);
+  if (locator === "") return null;
+  let decoded = locator;
+  try {
+    decoded = decodeURIComponent(locator);
+  } catch {
+    // A malformed escape is a literal path; the host validates it either way.
+  }
+  if (isFilesPath(decoded)) return parseFilesPath(decoded);
+  const segments = decoded.startsWith("/") ? [] : directorySegments(fromPath);
+  for (const part of decoded.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part !== "..") {
+      segments.push(part);
+      continue;
+    }
+    if (segments.length === 0) return null;
+    segments.pop();
+  }
+  return segments.length === 0 ? null : segments.join("/");
+}
+
+function rewriteSpan(span, fromPath, hrefFor) {
+  return span.replace(TARGET, (match, bang, label, target, tail) => {
+    const path = workspaceTargetPath(fromPath, target);
+    return path === null ? match : `${bang}[${label}](${hrefFor(path)}${tail})`;
+  });
+}
+
+/**
+ * Rewrite every workspace-relative or Olares files-path link and image target
+ * in `text` to an absolute URL. Fenced blocks and inline code keep their source
+ * verbatim.
+ * @param hrefFor - path → absolute URL the renderer accepts.
+ */
+export function rewriteWorkspaceTargets(text, fromPath, hrefFor) {
+  const lines = String(text ?? "").split("\n");
+  let fence = null;
+  return lines
+    .map((line) => {
+      const marker = FENCE.exec(line);
+      if (fence !== null) {
+        if (marker !== null && marker[1].startsWith(fence[0]) && marker[1].length >= fence.length) fence = null;
+        return line;
+      }
+      if (marker !== null) {
+        fence = marker[1];
+        return line;
+      }
+      let cursor = 0;
+      let out = "";
+      INLINE_CODE.lastIndex = 0;
+      for (let code = INLINE_CODE.exec(line); code !== null; code = INLINE_CODE.exec(line)) {
+        out += rewriteSpan(line.slice(cursor, code.index), fromPath, hrefFor) + code[0];
+        cursor = code.index + code[0].length;
+      }
+      return out + rewriteSpan(line.slice(cursor), fromPath, hrefFor);
+    })
+    .join("\n");
+}