@lambdacurry/arbor 0.24.14 → 0.24.16

package/dist/arbor.js

@@ -1,2041 +1,1348 @@
 #!/usr/bin/env node
 
-// src/config.ts
-import {
-  chmodSync,
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  statSync,
-  writeFileSync
-} from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-// src/errors.ts
-var ERROR_CODES = new Set([
-  "UNAUTHORIZED",
-  "FORBIDDEN",
-  "NOT_FOUND",
-  "VALIDATION",
-  "CONFLICT",
-  "RATE_LIMITED",
-  "NETWORK",
-  "INTERNAL"
-]);
-function isErrorCode(value) {
-  return typeof value === "string" && ERROR_CODES.has(value);
-}
-function codeForStatus(status) {
-  switch (status) {
-    case 0:
-      return "NETWORK";
-    case 400:
-    case 422:
-      return "VALIDATION";
-    case 401:
-      return "UNAUTHORIZED";
-    case 403:
-      return "FORBIDDEN";
-    case 404:
-    case 410:
-      return "NOT_FOUND";
-    case 409:
-      return "CONFLICT";
-    case 429:
-      return "RATE_LIMITED";
-    default:
-      return "INTERNAL";
-  }
+// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/util.js
+function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
+  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
+  return values;
 }
-function exitCodeForError(code) {
-  switch (code) {
-    case "VALIDATION":
-      return 2;
-    case "UNAUTHORIZED":
-      return 22;
-    default:
-      return 1;
-  }
+function joinValues(array, separator = "|") {
+  return array.map((val) => stringifyPrimitive(val)).join(separator);
 }
-function codeForError(err) {
-  if (err && typeof err === "object" && "code" in err && isErrorCode(err.code)) {
-    return err.code;
-  }
-  return "INTERNAL";
+function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  return value;
 }
-function parseErrorDetails(value) {
-  if (!value || typeof value !== "object")
-    return;
-  const raw = value;
-  if (typeof raw.reason !== "string" || raw.reason === "")
-    return;
-  const details = { reason: raw.reason };
-  if (typeof raw.field === "string")
-    details.field = raw.field;
-  if (typeof raw.limit === "number")
-    details.limit = raw.limit;
-  if (typeof raw.retryable === "boolean")
-    details.retryable = raw.retryable;
-  if (typeof raw.phase === "string")
-    details.phase = raw.phase;
-  if (raw.provider && typeof raw.provider === "object" && !Array.isArray(raw.provider)) {
-    const provider = raw.provider;
-    if (typeof provider.stage === "string" && provider.stage !== "") {
-      details.provider = {
-        stage: provider.stage,
-        ...typeof provider.exitCode === "number" ? { exitCode: provider.exitCode } : {},
-        ...typeof provider.stdout === "string" ? { stdout: provider.stdout } : {},
-        ...typeof provider.stderr === "string" ? { stderr: provider.stderr } : {},
-        ...typeof provider.containerStarted === "boolean" ? { containerStarted: provider.containerStarted } : {},
-        ...typeof provider.repositoryMaterialized === "boolean" ? { repositoryMaterialized: provider.repositoryMaterialized } : {}
-      };
-    }
-  }
-  if (typeof raw.runId === "string")
-    details.runId = raw.runId;
-  if (typeof raw.operationId === "string")
-    details.operationId = raw.operationId;
-  if (typeof raw.processId === "string")
-    details.processId = raw.processId;
-  if (raw.outputRetention && typeof raw.outputRetention === "object") {
-    const retention = raw.outputRetention;
-    if (retention.state === "expired" && typeof retention.expiresAt === "string") {
-      details.outputRetention = { state: "expired", expiresAt: retention.expiresAt };
+function cached(getter) {
+  const set = false;
+  return {
+    get value() {
+      if (!set) {
+        const value = getter();
+        Object.defineProperty(this, "value", { value });
+        return value;
+      }
+      throw new Error("cached value already set");
     }
-  }
-  if (raw.commandExecution === "not-routed" || raw.commandExecution === "unknown") {
-    details.commandExecution = raw.commandExecution;
-  }
-  if (raw.mutationRetrySafety === "safe" || raw.mutationRetrySafety === "unsafe" || raw.mutationRetrySafety === "unknown") {
-    details.mutationRetrySafety = raw.mutationRetrySafety;
-  }
-  if (typeof raw.compatibilityState === "string") {
-    details.compatibilityState = raw.compatibilityState;
-  }
-  if (typeof raw.compatibilityReason === "string") {
-    details.compatibilityReason = raw.compatibilityReason;
-  }
-  if (typeof raw.suggestedAction === "string")
-    details.suggestedAction = raw.suggestedAction;
-  if (typeof raw.catalogRevision === "string")
-    details.catalogRevision = raw.catalogRevision;
-  if (typeof raw.clientCatalogRevision === "string") {
-    details.clientCatalogRevision = raw.clientCatalogRevision;
-  }
-  if (typeof raw.catalogNextStep === "string")
-    details.catalogNextStep = raw.catalogNextStep;
-  return details;
+  };
 }
-function detailsForError(err) {
-  if (!err || typeof err !== "object" || !("details" in err))
-    return;
-  return parseErrorDetails(err.details);
+function nullish(input) {
+  return input === null || input === undefined;
 }
-
-class ApiError extends Error {
-  status;
-  details;
-  code;
-  constructor(message, status, details) {
-    super(message);
-    this.status = status;
-    this.details = details;
-    this.name = "ApiError";
-    this.code = codeForStatus(status);
-  }
+function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
 }
-
-class UsageError extends Error {
-  code = "VALIDATION";
-  details;
-  constructor(message, details) {
-    super(message);
-    this.name = "UsageError";
-    this.details = details ?? { reason: "validation.invalid_value" };
-  }
+function floatSafeRemainder(val, step) {
+  const ratio = val / step;
+  const roundedRatio = Math.round(ratio);
+  const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
+  if (Math.abs(ratio - roundedRatio) < tolerance)
+    return 0;
+  return ratio - roundedRatio;
 }
-
-class PartialUploadError extends Error {
-  partialResult;
-  code;
-  details;
-  constructor(message, cause, partialResult) {
-    super(message);
-    this.partialResult = partialResult;
-    this.name = "PartialUploadError";
-    this.code = codeForError(cause);
-    this.details = detailsForError(cause);
-  }
+var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
+function defineLazy(object, key, getter) {
+  let value = undefined;
+  Object.defineProperty(object, key, {
+    get() {
+      if (value === EVALUATING) {
+        return;
+      }
+      if (value === undefined) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object, key, {
+        value: v
+      });
+    },
+    configurable: true
+  });
 }
-
-// src/config.ts
-var PROD_API_URL = "https://arborthreads.com";
-var PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-function arborDir() {
-  return join(homedir(), ".arbor");
+function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
 }
-function defaultConfigPath() {
-  return join(arborDir(), "config.json");
+function mergeDefs(...defs) {
+  const mergedDescriptors = {};
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+  return Object.defineProperties({}, mergedDescriptors);
 }
-function profilesDir() {
-  return join(arborDir(), "profiles");
+function esc(str) {
+  return JSON.stringify(str);
 }
-function registryPath() {
-  return join(arborDir(), "profiles.json");
+function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
 }
-function namedConfigPath(name) {
-  return join(profilesDir(), `${name}.json`);
+var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
+function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
 }
-var CONFIG_PATH = process.env.ARBOR_CONFIG ?? join(homedir(), ".arbor", "config.json");
-var DEFAULT_TOKEN_OVERWRITE_REFUSAL = "refusing to overwrite ~/.arbor/config.json — a token already exists. Set ARBOR_CONFIG to an isolated path (e.g. ~/.arbor/<agent>.config.json) and retry.";
-var LOCK_TIMEOUT_MS = 5000;
-var LOCK_STALE_MS = 30000;
-var LOCK_POLL_MS = 20;
-var activeTarget;
-function sleepSync(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-function acquireConfigLock(configPath) {
-  const lockPath = `${configPath}.lock`;
-  const deadline = Date.now() + LOCK_TIMEOUT_MS;
-  for (;; ) {
-    try {
-      mkdirSync(lockPath);
-      return () => {
-        try {
-          rmSync(lockPath, { recursive: true, force: true });
-        } catch {}
-      };
-    } catch (err) {
-      if (err?.code !== "EEXIST")
-        throw err;
-      try {
-        if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
-          rmSync(lockPath, { recursive: true, force: true });
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      if (Date.now() >= deadline) {
-        throw new Error(`timed out waiting for another arbor process to finish writing ${configPath}. If none is running, remove ${lockPath}.`);
-      }
-      sleepSync(LOCK_POLL_MS);
-    }
+var allowsEval = /* @__PURE__ */ cached(() => {
+  if (globalConfig.jitless) {
+    return false;
   }
-}
-function validateProfileName(name, field = "profile") {
-  if (!PROFILE_NAME.test(name)) {
-    throw new UsageError(`invalid profile name: ${JSON.stringify(name)}`, {
-      reason: "validation.invalid_value",
-      field
-    });
+  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
+    return false;
   }
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+function isPlainObject(o) {
+  if (isObject(o) === false)
+    return false;
+  const ctor = o.constructor;
+  if (ctor === undefined)
+    return true;
+  if (typeof ctor !== "function")
+    return true;
+  const prot = ctor.prototype;
+  if (isObject(prot) === false)
+    return false;
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
 }
-function fsType(entry, predicate) {
-  const value = entry[predicate];
-  return typeof value === "function" ? Boolean(value.call(entry)) : value === true;
-}
-function rejectSymlink(path, label) {
-  if (!existsSync(path))
-    return;
-  if (fsType(lstatSync(path), "isSymbolicLink"))
-    throw new Error(`${label} must not be a symbolic link: ${path}`);
+function shallowClone(o) {
+  if (isPlainObject(o))
+    return { ...o };
+  if (Array.isArray(o))
+    return [...o];
+  if (o instanceof Map)
+    return new Map(o);
+  if (o instanceof Set)
+    return new Set(o);
+  return o;
 }
-function ensureArborDir() {
-  const dir = arborDir();
-  rejectSymlink(dir, "Arbor config directory");
-  mkdirSync(dir, { recursive: true, mode: 448 });
-  chmodSync(dir, 448);
+var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-function ensureProfilesDir() {
-  ensureArborDir();
-  const dir = profilesDir();
-  rejectSymlink(dir, "Arbor profiles directory");
-  mkdirSync(dir, { recursive: true, mode: 448 });
-  chmodSync(dir, 448);
+function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def ?? inst._zod.def);
+  if (!def || params?.parent)
+    cl._zod.parent = inst;
+  return cl;
 }
-function readRegistry() {
-  const path = registryPath();
-  if (!existsSync(path))
+function normalizeParams(_params) {
+  const params = _params;
+  if (!params)
     return {};
-  rejectSymlink(path, "Arbor profile registry");
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf8"));
-    if (parsed.defaultProfile !== undefined)
-      validateProfileName(parsed.defaultProfile);
-    return { defaultProfile: parsed.defaultProfile };
-  } catch (err) {
-    if (err instanceof UsageError)
-      throw err;
-    throw new Error(`could not read Arbor profile registry ${path}`);
-  }
-}
-function writeRegistry(registry) {
-  ensureArborDir();
-  const path = registryPath();
-  rejectSymlink(path, "Arbor profile registry");
-  const release = acquireConfigLock(path);
-  try {
-    const safe = registry.defaultProfile ? { defaultProfile: registry.defaultProfile } : {};
-    writeFileSync(path, `${JSON.stringify(safe, null, 2)}
-`, { mode: 384 });
-    chmodSync(path, 384);
-  } finally {
-    release();
+  if (typeof params === "string")
+    return { error: () => params };
+  if (params?.message !== undefined) {
+    if (params?.error !== undefined)
+      throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
   }
+  delete params.message;
+  if (typeof params.error === "string")
+    return { ...params, error: () => params.error };
+  return params;
 }
-function profileExists(name, field = "profile") {
-  validateProfileName(name, field);
-  const path = namedConfigPath(name);
-  if (!existsSync(path))
-    return false;
-  rejectSymlink(path, `Arbor profile ${name}`);
-  return fsType(lstatSync(path), "isFile");
+function stringifyPrimitive(value) {
+  if (typeof value === "bigint")
+    return value.toString() + "n";
+  if (typeof value === "string")
+    return `"${value}"`;
+  return `${value}`;
 }
-function legacyTarget() {
-  const defaultPath = defaultConfigPath();
-  const envPath = process.env.ARBOR_CONFIG;
-  return {
-    path: envPath ?? defaultPath,
-    defaultPath,
-    isolated: Boolean(envPath),
-    named: false,
-    explicitProfile: false
-  };
+function optionalKeys(shape) {
+  return Object.keys(shape).filter((k) => {
+    return shape[k]._zod.optin !== undefined && shape[k]._zod.optout === "optional";
+  });
 }
-function resolveTarget(opts) {
-  const profileFlag = opts?.profileFlag;
-  const envProfile = process.env.ARBOR_PROFILE;
-  if (process.env.ARBOR_CONFIG && profileFlag !== undefined) {
-    throw new UsageError("ARBOR_CONFIG and --profile are ambiguous; choose one credential selector", {
-      reason: "validation.invalid_value",
-      field: "profile"
-    });
+var NUMBER_FORMAT_RANGES = /* @__PURE__ */ (() => ({
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+}))();
+function pick(schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".pick() cannot be used on object schemas containing refinements");
   }
-  if (process.env.ARBOR_CONFIG && envProfile !== undefined) {
-    throw new UsageError("ARBOR_CONFIG and ARBOR_PROFILE are ambiguous; choose one credential selector", { reason: "validation.invalid_value", field: "ARBOR_PROFILE" });
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = {};
+      for (const key of Reflect.ownKeys(mask)) {
+        if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
+          throw new Error(`Unrecognized key: "${String(key)}"`);
+        }
+        if (!mask[key])
+          continue;
+        assignProp(newShape, key, currDef.shape[key]);
+      }
+      assignProp(this, "shape", newShape);
+      return newShape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function omit(schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".omit() cannot be used on object schemas containing refinements");
   }
-  if (process.env.ARBOR_CONFIG)
-    return legacyTarget();
-  const registryDefault = readRegistry().defaultProfile;
-  const selected = profileFlag ?? envProfile ?? registryDefault;
-  if (selected === undefined)
-    return legacyTarget();
-  const field = profileFlag !== undefined ? "profile" : envProfile !== undefined ? "ARBOR_PROFILE" : "profile";
-  validateProfileName(selected, field);
-  if (!opts?.allowMissingProfile && !profileExists(selected, field)) {
-    throw new UsageError(`unknown profile: ${selected}`, {
-      reason: "validation.invalid_value",
-      field
-    });
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = { ...schema._zod.def.shape };
+      for (const key of Reflect.ownKeys(mask)) {
+        if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
+          throw new Error(`Unrecognized key: "${String(key)}"`);
+        }
+        if (!mask[key])
+          continue;
+        delete newShape[key];
+      }
+      assignProp(this, "shape", newShape);
+      return newShape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+function extend(schema, shape) {
+  if (!isPlainObject(shape)) {
+    throw new Error("Invalid input to extend: expected a plain object");
   }
-  return {
-    path: namedConfigPath(selected),
-    defaultPath: defaultConfigPath(),
-    isolated: true,
-    profile: selected,
-    named: true,
-    explicitProfile: profileFlag !== undefined
-  };
-}
-function configureConfigTarget(opts) {
-  activeTarget = resolveTarget(opts);
-}
-function currentTarget() {
-  return activeTarget ?? resolveTarget();
-}
-function getConfigPath() {
-  return currentTarget().path;
-}
-function listProfiles() {
-  const registry = readRegistry();
-  const dir = profilesDir();
-  if (!existsSync(dir))
-    return { defaultProfile: registry.defaultProfile, profiles: [] };
-  rejectSymlink(dir, "Arbor profiles directory");
-  const profiles = readdirSync(dir).filter((entry) => entry.endsWith(".json")).map((entry) => {
-    const name = entry.slice(0, -5);
-    validateProfileName(name);
-    const path = join(dir, entry);
-    const stats = lstatSync(path);
-    if (fsType(stats, "isSymbolicLink"))
-      throw new Error(`Arbor profile ${name} must not be a symbolic link: ${path}`);
-    if (!fsType(stats, "isFile"))
-      throw new Error(`Arbor profile ${name} is not a regular file: ${path}`);
-    return { name, default: registry.defaultProfile === name };
-  }).sort((a, b) => a.name.localeCompare(b.name));
-  return { defaultProfile: registry.defaultProfile, profiles };
-}
-function profileShow(name) {
-  validateProfileName(name);
-  if (!profileExists(name)) {
-    throw new UsageError(`unknown profile: ${name}`, {
-      reason: "validation.invalid_value",
-      field: "profile"
-    });
-  }
-  const registry = readRegistry();
-  const cfg = JSON.parse(readFileSync(namedConfigPath(name), "utf8"));
-  return {
-    name,
-    default: registry.defaultProfile === name,
-    apiUrl: cfg.apiUrl || PROD_API_URL
-  };
-}
-function setDefaultProfile(name) {
-  if (name !== null) {
-    validateProfileName(name);
-    if (!profileExists(name)) {
-      throw new UsageError(`unknown profile: ${name}`, {
-        reason: "validation.invalid_value",
-        field: "profile"
-      });
+  const checks = schema._zod.def.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    const existingShape = schema._zod.def.shape;
+    for (const key of Reflect.ownKeys(shape)) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+      }
     }
   }
-  writeRegistry(name ? { defaultProfile: name } : {});
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    }
+  });
+  return clone(schema, def);
 }
-function clearDefaultProfile() {
-  setDefaultProfile(null);
+function safeExtend(schema, shape) {
+  if (!isPlainObject(shape)) {
+    throw new Error("Invalid input to safeExtend: expected a plain object");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = { ...schema._zod.def.shape, ...shape };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    }
+  });
+  return clone(schema, def);
 }
-function deleteProfile(name) {
-  validateProfileName(name);
-  const registry = readRegistry();
-  if (registry.defaultProfile === name) {
-    throw new UsageError(`cannot delete default profile ${name}; select another default or run profile clear-default first`, { reason: "validation.invalid_value", field: "profile" });
+function merge(a, b) {
+  if (!b?._zod?.def) {
+    throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
   }
-  if (!profileExists(name)) {
-    throw new UsageError(`unknown profile: ${name}`, {
-      reason: "validation.invalid_value",
-      field: "profile"
-    });
+  if (a._zod.def.checks?.length) {
+    throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
   }
-  const path = namedConfigPath(name);
-  rejectSymlink(path, `Arbor profile ${name}`);
-  rmSync(path);
+  const def = mergeDefs(a._zod.def, {
+    get shape() {
+      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
+      assignProp(this, "shape", _shape);
+      return _shape;
+    },
+    get catchall() {
+      return b._zod.def.catchall;
+    },
+    checks: b._zod.def.checks ?? []
+  });
+  return clone(a, def);
 }
-function defaultConfigOverwriteBlocked(opts) {
-  const target = currentTarget();
-  const isolated = opts?.isolated ?? target.isolated;
-  const path = opts?.path ?? target.defaultPath;
-  if (isolated)
-    return false;
-  if (!existsSync(path))
-    return false;
-  try {
-    const cfg = JSON.parse(readFileSync(path, "utf8"));
-    return Boolean(cfg.token);
-  } catch {
-    return false;
+function partial(Class, schema, mask, name = "partial") {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
   }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape = { ...oldShape };
+      if (mask) {
+        for (const key of Reflect.ownKeys(mask)) {
+          if (!Object.prototype.hasOwnProperty.call(oldShape, key)) {
+            throw new Error(`Unrecognized key: "${String(key)}"`);
+          }
+          if (!mask[key])
+            continue;
+          shape[key] = Class ? new Class({
+            type: "optional",
+            innerType: oldShape[key]
+          }) : oldShape[key];
+        }
+      } else {
+        for (const key of Reflect.ownKeys(oldShape)) {
+          shape[key] = Class ? new Class({
+            type: "optional",
+            innerType: oldShape[key]
+          }) : oldShape[key];
+        }
+      }
+      assignProp(this, "shape", shape);
+      return shape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
 }
-function loadConfig() {
-  const target = currentTarget();
-  const envToken = target.explicitProfile ? undefined : process.env.ARBOR_TOKEN || undefined;
-  const envUrl = process.env.ARBOR_API_URL || undefined;
-  if (target.named)
-    rejectSymlink(target.path, `Arbor profile ${target.profile}`);
-  if (existsSync(target.path)) {
-    try {
-      const cfg = JSON.parse(readFileSync(target.path, "utf8"));
-      return { apiUrl: envUrl ?? (cfg.apiUrl || PROD_API_URL), token: envToken ?? cfg.token };
-    } catch (err) {
-      if (err instanceof Error && /symbolic link/i.test(err.message))
-        throw err;
+function required(Class, schema, mask) {
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape = { ...oldShape };
+      if (mask) {
+        for (const key of Reflect.ownKeys(mask)) {
+          if (!Object.prototype.hasOwnProperty.call(shape, key)) {
+            throw new Error(`Unrecognized key: "${String(key)}"`);
+          }
+          if (!mask[key])
+            continue;
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]
+          });
+        }
+      } else {
+        for (const key of Reflect.ownKeys(oldShape)) {
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]
+          });
+        }
+      }
+      assignProp(this, "shape", shape);
+      return shape;
     }
-  }
-  return { apiUrl: envUrl ?? PROD_API_URL, token: envToken };
+  });
+  return clone(schema, def);
 }
-function writeConfigGuarded(opts) {
-  mkdirSync(dirname(opts.configPath), { recursive: true });
-  const release = acquireConfigLock(opts.configPath);
-  try {
-    if (!opts.allowDefaultTokenOverwrite && defaultConfigOverwriteBlocked({ isolated: opts.isolated, path: opts.defaultPath })) {
-      throw new Error(DEFAULT_TOKEN_OVERWRITE_REFUSAL);
+function aborted(x, startIndex = 0) {
+  if (x.aborted === true)
+    return true;
+  for (let i = startIndex;i < x.issues.length; i++) {
+    if (x.issues[i]?.continue !== true) {
+      return true;
     }
-    writeFileSync(opts.configPath, `${JSON.stringify(opts.cfg, null, 2)}
-`, { mode: 384 });
-    chmodSync(opts.configPath, 384);
-  } finally {
-    release();
   }
+  return false;
 }
-function saveConfig(cfg, opts) {
-  const target = currentTarget();
-  if (target.named) {
-    ensureProfilesDir();
-    rejectSymlink(target.path, `Arbor profile ${target.profile}`);
+function explicitlyAborted(x, startIndex = 0) {
+  if (x.aborted === true)
+    return true;
+  for (let i = startIndex;i < x.issues.length; i++) {
+    if (x.issues[i]?.continue === false) {
+      return true;
+    }
   }
-  writeConfigGuarded({
-    cfg,
-    configPath: target.path,
-    defaultPath: target.defaultPath,
-    isolated: target.isolated,
-    allowDefaultTokenOverwrite: opts?.allowDefaultTokenOverwrite
-  });
-}
-function clearToken() {
-  const cfg = loadConfig();
-  saveConfig({ apiUrl: cfg.apiUrl }, { allowDefaultTokenOverwrite: true });
+  return false;
 }
-
-// src/source.ts
-var SNIFF = [
-  ["CLAUDECODE", "Claude Code"],
-  ["CLAUDE_CODE_ENTRYPOINT", "Claude Code"],
-  ["OPENCLAW_HOME", "openclaw"],
-  ["CODEX_SANDBOX", "Codex"],
-  ["CURSOR_TRACE_ID", "Cursor"]
-];
-function detectSource(env = process.env) {
-  const explicit = env.ARBOR_SOURCE?.trim();
-  if (explicit)
-    return explicit;
-  for (const [envVar, tool] of SNIFF) {
-    if (env[envVar]?.trim())
-      return tool;
-  }
-  return;
+function prefixIssues(path, issues) {
+  return issues.map((iss) => {
+    var _a;
+    (_a = iss).path ?? (_a.path = []);
+    iss.path.unshift(path);
+    return iss;
+  });
 }
-
-// src/client.ts
-class NotLoggedInError extends Error {
-  code = "UNAUTHORIZED";
-  details = { reason: "authorization.denied" };
-  constructor() {
-    super("Not logged in. Run: arbor login");
-    this.name = "NotLoggedInError";
+function unwrapMessage(message) {
+  return typeof message === "string" ? message : message?.message;
+}
+function attachSchema(issues, start, inst) {
+  var _a;
+  for (let i = start;i < issues.length; i++) {
+    (_a = issues[i]).schema ?? (_a.schema = inst);
   }
 }
-function authHeader() {
-  const cfg = loadConfig();
-  if (!cfg.token)
-    throw new NotLoggedInError;
-  return { authorization: `Bearer ${cfg.token}`, apiUrl: cfg.apiUrl };
+function finalizeIssue(iss, ctx, config) {
+  var _a;
+  const traits = iss.inst?._zod?.traits;
+  if (traits?.has("$ZodType")) {
+    if (traits.has("$ZodCheck"))
+      (_a = iss).schema ?? (_a.schema = iss.inst);
+    else
+      iss.schema = iss.inst;
+  }
+  const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : undefined;
+  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
+  const { inst: _inst, schema: _schema, continue: _continue, input: _input, ...rest } = iss;
+  rest.path ?? (rest.path = []);
+  rest.message = message;
+  if (ctx?.reportInput) {
+    rest.input = _input;
+  }
+  return rest;
 }
-var source = detectSource();
-var httpExecutor = {
-  async call(name, input) {
-    const { authorization, apiUrl } = authHeader();
-    const dot = name.indexOf(".");
-    const object = dot === -1 ? name : name.slice(0, dot);
-    const verb = dot === -1 ? "" : name.slice(dot + 1);
-    let res;
-    try {
-      res = await fetch(`${apiUrl}/api`, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          authorization,
-          ...source ? { "x-arbor-source": source } : {}
-        },
-        body: JSON.stringify({ object, verb, input })
-      });
-    } catch (cause) {
-      throw new ApiError(`could not reach ${apiUrl} (${cause instanceof Error ? cause.message : String(cause)})`, 0);
+var highSurrogate = /[\uD800-\uDBFF]/;
+function codePointLength(str) {
+  const units = str.length;
+  if (!highSurrogate.test(str))
+    return units;
+  let count = units;
+  for (let i = 0;i < units - 1; i++) {
+    if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
+      count--;
+      i++;
     }
-    const body = await res.json().catch(() => ({}));
-    if (!res.ok || !body.success)
-      throw new ApiError(body.error ?? `request failed (${res.status})`, res.status, parseErrorDetails(body.errorDetails));
-    return body.data;
-  }
-};
-async function binaryGet(path, authenticated = true) {
-  const { authorization, apiUrl } = authHeader();
-  let response;
-  const url = new URL(path, apiUrl);
-  if (url.origin !== new URL(apiUrl).origin || !authenticated && !url.pathname.startsWith("/api/attachment-read/"))
-    throw new Error("Invalid download target");
-  try {
-    response = await fetch(url.toString(), {
-      headers: authenticated ? { authorization } : {},
-      redirect: "error"
-    });
-  } catch {
-    throw new ApiError("Binary download request failed", 0);
   }
-  if (!response.ok)
-    throw new ApiError(`Download failed (${response.status})`, response.status);
-  return response;
+  return count;
 }
-
-// src/attachment-download.ts
-async function downloadAttachment(id, output, signed = false, force = false) {
-  const { createHash, randomUUID } = await import("node:crypto");
-  const { open, rename, unlink, link } = await import("node:fs/promises");
-  const { basename, resolve } = await import("node:path");
-  if (!/^(att_|art_)[a-zA-Z0-9_-]+$/.test(id))
-    throw new Error("Expected an Attachment or Artifact id");
-  const artifact = id.startsWith("art_");
-  const metadata = artifact && !signed ? null : await httpExecutor.call("attachment.get", {
-    attachmentId: id,
-    ...signed ? { signed: true } : {}
-  });
-  if (signed && !metadata?.signedRead)
-    throw new Error("Signed download is unavailable");
-  const response = await binaryGet(signed ? metadata.signedRead.url : `/api/download/${artifact ? "artifact/" : ""}${encodeURIComponent(id)}`, !signed);
-  const size = metadata?.size ?? Number(response.headers.get("x-arbor-size") ?? response.headers.get("content-length") ?? "NaN");
-  if (!Number.isSafeInteger(size) || size < 0 || !response.body)
-    throw new Error("Download has no valid size or body");
-  const suggested = basename(metadata?.filename ?? dispositionFilename(response.headers.get("content-disposition")) ?? id);
-  const destination = resolve(output ?? (suggested.startsWith(".") ? id : suggested));
-  const temporary = `${destination}.${randomUUID()}.part`;
-  const file = await open(temporary, "wx", 384);
-  const reader = response.body.getReader();
-  const hash = createHash("sha256");
-  let received = 0;
-  try {
-    for (;; ) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      received += value.byteLength;
-      if (received > size)
-        throw new Error("Download size mismatch");
-      hash.update(value);
-      let offset = 0;
-      while (offset < value.length) {
-        const written = await file.write(value, offset, value.length - offset);
-        offset += written.bytesWritten;
-      }
+function getLengthableOrigin(input) {
+  if (Array.isArray(input))
+    return "array";
+  if (typeof input === "string")
+    return "string";
+  return "unknown";
+}
+function parsedType(data) {
+  const t = typeof data;
+  switch (t) {
+    case "number": {
+      return Number.isNaN(data) ? "nan" : "number";
     }
-    const sha256 = hash.digest("hex");
-    const expectedHash = metadata?.sha256 ?? response.headers.get("x-arbor-sha256");
-    if (received !== size || expectedHash && expectedHash !== sha256)
-      throw new Error("Download integrity mismatch");
-    await file.close();
-    if (force)
-      await rename(temporary, destination);
-    else {
-      try {
-        await link(temporary, destination);
-      } catch (error) {
-        if (error.code === "EEXIST")
-          throw new Error("Destination exists; use --force to replace it");
-        if (["EPERM", "ENOTSUP"].includes(error.code ?? ""))
-          throw new Error("Filesystem does not support safe no-replace downloads; choose another destination or use --force to allow replacement");
-        throw error;
+    case "object": {
+      if (data === null) {
+        return "null";
+      }
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      const obj = data;
+      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+        return obj.constructor.name;
       }
-      await unlink(temporary);
     }
-    return { path: destination, size: received, sha256 };
-  } catch (error) {
-    await reader.cancel().catch(() => {});
-    await file.close().catch(() => {});
-    await unlink(temporary).catch(() => {});
-    throw error;
-  } finally {
-    reader.releaseLock();
   }
+  return t;
 }
-function dispositionFilename(value) {
-  if (!value)
-    return;
-  const encoded = /filename\*=UTF-8''([^;]+)/i.exec(value)?.[1];
-  if (encoded) {
-    try {
-      return decodeURIComponent(encoded);
-    } catch {}
+function issue(...args) {
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") {
+    return {
+      message: iss,
+      code: "custom",
+      input,
+      inst
+    };
   }
-  return /filename="([^"]*)"/i.exec(value)?.[1] ?? /filename=([^;\s]+)/i.exec(value)?.[1];
+  return { ...iss };
 }
-// package.json
-var package_default = {
-  name: "@lambdacurry/arbor",
-  version: "0.24.14",
-  description: "The Arbor CLI — a shared workspace for people and agents. The human + headless-agent write path over Arbor's guarded operation surface.",
-  keywords: [
-    "agents",
-    "arbor",
-    "cli",
-    "collaboration",
-    "mcp"
-  ],
-  license: "MIT",
-  repository: {
-    type: "git",
-    url: "git+https://github.com/lambda-curry/arbor.git",
-    directory: "packages/cli"
-  },
-  bin: {
-    arbor: "./dist/arbor.js"
-  },
-  files: [
-    "dist",
-    "README.md"
-  ],
-  type: "module",
-  publishConfig: {
-    access: "public"
-  },
-  scripts: {
-    arbor: "vpx src/bin.ts",
-    build: "bun build ./src/bin.ts --target=node --outfile=dist/arbor.js",
-    test: "vp test run --passWithNoTests",
-    typecheck: "tsc -b",
-    prepublishOnly: "bun run build"
-  },
-  devDependencies: {
-    "@arbor/actions": "workspace:*",
-    "@arbor/core": "workspace:*",
-    "@types/node": "^26.2.0",
-    "just-bash": "3.4.2",
-    typescript: "^5.8.0",
-    "vite-plus": "catalog:",
-    zod: "^4.4.3"
-  },
-  engines: {
-    node: ">=18"
-  }
-};
-
-// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/util.js
-function getEnumValues(entries) {
-  const numericValues = Object.values(entries).filter((v) => typeof v === "number");
-  const values = Object.entries(entries).filter(([k, _]) => numericValues.indexOf(+k) === -1).map(([_, v]) => v);
-  return values;
-}
-function joinValues(array, separator = "|") {
-  return array.map((val) => stringifyPrimitive(val)).join(separator);
+function members(proto, table) {
+  for (const key in table) {
+    const desc = Object.getOwnPropertyDescriptor(table, key);
+    if (desc.get)
+      Object.defineProperty(proto, key, { ...desc, enumerable: false });
+    else
+      defineBound(proto, key, desc.value);
+  }
 }
-function jsonStringifyReplacer(_, value) {
-  if (typeof value === "bigint")
-    return value.toString();
+function own(inst, key, value, enumerable = true) {
+  Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
   return value;
 }
-function cached(getter) {
-  const set = false;
-  return {
-    get value() {
-      if (!set) {
-        const value = getter();
-        Object.defineProperty(this, "value", { value });
-        return value;
-      }
-      throw new Error("cached value already set");
-    }
-  };
-}
-function nullish(input) {
-  return input === null || input === undefined;
+function hide(inst, key, value) {
+  return own(inst, key, value, false);
 }
-function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
-  const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
+function defineBound(proto, key, fn) {
+  Object.defineProperty(proto, key, {
+    configurable: true,
+    get() {
+      return this == null ? fn : own(this, key, fn.bind(this));
+    },
+    set(value) {
+      own(this, key, value);
+    }
+  });
 }
-function floatSafeRemainder(val, step) {
-  const ratio = val / step;
-  const roundedRatio = Math.round(ratio);
-  const tolerance = 4 * Number.EPSILON * Math.max(Math.abs(ratio), 1);
-  if (Math.abs(ratio - roundedRatio) < tolerance)
-    return 0;
-  return ratio - roundedRatio;
+function claim(inst, sentinel) {
+  const proto = Object.getPrototypeOf(inst);
+  return sentinel in proto ? undefined : proto;
 }
-var EVALUATING = /* @__PURE__ */ Symbol("evaluating");
-function defineLazy(object, key, getter) {
-  let value = undefined;
-  Object.defineProperty(object, key, {
+var installing;
+var broke = false;
+var breaker = {
+  configurable: true,
+  get() {
+    broke = true;
+    return;
+  }
+};
+function defineLazyInternal(inst, key, compute) {
+  const proto = Object.getPrototypeOf(inst._zod);
+  if (key in proto && installing !== inst._zod) {
+    installing = undefined;
+    return;
+  }
+  installing = inst._zod;
+  Object.defineProperty(proto, key, {
+    configurable: true,
     get() {
-      if (value === EVALUATING) {
-        return;
-      }
-      if (value === undefined) {
-        value = EVALUATING;
-        value = getter();
+      Object.defineProperty(this, key, breaker);
+      const outer = broke;
+      broke = false;
+      try {
+        const value = compute(this);
+        if (broke)
+          delete this[key];
+        else
+          Object.defineProperty(this, key, { configurable: true, writable: true, value });
+        broke = broke || outer;
+        return value;
+      } catch (err) {
+        delete this[key];
+        broke = broke || outer;
+        throw err;
       }
-      return value;
-    },
-    set(v) {
-      Object.defineProperty(object, key, {
-        value: v
-      });
     },
-    configurable: true
+    set(value) {
+      Object.defineProperty(this, key, { configurable: true, writable: true, value });
+    }
   });
 }
-function assignProp(target, prop, value) {
-  Object.defineProperty(target, prop, {
-    value,
-    writable: true,
-    enumerable: true,
-    configurable: true
+function installLazyProp(inst, key, make, enumerable) {
+  const proto = claim(inst, key);
+  if (!proto)
+    return;
+  Object.defineProperty(proto, key, {
+    configurable: true,
+    get() {
+      const desc = { configurable: true, writable: true, enumerable, value: undefined };
+      Object.defineProperty(this, key, desc);
+      desc.value = make(this);
+      Object.defineProperty(this, key, desc);
+      return desc.value;
+    },
+    set(value) {
+      Object.defineProperty(this, key, { configurable: true, writable: true, enumerable, value });
+    }
   });
 }
-function mergeDefs(...defs) {
-  const mergedDescriptors = {};
-  for (const def of defs) {
-    const descriptors = Object.getOwnPropertyDescriptors(def);
-    Object.assign(mergedDescriptors, descriptors);
-  }
-  return Object.defineProperties({}, mergedDescriptors);
-}
-function esc(str) {
-  return JSON.stringify(str);
-}
-function slugify(input) {
-  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
-}
-var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {};
-function isObject(data) {
-  return typeof data === "object" && data !== null && !Array.isArray(data);
+var CONSTANT_CATCH = "~constantCatch";
+function constantCatch(value) {
+  const fn = () => value;
+  fn[CONSTANT_CATCH] = true;
+  return fn;
 }
-var allowsEval = /* @__PURE__ */ cached(() => {
-  if (globalConfig.jitless) {
-    return false;
+
+// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/core.js
+var _a;
+var _zodDesc = { value: undefined, enumerable: false };
+var _E = "captureStackTrace" in Error ? Error : null;
+function newError(Definition) {
+  const E = _E;
+  if (E) {
+    const saved = E.stackTraceLimit;
+    if (typeof saved === "number") {
+      try {
+        E.stackTraceLimit = 0;
+      } catch {
+        _E = null;
+        return new Definition;
+      }
+      try {
+        return new Definition;
+      } finally {
+        E.stackTraceLimit = saved;
+      }
+    }
   }
-  if (typeof navigator !== "undefined" && navigator?.userAgent?.includes("Cloudflare")) {
-    return false;
+  return new Definition;
+}
+function $constructor(name, initializer, proto, params) {
+  const zodProto = {};
+  function Internals(def) {
+    this.def = def;
+    this.constr = _;
+    this.traits = new Set;
   }
-  try {
-    const F = Function;
-    new F("");
-    return true;
-  } catch (_) {
-    return false;
+  Internals.prototype = zodProto;
+  const protoMembers = proto;
+  const initialized = protoMembers && new WeakSet;
+  function init(inst, def) {
+    if (!inst._zod) {
+      _zodDesc.value = new Internals(def);
+      try {
+        Object.defineProperty(inst, "_zod", _zodDesc);
+      } finally {
+        _zodDesc.value = undefined;
+      }
+    }
+    if (inst._zod.traits.has(name)) {
+      return;
+    }
+    inst._zod.traits.add(name);
+    initializer(inst, def);
+    if (initialized) {
+      const own = Object.getPrototypeOf(inst);
+      const ctorProto = inst._zod.constr.prototype;
+      let up = own;
+      while (up && up !== ctorProto)
+        up = Object.getPrototypeOf(up);
+      const target = up ?? own;
+      if (!initialized.has(target)) {
+        initialized.add(target);
+        members(target, protoMembers);
+      }
+    }
+    const proto = _.prototype;
+    for (const k in proto) {
+      if (!Object.prototype.hasOwnProperty.call(proto, k))
+        continue;
+      if (!(k in inst)) {
+        inst[k] = proto[k].bind(inst);
+      }
+    }
   }
-});
-function isPlainObject(o) {
-  if (isObject(o) === false)
-    return false;
-  const ctor = o.constructor;
-  if (ctor === undefined)
-    return true;
-  if (typeof ctor !== "function")
-    return true;
-  const prot = ctor.prototype;
-  if (isObject(prot) === false)
-    return false;
-  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
-    return false;
+  const Parent = params?.Parent ?? Object;
+
+  class Definition extends Parent {
   }
-  return true;
-}
-function shallowClone(o) {
-  if (isPlainObject(o))
-    return { ...o };
-  if (Array.isArray(o))
-    return [...o];
-  if (o instanceof Map)
-    return new Map(o);
-  if (o instanceof Set)
-    return new Set(o);
-  return o;
-}
-var propertyKeyTypes = /* @__PURE__ */ new Set(["string", "number", "symbol"]);
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  Object.defineProperty(Definition, "name", { value: name });
+  function _(def) {
+    const inst = params?.Parent ? newError(Definition) : this;
+    init(inst, def);
+    const deferred = inst._zod.deferred;
+    if (deferred) {
+      for (const fn of deferred) {
+        fn();
+      }
+      inst._zod.deferred = undefined;
+    }
+    const pp = globalThis.__zod_globalConfig?.postProcessor;
+    if (pp)
+      pp(inst);
+    return inst;
+  }
+  Object.defineProperty(_, "init", { value: init });
+  Object.defineProperty(_, Symbol.hasInstance, {
+    value: (inst) => {
+      if (params?.Parent && inst instanceof params.Parent)
+        return true;
+      return inst?._zod?.traits?.has(name);
+    }
+  });
+  Object.defineProperty(_, "name", { value: name });
+  return _;
 }
-function clone(inst, def, params) {
-  const cl = new inst._zod.constr(def ?? inst._zod.def);
-  if (!def || params?.parent)
-    cl._zod.parent = inst;
-  return cl;
+class $ZodAsyncError extends Error {
+  constructor() {
+    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
+  }
 }
-function normalizeParams(_params) {
-  const params = _params;
-  if (!params)
-    return {};
-  if (typeof params === "string")
-    return { error: () => params };
-  if (params?.message !== undefined) {
-    if (params?.error !== undefined)
-      throw new Error("Cannot specify both `message` and `error` params");
-    params.error = params.message;
+
+class $ZodEncodeError extends Error {
+  constructor(name) {
+    super(`Encountered unidirectional transform during encode: ${name}`);
+    this.name = "ZodEncodeError";
   }
-  delete params.message;
-  if (typeof params.error === "string")
-    return { ...params, error: () => params.error };
-  return params;
 }
-function stringifyPrimitive(value) {
-  if (typeof value === "bigint")
-    return value.toString() + "n";
-  if (typeof value === "string")
-    return `"${value}"`;
-  return `${value}`;
+(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
+var globalConfig = globalThis.__zod_globalConfig;
+function config(newConfig) {
+  if (newConfig)
+    Object.assign(globalConfig, newConfig);
+  return globalConfig;
 }
-function optionalKeys(shape) {
-  return Object.keys(shape).filter((k) => {
-    return shape[k]._zod.optin !== undefined && shape[k]._zod.optout === "optional";
-  });
+// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/errors.js
+function _getMessage() {
+  const internals = this._zod;
+  internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
+  return internals.message;
 }
-var NUMBER_FORMAT_RANGES = /* @__PURE__ */ (() => ({
-  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
-  int32: [-2147483648, 2147483647],
-  uint32: [0, 4294967295],
-  float32: [-340282346638528860000000000000000000000, 340282346638528860000000000000000000000],
-  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
-}))();
-function pick(schema, mask) {
-  const currDef = schema._zod.def;
-  const checks = currDef.checks;
-  const hasChecks = checks && checks.length > 0;
-  if (hasChecks) {
-    throw new Error(".pick() cannot be used on object schemas containing refinements");
-  }
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const newShape = {};
-      for (const key of Reflect.ownKeys(mask)) {
-        if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
-          throw new Error(`Unrecognized key: "${String(key)}"`);
-        }
-        if (!mask[key])
-          continue;
-        assignProp(newShape, key, currDef.shape[key]);
-      }
-      assignProp(this, "shape", newShape);
-      return newShape;
-    },
-    checks: []
-  });
-  return clone(schema, def);
+function _setMessage(value) {
+  this._zod.message = value;
 }
-function omit(schema, mask) {
-  const currDef = schema._zod.def;
-  const checks = currDef.checks;
-  const hasChecks = checks && checks.length > 0;
-  if (hasChecks) {
-    throw new Error(".omit() cannot be used on object schemas containing refinements");
-  }
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const newShape = { ...schema._zod.def.shape };
-      for (const key of Reflect.ownKeys(mask)) {
-        if (!Object.prototype.hasOwnProperty.call(currDef.shape, key)) {
-          throw new Error(`Unrecognized key: "${String(key)}"`);
-        }
-        if (!mask[key])
-          continue;
-        delete newShape[key];
+var _messageDesc = {
+  get: _getMessage,
+  set: _setMessage,
+  enumerable: true,
+  configurable: true
+};
+var _zodDesc2 = { value: undefined, enumerable: false };
+var _issuesDesc = { value: undefined, enumerable: false };
+var _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
+var initializer = (inst, def) => {
+  inst.name = "$ZodError";
+  _zodDesc2.value = inst._zod;
+  Object.defineProperty(inst, "_zod", _zodDesc2);
+  _issuesDesc.value = def;
+  Object.defineProperty(inst, "issues", _issuesDesc);
+  _zodDesc2.value = undefined;
+  _issuesDesc.value = undefined;
+  Object.defineProperty(inst, "message", _messageDesc);
+  const proto = Object.getPrototypeOf(inst);
+  if (!_installedToString.has(proto)) {
+    _installedToString.add(proto);
+    Object.defineProperty(proto, "toString", {
+      configurable: true,
+      enumerable: false,
+      get() {
+        const value = () => this.message;
+        Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
+        return value;
+      },
+      set(value) {
+        Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
       }
-      assignProp(this, "shape", newShape);
-      return newShape;
-    },
-    checks: []
-  });
-  return clone(schema, def);
-}
-function extend(schema, shape) {
-  if (!isPlainObject(shape)) {
-    throw new Error("Invalid input to extend: expected a plain object");
+    });
   }
-  const checks = schema._zod.def.checks;
-  const hasChecks = checks && checks.length > 0;
-  if (hasChecks) {
-    const existingShape = schema._zod.def.shape;
-    for (const key of Reflect.ownKeys(shape)) {
-      if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
-        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
-      }
+};
+var $ZodError = $constructor("$ZodError", initializer);
+var $ZodRealError = $constructor("$ZodError", initializer, undefined, {
+  Parent: Error
+});
+function node(obj, key, make) {
+  if (!Object.prototype.hasOwnProperty.call(obj, key)) {
+    if (key === "__proto__") {
+      Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
+    } else {
+      obj[key] = make();
     }
   }
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
-      assignProp(this, "shape", _shape);
-      return _shape;
-    }
-  });
-  return clone(schema, def);
+  return obj[key];
 }
-function safeExtend(schema, shape) {
-  if (!isPlainObject(shape)) {
-    throw new Error("Invalid input to safeExtend: expected a plain object");
-  }
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const _shape = { ...schema._zod.def.shape, ...shape };
-      assignProp(this, "shape", _shape);
-      return _shape;
+function flattenError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = {};
+  const formErrors = [];
+  for (const sub of error.issues) {
+    if (sub.path.length > 0) {
+      node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
+    } else {
+      formErrors.push(mapper(sub));
     }
-  });
-  return clone(schema, def);
-}
-function merge(a, b) {
-  if (!b?._zod?.def) {
-    throw new Error("Invalid input to merge: expected an object schema. To merge a plain shape, use `.extend()`.");
-  }
-  if (a._zod.def.checks?.length) {
-    throw new Error(".merge() cannot be used on object schemas containing refinements. Use .safeExtend() instead.");
   }
-  const def = mergeDefs(a._zod.def, {
-    get shape() {
-      const _shape = { ...a._zod.def.shape, ...b._zod.def.shape };
-      assignProp(this, "shape", _shape);
-      return _shape;
-    },
-    get catchall() {
-      return b._zod.def.catchall;
-    },
-    checks: b._zod.def.checks ?? []
-  });
-  return clone(a, def);
+  return { formErrors, fieldErrors };
 }
-function partial(Class, schema, mask, name = "partial") {
-  const currDef = schema._zod.def;
-  const checks = currDef.checks;
-  const hasChecks = checks && checks.length > 0;
-  if (hasChecks) {
-    throw new Error(`.${name}() cannot be used on object schemas containing refinements`);
-  }
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const oldShape = schema._zod.def.shape;
-      const shape = { ...oldShape };
-      if (mask) {
-        for (const key of Reflect.ownKeys(mask)) {
-          if (!Object.prototype.hasOwnProperty.call(oldShape, key)) {
-            throw new Error(`Unrecognized key: "${String(key)}"`);
-          }
-          if (!mask[key])
-            continue;
-          shape[key] = Class ? new Class({
-            type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
-        }
+function formatError(error, mapper = (issue) => issue.message) {
+  const fieldErrors = { _errors: [] };
+  const processError = (error, path = []) => {
+    for (const issue of error.issues) {
+      if (issue.code === "invalid_union" && issue.errors.length) {
+        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
+      } else if (issue.code === "invalid_key") {
+        processError({ issues: issue.issues }, [...path, ...issue.path]);
+      } else if (issue.code === "invalid_element") {
+        processError({ issues: issue.issues }, [...path, ...issue.path]);
       } else {
-        for (const key of Reflect.ownKeys(oldShape)) {
-          shape[key] = Class ? new Class({
-            type: "optional",
-            innerType: oldShape[key]
-          }) : oldShape[key];
-        }
-      }
-      assignProp(this, "shape", shape);
-      return shape;
-    },
-    checks: []
-  });
-  return clone(schema, def);
-}
-function required(Class, schema, mask) {
-  const def = mergeDefs(schema._zod.def, {
-    get shape() {
-      const oldShape = schema._zod.def.shape;
-      const shape = { ...oldShape };
-      if (mask) {
-        for (const key of Reflect.ownKeys(mask)) {
-          if (!Object.prototype.hasOwnProperty.call(shape, key)) {
-            throw new Error(`Unrecognized key: "${String(key)}"`);
+        const fullpath = [...path, ...issue.path];
+        if (fullpath.length === 0) {
+          fieldErrors._errors.push(mapper(issue));
+        } else {
+          let curr = fieldErrors;
+          let i = 0;
+          while (i < fullpath.length) {
+            const el = fullpath[i];
+            const terminal = i === fullpath.length - 1;
+            if (el === "_errors") {
+              if (terminal)
+                curr._errors.push(mapper(issue));
+              i++;
+              continue;
+            }
+            if (!Object.prototype.hasOwnProperty.call(curr, el)) {
+              Object.defineProperty(curr, el, {
+                value: { _errors: [] },
+                enumerable: true,
+                writable: true,
+                configurable: true
+              });
+            }
+            const node = curr[el];
+            if (terminal) {
+              node._errors.push(mapper(issue));
+            }
+            curr = node;
+            i++;
           }
-          if (!mask[key])
-            continue;
-          shape[key] = new Class({
-            type: "nonoptional",
-            innerType: oldShape[key]
-          });
-        }
-      } else {
-        for (const key of Reflect.ownKeys(oldShape)) {
-          shape[key] = new Class({
-            type: "nonoptional",
-            innerType: oldShape[key]
-          });
         }
       }
-      assignProp(this, "shape", shape);
-      return shape;
     }
-  });
-  return clone(schema, def);
+  };
+  processError(error);
+  return fieldErrors;
 }
-function aborted(x, startIndex = 0) {
-  if (x.aborted === true)
-    return true;
-  for (let i = startIndex;i < x.issues.length; i++) {
-    if (x.issues[i]?.continue !== true) {
-      return true;
-    }
-  }
-  return false;
+
+// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/parse.js
+function finalizeParams(callee, params) {
+  return { callee: params?.callee ?? callee, Err: params?.Err };
 }
-function explicitlyAborted(x, startIndex = 0) {
-  if (x.aborted === true)
-    return true;
-  for (let i = startIndex;i < x.issues.length; i++) {
-    if (x.issues[i]?.continue === false) {
-      return true;
+var _parse = (_Err) => {
+  const fn = (schema, value, _ctx, _params) => {
+    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+    const result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise) {
+      throw new $ZodAsyncError;
+    }
+    if (result.issues.length) {
+      const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+      captureStackTrace(e, _params?.callee ?? fn);
+      throw e;
+    }
+    return result.value;
+  };
+  return fn;
+};
+var _parseAsync = (_Err) => {
+  const fn = async (schema, value, _ctx, params) => {
+    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+    let result = schema._zod.run({ value, issues: [] }, ctx);
+    if (result instanceof Promise)
+      result = await result;
+    if (result.issues.length) {
+      const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
+      captureStackTrace(e, params?.callee ?? fn);
+      throw e;
     }
+    return result.value;
+  };
+  return fn;
+};
+var _safeParse = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
+  const result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise) {
+    throw new $ZodAsyncError;
   }
-  return false;
-}
-function prefixIssues(path, issues) {
-  return issues.map((iss) => {
-    var _a;
-    (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path);
-    return iss;
-  });
+  return result.issues.length ? {
+    success: false,
+    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
+var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
+  let result = schema._zod.run({ value, issues: [] }, ctx);
+  if (result instanceof Promise)
+    result = await result;
+  return result.issues.length ? {
+    success: false,
+    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
+  } : { success: true, data: result.value };
+};
+var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
+var _encode = (_Err) => {
+  const parse = _parse(_Err);
+  const fn = (schema, value, _ctx, _params) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return parse(schema, value, ctx, finalizeParams(fn, _params));
+  };
+  return fn;
+};
+var _decode = (_Err) => {
+  const parse = _parse(_Err);
+  const fn = (schema, value, _ctx, _params) => {
+    return parse(schema, value, _ctx, finalizeParams(fn, _params));
+  };
+  return fn;
+};
+var _encodeAsync = (_Err) => {
+  const parseAsync = _parseAsync(_Err);
+  const fn = async (schema, value, _ctx, _params) => {
+    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+    return await parseAsync(schema, value, ctx, finalizeParams(fn, _params));
+  };
+  return fn;
+};
+var _decodeAsync = (_Err) => {
+  const parseAsync = _parseAsync(_Err);
+  const fn = async (schema, value, _ctx, _params) => {
+    return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));
+  };
+  return fn;
+};
+var _safeEncode = (_Err) => (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+  return _safeParse(_Err)(schema, value, ctx);
+};
+var _safeDecode = (_Err) => (schema, value, _ctx) => {
+  return _safeParse(_Err)(schema, value, _ctx);
+};
+var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
+  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
+  return _safeParseAsync(_Err)(schema, value, ctx);
+};
+var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
+  return _safeParseAsync(_Err)(schema, value, _ctx);
+};
+// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/regexes.js
+var cuid = /^[cC][0-9a-z]{6,}$/;
+var cuid2 = /^[0-9a-z]+$/;
+var ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;
+var xid = /^[0-9a-vA-V]{20}$/;
+var ksuid = /^[A-Za-z0-9]{27}$/;
+var nanoid = /^[a-zA-Z0-9_-]{21}$/;
+function nanoidOfLength(length) {
+  return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);
 }
-function unwrapMessage(message) {
-  return typeof message === "string" ? message : message?.message;
+var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+var uuid = (version) => {
+  if (!version)
+    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+};
+var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
+var _emoji = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
+function emoji() {
+  return new RegExp(_emoji, "u");
 }
-function attachSchema(issues, start, inst) {
-  var _a;
-  for (let i = start;i < issues.length; i++) {
-    (_a = issues[i]).schema ?? (_a.schema = inst);
-  }
+var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
+var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
+var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
+var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
+var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
+var base64url = /^[A-Za-z0-9_-]*$/;
+var httpProtocol = /^https?$/;
+var e164 = /^\+[1-9]\d{6,14}$/;
+var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
+function anchor(source) {
+  return new RegExp(`^${source}$`);
 }
-function finalizeIssue(iss, ctx, config) {
-  var _a;
-  const traits = iss.inst?._zod?.traits;
-  if (traits?.has("$ZodType")) {
-    if (traits.has("$ZodCheck"))
-      (_a = iss).schema ?? (_a.schema = iss.inst);
-    else
-      iss.schema = iss.inst;
-  }
-  const schemaError = iss.schema !== iss.inst ? iss.schema?._zod.def?.error : undefined;
-  const message = iss.message ? iss.message : unwrapMessage(iss.inst?._zod.def?.error?.(iss)) ?? unwrapMessage(schemaError?.(iss)) ?? unwrapMessage(ctx?.error?.(iss)) ?? unwrapMessage(config.customError?.(iss)) ?? unwrapMessage(config.localeError?.(iss)) ?? "Invalid input";
-  const { inst: _inst, schema: _schema, continue: _continue, input: _input, ...rest } = iss;
-  rest.path ?? (rest.path = []);
-  rest.message = message;
-  if (ctx?.reportInput) {
-    rest.input = _input;
-  }
-  return rest;
-}
-var highSurrogate = /[\uD800-\uDBFF]/;
-function codePointLength(str) {
-  const units = str.length;
-  if (!highSurrogate.test(str))
-    return units;
-  let count = units;
-  for (let i = 0;i < units - 1; i++) {
-    if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count--;
-      i++;
-    }
-  }
-  return count;
-}
-function getLengthableOrigin(input) {
-  if (Array.isArray(input))
-    return "array";
-  if (typeof input === "string")
-    return "string";
-  return "unknown";
-}
-function parsedType(data) {
-  const t = typeof data;
-  switch (t) {
-    case "number": {
-      return Number.isNaN(data) ? "nan" : "number";
-    }
-    case "object": {
-      if (data === null) {
-        return "null";
-      }
-      if (Array.isArray(data)) {
-        return "array";
-      }
-      const obj = data;
-      if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
-        return obj.constructor.name;
-      }
-    }
-  }
-  return t;
-}
-function issue(...args) {
-  const [iss, input, inst] = args;
-  if (typeof iss === "string") {
-    return {
-      message: iss,
-      code: "custom",
-      input,
-      inst
-    };
-  }
-  return { ...iss };
-}
-function members(proto, table) {
-  for (const key in table) {
-    const desc = Object.getOwnPropertyDescriptor(table, key);
-    if (desc.get)
-      Object.defineProperty(proto, key, { ...desc, enumerable: false });
-    else
-      defineBound(proto, key, desc.value);
-  }
+var date = /* @__PURE__ */ anchor(dateSource);
+function timeSource(args) {
+  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
+  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\d(?:\\.\\d+)?` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
+  return regex;
 }
-function own(inst, key, value, enumerable = true) {
-  Object.defineProperty(inst, key, { configurable: true, writable: true, enumerable, value });
-  return value;
+function time(args) {
+  return new RegExp(`^${timeSource(args)}$`);
 }
-function hide(inst, key, value) {
-  return own(inst, key, value, false);
+function datetime(args) {
+  const opts = ["Z"];
+  if (args.offset)
+    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
+  const qualified = `${timeSource({ precision: args.precision, seconds: true })}(?:${opts.join("|")})`;
+  const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;
+  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
 }
-function defineBound(proto, key, fn) {
-  Object.defineProperty(proto, key, {
-    configurable: true,
-    get() {
-      return this == null ? fn : own(this, key, fn.bind(this));
-    },
-    set(value) {
-      own(this, key, value);
+var string = (params) => {
+  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
+  return new RegExp(`^${regex}$`);
+};
+var integer = /^-?\d+$/;
+var number = /^-?\d+(?:\.\d+)?$/;
+var boolean = /^(?:true|false)$/i;
+var _null = /^null$/i;
+var lowercase = /^[^A-Z]*$/;
+var uppercase = /^[^a-z]*$/;
+
+// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/checks.js
+var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
+  var _a;
+  inst._zod ?? (inst._zod = {});
+  inst._zod.def = def;
+  (_a = inst._zod).onattach ?? (_a.onattach = []);
+});
+var _whenHasLength = (payload) => {
+  const val = payload.value;
+  return !nullish(val) && val.length !== undefined;
+};
+var numericOriginMap = {
+  number: "number",
+  bigint: "bigint",
+  object: "date"
+};
+var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
+    if (def.value < curr) {
+      if (def.inclusive)
+        bag.maximum = def.value;
+      else
+        bag.exclusiveMaximum = def.value;
     }
   });
-}
-function claim(inst, sentinel) {
-  const proto = Object.getPrototypeOf(inst);
-  return sentinel in proto ? undefined : proto;
-}
-var installing;
-var broke = false;
-var breaker = {
-  configurable: true,
-  get() {
-    broke = true;
-    return;
-  }
-};
-function defineLazyInternal(inst, key, compute) {
-  const proto = Object.getPrototypeOf(inst._zod);
-  if (key in proto && installing !== inst._zod) {
-    installing = undefined;
-    return;
-  }
-  installing = inst._zod;
-  Object.defineProperty(proto, key, {
-    configurable: true,
-    get() {
-      Object.defineProperty(this, key, breaker);
-      const outer = broke;
-      broke = false;
-      try {
-        const value = compute(this);
-        if (broke)
-          delete this[key];
-        else
-          Object.defineProperty(this, key, { configurable: true, writable: true, value });
-        broke = broke || outer;
-        return value;
-      } catch (err) {
-        delete this[key];
-        broke = broke || outer;
-        throw err;
-      }
-    },
-    set(value) {
-      Object.defineProperty(this, key, { configurable: true, writable: true, value });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
+      return;
+    }
+    payload.issues.push({
+      origin: numericOriginMap[typeof payload.value] ?? origin,
+      code: "too_big",
+      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  const origin = numericOriginMap[typeof def.value];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
+    if (def.value > curr) {
+      if (def.inclusive)
+        bag.minimum = def.value;
+      else
+        bag.exclusiveMinimum = def.value;
     }
   });
-}
-function installLazyProp(inst, key, make, enumerable) {
-  const proto = claim(inst, key);
-  if (!proto)
-    return;
-  Object.defineProperty(proto, key, {
-    configurable: true,
-    get() {
-      const desc = { configurable: true, writable: true, enumerable, value: undefined };
-      Object.defineProperty(this, key, desc);
-      desc.value = make(this);
-      Object.defineProperty(this, key, desc);
-      return desc.value;
-    },
-    set(value) {
-      Object.defineProperty(this, key, { configurable: true, writable: true, enumerable, value });
+  inst._zod.check = (payload) => {
+    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+      return;
     }
+    payload.issues.push({
+      origin: numericOriginMap[typeof payload.value] ?? origin,
+      code: "too_small",
+      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      input: payload.value,
+      inclusive: def.inclusive,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    var _a;
+    (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
   });
-}
-var CONSTANT_CATCH = "~constantCatch";
-function constantCatch(value) {
-  const fn = () => value;
-  fn[CONSTANT_CATCH] = true;
-  return fn;
-}
-
-// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/core.js
-var _a;
-var _zodDesc = { value: undefined, enumerable: false };
-var _E = "captureStackTrace" in Error ? Error : null;
-function newError(Definition) {
-  const E = _E;
-  if (E) {
-    const saved = E.stackTraceLimit;
-    if (typeof saved === "number") {
-      try {
-        E.stackTraceLimit = 0;
-      } catch {
-        _E = null;
-        return new Definition;
-      }
-      try {
-        return new Definition;
-      } finally {
-        E.stackTraceLimit = saved;
-      }
-    }
-  }
-  return new Definition;
-}
-function $constructor(name, initializer, proto, params) {
-  const zodProto = {};
-  function Internals(def) {
-    this.def = def;
-    this.constr = _;
-    this.traits = new Set;
-  }
-  Internals.prototype = zodProto;
-  const protoMembers = proto;
-  const initialized = protoMembers && new WeakSet;
-  function init(inst, def) {
-    if (!inst._zod) {
-      _zodDesc.value = new Internals(def);
-      try {
-        Object.defineProperty(inst, "_zod", _zodDesc);
-      } finally {
-        _zodDesc.value = undefined;
-      }
-    }
-    if (inst._zod.traits.has(name)) {
+  inst._zod.check = (payload) => {
+    if (typeof payload.value !== typeof def.value)
+      throw new Error("Cannot mix number and bigint in multiple_of check.");
+    const isMultiple = typeof payload.value === "bigint" ? def.value !== BigInt(0) && payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
+    if (isMultiple)
       return;
-    }
-    inst._zod.traits.add(name);
-    initializer(inst, def);
-    if (initialized) {
-      const own = Object.getPrototypeOf(inst);
-      const ctorProto = inst._zod.constr.prototype;
-      let up = own;
-      while (up && up !== ctorProto)
-        up = Object.getPrototypeOf(up);
-      const target = up ?? own;
-      if (!initialized.has(target)) {
-        initialized.add(target);
-        members(target, protoMembers);
+    payload.issues.push({
+      origin: typeof payload.value,
+      code: "not_multiple_of",
+      divisor: def.value,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
+  };
+});
+var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  def.format = def.format || "float64";
+  const isInt = def.format?.includes("int");
+  const origin = isInt ? "int" : "number";
+  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    bag.minimum = minimum;
+    bag.maximum = maximum;
+    if (isInt)
+      bag.pattern = integer;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    if (isInt) {
+      if (!Number.isInteger(input)) {
+        payload.issues.push({
+          expected: origin,
+          format: def.format,
+          code: "invalid_type",
+          continue: false,
+          input,
+          inst
+        });
+        return;
       }
-    }
-    const proto = _.prototype;
-    for (const k in proto) {
-      if (!Object.prototype.hasOwnProperty.call(proto, k))
-        continue;
-      if (!(k in inst)) {
-        inst[k] = proto[k].bind(inst);
+      if (!Number.isSafeInteger(input)) {
+        if (input > 0) {
+          payload.issues.push({
+            input,
+            code: "too_big",
+            maximum: Number.MAX_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        } else {
+          payload.issues.push({
+            input,
+            code: "too_small",
+            minimum: Number.MIN_SAFE_INTEGER,
+            note: "Integers must be within the safe integer range.",
+            inst,
+            origin,
+            inclusive: true,
+            continue: !def.abort
+          });
+        }
+        return;
       }
     }
-  }
-  const Parent = params?.Parent ?? Object;
-
-  class Definition extends Parent {
-  }
-  Object.defineProperty(Definition, "name", { value: name });
-  function _(def) {
-    const inst = params?.Parent ? newError(Definition) : this;
-    init(inst, def);
-    const deferred = inst._zod.deferred;
-    if (deferred) {
-      for (const fn of deferred) {
-        fn();
-      }
-      inst._zod.deferred = undefined;
+    if (input < minimum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_small",
+        minimum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
     }
-    const pp = globalThis.__zod_globalConfig?.postProcessor;
-    if (pp)
-      pp(inst);
-    return inst;
-  }
-  Object.defineProperty(_, "init", { value: init });
-  Object.defineProperty(_, Symbol.hasInstance, {
-    value: (inst) => {
-      if (params?.Parent && inst instanceof params.Parent)
-        return true;
-      return inst?._zod?.traits?.has(name);
+    if (input > maximum) {
+      payload.issues.push({
+        origin: "number",
+        input,
+        code: "too_big",
+        maximum,
+        inclusive: true,
+        inst,
+        continue: !def.abort
+      });
     }
-  });
-  Object.defineProperty(_, "name", { value: name });
-  return _;
-}
-class $ZodAsyncError extends Error {
-  constructor() {
-    super(`Encountered Promise during synchronous parse. Use .parseAsync() instead.`);
-  }
-}
-
-class $ZodEncodeError extends Error {
-  constructor(name) {
-    super(`Encountered unidirectional transform during encode: ${name}`);
-    this.name = "ZodEncodeError";
-  }
-}
-(_a = globalThis).__zod_globalConfig ?? (_a.__zod_globalConfig = {});
-var globalConfig = globalThis.__zod_globalConfig;
-function config(newConfig) {
-  if (newConfig)
-    Object.assign(globalConfig, newConfig);
-  return globalConfig;
-}
-// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/errors.js
-function _getMessage() {
-  const internals = this._zod;
-  internals.message ?? (internals.message = JSON.stringify(internals.def, jsonStringifyReplacer, 2));
-  return internals.message;
-}
-function _setMessage(value) {
-  this._zod.message = value;
-}
-var _messageDesc = {
-  get: _getMessage,
-  set: _setMessage,
-  enumerable: true,
-  configurable: true
-};
-var _zodDesc2 = { value: undefined, enumerable: false };
-var _issuesDesc = { value: undefined, enumerable: false };
-var _installedToString = /* @__PURE__ */ new WeakSet([Object.prototype, Error.prototype]);
-var initializer = (inst, def) => {
-  inst.name = "$ZodError";
-  _zodDesc2.value = inst._zod;
-  Object.defineProperty(inst, "_zod", _zodDesc2);
-  _issuesDesc.value = def;
-  Object.defineProperty(inst, "issues", _issuesDesc);
-  _zodDesc2.value = undefined;
-  _issuesDesc.value = undefined;
-  Object.defineProperty(inst, "message", _messageDesc);
-  const proto = Object.getPrototypeOf(inst);
-  if (!_installedToString.has(proto)) {
-    _installedToString.add(proto);
-    Object.defineProperty(proto, "toString", {
-      configurable: true,
-      enumerable: false,
-      get() {
-        const value = () => this.message;
-        Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
-        return value;
-      },
-      set(value) {
-        Object.defineProperty(this, "toString", { value, configurable: true, writable: true });
-      }
-    });
-  }
-};
-var $ZodError = $constructor("$ZodError", initializer);
-var $ZodRealError = $constructor("$ZodError", initializer, undefined, {
-  Parent: Error
+  };
 });
-function node(obj, key, make) {
-  if (!Object.prototype.hasOwnProperty.call(obj, key)) {
-    if (key === "__proto__") {
-      Object.defineProperty(obj, key, { value: make(), writable: true, enumerable: true, configurable: true });
-    } else {
-      obj[key] = make();
-    }
-  }
-  return obj[key];
-}
-function flattenError(error, mapper = (issue) => issue.message) {
-  const fieldErrors = {};
-  const formErrors = [];
-  for (const sub of error.issues) {
-    if (sub.path.length > 0) {
-      node(fieldErrors, sub.path[0], () => []).push(mapper(sub));
-    } else {
-      formErrors.push(mapper(sub));
-    }
-  }
-  return { formErrors, fieldErrors };
-}
-function formatError(error, mapper = (issue) => issue.message) {
-  const fieldErrors = { _errors: [] };
-  const processError = (error, path = []) => {
-    for (const issue of error.issues) {
-      if (issue.code === "invalid_union" && issue.errors.length) {
-        issue.errors.map((issues) => processError({ issues }, [...path, ...issue.path]));
-      } else if (issue.code === "invalid_key") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
-      } else if (issue.code === "invalid_element") {
-        processError({ issues: issue.issues }, [...path, ...issue.path]);
-      } else {
-        const fullpath = [...path, ...issue.path];
-        if (fullpath.length === 0) {
-          fieldErrors._errors.push(mapper(issue));
-        } else {
-          let curr = fieldErrors;
-          let i = 0;
-          while (i < fullpath.length) {
-            const el = fullpath[i];
-            const terminal = i === fullpath.length - 1;
-            if (el === "_errors") {
-              if (terminal)
-                curr._errors.push(mapper(issue));
-              i++;
-              continue;
-            }
-            if (!Object.prototype.hasOwnProperty.call(curr, el)) {
-              Object.defineProperty(curr, el, {
-                value: { _errors: [] },
-                enumerable: true,
-                writable: true,
-                configurable: true
-              });
-            }
-            const node = curr[el];
-            if (terminal) {
-              node._errors.push(mapper(issue));
-            }
-            curr = node;
-            i++;
-          }
-        }
-      }
-    }
-  };
-  processError(error);
-  return fieldErrors;
-}
-
-// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/parse.js
-function finalizeParams(callee, params) {
-  return { callee: params?.callee ?? callee, Err: params?.Err };
-}
-var _parse = (_Err) => {
-  const fn = (schema, value, _ctx, _params) => {
-    const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-    const result = schema._zod.run({ value, issues: [] }, ctx);
-    if (result instanceof Promise) {
-      throw new $ZodAsyncError;
-    }
-    if (result.issues.length) {
-      const e = new (_params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
-      captureStackTrace(e, _params?.callee ?? fn);
-      throw e;
-    }
-    return result.value;
+var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
+  inst._zod.onattach.push((inst) => {
+    const curr = inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
+    if (def.maximum < curr)
+      inst._zod.bag.maximum = def.maximum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const units = input.length;
+    const length = typeof input === "string" && units > def.maximum ? codePointLength(input) : units;
+    if (length <= def.maximum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_big",
+      maximum: def.maximum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
   };
-  return fn;
-};
-var _parseAsync = (_Err) => {
-  const fn = async (schema, value, _ctx, params) => {
-    const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-    let result = schema._zod.run({ value, issues: [] }, ctx);
-    if (result instanceof Promise)
-      result = await result;
-    if (result.issues.length) {
-      const e = new (params?.Err ?? _Err)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())));
-      captureStackTrace(e, params?.callee ?? fn);
-      throw e;
-    }
-    return result.value;
+});
+var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
+  inst._zod.onattach.push((inst) => {
+    const curr = inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
+    if (def.minimum > curr)
+      inst._zod.bag.minimum = def.minimum;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const units = input.length;
+    const length = typeof input === "string" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input) : units;
+    if (length >= def.minimum)
+      return;
+    const origin = getLengthableOrigin(input);
+    payload.issues.push({
+      origin,
+      code: "too_small",
+      minimum: def.minimum,
+      inclusive: true,
+      input,
+      inst,
+      continue: !def.abort
+    });
   };
-  return fn;
-};
-var _safeParse = (_Err) => (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, async: false } : { async: false };
-  const result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise) {
-    throw new $ZodAsyncError;
-  }
-  return result.issues.length ? {
-    success: false,
-    error: new (_Err ?? $ZodError)(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result.value };
-};
-var safeParse = /* @__PURE__ */ _safeParse($ZodRealError);
-var _safeParseAsync = (_Err) => async (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, async: true } : { async: true };
-  let result = schema._zod.run({ value, issues: [] }, ctx);
-  if (result instanceof Promise)
-    result = await result;
-  return result.issues.length ? {
-    success: false,
-    error: new _Err(result.issues.map((iss) => finalizeIssue(iss, ctx, config())))
-  } : { success: true, data: result.value };
-};
-var safeParseAsync = /* @__PURE__ */ _safeParseAsync($ZodRealError);
-var _encode = (_Err) => {
-  const parse = _parse(_Err);
-  const fn = (schema, value, _ctx, _params) => {
-    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return parse(schema, value, ctx, finalizeParams(fn, _params));
+});
+var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
+  var _a;
+  $ZodCheck.init(inst, def);
+  (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.minimum = def.length;
+    bag.maximum = def.length;
+    bag.length = def.length;
+  });
+  inst._zod.check = (payload) => {
+    const input = payload.value;
+    const units = input.length;
+    const length = typeof input === "string" && units >= def.length && units <= def.length * 2 ? codePointLength(input) : units;
+    if (length === def.length)
+      return;
+    const origin = getLengthableOrigin(input);
+    const tooBig = length > def.length;
+    payload.issues.push({
+      origin,
+      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
+      inclusive: true,
+      exact: true,
+      input: payload.value,
+      inst,
+      continue: !def.abort
+    });
   };
-  return fn;
-};
-var _decode = (_Err) => {
-  const parse = _parse(_Err);
-  const fn = (schema, value, _ctx, _params) => {
-    return parse(schema, value, _ctx, finalizeParams(fn, _params));
+});
+var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
+  var _a, _b;
+  $ZodCheck.init(inst, def);
+  inst._zod.onattach.push((inst) => {
+    const bag = inst._zod.bag;
+    bag.format = def.format;
+    if (def.pattern) {
+      bag.patterns ?? (bag.patterns = new Set);
+      bag.patterns.add(def.pattern);
+    }
+  });
+  if (def.pattern)
+    (_a = inst._zod).check ?? (_a.check = (payload) => {
+      def.pattern.lastIndex = 0;
+      if (def.pattern.test(payload.value))
+        return;
+      payload.issues.push({
+        origin: "string",
+        code: "invalid_format",
+        format: def.format,
+        input: payload.value,
+        ...def.pattern ? { pattern: def.pattern.toString() } : {},
+        inst,
+        continue: !def.abort
+      });
+    });
+  else
+    (_b = inst._zod).check ?? (_b.check = () => {});
+});
+var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
+  $ZodCheckStringFormat.init(inst, def);
+  inst._zod.check = (payload) => {
+    def.pattern.lastIndex = 0;
+    if (def.pattern.test(payload.value))
+      return;
+    payload.issues.push({
+      origin: "string",
+      code: "invalid_format",
+      format: "regex",
+      input: payload.value,
+      pattern: def.pattern.toString(),
+      inst,
+      continue: !def.abort
+    });
   };
-  return fn;
-};
-var _encodeAsync = (_Err) => {
-  const parseAsync = _parseAsync(_Err);
-  const fn = async (schema, value, _ctx, _params) => {
-    const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-    return await parseAsync(schema, value, ctx, finalizeParams(fn, _params));
-  };
-  return fn;
-};
-var _decodeAsync = (_Err) => {
-  const parseAsync = _parseAsync(_Err);
-  const fn = async (schema, value, _ctx, _params) => {
-    return await parseAsync(schema, value, _ctx, finalizeParams(fn, _params));
-  };
-  return fn;
-};
-var _safeEncode = (_Err) => (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParse(_Err)(schema, value, ctx);
-};
-var _safeDecode = (_Err) => (schema, value, _ctx) => {
-  return _safeParse(_Err)(schema, value, _ctx);
-};
-var _safeEncodeAsync = (_Err) => async (schema, value, _ctx) => {
-  const ctx = _ctx ? { ..._ctx, direction: "backward" } : { direction: "backward" };
-  return _safeParseAsync(_Err)(schema, value, ctx);
-};
-var _safeDecodeAsync = (_Err) => async (schema, value, _ctx) => {
-  return _safeParseAsync(_Err)(schema, value, _ctx);
-};
-// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/regexes.js
-var cuid = /^[cC][0-9a-z]{6,}$/;
-var cuid2 = /^[0-9a-z]+$/;
-var ulid = /^[0-7][0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{25}$/;
-var xid = /^[0-9a-vA-V]{20}$/;
-var ksuid = /^[A-Za-z0-9]{27}$/;
-var nanoid = /^[a-zA-Z0-9_-]{21}$/;
-function nanoidOfLength(length) {
-  return new RegExp(`^[a-zA-Z0-9_-]{${length}}$`);
-}
-var duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
-var guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
-var uuid = (version) => {
-  if (!version)
-    return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
-};
-var email = /^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-\.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9\-]*\.)+[A-Za-z]{2,}$/;
-var _emoji = `^[\\p{Extended_Pictographic}\\p{Emoji_Component}]+$`;
-function emoji() {
-  return new RegExp(_emoji, "u");
-}
-var ipv4 = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
-var ipv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))$/;
-var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/([0-9]|[1-2][0-9]|3[0-2])$/;
-var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
-var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
-var base64url = /^[A-Za-z0-9_-]*$/;
-var httpProtocol = /^https?$/;
-var e164 = /^\+[1-9]\d{6,14}$/;
-var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
-function anchor(source) {
-  return new RegExp(`^${source}$`);
-}
-var date = /* @__PURE__ */ anchor(dateSource);
-function timeSource(args) {
-  const hhmm = `(?:[01]\\d|2[0-3]):[0-5]\\d`;
-  const regex = typeof args.precision === "number" ? args.precision === -1 ? `${hhmm}` : args.precision === 0 ? `${hhmm}:[0-5]\\d` : `${hhmm}:[0-5]\\d\\.\\d{${args.precision}}` : args.seconds ? `${hhmm}:[0-5]\\d(?:\\.\\d+)?` : `${hhmm}(?::[0-5]\\d(?:\\.\\d+)?)?`;
-  return regex;
-}
-function time(args) {
-  return new RegExp(`^${timeSource(args)}$`);
-}
-function datetime(args) {
-  const opts = ["Z"];
-  if (args.offset)
-    opts.push(`([+-](?:[01]\\d|2[0-3]):[0-5]\\d)`);
-  const qualified = `${timeSource({ precision: args.precision, seconds: true })}(?:${opts.join("|")})`;
-  const timeRegex = args.local ? `${qualified}|${timeSource({ precision: args.precision })}` : qualified;
-  return new RegExp(`^${dateSource}T(?:${timeRegex})$`);
-}
-var string = (params) => {
-  const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
-  return new RegExp(`^${regex}$`);
-};
-var integer = /^-?\d+$/;
-var number = /^-?\d+(?:\.\d+)?$/;
-var boolean = /^(?:true|false)$/i;
-var _null = /^null$/i;
-var lowercase = /^[^A-Z]*$/;
-var uppercase = /^[^a-z]*$/;
-
-// ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/checks.js
-var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
-  var _a;
-  inst._zod ?? (inst._zod = {});
-  inst._zod.def = def;
-  (_a = inst._zod).onattach ?? (_a.onattach = []);
 });
-var _whenHasLength = (payload) => {
-  const val = payload.value;
-  return !nullish(val) && val.length !== undefined;
-};
-var numericOriginMap = {
-  number: "number",
-  bigint: "bigint",
-  object: "date"
-};
-var $ZodCheckLessThan = /* @__PURE__ */ $constructor("$ZodCheckLessThan", (inst, def) => {
+var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
+  def.pattern ?? (def.pattern = lowercase);
+  $ZodCheckStringFormat.init(inst, def);
+});
+var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
+  def.pattern ?? (def.pattern = uppercase);
+  $ZodCheckStringFormat.init(inst, def);
+});
+var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
   $ZodCheck.init(inst, def);
-  const origin = numericOriginMap[typeof def.value];
+  const escapedRegex = escapeRegex(def.includes);
+  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);
+  def.pattern = pattern;
   inst._zod.onattach.push((inst) => {
     const bag = inst._zod.bag;
-    const curr = (def.inclusive ? bag.maximum : bag.exclusiveMaximum) ?? Number.POSITIVE_INFINITY;
-    if (def.value < curr) {
-      if (def.inclusive)
-        bag.maximum = def.value;
-      else
-        bag.exclusiveMaximum = def.value;
-    }
+    bag.patterns ?? (bag.patterns = new Set);
+    bag.patterns.add(pattern);
   });
   inst._zod.check = (payload) => {
-    if (def.inclusive ? payload.value <= def.value : payload.value < def.value) {
+    if (payload.value.includes(def.includes, def.position))
       return;
-    }
     payload.issues.push({
-      origin: numericOriginMap[typeof payload.value] ?? origin,
-      code: "too_big",
-      maximum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      origin: "string",
+      code: "invalid_format",
+      format: "includes",
+      includes: def.includes,
       input: payload.value,
-      inclusive: def.inclusive,
       inst,
       continue: !def.abort
     });
   };
 });
-var $ZodCheckGreaterThan = /* @__PURE__ */ $constructor("$ZodCheckGreaterThan", (inst, def) => {
+var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
   $ZodCheck.init(inst, def);
-  const origin = numericOriginMap[typeof def.value];
+  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
+  def.pattern ?? (def.pattern = pattern);
   inst._zod.onattach.push((inst) => {
     const bag = inst._zod.bag;
-    const curr = (def.inclusive ? bag.minimum : bag.exclusiveMinimum) ?? Number.NEGATIVE_INFINITY;
-    if (def.value > curr) {
-      if (def.inclusive)
-        bag.minimum = def.value;
-      else
-        bag.exclusiveMinimum = def.value;
-    }
+    bag.patterns ?? (bag.patterns = new Set);
+    bag.patterns.add(pattern);
   });
   inst._zod.check = (payload) => {
-    if (def.inclusive ? payload.value >= def.value : payload.value > def.value) {
+    if (payload.value.startsWith(def.prefix))
       return;
-    }
     payload.issues.push({
-      origin: numericOriginMap[typeof payload.value] ?? origin,
-      code: "too_small",
-      minimum: typeof def.value === "object" ? def.value.getTime() : def.value,
+      origin: "string",
+      code: "invalid_format",
+      format: "starts_with",
+      prefix: def.prefix,
       input: payload.value,
-      inclusive: def.inclusive,
       inst,
       continue: !def.abort
     });
   };
 });
-var $ZodCheckMultipleOf = /* @__PURE__ */ $constructor("$ZodCheckMultipleOf", (inst, def) => {
+var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
   $ZodCheck.init(inst, def);
+  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
+  def.pattern ?? (def.pattern = pattern);
   inst._zod.onattach.push((inst) => {
-    var _a;
-    (_a = inst._zod.bag).multipleOf ?? (_a.multipleOf = def.value);
+    const bag = inst._zod.bag;
+    bag.patterns ?? (bag.patterns = new Set);
+    bag.patterns.add(pattern);
   });
   inst._zod.check = (payload) => {
-    if (typeof payload.value !== typeof def.value)
-      throw new Error("Cannot mix number and bigint in multiple_of check.");
-    const isMultiple = typeof payload.value === "bigint" ? def.value !== BigInt(0) && payload.value % def.value === BigInt(0) : floatSafeRemainder(payload.value, def.value) === 0;
-    if (isMultiple)
+    if (payload.value.endsWith(def.suffix))
       return;
     payload.issues.push({
-      origin: typeof payload.value,
-      code: "not_multiple_of",
-      divisor: def.value,
+      origin: "string",
+      code: "invalid_format",
+      format: "ends_with",
+      suffix: def.suffix,
       input: payload.value,
       inst,
       continue: !def.abort
     });
   };
 });
-var $ZodCheckNumberFormat = /* @__PURE__ */ $constructor("$ZodCheckNumberFormat", (inst, def) => {
-  $ZodCheck.init(inst, def);
-  def.format = def.format || "float64";
-  const isInt = def.format?.includes("int");
-  const origin = isInt ? "int" : "number";
-  const [minimum, maximum] = NUMBER_FORMAT_RANGES[def.format];
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag;
-    bag.format = def.format;
-    bag.minimum = minimum;
-    bag.maximum = maximum;
-    if (isInt)
-      bag.pattern = integer;
-  });
-  inst._zod.check = (payload) => {
-    const input = payload.value;
-    if (isInt) {
-      if (!Number.isInteger(input)) {
-        payload.issues.push({
-          expected: origin,
-          format: def.format,
-          code: "invalid_type",
-          continue: false,
-          input,
-          inst
-        });
-        return;
-      }
-      if (!Number.isSafeInteger(input)) {
-        if (input > 0) {
-          payload.issues.push({
-            input,
-            code: "too_big",
-            maximum: Number.MAX_SAFE_INTEGER,
-            note: "Integers must be within the safe integer range.",
-            inst,
-            origin,
-            inclusive: true,
-            continue: !def.abort
-          });
-        } else {
-          payload.issues.push({
-            input,
-            code: "too_small",
-            minimum: Number.MIN_SAFE_INTEGER,
-            note: "Integers must be within the safe integer range.",
-            inst,
-            origin,
-            inclusive: true,
-            continue: !def.abort
-          });
-        }
-        return;
-      }
-    }
-    if (input < minimum) {
-      payload.issues.push({
-        origin: "number",
-        input,
-        code: "too_small",
-        minimum,
-        inclusive: true,
-        inst,
-        continue: !def.abort
-      });
-    }
-    if (input > maximum) {
-      payload.issues.push({
-        origin: "number",
-        input,
-        code: "too_big",
-        maximum,
-        inclusive: true,
-        inst,
-        continue: !def.abort
-      });
-    }
-  };
-});
-var $ZodCheckMaxLength = /* @__PURE__ */ $constructor("$ZodCheckMaxLength", (inst, def) => {
-  var _a;
-  $ZodCheck.init(inst, def);
-  (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
-  inst._zod.onattach.push((inst) => {
-    const curr = inst._zod.bag.maximum ?? Number.POSITIVE_INFINITY;
-    if (def.maximum < curr)
-      inst._zod.bag.maximum = def.maximum;
-  });
-  inst._zod.check = (payload) => {
-    const input = payload.value;
-    const units = input.length;
-    const length = typeof input === "string" && units > def.maximum ? codePointLength(input) : units;
-    if (length <= def.maximum)
-      return;
-    const origin = getLengthableOrigin(input);
-    payload.issues.push({
-      origin,
-      code: "too_big",
-      maximum: def.maximum,
-      inclusive: true,
-      input,
-      inst,
-      continue: !def.abort
-    });
-  };
-});
-var $ZodCheckMinLength = /* @__PURE__ */ $constructor("$ZodCheckMinLength", (inst, def) => {
-  var _a;
-  $ZodCheck.init(inst, def);
-  (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
-  inst._zod.onattach.push((inst) => {
-    const curr = inst._zod.bag.minimum ?? Number.NEGATIVE_INFINITY;
-    if (def.minimum > curr)
-      inst._zod.bag.minimum = def.minimum;
-  });
-  inst._zod.check = (payload) => {
-    const input = payload.value;
-    const units = input.length;
-    const length = typeof input === "string" && units >= def.minimum && units < def.minimum * 2 ? codePointLength(input) : units;
-    if (length >= def.minimum)
-      return;
-    const origin = getLengthableOrigin(input);
-    payload.issues.push({
-      origin,
-      code: "too_small",
-      minimum: def.minimum,
-      inclusive: true,
-      input,
-      inst,
-      continue: !def.abort
-    });
-  };
-});
-var $ZodCheckLengthEquals = /* @__PURE__ */ $constructor("$ZodCheckLengthEquals", (inst, def) => {
-  var _a;
-  $ZodCheck.init(inst, def);
-  (_a = inst._zod.def).when ?? (_a.when = _whenHasLength);
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag;
-    bag.minimum = def.length;
-    bag.maximum = def.length;
-    bag.length = def.length;
-  });
-  inst._zod.check = (payload) => {
-    const input = payload.value;
-    const units = input.length;
-    const length = typeof input === "string" && units >= def.length && units <= def.length * 2 ? codePointLength(input) : units;
-    if (length === def.length)
-      return;
-    const origin = getLengthableOrigin(input);
-    const tooBig = length > def.length;
-    payload.issues.push({
-      origin,
-      ...tooBig ? { code: "too_big", maximum: def.length } : { code: "too_small", minimum: def.length },
-      inclusive: true,
-      exact: true,
-      input: payload.value,
-      inst,
-      continue: !def.abort
-    });
-  };
-});
-var $ZodCheckStringFormat = /* @__PURE__ */ $constructor("$ZodCheckStringFormat", (inst, def) => {
-  var _a, _b;
-  $ZodCheck.init(inst, def);
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag;
-    bag.format = def.format;
-    if (def.pattern) {
-      bag.patterns ?? (bag.patterns = new Set);
-      bag.patterns.add(def.pattern);
-    }
-  });
-  if (def.pattern)
-    (_a = inst._zod).check ?? (_a.check = (payload) => {
-      def.pattern.lastIndex = 0;
-      if (def.pattern.test(payload.value))
-        return;
-      payload.issues.push({
-        origin: "string",
-        code: "invalid_format",
-        format: def.format,
-        input: payload.value,
-        ...def.pattern ? { pattern: def.pattern.toString() } : {},
-        inst,
-        continue: !def.abort
-      });
-    });
-  else
-    (_b = inst._zod).check ?? (_b.check = () => {});
-});
-var $ZodCheckRegex = /* @__PURE__ */ $constructor("$ZodCheckRegex", (inst, def) => {
-  $ZodCheckStringFormat.init(inst, def);
-  inst._zod.check = (payload) => {
-    def.pattern.lastIndex = 0;
-    if (def.pattern.test(payload.value))
-      return;
-    payload.issues.push({
-      origin: "string",
-      code: "invalid_format",
-      format: "regex",
-      input: payload.value,
-      pattern: def.pattern.toString(),
-      inst,
-      continue: !def.abort
-    });
-  };
-});
-var $ZodCheckLowerCase = /* @__PURE__ */ $constructor("$ZodCheckLowerCase", (inst, def) => {
-  def.pattern ?? (def.pattern = lowercase);
-  $ZodCheckStringFormat.init(inst, def);
-});
-var $ZodCheckUpperCase = /* @__PURE__ */ $constructor("$ZodCheckUpperCase", (inst, def) => {
-  def.pattern ?? (def.pattern = uppercase);
-  $ZodCheckStringFormat.init(inst, def);
-});
-var $ZodCheckIncludes = /* @__PURE__ */ $constructor("$ZodCheckIncludes", (inst, def) => {
-  $ZodCheck.init(inst, def);
-  const escapedRegex = escapeRegex(def.includes);
-  const pattern = new RegExp(typeof def.position === "number" ? `^.{${def.position},}${escapedRegex}` : escapedRegex);
-  def.pattern = pattern;
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag;
-    bag.patterns ?? (bag.patterns = new Set);
-    bag.patterns.add(pattern);
-  });
-  inst._zod.check = (payload) => {
-    if (payload.value.includes(def.includes, def.position))
-      return;
-    payload.issues.push({
-      origin: "string",
-      code: "invalid_format",
-      format: "includes",
-      includes: def.includes,
-      input: payload.value,
-      inst,
-      continue: !def.abort
-    });
-  };
-});
-var $ZodCheckStartsWith = /* @__PURE__ */ $constructor("$ZodCheckStartsWith", (inst, def) => {
-  $ZodCheck.init(inst, def);
-  const pattern = new RegExp(`^${escapeRegex(def.prefix)}.*`);
-  def.pattern ?? (def.pattern = pattern);
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag;
-    bag.patterns ?? (bag.patterns = new Set);
-    bag.patterns.add(pattern);
-  });
-  inst._zod.check = (payload) => {
-    if (payload.value.startsWith(def.prefix))
-      return;
-    payload.issues.push({
-      origin: "string",
-      code: "invalid_format",
-      format: "starts_with",
-      prefix: def.prefix,
-      input: payload.value,
-      inst,
-      continue: !def.abort
-    });
-  };
-});
-var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst, def) => {
-  $ZodCheck.init(inst, def);
-  const pattern = new RegExp(`.*${escapeRegex(def.suffix)}$`);
-  def.pattern ?? (def.pattern = pattern);
-  inst._zod.onattach.push((inst) => {
-    const bag = inst._zod.bag;
-    bag.patterns ?? (bag.patterns = new Set);
-    bag.patterns.add(pattern);
-  });
-  inst._zod.check = (payload) => {
-    if (payload.value.endsWith(def.suffix))
-      return;
-    payload.issues.push({
-      origin: "string",
-      code: "invalid_format",
-      format: "ends_with",
-      suffix: def.suffix,
-      input: payload.value,
-      inst,
-      continue: !def.abort
-    });
-  };
-});
-var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
+var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
   $ZodCheck.init(inst, def);
   inst._zod.check = (payload) => {
     payload.value = def.tx(payload.value);
@@ -6338,6 +5645,14 @@ function object(shape, params) {
   };
   return new ZodObject(def);
 }
+function strictObject(shape, params) {
+  return new ZodObject({
+    type: "object",
+    shape,
+    catchall: never(),
+    ...normalizeParams(params)
+  });
+}
 function looseObject(shape, params) {
   return new ZodObject({
     type: "object",
@@ -8937,6 +8252,7 @@ var contributions = sqliteTable("contributions", {
   createdAt: ts("created_at").notNull()
 }, (t) => ({
   threadIdx: index("contributions_thread_idx").on(t.threadId),
+  threadCreatedIdx: index("contributions_thread_created_idx").on(t.threadId, t.createdAt),
   aboutIdx: index("contributions_about_idx").on(t.aboutType, t.aboutId),
   authorIdempotencyIdx: uniqueIndex("contributions_author_idempotency_idx").on(t.authorProfileId, t.idempotencyKey)
 }));
@@ -9612,6 +8928,14 @@ var notificationCursors = sqliteTable("notification_cursors", {
   profileId: text("profile_id").primaryKey().references(() => profiles.id),
   lastSeenAt: ts("last_seen_at").notNull()
 });
+var spaceVisits = sqliteTable("space_visits", {
+  profileId: text("profile_id").notNull().references(() => profiles.id),
+  spaceId: text("space_id").notNull().references(() => spaces.id),
+  lastVisitedAt: ts("last_visited_at").notNull()
+}, (t) => ({
+  pk: primaryKey({ columns: [t.profileId, t.spaceId] }),
+  spaceIdx: index("space_visits_space_idx").on(t.spaceId, t.lastVisitedAt)
+}));
 var recallIndex = sqliteTable("recall_index", {
   objectId: text("object_id").primaryKey(),
   indexedAt: ts("indexed_at").notNull(),
@@ -9994,6 +9318,8 @@ var EMOJI_RE = new RegExp("^\\p{RGI_Emoji}$", "v");
 var BASE_MS = Date.parse("2026-07-20T15:00:00.000Z");
 // ../core/src/ops/agent-pairing.ts
 var PAIRING_TTL_MS = 15 * 60 * 1000;
+// ../core/src/ops/space-visit.ts
+var VISIT_THROTTLE_MS = 5 * 60 * 1000;
 // ../core/src/ops/package-cache.ts
 var PACKAGE_CACHE_PENDING_TTL_MS = 15 * 60 * 1000;
 var PACKAGE_CACHE_FINAL_TTL_MS = 30 * 24 * 60 * 60 * 1000;
@@ -10139,6 +9465,13 @@ function recordExternalReadDefaults(operation, defaults) {
 }
 
 // ../actions/src/output-schemas.ts
+var adminCloseOutputSchema = strictObject({
+  finishMode: literal("admin_close"),
+  runId: string2(),
+  status: literal("cancelled"),
+  reasonCode: literal("run.admin_closed_abandoned"),
+  actorProfileId: string2()
+});
 function buildOutputSchemas() {
   const id = string2();
   const timestamp = string2();
@@ -10432,6 +9765,11 @@ function buildOutputSchemas() {
     execution: _enum(["completed", "running"]).optional(),
     nextAction: literal("computer_process_read").optional()
   });
+  const computerRunSaveSkip = looseObject({
+    state: literal("skipped"),
+    lastDurableSnapshotId: id.nullable(),
+    unsavedChanges: literal("not-saved-by-close")
+  });
   const computerRunReceipt = looseObject({
     runId: id,
     threadId: id,
@@ -10472,6 +9810,7 @@ function buildOutputSchemas() {
     outcome: _enum(["finished", "failed", "cancelled"]).nullable(),
     reason: string2().nullable(),
     reasonCode: string2().nullable(),
+    save: computerRunSaveSkip.nullable(),
     operations: array(looseObject({
       operationId: string2(),
       kind: literal("exec"),
@@ -11734,10 +11073,12 @@ function buildOutputSchemas() {
     computer_run_finish: looseObject({
       runId: id,
       status: string2(),
+      finishMode: literal("owner").optional(),
       replayed: boolean2(),
       durability: computerRunDurability,
       finishAssessment: computerRunFinishAssessment.nullable(),
       finishRequest: computerRunFinishRequest.nullable(),
+      save: computerRunSaveSkip.optional(),
       parent: object({
         checkpoint: string2().nullable(),
         stopped: boolean2(),
@@ -12135,6 +11476,78 @@ function outputSchemaFor(actionName) {
   return outputSchemas[actionName];
 }
 
+// ../actions/src/action-projection.ts
+var templates = new WeakMap;
+var origins = new WeakMap;
+var advertisements = new WeakMap;
+function variantShape(action, variant) {
+  return Object.fromEntries(Object.entries({ ...action.inputSchema, ...variant.inputSchema }).filter(([key]) => !variant.omitInputs?.includes(key)));
+}
+function objectUnion(schemas) {
+  const shape = {};
+  const keys = new Set(schemas.flatMap((schema) => Object.keys(schema.shape)));
+  for (const key of keys) {
+    const fields = schemas.map((schema) => schema.shape[key]);
+    const present = fields.filter((field) => field !== undefined);
+    const field = present.length === 1 ? present[0] : union(present);
+    shape[key] = fields.some((field) => field === undefined || field.isOptional()) ? field.optional() : field;
+  }
+  const union2 = union(schemas);
+  return looseObject(shape).superRefine((value, ctx) => {
+    const parsed = union2.safeParse(value);
+    if (!parsed.success)
+      for (const issue of parsed.error.issues)
+        ctx.addIssue({ code: "custom", path: issue.path, message: issue.message });
+  });
+}
+function prepare(action) {
+  action = origins.get(action) ?? action;
+  const cached = templates.get(action);
+  if (cached)
+    return cached;
+  const inputs = [strictObject(action.inputSchema)];
+  const outputs = action.outputSchema ? [action.outputSchema] : [];
+  const combined = { ...action.inputSchema };
+  const extensions = action.privilegedVariants ?? [];
+  for (const variant of extensions) {
+    inputs.push(strictObject(variantShape(action, variant)));
+    outputs.push(variant.outputSchema);
+    for (const [key, field] of Object.entries(variant.inputSchema)) {
+      const base = combined[key];
+      const extension = field;
+      combined[key] = (base ? union([base, extension]).optional() : extension.optional()).describe(extension.description ?? "");
+    }
+  }
+  Object.freeze(action.inputSchema);
+  const advertisedOutput = objectUnion(outputs);
+  Object.freeze(advertisedOutput.shape);
+  const result = {
+    tags: Object.freeze(extensions.map((variant) => variant.tag)),
+    advertised: Object.freeze({
+      ...action,
+      description: extensions.map((variant) => variant.description).join(" "),
+      inputSchema: Object.freeze(combined),
+      outputSchema: advertisedOutput
+    }),
+    executionInput: inputs.length === 1 ? inputs[0] : discriminatedUnion(action.variantDiscriminator, [inputs[0], ...inputs.slice(1)]),
+    executionOutput: outputs.length > 1 ? union(outputs) : outputs[0],
+    executionShape: combined
+  };
+  origins.set(result.advertised, action);
+  templates.set(action, result);
+  return result;
+}
+function projectActionVariants(action, tags) {
+  action = origins.get(action) ?? action;
+  if (!action.privilegedVariants?.length || tags.length === 0)
+    return action;
+  const template = prepare(action);
+  return tags.length === template.tags.length && template.tags.every((tag) => tags.includes(tag)) ? template.advertised : action;
+}
+function canonicalInputShape(action) {
+  return action.privilegedVariants?.length ? prepare(action).executionShape : action.inputSchema;
+}
+var manifests = new WeakMap;
 // ../actions/src/agent-guides.ts
 var AGENT_GUIDE_URLS = {
   tldraw: "https://arborthreads.com/docs/agents/tldraw",
@@ -12373,6 +11786,9 @@ var OUTPUT_SHAPERS = {
     ]);
   },
   computer_run_finish: (result) => {
+    if (result.finishMode === "admin_close") {
+      return selected(result, ["finishMode", "runId", "status", "reasonCode", "actorProfileId"]);
+    }
     const run = record2(result.run) ?? {};
     return defined([
       ["runId", run.runId],
@@ -12381,6 +11797,7 @@ var OUTPUT_SHAPERS = {
       ["durability", run.durability],
       ["finishAssessment", result.finishAssessment],
       ["finishRequest", result.finishRequest ?? null],
+      ["save", result.save],
       ["parent", result.parent]
     ]);
   },
@@ -12436,7 +11853,7 @@ function shapeActionOutput(actionName, value, input = {}) {
   if (!shaper)
     return value;
   const publicValue = shaper(record2(value) ?? {}, input);
-  const schema = outputSchemaFor(actionName);
+  const schema = actionName === "computer_run_finish" && record2(publicValue)?.finishMode === "admin_close" ? adminCloseOutputSchema : outputSchemaFor(actionName);
   if (!schema)
     throw new Error(`${actionName}: compact action is missing an output schema`);
   const parsed = schema.safeParse(publicValue);
@@ -12610,7 +12027,7 @@ var MCP_TOOL_ANNOTATIONS = {
   computer_run_suspend: idempotent,
   computer_run_promote: idempotent,
   computer_repo_work_status: readOnly,
-  computer_run_finish: idempotent,
+  computer_run_finish: destructive,
   computer_run_receipt: readOnly,
   computer_run_retention: readOnly,
   computer_run_keep: idempotent,
@@ -13846,15 +13263,30 @@ var ACTION_DEFINITIONS = [
   {
     name: "computer_run_finish",
     title: "Finish a run",
-    description: "End this Run with an accomplishments summary when done with its workspace; suspend if you expect to return. Git publication not required (isolated finish drops unpublished work); shared finish checkpoints/stops last shared Run; shared discard closes only record; isolated discard abandons after quiescence; May stay pending for quiescence, checkpoint, release; discard=true requires failed/cancelled.",
+    description: "End your Run with a reason; suspend if you expect to return; shared finish checkpoints/stops the last Run, isolated finish needs no Git publication and may stay pending for quiescence, checkpoint, release. Owner discard=true requires failed/cancelled; shared closes only the record, isolated abandons after quiescence.",
     inputSchema: {
       runId: string2().describe("the runId returned by computer_run_start, run_…"),
-      outcome: _enum(["finished", "failed", "cancelled"]).optional().describe("terminal outcome; defaults to finished"),
-      reason: string2().trim().max(500).optional().describe("required for a new finish intent: accomplishments and useful outcomes or limits; exact accepted legacy retries reuse their original text or omission"),
-      discard: boolean2().optional().describe("explicitly abandon this Run's workspace only after provider quiescence; requires outcome failed or cancelled and never overrides active or unknown execution")
+      finishMode: literal("owner").optional().describe("owner finish; omission preserves existing behavior"),
+      outcome: _enum(["finished", "failed", "cancelled"]).optional().describe("owner mode only: terminal outcome; defaults to finished"),
+      reason: string2().trim().max(500).optional().describe("owner mode only, required for a new finish intent: accomplishments and useful outcomes or limits; exact accepted legacy retries reuse their original text or omission"),
+      discard: boolean2().optional().describe("owner mode only: discard=true requires failed/cancelled; shared closes only the record, isolated abandons after quiescence; never overrides active or unknown execution"),
+      save: boolean2().optional().describe("owner mode only: false closes without the final checkpoint and deletes nothing: receipt records reasonCode run.closed_without_save and save.lastDurableSnapshotId; shared or suspended Runs only; not with discard")
     },
     surfaces: ["computer-mcp", "computer-cli"],
     toolset: "loop",
+    variantDiscriminator: "finishMode",
+    privilegedVariants: [
+      {
+        tag: "admin_close",
+        requires: "active-org-admin",
+        inputSchema: {
+          finishMode: literal("admin_close").describe("active same-org owner/admin only: admin_close is record-only cancelled/run.admin_closed_abandoned for an abandoned shared Run; omit outcome/reason/discard/save; refuses unsettled processes, pending finish or isolated execution")
+        },
+        omitInputs: ["outcome", "reason", "discard", "save"],
+        description: "End your Run with a reason; owner finish checkpoints/stops the last shared Run or releases isolated execution. Organization owner/admin only: finishMode=admin_close cancels only an abandoned shared record with fixed audit code and no runtime work; omit outcome/reason/discard/save.",
+        outputSchema: adminCloseOutputSchema
+      }
+    ],
     run: forward("computer_runtime.run_finish")
   },
   {
@@ -16068,224 +15500,962 @@ var ACTION_DEFINITIONS = [
     })
   }
 ];
-var ACTIONS = ACTION_DEFINITIONS.map((action) => {
-  if (action.requiresCapability && !action.surfaces.includes("mcp")) {
-    throw new Error(`${action.name}: requiresCapability is an MCP catalog gate`);
+var ACTIONS = ACTION_DEFINITIONS.map((action) => {
+  if (action.requiresCapability && !action.surfaces.includes("mcp")) {
+    throw new Error(`${action.name}: requiresCapability is an MCP catalog gate`);
+  }
+  const externalReadDefaults = action.inputSchema.limit === PAGINATION_INPUT.limit ? { ...action.externalReadDefaults, limit: EXTERNAL_DEFAULT_PAGE_SIZE } : action.externalReadDefaults;
+  for (const operation of forwardedOperations(action.run)) {
+    recordExternalReadDefaults(operation, externalReadDefaults);
+  }
+  if (!action.surfaces.some((surface) => surface === "mcp" || surface === "computer-mcp")) {
+    return externalReadDefaults ? { ...action, externalReadDefaults } : action;
+  }
+  const annotations = mcpAnnotationsFor(action.name);
+  return {
+    ...action,
+    externalReadDefaults,
+    get outputSchema() {
+      const schema = outputSchemaFor(action.name);
+      if (!schema)
+        throw new Error(`${action.name}: MCP action is missing an output schema`);
+      return schema;
+    },
+    annotations
+  };
+});
+
+// ../actions/src/retention-entry.ts
+var ARBOR_VERSION = "0.24.16";
+var historyPolicySchema = _enum(["full", "checkpoint"]).optional().describe("text Artifacts: future history retention policy; full retains every source snapshot, checkpoint keeps metadata for every revision and source only when explicitly retained");
+var retainSourceSchema = boolean2().optional().describe("edit: in checkpoint mode, retain this newly minted content revision's source");
+var checkpointSchema = boolean2().optional().describe("edit: retain the exact current version source without incrementing content version");
+var ARTIFACT_GET_PUBLIC_DESCRIPTION = "Read one Artifact as a compact card without loading its body; editable text supports its outline plus bounded startLine+limit or heading windows and explicit all=true; File Artifacts remain files and report whether bounded UTF-8 text projection is available. For text-like files use startLine+limit and nextLine; all=true and heading stay unavailable for files, binary/unsupported files use the Artifact URL/download/media surface, and editable historical reads retain exact artifactVersionId.";
+function artifactEditInput(input) {
+  const patches = Array.isArray(input.patches);
+  const hasSource = typeof input.source === "string";
+  const checkpoint = input.checkpoint === true;
+  const historyPolicy = input.historyPolicy === "full" || input.historyPolicy === "checkpoint";
+  if (checkpoint && (patches || hasSource || historyPolicy)) {
+    throw new Error("artifact edit checkpoint cannot be combined with source, patches, or historyPolicy");
+  }
+  if (historyPolicy && (patches || hasSource)) {
+    throw new Error("artifact historyPolicy change cannot be combined with a content edit");
+  }
+  if (checkpoint)
+    return { ...input, verb: "checkpoint" };
+  if (historyPolicy)
+    return { ...input, verb: "set_history_policy" };
+  return { ...input, verb: patches ? "patch" : "replace" };
+}
+function runArtifact(ex, input) {
+  const { verb, ...rest } = input;
+  if (verb === "create")
+    return ex.call("artifact.create", rest);
+  if (verb === "edit")
+    return ex.call("artifact.edit", artifactEditInput(rest));
+  if (verb === "set_live_preview")
+    return ex.call("artifact.setLivePreview", rest);
+  if (verb === "set_snapshot")
+    return ex.call("artifact.setSnapshot", rest);
+  if (verb === "promote_attachment")
+    return ex.call("attachment.promote", rest);
+  return Promise.reject(new Error(`unknown artifact verb "${verb ?? ""}"`));
+}
+function overrideAction(action, overrides) {
+  return Object.assign(Object.defineProperties({}, Object.getOwnPropertyDescriptors(action)), overrides);
+}
+function retentionAction(action) {
+  if (action.name === "create_artifact") {
+    return overrideAction(action, {
+      description: "Create a durable Artifact; text kinds may choose historyPolicy=full (default) or checkpoint. Checkpoint mode still keeps metadata/provenance for every revision while source snapshots are retained only when explicitly checkpointed.",
+      inputSchema: { ...action.inputSchema, historyPolicy: historyPolicySchema }
+    });
+  }
+  if (action.name === "edit_artifact") {
+    return overrideAction(action, {
+      description: "Edit a text Artifact from the baseVersion you read, or change its future historyPolicy/checkpoint the exact current source without minting a content version. Content edits return the exact artifactVersionId; byte-identical results are idempotent no-ops that reuse the current version identity, while stale divergent edits remain structured conflicts.",
+      inputSchema: {
+        ...action.inputSchema,
+        historyPolicy: historyPolicySchema,
+        checkpoint: checkpointSchema,
+        retainSource: retainSourceSchema
+      },
+      run: (ex, input) => ex.call("artifact.edit", artifactEditInput(input))
+    });
+  }
+  if (action.name === "get_artifact" || action.name === "artifact_get") {
+    return overrideAction(action, { description: ARTIFACT_GET_PUBLIC_DESCRIPTION });
+  }
+  if (action.name === "artifact") {
+    return overrideAction(action, {
+      description: "Create/edit a durable Artifact with full|checkpoint retention or manage Live Preview, snapshots, and attachments. Git edits derive retry keys (omitted edits derive one); keyless creates mint per-invocation keys; stable idempotencyKey supports caller retries; never blindly repeat ambiguous creates. promote_attachment creates a file Artifact from a Contribution; exported reports use the Attachment downloadUrl; policy changes do not mint content versions.",
+      inputSchema: {
+        ...action.inputSchema,
+        historyPolicy: historyPolicySchema,
+        checkpoint: checkpointSchema,
+        retainSource: retainSourceSchema
+      },
+      run: runArtifact
+    });
+  }
+  return action;
+}
+var ACTIONS2 = ACTIONS.map(retentionAction);
+
+// ../actions/src/recovery-entry.ts
+var grantOutput = object({
+  grant: object({
+    grantId: string2(),
+    requestId: string2(),
+    threadId: string2(),
+    runId: string2(),
+    computerId: string2(),
+    granteeProfileId: string2(),
+    grantedByProfileId: string2(),
+    expiresAt: string2(),
+    createdAt: string2(),
+    revokedAt: string2().nullable(),
+    revokedByProfileId: string2().nullable()
+  }),
+  replayed: boolean2()
+});
+var diagnosticOutput = object({
+  grant: object({
+    grantId: string2(),
+    requestId: string2(),
+    expiresAt: string2()
+  }),
+  diagnostic: object({
+    runId: string2(),
+    computerId: string2(),
+    computerGeneration: number2().int().positive(),
+    status: _enum(["active", "finished", "failed", "cancelled"]),
+    outcome: _enum(["finished", "failed", "cancelled"]).nullable(),
+    reasonCode: string2().nullable(),
+    runtimeState: _enum(["shared", "live", "suspended", "releasing", "released"]),
+    snapshotLineage: object({
+      baseSnapshotId: string2().nullable(),
+      currentSnapshotId: string2().nullable()
+    }),
+    providerState: object({
+      generation: number2().int().min(0).nullable(),
+      lastPhase: string2().nullable(),
+      lastReasonCode: string2().nullable()
+    }),
+    operations: array(object({
+      operationId: string2(),
+      execution: _enum(["foreground", "background"]),
+      state: _enum([
+        "starting",
+        "running",
+        "completed",
+        "failed",
+        "cancelled",
+        "not-routed",
+        "provider-lost",
+        "unknown"
+      ]),
+      mutationRetrySafety: _enum(["not-needed", "safe", "unsafe", "unknown"]),
+      reasonCode: string2()
+    }))
+  }),
+  auditEventId: string2()
+});
+var additive2 = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var auditedRead = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: false,
+  openWorldHint: false
+};
+var RECOVERY_ACTIONS = [
+  {
+    name: "computer_recovery_grant",
+    title: "Grant delegated Computer recovery",
+    description: "Issue one short-lived diagnostic grant for a profile explicitly targeted by the same open Request and exact Run. This grants no execution, file, environment, Secret, Git, checkpoint, or lifecycle capability.",
+    inputSchema: {
+      requestId: string2().describe("the targeted open Request authorizing this recovery scope, req_…"),
+      runId: string2().describe("the exact Run whose diagnostic state may be inspected, run_…"),
+      granteeProfileId: string2().describe("the exact targeted profile receiving diagnostic visibility"),
+      expiresAt: string2().describe("future ISO timestamp, at most 24 hours and never after Request expiry"),
+      idempotencyKey: string2().min(1).max(200).describe("stable key for this one logical grant")
+    },
+    outputSchema: grantOutput,
+    annotations: additive2,
+    surfaces: ["computer-cli"],
+    toolset: "loop",
+    run: (ex, input) => ex.call("computer_recovery.grant", input)
+  },
+  {
+    name: "computer_recovery_revoke",
+    title: "Revoke delegated Computer recovery",
+    description: "Revoke one previously issued delegated diagnostic grant without touching the Computer or provider. Repeating the same revoke is an idempotent no-op.",
+    inputSchema: {
+      grantId: string2().describe("the delegated recovery grant, crg_…")
+    },
+    outputSchema: grantOutput,
+    annotations: additive2,
+    surfaces: ["computer-cli"],
+    toolset: "loop",
+    run: (ex, input) => ex.call("computer_recovery.revoke", input)
+  },
+  {
+    name: "computer_recovery_inspect",
+    title: "Inspect delegated Computer recovery state",
+    description: "Read only the sanitized diagnostic projection authorized by one live delegated grant; every successful read records an attributed Arbor audit Event. It never calls the provider or exposes repository paths/heads, command output, environment, Secrets, sessions, or mutation controls.",
+    inputSchema: {
+      grantId: string2().describe("the delegated recovery grant, crg_…")
+    },
+    outputSchema: diagnosticOutput,
+    annotations: auditedRead,
+    surfaces: ["computer-mcp", "computer-cli"],
+    toolset: "loop",
+    run: (ex, input) => ex.call("computer_recovery.inspect", input)
+  }
+];
+var ACTIONS3 = [...ACTIONS2, ...RECOVERY_ACTIONS];
+
+// src/config.ts
+import {
+  chmodSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+// src/errors.ts
+var ERROR_CODES = new Set([
+  "UNAUTHORIZED",
+  "FORBIDDEN",
+  "NOT_FOUND",
+  "VALIDATION",
+  "CONFLICT",
+  "RATE_LIMITED",
+  "NETWORK",
+  "INTERNAL"
+]);
+function isErrorCode(value) {
+  return typeof value === "string" && ERROR_CODES.has(value);
+}
+function codeForStatus(status) {
+  switch (status) {
+    case 0:
+      return "NETWORK";
+    case 400:
+    case 422:
+      return "VALIDATION";
+    case 401:
+      return "UNAUTHORIZED";
+    case 403:
+      return "FORBIDDEN";
+    case 404:
+    case 410:
+      return "NOT_FOUND";
+    case 409:
+      return "CONFLICT";
+    case 429:
+      return "RATE_LIMITED";
+    default:
+      return "INTERNAL";
+  }
+}
+function exitCodeForError(code) {
+  switch (code) {
+    case "VALIDATION":
+      return 2;
+    case "UNAUTHORIZED":
+      return 22;
+    default:
+      return 1;
+  }
+}
+function codeForError(err) {
+  if (err && typeof err === "object" && "code" in err && isErrorCode(err.code)) {
+    return err.code;
+  }
+  return "INTERNAL";
+}
+function parseErrorDetails(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const raw = value;
+  if (typeof raw.reason !== "string" || raw.reason === "")
+    return;
+  const details = { reason: raw.reason };
+  if (typeof raw.field === "string")
+    details.field = raw.field;
+  if (typeof raw.limit === "number")
+    details.limit = raw.limit;
+  if (typeof raw.retryable === "boolean")
+    details.retryable = raw.retryable;
+  if (typeof raw.phase === "string")
+    details.phase = raw.phase;
+  if (raw.provider && typeof raw.provider === "object" && !Array.isArray(raw.provider)) {
+    const provider = raw.provider;
+    if (typeof provider.stage === "string" && provider.stage !== "") {
+      details.provider = {
+        stage: provider.stage,
+        ...typeof provider.exitCode === "number" ? { exitCode: provider.exitCode } : {},
+        ...typeof provider.stdout === "string" ? { stdout: provider.stdout } : {},
+        ...typeof provider.stderr === "string" ? { stderr: provider.stderr } : {},
+        ...typeof provider.containerStarted === "boolean" ? { containerStarted: provider.containerStarted } : {},
+        ...typeof provider.repositoryMaterialized === "boolean" ? { repositoryMaterialized: provider.repositoryMaterialized } : {}
+      };
+    }
+  }
+  if (typeof raw.runId === "string")
+    details.runId = raw.runId;
+  if (typeof raw.operationId === "string")
+    details.operationId = raw.operationId;
+  if (typeof raw.processId === "string")
+    details.processId = raw.processId;
+  if (raw.outputRetention && typeof raw.outputRetention === "object") {
+    const retention = raw.outputRetention;
+    if (retention.state === "expired" && typeof retention.expiresAt === "string") {
+      details.outputRetention = { state: "expired", expiresAt: retention.expiresAt };
+    }
+  }
+  if (raw.commandExecution === "not-routed" || raw.commandExecution === "unknown") {
+    details.commandExecution = raw.commandExecution;
+  }
+  if (raw.mutationRetrySafety === "safe" || raw.mutationRetrySafety === "unsafe" || raw.mutationRetrySafety === "unknown") {
+    details.mutationRetrySafety = raw.mutationRetrySafety;
+  }
+  if (typeof raw.compatibilityState === "string") {
+    details.compatibilityState = raw.compatibilityState;
+  }
+  if (typeof raw.compatibilityReason === "string") {
+    details.compatibilityReason = raw.compatibilityReason;
+  }
+  if (typeof raw.suggestedAction === "string")
+    details.suggestedAction = raw.suggestedAction;
+  if (typeof raw.catalogRevision === "string")
+    details.catalogRevision = raw.catalogRevision;
+  if (typeof raw.clientCatalogRevision === "string") {
+    details.clientCatalogRevision = raw.clientCatalogRevision;
+  }
+  if (typeof raw.catalogNextStep === "string")
+    details.catalogNextStep = raw.catalogNextStep;
+  return details;
+}
+function detailsForError(err) {
+  if (!err || typeof err !== "object" || !("details" in err))
+    return;
+  return parseErrorDetails(err.details);
+}
+
+class ApiError extends Error {
+  status;
+  details;
+  code;
+  constructor(message, status, details) {
+    super(message);
+    this.status = status;
+    this.details = details;
+    this.name = "ApiError";
+    this.code = codeForStatus(status);
+  }
+}
+
+class UsageError extends Error {
+  code = "VALIDATION";
+  details;
+  constructor(message, details) {
+    super(message);
+    this.name = "UsageError";
+    this.details = details ?? { reason: "validation.invalid_value" };
+  }
+}
+
+class PartialUploadError extends Error {
+  partialResult;
+  code;
+  details;
+  constructor(message, cause, partialResult) {
+    super(message);
+    this.partialResult = partialResult;
+    this.name = "PartialUploadError";
+    this.code = codeForError(cause);
+    this.details = detailsForError(cause);
+  }
+}
+
+// src/config.ts
+var PROD_API_URL = "https://arborthreads.com";
+var PROFILE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function arborDir() {
+  return join(homedir(), ".arbor");
+}
+function defaultConfigPath() {
+  return join(arborDir(), "config.json");
+}
+function profilesDir() {
+  return join(arborDir(), "profiles");
+}
+function registryPath() {
+  return join(arborDir(), "profiles.json");
+}
+function namedConfigPath(name) {
+  return join(profilesDir(), `${name}.json`);
+}
+var CONFIG_PATH = process.env.ARBOR_CONFIG ?? join(homedir(), ".arbor", "config.json");
+var DEFAULT_TOKEN_OVERWRITE_REFUSAL = "refusing to overwrite ~/.arbor/config.json — a token already exists. Set ARBOR_CONFIG to an isolated path (e.g. ~/.arbor/<agent>.config.json) and retry.";
+var LOCK_TIMEOUT_MS = 5000;
+var LOCK_STALE_MS = 30000;
+var LOCK_POLL_MS = 20;
+var activeTarget;
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function acquireConfigLock(configPath) {
+  const lockPath = `${configPath}.lock`;
+  const deadline = Date.now() + LOCK_TIMEOUT_MS;
+  for (;; ) {
+    try {
+      mkdirSync(lockPath);
+      return () => {
+        try {
+          rmSync(lockPath, { recursive: true, force: true });
+        } catch {}
+      };
+    } catch (err) {
+      if (err?.code !== "EEXIST")
+        throw err;
+      try {
+        if (Date.now() - statSync(lockPath).mtimeMs > LOCK_STALE_MS) {
+          rmSync(lockPath, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`timed out waiting for another arbor process to finish writing ${configPath}. If none is running, remove ${lockPath}.`);
+      }
+      sleepSync(LOCK_POLL_MS);
+    }
+  }
+}
+function validateProfileName(name, field = "profile") {
+  if (!PROFILE_NAME.test(name)) {
+    throw new UsageError(`invalid profile name: ${JSON.stringify(name)}`, {
+      reason: "validation.invalid_value",
+      field
+    });
+  }
+}
+function fsType(entry, predicate) {
+  const value = entry[predicate];
+  return typeof value === "function" ? Boolean(value.call(entry)) : value === true;
+}
+function rejectSymlink(path, label) {
+  if (!existsSync(path))
+    return;
+  if (fsType(lstatSync(path), "isSymbolicLink"))
+    throw new Error(`${label} must not be a symbolic link: ${path}`);
+}
+function ensureArborDir() {
+  const dir = arborDir();
+  rejectSymlink(dir, "Arbor config directory");
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+}
+function ensureProfilesDir() {
+  ensureArborDir();
+  const dir = profilesDir();
+  rejectSymlink(dir, "Arbor profiles directory");
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+}
+function readRegistry() {
+  const path = registryPath();
+  if (!existsSync(path))
+    return {};
+  rejectSymlink(path, "Arbor profile registry");
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.defaultProfile !== undefined)
+      validateProfileName(parsed.defaultProfile);
+    return { defaultProfile: parsed.defaultProfile };
+  } catch (err) {
+    if (err instanceof UsageError)
+      throw err;
+    throw new Error(`could not read Arbor profile registry ${path}`);
+  }
+}
+function writeRegistry(registry) {
+  ensureArborDir();
+  const path = registryPath();
+  rejectSymlink(path, "Arbor profile registry");
+  const release = acquireConfigLock(path);
+  try {
+    const safe = registry.defaultProfile ? { defaultProfile: registry.defaultProfile } : {};
+    writeFileSync(path, `${JSON.stringify(safe, null, 2)}
+`, { mode: 384 });
+    chmodSync(path, 384);
+  } finally {
+    release();
+  }
+}
+function profileExists(name, field = "profile") {
+  validateProfileName(name, field);
+  const path = namedConfigPath(name);
+  if (!existsSync(path))
+    return false;
+  rejectSymlink(path, `Arbor profile ${name}`);
+  return fsType(lstatSync(path), "isFile");
+}
+function legacyTarget() {
+  const defaultPath = defaultConfigPath();
+  const envPath = process.env.ARBOR_CONFIG;
+  return {
+    path: envPath ?? defaultPath,
+    defaultPath,
+    isolated: Boolean(envPath),
+    named: false,
+    explicitProfile: false
+  };
+}
+function resolveTarget(opts) {
+  const profileFlag = opts?.profileFlag;
+  const envProfile = process.env.ARBOR_PROFILE;
+  if (process.env.ARBOR_CONFIG && profileFlag !== undefined) {
+    throw new UsageError("ARBOR_CONFIG and --profile are ambiguous; choose one credential selector", {
+      reason: "validation.invalid_value",
+      field: "profile"
+    });
+  }
+  if (process.env.ARBOR_CONFIG && envProfile !== undefined) {
+    throw new UsageError("ARBOR_CONFIG and ARBOR_PROFILE are ambiguous; choose one credential selector", { reason: "validation.invalid_value", field: "ARBOR_PROFILE" });
+  }
+  if (process.env.ARBOR_CONFIG)
+    return legacyTarget();
+  const registryDefault = readRegistry().defaultProfile;
+  const selected = profileFlag ?? envProfile ?? registryDefault;
+  if (selected === undefined)
+    return legacyTarget();
+  const field = profileFlag !== undefined ? "profile" : envProfile !== undefined ? "ARBOR_PROFILE" : "profile";
+  validateProfileName(selected, field);
+  if (!opts?.allowMissingProfile && !profileExists(selected, field)) {
+    throw new UsageError(`unknown profile: ${selected}`, {
+      reason: "validation.invalid_value",
+      field
+    });
+  }
+  return {
+    path: namedConfigPath(selected),
+    defaultPath: defaultConfigPath(),
+    isolated: true,
+    profile: selected,
+    named: true,
+    explicitProfile: profileFlag !== undefined
+  };
+}
+function configureConfigTarget(opts) {
+  activeTarget = resolveTarget(opts);
+}
+function currentTarget() {
+  return activeTarget ?? resolveTarget();
+}
+function getConfigPath() {
+  return currentTarget().path;
+}
+function listProfiles() {
+  const registry = readRegistry();
+  const dir = profilesDir();
+  if (!existsSync(dir))
+    return { defaultProfile: registry.defaultProfile, profiles: [] };
+  rejectSymlink(dir, "Arbor profiles directory");
+  const profiles = readdirSync(dir).filter((entry) => entry.endsWith(".json")).map((entry) => {
+    const name = entry.slice(0, -5);
+    validateProfileName(name);
+    const path = join(dir, entry);
+    const stats = lstatSync(path);
+    if (fsType(stats, "isSymbolicLink"))
+      throw new Error(`Arbor profile ${name} must not be a symbolic link: ${path}`);
+    if (!fsType(stats, "isFile"))
+      throw new Error(`Arbor profile ${name} is not a regular file: ${path}`);
+    return { name, default: registry.defaultProfile === name };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+  return { defaultProfile: registry.defaultProfile, profiles };
+}
+function profileShow(name) {
+  validateProfileName(name);
+  if (!profileExists(name)) {
+    throw new UsageError(`unknown profile: ${name}`, {
+      reason: "validation.invalid_value",
+      field: "profile"
+    });
+  }
+  const registry = readRegistry();
+  const cfg = JSON.parse(readFileSync(namedConfigPath(name), "utf8"));
+  return {
+    name,
+    default: registry.defaultProfile === name,
+    apiUrl: cfg.apiUrl || PROD_API_URL
+  };
+}
+function setDefaultProfile(name) {
+  if (name !== null) {
+    validateProfileName(name);
+    if (!profileExists(name)) {
+      throw new UsageError(`unknown profile: ${name}`, {
+        reason: "validation.invalid_value",
+        field: "profile"
+      });
+    }
+  }
+  writeRegistry(name ? { defaultProfile: name } : {});
+}
+function clearDefaultProfile() {
+  setDefaultProfile(null);
+}
+function deleteProfile(name) {
+  validateProfileName(name);
+  const registry = readRegistry();
+  if (registry.defaultProfile === name) {
+    throw new UsageError(`cannot delete default profile ${name}; select another default or run profile clear-default first`, { reason: "validation.invalid_value", field: "profile" });
+  }
+  if (!profileExists(name)) {
+    throw new UsageError(`unknown profile: ${name}`, {
+      reason: "validation.invalid_value",
+      field: "profile"
+    });
+  }
+  const path = namedConfigPath(name);
+  rejectSymlink(path, `Arbor profile ${name}`);
+  rmSync(path);
+}
+function defaultConfigOverwriteBlocked(opts) {
+  const target = currentTarget();
+  const isolated = opts?.isolated ?? target.isolated;
+  const path = opts?.path ?? target.defaultPath;
+  if (isolated)
+    return false;
+  if (!existsSync(path))
+    return false;
+  try {
+    const cfg = JSON.parse(readFileSync(path, "utf8"));
+    return Boolean(cfg.token);
+  } catch {
+    return false;
+  }
+}
+function loadConfig() {
+  const target = currentTarget();
+  const envToken = target.explicitProfile ? undefined : process.env.ARBOR_TOKEN || undefined;
+  const envUrl = process.env.ARBOR_API_URL || undefined;
+  if (target.named)
+    rejectSymlink(target.path, `Arbor profile ${target.profile}`);
+  if (existsSync(target.path)) {
+    try {
+      const cfg = JSON.parse(readFileSync(target.path, "utf8"));
+      return { apiUrl: envUrl ?? (cfg.apiUrl || PROD_API_URL), token: envToken ?? cfg.token };
+    } catch (err) {
+      if (err instanceof Error && /symbolic link/i.test(err.message))
+        throw err;
+    }
+  }
+  return { apiUrl: envUrl ?? PROD_API_URL, token: envToken };
+}
+function writeConfigGuarded(opts) {
+  mkdirSync(dirname(opts.configPath), { recursive: true });
+  const release = acquireConfigLock(opts.configPath);
+  try {
+    if (!opts.allowDefaultTokenOverwrite && defaultConfigOverwriteBlocked({ isolated: opts.isolated, path: opts.defaultPath })) {
+      throw new Error(DEFAULT_TOKEN_OVERWRITE_REFUSAL);
+    }
+    writeFileSync(opts.configPath, `${JSON.stringify(opts.cfg, null, 2)}
+`, { mode: 384 });
+    chmodSync(opts.configPath, 384);
+  } finally {
+    release();
+  }
+}
+function saveConfig(cfg, opts) {
+  const target = currentTarget();
+  if (target.named) {
+    ensureProfilesDir();
+    rejectSymlink(target.path, `Arbor profile ${target.profile}`);
+  }
+  writeConfigGuarded({
+    cfg,
+    configPath: target.path,
+    defaultPath: target.defaultPath,
+    isolated: target.isolated,
+    allowDefaultTokenOverwrite: opts?.allowDefaultTokenOverwrite
+  });
+}
+function clearToken() {
+  const cfg = loadConfig();
+  saveConfig({ apiUrl: cfg.apiUrl }, { allowDefaultTokenOverwrite: true });
+}
+
+// src/source.ts
+var SNIFF = [
+  ["CLAUDECODE", "Claude Code"],
+  ["CLAUDE_CODE_ENTRYPOINT", "Claude Code"],
+  ["OPENCLAW_HOME", "openclaw"],
+  ["CODEX_SANDBOX", "Codex"],
+  ["CURSOR_TRACE_ID", "Cursor"]
+];
+function detectSource(env = process.env) {
+  const explicit = env.ARBOR_SOURCE?.trim();
+  if (explicit)
+    return explicit;
+  for (const [envVar, tool] of SNIFF) {
+    if (env[envVar]?.trim())
+      return tool;
   }
-  const externalReadDefaults = action.inputSchema.limit === PAGINATION_INPUT.limit ? { ...action.externalReadDefaults, limit: EXTERNAL_DEFAULT_PAGE_SIZE } : action.externalReadDefaults;
-  for (const operation of forwardedOperations(action.run)) {
-    recordExternalReadDefaults(operation, externalReadDefaults);
+  return;
+}
+
+// src/client.ts
+class NotLoggedInError extends Error {
+  code = "UNAUTHORIZED";
+  details = { reason: "authorization.denied" };
+  constructor() {
+    super("Not logged in. Run: arbor login");
+    this.name = "NotLoggedInError";
   }
-  if (!action.surfaces.some((surface) => surface === "mcp" || surface === "computer-mcp")) {
-    return externalReadDefaults ? { ...action, externalReadDefaults } : action;
+}
+function authHeader() {
+  const cfg = loadConfig();
+  if (!cfg.token)
+    throw new NotLoggedInError;
+  return { authorization: `Bearer ${cfg.token}`, apiUrl: cfg.apiUrl };
+}
+var source = detectSource();
+async function callApi(name, input, signal) {
+  const { authorization, apiUrl } = authHeader();
+  const dot = name.indexOf(".");
+  const object = dot === -1 ? name : name.slice(0, dot);
+  const verb = dot === -1 ? "" : name.slice(dot + 1);
+  let res;
+  try {
+    res = await fetch(`${apiUrl}/api`, {
+      method: "POST",
+      signal,
+      headers: {
+        "content-type": "application/json",
+        authorization,
+        ...source ? { "x-arbor-source": source } : {}
+      },
+      body: JSON.stringify({ object, verb, input })
+    });
+  } catch (cause) {
+    throw new ApiError(`could not reach ${apiUrl} (${cause instanceof Error ? cause.message : String(cause)})`, 0);
   }
-  const annotations = mcpAnnotationsFor(action.name);
-  return {
-    ...action,
-    externalReadDefaults,
-    get outputSchema() {
-      const schema = outputSchemaFor(action.name);
-      if (!schema)
-        throw new Error(`${action.name}: MCP action is missing an output schema`);
-      return schema;
-    },
-    annotations
-  };
-});
-// ../actions/src/retention-entry.ts
-var historyPolicySchema = _enum(["full", "checkpoint"]).optional().describe("text Artifacts: future history retention policy; full retains every source snapshot, checkpoint keeps metadata for every revision and source only when explicitly retained");
-var retainSourceSchema = boolean2().optional().describe("edit: in checkpoint mode, retain this newly minted content revision's source");
-var checkpointSchema = boolean2().optional().describe("edit: retain the exact current version source without incrementing content version");
-var ARTIFACT_GET_PUBLIC_DESCRIPTION = "Read one Artifact as a compact card without loading its body; editable text supports its outline plus bounded startLine+limit or heading windows and explicit all=true; File Artifacts remain files and report whether bounded UTF-8 text projection is available. For text-like files use startLine+limit and nextLine; all=true and heading stay unavailable for files, binary/unsupported files use the Artifact URL/download/media surface, and editable historical reads retain exact artifactVersionId.";
-function artifactEditInput(input) {
-  const patches = Array.isArray(input.patches);
-  const hasSource = typeof input.source === "string";
-  const checkpoint = input.checkpoint === true;
-  const historyPolicy = input.historyPolicy === "full" || input.historyPolicy === "checkpoint";
-  if (checkpoint && (patches || hasSource || historyPolicy)) {
-    throw new Error("artifact edit checkpoint cannot be combined with source, patches, or historyPolicy");
+  const body = await res.json().catch(() => ({}));
+  if (!res.ok || !body.success)
+    throw new ApiError(body.error ?? `request failed (${res.status})`, res.status, parseErrorDetails(body.errorDetails));
+  return body.data;
+}
+var httpExecutor = { call: callApi };
+async function binaryGet(path, authenticated = true) {
+  const { authorization, apiUrl } = authHeader();
+  let response;
+  const url = new URL(path, apiUrl);
+  if (url.origin !== new URL(apiUrl).origin || !authenticated && !url.pathname.startsWith("/api/attachment-read/"))
+    throw new Error("Invalid download target");
+  try {
+    response = await fetch(url.toString(), {
+      headers: authenticated ? { authorization } : {},
+      redirect: "error"
+    });
+  } catch {
+    throw new ApiError("Binary download request failed", 0);
   }
-  if (historyPolicy && (patches || hasSource)) {
-    throw new Error("artifact historyPolicy change cannot be combined with a content edit");
+  if (!response.ok)
+    throw new ApiError(`Download failed (${response.status})`, response.status);
+  return response;
+}
+
+// src/discovery.ts
+var HELP_DISCOVERY_TIMEOUT_MS = 1000;
+var baseActions = ACTIONS3.filter((action) => action.surfaces.some((surface) => surface === "cli" || surface === "computer-cli"));
+var BASE_HELP_NOTE = "Base help only: authenticated catalog unavailable.";
+async function discoverHelpActions(timeoutMs = HELP_DISCOVERY_TIMEOUT_MS) {
+  const base = () => ({ actions: baseActions, note: BASE_HELP_NOTE });
+  if (!loadConfig().token)
+    return base();
+  if (typeof AbortController !== "function" || typeof setTimeout !== "function")
+    return base();
+  const controller = new AbortController;
+  let timer;
+  try {
+    const value = await Promise.race([
+      callApi("tooling.catalog", {}, controller.signal),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          reject(new Error("catalog deadline"));
+        }, timeoutMs);
+      })
+    ]);
+    const catalog = value;
+    if (catalog?.serverVersion !== ARBOR_VERSION || !Array.isArray(catalog.actions))
+      return base();
+    const selectors = new Map;
+    for (const item of catalog.actions) {
+      if (!item || typeof item.name !== "string" || !Array.isArray(item.variants) || !item.variants.every((tag) => typeof tag === "string"))
+        return base();
+      selectors.set(item.name, item.variants);
+    }
+    return {
+      actions: baseActions.map((action) => projectActionVariants(action, selectors.get(action.name) ?? []))
+    };
+  } catch {
+    return base();
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+    controller.abort();
+  }
+}
+
+// src/attachment-download.ts
+async function downloadAttachment(id, output, signed = false, force = false) {
+  const { createHash, randomUUID } = await import("node:crypto");
+  const { open, rename, unlink, link } = await import("node:fs/promises");
+  const { basename, resolve } = await import("node:path");
+  if (!/^(att_|art_)[a-zA-Z0-9_-]+$/.test(id))
+    throw new Error("Expected an Attachment or Artifact id");
+  const artifact = id.startsWith("art_");
+  const metadata = artifact && !signed ? null : await httpExecutor.call("attachment.get", {
+    attachmentId: id,
+    ...signed ? { signed: true } : {}
+  });
+  if (signed && !metadata?.signedRead)
+    throw new Error("Signed download is unavailable");
+  const response = await binaryGet(signed ? metadata.signedRead.url : `/api/download/${artifact ? "artifact/" : ""}${encodeURIComponent(id)}`, !signed);
+  const size = metadata?.size ?? Number(response.headers.get("x-arbor-size") ?? response.headers.get("content-length") ?? "NaN");
+  if (!Number.isSafeInteger(size) || size < 0 || !response.body)
+    throw new Error("Download has no valid size or body");
+  const suggested = basename(metadata?.filename ?? dispositionFilename(response.headers.get("content-disposition")) ?? id);
+  const destination = resolve(output ?? (suggested.startsWith(".") ? id : suggested));
+  const temporary = `${destination}.${randomUUID()}.part`;
+  const file = await open(temporary, "wx", 384);
+  const reader = response.body.getReader();
+  const hash = createHash("sha256");
+  let received = 0;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      received += value.byteLength;
+      if (received > size)
+        throw new Error("Download size mismatch");
+      hash.update(value);
+      let offset = 0;
+      while (offset < value.length) {
+        const written = await file.write(value, offset, value.length - offset);
+        offset += written.bytesWritten;
+      }
+    }
+    const sha256 = hash.digest("hex");
+    const expectedHash = metadata?.sha256 ?? response.headers.get("x-arbor-sha256");
+    if (received !== size || expectedHash && expectedHash !== sha256)
+      throw new Error("Download integrity mismatch");
+    await file.close();
+    if (force)
+      await rename(temporary, destination);
+    else {
+      try {
+        await link(temporary, destination);
+      } catch (error) {
+        if (error.code === "EEXIST")
+          throw new Error("Destination exists; use --force to replace it");
+        if (["EPERM", "ENOTSUP"].includes(error.code ?? ""))
+          throw new Error("Filesystem does not support safe no-replace downloads; choose another destination or use --force to allow replacement");
+        throw error;
+      }
+      await unlink(temporary);
+    }
+    return { path: destination, size: received, sha256 };
+  } catch (error) {
+    await reader.cancel().catch(() => {});
+    await file.close().catch(() => {});
+    await unlink(temporary).catch(() => {});
+    throw error;
+  } finally {
+    reader.releaseLock();
   }
-  if (checkpoint)
-    return { ...input, verb: "checkpoint" };
-  if (historyPolicy)
-    return { ...input, verb: "set_history_policy" };
-  return { ...input, verb: patches ? "patch" : "replace" };
-}
-function runArtifact(ex, input) {
-  const { verb, ...rest } = input;
-  if (verb === "create")
-    return ex.call("artifact.create", rest);
-  if (verb === "edit")
-    return ex.call("artifact.edit", artifactEditInput(rest));
-  if (verb === "set_live_preview")
-    return ex.call("artifact.setLivePreview", rest);
-  if (verb === "set_snapshot")
-    return ex.call("artifact.setSnapshot", rest);
-  if (verb === "promote_attachment")
-    return ex.call("attachment.promote", rest);
-  return Promise.reject(new Error(`unknown artifact verb "${verb ?? ""}"`));
-}
-function overrideAction(action, overrides) {
-  return Object.assign(Object.defineProperties({}, Object.getOwnPropertyDescriptors(action)), overrides);
 }
-function retentionAction(action) {
-  if (action.name === "create_artifact") {
-    return overrideAction(action, {
-      description: "Create a durable Artifact; text kinds may choose historyPolicy=full (default) or checkpoint. Checkpoint mode still keeps metadata/provenance for every revision while source snapshots are retained only when explicitly checkpointed.",
-      inputSchema: { ...action.inputSchema, historyPolicy: historyPolicySchema }
-    });
-  }
-  if (action.name === "edit_artifact") {
-    return overrideAction(action, {
-      description: "Edit a text Artifact from the baseVersion you read, or change its future historyPolicy/checkpoint the exact current source without minting a content version. Content edits return the exact artifactVersionId; byte-identical results are idempotent no-ops that reuse the current version identity, while stale divergent edits remain structured conflicts.",
-      inputSchema: {
-        ...action.inputSchema,
-        historyPolicy: historyPolicySchema,
-        checkpoint: checkpointSchema,
-        retainSource: retainSourceSchema
-      },
-      run: (ex, input) => ex.call("artifact.edit", artifactEditInput(input))
-    });
-  }
-  if (action.name === "get_artifact" || action.name === "artifact_get") {
-    return overrideAction(action, { description: ARTIFACT_GET_PUBLIC_DESCRIPTION });
-  }
-  if (action.name === "artifact") {
-    return overrideAction(action, {
-      description: "Create/edit a durable Artifact with full|checkpoint retention or manage Live Preview, snapshots, and attachments. Git edits derive retry keys (omitted edits derive one); keyless creates mint per-invocation keys; stable idempotencyKey supports caller retries; never blindly repeat ambiguous creates. promote_attachment creates a file Artifact from a Contribution; exported reports use the Attachment downloadUrl; policy changes do not mint content versions.",
-      inputSchema: {
-        ...action.inputSchema,
-        historyPolicy: historyPolicySchema,
-        checkpoint: checkpointSchema,
-        retainSource: retainSourceSchema
-      },
-      run: runArtifact
-    });
+function dispositionFilename(value) {
+  if (!value)
+    return;
+  const encoded = /filename\*=UTF-8''([^;]+)/i.exec(value)?.[1];
+  if (encoded) {
+    try {
+      return decodeURIComponent(encoded);
+    } catch {}
   }
-  return action;
+  return /filename="([^"]*)"/i.exec(value)?.[1] ?? /filename=([^;\s]+)/i.exec(value)?.[1];
 }
-var ACTIONS2 = ACTIONS.map(retentionAction);
-
-// ../actions/src/recovery-entry.ts
-var grantOutput = object({
-  grant: object({
-    grantId: string2(),
-    requestId: string2(),
-    threadId: string2(),
-    runId: string2(),
-    computerId: string2(),
-    granteeProfileId: string2(),
-    grantedByProfileId: string2(),
-    expiresAt: string2(),
-    createdAt: string2(),
-    revokedAt: string2().nullable(),
-    revokedByProfileId: string2().nullable()
-  }),
-  replayed: boolean2()
-});
-var diagnosticOutput = object({
-  grant: object({
-    grantId: string2(),
-    requestId: string2(),
-    expiresAt: string2()
-  }),
-  diagnostic: object({
-    runId: string2(),
-    computerId: string2(),
-    computerGeneration: number2().int().positive(),
-    status: _enum(["active", "finished", "failed", "cancelled"]),
-    outcome: _enum(["finished", "failed", "cancelled"]).nullable(),
-    reasonCode: string2().nullable(),
-    runtimeState: _enum(["shared", "live", "suspended", "releasing", "released"]),
-    snapshotLineage: object({
-      baseSnapshotId: string2().nullable(),
-      currentSnapshotId: string2().nullable()
-    }),
-    providerState: object({
-      generation: number2().int().min(0).nullable(),
-      lastPhase: string2().nullable(),
-      lastReasonCode: string2().nullable()
-    }),
-    operations: array(object({
-      operationId: string2(),
-      execution: _enum(["foreground", "background"]),
-      state: _enum([
-        "starting",
-        "running",
-        "completed",
-        "failed",
-        "cancelled",
-        "not-routed",
-        "provider-lost",
-        "unknown"
-      ]),
-      mutationRetrySafety: _enum(["not-needed", "safe", "unsafe", "unknown"]),
-      reasonCode: string2()
-    }))
-  }),
-  auditEventId: string2()
-});
-var additive2 = {
-  readOnlyHint: false,
-  destructiveHint: false,
-  idempotentHint: true,
-  openWorldHint: false
-};
-var auditedRead = {
-  readOnlyHint: false,
-  destructiveHint: false,
-  idempotentHint: false,
-  openWorldHint: false
-};
-var RECOVERY_ACTIONS = [
-  {
-    name: "computer_recovery_grant",
-    title: "Grant delegated Computer recovery",
-    description: "Issue one short-lived diagnostic grant for a profile explicitly targeted by the same open Request and exact Run. This grants no execution, file, environment, Secret, Git, checkpoint, or lifecycle capability.",
-    inputSchema: {
-      requestId: string2().describe("the targeted open Request authorizing this recovery scope, req_…"),
-      runId: string2().describe("the exact Run whose diagnostic state may be inspected, run_…"),
-      granteeProfileId: string2().describe("the exact targeted profile receiving diagnostic visibility"),
-      expiresAt: string2().describe("future ISO timestamp, at most 24 hours and never after Request expiry"),
-      idempotencyKey: string2().min(1).max(200).describe("stable key for this one logical grant")
-    },
-    outputSchema: grantOutput,
-    annotations: additive2,
-    surfaces: ["computer-cli"],
-    toolset: "loop",
-    run: (ex, input) => ex.call("computer_recovery.grant", input)
+// package.json
+var package_default = {
+  name: "@lambdacurry/arbor",
+  version: "0.24.16",
+  description: "The Arbor CLI — a shared workspace for people and agents. The human + headless-agent write path over Arbor's guarded operation surface.",
+  keywords: [
+    "agents",
+    "arbor",
+    "cli",
+    "collaboration",
+    "mcp"
+  ],
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/lambda-curry/arbor.git",
+    directory: "packages/cli"
   },
-  {
-    name: "computer_recovery_revoke",
-    title: "Revoke delegated Computer recovery",
-    description: "Revoke one previously issued delegated diagnostic grant without touching the Computer or provider. Repeating the same revoke is an idempotent no-op.",
-    inputSchema: {
-      grantId: string2().describe("the delegated recovery grant, crg_…")
-    },
-    outputSchema: grantOutput,
-    annotations: additive2,
-    surfaces: ["computer-cli"],
-    toolset: "loop",
-    run: (ex, input) => ex.call("computer_recovery.revoke", input)
+  bin: {
+    arbor: "./dist/arbor.js"
   },
-  {
-    name: "computer_recovery_inspect",
-    title: "Inspect delegated Computer recovery state",
-    description: "Read only the sanitized diagnostic projection authorized by one live delegated grant; every successful read records an attributed Arbor audit Event. It never calls the provider or exposes repository paths/heads, command output, environment, Secrets, sessions, or mutation controls.",
-    inputSchema: {
-      grantId: string2().describe("the delegated recovery grant, crg_…")
-    },
-    outputSchema: diagnosticOutput,
-    annotations: auditedRead,
-    surfaces: ["computer-mcp", "computer-cli"],
-    toolset: "loop",
-    run: (ex, input) => ex.call("computer_recovery.inspect", input)
+  files: [
+    "dist",
+    "README.md"
+  ],
+  type: "module",
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    arbor: "vpx src/bin.ts",
+    build: "bun build ./src/bin.ts --target=node --outfile=dist/arbor.js",
+    test: "vp test run --passWithNoTests",
+    typecheck: "tsc -b",
+    prepublishOnly: "bun run build"
+  },
+  devDependencies: {
+    "@arbor/actions": "workspace:*",
+    "@arbor/core": "workspace:*",
+    "@types/node": "^26.2.0",
+    "just-bash": "3.4.2",
+    typescript: "^5.8.0",
+    "vite-plus": "catalog:",
+    zod: "^4.4.3"
+  },
+  engines: {
+    node: ">=18"
   }
-];
-var ACTIONS3 = [...ACTIONS2, ...RECOVERY_ACTIONS];
+};
 
 // src/attachment-upload.ts
 import { basename, resolve } from "node:path";
@@ -17121,11 +17291,11 @@ var KNOWN_MISREACHES = [
     why: "this command is noun-verb"
   }
 ];
-function familyHelp(positionals) {
+function familyHelp(positionals, actions = CLI_ACTIONS) {
   if (positionals.length !== 1)
     return;
   const word = positionals[0].toLowerCase().replace(/_/g, " ");
-  const members = CLI_ACTIONS.filter((a) => commandWords(a).split(" ").includes(word)).sort((a, b) => commandWords(a).localeCompare(commandWords(b)));
+  const members = actions.filter((a) => commandWords(a).split(" ").includes(word)).sort((a, b) => commandWords(a).localeCompare(commandWords(b)));
   if (members.length === 0)
     return;
   return `\`${word}\` commands — run \`arbor <command> --help\` for one command's exact flags.
@@ -17189,11 +17359,11 @@ function helpLine(action) {
 }
 var COMMAND_HELP = CLI_ACTIONS.map(helpLine).join(`
 `);
-function commandHelp(positionals) {
+function commandHelp(positionals, actions = CLI_ACTIONS) {
   const match = matchCommand(positionals);
   if (!match)
     return;
-  const { action } = match;
+  const action = actions.find((action) => action.name === match.action.name) ?? match.action;
   const specs = flagsForSchema(action.inputSchema);
   const explicitPositionals = positionalSpecs(action);
   const primary = explicitPositionals.length === 0 ? primaryPositionalField(action.inputSchema) : undefined;
@@ -17256,8 +17426,8 @@ ${[...lines, ...waitLines].join(`
 `)}${primaryNote}${explicitNote}${aliasNote}${notes}
 `;
 }
-function commandCatalog() {
-  return CLI_ACTIONS.map((action) => ({
+function commandCatalog(actions = CLI_ACTIONS) {
+  return actions.filter((action) => action.surfaces.some((surface) => surface === "cli" || surface === "computer-cli")).map((action) => ({
     command: commandWords(action),
     name: action.name,
     description: action.description,
@@ -17326,7 +17496,8 @@ async function runObjectVerb(positionals, flags, ctx) {
     const typed = positionals.join(" ") || "(none)";
     throw new UsageError(`unknown command: ${typed} — ${suggestCommand(positionals)}`);
   }
-  const { action, words } = match;
+  const { words } = match;
+  const action = { ...match.action, inputSchema: canonicalInputShape(match.action) };
   applyPositionals(action, positionals.slice(words), flags);
   const accepted = acceptedFlags(action.inputSchema);
   const unknown = Object.keys(flags).filter((f) => !accepted.has(f) && !RESERVED_FLAGS.has(f));
@@ -17645,8 +17816,22 @@ Tokens: a human PAT or an agent key works in either ARBOR_TOKEN (env, headless)
 
 ${COMMAND_HELP}
 `;
-function renderHelp(ctx) {
-  emitDual(commandCatalog(), HELP, "help", ctx);
+function renderHelp(ctx, actions) {
+  emitDual(commandCatalog(actions), HELP, "help", ctx);
+}
+async function renderRequestedHelp(ctx, positionals) {
+  const matched = matchCommand(positionals)?.action;
+  const family = positionals.length === 1 ? positionals[0].replace(/_/g, " ") : null;
+  const needsDiscovery = ctx.json || Boolean(matched?.privilegedVariants?.length) || Boolean(family && ACTIONS3.some((action) => action.privilegedVariants?.length && action.name.replace(/_/g, " ").split(" ").includes(family)));
+  const discovery = needsDiscovery ? await discoverHelpActions() : undefined;
+  if (discovery?.note)
+    writeStderr(`${discovery.note}
+`);
+  const focused = positionals.length ? commandHelp(positionals, discovery?.actions) ?? familyHelp(positionals, discovery?.actions) : undefined;
+  if (focused)
+    emitDual({ help: focused }, focused, "help", ctx);
+  else
+    renderHelp(ctx, discovery?.actions);
 }
 async function renderHealth(ctx) {
   const cfg = loadConfig();
@@ -17692,7 +17877,7 @@ async function main() {
     if (cmd !== "profile") {
       configureConfigTarget({
         profileFlag,
-        allowMissingProfile: cmd === "login" || cmd === "auth" || cmd === "connect"
+        allowMissingProfile: cmd === "login" || cmd === "auth" || cmd === "connect" || cmd === "help" || cmd === undefined || truthyFlag(flags.help)
       });
     } else if (profileFlag !== undefined) {
       throw new UsageError("--profile selects a credential for a command; profile management names its target positionally");
@@ -17709,11 +17894,7 @@ Stream authenticated bytes to a file; verify size and the recorded SHA-256 when
       return;
     }
     if (truthyFlag(flags.help)) {
-      const focused = positionals.length > 0 ? commandHelp(positionals) ?? familyHelp(positionals) : undefined;
-      if (focused)
-        emitDual({ help: focused }, focused, "help", ctx);
-      else
-        renderHelp(ctx);
+      await renderRequestedHelp(ctx, positionals);
       return;
     }
     if (cmd === "attachment" && positionals[1] === "download") {
@@ -17726,8 +17907,10 @@ Stream authenticated bytes to a file; verify size and the recorded SHA-256 when
     }
     switch (cmd) {
       case undefined:
+        await renderRequestedHelp(ctx, []);
+        return;
       case "help":
-        renderHelp(ctx);
+        await renderRequestedHelp(ctx, positionals.slice(1));
         return;
       case "login": {
         await login({ url: stringFlag(flags.url, "url") });