@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/{chunk-673JJUWJ.js → chunk-BMEMKKIT.js}

@@ -1,7 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   DEFAULT_SETTINGS_YAML
-} from "./chunk-NMOX6HFD.js";
+} from "./chunk-ZDOOVTXZ.js";
 import {
   clioCacheDir,
   clioConfigDir,
@@ -143,4 +143,4 @@ function enforceHomePrefixGuard() {
 export {
   initializeClioHome
 };
-//# sourceMappingURL=chunk-673JJUWJ.js.map
+//# sourceMappingURL=chunk-BMEMKKIT.js.map

package/dist/chunk-CBCAPZAA.js

@@ -0,0 +1,229 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  SettingsValidationError,
+  applySettingsDelta,
+  settingsPath,
+  updateSavedSettingsDocument,
+  validateSettings
+} from "./chunk-A3CYT5EX.js";
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/settings-layers.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var STRICT_USER_ISSUES = /* @__PURE__ */ Symbol("strict-user-issues");
+var CREDENTIAL_KEYS = /* @__PURE__ */ new Set(["auth", "apikey", "api_key", "token", "secret", "password"]);
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function deepEquals(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((entry, index) => deepEquals(entry, b[index]));
+  }
+  if (!isRecord(a) || !isRecord(b)) return false;
+  const keys = Object.keys(a);
+  if (keys.length !== Object.keys(b).length) return false;
+  return keys.every((key) => key in b && deepEquals(a[key], b[key]));
+}
+function readRawLayer(origin, path, issues) {
+  if (!existsSync(path)) return { origin, path, blob: void 0 };
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch (err) {
+    issues.push({
+      origin,
+      path: "(root)",
+      message: `unreadable: ${err instanceof Error ? err.message : String(err)}`,
+      kind: "unreadable"
+    });
+    return { origin, path, blob: void 0 };
+  }
+  let parsed;
+  try {
+    parsed = (0, import_yaml.parse)(text);
+  } catch (err) {
+    issues.push({
+      origin,
+      path: "(root)",
+      message: `invalid YAML: ${err instanceof Error ? err.message : String(err)}`,
+      kind: "syntax"
+    });
+    return { origin, path, blob: void 0 };
+  }
+  if (parsed === null || parsed === void 0) return { origin, path, blob: {} };
+  if (!isRecord(parsed)) {
+    issues.push({ origin, path: "(root)", message: "settings file must be a mapping at the root" });
+    return { origin, path, blob: void 0 };
+  }
+  return { origin, path, blob: parsed };
+}
+function stripCredentials(value, origin, path, issues) {
+  if (Array.isArray(value)) {
+    return value.map((item, index) => stripCredentials(item, origin, `${path}[${index}]`, issues));
+  }
+  if (!isRecord(value)) return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (CREDENTIAL_KEYS.has(key.toLowerCase())) {
+      issues.push({
+        origin,
+        path: path ? `${path}.${key}` : key,
+        message: "credentials are not allowed in project settings; key ignored"
+      });
+      continue;
+    }
+    out[key] = stripCredentials(child, origin, path ? `${path}.${key}` : key, issues);
+  }
+  return out;
+}
+function mergeLayersWithSources(layers) {
+  const merged = {};
+  const sources = {};
+  for (const layer of layers) {
+    if (layer.blob === void 0) continue;
+    mergeInto(merged, layer.blob, layer.origin, "", sources);
+  }
+  return { merged, sources };
+}
+function mergeInto(target, source, origin, prefix, sources) {
+  for (const [key, value] of Object.entries(source)) {
+    const path = prefix ? `${prefix}.${key}` : key;
+    if (isRecord(value)) {
+      const existing = target[key];
+      const nested = isRecord(existing) ? existing : {};
+      mergeInto(nested, value, origin, path, sources);
+      target[key] = nested;
+      sources[path] = origin;
+    } else {
+      target[key] = Array.isArray(value) ? [...value] : value;
+      sources[path] = origin;
+    }
+  }
+}
+function prepareProjectLayers(cwd, issues) {
+  const projectFile = join(cwd, ".clio-coder", "settings.yaml");
+  const localFile = join(cwd, ".clio-coder", "settings.local.yaml");
+  const projectRaw = readRawLayer("project", projectFile, issues);
+  const localRaw = readRawLayer("project.local", localFile, issues);
+  const project = {
+    ...projectRaw,
+    blob: projectRaw.blob === void 0 ? void 0 : stripCredentials(projectRaw.blob, "project", "", issues)
+  };
+  const local = {
+    ...localRaw,
+    blob: localRaw.blob === void 0 ? void 0 : stripCredentials(localRaw.blob, "project.local", "", issues)
+  };
+  return { projectFile, localFile, projectRaw, localRaw, project, local };
+}
+function validateLayerStack(user, prepared, issues) {
+  const { merged, sources } = mergeLayersWithSources([user, prepared.project, prepared.local]);
+  const validation = validateSettings(merged);
+  for (const issue of validation.issues) {
+    issues.push({ origin: settingsSourceFor(sources, issue.path), path: issue.path, message: issue.message });
+  }
+  return { settings: validation.settings, sources };
+}
+function readLayeredSettings(cwd, options = {}) {
+  const issues = [];
+  const userFile = options.userPath ?? settingsPath();
+  const user = readRawLayer("user", userFile, issues);
+  const prepared = prepareProjectLayers(cwd, issues);
+  const { settings, sources } = validateLayerStack(user, prepared, issues);
+  const strictUserIssues = user.blob === void 0 ? [] : validateSettings(user.blob).issues.map((issue) => ({
+    path: issue.path,
+    message: issue.message,
+    ...issue.kind ? { kind: issue.kind } : {}
+  }));
+  return {
+    settings,
+    sources,
+    issues,
+    layers: [
+      { origin: "built-in", path: "(defaults)", present: true },
+      { origin: "user", path: userFile, present: user.blob !== void 0 },
+      { origin: "project", path: prepared.projectFile, present: prepared.projectRaw.blob !== void 0 },
+      { origin: "project.local", path: prepared.localFile, present: prepared.localRaw.blob !== void 0 }
+    ],
+    [STRICT_USER_ISSUES]: strictUserIssues
+  };
+}
+function readStrictLayeredSettings(cwd, options = {}) {
+  const layered = readLayeredSettings(cwd, options);
+  const reportedUserIssues = layered.issues.filter((issue) => issue.origin === "user").map(({ path, message, kind }) => ({ path, message, ...kind ? { kind } : {} }));
+  const userIssues = [...reportedUserIssues, ...layered[STRICT_USER_ISSUES]].filter(
+    (issue, index, all) => all.findIndex(
+      (candidate) => candidate.path === issue.path && candidate.message === issue.message && candidate.kind === issue.kind
+    ) === index
+  );
+  if (userIssues.length > 0) throw new SettingsValidationError(userIssues);
+  return layered;
+}
+function updateLayeredSettings(cwd, mutate) {
+  let committed = null;
+  updateSavedSettingsDocument((saved) => {
+    const userValidation = validateSettings(saved);
+    if (userValidation.issues.length > 0) throw new SettingsValidationError(userValidation.issues);
+    const issues = [];
+    const prepared = prepareProjectLayers(cwd, issues);
+    const user = {
+      origin: "user",
+      path: settingsPath(),
+      blob: isRecord(saved) ? saved : {}
+    };
+    const before = validateLayerStack(user, prepared, issues).settings;
+    const candidate = structuredClone(before);
+    const next = mutate(candidate) ?? candidate;
+    const candidateValidation = validateSettings(JSON.parse(JSON.stringify(next)));
+    if (candidateValidation.issues.length > 0) throw new SettingsValidationError(candidateValidation.issues);
+    const nextSaved = applySettingsDelta(saved, before, candidateValidation.settings);
+    const finalIssues = [];
+    const final = validateLayerStack(
+      { origin: "user", path: settingsPath(), blob: isRecord(nextSaved) ? nextSaved : {} },
+      prepared,
+      finalIssues
+    ).settings;
+    if (!deepEquals(final, candidateValidation.settings)) {
+      throw new Error("a higher-precedence project setting prevents this settings update");
+    }
+    committed = final;
+    return nextSaved;
+  });
+  if (committed === null) throw new Error("layered settings update did not commit");
+  return committed;
+}
+function settingsSourceFor(sources, keyPath) {
+  let prefix = keyPath;
+  while (prefix.length > 0) {
+    const direct = sources[prefix];
+    if (direct) return direct;
+    const bracket = prefix.lastIndexOf("[");
+    if (bracket >= 0) {
+      const arrayKey = prefix.slice(0, bracket);
+      const hit = sources[arrayKey];
+      if (hit) return hit;
+    }
+    const dot = prefix.lastIndexOf(".");
+    if (dot < 0) break;
+    prefix = prefix.slice(0, dot);
+  }
+  return "built-in";
+}
+
+export {
+  readLayeredSettings,
+  readStrictLayeredSettings,
+  updateLayeredSettings,
+  settingsSourceFor
+};
+//# sourceMappingURL=chunk-CBCAPZAA.js.map

