@ai-matrx/alchemy 0.6.2 → 0.8.2

package/dist/index.cjs

@@ -1,8 +1,17 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -11,11 +20,1757 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/operate/types.ts
+var init_types = __esm({
+  "src/operate/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/operate/fenced-code.ts
+function fencedCodeBlock(text, language) {
+  const runs = text.match(/`+/g) ?? [];
+  const fence = "`".repeat(Math.max(3, ...runs.map((run) => run.length + 1)));
+  return `${fence}${language}
+${text}${text.endsWith("\n") ? "" : "\n"}${fence}`;
+}
+var init_fenced_code = __esm({
+  "src/operate/fenced-code.ts"() {
+    "use strict";
+  }
+});
+
+// src/operate/agent-payload.ts
+function fenceJsonBlock(json) {
+  return fencedCodeBlock(json.trimEnd(), "json");
+}
+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}>`;
+}
+var escapeXml, xmlName, presentEntries;
+var init_agent_payload = __esm({
+  "src/operate/agent-payload.ts"() {
+    "use strict";
+    init_fenced_code();
+    escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+    xmlName = (name) => {
+      if (!/^[A-Za-z_][A-Za-z0-9_.-]*$/.test(name)) throw new Error(`Invalid AI envelope name: ${name}`);
+      return name;
+    };
+    presentEntries = (values) => Object.entries(values ?? {}).filter(([, value]) => value !== null && value !== void 0 && value !== "");
+  }
+});
+
+// src/operate/core.ts
+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;
+}
+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 normalizeTransferJsonAtPath(value, path, {
+      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 normalizeTransferJsonAtPath(value, path, options = {}) {
+  return clone(value, path, /* @__PURE__ */ new WeakSet(), options);
+}
+function normalizeTransferJson(value, options = {}) {
+  return normalizeTransferJsonAtPath(value, "", options);
+}
+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 excludedColumn(column) {
+  return column.exportable === false || column.classification === "secret" || column.classification === "credential";
+}
+function rowProjectionExcludesColumnSchema(column, rules) {
+  return rules.some(
+    (rule) => rule.target === "row" && (!rule.exportable || rule.classification !== "ordinary") && (rule.path === column.path || column.path.startsWith(`${rule.path}/`))
+  );
+}
+function projectColumnSchema(column, rules, omit) {
+  if (column.schema === void 0) return void 0;
+  const root = `/columns/${enc(column.id)}/schema`;
+  const schemaRules = rules.filter((rule) => rule.target === "payload" && (rule.path === root || rule.path.startsWith(`${root}/`))).map((rule) => ({ ...rule, path: rule.path.slice(root.length) }));
+  const projected = projectValue(column.schema, schemaRules, "payload", omit);
+  if (schemaRules.some((rule) => rule.path === "" && (!rule.exportable || rule.classification !== "ordinary")))
+    return void 0;
+  return projected;
+}
+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);
+    const text = typeof value === "string" ? value : "";
+    return p.kind === "text" && typeof p.language === "string" && p.language.trim() ? { kind: "text", text, language: p.language.trim() } : { kind: p.kind, text };
+  }
+  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 sourceColumns = rowsPayload.columns.map((column) => ({ ...column }));
+  const columns = sourceColumns.filter((column) => !excludedColumn(column)).map((column) => {
+    const { schema: _sourceSchema, ...withoutSchema } = column;
+    const schema = rowProjectionExcludesColumnSchema(column, projection.rules) ? void 0 : projectColumnSchema(column, projection.rules, omit);
+    return {
+      ...withoutSchema,
+      ...schema === void 0 ? {} : { schema }
+    };
+  });
+  resolveTransferRegistry(columns);
+  columns.forEach((column) => validatePointer(column.path));
+  const rules = [
+    ...projection.rules,
+    ...sourceColumns.filter(excludedColumn).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 } } : {}
+  });
+}
+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 })) },
+      // Page rows must be normalized against the original declaration so excluded
+      // column values are removed before stable IDs or any caller can observe them.
+      columns: captured.snapshot.payload.kind === "rows" ? captured.snapshot.payload.columns.map((column) => ({ ...column })) : [],
+      ...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]
+  });
+}
+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]))
+    );
+    const excludedColumns = d.payload.columns.length - cols.length;
+    if (excludedColumns > 0)
+      omit.push({
+        path: "/columns",
+        reason: "excluded",
+        count: excludedColumns
+      });
+  }
+  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
+    };
+  }
+}
+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 = (0, import_json_format.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) => (0, import_html_escape.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>${(0, import_html_escape.escapeHtml)(c.label)}</th>`).join("")}</tr></thead><tbody>${payload.rows.map((row) => `<tr>${columns.map((c) => `<td>${(0, import_html_escape.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 : (0, import_json_format.stringifyJson)(payload.value, { style: "pretty" });
+    if (format === "markdown") {
+      mime = "text/markdown;charset=utf-8";
+      extension = "md";
+    }
+    if (format === "html") html = `<pre>${(0, import_html_escape.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
+  });
+}
+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`
+    );
+  }
+}
+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 isReactElementType(value) {
+  const tag = value.$$typeof;
+  return typeof tag === "symbol";
+}
+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 (isReactElementType(value)) 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;
+}
+var import_json_format, import_html_escape, TRANSFER_ERROR, ContentTransferError, bound, stop, enc, dec, maxSurfacePointerSegmentLength, maxSurfacePointerLength, truncateSurfacePointer, uid, editDraft, resetDraft, sourceChanged, textValue, limitKeys;
+var init_core = __esm({
+  "src/operate/core.ts"() {
+    "use strict";
+    import_json_format = require("@ai-matrx/kit/json-format");
+    import_html_escape = require("@ai-matrx/kit/html-escape");
+    init_types();
+    init_agent_payload();
+    TRANSFER_ERROR = /* @__PURE__ */ Symbol.for("ai-matrx.alchemy.operate.transfer-error");
+    ContentTransferError = class extends Error {
+      code;
+      path;
+      constructor(code, message, path) {
+        super(message);
+        this.code = code;
+        this.path = path;
+        this[TRANSFER_ERROR] = true;
+      }
+      /**
+       * One error class across every loaded copy: while `@ai-matrx/kit/content-transfer`
+       * still bundles this module for its not-yet-repointed consumers (ALC-16), an
+       * error raised by one copy is `instanceof` the other.
+       */
+      static [Symbol.hasInstance](value) {
+        return typeof value === "object" && value !== null && value[TRANSFER_ERROR] === true;
+      }
+    };
+    bound = /* @__PURE__ */ Symbol.for("ai-matrx.alchemy.operate.bound-all-matching");
+    stop = (s) => {
+      if (s.aborted) throw new DOMException("Cancelled", "AbortError");
+    };
+    enc = (x) => x.replace(/~/g, "~0").replace(/\//g, "~1");
+    dec = (x) => x.replace(/~1/g, "/").replace(/~0/g, "~");
+    maxSurfacePointerSegmentLength = 64;
+    maxSurfacePointerLength = 192;
+    truncateSurfacePointer = (value, maxLength) => {
+      const characters = Array.from(value);
+      return characters.length > maxLength ? `${characters.slice(0, maxLength - 1).join("")}\u2026` : value;
+    };
+    uid = () => globalThis.crypto?.randomUUID?.() ?? `capture-${Date.now()}-${Math.random()}`;
+    editDraft = (d, p) => revise(d, p, [], "Manual edit", true, "manual");
+    resetDraft = (s) => createDraft(s);
+    sourceChanged = (d, s) => d.sourceId !== s.sourceId || d.sourceRevision !== s.revision;
+    textValue = (value) => value === void 0 || value === null ? "" : typeof value === "string" ? value : (0, import_json_format.stringifyJson)(value, { style: "compact" });
+    limitKeys = [
+      "maxRows",
+      "maxStringChars",
+      "maxDepth",
+      "maxArrayItems",
+      "targetTokens"
+    ];
+  }
+});
+
+// src/operate/formats/rich-html.ts
+var rich_html_exports = {};
+__export(rich_html_exports, {
+  loadMarkdownHtmlEngine: () => loadMarkdownHtmlEngine,
+  markdownPlainText: () => markdownPlainText,
+  richHtmlEngine: () => richHtmlEngine
+});
+async function loadMarkdownHtmlEngine() {
+  const g = globalThis;
+  g[ENGINE] ??= import("@ai-matrx/print/markdown-html").then((m) => m.createMarkdownHtmlEngine());
+  return g[ENGINE];
+}
+function parseOptions(options, signal) {
+  return {
+    signal,
+    ...options.onNotice ? { onNotice: options.onNotice } : {},
+    ...options.assets ? { assets: options.assets } : {}
+  };
+}
+async function markdownPlainText(markdown, options, signal) {
+  const engine = await loadMarkdownHtmlEngine();
+  return engine.plainText(await engine.parse(markdown, parseOptions(options, signal)));
+}
+var ENGINE, richHtmlEngine;
+var init_rich_html = __esm({
+  "src/operate/formats/rich-html.ts"() {
+    "use strict";
+    init_core();
+    ENGINE = /* @__PURE__ */ Symbol.for("ai-matrx.alchemy.operate.markdown-html-engine");
+    richHtmlEngine = {
+      async build(draft, options, signal) {
+        if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+        if (draft.payload.kind !== "markdown") {
+          throw new ContentTransferError("unsupported-format", "Formatted copy needs Markdown content. Copy it as plain text instead.");
+        }
+        const engine = await loadMarkdownHtmlEngine();
+        const tree = await engine.parse(draft.payload.text, parseOptions(options, signal));
+        if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+        const html = engine.fragment(tree, { skin: options.skin ?? "inline", profile: options.profile ?? "generic" });
+        return sealTransferArtifact({
+          snapshotId: draft.snapshotId,
+          draftRevision: draft.revision,
+          format: "rich-html",
+          plainText: engine.plainText(tree),
+          html,
+          file: { filename: options.filename ?? "export.html", mime: "text/html;charset=utf-8", bytes: new TextEncoder().encode(html) },
+          omissions: draft.omissions.map((o) => ({ ...o }))
+        });
+      }
+    };
+  }
+});
+
+// src/operate/formats/document.ts
+var document_exports = {};
+__export(document_exports, {
+  documentEngine: () => documentEngine,
+  documentHtmlEngine: () => documentHtmlEngine
+});
+function markdownOf(draft) {
+  const p = draft.payload;
+  if (p.kind === "markdown") return p.text;
+  if (p.kind === "text") {
+    if (!p.language) return p.text;
+    return fencedCodeBlock(p.text, p.language);
+  }
+  throw new ContentTransferError("unsupported-format", "A document needs text or Markdown content. Download it as JSON or CSV instead.");
+}
+function documentEngine(format) {
+  return {
+    async build(draft, options, signal) {
+      if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+      const source = markdownOf(draft);
+      const { exportDocument } = await import("@ai-matrx/print/document");
+      const name = stem(options.filename);
+      const out = await exportDocument(source, format, {
+        ...name ? { fileName: name } : {},
+        ...options.onNotice ? { onNotice: (n) => options.onNotice?.({ code: n.code, sentence: n.message, remedy: n.remedy }) } : {}
+      });
+      if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+      return sealTransferArtifact({
+        snapshotId: draft.snapshotId,
+        draftRevision: draft.revision,
+        format,
+        plainText: source,
+        file: { filename: out.fileName, mime: out.mime, bytes: out.bytes },
+        omissions: draft.omissions.map((o) => ({ ...o }))
+      });
+    }
+  };
+}
+var enc2, stem, documentHtmlEngine;
+var init_document = __esm({
+  "src/operate/formats/document.ts"() {
+    "use strict";
+    init_core();
+    init_fenced_code();
+    init_rich_html();
+    enc2 = new TextEncoder();
+    stem = (filename) => filename ? filename.replace(/\.[a-z0-9]+$/i, "") : void 0;
+    documentHtmlEngine = {
+      async build(draft, options, signal) {
+        if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+        const engine = await loadMarkdownHtmlEngine();
+        const tree = await engine.parse(markdownOf(draft), {
+          signal,
+          ...options.onNotice ? { onNotice: options.onNotice } : {},
+          ...options.assets ? { assets: options.assets } : {}
+        });
+        const page = engine.document(tree);
+        return sealTransferArtifact({
+          snapshotId: draft.snapshotId,
+          draftRevision: draft.revision,
+          format: "html",
+          plainText: engine.plainText(tree),
+          html: page,
+          file: { filename: options.filename ?? "export.html", mime: "text/html;charset=utf-8", bytes: enc2.encode(page) },
+          omissions: draft.omissions.map((o) => ({ ...o }))
+        });
+      }
+    };
+  }
+});
+
+// src/operate/formats/xlsx.ts
+var xlsx_exports = {};
+__export(xlsx_exports, {
+  xlsxEngine: () => xlsxEngine
+});
+var cell, xlsxEngine;
+var init_xlsx = __esm({
+  "src/operate/formats/xlsx.ts"() {
+    "use strict";
+    init_core();
+    cell = (value) => value === void 0 || value === null ? null : typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : JSON.stringify(value);
+    xlsxEngine = {
+      async build(draft, options, signal) {
+        if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+        const p = draft.payload;
+        if (p.kind !== "rows") throw new ContentTransferError("unsupported-format", "An Excel workbook needs table rows. Download it as CSV or JSON instead.");
+        const columns = p.columns.filter(
+          (c) => c.visible && c.exportable !== false && c.classification !== "secret" && c.classification !== "credential"
+        );
+        const XLSX = await import("xlsx");
+        if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+        const sheet = XLSX.utils.aoa_to_sheet([columns.map((c) => c.label), ...p.rows.map((row) => columns.map((c) => cell(readTransferCell(row, c))))]);
+        const book = XLSX.utils.book_new();
+        const filename = options.filename ?? "export.xlsx";
+        const sheetName = filename.replace(/\.xlsx$/i, "").replace(/[\\/?*[\]:]/g, " ").trim().slice(0, 31) || "Data";
+        XLSX.utils.book_append_sheet(book, sheet, sheetName);
+        const written = XLSX.write(book, { type: "array", bookType: "xlsx", compression: true });
+        return sealTransferArtifact({
+          snapshotId: draft.snapshotId,
+          draftRevision: draft.revision,
+          format: "xlsx",
+          plainText: serialize(draft, "tsv", { spreadsheetSafe: true }).plainText,
+          file: {
+            filename,
+            mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            bytes: written instanceof Uint8Array ? written : new Uint8Array(written)
+          },
+          omissions: draft.omissions.map((o) => ({ ...o }))
+        });
+      }
+    };
+  }
+});
+
 // src/index.ts
 var src_exports = {};
+__export(src_exports, {
+  ContentTransferError: () => ContentTransferError,
+  FORMAT_ADAPTERS: () => FORMAT_ADAPTERS,
+  applySectionSelection: () => applySectionSelection,
+  applyTransferLimits: () => applyTransferLimits,
+  buildAgentPayload: () => buildAgentPayload,
+  capture: () => capture,
+  collectAllMatching: () => collectAllMatching,
+  createBrowserTransport: () => createBrowserTransport,
+  createDelivery: () => createDelivery,
+  createDraft: () => createDraft,
+  createSurfaceTransferHandle: () => createSurfaceTransferHandle,
+  directSource: () => directSource,
+  editDraft: () => editDraft,
+  eligibleFormats: () => eligibleFormats,
+  extensionForLanguage: () => extensionForLanguage,
+  fenceJsonBlock: () => fenceJsonBlock,
+  formatAdapter: () => formatAdapter,
+  isSealed: () => isSealed,
+  normalizeTransferJson: () => normalizeTransferJson,
+  openPreparation: () => openPreparation,
+  projectSnapshot: () => projectSnapshot,
+  readTransferCell: () => readTransferCell,
+  reduceJson: () => reduceJson,
+  refreshDraft: () => refreshDraft,
+  resetDraft: () => resetDraft,
+  resolveTransferPreferences: () => resolveTransferPreferences,
+  resolveTransferRegistry: () => resolveTransferRegistry,
+  sealArtifact: () => sealArtifact,
+  sealDraft: () => sealDraft,
+  sealTransferArtifact: () => sealTransferArtifact,
+  serialize: () => serialize,
+  sourceChanged: () => sourceChanged,
+  transformRows: () => transformRows,
+  undoDraft: () => undoDraft
+});
 module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("@ai-matrx/kit/content-transfer"), module.exports);
