synartesis 0.1.0

package/dist/chunk-X4VQNEP5.js

@@ -0,0 +1,1383 @@
+import {
+  JournalError,
+  ManifestError,
+  SnapshotError,
+  UpstreamError,
+  describe
+} from "./chunk-K3QIPVBY.js";
+
+// src/invocation.ts
+import { accessSync, constants } from "fs";
+import { basename, delimiter, join } from "path";
+import { fileURLToPath } from "url";
+function onPath(command) {
+  const dirs = (process.env["PATH"] ?? "").split(delimiter).filter((dir) => dir !== "");
+  return dirs.some((dir) => {
+    try {
+      accessSync(join(dir, command), constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}
+var cached;
+function cliCommand() {
+  if (cached !== void 0) {
+    return cached;
+  }
+  const invokedAs = process.argv[1];
+  if (invokedAs !== void 0 && basename(invokedAs) === "synartesis") {
+    cached = "synartesis";
+    return cached;
+  }
+  if (onPath("synartesis")) {
+    cached = "synartesis";
+    return cached;
+  }
+  cached = `node ${invokedAs ?? "dist/cli.js"}`;
+  return cached;
+}
+function cliCommandFrom(moduleUrl) {
+  if (onPath("synartesis")) {
+    return "synartesis";
+  }
+  return `node ${fileURLToPath(new URL("cli.js", moduleUrl))}`;
+}
+function proxyCommand() {
+  if (onPath("synartesis")) {
+    return "synartesis proxy";
+  }
+  if (onPath("synartesis-proxy")) {
+    return "synartesis-proxy";
+  }
+  const invokedAs = process.argv[1];
+  if (invokedAs !== void 0 && invokedAs.endsWith("cli.js")) {
+    return `node ${invokedAs} proxy`;
+  }
+  return `node ${fileURLToPath(new URL("cli.js", import.meta.url))} proxy`;
+}
+
+// src/locate.ts
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2, resolve } from "path";
+var MANIFEST_NAME = "synartesis.yaml";
+var JOURNAL_NAME = "journal.db";
+var NESTED_JOURNAL = join2(".synartesis", JOURNAL_NAME);
+function home() {
+  return process.env["SYNARTESIS_HOME"] ?? join2(homedir(), ".synartesis");
+}
+function walkUp(from, name) {
+  let dir = resolve(from);
+  for (; ; ) {
+    const candidate = join2(dir, name);
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    dir = parent;
+  }
+}
+function findManifest(given) {
+  if (given !== void 0) {
+    return given;
+  }
+  return walkUp(process.cwd(), MANIFEST_NAME) ?? join2(home(), MANIFEST_NAME);
+}
+function findJournal(given, manifest) {
+  if (given !== void 0) {
+    return given;
+  }
+  const near = manifest === void 0 ? void 0 : dirname(resolve(manifest));
+  for (const dir of [near, process.cwd()]) {
+    if (dir === void 0) {
+      continue;
+    }
+    for (const name of [JOURNAL_NAME, NESTED_JOURNAL]) {
+      const candidate = join2(dir, name);
+      if (existsSync(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  const found = walkUp(process.cwd(), NESTED_JOURNAL) ?? walkUp(process.cwd(), JOURNAL_NAME);
+  if (found !== void 0) {
+    return found;
+  }
+  return near === void 0 ? join2(home(), JOURNAL_NAME) : join2(near, JOURNAL_NAME);
+}
+
+// src/style.ts
+var ESC = "\x1B[";
+var ACCENT = `${ESC}38;2;226;134;118m`;
+var ON_ACCENT = `${ESC}48;2;94;20;32m${ESC}38;2;246;233;229m`;
+var BRIGHT = `${ESC}38;2;246;233;229m`;
+var DIM = `${ESC}2m`;
+var BOLD = `${ESC}1m`;
+var RESET = `${ESC}0m`;
+var enabled = process.env["NO_COLOR"] === void 0 && process.env["TERM"] !== "dumb" && process.stdout.isTTY;
+function paint(codes, text) {
+  return enabled ? `${codes}${text}${RESET}` : text;
+}
+function spaced(text) {
+  return Array.from(text).join(" ");
+}
+var style = {
+  /** A section label: small, capital, spaced out. */
+  label: (text) => paint(ACCENT + DIM, spaced(text.toUpperCase())),
+  heading: (text) => paint(BRIGHT + BOLD, text.toUpperCase()),
+  accent: (text) => paint(ACCENT, text),
+  strong: (text) => paint(BOLD, text),
+  quiet: (text) => paint(DIM, text),
+  /** Off-white on oxblood, the way the wordmark is set. */
+  plate: (text) => paint(ON_ACCENT + BOLD, ` ${text} `)
+};
+var WORDMARK = spaced("SYNARTESIS");
+function meander(width) {
+  const unit = "\u2517\u2501\u2513\u250F\u2501\u251B";
+  return unit.repeat(Math.max(1, Math.ceil(width / unit.length))).slice(0, width);
+}
+function rule(width = 48) {
+  return style.quiet(meander(width));
+}
+var GREEK = spaced("\u03A3\u03A5\u039D\u0391\u03A1\u03A4\u0397\u03A3\u0399\u03A3");
+var MEANING = "a fastening together";
+var TAGLINE = "an undo layer for AI agents";
+function mark() {
+  return `
+  ${style.plate(WORDMARK)}  ${style.quiet(MEANING)}
+
+`;
+}
+function banner() {
+  return [
+    "",
+    `  ${style.plate(WORDMARK)}`,
+    `  ${style.accent(meander(24))}`,
+    "",
+    `  ${style.quiet(GREEK)}  ${style.quiet("\xB7")}  ${style.quiet(MEANING)}`,
+    "",
+    `  ${style.accent(spaced(TAGLINE.toUpperCase()))}`,
+    `  ${style.quiet("Every action is bound to the action that undoes it.")}`,
+    ""
+  ].join("\n");
+}
+
+// src/journal/journal.ts
+import { existsSync as existsSync2, mkdirSync } from "fs";
+import { dirname as dirname2 } from "path";
+import Database from "better-sqlite3";
+import { z } from "zod";
+
+// src/canonical.ts
+function canonical(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(canonical).join(",")}]`;
+  }
+  const entries = Object.entries(value).filter(([, item]) => item !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+}
+
+// src/journal/schema.ts
+var SCHEMA_VERSION = 3;
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS runs (
+  id           TEXT PRIMARY KEY,
+  label        TEXT,
+  started_at   TEXT NOT NULL,
+  ended_at     TEXT,
+  status       TEXT NOT NULL CHECK (status IN ('active','complete','rolled_back','partial'))
+);
+
+CREATE TABLE IF NOT EXISTS actions (
+  id                 TEXT PRIMARY KEY,
+  run_id             TEXT NOT NULL REFERENCES runs(id),
+  seq                INTEGER NOT NULL,
+  server             TEXT NOT NULL,
+  tool               TEXT NOT NULL,
+  args_json          TEXT NOT NULL,
+  class              TEXT NOT NULL,
+  snapshot_json      TEXT,
+  post_snapshot_json TEXT,
+  result_json        TEXT,
+  inverse_json       TEXT,
+  verify_json        TEXT,
+  error              TEXT,
+  idempotency_key    TEXT NOT NULL UNIQUE,
+  status             TEXT NOT NULL CHECK (status IN
+                       ('pending','gated','approved','denied','applied','failed',
+                        'rolling_back','rolled_back','unrecoverable')),
+  approved_by        TEXT,
+  approved_at        TEXT,
+  ts                 TEXT NOT NULL,
+  UNIQUE(run_id, seq)
+);
+
+CREATE INDEX IF NOT EXISTS actions_by_run ON actions(run_id, seq);
+`;
+
+// src/journal/journal.ts
+var SPENT_APPROVAL = "approval was used by action";
+var runSchema = z.object({
+  id: z.string(),
+  label: z.string().nullable(),
+  started_at: z.string(),
+  ended_at: z.string().nullable(),
+  status: z.enum(["active", "complete", "rolled_back", "partial"])
+});
+var actionSchema = z.object({
+  id: z.string(),
+  run_id: z.string(),
+  seq: z.number(),
+  server: z.string(),
+  tool: z.string(),
+  args_json: z.string(),
+  class: z.enum(["unclassified", "readonly", "reversible", "compensable", "irreversible"]),
+  snapshot_json: z.string().nullable(),
+  post_snapshot_json: z.string().nullable(),
+  result_json: z.string().nullable(),
+  inverse_json: z.string().nullable(),
+  verify_json: z.string().nullable(),
+  error: z.string().nullable(),
+  idempotency_key: z.string(),
+  status: z.enum([
+    "pending",
+    "gated",
+    "approved",
+    "denied",
+    "applied",
+    "failed",
+    "rolling_back",
+    "rolled_back",
+    "unrecoverable"
+  ]),
+  approved_by: z.string().nullable(),
+  approved_at: z.string().nullable(),
+  ts: z.string()
+});
+function decode(value) {
+  return value === null ? void 0 : JSON.parse(value);
+}
+function orUndefined(value) {
+  return value === null ? void 0 : value;
+}
+function toRun(raw) {
+  const row = runSchema.parse(raw);
+  return {
+    id: row.id,
+    label: orUndefined(row.label),
+    startedAt: row.started_at,
+    endedAt: orUndefined(row.ended_at),
+    status: row.status
+  };
+}
+function toAction(raw) {
+  const row = actionSchema.parse(raw);
+  return {
+    id: row.id,
+    runId: row.run_id,
+    seq: row.seq,
+    server: row.server,
+    tool: row.tool,
+    args: decode(row.args_json),
+    class: row.class,
+    snapshot: decode(row.snapshot_json),
+    postSnapshot: decode(row.post_snapshot_json),
+    result: decode(row.result_json),
+    inverse: decode(row.inverse_json),
+    verify: decode(row.verify_json),
+    error: orUndefined(row.error),
+    idempotencyKey: row.idempotency_key,
+    status: row.status,
+    approvedBy: orUndefined(row.approved_by),
+    approvedAt: orUndefined(row.approved_at),
+    ts: row.ts
+  };
+}
+function openDatabase(path) {
+  try {
+    const db = new Database(path);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    return db;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    if (detail.includes("not a database")) {
+      throw new JournalError(
+        "open",
+        `${path} is not a Synartesis journal. Point --journal at a journal, or at a new file to start one.`
+      );
+    }
+    throw new JournalError("open", `the journal at ${path} could not be opened: ${detail}`);
+  }
+}
+var SqliteJournal = class {
+  #db;
+  constructor(path) {
+    if (path !== ":memory:") {
+      mkdirSync(dirname2(path), { recursive: true });
+    }
+    this.#db = openDatabase(path);
+    const existing = z.number().parse(this.#db.pragma("user_version", { simple: true }));
+    const populated = z.object({ count: z.number() }).parse(
+      this.#db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND name = 'runs'").get()
+    ).count > 0;
+    if (populated && existing !== SCHEMA_VERSION) {
+      throw new JournalError(
+        "open",
+        `journal at ${path} was written by schema version ${String(existing)}, but this build expects ${String(SCHEMA_VERSION)}. Point --journal at a new file to carry on, and keep this one: everything an agent did is in it. Delete it only once you are sure you do not want that history.`
+      );
+    }
+    this.#db.exec(SCHEMA_SQL);
+    this.#db.pragma(`user_version = ${String(SCHEMA_VERSION)}`);
+  }
+  beginRun(label) {
+    const id = crypto.randomUUID();
+    this.#run("beginRun", () => {
+      this.#db.prepare("INSERT INTO runs (id, label, started_at, status) VALUES (?, ?, ?, 'active')").run(id, label ?? null, (/* @__PURE__ */ new Date()).toISOString());
+    });
+    return id;
+  }
+  endRun(runId, status) {
+    this.#run("endRun", () => {
+      this.#db.prepare("UPDATE runs SET ended_at = ?, status = ? WHERE id = ?").run((/* @__PURE__ */ new Date()).toISOString(), status, runId);
+    });
+  }
+  closeAbandonedRun(runId) {
+    return this.#run("closeAbandonedRun", () => {
+      const last = z.object({ ts: z.string().nullable() }).parse(
+        this.#db.prepare("SELECT MAX(ts) AS ts FROM actions WHERE run_id = ?").get(runId) ?? { ts: null }
+      ).ts;
+      const result = this.#db.prepare("UPDATE runs SET ended_at = ?, status = 'complete' WHERE id = ? AND status = 'active'").run(last ?? (/* @__PURE__ */ new Date()).toISOString(), runId);
+      return result.changes === 1;
+    });
+  }
+  setRunLabel(runId, label) {
+    this.#run("setRunLabel", () => {
+      this.#db.prepare("UPDATE runs SET label = ? WHERE id = ?").run(label, runId);
+    });
+  }
+  recordPending(input) {
+    return this.#run("recordPending", () => {
+      const insert = this.#db.transaction(() => {
+        const next = this.#db.prepare("SELECT COALESCE(MAX(seq), 0) + 1 AS seq FROM actions WHERE run_id = ?").get(input.runId);
+        const seq = z.object({ seq: z.number() }).parse(next).seq;
+        const actionId = crypto.randomUUID();
+        const idempotencyKey = `${input.runId}:${String(seq)}`;
+        this.#db.prepare(
+          `INSERT INTO actions
+               (id, run_id, seq, server, tool, args_json, class, idempotency_key, status, ts)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'pending', ?)`
+        ).run(
+          actionId,
+          input.runId,
+          seq,
+          input.server,
+          input.tool,
+          JSON.stringify(input.args ?? {}),
+          input.class,
+          idempotencyKey,
+          (/* @__PURE__ */ new Date()).toISOString()
+        );
+        return { actionId, seq, idempotencyKey };
+      });
+      return insert();
+    });
+  }
+  attachSnapshot(actionId, snapshot) {
+    this.#run("attachSnapshot", () => {
+      this.#db.prepare("UPDATE actions SET snapshot_json = ? WHERE id = ?").run(JSON.stringify(snapshot ?? null), actionId);
+    });
+  }
+  markApplied(actionId, outcome) {
+    this.#run("markApplied", () => {
+      this.#db.prepare(
+        `UPDATE actions
+             SET status = 'applied',
+                 result_json = ?,
+                 inverse_json = ?,
+                 verify_json = ?,
+                 post_snapshot_json = ?,
+                 error = ?
+           WHERE id = ?`
+      ).run(
+        JSON.stringify(outcome.result ?? null),
+        outcome.inverse === void 0 ? null : JSON.stringify(outcome.inverse),
+        outcome.verify === void 0 ? null : JSON.stringify(outcome.verify),
+        outcome.postSnapshot === void 0 ? null : JSON.stringify(outcome.postSnapshot),
+        outcome.warning ?? null,
+        actionId
+      );
+    });
+  }
+  markFailed(actionId, error) {
+    this.#run("markFailed", () => {
+      this.#db.prepare("UPDATE actions SET status = 'failed', error = ? WHERE id = ?").run(error, actionId);
+    });
+  }
+  /**
+   * The call was interrupted, so whether the upstream applied it is genuinely
+   * unknown. The row deliberately stays `pending`: recording it as failed
+   * would assert something we cannot know, and section 3.1 wants exactly this
+   * case surfaced rather than resolved by guesswork.
+   */
+  markUnknown(actionId, error) {
+    this.#run("markUnknown", () => {
+      this.#db.prepare("UPDATE actions SET status = 'pending', error = ? WHERE id = ?").run(error, actionId);
+    });
+  }
+  markRollingBack(actionId) {
+    return this.#run("markRollingBack", () => {
+      const result = this.#db.prepare("UPDATE actions SET status = 'rolling_back' WHERE id = ? AND status = 'applied'").run(actionId);
+      return result.changes === 1;
+    });
+  }
+  markRolledBack(actionId) {
+    this.#run("markRolledBack", () => {
+      this.#db.prepare("UPDATE actions SET status = 'rolled_back' WHERE id = ?").run(actionId);
+    });
+  }
+  /**
+   * The upstream processed the inverse and refused it, so nothing was applied
+   * and the action still needs undoing. Distinct from `unrecoverable`, which
+   * means a human has to look: a refused inverse may simply be a server that
+   * was briefly unwell, and rollback is expected to be retried (D7).
+   */
+  markInverseRejected(actionId, error) {
+    this.#run("markInverseRejected", () => {
+      this.#db.prepare("UPDATE actions SET status = 'applied', error = ? WHERE id = ?").run(error, actionId);
+    });
+  }
+  /**
+   * The inverse may or may not have reached the upstream. The row stays in
+   * `rolling_back` so the next attempt knows to resolve it by reading the
+   * current state rather than assuming either way.
+   */
+  markUnknownInverse(actionId, error) {
+    this.#run("markUnknownInverse", () => {
+      this.#db.prepare("UPDATE actions SET status = 'rolling_back', error = ? WHERE id = ?").run(error, actionId);
+    });
+  }
+  markGated(actionId, why) {
+    this.#run("markGated", () => {
+      this.#db.prepare("UPDATE actions SET status = 'gated', error = ? WHERE id = ?").run(why ?? null, actionId);
+    });
+  }
+  markInFlight(actionId) {
+    this.#run("markInFlight", () => {
+      this.#db.prepare("UPDATE actions SET status = 'pending' WHERE id = ?").run(actionId);
+    });
+  }
+  /**
+   * Conditional on the row still being gated, so a decision made at the same
+   * moment as a timeout resolves one way rather than both.
+   */
+  approve(actionId, by) {
+    return this.#run("approve", () => {
+      const result = this.#db.prepare(
+        `UPDATE actions SET status = 'approved', approved_by = ?, approved_at = ?, error = NULL
+           WHERE id = ? AND status = 'gated'`
+      ).run(by, (/* @__PURE__ */ new Date()).toISOString(), actionId);
+      return result.changes === 1;
+    });
+  }
+  deny(actionId, by, reason) {
+    return this.#run("deny", () => {
+      const result = this.#db.prepare(
+        `UPDATE actions SET status = 'denied', approved_by = ?, approved_at = ?, error = ?
+           WHERE id = ? AND status = 'gated'`
+      ).run(by ?? null, (/* @__PURE__ */ new Date()).toISOString(), reason, actionId);
+      return result.changes === 1;
+    });
+  }
+  settleAsDenied(actionId, by, reason) {
+    this.#run("settleAsDenied", () => {
+      this.#db.prepare(
+        "UPDATE actions SET status = 'denied', approved_by = ?, approved_at = ?, error = ? WHERE id = ?"
+      ).run(by ?? null, (/* @__PURE__ */ new Date()).toISOString(), reason, actionId);
+    });
+  }
+  adoptApproval(actionId, granted) {
+    this.#run("adoptApproval", () => {
+      const move = this.#db.transaction(() => {
+        this.#db.prepare("UPDATE actions SET approved_by = ?, approved_at = ? WHERE id = ?").run(granted.approvedBy ?? null, granted.approvedAt ?? null, actionId);
+        this.#db.prepare("UPDATE actions SET status = 'denied', error = ? WHERE id = ?").run(`${SPENT_APPROVAL} ${actionId}`, granted.id);
+      });
+      move();
+    });
+  }
+  listGated() {
+    return this.#run(
+      "listGated",
+      () => this.#db.prepare("SELECT * FROM actions WHERE status = 'gated' ORDER BY ts").all().map(toAction)
+    );
+  }
+  findApproval(query) {
+    return this.#run("findApproval", () => {
+      const rows = this.#db.prepare(
+        `SELECT * FROM actions
+            WHERE server = ? AND tool = ?
+              AND status = 'approved'
+              AND approved_at >= ?
+            ORDER BY approved_at DESC`
+      ).all(query.server, query.tool, query.notBefore).map(toAction);
+      const wanted = canonical(query.args ?? {});
+      return rows.find((row) => canonical(row.args) === wanted);
+    });
+  }
+  findGated(query) {
+    return this.#run("findGated", () => {
+      const rows = this.#db.prepare(
+        `SELECT * FROM actions
+            WHERE run_id = ? AND server = ? AND tool = ? AND status = 'gated'
+            ORDER BY seq`
+      ).all(query.runId, query.server, query.tool).map(toAction);
+      const wanted = canonical(query.args ?? {});
+      return rows.find((row) => canonical(row.args) === wanted);
+    });
+  }
+  getAction(actionId) {
+    return this.#run("getAction", () => {
+      const raw = this.#db.prepare("SELECT * FROM actions WHERE id = ?").get(actionId);
+      return raw === void 0 ? void 0 : toAction(raw);
+    });
+  }
+  markUnrecoverable(actionId, error) {
+    this.#run("markUnrecoverable", () => {
+      this.#db.prepare("UPDATE actions SET status = 'unrecoverable', error = ? WHERE id = ?").run(error, actionId);
+    });
+  }
+  listRuns() {
+    return this.#run(
+      "listRuns",
+      () => (
+        // Insertion order as the tiebreak, not the id. Two runs that start in
+        // the same millisecond have equal timestamps, and a uuid orders them at
+        // random -- which decides which one `show` and `undo` mean by "the most
+        // recent", so the answer has to come from when they were written rather
+        // than from what they happen to be called.
+        this.#db.prepare("SELECT * FROM runs ORDER BY started_at, rowid").all().map(toRun)
+      )
+    );
+  }
+  getRun(runId) {
+    return this.#run("getRun", () => {
+      const raw = this.#db.prepare("SELECT * FROM runs WHERE id = ?").get(runId);
+      return raw === void 0 ? void 0 : toRun(raw);
+    });
+  }
+  getActions(runId) {
+    return this.#run(
+      "getActions",
+      () => this.#db.prepare("SELECT * FROM actions WHERE run_id = ? ORDER BY seq").all(runId).map(toAction)
+    );
+  }
+  recentActions(limit) {
+    return this.#run(
+      "recentActions",
+      () => this.#db.prepare("SELECT * FROM actions ORDER BY ts DESC, seq DESC LIMIT ?").all(limit).map(toAction).reverse()
+    );
+  }
+  pragma(name) {
+    return this.#db.pragma(name, { simple: true });
+  }
+  close() {
+    this.#db.close();
+  }
+  /**
+   * A failed journal write means the record of what the agent did is
+   * incomplete. It is never swallowed and never merely logged.
+   */
+  #run(operation, body) {
+    try {
+      return body();
+    } catch (error) {
+      throw new JournalError(operation, error);
+    }
+  }
+};
+function openJournal(path, options = {}) {
+  if (options.mustExist === true && path !== ":memory:" && !existsSync2(path)) {
+    throw new JournalError("open", `there is no journal at ${path}`);
+  }
+  return new SqliteJournal(path);
+}
+function labelFor(action) {
+  return action.status === "denied" && (action.error ?? "").startsWith(SPENT_APPROVAL) ? "used" : action.status;
+}
+function wasRefused(action) {
+  return action.status === "unrecoverable" || labelFor(action) === "denied";
+}
+
+// src/manifest/load.ts
+import { readFileSync } from "fs";
+import { LineCounter, isNode, parseDocument } from "yaml";
+import { z as z2 } from "zod";
+
+// src/manifest/template.ts
+var NAMESPACES = ["snapshot", "result"];
+function parseReference(raw) {
+  if (!raw.startsWith("$")) {
+    return void 0;
+  }
+  if (raw === "$") {
+    return { namespace: "args", path: "" };
+  }
+  if (raw.startsWith("$.") || raw.startsWith("$[")) {
+    return { namespace: "args", path: raw.slice(raw[1] === "." ? 2 : 1) };
+  }
+  for (const namespace of NAMESPACES) {
+    if (raw === `$${namespace}`) {
+      return { namespace, path: "" };
+    }
+    const head = `$${namespace}`;
+    const after = raw.startsWith(head) ? raw.slice(head.length) : void 0;
+    if (after !== void 0 && (after.startsWith(".") || after.startsWith("["))) {
+      return { namespace, path: after.startsWith(".") ? after.slice(1) : after };
+    }
+  }
+  throw new ManifestError(
+    `unknown interpolation namespace in ${raw}; expected $., $snapshot. or $result.`
+  );
+}
+function segments(path, reference) {
+  const parts = [];
+  for (const chunk of path.split(".")) {
+    const match = /^([^[\]]*)((?:\[\d*\])*)$/.exec(chunk);
+    if (match === null) {
+      throw new ManifestError(`malformed path in ${reference}`);
+    }
+    const [, head = "", brackets = ""] = match;
+    if (head !== "") {
+      parts.push({ kind: "key", key: head });
+    }
+    for (const bracket of brackets.matchAll(/\[(\d*)\]/g)) {
+      const index = bracket[1] ?? "";
+      parts.push(index === "" ? { kind: "each" } : { kind: "index", index: Number(index) });
+    }
+  }
+  if (parts.length === 0) {
+    throw new ManifestError(`empty path in ${reference}`);
+  }
+  return parts;
+}
+function walk(current, parts, at, reference) {
+  const segment = parts[at];
+  if (segment === void 0) {
+    return current;
+  }
+  if (current === null || current === void 0) {
+    throw new ManifestError(`${reference} is unresolvable: nothing to read from`);
+  }
+  switch (segment.kind) {
+    case "each": {
+      if (!Array.isArray(current)) {
+        throw new ManifestError(`${reference} is unresolvable: [] needs a list to walk`);
+      }
+      return current.map((item) => walk(item, parts, at + 1, reference));
+    }
+    case "index": {
+      if (!Array.isArray(current) || segment.index >= current.length) {
+        throw new ManifestError(
+          `${reference} is unresolvable: index ${String(segment.index)} is absent`
+        );
+      }
+      return walk(current[segment.index], parts, at + 1, reference);
+    }
+    case "key": {
+      if (typeof current !== "object" || !(segment.key in current)) {
+        throw new ManifestError(`${reference} is unresolvable: ${segment.key} is absent`);
+      }
+      const next = Object.getOwnPropertyDescriptor(current, segment.key)?.value;
+      return walk(next, parts, at + 1, reference);
+    }
+  }
+}
+function read(root, path, reference) {
+  return walk(root, segments(path, reference), 0, reference);
+}
+var EMBEDDED = /\$(?:snapshot|result)?\.[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*|\[\d*\])*/g;
+var ESCAPE = "\0synartesis-dollar\0";
+function stringify(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function resolveString(raw, context) {
+  const whole = raw.startsWith("$$") ? void 0 : parseReference(raw);
+  if (whole !== void 0) {
+    return readNamespace(whole, raw, context);
+  }
+  const escaped = raw.split("$$").join(ESCAPE);
+  const substituted = escaped.replace(EMBEDDED, (token) => {
+    const reference = parseReference(token);
+    if (reference === void 0) {
+      return token;
+    }
+    return stringify(readNamespace(reference, token, context));
+  });
+  return substituted.split(ESCAPE).join("$");
+}
+function readNamespace(reference, raw, context) {
+  const root = context[reference.namespace];
+  if (root === void 0) {
+    throw new ManifestError(
+      `${raw} refers to ${reference.namespace}, which is not available at this point`
+    );
+  }
+  return reference.path === "" ? root : read(root, reference.path, raw);
+}
+function isTemplateArray(value) {
+  return Array.isArray(value);
+}
+function resolveTemplate(template, context) {
+  if (typeof template === "string") {
+    return resolveString(template, context);
+  }
+  if (isTemplateArray(template)) {
+    return template.map((item) => resolveTemplate(item, context));
+  }
+  if (template !== null && typeof template === "object") {
+    return Object.fromEntries(
+      Object.entries(template).map(([key, value]) => [key, resolveTemplate(value, context)])
+    );
+  }
+  return template;
+}
+function referencesIn(template) {
+  if (typeof template === "string") {
+    if (template.startsWith("$$")) {
+      return [];
+    }
+    if (parseReference(template) !== void 0) {
+      return [template];
+    }
+    return template.split("$$").join(ESCAPE).match(EMBEDDED) ?? [];
+  }
+  if (isTemplateArray(template)) {
+    return template.flatMap(referencesIn);
+  }
+  if (template !== null && typeof template === "object") {
+    return Object.values(template).flatMap(referencesIn);
+  }
+  return [];
+}
+
+// src/manifest/load.ts
+var templateValue = z2.lazy(
+  () => z2.union([
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.null(),
+    z2.array(templateValue),
+    z2.record(z2.string(), templateValue)
+  ])
+);
+var callTemplate = z2.strictObject({
+  tool: z2.string().min(1),
+  args: z2.record(z2.string(), templateValue).default({})
+});
+var toolPolicy = z2.strictObject({
+  match: z2.string().min(1),
+  class: z2.enum(["readonly", "reversible", "compensable", "irreversible"]),
+  gate: z2.enum(["always", "on_write", "never"]).optional(),
+  snapshot: callTemplate.optional(),
+  inverse: callTemplate.optional()
+});
+var serverSpec = z2.strictObject({
+  command: z2.string().min(1),
+  args: z2.array(z2.string()).default([]),
+  env: z2.record(z2.string(), z2.string()).optional()
+});
+var manifestSchema = z2.strictObject({
+  version: z2.literal(1),
+  servers: z2.record(z2.string(), serverSpec),
+  tools: z2.array(toolPolicy).default([])
+});
+var Source = class {
+  constructor(doc, lines, file) {
+    this.doc = doc;
+    this.lines = lines;
+    this.file = file;
+  }
+  doc;
+  lines;
+  file;
+  /** Narrows to the deepest node that still exists, so a location is always given. */
+  locate(path) {
+    for (let depth = path.length; depth >= 0; depth -= 1) {
+      const node = depth === 0 ? this.doc.contents : this.doc.getIn(path.slice(0, depth), true);
+      const range = isNode(node) ? node.range : void 0;
+      if (range != null) {
+        const position = this.lines.linePos(range[0]);
+        return { file: this.file, line: position.line, column: position.col };
+      }
+    }
+    return { file: this.file, line: 1, column: 1 };
+  }
+  fail(path, message) {
+    throw new ManifestError(message, this.locate(path));
+  }
+};
+var REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
+function expandEnvironment(source, path, env) {
+  const expanded = {};
+  for (const [key, value] of Object.entries(env)) {
+    expanded[key] = value.replace(REFERENCE, (whole, name) => {
+      const found = process.env[name];
+      if (found === void 0) {
+        source.fail(
+          [...path, "env", key],
+          `${whole} is not set in this environment; export ${name} before starting, or write the value here`
+        );
+      }
+      return found;
+    });
+  }
+  return expanded;
+}
+function serverSegment(pattern) {
+  const dot = pattern.indexOf(".");
+  return dot === -1 ? "" : pattern.slice(0, dot);
+}
+function matchesAnyServer(segment, servers) {
+  if (!segment.includes("*")) {
+    return servers.includes(segment);
+  }
+  const source = segment.split("*").map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^.]*");
+  const test = new RegExp(`^${source}$`);
+  return servers.some((name) => test.test(name));
+}
+function checkCall(source, path, call, servers, allowed) {
+  const segment = serverSegment(call.tool);
+  if (segment === "" || call.tool.endsWith(".")) {
+    source.fail([...path, "tool"], `${call.tool} must be qualified as server.tool`);
+  }
+  if (segment.includes("*")) {
+    source.fail([...path, "tool"], `${call.tool} must name one server, not a pattern`);
+  }
+  if (!servers.includes(segment)) {
+    source.fail([...path, "tool"], `${call.tool} names server ${segment}, which is not declared`);
+  }
+  for (const reference of referencesIn(call.args)) {
+    const namespace = /^\$(\w*)(?:[.[]|$)/.exec(reference)?.[1] ?? "";
+    const label = namespace === "" ? "$." : `$${namespace}.`;
+    if (!allowed.includes(label)) {
+      source.fail(
+        [...path, "args"],
+        `${reference} uses ${label}, which is not available here; allowed: ${allowed.join(", ")}`
+      );
+    }
+  }
+}
+function validate(source, manifest) {
+  const servers = Object.keys(manifest.servers);
+  if (servers.length === 0) {
+    source.fail(["servers"], "at least one server must be declared");
+  }
+  const seen = /* @__PURE__ */ new Map();
+  manifest.tools.forEach((policy, index) => {
+    const path = ["tools", index];
+    const previous = seen.get(policy.match);
+    if (previous !== void 0) {
+      source.fail(
+        [...path, "match"],
+        `duplicate match pattern ${policy.match}; it is already declared at tools[${String(previous)}]`
+      );
+    }
+    seen.set(policy.match, index);
+    const segment = serverSegment(policy.match);
+    if (segment === "") {
+      source.fail([...path, "match"], `${policy.match} must be qualified as server.tool`);
+    }
+    if (!matchesAnyServer(segment, servers)) {
+      source.fail(
+        [...path, "match"],
+        `${policy.match} names server ${segment}, which is not declared`
+      );
+    }
+    const needsInverse = policy.class === "reversible" || policy.class === "compensable";
+    if (needsInverse && policy.inverse === void 0) {
+      source.fail(path, `a ${policy.class} tool must declare an inverse`);
+    }
+    if (!needsInverse && policy.inverse !== void 0) {
+      source.fail([...path, "inverse"], `a ${policy.class} tool must not declare an inverse`);
+    }
+    const needsSnapshot = policy.inverse !== void 0 && referencesIn(policy.inverse.args).some(
+      (reference) => reference === "$snapshot" || reference.startsWith("$snapshot.")
+    );
+    if (policy.class === "reversible" && needsSnapshot && policy.snapshot === void 0) {
+      source.fail(path, "this inverse reads $snapshot, so a snapshot must be declared");
+    }
+    if (policy.class === "readonly" && policy.snapshot !== void 0) {
+      source.fail([...path, "snapshot"], "a readonly tool must not declare a snapshot");
+    }
+    if (policy.snapshot !== void 0) {
+      checkCall(source, [...path, "snapshot"], policy.snapshot, servers, ["$."]);
+    }
+    if (policy.inverse !== void 0) {
+      const allowed = ["$.", "$result."];
+      if (policy.snapshot !== void 0) {
+        allowed.push("$snapshot.");
+      }
+      checkCall(source, [...path, "inverse"], policy.inverse, servers, allowed);
+    }
+  });
+}
+function withGate(policy) {
+  const gate = policy.gate ?? (policy.class === "irreversible" ? "always" : "never");
+  return {
+    match: policy.match,
+    class: policy.class,
+    gate,
+    ...policy.snapshot === void 0 ? {} : { snapshot: policy.snapshot },
+    ...policy.inverse === void 0 ? {} : { inverse: policy.inverse }
+  };
+}
+function parseManifest(text, file) {
+  const lines = new LineCounter();
+  const doc = parseDocument(text, { lineCounter: lines });
+  const syntaxError = doc.errors[0];
+  if (syntaxError !== void 0) {
+    const position = lines.linePos(syntaxError.pos[0]);
+    throw new ManifestError(syntaxError.message, {
+      file,
+      line: position.line,
+      column: position.col
+    });
+  }
+  const source = new Source(doc, lines, file);
+  const parsed = manifestSchema.safeParse(doc.toJS());
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    if (issue === void 0) {
+      throw new ManifestError("manifest failed validation", source.locate([]));
+    }
+    const path = issue.path.filter(
+      (segment) => typeof segment !== "symbol"
+    );
+    const where = path.length === 0 ? "" : `${path.join(".")}: `;
+    throw new ManifestError(`${where}${issue.message}`, source.locate(path));
+  }
+  const manifest = {
+    version: parsed.data.version,
+    servers: Object.fromEntries(
+      Object.entries(parsed.data.servers).map(([name, spec]) => [
+        name,
+        {
+          command: spec.command,
+          args: spec.args,
+          ...spec.env === void 0 ? {} : { env: expandEnvironment(source, ["servers", name], spec.env) }
+        }
+      ])
+    ),
+    tools: parsed.data.tools.map(withGate)
+  };
+  validate(source, manifest);
+  return manifest;
+}
+function loadManifest(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (error) {
+    throw new ManifestError(`cannot read manifest at ${path}: ${describe(error)}`);
+  }
+  return parseManifest(text, path);
+}
+
+// src/manifest/verify.ts
+import { z as z3 } from "zod";
+
+// src/manifest/types.ts
+function qualify(server, tool) {
+  return `${server}.${tool}`;
+}
+function splitQualified(qualified) {
+  const dot = qualified.indexOf(".");
+  if (dot <= 0 || dot === qualified.length - 1) {
+    return void 0;
+  }
+  return { server: qualified.slice(0, dot), tool: qualified.slice(dot + 1) };
+}
+
+// src/manifest/verify.ts
+var listSchema = z3.looseObject({
+  tools: z3.array(z3.looseObject({ name: z3.string() })),
+  nextCursor: z3.string().optional()
+});
+async function toolNames(upstream) {
+  const names = /* @__PURE__ */ new Set();
+  let cursor;
+  do {
+    const page = listSchema.parse(
+      await upstream.client.request(
+        { method: "tools/list", params: cursor === void 0 ? {} : { cursor } },
+        z3.looseObject({})
+      )
+    );
+    for (const tool of page.tools) {
+      names.add(tool.name);
+    }
+    cursor = page.nextCursor;
+  } while (cursor !== void 0);
+  return names;
+}
+async function verifyAgainstServers(upstreams, manifest) {
+  const available = /* @__PURE__ */ new Map();
+  for (const upstream of upstreams) {
+    available.set(upstream.name, await toolNames(upstream));
+  }
+  const problems = [];
+  const check = (qualified, role, match) => {
+    const target = splitQualified(qualified);
+    if (target === void 0) {
+      return;
+    }
+    const names = available.get(target.server);
+    if (names === void 0) {
+      problems.push(`${match}: its ${role} names server ${target.server}, which is not connected`);
+      return;
+    }
+    if (!names.has(target.tool)) {
+      problems.push(
+        `${match}: its ${role} calls ${qualified}, which ${target.server} does not expose`
+      );
+    }
+  };
+  for (const policy of manifest.tools) {
+    if (policy.snapshot !== void 0) {
+      check(policy.snapshot.tool, "snapshot", policy.match);
+    }
+    if (policy.inverse !== void 0) {
+      check(policy.inverse.tool, "inverse", policy.match);
+    }
+  }
+  if (problems.length > 0) {
+    throw new ManifestError(`the manifest calls tools that do not exist:
+  ${problems.join("\n  ")}`);
+  }
+}
+
+// src/proxy/routing.ts
+var SEPARATOR = "__";
+function createRouter(upstreams, manifest) {
+  if (upstreams.length === 0) {
+    throw new ManifestError("no upstream servers were connected");
+  }
+  for (const upstream of upstreams) {
+    if (!(upstream.name in manifest.servers)) {
+      throw new ManifestError(
+        `upstream ${upstream.name} is connected but not declared in the manifest`
+      );
+    }
+    if (upstream.name.includes(SEPARATOR) || upstream.name.includes(".")) {
+      throw new ManifestError(
+        `server name ${upstream.name} may not contain "." or "${SEPARATOR}"; both are reserved for qualifying tool names`
+      );
+    }
+  }
+  const byName = new Map(upstreams.map((upstream) => [upstream.name, upstream]));
+  if (byName.size !== upstreams.length) {
+    throw new ManifestError("two upstreams were connected under the same name");
+  }
+  const prefixed = upstreams.length > 1;
+  const keys = [...byName.keys()].sort((a, b) => b.length - a.length);
+  return {
+    prefixed,
+    upstreams,
+    expose(server, name) {
+      return prefixed ? `${server}${SEPARATOR}${name}` : name;
+    },
+    route(exposed) {
+      if (!prefixed) {
+        const only = upstreams[0];
+        if (only === void 0) {
+          return void 0;
+        }
+        const prefix = `${only.name}${SEPARATOR}`;
+        return exposed.startsWith(prefix) ? { upstream: only, tool: exposed.slice(prefix.length) } : { upstream: only, tool: exposed };
+      }
+      for (const key of keys) {
+        const prefix = `${key}${SEPARATOR}`;
+        if (exposed.startsWith(prefix)) {
+          const upstream = byName.get(key);
+          if (upstream !== void 0) {
+            return { upstream, tool: exposed.slice(prefix.length) };
+          }
+        }
+      }
+      return void 0;
+    },
+    byName(server) {
+      return byName.get(server);
+    }
+  };
+}
+
+// src/proxy/upstream.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function describeError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var PROXY_CLIENT_INFO = { name: "synartesis-proxy", version: "0.0.0" };
+function bufferedText(stream) {
+  if (typeof stream !== "object" || stream === null || !("read" in stream)) {
+    return "";
+  }
+  const read2 = stream.read;
+  if (typeof read2 !== "function") {
+    return "";
+  }
+  const chunk = read2.call(stream);
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  return Buffer.isBuffer(chunk) ? chunk.toString("utf8") : "";
+}
+function lastWords(text) {
+  const lines = text.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim() !== "");
+  const kept = lines.slice(-4).join("; ");
+  return kept === "" ? void 0 : kept;
+}
+async function connectStdioUpstream(spec) {
+  const started = await start(spec);
+  let current = started;
+  return {
+    name: spec.name,
+    get client() {
+      return current.client;
+    },
+    async reconnect() {
+      await current.client.close().catch(() => void 0);
+      current = await start(spec);
+    },
+    close: async () => {
+      await current.client.close();
+    }
+  };
+}
+async function start(spec) {
+  const wanted = spec.stderr ?? "inherit";
+  const transport = new StdioClientTransport({
+    command: spec.command,
+    args: [...spec.args ?? []],
+    ...spec.env === void 0 ? {} : { env: { ...spec.env } },
+    // "pipe" is what the sdk calls it; captured here so a failure can quote it.
+    stderr: wanted === "capture" ? "pipe" : wanted
+  });
+  const client = new Client({ ...PROXY_CLIENT_INFO });
+  let said = "";
+  try {
+    await client.connect(transport);
+  } catch (error) {
+    said = bufferedText(transport.stderr);
+    const reason = lastWords(said);
+    throw new UpstreamError(
+      spec.name,
+      "connect",
+      reason === void 0 ? error : `${describeError(error)} \u2014 the server said: ${reason}`
+    );
+  }
+  return { client };
+}
+
+// src/manifest/match.ts
+function toRegExp(pattern) {
+  const source = pattern.split("*").map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^.]*");
+  return new RegExp(`^${source}$`);
+}
+function literalLength(pattern) {
+  return pattern.length - pattern.split("*").length + 1;
+}
+function failClosed(qualifiedName) {
+  return { match: qualifiedName, class: "irreversible", gate: "always" };
+}
+function createPolicyResolver(manifest) {
+  const compiled = manifest.tools.map((policy) => ({
+    policy,
+    test: toRegExp(policy.match),
+    specificity: literalLength(policy.match),
+    wildcards: policy.match.split("*").length - 1
+  })).sort((a, b) => b.specificity - a.specificity || a.wildcards - b.wildcards);
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    resolve(qualifiedName) {
+      const cached2 = cache.get(qualifiedName);
+      if (cached2 !== void 0) {
+        return cached2;
+      }
+      const hit = compiled.find((candidate) => candidate.test.test(qualifiedName));
+      const match = hit === void 0 ? { policy: failClosed(qualifiedName), matched: false } : { policy: hit.policy, matched: true };
+      cache.set(qualifiedName, match);
+      return match;
+    }
+  };
+}
+
+// src/proxy/snapshot.ts
+import { z as z4 } from "zod";
+var ToolResult = z4.looseObject({
+  isError: z4.boolean().default(false),
+  content: z4.array(z4.looseObject({ type: z4.string() })).default([])
+});
+function refusal(result) {
+  const parsed = ToolResult.safeParse(result);
+  if (!parsed.success || !parsed.data.isError) {
+    return void 0;
+  }
+  const said = parsed.data.content.map((block) => typeof block["text"] === "string" ? block["text"] : "").filter((text) => text !== "").join(" ");
+  return said === "" ? JSON.stringify(result) : said;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toPayload(result) {
+  if (!isRecord(result)) {
+    return result;
+  }
+  const structured = result["structuredContent"];
+  if (structured !== void 0) {
+    return structured;
+  }
+  const content = result["content"];
+  if (Array.isArray(content) && content.length === 1) {
+    const block = content[0];
+    if (isRecord(block) && block["type"] === "text" && typeof block["text"] === "string") {
+      const text = block["text"];
+      try {
+        return JSON.parse(text);
+      } catch {
+        return text;
+      }
+    }
+  }
+  return result;
+}
+function resolveArgs(call, context) {
+  const resolved = resolveTemplate(call.args, context);
+  if (!isRecord(resolved)) {
+    throw new ManifestError(`${call.tool} resolved to arguments that are not an object`);
+  }
+  return resolved;
+}
+function planInverse(call, context) {
+  const target = splitQualified(call.tool);
+  if (target === void 0) {
+    throw new ManifestError(`inverse tool ${call.tool} is not qualified as server.tool`);
+  }
+  return { server: target.server, tool: target.tool, args: resolveArgs(call, context) };
+}
+function planRead(call, context) {
+  const target = splitQualified(call.tool);
+  if (target === void 0) {
+    throw new SnapshotError(call.tool, "the snapshot tool is not qualified as server.tool");
+  }
+  try {
+    return { server: target.server, tool: target.tool, args: resolveArgs(call, context) };
+  } catch (error) {
+    throw new SnapshotError(call.tool, describe(error), { cause: error });
+  }
+}
+function isDisconnected(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Not connected") || message.includes("Connection closed");
+}
+function mayHaveArrived(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Connection closed");
+}
+async function runRead(router, read2, signal) {
+  const label = `${read2.server}.${read2.tool}`;
+  const upstream = router.byName(read2.server);
+  if (upstream === void 0) {
+    throw new SnapshotError(label, `server ${read2.server} is not connected`);
+  }
+  const { tool, args } = read2;
+  const ask = () => upstream.client.request(
+    { method: "tools/call", params: { name: tool, arguments: args } },
+    z4.looseObject({}),
+    { signal }
+  );
+  let raw;
+  try {
+    raw = await ask();
+  } catch (error) {
+    if (!isDisconnected(error) || upstream.reconnect === void 0) {
+      throw new SnapshotError(label, describe(error), { cause: error });
+    }
+    try {
+      await upstream.reconnect();
+      raw = await ask();
+    } catch (retry) {
+      if (isDisconnected(retry)) {
+        await upstream.reconnect().catch(() => void 0);
+      }
+      throw new SnapshotError(
+        label,
+        `${describe(error)} (the connection to ${read2.server} was restarted and the read failed again: ${describe(retry)})`,
+        { cause: retry }
+      );
+    }
+  }
+  const parsed = ToolResult.safeParse(raw);
+  if (parsed.success && parsed.data.isError) {
+    throw new SnapshotError(label, `the read reported an error: ${JSON.stringify(raw)}`, {
+      absent: true
+    });
+  }
+  return toPayload(raw);
+}
+async function observeState(router, read2, signal) {
+  try {
+    return { present: true, value: await runRead(router, read2, signal) };
+  } catch (error) {
+    if (error instanceof SnapshotError && error.absent) {
+      return { present: false };
+    }
+    throw error;
+  }
+}
+
+export {
+  cliCommand,
+  cliCommandFrom,
+  proxyCommand,
+  findManifest,
+  findJournal,
+  style,
+  WORDMARK,
+  rule,
+  mark,
+  banner,
+  canonical,
+  openJournal,
+  labelFor,
+  wasRefused,
+  parseManifest,
+  loadManifest,
+  qualify,
+  verifyAgainstServers,
+  createPolicyResolver,
+  createRouter,
+  refusal,
+  toPayload,
+  planInverse,
+  planRead,
+  isDisconnected,
+  mayHaveArrived,
+  runRead,
+  observeState,
+  connectStdioUpstream
+};
+//# sourceMappingURL=chunk-X4VQNEP5.js.map