package/dist/chunk-CMZWFGD2.js

@@ -0,0 +1,352 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/worker/protocol.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+var WORKER_PROTOCOL_VERSION = 1;
+var CONTROL_FRAME_PREFIX = "@clio-control/1 ";
+var WORKER_CONTROL_FRAME_MAX_BYTES = 16 * 1024;
+var WORKER_BULK_FRAME_MAX_BYTES = 4 * 1024 * 1024;
+var WORKER_STDIN_FRAME_MAX_BYTES = 1024 * 1024;
+var WORKER_STDIN_QUEUE_MAX_BYTES = 4 * 1024 * 1024;
+var WORKER_EVENT_QUEUE_MAX_FRAMES = 4096;
+function knownResource(value) {
+  return { known: true, value };
+}
+var UNKNOWN_RESOURCE = { known: false };
+var WORKER_RESOURCE_LABEL_MAX = 32;
+var WORKER_RESIDENT_MODEL_MAX = 64;
+var AGENT_LEDGER_SCOPE_MAX_ENTRIES = 8;
+var AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS = 200;
+var AGENT_LEDGER_INTENT_MAX_CHARS = 200;
+var AGENT_LEDGER_CLAIM_MAX_CHARS = 400;
+var AGENT_LEDGER_EVIDENCE_MAX_CHARS = 400;
+var AGENT_LEDGER_PATH_MAX_CHARS = 400;
+var AGENT_LEDGER_ENTRY_ID = /^e[1-9][0-9]*$/;
+function isAgentLedgerEntryId(value) {
+  return typeof value === "string" && AGENT_LEDGER_ENTRY_ID.test(value);
+}
+function boundedString(value, max) {
+  return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+function parseAgentLedgerBody(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "ledger body is not an object" };
+  }
+  const record = value;
+  switch (record.kind) {
+    case "claim": {
+      const scope = record.scope;
+      if (!Array.isArray(scope) || scope.length === 0) {
+        return { ok: false, reason: "claim scope must be a non-empty array of path prefixes" };
+      }
+      if (scope.length > AGENT_LEDGER_SCOPE_MAX_ENTRIES) {
+        return { ok: false, reason: `claim scope exceeds ${AGENT_LEDGER_SCOPE_MAX_ENTRIES} entries` };
+      }
+      for (const entry of scope) {
+        if (!boundedString(entry, AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS)) {
+          return {
+            ok: false,
+            reason: `claim scope entries must be 1..${AGENT_LEDGER_SCOPE_ENTRY_MAX_CHARS} characters`
+          };
+        }
+      }
+      if (!boundedString(record.intent, AGENT_LEDGER_INTENT_MAX_CHARS)) {
+        return { ok: false, reason: `claim intent must be 1..${AGENT_LEDGER_INTENT_MAX_CHARS} characters` };
+      }
+      return { ok: true, body: { kind: "claim", scope: scope.map(String), intent: record.intent } };
+    }
+    case "finding": {
+      if (!boundedString(record.claim, AGENT_LEDGER_CLAIM_MAX_CHARS)) {
+        return { ok: false, reason: `finding claim must be 1..${AGENT_LEDGER_CLAIM_MAX_CHARS} characters` };
+      }
+      const body = {
+        kind: "finding",
+        claim: record.claim
+      };
+      if (record.path !== void 0) {
+        if (!boundedString(record.path, AGENT_LEDGER_PATH_MAX_CHARS)) {
+          return { ok: false, reason: `finding path must be 1..${AGENT_LEDGER_PATH_MAX_CHARS} characters` };
+        }
+        body.path = record.path;
+      }
+      if (record.line !== void 0) {
+        const line = record.line;
+        if (typeof line !== "number" || !Number.isSafeInteger(line) || line <= 0) {
+          return { ok: false, reason: "finding line must be a positive safe integer" };
+        }
+        body.line = line;
+      }
+      return { ok: true, body };
+    }
+    case "review": {
+      if (!isAgentLedgerEntryId(record.target)) {
+        return { ok: false, reason: "review target must be a ledger entry id such as e3" };
+      }
+      if (typeof record.passed !== "boolean") {
+        return { ok: false, reason: "review passed must be a boolean" };
+      }
+      if (!boundedString(record.evidence, AGENT_LEDGER_EVIDENCE_MAX_CHARS)) {
+        return { ok: false, reason: `review evidence must be 1..${AGENT_LEDGER_EVIDENCE_MAX_CHARS} characters` };
+      }
+      return {
+        ok: true,
+        body: { kind: "review", target: record.target, passed: record.passed, evidence: record.evidence }
+      };
+    }
+    default:
+      return { ok: false, reason: `unknown ledger entry kind ${String(record.kind)}` };
+  }
+}
+function parseAgentLedgerEntry(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  const sequence = record.sequence;
+  if (typeof sequence !== "number" || !Number.isSafeInteger(sequence) || sequence <= 0) return null;
+  if (!isAgentLedgerEntryId(record.id)) return null;
+  for (const key of ["at", "runId", "assignmentId", "agentId", "nodeId"]) {
+    if (typeof record[key] !== "string" || record[key].length === 0) return null;
+  }
+  const body = parseAgentLedgerBody(record.body);
+  if (!body.ok) return null;
+  const conflicts = record.conflictsWith;
+  if (conflicts !== void 0 && !(Array.isArray(conflicts) && conflicts.every(isAgentLedgerEntryId))) return null;
+  return {
+    id: record.id,
+    sequence,
+    at: record.at,
+    runId: record.runId,
+    assignmentId: record.assignmentId,
+    agentId: record.agentId,
+    nodeId: record.nodeId,
+    body: body.body,
+    ...conflicts === void 0 ? {} : { conflictsWith: [...conflicts] }
+  };
+}
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+var HEX_64 = /^[0-9a-f]{64}$/;
+function endpointIdentityHash(url) {
+  if (url === void 0 || url.trim().length === 0) return sha256Hex("clio.endpoint:none");
+  const raw = url.trim();
+  let canonical;
+  try {
+    const parsed = new URL(raw);
+    const path = parsed.pathname.replace(/\/+$/u, "");
+    canonical = `${parsed.protocol}//${parsed.hostname}:${parsed.port}${path}`;
+  } catch {
+    canonical = raw.replace(/\/+$/u, "");
+  }
+  return sha256Hex(`clio.endpoint:${canonical}`);
+}
+function workerSpecDigest(spec) {
+  return sha256Hex(`clio.workerSpec:${canonicalJson(spec)}`);
+}
+function toolSignatureOf(names) {
+  return sha256Hex(`clio.tools:${[...names].sort().join(",")}`);
+}
+function canonicalJson(value) {
+  if (value === null) return "null";
+  if (typeof value === "number") return Number.isFinite(value) ? JSON.stringify(value) : "null";
+  if (typeof value === "string" || typeof value === "boolean") return JSON.stringify(value);
+  if (Array.isArray(value))
+    return `[${value.map((entry) => entry === void 0 ? "null" : canonicalJson(entry)).join(",")}]`;
+  if (typeof value === "object") {
+    const record = value;
+    const parts = [];
+    for (const key of Object.keys(record).sort()) {
+      const child = record[key];
+      if (child === void 0) continue;
+      parts.push(`${JSON.stringify(key)}:${canonicalJson(child)}`);
+    }
+    return `{${parts.join(",")}}`;
+  }
+  return "null";
+}
+function withinFrameBudget(line, maxBytes) {
+  return Buffer.byteLength(line, "utf8") <= maxBytes;
+}
+function parseJsonObject(line, maxBytes, lane) {
+  if (!withinFrameBudget(line, maxBytes)) {
+    return { ok: false, reason: `${lane} frame exceeds ${maxBytes} bytes` };
+  }
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return { ok: false, reason: `${lane} frame is not JSON` };
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: `${lane} frame is not a JSON object` };
+  }
+  return { ok: true, value };
+}
+function parseBulkFrame(line) {
+  return parseJsonObject(line, WORKER_BULK_FRAME_MAX_BYTES, "bulk");
+}
+function isControlLine(line) {
+  return line.startsWith(CONTROL_FRAME_PREFIX);
+}
+function encodeControlFrame(frame) {
+  return `${CONTROL_FRAME_PREFIX}${JSON.stringify(frame)}
+`;
+}
+function readFiniteNumber(record, key) {
+  const value = record[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readResourceValue(value, validate) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  if (record.known === false) return { known: false };
+  if (record.known !== true || !validate(record.value)) return null;
+  return { known: true, value: record.value };
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isBoundedStringArray(value, max) {
+  return Array.isArray(value) && value.length <= max && value.every((entry) => typeof entry === "string");
+}
+function parseResourceFacts(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  if (!isBoundedStringArray(record.labels, WORKER_RESOURCE_LABEL_MAX)) return null;
+  const numeric = ["cpuCount", "totalMemoryBytes", "freeMemoryBytes", "gpuCount", "vramBytes"];
+  const parsed = { labels: [...record.labels] };
+  for (const key of numeric) {
+    const fact = readResourceValue(record[key], isFiniteNumber);
+    if (fact === null) return null;
+    parsed[key] = fact;
+  }
+  const residentModels = readResourceValue(
+    record.residentModels,
+    (raw) => isBoundedStringArray(raw, WORKER_RESIDENT_MODEL_MAX)
+  );
+  if (residentModels === null) return null;
+  parsed.residentModels = residentModels;
+  return parsed;
+}
+function parseAttestation(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { ok: false, reason: "announce attestation is not an object" };
+  }
+  const record = value;
+  if (record.protocolVersion !== WORKER_PROTOCOL_VERSION) {
+    return { ok: false, reason: `announce protocol version ${String(record.protocolVersion)} is unsupported` };
+  }
+  const specVersion = readFiniteNumber(record, "specVersion");
+  if (specVersion === null) return { ok: false, reason: "announce specVersion must be a finite number" };
+  const pid = readFiniteNumber(record, "pid");
+  if (pid === null) return { ok: false, reason: "announce pid must be a finite number" };
+  const rawPgid = record.processGroupId;
+  if (rawPgid !== null && !(typeof rawPgid === "number" && Number.isFinite(rawPgid))) {
+    return { ok: false, reason: "announce processGroupId must be a finite number or null" };
+  }
+  for (const key of ["host", "runtimeId", "targetId", "wireModelId"]) {
+    if (typeof record[key] !== "string" || record[key].length === 0) {
+      return { ok: false, reason: `announce ${key} must be a non-empty string` };
+    }
+  }
+  for (const key of ["settingsFingerprint", "specDigest", "endpointIdentityHash", "toolSignature"]) {
+    if (typeof record[key] !== "string" || !HEX_64.test(record[key])) {
+      return { ok: false, reason: `announce ${key} must be a sha256 hex digest` };
+    }
+  }
+  const resources = parseResourceFacts(record.resources);
+  if (resources === null) return { ok: false, reason: "announce resources are missing or malformed" };
+  return {
+    ok: true,
+    value: {
+      protocolVersion: WORKER_PROTOCOL_VERSION,
+      specVersion,
+      pid,
+      processGroupId: typeof rawPgid === "number" ? rawPgid : null,
+      host: record.host,
+      settingsFingerprint: record.settingsFingerprint,
+      specDigest: record.specDigest,
+      runtimeId: record.runtimeId,
+      targetId: record.targetId,
+      endpointIdentityHash: record.endpointIdentityHash,
+      wireModelId: record.wireModelId,
+      toolSignature: record.toolSignature,
+      resources
+    }
+  };
+}
+function parseControlFrame(line) {
+  if (!isControlLine(line)) return { ok: false, reason: "control frame is missing its lane marker" };
+  const body = line.slice(CONTROL_FRAME_PREFIX.length);
+  const parsed = parseJsonObject(body, WORKER_CONTROL_FRAME_MAX_BYTES, "control");
+  if (!parsed.ok) return parsed;
+  const record = parsed.value;
+  switch (record.kind) {
+    case "announce": {
+      const attestation = parseAttestation(record.attestation);
+      if (!attestation.ok) return attestation;
+      return { ok: true, value: { kind: "announce", attestation: attestation.value } };
+    }
+    case "heartbeat":
+      return { ok: true, value: { kind: "heartbeat" } };
+    case "cancel_ack": {
+      const at = readFiniteNumber(record, "at");
+      if (at === null) return { ok: false, reason: "cancel_ack frame requires a finite at" };
+      return { ok: true, value: { kind: "cancel_ack", at } };
+    }
+    case "ledger_post": {
+      const body2 = parseAgentLedgerBody(record.body);
+      if (!body2.ok) return { ok: false, reason: `ledger_post frame rejected: ${body2.reason}` };
+      return { ok: true, value: { kind: "ledger_post", body: body2.body } };
+    }
+    default:
+      return { ok: false, reason: `unknown control frame kind ${String(record.kind)}` };
+  }
+}
+var RECEIPT_BEARING_BULK_TYPES = /* @__PURE__ */ new Set([
+  "message_end",
+  "clio_run_outcome",
+  "clio_permission_escalated",
+  "clio_permission_resolved",
+  "clio_steer_received",
+  "clio_tool_activity",
+  "clio_skill_activation",
+  "clio_safety_decision",
+  "clio_verification",
+  "clio_usage",
+  "tool_execution_end",
+  "spawn_error"
+]);
+function isReceiptBearingFrame(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return true;
+  const type = value.type;
+  if (typeof type !== "string") return true;
+  return RECEIPT_BEARING_BULK_TYPES.has(type);
+}
+
+export {
+  WORKER_PROTOCOL_VERSION,
+  WORKER_BULK_FRAME_MAX_BYTES,
+  WORKER_STDIN_FRAME_MAX_BYTES,
+  WORKER_STDIN_QUEUE_MAX_BYTES,
+  WORKER_EVENT_QUEUE_MAX_FRAMES,
+  knownResource,
+  UNKNOWN_RESOURCE,
+  WORKER_RESOURCE_LABEL_MAX,
+  parseAgentLedgerBody,
+  parseAgentLedgerEntry,
+  endpointIdentityHash,
+  workerSpecDigest,
+  toolSignatureOf,
+  canonicalJson,
+  withinFrameBudget,
+  parseBulkFrame,
+  isControlLine,
+  encodeControlFrame,
+  parseControlFrame,
+  isReceiptBearingFrame
+};
+//# sourceMappingURL=chunk-CMZWFGD2.js.map