@ai-matrx/kit 0.12.1 → 0.13.2

package/dist/index.js

@@ -804,7 +804,7 @@ function messageText(message, data) {
 }
 function createMatrxToast({
   toast: hostToast,
-  capture
+  capture: capture2
 }) {
   if (typeof hostToast !== "function") {
     throw new Error(
@@ -812,9 +812,9 @@ function createMatrxToast({
     );
   }
   function captureToast(kind, message, data) {
-    if (!capture) return;
+    if (!capture2) return;
     try {
-      capture({
+      capture2({
         source: "user-toast",
         message: `${kind === "warning" ? "[warning] " : ""}${messageText(message, data)}`,
         userMessage: messageText(message, data),
@@ -2719,7 +2719,1185 @@ async function decodeQrFromImageFile(file) {
     bitmap.close();
   }
 }
+
+// src/html-escape.ts
+var HTML_ESCAPES = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var HTML_ESCAPE_RE = /[&<>"']/g;
+function escapeHtml(value) {
+  if (typeof value !== "string") return "";
+  return value.replace(HTML_ESCAPE_RE, (char) => HTML_ESCAPES[char] ?? char);
+}
+
+// src/content-transfer/agent-payload.ts
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var xmlName = (name) => {
+  if (!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(name)) throw new Error(`Invalid AI envelope name: ${name}`);
+  return name;
+};
+var presentEntries = (values) => Object.entries(values ?? {}).filter(([, value]) => value !== null && value !== void 0 && value !== "");
+function fenceJsonBlock(json) {
+  const runs = json.match(/`+/g) ?? [];
+  const fence = "`".repeat(Math.max(3, ...runs.map((run) => run.length + 1)));
+  return `${fence}json
+${json.trimEnd()}
+${fence}`;
+}
+function buildAgentPayload(input, environment = {}) {
+  const kind = xmlName(input.kind);
+  const url = environment.url ?? (typeof window === "undefined" ? "" : window.location.href);
+  const route = environment.route ?? (typeof window === "undefined" ? "" : window.location.pathname);
+  const attrs = presentEntries(input.attributes).map(([key, value]) => ` ${xmlName(key)}="${escapeXml(String(value))}"`).join("");
+  const entries = [
+    ["location", input.location],
+    ...url ? [["url", url]] : [],
+    ...route ? [["route", route]] : [],
+    ["copied", input.description],
+    ["copied-at", environment.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString()],
+    ...presentEntries(input.context).map(([key, value]) => [xmlName(key), String(value)])
+  ];
+  const json = JSON.stringify(input.data, null, 2);
+  if (json === void 0) throw new Error("AI envelope data must be JSON serializable.");
+  const safeJson = json.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+  const context = entries.map(([key, value]) => `<${key}>${escapeXml(value)}</${key}>`).join("\n");
+  const summary = input.summary ? `<summary>
+${escapeXml(input.summary)}
+</summary>
+` : "";
+  return `<${kind}${attrs}>
+<context>
+${context}
+</context>
+${summary}<data format="json">
+${fenceJsonBlock(safeJson)}
+</data>
+</${kind}>`;
+}
+
+// src/content-transfer.ts
+var ContentTransferError = class extends Error {
+  code;
+  path;
+  constructor(code, message, path) {
+    super(message);
+    this.code = code;
+    this.path = path;
+  }
+};
+var bound = /* @__PURE__ */ Symbol("bound-all-matching");
+var stop = (s) => {
+  if (s.aborted) throw new DOMException("Cancelled", "AbortError");
+};
+var enc = (x) => x.replace(/~/g, "~0").replace(/\//g, "~1");
+var dec = (x) => x.replace(/~1/g, "/").replace(/~0/g, "~");
+function clone(v, path = "", seen = /* @__PURE__ */ new WeakSet(), policy = {}) {
+  if (v === null || typeof v === "string" || typeof v === "boolean") return v;
+  if (typeof v === "number") {
+    if (!Number.isFinite(v))
+      throw new ContentTransferError(
+        "unsupported-value",
+        "Only finite numbers are transferable",
+        path
+      );
+    return v;
+  }
+  if (typeof v !== "object")
+    throw new ContentTransferError(
+      "unsupported-value",
+      "Unsupported value",
+      path
+    );
+  if (seen.has(v))
+    throw new ContentTransferError(
+      "circular-value",
+      "Circular values cannot be transferred",
+      path
+    );
+  if (!Array.isArray(v) && Object.getPrototypeOf(v) !== Object.prototype && Object.getPrototypeOf(v) !== null)
+    throw new ContentTransferError(
+      "unsupported-value",
+      "Only plain JSON objects are transferable",
+      path
+    );
+  seen.add(v);
+  if (Array.isArray(v)) {
+    for (let index = 0; index < v.length; index += 1)
+      if (!Object.hasOwn(v, index))
+        throw new ContentTransferError(
+          "unsupported-value",
+          "Sparse arrays cannot be transferred",
+          `${path}/${index}`
+        );
+  }
+  const out = Array.isArray(v) ? v.map((x, i) => clone(x, `${path}/${i}`, seen, policy)) : Object.fromEntries(
+    Object.entries(v).filter(([, x]) => !policy.omitUndefinedObjectProperties || x !== void 0).map(([k, x]) => [
+      k,
+      clone(x, `${path}/${enc(k)}`, seen, policy)
+    ])
+  );
+  seen.delete(v);
+  return out;
+}
+var maxSurfacePointerSegmentLength = 64;
+var maxSurfacePointerLength = 192;
+var truncateSurfacePointer = (value, maxLength) => {
+  const characters = Array.from(value);
+  return characters.length > maxLength ? `${characters.slice(0, maxLength - 1).join("")}\u2026` : value;
+};
+function displaySurfacePointer(path) {
+  if (!path) return "/";
+  const safe = path.split("/").slice(1).map((segment) => {
+    const controlSafe = segment.replace(
+      /[\u0000-\u001F\u007F-\u009F]/g,
+      (character) => `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`
+    );
+    return truncateSurfacePointer(controlSafe, maxSurfacePointerSegmentLength);
+  }).join("/");
+  const pointer = `/${safe}`;
+  return truncateSurfacePointer(pointer, maxSurfacePointerLength);
+}
+function cloneSurfaceValue(value, path) {
+  try {
+    return clone(value, path, /* @__PURE__ */ new WeakSet(), {
+      omitUndefinedObjectProperties: true
+    });
+  } catch (error) {
+    if (error instanceof ContentTransferError)
+      throw new ContentTransferError(
+        error.code,
+        `Surface capture rejected value at ${displaySurfacePointer(error.path)}: ${error.message}`,
+        error.path
+      );
+    throw error;
+  }
+}
+function normalizeTransferJson(value) {
+  return clone(value);
+}
+function deepFreeze(v) {
+  if (ArrayBuffer.isView(v)) return v;
+  if (v && typeof v === "object" && !Object.isFrozen(v)) {
+    Object.freeze(v);
+    for (const x of Object.values(v)) deepFreeze(x);
+  }
+  return v;
+}
+function at(v, path) {
+  validatePointer(path);
+  if (path === "") return v;
+  if (!path.startsWith("/"))
+    throw new ContentTransferError(
+      "invalid-path",
+      "Expected RFC 6901 pointer",
+      path
+    );
+  let cur = v;
+  for (const part of path.slice(1).split("/").map(dec)) {
+    if (Array.isArray(cur)) cur = cur[Number(part)];
+    else if (cur && typeof cur === "object")
+      cur = Object.hasOwn(cur, part) ? cur[part] : void 0;
+    else return void 0;
+  }
+  return cur;
+}
+function validatePointer(path) {
+  if (path !== "" && !path.startsWith("/") || /~(?![01])/u.test(path))
+    throw new ContentTransferError(
+      "invalid-path",
+      "Expected an RFC 6901 JSON pointer",
+      path
+    );
+}
+function readTransferCell(row, column) {
+  return at(row, column.path);
+}
+function without(v, paths, omit, path = "") {
+  if (paths.includes(path)) {
+    omit.push({ path, reason: "excluded" });
+    return void 0;
+  }
+  if (Array.isArray(v))
+    return v.map((x, i) => without(x, paths, omit, `${path}/${i}`)).filter((x) => x !== void 0);
+  if (v && typeof v === "object") {
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const [k, x] of Object.entries(v)) {
+      const y = without(x, paths, omit, `${path}/${enc(k)}`);
+      if (y !== void 0) out[k] = y;
+    }
+    return out;
+  }
+  return v;
+}
+function projectValue(v, rules, target, omit) {
+  rules.forEach((rule) => validatePointer(rule.path));
+  return without(
+    clone(v),
+    rules.filter(
+      (r) => r.target === target && (!r.exportable || r.classification !== "ordinary")
+    ).map((r) => r.path),
+    omit
+  ) ?? null;
+}
+function normalize(p, projection, omit) {
+  if (p.kind === "text" || p.kind === "markdown") {
+    if (typeof p.text !== "string")
+      throw new ContentTransferError(
+        "unsupported-value",
+        "Text payload must contain a string",
+        "/text"
+      );
+    const value = projectValue(p.text, projection.rules, "payload", omit);
+    return { kind: p.kind, text: typeof value === "string" ? value : "" };
+  }
+  if (p.kind === "json")
+    return {
+      kind: "json",
+      value: projectValue(p.value, projection.rules, "payload", omit)
+    };
+  if (p.kind === "registered")
+    return {
+      kind: "registered",
+      format: p.format,
+      value: projectValue(p.value, projection.rules, "payload", omit)
+    };
+  const rowsPayload = p;
+  if (p.kind !== "rows")
+    throw new ContentTransferError(
+      "invalid-payload",
+      "Unsupported payload kind"
+    );
+  const columns = rowsPayload.columns.map((c) => ({ ...c }));
+  resolveTransferRegistry(columns);
+  columns.forEach((column) => validatePointer(column.path));
+  const rules = [
+    ...projection.rules,
+    ...columns.filter(
+      (c) => c.exportable === false || c.classification === "secret" || c.classification === "credential"
+    ).map((c) => ({
+      target: "row",
+      path: c.path,
+      exportable: c.exportable ?? true,
+      classification: c.classification ?? "ordinary"
+    }))
+  ];
+  return {
+    kind: "rows",
+    columns,
+    rows: rowsPayload.rows.map((row, index) => {
+      if (!row || typeof row !== "object" || Array.isArray(row))
+        throw new ContentTransferError(
+          "invalid-row",
+          "A table row must be a JSON object",
+          `/rows/${index}`
+        );
+      const projected = projectValue(row, rules, "row", omit);
+      return projected === null ? {} : projected;
+    })
+  };
+}
+function projectSnapshot(raw, projection) {
+  const omissions = raw.omissions.map((o) => ({ ...o }));
+  const normalized = normalize(raw.payload, projection, omissions);
+  const payload = raw.limits ? limitPayload(normalized, raw.limits, omissions) : normalized;
+  const included = payload.kind === "rows" ? payload.rows.length : raw.coverage.included;
+  return deepFreeze({
+    ...raw,
+    payload,
+    coverage: {
+      ...raw.coverage,
+      included,
+      ...included < raw.coverage.included ? { status: "partial", reason: "Source export limit applied" } : {}
+    },
+    omissions,
+    sections: raw.sections.filter(
+      (section) => !projection.rules.some(
+        (rule) => rule.target === "payload" && (!rule.exportable || rule.classification !== "ordinary") && (section.path === rule.path || section.path.startsWith(`${rule.path}/`))
+      )
+    ).map((x) => ({ ...x })),
+    ...raw.limits ? { limits: { ...raw.limits } } : {}
+  });
+}
+var uid = () => globalThis.crypto?.randomUUID?.() ?? `capture-${Date.now()}-${Math.random()}`;
+function directSource(payload, options = {}) {
+  const id = options.id ?? uid();
+  return {
+    projection: options.projection ?? { rules: [] },
+    snapshot: {
+      id,
+      sourceId: options.sourceId ?? id,
+      revision: options.revision ?? uid(),
+      capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      label: options.label ?? "Content",
+      payload,
+      coverage: options.coverage ?? {
+        status: "complete",
+        included: payload.kind === "rows" ? payload.rows.length : 1,
+        total: payload.kind === "rows" ? payload.rows.length : 1
+      },
+      unsavedChanges: options.unsavedChanges ?? false,
+      omissions: [],
+      sections: options.sections ?? [],
+      ...options.limits ? { limits: { ...options.limits } } : {}
+    }
+  };
+}
+async function capture(source, signal, scope = "target") {
+  stop(signal);
+  const captured = "kind" in source ? directSource(source) : await source.capture({ scope, signal });
+  stop(signal);
+  const all = captured.allMatching;
+  if (all && (all.query.sourceId !== captured.snapshot.sourceId || all.query.revision !== captured.snapshot.revision || all.query.order.length === 0))
+    throw new ContentTransferError(
+      "query-mismatch",
+      "All-matching query must be captured with stable ordering"
+    );
+  const snapshot = projectSnapshot(captured.snapshot, captured.projection);
+  if (!all) return { snapshot };
+  return {
+    snapshot,
+    allMatching: deepFreeze({
+      [bound]: true,
+      source: {
+        ...all,
+        query: {
+          ...all.query,
+          query: clone(all.query.query),
+          order: all.query.order.map((x) => ({ ...x }))
+        }
+      },
+      projection: { rules: captured.projection.rules.map((x) => ({ ...x })) },
+      columns: snapshot.payload.kind === "rows" ? snapshot.payload.columns : [],
+      ...snapshot.limits ? { limits: { ...snapshot.limits } } : {}
+    })
+  };
+}
+function createDraft(s) {
+  return deepFreeze({
+    snapshotId: s.id,
+    sourceId: s.sourceId,
+    sourceRevision: s.revision,
+    revision: 0,
+    payload: normalize(s.payload, { rules: [] }, []),
+    omissions: [...s.omissions],
+    manuallyEdited: false,
+    provenance: [{ kind: "original", description: "Captured source snapshot" }]
+  });
+}
+function revise(d, p, o, description, manual = d.manuallyEdited, kind = "deterministic", baseOmissions = d.omissions) {
+  const { history: _history, ...previous } = d;
+  return deepFreeze({
+    ...d,
+    revision: d.revision + 1,
+    payload: normalize(p, { rules: [] }, []),
+    omissions: [...baseOmissions, ...o],
+    manuallyEdited: manual,
+    provenance: [...d.provenance, { kind, description }],
+    history: [...d.history ?? [], previous]
+  });
+}
+var editDraft = (d, p) => revise(d, p, [], "Manual edit", true, "manual");
+var resetDraft = (s) => createDraft(s);
+var sourceChanged = (d, s) => d.sourceId !== s.sourceId || d.sourceRevision !== s.revision;
+function undoDraft(d) {
+  const previous = d.history?.at(-1);
+  if (!previous) return d;
+  return deepFreeze({
+    ...previous,
+    revision: d.revision + 1,
+    history: d.history.slice(0, -1)
+  });
+}
+function refreshDraft(draft, snapshot, choice) {
+  return choice === "keep" ? draft : createDraft(snapshot);
+}
+function applySectionSelection(d, s, ids) {
+  if (d.snapshotId !== s.id || d.sourceId !== s.sourceId || d.sourceRevision !== s.revision)
+    throw new ContentTransferError(
+      "snapshot-mismatch",
+      "Section selection requires the draft's captured source snapshot"
+    );
+  const selected = new Set(ids), omit = [], paths = s.sections.filter((x) => !selected.has(x.id)).map((x) => {
+    omit.push({ path: x.path, reason: "excluded" });
+    return x.path;
+  }), baseOmissions = s.omissions;
+  if (s.payload.kind === "json")
+    return revise(
+      d,
+      { kind: "json", value: without(s.payload.value, paths, []) ?? null },
+      omit,
+      "Selected sections",
+      d.manuallyEdited,
+      "deterministic",
+      baseOmissions
+    );
+  if (s.payload.kind === "registered")
+    return revise(
+      d,
+      {
+        kind: "registered",
+        format: s.payload.format,
+        value: without(s.payload.value, paths, []) ?? null
+      },
+      omit,
+      "Selected sections",
+      d.manuallyEdited,
+      "deterministic",
+      baseOmissions
+    );
+  return revise(
+    d,
+    s.payload,
+    omit,
+    "Selected sections",
+    d.manuallyEdited,
+    "deterministic",
+    baseOmissions
+  );
+}
+function transformRows(d, o) {
+  if (d.payload.kind !== "rows") return d;
+  if (o.top != null) assertLimit(o.top, "maxRows");
+  const cols = o.visibleColumns ? o.visibleColumns.map(
+    (id) => d.payload.kind === "rows" ? d.payload.columns.find((c) => c.id === id) : void 0
+  ).filter((c) => Boolean(c)) : d.payload.columns.filter((c) => c.visible);
+  const get = readTransferCell;
+  let rows = [...d.payload.rows], omit = [];
+  const before = rows.length;
+  if (o.selectedIndices !== void 0) {
+    const selected = /* @__PURE__ */ new Set();
+    for (const index of o.selectedIndices) {
+      if (!Number.isSafeInteger(index) || index < 0 || index >= d.payload.rows.length)
+        throw new ContentTransferError(
+          "invalid-selection-index",
+          "Selected row indexes must be non-negative positions in the input draft rows"
+        );
+      selected.add(index);
+    }
+    rows = d.payload.rows.filter((_, index) => selected.has(index));
+  }
+  if (o.selectedIds && o.idColumn) {
+    const set = new Set(o.selectedIds);
+    const idColumn = d.payload.columns.find((c) => c.id === o.idColumn);
+    rows = rows.filter(
+      (r) => set.has(String(idColumn ? get(r, idColumn) : r[o.idColumn]))
+    );
+  }
+  if (o.search) {
+    const q = o.search.toLowerCase();
+    rows = rows.filter(
+      (r) => cols.some(
+        (c) => String(get(r, c) ?? "").toLowerCase().includes(q)
+      )
+    );
+  }
+  for (const [id, q] of Object.entries(o.filters ?? {})) {
+    const c = cols.find((x) => x.id === id);
+    if (c)
+      rows = rows.filter(
+        (r) => String(get(r, c) ?? "").toLowerCase().includes(q.toLowerCase())
+      );
+  }
+  if (rows.length !== before)
+    omit.push({
+      path: "/rows",
+      reason: "filtered",
+      count: before - rows.length
+    });
+  if (o.sort) {
+    const c = cols.find((x) => x.id === o.sort.column);
+    if (c)
+      rows.sort((a, b) => {
+        const left = get(a, c);
+        const right = get(b, c);
+        const compare = typeof left === "number" && typeof right === "number" ? left - right : String(left ?? "").localeCompare(String(right ?? ""));
+        return compare * (o.sort.direction === "asc" ? 1 : -1);
+      });
+  }
+  if (o.top != null && rows.length > o.top) {
+    omit.push({
+      path: "/rows",
+      reason: "truncated",
+      count: rows.length - o.top
+    });
+    rows = rows.slice(0, o.top);
+  }
+  if (o.structuredProjection === "visible") {
+    rows = rows.map(
+      (r) => Object.fromEntries(cols.map((c) => [c.id, get(r, c) ?? null]))
+    );
+    omit.push({
+      path: "/columns",
+      reason: "excluded",
+      count: d.payload.columns.length - cols.length
+    });
+  }
+  return revise(
+    d,
+    {
+      kind: "rows",
+      rows,
+      columns: cols.map((c) => ({
+        ...c,
+        visible: true,
+        ...o.structuredProjection === "visible" ? { path: `/${enc(c.id)}` } : {}
+      }))
+    },
+    omit,
+    "Prepared row subset"
+  );
+}
+function reduceJson(draft, options) {
+  if (draft.payload.kind !== "json" && draft.payload.kind !== "registered")
+    return draft;
+  const omissions = [];
+  options.exclude?.forEach(validatePointer);
+  const filtered = without(clone(draft.payload.value), options.exclude ?? [], omissions) ?? null;
+  const payload = limitPayload(
+    { ...draft.payload, value: filtered },
+    options,
+    omissions
+  );
+  return revise(draft, payload, omissions, "Reduced JSON");
+}
+async function collectAllMatching(c, signal) {
+  const rows = [], omissions = [], ids = /* @__PURE__ */ new Set(), cursors = /* @__PURE__ */ new Set();
+  let cursor = null, token, last = {
+    status: "unknown",
+    included: 0,
+    total: null
+  };
+  let certifiedTotal;
+  const maxRows = c.limits?.maxRows;
+  if (maxRows != null) assertLimit(maxRows, "maxRows");
+  const finishAtLimit = (total, knownOmitted) => ({
+    rows: deepFreeze(rows),
+    omissions: deepFreeze([
+      ...omissions,
+      {
+        path: "/rows",
+        reason: "truncated",
+        ...knownOmitted === void 0 || knownOmitted <= 0 ? {} : { count: knownOmitted }
+      }
+    ]),
+    coverage: deepFreeze({
+      status: "partial",
+      included: rows.length,
+      total,
+      reason: "Source export limit applied"
+    })
+  });
+  try {
+    if (maxRows === 0) return finishAtLimit(null);
+    do {
+      stop(signal);
+      const page = await c.source.page({
+        query: c.source.query,
+        cursor,
+        consistencyToken: token ?? null,
+        signal
+      });
+      stop(signal);
+      if (token === void 0) token = page.consistencyToken;
+      else if (page.consistencyToken !== token)
+        throw new ContentTransferError(
+          "consistency-token-changed",
+          "All-matching export changed during collection"
+        );
+      if (page.coverage.included !== page.rows.length)
+        throw new ContentTransferError(
+          "invalid-page-coverage",
+          "Page count does not match returned rows"
+        );
+      if (page.coverage.total !== null && (!Number.isSafeInteger(page.coverage.total) || page.coverage.total < 0))
+        throw new ContentTransferError(
+          "invalid-page-coverage",
+          "Page total must be a non-negative integer or null"
+        );
+      if (certifiedTotal === void 0) certifiedTotal = page.coverage.total;
+      else if (page.coverage.total !== certifiedTotal)
+        throw new ContentTransferError(
+          "inconsistent-total",
+          "All-matching source changed its reported total during collection"
+        );
+      const projected = normalize(
+        { kind: "rows", rows: page.rows, columns: [...c.columns] },
+        c.projection,
+        omissions
+      ).rows;
+      let uniqueBeyondLimit = 0;
+      for (const row of projected) {
+        const id = c.source.getRowId(row);
+        if (!id)
+          throw new ContentTransferError(
+            "invalid-row-id",
+            "All-matching source returned empty projected ID"
+          );
+        if (!ids.has(id)) {
+          ids.add(id);
+          if (maxRows == null || rows.length < maxRows)
+            rows.push(
+              limitPayload(
+                { kind: "rows", rows: [row], columns: [...c.columns] },
+                { ...c.limits, maxRows: null },
+                omissions
+              ).rows[0]
+            );
+          else uniqueBeyondLimit += 1;
+        } else omissions.push({ path: `/rows/${enc(id)}`, reason: "duplicate" });
+      }
+      if (page.coverage.total !== null && page.coverage.total < ids.size)
+        throw new ContentTransferError(
+          "invalid-page-coverage",
+          "Page total is smaller than the accumulated unique row count"
+        );
+      last = page.coverage;
+      if (maxRows != null && rows.length >= maxRows && (uniqueBeyondLimit > 0 || page.nextCursor !== null))
+        return finishAtLimit(
+          page.coverage.total,
+          page.nextCursor === null ? uniqueBeyondLimit : page.coverage.total != null && page.coverage.total > rows.length ? page.coverage.total - rows.length : void 0
+        );
+      cursor = page.nextCursor;
+      if (cursor !== null && (!cursor || cursors.has(cursor)))
+        throw new ContentTransferError(
+          "non-advancing-cursor",
+          "All-matching source repeated a cursor"
+        );
+      if (cursor) cursors.add(cursor);
+    } while (cursor !== null);
+    const complete = c.source.stableSnapshot === true && last.status === "complete" && last.total === rows.length && token !== void 0;
+    return {
+      rows: deepFreeze(rows),
+      omissions: deepFreeze(omissions),
+      coverage: deepFreeze(
+        complete ? { ...last, included: rows.length } : {
+          ...last,
+          status: "partial",
+          included: rows.length,
+          reason: last.reason ?? "Source did not certify a stable complete snapshot"
+        }
+      )
+    };
+  } catch (e) {
+    const error = e instanceof ContentTransferError ? e : new ContentTransferError(
+      signal.aborted ? "cancelled" : "page-failed",
+      e instanceof Error ? e.message : "Page collection failed"
+    );
+    return {
+      rows: deepFreeze(rows),
+      omissions: deepFreeze(omissions),
+      coverage: deepFreeze({
+        status: "partial",
+        included: rows.length,
+        total: last.total,
+        reason: error.message
+      }),
+      error
+    };
+  }
+}
+var textValue = (value) => value === void 0 ? "" : typeof value === "string" ? value : stringifyJson(value, { style: "compact" });
+function sealTransferArtifact(artifact) {
+  if (!artifact.file)
+    return deepFreeze({
+      ...artifact,
+      omissions: artifact.omissions.map((o) => ({ ...o }))
+    });
+  const bytes = artifact.file.bytes.slice();
+  const file = {
+    filename: artifact.file.filename,
+    mime: artifact.file.mime,
+    get bytes() {
+      return bytes.slice();
+    }
+  };
+  return deepFreeze({
+    ...artifact,
+    file,
+    omissions: artifact.omissions.map((o) => ({ ...o }))
+  });
+}
+function serialize(draft, format, options = {}) {
+  const payload = draft.payload;
+  const omissions = draft.omissions.map((o) => ({ ...o }));
+  let plainText = "", html;
+  let mime = "text/plain;charset=utf-8", extension = "txt";
+  const columnCell = (row, column) => textValue(readTransferCell(row, column));
+  if ((format === "csv" || format === "tsv") && payload.kind !== "rows") {
+    throw new ContentTransferError(
+      "unsupported-format",
+      `${format.toUpperCase()} requires tabular data`
+    );
+  }
+  if (format === "json" || format === "compact-json") {
+    const value = payload.kind === "rows" ? payload.rows : payload.kind === "text" || payload.kind === "markdown" ? payload.text : payload.value;
+    plainText = stringifyJson(value, {
+      style: format === "json" ? "pretty" : "compact"
+    });
+    mime = "application/json;charset=utf-8";
+    extension = "json";
+  } else if (payload.kind === "rows") {
+    const columns = payload.columns.filter(
+      (c) => c.visible && c.exportable !== false && c.classification !== "secret" && c.classification !== "credential"
+    );
+    if (format === "markdown") {
+      const escapeCell = (value) => escapeHtml(value).replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r\n|\r|\n/g, "<br>");
+      plainText = [
+        `| ${columns.map((c) => escapeCell(c.label)).join(" | ")} |`,
+        `| ${columns.map(() => "---").join(" | ")} |`,
+        ...payload.rows.map(
+          (row) => `| ${columns.map((c) => escapeCell(columnCell(row, c))).join(" | ")} |`
+        )
+      ].join("\n");
+      mime = "text/markdown;charset=utf-8";
+      extension = "md";
+    } else {
+      const delimiter = format === "csv" ? "," : "	";
+      const safe = options.spreadsheetSafe ?? format === "tsv";
+      const encode = (value, path, isString = true) => {
+        let text = value;
+        if (safe && isString && /^[\t\r\n ]*[=+\-@]/.test(text)) {
+          text = `'${text}`;
+          omissions.push({ path, reason: "escaped", count: 1 });
+        }
+        return text.includes(delimiter) || /["\n\r]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+      };
+      plainText = [
+        columns.map((c) => encode(c.label, `/columns/${enc(c.id)}`)).join(delimiter),
+        ...payload.rows.map(
+          (row, index) => columns.map(
+            (c) => encode(
+              columnCell(row, c),
+              `/rows/${index}${c.path}`,
+              typeof readTransferCell(row, c) === "string"
+            )
+          ).join(delimiter)
+        )
+      ].join("\n");
+      if (format === "csv") {
+        mime = "text/csv;charset=utf-8";
+        extension = "csv";
+      }
+      if (format === "tsv") {
+        mime = "text/tab-separated-values;charset=utf-8";
+        extension = "tsv";
+      }
+    }
+    if (format === "html")
+      html = `<table><thead><tr>${columns.map((c) => `<th>${escapeHtml(c.label)}</th>`).join("")}</tr></thead><tbody>${payload.rows.map((row) => `<tr>${columns.map((c) => `<td>${escapeHtml(columnCell(row, c)).replace(/\r\n|\r|\n/g, "<br>")}</td>`).join("")}</tr>`).join("")}</tbody></table>`;
+  } else {
+    plainText = payload.kind === "text" || payload.kind === "markdown" ? payload.text : stringifyJson(payload.value, { style: "pretty" });
+    if (format === "markdown") {
+      mime = "text/markdown;charset=utf-8";
+      extension = "md";
+    }
+    if (format === "html") html = `<pre>${escapeHtml(plainText)}</pre>`;
+  }
+  if (format === "html") {
+    mime = "text/html;charset=utf-8";
+    extension = "html";
+  }
+  return sealTransferArtifact({
+    snapshotId: draft.snapshotId,
+    draftRevision: draft.revision,
+    format,
+    plainText,
+    ...html === void 0 ? {} : { html },
+    file: {
+      filename: options.filename ?? `export.${extension}`,
+      mime,
+      bytes: new TextEncoder().encode(
+        format === "html" ? html ?? plainText : plainText
+      )
+    },
+    omissions
+  });
+}
+async function renderMarkdownHtml(markdown) {
+  const [{ marked }, purify] = await Promise.all([
+    import("marked"),
+    import("dompurify")
+  ]);
+  const html = await marked.parse(markdown);
+  const api = purify.default;
+  if (typeof api === "function" && typeof window !== "undefined") {
+    const purifier = api(window);
+    if (typeof purifier?.sanitize === "function") return purifier.sanitize(html);
+  }
+  if (typeof api.sanitize === "function")
+    return api.sanitize(html);
+  throw new ContentTransferError(
+    "rich-html-unavailable",
+    "Rich Markdown HTML requires a DOMPurify DOM adapter"
+  );
+}
+async function serializeMarkdownRich(d, filename = "export.html") {
+  if (d.payload.kind !== "markdown")
+    throw new ContentTransferError(
+      "unsupported-format",
+      "Rich Markdown requires Markdown payload"
+    );
+  const html = await renderMarkdownHtml(d.payload.text);
+  return sealTransferArtifact({
+    snapshotId: d.snapshotId,
+    draftRevision: d.revision,
+    format: "html",
+    plainText: d.payload.text,
+    html,
+    file: {
+      filename,
+      mime: "text/html;charset=utf-8",
+      bytes: new TextEncoder().encode(html)
+    },
+    omissions: [...d.omissions]
+  });
+}
+function createBrowserTransport() {
+  return {
+    async copy(a, signal) {
+      const cancelled = () => signal.aborted ? { status: "cancelled" } : void 0;
+      try {
+        if (cancelled()) return cancelled();
+        const c = globalThis.navigator?.clipboard;
+        if (!c?.write && !c?.writeText)
+          return {
+            status: "error",
+            code: "clipboard-unavailable",
+            message: "Clipboard writing is unavailable",
+            retryable: false
+          };
+        if (a.html && c.write && typeof globalThis.ClipboardItem === "function") {
+          try {
+            await c.write([
+              new ClipboardItem({
+                "text/plain": new Blob([a.plainText], { type: "text/plain" }),
+                "text/html": new Blob([a.html], { type: "text/html" })
+              })
+            ]);
+            if (cancelled()) return cancelled();
+            return {
+              status: "success",
+              delivered: "clipboard",
+              mimeTypes: ["text/plain", "text/html"]
+            };
+          } catch {
+            if (cancelled()) return cancelled();
+          }
+        }
+        if (c.writeText) {
+          await c.writeText(a.plainText);
+          if (cancelled()) return cancelled();
+          return a.html ? {
+            status: "degraded",
+            delivered: "plain-text",
+            reason: "Rich clipboard write was unavailable or rejected"
+          } : {
+            status: "success",
+            delivered: "clipboard",
+            mimeTypes: ["text/plain"]
+          };
+        }
+        return {
+          status: "error",
+          code: "clipboard-rejected",
+          message: "Clipboard rejected the write",
+          retryable: true
+        };
+      } catch (e) {
+        return cancelled() ?? {
+          status: "error",
+          code: "clipboard-rejected",
+          message: e instanceof Error ? e.message : "Clipboard rejected the write",
+          retryable: true
+        };
+      }
+    },
+    async download(a, signal) {
+      if (signal.aborted) return { status: "cancelled" };
+      if (!a.file || typeof document === "undefined" || !URL?.createObjectURL)
+        return {
+          status: "error",
+          code: "download-unavailable",
+          message: "Download is unavailable",
+          retryable: false
+        };
+      let url;
+      try {
+        url = URL.createObjectURL(
+          new Blob([a.file.bytes.slice().buffer], {
+            type: a.file.mime
+          })
+        );
+        const link = document.createElement("a");
+        link.href = url;
+        link.download = a.file.filename;
+        link.click();
+        return signal.aborted ? { status: "cancelled" } : {
+          status: "success",
+          delivered: "download-started",
+          mimeTypes: [a.file.mime]
+        };
+      } catch (e) {
+        return signal.aborted ? { status: "cancelled" } : {
+          status: "error",
+          code: "download-failed",
+          message: e instanceof Error ? e.message : "Download failed",
+          retryable: true
+        };
+      } finally {
+        if (url) setTimeout(() => URL.revokeObjectURL(url), 0);
+      }
+    }
+  };
+}
+function assertLimit(value, name) {
+  if (value != null && (!Number.isSafeInteger(value) || value < 0)) {
+    throw new ContentTransferError(
+      "invalid-limit",
+      `${name} must be a non-negative safe integer or null`
+    );
+  }
+}
+var limitKeys = [
+  "maxRows",
+  "maxStringChars",
+  "maxDepth",
+  "maxArrayItems",
+  "targetTokens"
+];
+function resolveTransferPreferences(provider = {}, menu = {}, sourceLimits = {}) {
+  const limits = {
+    maxRows: null,
+    maxStringChars: null,
+    maxDepth: null,
+    maxArrayItems: null,
+    targetTokens: null
+  };
+  for (const key of limitKeys) {
+    const candidates = [
+      provider.limits?.[key],
+      menu.limits?.[key],
+      sourceLimits[key]
+    ];
+    candidates.forEach((value) => assertLimit(value, key));
+    const finite = candidates.filter((value) => value != null);
+    limits[key] = finite.length ? Math.min(...finite) : null;
+  }
+  return deepFreeze({
+    initialFormat: menu.initialFormat ?? provider.initialFormat ?? "plain",
+    initialPreset: menu.initialPreset ?? provider.initialPreset ?? "full",
+    limits
+  });
+}
+function cloneTransferRegistration(value, path = "registration", seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === null || typeof value !== "object" && typeof value !== "function")
+    return value;
+  if (typeof value === "function") return value;
+  if (seen.has(value))
+    throw new ContentTransferError(
+      "unsupported-registration-metadata",
+      "Circular transfer registration metadata is unsupported",
+      path
+    );
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const copy2 = value.map(
+      (item, index) => cloneTransferRegistration(item, `${path}/${index}`, seen)
+    );
+    seen.delete(value);
+    return Object.freeze(copy2);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null)
+    throw new ContentTransferError(
+      "unsupported-registration-metadata",
+      "Transfer registration metadata must use plain objects and arrays",
+      path
+    );
+  const copy = Object.create(prototype);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!("value" in descriptor))
+      throw new ContentTransferError(
+        "unsupported-registration-metadata",
+        "Transfer registration metadata cannot use accessors",
+        `${path}/${String(key)}`
+      );
+    Object.defineProperty(copy, key, {
+      value: cloneTransferRegistration(
+        descriptor.value,
+        `${path}/${String(key)}`,
+        seen
+      ),
+      enumerable: descriptor.enumerable === true,
+      writable: false,
+      configurable: false
+    });
+  }
+  seen.delete(value);
+  return Object.freeze(copy);
+}
+function resolveTransferRegistry(...groups) {
+  const ids = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const group of groups)
+    for (const item of group) {
+      const copy = cloneTransferRegistration(item);
+      if (!copy.id.trim() || ids.has(copy.id))
+        throw new ContentTransferError(
+          "duplicate-registration",
+          `Transfer id ${JSON.stringify(copy.id)} is empty or registered more than once`
+        );
+      ids.add(copy.id);
+      result.push(copy);
+    }
+  return Object.freeze(result);
+}
+function createSurfaceTransferHandle(options) {
+  const declarations = resolveTransferRegistry(
+    options.manifest.values.map((value) => ({ ...value, id: value.name }))
+  );
+  return {
+    instanceId: options.instanceId,
+    surfaceName: options.manifest.surfaceName,
+    isMounted: options.isMounted,
+    async capture(signal) {
+      stop(signal);
+      if (!options.isMounted())
+        throw new ContentTransferError(
+          "surface-unmounted",
+          "The captured surface is no longer mounted"
+        );
+      const revisionBefore = options.getRevision?.();
+      const scope = await options.getScope();
+      stop(signal);
+      if (!options.isMounted())
+        throw new ContentTransferError(
+          "surface-unmounted",
+          "The surface closed during capture"
+        );
+      if (revisionBefore !== void 0 && options.getRevision?.() !== revisionBefore)
+        throw new ContentTransferError(
+          "surface-changed",
+          "The surface changed during capture; capture again"
+        );
+      const value = {};
+      for (const declaration of declarations) {
+        if (Object.hasOwn(scope, declaration.name) && scope[declaration.name] !== void 0) {
+          Object.defineProperty(value, declaration.name, {
+            value: cloneSurfaceValue(
+              scope[declaration.name],
+              `/${enc(declaration.name)}`
+            ),
+            enumerable: true,
+            writable: true,
+            configurable: true
+          });
+        }
+      }
+      return directSource(
+        { kind: "json", value },
+        {
+          sourceId: options.instanceId,
+          revision: revisionBefore ?? uid(),
+          label: options.manifest.label ?? options.manifest.surfaceName,
+          unsavedChanges: options.unsavedChanges?.() ?? false,
+          sections: declarations.filter((d) => Object.hasOwn(value, d.name)).map((d) => ({
+            id: d.name,
+            label: d.label,
+            path: `/${enc(d.name)}`,
+            includedByDefault: d.includedByDefault ?? true
+          })),
+          projection: {
+            rules: [
+              ...options.projection?.rules ?? [],
+              ...declarations.map((d) => ({
+                target: "payload",
+                path: `/${enc(d.name)}`,
+                exportable: d.exportable ?? true,
+                classification: d.classification ?? "ordinary"
+              }))
+            ]
+          },
+          ...options.limits ? { limits: options.limits } : {}
+        }
+      );
+    }
+  };
+}
+function limitJson(value, limits, omissions, path = "", depth = 0) {
+  if (limits.maxDepth != null && depth > limits.maxDepth) {
+    omissions.push({ path, reason: "truncated" });
+    return null;
+  }
+  if (typeof value === "string" && limits.maxStringChars != null && Array.from(value).length > limits.maxStringChars) {
+    const chars = Array.from(value);
+    omissions.push({
+      path,
+      reason: "truncated",
+      count: chars.length - limits.maxStringChars
+    });
+    return chars.slice(0, limits.maxStringChars).join("");
+  }
+  if (Array.isArray(value)) {
+    const count = Math.min(value.length, limits.maxArrayItems ?? value.length);
+    if (count < value.length)
+      omissions.push({
+        path,
+        reason: "truncated",
+        count: value.length - count
+      });
+    return value.slice(0, count).map(
+      (item, index) => limitJson(item, limits, omissions, `${path}/${index}`, depth + 1)
+    );
+  }
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [
+        key,
+        limitJson(item, limits, omissions, `${path}/${enc(key)}`, depth + 1)
+      ])
+    );
+  return value;
+}
+function limitPayload(payload, limits, omissions) {
+  limitKeys.forEach((key) => assertLimit(limits[key], key));
+  if (payload.kind === "rows") {
+    const count = Math.min(
+      payload.rows.length,
+      limits.maxRows ?? payload.rows.length
+    );
+    if (count < payload.rows.length)
+      omissions.push({
+        path: "/rows",
+        reason: "truncated",
+        count: payload.rows.length - count
+      });
+    return {
+      ...payload,
+      rows: payload.rows.slice(0, count).map(
+        (row, index) => limitJson(row, limits, omissions, `/rows/${index}`)
+      )
+    };
+  }
+  if (payload.kind === "json" || payload.kind === "registered")
+    return { ...payload, value: limitJson(payload.value, limits, omissions) };
+  return {
+    ...payload,
+    text: limitJson(payload.text, limits, omissions)
+  };
+}
+function applyTransferLimits(draft, limits) {
+  const omissions = [];
+  const payload = limitPayload(draft.payload, limits, omissions);
+  return omissions.length ? revise(draft, payload, omissions, "Applied preparation limits") : draft;
+}
 export {
+  ContentTransferError,
   DBStoreManager,
   DEFAULT_JSON_INDENT,
   DEFAULT_JSON_WIDTH,
@@ -2727,19 +3905,30 @@ export {
   FeatureStore,
   PublicStoreManager,
   _resetIdbStoreSingletons,
+  applySectionSelection,
+  applyTransferLimits,
   booleanUrlCodec,
+  buildAgentPayload,
+  capture,
   captureDrafts,
+  collectAllMatching,
   commitUrlParams,
   computeSearchScore,
+  createBrowserTransport,
   createColorNormalizer,
+  createDraft,
   createFormatter,
   createMatrxToast,
+  createSurfaceTransferHandle,
   decodeQrFromElement,
   decodeQrFromImageData,
   decodeQrFromImageFile,
   detectJson,
+  directSource,
   discardDraft,
+  editDraft,
   enumUrlCodec,
+  fenceJsonBlock,
   filterAndSortBySearch,
   findNearestTailwindColor,
   fireInvalidation,
@@ -2783,23 +3972,38 @@ export {
   jsonUrlCodec,
   listDrafts,
   matchesSearch,
+  normalizeTransferJson,
   onFlushComplete,
   parseHexOrRgb,
   positiveIntegerUrlCodec,
+  projectSnapshot,
+  readTransferCell,
+  reduceJson,
+  refreshDraft,
   registerDraftSource,
   registerIdleTask,
   registerInvalidationCallback,
+  renderMarkdownHtml,
   reportDelimiterViolations,
+  resetDraft,
   resetScheduler,
+  resolveTransferPreferences,
+  resolveTransferRegistry,
   rgbDelta,
   rgbToLab,
   runWithConcurrency,
+  sealTransferArtifact,
+  serialize,
+  serializeMarkdownRich,
   setUrlStateRouter,
+  sourceChanged,
   stringUrlCodec,
   stringifyJson,
   subscribeDrafts,
   tailwindColors,
+  transformRows,
   treeContainsComponent,
+  undoDraft,
   useAutosave,
   useClipboard,
   useDurableDraft,