@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-VB3H5WWB.js

@@ -0,0 +1,151 @@
+// src/utils/child-env.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "PATH",
+  "HOME",
+  "USER",
+  "USERNAME",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TERM",
+  "TZ",
+  "TMPDIR",
+  "TEMP",
+  "TMP",
+  "PWD",
+  "OLDPWD",
+  "COMSPEC",
+  "SYSTEMROOT",
+  "SYSTEMDRIVE",
+  "WINDIR",
+  "PROGRAMFILES",
+  "PROGRAMFILES(X86)",
+  "PROGRAMDATA",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "USERPROFILE",
+  "PUBLIC",
+  "PATHEXT"
+]);
+var SECRET_NAME_PARTS = [
+  "TOKEN",
+  "SECRET",
+  "PASSWORD",
+  "PASSWD",
+  // WRONGSTACK_VAULT_PASSPHRASE is the vault KEK. Without this entry it matched
+  // no rule here and fell through to the `WRONGSTACK_` prefix allow-rule, so the
+  // key that protects the credential vault was forwarded to every child process
+  // — including the agent's own exec/bash tools and MCP stdio servers (WS-033).
+  "PASSPHRASE",
+  "AUTH",
+  "CRED",
+  "BEARER",
+  "COOKIE",
+  "PRIVATE"
+];
+function looksSecret(name) {
+  const upper = name.toUpperCase();
+  for (const p of SECRET_NAME_PARTS) {
+    if (upper.includes(p)) return true;
+  }
+  if (/(?:^|_)KEY(?:$|_|S$)/i.test(upper)) return true;
+  if (/API[_-]?KEY/i.test(upper)) return true;
+  if (/ACCESS[_-]?KEY/i.test(upper)) return true;
+  if (/SESSION[_-]?ID/i.test(upper) === false && /SESSION/i.test(upper)) {
+    return true;
+  }
+  return false;
+}
+function valueHasEmbeddedCredential(value) {
+  return /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]*:[^/\s@]+@/i.test(value);
+}
+var NODE_OPTIONS_INJECTION_FLAG = /^(?:--require|-r|--import|--loader|--experimental-loader)$/;
+var NODE_OPTIONS_INJECTION_FLAG_EQ = /^(?:--require|-r|--import|--loader|--experimental-loader)=/;
+function sanitizeNodeOptions(value) {
+  const tokens = value.split(/\s+/).filter(Boolean);
+  const kept = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i];
+    if (NODE_OPTIONS_INJECTION_FLAG_EQ.test(tok)) continue;
+    if (NODE_OPTIONS_INJECTION_FLAG.test(tok)) {
+      i++;
+      continue;
+    }
+    kept.push(tok);
+  }
+  return kept.join(" ");
+}
+var gitIdentity = null;
+function configureChildEnvGitIdentity(identity) {
+  const name = identity?.name?.trim();
+  const email = identity?.email?.trim();
+  gitIdentity = name || email ? { name: name || void 0, email: email || void 0 } : null;
+}
+function getChildEnvGitIdentity() {
+  return gitIdentity;
+}
+function buildChildEnv(optsOrSessionId) {
+  const opts = typeof optsOrSessionId === "string" ? { sessionId: optsOrSessionId } : optsOrSessionId ?? {};
+  const hasOwn = Object.hasOwn(process.env, "WRONGSTACK_CHILD_ENV_PASSTHROUGH");
+  const legacyHasOwn = Object.hasOwn(process.env, "WRONGSTACK_BASH_ENV_PASSTHROUGH");
+  const passthrough = hasOwn && process.env["WRONGSTACK_CHILD_ENV_PASSTHROUGH"] === "1" || legacyHasOwn && process.env["WRONGSTACK_BASH_ENV_PASSTHROUGH"] === "1";
+  if (passthrough && !process.env["CI"]) {
+    console.warn(
+      "[agent] WARNING: WRONGSTACK_*_ENV_PASSTHROUGH=1 is active \u2014\n  all parent env vars (including API keys) forwarded to child processes.\n  Do not use on shared or multi-tenant systems."
+    );
+  }
+  const out = {};
+  const nodeEnvDefaulted = process.env["WRONGSTACK_NODE_ENV_DEFAULTED"] === "1";
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v === void 0) continue;
+    if (nodeEnvDefaulted && (k === "NODE_ENV" || k === "WRONGSTACK_NODE_ENV_DEFAULTED")) continue;
+    if (passthrough) {
+      out[k] = v;
+      continue;
+    }
+    const upper = k.toUpperCase();
+    if (valueHasEmbeddedCredential(v)) continue;
+    if (ALLOWED_KEYS.has(upper)) {
+      out[k] = v;
+      continue;
+    }
+    if (looksSecret(upper)) continue;
+    if (upper === "NODE_OPTIONS") {
+      const sanitized = sanitizeNodeOptions(v);
+      if (sanitized) out[k] = sanitized;
+      continue;
+    }
+    if (upper.startsWith("NODE_") || upper.startsWith("NPM_") || upper.startsWith("PNPM_") || upper.startsWith("YARN_") || upper.startsWith("GIT_") || upper.startsWith("CI") || upper.startsWith("XDG_") || // Our own non-secret knobs (WRONGSTACK_HOME, WRONGSTACK_SESSION_ID, …).
+    // Secrets never live in WRONGSTACK_* env vars (they're in the encrypted
+    // vault). Forwarding keeps child wstack processes — e.g. ones spawned
+    // by the test suite — inside the same redirected global root.
+    upper.startsWith("WRONGSTACK_") || upper === "EDITOR" || upper === "VISUAL" || upper === "PAGER") {
+      out[k] = v;
+    }
+  }
+  if (gitIdentity) {
+    if (gitIdentity.name) {
+      out["GIT_AUTHOR_NAME"] = gitIdentity.name;
+      out["GIT_COMMITTER_NAME"] = gitIdentity.name;
+    }
+    if (gitIdentity.email) {
+      out["GIT_AUTHOR_EMAIL"] = gitIdentity.email;
+      out["GIT_COMMITTER_EMAIL"] = gitIdentity.email;
+    }
+  }
+  if (opts.extra) {
+    Object.assign(out, opts.extra);
+  }
+  if (opts.sessionId) out["WRONGSTACK_SESSION_ID"] = opts.sessionId;
+  return out;
+}
+
+export {
+  sanitizeNodeOptions,
+  configureChildEnvGitIdentity,
+  getChildEnvGitIdentity,
+  buildChildEnv
+};
+//# sourceMappingURL=chunk-VB3H5WWB.js.map

