@iowarp/clio-coder 0.3.7 → 0.3.9

package/dist/{chunk-FCSXB6T2.js → chunk-UOSL25KY.js}

@@ -210,6 +210,7 @@ registerEngineBuiltins();
 
 // src/engine/ai.ts
 var stream = engineStream;
+var streamSimple = engineStreamSimple;
 async function completeEngineText(input) {
   const response = await completeEngineSimple(
     input.model,
@@ -231,7 +232,17 @@ async function completeEngineText(input) {
   return {
     text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
     inputTokens: response.usage.input,
-    outputTokens: response.usage.output
+    outputTokens: response.usage.output,
+    usage: {
+      input: response.usage.input,
+      output: response.usage.output,
+      cacheRead: response.usage.cacheRead,
+      cacheWrite: response.usage.cacheWrite,
+      reasoning: response.usage.reasoning ?? 0,
+      totalTokens: response.usage.totalTokens,
+      costUsd: response.usage.cost.total
+    },
+    backend: response.backendTimings ?? null
   };
 }
 var registered = false;
@@ -325,6 +336,7 @@ export {
   activateExternalPluginApiBridge,
   StringEnum,
   stream,
+  streamSimple,
   completeEngineText,
   ensurePiAiRegistered,
   createEngineAi,
@@ -335,4 +347,4 @@ export {
   calculateEngineCost,
   registerFauxFromEnv
 };
-//# sourceMappingURL=chunk-FCSXB6T2.js.map
+//# sourceMappingURL=chunk-UOSL25KY.js.map

package/dist/{chunk-EELBMBT6.js → chunk-VKBMFOYV.js}

@@ -7,21 +7,23 @@ import {
   cloneDispatchBudgetRequest,
   isApprovedAssignmentRoute,
   isDispatchIntent,
-  isToolProfileName
-} from "./chunk-CEYBNUGC.js";
+  isToolProfileName,
+  resolveDispatchPathScope
+} from "./chunk-4H6ULJ3H.js";
 import {
   ROUTE_POLICY_VERSION,
   isRouteDecisionAgentSelection,
   isRoutingIntent,
   parseRoutingIntent
-} from "./chunk-5C77SEEY.js";
+} from "./chunk-VPTUJU4P.js";
 import {
   isExecutionRole,
   requestExecutionRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
 import {
-  AGENT_AUTOMATION_AUTHORITIES
-} from "./chunk-AOCYTWAV.js";
+  AGENT_AUTOMATION_AUTHORITIES,
+  pathBoundaryCovers
+} from "./chunk-S4COXYBG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -217,8 +219,34 @@ function dispatchRequestsFromArgs(args, options) {
   for (let index = 0; index < tasks.length; index += 1) {
     const item = tasks[index];
     const itemArgs = isRecord(item) ? { ...shared, ...item } : { ...shared, task: item };
+    const sharedIntent = isRecord(shared.intent) ? shared.intent : null;
+    const itemIntent = isRecord(item) && Object.hasOwn(item, "intent") && isRecord(item.intent) ? item.intent : null;
+    if (sharedIntent !== null && itemIntent !== null) itemArgs.intent = { ...sharedIntent, ...itemIntent };
     const parsed = dispatchRequestFromArgs(itemArgs, options);
     if (!parsed.ok) return { ok: false, message: `dispatch: task ${index + 1}: ${parsed.message}` };
+    if (sharedIntent !== null && itemIntent !== null) {
+      if (options.resolveIntent === void 0) {
+        return { ok: false, message: `dispatch: task ${index + 1}: intent resolver is unavailable` };
+      }
+      const ceiling = options.resolveIntent(sharedIntent, parsed.request.cwd);
+      if (!ceiling.ok) return { ok: false, message: `dispatch: task ${index + 1}: ${ceiling.message}` };
+      const pathCeilings = {
+        readRoots: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots],
+        writeRoots: ceiling.intent.writeRoots,
+        relevantPaths: [...ceiling.intent.readRoots, ...ceiling.intent.writeRoots, ...ceiling.intent.relevantPaths]
+      };
+      for (const field of ["readRoots", "writeRoots", "relevantPaths"]) {
+        const outside = parsed.request.intent?.[field].find(
+          (candidate) => !pathBoundaryCovers(pathCeilings[field], candidate)
+        );
+        if (outside !== void 0) {
+          return {
+            ok: false,
+            message: `dispatch: task ${index + 1}: intent_scope_widening: ${field} entry '${outside}' is outside the top-level intent ceiling`
+          };
+        }
+      }
+    }
     requests.push(parsed.request);
   }
   return { ok: true, requests };