+
+// src/operate.ts
+init_core();
+
+// src/operate/formats.ts
+init_core();
+init_fenced_code();
+var enc3 = new TextEncoder();
+var isRows = (p) => p.kind === "rows";
+var isProse = (p) => p.kind === "markdown" || p.kind === "text";
+var always = () => true;
+var LANGUAGE_EXTENSION = {
+  typescript: "ts",
+  ts: "ts",
+  tsx: "tsx",
+  javascript: "js",
+  js: "js",
+  jsx: "jsx",
+  python: "py",
+  py: "py",
+  json: "json",
+  html: "html",
+  css: "css",
+  sql: "sql",
+  bash: "sh",
+  sh: "sh",
+  shell: "sh",
+  zsh: "sh",
+  yaml: "yaml",
+  yml: "yaml",
+  markdown: "md",
+  md: "md",
+  go: "go",
+  rust: "rs",
+  java: "java",
+  ruby: "rb",
+  php: "php",
+  csharp: "cs",
+  cs: "cs",
+  cpp: "cpp",
+  c: "c",
+  swift: "swift",
+  kotlin: "kt",
+  xml: "xml",
+  toml: "toml"
+};
+function extensionForLanguage(language) {
+  return language && LANGUAGE_EXTENSION[language.trim().toLowerCase()] || "txt";
+}
+function checkSignal(signal) {
+  if (signal.aborted) throw new DOMException("Cancelled", "AbortError");
+}
+function textArtifact(draft, format, text, mime, filename, html) {
+  return sealTransferArtifact({
+    snapshotId: draft.snapshotId,
+    draftRevision: draft.revision,
+    format,
+    plainText: text,
+    ...html === void 0 ? {} : { html },
+    file: { filename, mime, bytes: enc3.encode(html ?? text) },
+    omissions: draft.omissions.map((o) => ({ ...o }))
+  });
+}
+function serialized(format, extension) {
+  return {
+    async build(draft, options, signal) {
+      checkSignal(signal);
+      const a = serialize(draft, format, {
+        filename: options.filename ?? `export.${extension}`,
+        ...options.spreadsheetSafe === void 0 ? { spreadsheetSafe: format === "csv" || format === "tsv" } : { spreadsheetSafe: options.spreadsheetSafe }
+      });
+      return a;
+    }
+  };
+}
+var plainEngine = {
+  async build(draft, options, signal) {
+    checkSignal(signal);
+    if (draft.payload.kind === "markdown") {
+      const { markdownPlainText: markdownPlainText2 } = await Promise.resolve().then(() => (init_rich_html(), rich_html_exports));
+      const text = await markdownPlainText2(draft.payload.text, options, signal);
+      return textArtifact(draft, "plain", text, "text/plain;charset=utf-8", options.filename ?? "export.txt");
+    }
+    const ext = draft.payload.kind === "text" ? extensionForLanguage(draft.payload.language) : "txt";
+    const a = serialize(draft, "plain", { filename: options.filename ?? `export.${ext}` });
+    return a;
+  }
+};
+var markdownEngine = {
+  async build(draft, options, signal) {
+    checkSignal(signal);
+    const p = draft.payload;
+    if (p.kind === "text" && p.language) {
+      const text = fencedCodeBlock(p.text, p.language);
+      return textArtifact(draft, "markdown", text, "text/markdown;charset=utf-8", options.filename ?? "export.md");
+    }
+    return serialize(draft, "markdown", { filename: options.filename ?? "export.md" });
+  }
+};
+var htmlEngine = {
+  async build(draft, options, signal) {
+    checkSignal(signal);
+    if (isProse(draft.payload)) {
+      const { documentHtmlEngine: documentHtmlEngine2 } = await Promise.resolve().then(() => (init_document(), document_exports));
+      return documentHtmlEngine2.build(draft, options, signal);
+    }
+    return serialize(draft, "html", { filename: options.filename ?? "export.html" });
+  }
+};
+var lazy = (pick) => pick;
+var FORMAT_ADAPTERS = Object.freeze([
+  { id: "plain", label: "Plain text", extension: "txt", mime: "text/plain;charset=utf-8", modes: ["copy", "download"], runsOn: "client", supports: always, load: async () => plainEngine },
+  { id: "markdown", label: "Markdown", extension: "md", mime: "text/markdown;charset=utf-8", modes: ["copy", "download"], runsOn: "client", supports: (p) => p.kind !== "json" && p.kind !== "registered", load: async () => markdownEngine },
+  {
+    // Google Docs and Word are ONE action until a destination profile produces different bytes (1.9a).
+    id: "rich-html",
+    label: "Copy formatted",
+    extension: "html",
+    mime: "text/html;charset=utf-8",
+    modes: ["copy"],
+    runsOn: "client",
+    supports: (p) => p.kind === "markdown",
+    load: lazy(async () => (await Promise.resolve().then(() => (init_rich_html(), rich_html_exports))).richHtmlEngine)
+  },
+  { id: "html", label: "HTML page", extension: "html", mime: "text/html;charset=utf-8", modes: ["copy", "download"], runsOn: "client", supports: (p) => p.kind !== "registered", load: async () => htmlEngine },
+  { id: "json", label: "JSON", extension: "json", mime: "application/json;charset=utf-8", modes: ["copy", "download"], runsOn: "client", supports: (p) => p.kind !== "registered", load: async () => serialized("json", "json") },
+  { id: "compact-json", label: "Compact JSON", extension: "json", mime: "application/json;charset=utf-8", modes: ["copy", "download"], runsOn: "client", supports: (p) => p.kind !== "registered", load: async () => serialized("compact-json", "json") },
+  { id: "csv", label: "CSV", extension: "csv", mime: "text/csv;charset=utf-8", modes: ["copy", "download"], runsOn: "client", supports: isRows, load: async () => serialized("csv", "csv") },
+  { id: "tsv", label: "Google Sheets", extension: "tsv", mime: "text/tab-separated-values;charset=utf-8", modes: ["copy", "download"], runsOn: "client", supports: isRows, load: async () => serialized("tsv", "tsv") },
+  {
+    id: "xlsx",
+    label: "Excel workbook",
+    extension: "xlsx",
+    mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    modes: ["download"],
+    runsOn: "client",
+    supports: isRows,
+    load: lazy(async () => (await Promise.resolve().then(() => (init_xlsx(), xlsx_exports))).xlsxEngine)
+  },
+  {
+    id: "pdf",
+    label: "PDF",
+    extension: "pdf",
+    mime: "application/pdf",
+    modes: ["download"],
+    runsOn: "client",
+    supports: isProse,
+    load: lazy(async () => (await Promise.resolve().then(() => (init_document(), document_exports))).documentEngine("pdf"))
+  },
+  {
+    id: "docx",
+    label: "Word document",
+    extension: "docx",
+    mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    modes: ["download"],
+    runsOn: "client",
+    supports: isProse,
+    load: lazy(async () => (await Promise.resolve().then(() => (init_document(), document_exports))).documentEngine("docx"))
+  },
+  {
+    id: "epub",
+    label: "EPUB book",
+    extension: "epub",
+    mime: "application/epub+zip",
+    modes: ["download"],
+    runsOn: "client",
+    supports: isProse,
+    load: lazy(async () => (await Promise.resolve().then(() => (init_document(), document_exports))).documentEngine("epub"))
+  }
+]);
+function eligibleFormats(payload, registered = [], mode) {
+  return resolveTransferRegistry(FORMAT_ADAPTERS, registered).filter(
+    (f) => f.supports(payload) && (mode === void 0 || f.modes.includes(mode))
+  );
+}
+function formatAdapter(id, registered = []) {
+  const found = resolveTransferRegistry(FORMAT_ADAPTERS, registered).find((f) => f.id === id);
+  if (!found) throw new ContentTransferError("unsupported-format", `There is no "${id}" format. Choose one of the formats offered for this content.`);
+  return found;
+}
+
+// src/operate/preparation.ts
+init_core();
+var SEALED = /* @__PURE__ */ Symbol.for("ai-matrx.alchemy.operate.sealed-artifacts");
+function sealedSet() {
+  const g = globalThis;
+  g[SEALED] ??= /* @__PURE__ */ new WeakSet();
+  return g[SEALED];
+}
+function sealArtifact(artifact) {
+  const frozen = sealTransferArtifact(artifact);
+  sealedSet().add(frozen);
+  return frozen;
+}
+function isSealed(artifact) {
+  return typeof artifact === "object" && artifact !== null && sealedSet().has(artifact);
+}
+var notSealed = {
+  status: "error",
+  code: "not-sealed",
+  message: "This content was not prepared for delivery, so nothing was copied or saved. Prepare it again and retry.",
+  retryable: true
+};
+var optionsKey = (o) => JSON.stringify({ f: o.filename ?? null, s: o.spreadsheetSafe ?? null, k: o.skin ?? null, p: o.profile ?? null, h: o.highlightCode ?? false });
+async function openPreparation(source, scope, signal, options = {}) {
+  const { snapshot } = await capture(source, signal, scope);
+  let draft = createDraft(snapshot);
+  const transforms = /* @__PURE__ */ new Map();
+  for (const t of options.transforms ?? []) {
+    if (transforms.has(t.id)) throw new ContentTransferError("duplicate-registration", `Transform "${t.id}" is registered more than once`);
+    transforms.set(t.id, t);
+  }
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    get snapshot() {
+      return snapshot;
+    },
+    get draft() {
+      return draft;
+    },
+    async transform(id, transformOptions, transformSignal) {
+      const t = transforms.get(id);
+      if (!t) throw new ContentTransferError("unsupported-transform", `There is no "${id}" preparation step here.`);
+      draft = await t.apply(draft, transformOptions, transformSignal);
+      return draft;
+    },
+    edit(payload) {
+      draft = editDraft(draft, payload);
+      return draft;
+    },
+    selectSections(ids) {
+      draft = applySectionSelection(draft, snapshot, ids);
+      return draft;
+    },
+    undo() {
+      draft = undoDraft(draft);
+      return draft;
+    },
+    seal(format, formatOptions, sealSignal) {
+      const adapter = formatAdapter(format, options.formats);
+      if (!adapter.supports(draft.payload)) {
+        return Promise.reject(new ContentTransferError("unsupported-format", `${adapter.label} is not available for this content.`));
+      }
+      const key = `${draft.revision}\0${format}\0${optionsKey(formatOptions)}`;
+      const hit = cache.get(key);
+      if (hit) return hit;
+      const at2 = draft;
+      const built = adapter.load().then((engine) => engine.build(at2, formatOptions, sealSignal)).then(sealArtifact);
+      built.catch(() => cache.delete(key));
+      cache.set(key, built);
+      return built;
+    }
+  };
+}
+async function sealDraft(draft, format, options, signal, formats) {
+  const adapter = formatAdapter(format, formats);
+  if (!adapter.supports(draft.payload)) throw new ContentTransferError("unsupported-format", `${adapter.label} is not available for this content.`);
+  return sealArtifact(await (await adapter.load()).build(draft, options, signal));
+}
+function narrow(outcome) {
+  if (outcome.status === "success" && outcome.delivered === "action") {
+    return { status: "success", delivered: "clipboard", mimeTypes: outcome.mimeTypes };
+  }
+  if (outcome.status === "queued") {
+    return { status: "error", code: "unexpected-queued", message: outcome.message, retryable: false };
+  }
+  return outcome;
+}
+function createDelivery(ports = {}) {
+  const transport = ports.transport ?? createBrowserTransport();
+  return {
+    async copy(artifact, signal) {
+      if (!isSealed(artifact)) return notSealed;
+      return narrow(await transport.copy(artifact, signal));
+    },
+    copyPending(pending, signal, options = {}) {
+      const clipboard = globalThis.navigator?.clipboard;
+      const Item = globalThis.ClipboardItem;
+      const checked = pending.then((a) => {
+        if (!isSealed(a)) throw new ContentTransferError("not-sealed", notSealed.status === "error" ? notSealed.message : "");
+        return a;
+      });
+      if (clipboard?.write && typeof Item === "function") {
+        const text = checked.then((a) => new Blob([a.plainText], { type: "text/plain" }));
+        const entries = { "text/plain": text };
+        if (options.html) entries["text/html"] = checked.then((a) => new Blob([a.html ?? a.plainText], { type: "text/html" }));
+        let item = null;
+        try {
+          item = new Item(entries);
+        } catch {
+          item = null;
+        }
+        if (item) {
+          const written = clipboard.write([item]);
+          return written.then(
+            async () => signal.aborted ? { status: "cancelled" } : { status: "success", delivered: "clipboard", mimeTypes: options.html ? ["text/plain", "text/html"] : ["text/plain"] },
+            async () => {
+              try {
+                const a = await checked;
+                return narrow(await transport.copy(a, signal));
+              } catch (error) {
+                return error instanceof ContentTransferError && error.code === "not-sealed" ? notSealed : { status: "error", code: "clipboard-rejected", message: "The clipboard refused the copy. Try again.", retryable: true };
+              }
+            }
+          );
+        }
+      }
+      return checked.then(
+        async (a) => narrow(await transport.copy(a, signal)),
+        () => notSealed
+      );
+    },
+    async download(artifact, signal) {
+      if (!isSealed(artifact)) return notSealed;
+      return narrow(await transport.download(artifact, signal));
+    },
+    async send(artifact, to, via) {
+      if (!isSealed(artifact)) {
+        return { status: "refused", to, reason: "failed", sentence: notSealed.status === "error" ? notSealed.message : "", remedy: "Prepare the content again, then send it." };
+      }
+      if (!ports.door) {
+        return {
+          status: "refused",
+          to,
+          reason: "unapplicable",
+          sentence: "Sending to a destination is not available here yet, so nothing was sent.",
+          remedy: "Copy or download it instead, then paste it where it belongs."
+        };
+      }
+      return ports.door.apply({ to, value: artifact.file ? artifact.file.bytes : artifact.plainText, origin: "user", via });
+    }
+  };
+}
 //# sourceMappingURL=index.cjs.map