package/dist/chunk-W4A6QA3D.js

@@ -0,0 +1,258 @@
+// src/coordination/mailbox-type-properties.ts
+var MAILBOX_TYPE_PROPERTIES = {
+  note: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 20,
+    recipientObligation: "Read for context; no reply needed.",
+    senderGuidance: "General-purpose FYI. Use when no more specific type applies."
+  },
+  ask: {
+    category: "actionable",
+    expectsReply: true,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Answer as soon as possible \u2014 the sender is waiting.",
+    senderGuidance: "Blocking question. Only use when you need an answer to proceed."
+  },
+  assign: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Accept or decline; act on it when current operation allows.",
+    senderGuidance: 'Task delegation. Must be directed to a specific recipient (not "*").'
+  },
+  steer: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 0,
+    // Always rendered first
+    recipientObligation: "Pause current approach, adjust per instruction, then resume.",
+    senderGuidance: "Mid-task direction change. The recipient is already working on something."
+  },
+  btw: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 30,
+    recipientObligation: "Absorb the information and stay on current task; no reply needed.",
+    senderGuidance: "Low-priority aside. Non-urgent info that can wait."
+  },
+  broadcast: {
+    category: "routing",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 20,
+    recipientObligation: 'Read if addressed to you (direct recipient, alias, or "*").',
+    senderGuidance: 'Multi-recipient envelope. Auto-selected when to is "*" or "@session".'
+  },
+  status: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: false,
+    renderPriority: 40,
+    recipientObligation: "Use to avoid redundant work; never act on as a task or question.",
+    senderGuidance: "Agent/system status update. Machine-generated, not for human-originated messages."
+  },
+  result: {
+    category: "informational",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Factor into next decision; treat as evidence, not a new task.",
+    senderGuidance: "Task completion notice. Share the outcome of finished work."
+  },
+  review: {
+    category: "actionable",
+    expectsReply: false,
+    requiresAction: true,
+    backgroundEligible: true,
+    outOfBand: false,
+    renderPriority: 10,
+    recipientObligation: "Inspect when convenient; no immediate reply required.",
+    senderGuidance: "Passive review request (code/doc/PR). No reply required."
+  },
+  control: {
+    category: "control_signal",
+    expectsReply: false,
+    requiresAction: false,
+    backgroundEligible: false,
+    outOfBand: true,
+    renderPriority: 999,
+    // Never rendered
+    recipientObligation: 'Handled by the agent loop, NOT folded into conversation. "interrupt" causes cooperative halt.',
+    senderGuidance: "RESERVED for runtime use. Agents must NOT send control messages."
+  }
+};
+
+// src/coordination/mailbox-predicates.ts
+function mailboxIdentityBase(agentId) {
+  return agentId.split(/[@#]/, 1)[0].trim().toLowerCase();
+}
+function isMailboxLeader(agentId, role) {
+  return mailboxIdentityBase(agentId) === "leader" || role?.trim().toLowerCase() === "leader";
+}
+function isMailboxSenderInFamily(senderId, family) {
+  const base = mailboxIdentityBase(senderId);
+  const normalizedFamily = family.trim().toLowerCase();
+  if (normalizedFamily.length === 0) return false;
+  return base === normalizedFamily || base.startsWith(`${normalizedFamily}-`);
+}
+function isMailboxMessageVisibleTo(message, agentId, role) {
+  return message.audience !== "leaders" || isMailboxLeader(agentId, role);
+}
+function validateSendType(type, to) {
+  if (type === "control") {
+    throw new TypeError('Type "control" is reserved for runtime use and cannot be set by agents');
+  }
+  const isMultiRecipient = to === "*" || to.startsWith("@session:");
+  if (type === "assign" && isMultiRecipient) {
+    throw new TypeError(
+      `Type "assign" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
+    );
+  }
+  if (type === "steer" && isMultiRecipient) {
+    throw new TypeError(
+      `Type "steer" requires a specific recipient \u2014 multi-recipient target "${to}" is ambiguous`
+    );
+  }
+}
+var SESSION_RECIPIENT_PREFIX = "@session:";
+function sessionRecipient(sessionId) {
+  const normalizedSessionId = sessionId.trim();
+  if (!normalizedSessionId) {
+    throw new TypeError('sessionId is required for the "@session" recipient');
+  }
+  return `${SESSION_RECIPIENT_PREFIX}${normalizedSessionId}`;
+}
+function normalizeRecipient(to, sessionId) {
+  const trimmed = to.trim();
+  const normalized = trimmed.toLowerCase();
+  if (normalized === "all") return "*";
+  if (normalized === "@session") return sessionRecipient(sessionId ?? "");
+  return trimmed;
+}
+function isMailboxReceiptRecordV2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const v = value;
+  if (v["__mailboxReceipt"] !== 2) return false;
+  if (typeof v["messageId"] !== "string" || v["messageId"].length === 0) return false;
+  if (typeof v["actorId"] !== "string" || v["actorId"].length === 0) return false;
+  if (typeof v["timestamp"] !== "string" || v["timestamp"].length === 0) return false;
+  if ("read" in v && typeof v["read"] !== "boolean") return false;
+  if ("completed" in v && typeof v["completed"] !== "boolean") return false;
+  if ("outcome" in v && v["outcome"] !== void 0 && typeof v["outcome"] !== "string")
+    return false;
+  return true;
+}
+function isActionRequiredForActor(message, projection) {
+  if (projection.legacyGlobalCompletion) return false;
+  if (message.deletedAt !== void 0) return false;
+  if (projection.completedByMe) return false;
+  return MAILBOX_TYPE_PROPERTIES[message.type]?.requiresAction === true;
+}
+
+// src/coordination/mailbox-auth-types.ts
+var MAILBOX_CAPABILITY_IMPLICATIONS = {
+  "mail.read.all": ["mail.read.self"],
+  "mail.events.all": ["mail.events.self"],
+  "mail.send.directive": ["mail.send.actionable", "mail.send.informational"],
+  "mail.send.actionable": ["mail.send.informational"],
+  // Leaf capabilities imply nothing further.
+  "mail.send.informational": [],
+  "mail.read.self": [],
+  "mail.ack.self": [],
+  "mail.events.self": [],
+  "mail.presence.register.self": [],
+  "mail.presence.heartbeat.self": [],
+  "mail.presence.deregister.self": [],
+  "mail.presence.read": [],
+  "mail.retention.purge": [],
+  "mail.retention.clear": [],
+  "mail.admin.receipts": []
+};
+function expandMailboxCapabilities(caps) {
+  const result = /* @__PURE__ */ new Set();
+  const queue = [...caps];
+  while (queue.length > 0) {
+    const cap = queue.pop();
+    if (result.has(cap)) continue;
+    result.add(cap);
+    const implied = MAILBOX_CAPABILITY_IMPLICATIONS[cap];
+    if (implied) queue.push(...implied);
+  }
+  return result;
+}
+function hasMailboxCapability(actor, cap) {
+  if (actor.capabilities.has(cap)) return true;
+  const expanded = expandMailboxCapabilities(actor.capabilities);
+  return expanded.has(cap);
+}
+
+// src/coordination/mailbox-session-sync.ts
+function isAffectedBySessionAffinity(message) {
+  return message.sessionAffinity !== void 0;
+}
+async function acceptMailboxMessageForSession(message, currentSessionId, ctx) {
+  if (!isAffectedBySessionAffinity(message)) return true;
+  const affinity = message.sessionAffinity;
+  if (affinity === null || typeof affinity !== "object" || Array.isArray(affinity)) {
+    return false;
+  }
+  if (affinity.sessionId !== void 0 && typeof affinity.sessionId !== "string" || affinity.reportId !== void 0 && typeof affinity.reportId !== "string") {
+    return false;
+  }
+  if (!currentSessionId) {
+    return ctx?.allowUnscoped === true;
+  }
+  if (typeof affinity.sessionId === "string" && affinity.sessionId.length > 0) {
+    if (affinity.sessionId !== currentSessionId) return false;
+    return true;
+  }
+  if (affinity.reportId && ctx?.resolveChimeraReportSessionId) {
+    try {
+      const resolved = await ctx.resolveChimeraReportSessionId(affinity.reportId);
+      if (resolved === currentSessionId) return true;
+      if (resolved !== void 0) return false;
+    } catch {
+    }
+  }
+  if (ctx?.allowUnscoped === true) return true;
+  return false;
+}
+
+export {
+  MAILBOX_TYPE_PROPERTIES,
+  hasMailboxCapability,
+  mailboxIdentityBase,
+  isMailboxLeader,
+  isMailboxSenderInFamily,
+  isMailboxMessageVisibleTo,
+  validateSendType,
+  SESSION_RECIPIENT_PREFIX,
+  sessionRecipient,
+  normalizeRecipient,
+  isMailboxReceiptRecordV2,
+  isActionRequiredForActor,
+  acceptMailboxMessageForSession
+};
+//# sourceMappingURL=chunk-W4A6QA3D.js.map

package/dist/chunk-WBPVKEEE.js

@@ -0,0 +1,227 @@
+import {
+  color,
+  writeErr
+} from "./chunk-4VWO3ZXL.js";
+
+// src/infrastructure/logger.ts
+import * as fsp from "node:fs/promises";
+import * as path from "node:path";
+var LEVEL_RANK = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var COLORS = {
+  error: color.red,
+  warn: color.yellow,
+  info: color.cyan,
+  debug: color.gray,
+  trace: color.dim
+};
+var LOG_LEVELS = /* @__PURE__ */ new Set(["error", "warn", "info", "debug", "trace"]);
+var LOG_FORMATS = /* @__PURE__ */ new Set(["pretty", "json"]);
+var DefaultLogger = class _DefaultLogger {
+  /** How many file writes between rotation size checks (statSync is not free). */
+  static ROTATE_CHECK_EVERY = 100;
+  static MAX_PENDING_FILE_WRITES = 2e3;
+  static MAX_PENDING_FILE_BYTES = 8 * 1024 * 1024;
+  level;
+  file;
+  bindings;
+  format;
+  stderr;
+  maxFileBytes;
+  writesSinceRotateCheck = 0;
+  /**
+   * Serialized async tail for file writes. Every appendFile (and any
+   * chained rotation) is awaited through this promise so file I/O
+   * never overlaps itself — preserving the per-line ordering the
+   * sync version had, but without blocking the caller thread. Any
+   * rejection is swallowed (`catch(() => {})`) because logging must
+   * never crash the host.
+   *
+   * Children share the parent's tail: `child.tail === parent.tail`
+   * for the lifetime of the chain. Read/write access goes through
+   * `_tail` so that, when a child has been wired to a parent, both
+   * `enqueueRotate` and `log` always observe the parent's current tail
+   * rather than a stale snapshot taken at `child()` time.
+   */
+  tail = Promise.resolve();
+  parent = null;
+  pendingFileWrites = 0;
+  pendingFileBytes = 0;
+  get root() {
+    return this.parent ? this.parent.root : this;
+  }
+  /**
+   * Resolve the current tail. For the root logger this is the field;
+   * for a child logger we always read through the parent so that a
+   * child's appends land on the parent's most recent tail, and a
+   * parent's `flush()` waits for everything the child chained.
+   */
+  get _tail() {
+    return this.parent ? this.parent._tail : this.tail;
+  }
+  set _tail(next) {
+    if (this.parent) this.parent.tail = next;
+    else this.tail = next;
+  }
+  constructor(opts = {}) {
+    this.level = opts.level ?? parseLogLevel(process.env.WRONGSTACK_LOG_LEVEL);
+    this.file = opts.file;
+    this.bindings = opts.bindings ?? {};
+    this.format = opts.format ?? parseLogFormat(process.env.WRONGSTACK_LOG_FORMAT);
+    this.stderr = opts.stderr !== false;
+    this.maxFileBytes = opts.maxFileBytes ?? 10 * 1024 * 1024;
+    if (this.file) {
+      const dir = path.dirname(this.file);
+      this._tail = this._tail.then(async () => {
+        await fsp.mkdir(dir, { recursive: true });
+      }).catch(() => void 0);
+    }
+  }
+  error(msg, ctx) {
+    this.log("error", msg, ctx);
+  }
+  warn(msg, ctx) {
+    this.log("warn", msg, ctx);
+  }
+  info(msg, ctx) {
+    this.log("info", msg, ctx);
+  }
+  debug(msg, ctx) {
+    this.log("debug", msg, ctx);
+  }
+  trace(msg, ctx) {
+    this.log("trace", msg, ctx);
+  }
+  child(bindings) {
+    const child = Object.create(_DefaultLogger.prototype);
+    child.level = this.level;
+    child.file = this.file;
+    child.bindings = { ...this.bindings, ...bindings };
+    child.format = this.format;
+    child.stderr = this.stderr;
+    child.maxFileBytes = this.maxFileBytes;
+    child.parent = this;
+    child.writesSinceRotateCheck = this.writesSinceRotateCheck;
+    return child;
+  }
+  /**
+   * Wait until all queued file writes (and any pending rotation) have
+   * completed. `log()` is fire-and-forget by design — the caller never
+   * blocks on disk — so tests, shutdown handlers, and processes that
+   * need a deterministic "everything is on disk now" guarantee should
+   * `await logger.flush()` before reading the file or exiting.
+   */
+  flush() {
+    return this._tail;
+  }
+  /**
+   * Size-based rotation: when the file outgrows `maxFileBytes`, rename it to
+   * `<file>.1` (dropping the previous `.1`) so the live file restarts empty.
+   * Checked on the first write and every ROTATE_CHECK_EVERY writes after.
+   * Best-effort: a rename can fail on Windows while another process holds
+   * the file — the next check retries. Multiple processes appending to the
+   * same log all run this check; whoever crosses the threshold first wins.
+   *
+   * Async: the rotation runs on the file-write tail (so its writes don't
+   * interleave with the next append), and the caller never blocks on a
+   * statSync / renameSync syscall on the hot log path.
+   */
+  enqueueRotate(file) {
+    if (this.writesSinceRotateCheck++ % _DefaultLogger.ROTATE_CHECK_EVERY !== 0) return;
+    this._tail = this._tail.then(async () => {
+      let st;
+      try {
+        st = await fsp.stat(file);
+      } catch {
+        return;
+      }
+      if (st.size < this.maxFileBytes) return;
+      try {
+        await fsp.rm(`${file}.1`, { force: true });
+        await fsp.rename(file, `${file}.1`);
+      } catch {
+      }
+    }).catch(() => void 0);
+  }
+  log(level, msg, ctx) {
+    const r = LEVEL_RANK[level];
+    const allowed = LEVEL_RANK[this.level];
+    if (r > allowed) return;
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const entry = { ts, level, msg, ...this.bindings };
+    if (ctx !== void 0) {
+      entry.ctx = ctx instanceof Error ? { message: ctx.message, stack: ctx.stack } : ctx;
+    }
+    if (this.file) {
+      const line = `${JSON.stringify(entry)}
+`;
+      const bytes = Buffer.byteLength(line, "utf8");
+      const root = this.root;
+      if (root.pendingFileWrites < _DefaultLogger.MAX_PENDING_FILE_WRITES && bytes <= _DefaultLogger.MAX_PENDING_FILE_BYTES && root.pendingFileBytes + bytes <= _DefaultLogger.MAX_PENDING_FILE_BYTES) {
+        root.pendingFileWrites += 1;
+        root.pendingFileBytes += bytes;
+        this.enqueueRotate(this.file);
+        this._tail = this._tail.then(() => fsp.appendFile(this.file, line, { mode: 384 })).catch(() => void 0).finally(() => {
+          root.pendingFileWrites = Math.max(0, root.pendingFileWrites - 1);
+          root.pendingFileBytes = Math.max(0, root.pendingFileBytes - bytes);
+        });
+      }
+    }
+    if (!this.stderr) return;
+    if (this.format === "json") {
+      writeErr(`${JSON.stringify(entry)}
+`);
+    } else {
+      const head = `${color.dim(ts)} ${COLORS[level](level.toUpperCase().padEnd(5))} ${msg}`;
+      if (ctx !== void 0) {
+        writeErr(`${head} ${formatCtx(ctx)}
+`);
+      } else {
+        writeErr(`${head}
+`);
+      }
+    }
+  }
+};
+function parseLogLevel(raw) {
+  return raw && LOG_LEVELS.has(raw) ? raw : "info";
+}
+function parseLogFormat(raw) {
+  return raw && LOG_FORMATS.has(raw) ? raw : "pretty";
+}
+function formatCtx(ctx) {
+  if (ctx instanceof Error) return color.dim(ctx.message);
+  if (typeof ctx === "string") return color.dim(ctx);
+  try {
+    return color.dim(JSON.stringify(ctx));
+  } catch {
+    return color.dim(String(ctx));
+  }
+}
+var noOpLogger = {
+  // 'error' is the quietest level the Logger contract offers; the methods
+  // discard everything regardless, this only matters to level checks.
+  level: "error",
+  error: () => {
+  },
+  warn: () => {
+  },
+  info: () => {
+  },
+  debug: () => {
+  },
+  trace: () => {
+  },
+  child: () => noOpLogger
+};
+
+export {
+  DefaultLogger,
+  noOpLogger
+};
+//# sourceMappingURL=chunk-WBPVKEEE.js.map