@@ -299,14 +327,44 @@ function isRecord2(value) {
 function str(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
-function safeField(value) {
+function safeField(value, bindChangedValue = true) {
   let result = "";
   for (const character of value) {
     const code = character.codePointAt(0) ?? 0;
     result += code < 32 || code >= 127 && code <= 159 ? "?" : character;
-    if (result.length >= 256) return `${result.slice(0, 255)}\u2026`;
+    if (result.length >= 256) {
+      result = `${result.slice(0, 255)}\u2026`;
+      break;
+    }
+  }
+  if (!bindChangedValue || result === value) return result;
+  return `${result}{sha256=${createHash("sha256").update(value, "utf8").digest("hex")}}`;
+}
+function renderLegacyPathScope(task) {
+  if (task.intent !== void 0) return [];
+  const scope = resolveDispatchPathScope({
+    agentId: task.agent,
+    executionRole: task.executionRole,
+    task: task.task,
+    ...task.briefing !== void 0 ? { briefing: task.briefing } : {}
+  });
+  const lines = ["    scope mode=legacy-inferred"];
+  for (const [policy, entries] of [
+    ["working_context", scope.provenance.workingContextPaths],
+    ["write_boundary", scope.provenance.writeBoundaries]
+  ]) {
+    for (const entry of entries) {
+      for (const evidence of entry.evidence) {
+        lines.push(
+          `    scope ${policy} path=${JSON.stringify(safeField(entry.path))} provenance=${evidence.provenance} source=${evidence.source} confidence=${evidence.confidence} reason=${evidence.reason}`
+        );
+      }
+    }
+  }
+  if (scope.provenance.workingContextPaths.length === 0 && scope.provenance.writeBoundaries.length === 0) {
+    lines.push("    scope policy_paths=none");
   }
-  return result;
+  return lines;
 }
 function taskViews(args) {
   const tasks = Array.isArray(args.tasks) ? args.tasks : [];
@@ -403,7 +461,7 @@ function renderPlanText(topology, tasks, costCeilingUsd, deadlineMs, source, max
     const routing = task.routingIntent;
     const routingText = routing === void 0 ? "" : ` posture=${routing.posture} maxCostUsd=${routing.maxCostUsd ?? "none"} deadlineMs=${routing.deadlineMs ?? "none"} minimumQuality=${routing.minimumQuality ?? "none"} locality=${routing.locality}`;
     lines.push(
-      `  ${index + 1}.${role} agent=${safeField(task.agent)}${target}${model}${node}${failover}${routingText} task=${JSON.stringify(safeField(task.task))}`
+      `  ${index + 1}.${role} agent=${safeField(task.agent)}${target}${model}${node}${failover}${routingText} task_bytes=${Buffer.byteLength(task.task, "utf8")} task_sha256=${createHash("sha256").update(task.task, "utf8").digest("hex")} task_preview=${JSON.stringify(safeField(task.task, false))}`
     );
     if (task.council !== void 0) {
       lines.push(
@@ -430,28 +488,29 @@ function renderPlanText(topology, tasks, costCeilingUsd, deadlineMs, source, max
     }
     if (task.agentSelection !== null) {
       lines.push(
-        `    agent-selection=auto baseline=${safeField(task.agentSelection.baselineAgentId)} authority=${task.agentSelection.approvedAuthorities.map(safeField).join(",")} basis=${task.agentSelection.authorityBasis}`
+        `    agent-selection=auto baseline=${safeField(task.agentSelection.baselineAgentId)} authority=${task.agentSelection.approvedAuthorities.map((authority) => safeField(authority)).join(",")} basis=${task.agentSelection.authorityBasis}`
       );
     }
     if (task.stepId !== null) {
       lines.push(
-        `    step=${safeField(task.stepId)} wave=${task.wave ?? "?"} role=${task.executionRole} dependencies=${task.dependencies.map(safeField).join(",") || "none"} result=${task.expectedResultContract ?? "none"} authority=${task.authorityGrant?.requested ?? "none"} basis=${task.authorityGrant?.basis ?? "none"}`
+        `    step=${safeField(task.stepId)} wave=${task.wave ?? "?"} role=${task.executionRole} dependencies=${task.dependencies.map((dependency) => safeField(dependency)).join(",") || "none"} result=${task.expectedResultContract ?? "none"} authority=${task.authorityGrant?.requested ?? "none"} basis=${task.authorityGrant?.basis ?? "none"}`
       );
       const agentReasons = task.agentDecision?.agentSelection.evaluations.filter((evaluation) => evaluation.rejections.length > 0).slice(0, 8).map(
-        (evaluation) => `${safeField(evaluation.agentId)}:${evaluation.rejections.slice(0, 4).map(safeField).join(",")}`
+        (evaluation) => `${safeField(evaluation.agentId)}:${evaluation.rejections.slice(0, 4).map((rejection) => safeField(rejection)).join(",")}`
       );
       if (agentReasons !== void 0 && agentReasons.length > 0)
         lines.push(`    agent-exclusions=${agentReasons.join(";")}`);
     }
     if (task.briefing !== void 0) {
       lines.push(
-        `    briefing_bytes=${Buffer.byteLength(task.briefing, "utf8")} briefing_sha256=${createHash("sha256").update(task.briefing, "utf8").digest("hex")} briefing_preview=${JSON.stringify(safeField(task.briefing))}`
+        `    briefing_bytes=${Buffer.byteLength(task.briefing, "utf8")} briefing_sha256=${createHash("sha256").update(task.briefing, "utf8").digest("hex")} briefing_preview=${JSON.stringify(safeField(task.briefing, false))}`
       );
     }
     if (task.intent !== void 0) {
       const serialized = JSON.stringify(task.intent);
       lines.push(`    intent_sha256=${createHash("sha256").update(serialized, "utf8").digest("hex")}`);
     }
+    lines.push(...renderLegacyPathScope(task));
     for (const check of task.resolvedVerification ?? []) {
       lines.push(
         `    verification check=${safeField(check.check)} argv=${JSON.stringify(check.argv)} cwd=${JSON.stringify(check.cwd)} timeout_ms=${check.timeoutMs}`
@@ -756,4 +815,4 @@ export {
   withResolvedDispatchPlan,
   describeDispatchPlan
 };
-//# sourceMappingURL=chunk-EELBMBT6.js.map
+//# sourceMappingURL=chunk-VKBMFOYV.js.map

package/dist/chunk-VO2LKSTM.js

@@ -0,0 +1,165 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  createEngineAi,
+  getEngineSupportedThinkingLevels
+} from "./chunk-UOSL25KY.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/providers/capabilities.ts
+init_esm_shims();
+function mergeCapabilities(base, kb, probe, userOverride) {
+  const merged = { ...base };
+  applyLayer(merged, probe);
+  applyLayer(merged, kb);
+  applyDeploymentLimits(merged, probe);
+  applyLayer(merged, userOverride);
+  return merged;
+}
+function applyDeploymentLimits(target, probe) {
+  if (!probe) return;
+  if (probe.contextWindow !== void 0) target.contextWindow = probe.contextWindow;
+  if (probe.maxTokens !== void 0) target.maxTokens = probe.maxTokens;
+}
+function supportsAgentRoleTools(capabilities) {
+  return capabilities.tools === true;
+}
+var AGENT_ROLE_TOOLS_REQUIRED_REASON = "reports no tool support; Clio drives every agent role through typed tools";
+function applyLayer(target, layer) {
+  if (!layer) return;
+  for (const key of Object.keys(layer)) {
+    const value = layer[key];
+    if (value !== void 0) target[key] = value;
+  }
+}
+
+// src/domains/providers/catalog.ts
+init_esm_shims();
+var engineAi = createEngineAi();
+var CATALOG_PROVIDER_BY_RUNTIME_ID = /* @__PURE__ */ new Map([
+  ["anthropic", "anthropic"],
+  ["anthropic-max", "anthropic"],
+  ["claude-code", "anthropic"],
+  ["claude-sdk", "anthropic"],
+  ["bedrock", "amazon-bedrock"],
+  ["deepseek", "deepseek"],
+  ["google", "google"],
+  ["groq", "groq"],
+  ["mistral", "mistral"],
+  ["openai", "openai"],
+  ["openai-codex", "openai-codex"],
+  ["openrouter", "openrouter"]
+]);
+function catalogProviderForRuntime(runtimeId) {
+  return CATALOG_PROVIDER_BY_RUNTIME_ID.get(runtimeId);
+}
+function listCatalogModelsForRuntime(runtimeId) {
+  const provider = catalogProviderForRuntime(runtimeId);
+  if (!provider) return [];
+  try {
+    return engineAi.listModels(provider);
+  } catch {
+    return [];
+  }
+}
+function resolveEffectivePricing(target, runtimeId, wireModelId) {
+  if (target.pricing) {
+    const rates = {
+      input: target.pricing.input,
+      output: target.pricing.output,
+      cacheRead: target.pricing.cacheRead ?? 0,
+      cacheWrite: target.pricing.cacheWrite ?? 0
+    };
+    return {
+      rates,
+      provenance: Object.values(rates).every((rate) => rate === 0) ? "known_free" : "known"
+    };
+  }
+  const catalogModel = getCatalogModelForRuntime(runtimeId, wireModelId);
+  if (!catalogModel) return { rates: null, provenance: "unknown" };
+  return {
+    rates: {
+      input: catalogModel.cost.input,
+      output: catalogModel.cost.output,
+      cacheRead: catalogModel.cost.cacheRead,
+      cacheWrite: catalogModel.cost.cacheWrite
+    },
+    provenance: "estimated"
+  };
+}
+function resolveCostProvenance(target, runtimeId, wireModelId) {
+  return resolveEffectivePricing(target, runtimeId, wireModelId).provenance;
+}
+function getCatalogModelForRuntime(runtimeId, wireModelId) {
+  const provider = catalogProviderForRuntime(runtimeId);
+  if (!provider) return void 0;
+  try {
+    return engineAi.getModel(provider, wireModelId);
+  } catch {
+    return void 0;
+  }
+}
+function capabilitiesFromCatalogModel(defaultCapabilities, model) {
+  if (!model) return defaultCapabilities;
+  return {
+    ...defaultCapabilities,
+    reasoning: model.reasoning,
+    vision: model.input.includes("image"),
+    contextWindow: model.contextWindow,
+    maxTokens: model.maxTokens
+  };
+}
+function catalogThinkingLevelsForRuntime(runtimeId, wireModelId) {
+  const model = getCatalogModelForRuntime(runtimeId, wireModelId);
+  return model ? getEngineSupportedThinkingLevels(model) : void 0;
+}
+function synthesizeCatalogBackedModel(input) {
+  const builtin = getCatalogModelForRuntime(input.runtimeId, input.wireModelId);
+  const caps = mergeCapabilities(
+    capabilitiesFromCatalogModel(input.defaultCapabilities, builtin),
+    input.kb?.entry.capabilities ?? null,
+    null,
+    input.target.capabilities ?? null
+  );
+  const pricing = input.target.pricing;
+  const targetHeaders = input.target.auth?.headers;
+  const model = {
+    ...builtin ?? {},
+    id: input.wireModelId,
+    name: `${input.wireModelId} (${input.target.id})`,
+    api: input.api,
+    provider: input.provider,
+    baseUrl: input.target.url ?? builtin?.baseUrl ?? input.defaultBaseUrl,
+    reasoning: caps.reasoning,
+    input: caps.vision ? builtin?.input.includes("image") ? builtin.input : ["text", "image"] : ["text"],
+    cost: {
+      input: pricing?.input ?? builtin?.cost.input ?? 0,
+      output: pricing?.output ?? builtin?.cost.output ?? 0,
+      cacheRead: pricing?.cacheRead ?? builtin?.cost.cacheRead ?? 0,
+      cacheWrite: pricing?.cacheWrite ?? builtin?.cost.cacheWrite ?? 0
+    },
+    contextWindow: caps.contextWindow,
+    maxTokens: caps.maxTokens
+  };
+  const headers = { ...input.defaultHeaders ?? {}, ...builtin?.headers ?? {}, ...targetHeaders ?? {} };
+  if (Object.keys(headers).length > 0) {
+    model.headers = headers;
+  }
+  return model;
+}
+
+export {
+  mergeCapabilities,
+  supportsAgentRoleTools,
+  AGENT_ROLE_TOOLS_REQUIRED_REASON,
+  catalogProviderForRuntime,
+  listCatalogModelsForRuntime,
+  resolveEffectivePricing,
+  resolveCostProvenance,
+  getCatalogModelForRuntime,
+  capabilitiesFromCatalogModel,
+  catalogThinkingLevelsForRuntime,
+  synthesizeCatalogBackedModel
+};
+//# sourceMappingURL=chunk-VO2LKSTM.js.map

package/dist/{chunk-5C77SEEY.js → chunk-VPTUJU4P.js}

@@ -2,10 +2,10 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   gateRouteCorrelation,
   isExecutionRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
 import {
   isAgentCapabilityClass
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-S4COXYBG.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -995,4 +995,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-5C77SEEY.js.map
+//# sourceMappingURL=chunk-VPTUJU4P.js.map

package/dist/{chunk-WEH5XRJQ.js → chunk-WIE7ZOSW.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-CGKSTWHD.js";
 import {
   StringEnum
-} from "./chunk-FCSXB6T2.js";
+} from "./chunk-UOSL25KY.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -29,4 +29,4 @@ var steerToolSurface = {
 export {
   steerToolSurface
 };
-//# sourceMappingURL=chunk-WEH5XRJQ.js.map
+//# sourceMappingURL=chunk-WIE7ZOSW.js.map

package/dist/{chunk-J7PIKKWC.js → chunk-WXCJ7VME.js}

@@ -4,25 +4,25 @@ import {
   READONLY_SCOPE,
   WORKSPACE_SCOPE,
   isSubset
-} from "./chunk-IR4CFBFN.js";
+} from "./chunk-HAY4ZE2P.js";
 import {
   createLoopState,
   observe
 } from "./chunk-UOV2BYIW.js";
 import {
   createSafetyPolicyEngine
-} from "./chunk-OBMAI2DP.js";
+} from "./chunk-N3PBVRTZ.js";
 import {
   classify
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-S4COXYBG.js";
+import {
+  BusChannels,
+  isRunAbortedPayload
+} from "./chunk-RKRLDWD3.js";
 import {
   clioStateDir,
   stateRootRemoved
 } from "./chunk-BNAZZHFG.js";
-import {
-  BusChannels,
-  isRunAbortedPayload
-} from "./chunk-OB5HIGJY.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -608,4 +608,4 @@ var SafetyDomainModule = {
 export {
   SafetyDomainModule
 };
-//# sourceMappingURL=chunk-J7PIKKWC.js.map
+//# sourceMappingURL=chunk-WXCJ7VME.js.map

package/dist/{chunk-4DGYLA73.js → chunk-XDOQXGFO.js}

@@ -65,11 +65,15 @@ var DEFAULT_SETTINGS = {
       everyNTools: 10,
       windowSteps: 8,
       maxTokens: 400,
-      // A memory step runs detached from the turn that triggered it, so a
-      // generous deadline costs no interactive latency. Measured steps on a
-      // small local route ranged past two minutes, and a deadline shorter than
-      // the model discards finished work as a timeout.
-      timeoutMs: 18e4
+      // A memory step runs detached from the turn that triggered it, but it
+      // runs on a real inference endpoint that the operator's own turns and
+      // dispatched workers also queue against. The operator's ledger over 14
+      // days recorded 60 llm-tier steps spending 1,666 seconds of model time
+      // for 6 injections, with one step holding a local server for 102.5
+      // seconds to answer nothing. The deadline is what a turn boundary can
+      // actually wait for; a step that runs past it is recorded as timed out
+      // rather than spending the remaining minutes unobserved.
+      timeoutMs: 3e4
     }
   },
   watchdog: { enabled: false },
@@ -155,6 +159,9 @@ var DEFAULT_SETTINGS = {
   context: {
     workingSet: DEFAULT_WORKING_SET_SETTINGS
   },
+  prewarm: {
+    enabled: true
+  },
   retry: {
     enabled: true,
     maxRetries: 3,
@@ -237,7 +244,7 @@ memory:
     everyNTools: 10
     windowSteps: 8
     maxTokens: 400
-    timeoutMs: 180000
+    timeoutMs: 30000
 
 # Opt-in turn-end watchdog. When enabled, a turn that changed the tree is
 # reviewed by one read-only verifier run briefed with the turn's coalesced diff
@@ -449,6 +456,14 @@ context:
     protectLastTurns: 6
     minEvictableTokens: 200
 
+# Prompt pre-warm. At session start, after a resume rebuilds the message array,
+# and after a compaction settles, Clio sends the prefix the next turn would send
+# (minus your text) so a local server has already prefilled it when you press
+# Enter. Local-native targets only, interactive sessions only, and never while a
+# turn or a dispatch is running.
+prewarm:
+  enabled: true
+
 # Transient provider/stream retry controls for interactive chat.
 # Retryable errors include overloads, rate limits, 5xx responses, network
 # resets, and timeouts. Context overflow uses compaction recovery instead.
@@ -497,4 +512,4 @@ export {
   DEFAULT_SETTINGS,
   DEFAULT_SETTINGS_YAML
 };
-//# sourceMappingURL=chunk-4DGYLA73.js.map
+//# sourceMappingURL=chunk-XDOQXGFO.js.map

package/dist/{chunk-PPAMZ32Z.js → chunk-XK56QHLX.js}

@@ -15,6 +15,10 @@ function printError(message, detail) {
   if (detail) process.stderr.write(`  ${detail}
 `);
 }
+function printNote(message) {
+  process.stderr.write(`${source_default.yellow("note:")} ${message}
+`);
+}
 function printOk(message) {
   process.stdout.write(`${source_default.green("ok:")} ${message}
 `);
@@ -138,6 +142,7 @@ function extractGlobalFlags(argv, isSubcommand = () => false) {
 
 export {
   printError,
+  printNote,
   printOk,
   printHeader,
   columnWidths,
@@ -147,4 +152,4 @@ export {
   globalFlagPositionHint,
   extractGlobalFlags
 };
-//# sourceMappingURL=chunk-PPAMZ32Z.js.map
+//# sourceMappingURL=chunk-XK56QHLX.js.map

package/dist/{chunk-AB4XIIVB.js → chunk-YKOFT37S.js}

@@ -1,22 +1,22 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   assistantTextFromEvent
-} from "./chunk-VREKEFLL.js";
+} from "./chunk-D73KXYPF.js";
 import {
   durableAssistantTextFromEvent
-} from "./chunk-UUANF5CR.js";
+} from "./chunk-TEO2TLVN.js";
 import {
   compileExecutionPlan
-} from "./chunk-M4AKACEO.js";
+} from "./chunk-HKO36JWF.js";
 import {
   deriveExecutionRole
-} from "./chunk-UND3GU2L.js";
+} from "./chunk-H7IXIC72.js";
 import {
   truncateUtf8
 } from "./chunk-6XLNIQDB.js";
 import {
   BusChannels
-} from "./chunk-OB5HIGJY.js";
+} from "./chunk-RKRLDWD3.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -276,4 +276,4 @@ export {
   compileScoutTransition,
   createDispatchRunEventRegistry
 };
-//# sourceMappingURL=chunk-AB4XIIVB.js.map
+//# sourceMappingURL=chunk-YKOFT37S.js.map