@tangle-network/agent-runtime 0.87.0 → 0.88.0

package/dist/agent.js

@@ -1,12 +1,12 @@
-import "./chunk-VKVNDNG4.js";
+import "./chunk-22HPUH77.js";
 import {
   createSandboxForSpec
-} from "./chunk-6XCW3M7W.js";
+} from "./chunk-LRNRPJAV.js";
 import "./chunk-UD4BHQMI.js";
 import "./chunk-BZF3KQ6G.js";
 import {
   mapSandboxEvent
-} from "./chunk-QUXZBZCS.js";
+} from "./chunk-FVJ7M3DA.js";
 import "./chunk-7LO5GMAO.js";
 import "./chunk-YEJR7IXO.js";
 import "./chunk-DPEUKJRO.js";

package/dist/analyst-loop.js

@@ -1,8 +1,8 @@
 import {
   iterationsToTraceStore,
   runAnalystLoop
-} from "./chunk-LCXXIL3U.js";
-import "./chunk-QUXZBZCS.js";
+} from "./chunk-ZQZX77MM.js";
+import "./chunk-FVJ7M3DA.js";
 import "./chunk-YEJR7IXO.js";
 import "./chunk-DGUM43GV.js";
 export {

package/dist/{chunk-VKVNDNG4.js → chunk-22HPUH77.js}

@@ -15,7 +15,7 @@ import {
   settledToIteration,
   supervise,
   withDriverExecutor
-} from "./chunk-6XCW3M7W.js";
+} from "./chunk-LRNRPJAV.js";
 import {
   addTokenUsage,
   isAbortError,
@@ -28,7 +28,7 @@ import {
   createSandboxToolPartState,
   mapSandboxEvent,
   mapSandboxToolEvent
-} from "./chunk-QUXZBZCS.js";
+} from "./chunk-FVJ7M3DA.js";
 import {
   AnalystError,
   BackendTransportError,
@@ -1405,6 +1405,263 @@ function inProcessSandboxClient(options) {
   };
 }
 
+// src/runtime/loop-author.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+
+// src/runtime/strategy-author.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3 } from "path";
+var strategyAuthorContract = `
+You author an OPTIMIZATION STRATEGY for an agentic loop system. A strategy decides how to
+spend a compute budget to beat a task's deployable check. You compose exactly two steps:
+
+  shot(spec?: { handle?, messages?, steer?, persona?, tools? }): Promise<ShotResult | null>
+    Runs ONE worker attempt (a bounded tool loop) over an artifact.
+    - omit handle  => the shot opens its OWN fresh artifact and closes it after (a sample).
+    - pass handle  => the shot CONTINUES that artifact (state accumulates across shots).
+    - messages     => the carried conversation (pass the previous ShotResult.messages to continue).
+    - steer        => a corrective instruction injected before the shot.
+    - persona      => { systemPrompt?, model? } \u2014 give THIS shot its own role and/or model
+      (multi-agent strategies: a researcher shot then an engineer shot, a panel of k
+      personas over one budget). On a fresh shot the systemPrompt replaces the task's; on
+      a carried conversation it arrives as a hand-off message. Same conserved budget.
+    - tools        => string[] \u2014 restrict THIS shot to a subset of the task's tools by
+      name (focus an explore shot on read-only tools, an execute shot on write tools).
+      Restriction-only; unknown names make the shot fail. ALWAYS select from
+      await listTools(handle) \u2014 never hardcode. Omitted => the shot sees every tool.
+    ShotResult = { messages, score (0..1 on the task's check), passes, total, completions, toolErrors }
+    Returns null if the attempt failed infra-wise.
+
+  critique(messages): Promise<string | null>
+    A firewalled trace-analyst reads the attempt's trajectory and returns ONE corrective
+    instruction (or null when it judges the work complete). Costs ~1 completion.
+
+  consult(messages, instruction): Promise<string | null>
+    The RAW analyst channel: the same firewalled critic answers YOUR instruction over the
+    trajectory verbatim (no reformatting) \u2014 use it when you need a specific reply format
+    (a decision, a prediction). Costs ~1 completion.
+
+  surface.open(task) / surface.close(handle)
+    Open a persistent artifact you manage yourself (remember to close in a finally).
+    close is idempotent \u2014 closing an already-closed handle is a safe no-op.
+
+  listTools(handle): Promise<Array<{ name, description? }>>
+    The tools THIS task actually offers. TOOL SETS VARY PER TASK \u2014 if you restrict a
+    shot with \`tools\`, you MUST pick names from await listTools(handle); hardcoding
+    names from an example kills your shots on every task whose tools differ.
+
+Rules:
+- ALWAYS await every shot/critique/surface call \u2014 a floating promise that rejects
+  crashes the whole benchmark run.
+- Stay within ~budget total shots; every shot/critique spends from a conserved pool.
+- For a FRESH attempt OMIT \`messages\` entirely (never pass \`[]\` \u2014 an empty array is a
+  fresh conversation too, but be explicit). To CONTINUE, pass the previous
+  ShotResult.messages unchanged.
+- Return { score, resolved, completions, progression, shots } \u2014 score = the BEST checkpoint
+  you reached (keep-best, never final-state), progression = score after each shot.
+- The module must be EXACTLY this shape (no other imports, no commentary outside code):
+
+import { defineStrategy } from '@tangle-network/agent-runtime/loops'
+export default defineStrategy('your-strategy-name', async ({ surface, task, budget, shot, critique, listTools }) => {
+  // your composition (listTools comes from the destructured context \u2014 it is NOT a global)
+})
+`;
+function assertStrategyContract(code) {
+  const allowedImport = /^\s*import\s+\{[^}]*\}\s+from\s+['"]@tangle-network\/agent-runtime\/loops['"]/;
+  for (const line of code.split("\n")) {
+    if (/^\s*import\s/.test(line) && !allowedImport.test(line)) {
+      throw new Error(`authored code rejected: foreign import \u2014 ${line.trim().slice(0, 120)}`);
+    }
+  }
+  const banned = [
+    [/\brequire\s*\(/, "require()"],
+    [/\bimport\s*\(/, "dynamic import()"],
+    [/\beval\s*\(/, "eval()"],
+    [/new\s+Function\s*\(/, "new Function()"],
+    [/\bprocess\s*[.[]/, "process access"],
+    [/\bglobalThis\s*[.[]/, "globalThis access"],
+    [/\bfetch\s*\(/, "network access"],
+    [/child_process|node:fs|node:net|node:http|worker_threads/, "node builtin access"]
+  ];
+  for (const [re, what] of banned) {
+    if (re.test(code)) throw new Error(`authored code rejected: ${what}`);
+  }
+}
+async function requestAuthoredCode(opts, model) {
+  const res = await opts.chat.chat(
+    {
+      ...model ? { model } : {},
+      ...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
+      ...opts.maxTokens !== void 0 ? { maxTokens: opts.maxTokens } : {},
+      messages: [
+        {
+          role: "system",
+          content: "You are a senior engineer authoring optimization strategies for agent loops. Output exactly one fenced ```ts code block and nothing else."
+        },
+        {
+          role: "user",
+          content: `${opts.contract ?? strategyAuthorContract}
+
+BASELINE RESULTS on the "${opts.environmentName}" environment (budget=${opts.budget}):
+${opts.lossesJson}
+
+Author ONE new strategy that you expect to beat the baselines on THIS environment at the same budget. Use the losses to target the observed failure mode. Output only the module code block.`
+        }
+      ]
+    },
+    { ...opts.signal ? { signal: opts.signal } : {} }
+  );
+  const match = res.content.match(/```(?:ts|typescript)?\s*\n([\s\S]*?)```/);
+  if (!match?.[1]) {
+    throw new Error(
+      `authorStrategy: no code block in the author's reply (model=${model ?? "default"}): ${res.content.slice(0, 300)}`
+    );
+  }
+  return match[1];
+}
+async function authorStrategy(opts) {
+  let code;
+  try {
+    code = await requestAuthoredCode(opts, opts.model);
+  } catch (primaryError) {
+    if (!opts.fallbackModel) throw primaryError;
+    code = await requestAuthoredCode(opts, opts.fallbackModel);
+  }
+  assertStrategyContract(code);
+  mkdirSync2(opts.outDir, { recursive: true });
+  const file = join3(opts.outDir, `authored-${Date.now()}.mts`);
+  writeFileSync2(file, code);
+  const mod = await import(`file://${file}`);
+  if (!mod.default || typeof mod.default.driver !== "function" || !mod.default.name) {
+    throw new Error(`authorStrategy: ${file} does not export a default Strategy`);
+  }
+  return { strategy: mod.default, file, code };
+}
+
+// src/runtime/loop-author.ts
+var loopAuthorContract = `
+You author a LOOP ATOM for an agent supervisor. A loop runs a bounded, multi-round journey
+toward a deployable check; a supervisor spawns / observes / steers it exactly like a worker.
+You write ONE round; the runtime owns the round ceiling, the conserved budget, the gate, and
+folding a supervisor's steer into the next round. So write real control flow inside a round,
+but never write the loop's stop condition as "hope the model stops" \u2014 that is the runtime's job.
+
+You export ONE module of EXACTLY this shape (no other imports, no commentary outside the code):
+
+import { defineLoop } from '@tangle-network/agent-runtime/loops'
+export default defineLoop('your-loop-name', {
+  maxRounds: 3,
+  round: async ({ task, scope, round, maxRounds, steer, budget, signal }) => {
+    // arbitrary code for ONE round. Do real work by spawning children on the nested scope:
+    //   const w = scope.spawn(childAgent, subtask, { budget: perRound, label: \`r\${round}\` })
+    //   if (!w.ok) throw new Error(w.reason)      // fail loud: budget-exhausted | depth-exceeded
+    //   const settled = await scope.next()        // conserved child work; settles gated
+    // 'steer' is the supervisor's messages since the last round (fold them into what you do next).
+    // 'signal' aborts if a forceful steer arrives mid-round \u2014 pass it to your awaited work.
+    return { out: /* the running result */ undefined, done: false }  // done:true stops early
+  },
+  check: (out) => /* the deployable completion oracle */ Boolean(out),
+})
+
+For a MULTI-AGENT loop (a proposer then a verifier, a researcher then an engineer), do NOT
+hand-write the pipeline in 'round' \u2014 use 'agents' instead: an ordered list of named agents piped
+each round (task -> agents[0] -> agents[1] -> ... -> out). "How many agents" is then self-evident.
+
+import { defineLoop } from '@tangle-network/agent-runtime/loops'
+export default defineLoop('your-loop-name', {
+  maxRounds: 3,
+  agents: [
+    { name: 'proposer', run: async (ctx, prior) => { /* spawn a worker, produce a draft */ return draft } },
+    { name: 'verifier', run: async (ctx, prior) => { /* verify/refine the proposer's draft */ return checked } },
+  ],
+  check: (out) => Boolean(out),
+})
+
+Provide EXACTLY one of 'round' or 'agents'. The round context (for the 'round' form, and passed to
+each agent's run as its first arg):
+  task       the spawn task, verbatim.
+  scope      the NESTED conserved scope. scope.spawn(agent, task, { budget, label }) reserves
+             budget and fails closed; scope.next() awaits one child settlement. Budget NESTS \u2014
+             the pool reserves each spawn's full ceiling until it settles, so give children a
+             per-round budget smaller than the loop's own.
+  round      1-based round index. maxRounds is the declared ceiling.
+  steer      readonly string[] \u2014 supervisor steer_agent messages that arrived since last round.
+  budget     conserved-pool readouts (tokensLeft, usdLeft, deadlineMs) for in-body awareness.
+  signal     AbortSignal \u2014 the spawn signal + a fresh per-round interrupt; honor it in awaits.
+
+The round result: { out: unknown; done?: boolean }. 'out' is the running result the gate reads;
+'done: true' is YOUR early stop (distinct from the runtime's gate 'check').
+
+check(out): boolean | Promise<boolean>. The DEPLOYABLE oracle \u2014 an executable test, a state
+verifier, a readiness score threshold \u2014 read off 'out', never the model judging itself. The loop
+settles valid IFF check passes, and the runtime polls it after each round to stop the instant the
+loop has delivered. A loop that exhausts maxRounds without check passing settles valid:false.
+
+Rules:
+- ALWAYS await every scope.spawn drain / async call \u2014 a floating rejection crashes the run.
+- Do real work by SPAWNING children; raw un-metered inference in the body is not budget-conserved.
+- Give 'check' a real oracle. A loop whose check is a self-judged score cannot be trusted.
+- The only import allowed is '@tangle-network/agent-runtime/loops'. No require/eval/fetch/process/
+  node builtins \u2014 the runtime meters and gates you; out-of-band compute breaks that.
+`;
+async function requestAuthoredCode2(opts, model) {
+  const res = await opts.chat.chat(
+    {
+      ...model ? { model } : {},
+      ...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
+      ...opts.maxTokens !== void 0 ? { maxTokens: opts.maxTokens } : {},
+      messages: [
+        {
+          role: "system",
+          content: "You are a senior engineer authoring coded loop atoms for an agent supervisor. Output exactly one fenced ```ts code block and nothing else."
+        },
+        {
+          role: "user",
+          content: `${opts.contract ?? loopAuthorContract}
+
+GOAL: ${opts.goal}
+MAX ROUNDS: ${opts.maxRounds}${opts.context ? `
+
+CONTEXT:
+${opts.context}` : ""}
+
+Author ONE loop that reaches the goal within the round ceiling, gated on a real check. Output only the module code block.`
+        }
+      ]
+    },
+    { ...opts.signal ? { signal: opts.signal } : {} }
+  );
+  const match = res.content.match(/```(?:ts|typescript)?\s*\n([\s\S]*?)```/);
+  if (!match?.[1]) {
+    throw new Error(
+      `authorLoop: no code block in the author's reply (model=${model ?? "default"}): ${res.content.slice(0, 300)}`
+    );
+  }
+  return match[1];
+}
+function isLoopDef(value) {
+  return typeof value === "object" && value !== null && typeof value.round === "function" && typeof value.name === "string" && Number.isInteger(value.maxRounds);
+}
+async function authorLoop(opts) {
+  let code;
+  try {
+    code = await requestAuthoredCode2(opts, opts.model);
+  } catch (primaryError) {
+    if (!opts.fallbackModel) throw primaryError;
+    code = await requestAuthoredCode2(opts, opts.fallbackModel);
+  }
+  assertStrategyContract(code);
+  mkdirSync3(opts.outDir, { recursive: true });
+  const file = join4(opts.outDir, `authored-loop-${Date.now()}.mts`);
+  writeFileSync3(file, code);
+  const mod = await import(`file://${file}`);
+  if (!isLoopDef(mod.default)) {
+    throw new Error(`authorLoop: ${file} does not default-export a LoopDef (defineLoop(...))`);
+  }
+  return { loop: mod.default, file, code };
+}
+
 // src/runtime/mcp-environment.ts
 async function rpc(endpoint, body) {
   let lastErr;
@@ -3532,7 +3789,8 @@ async function openSandboxRun(client, options, deliverable) {
         const r = await lineage.start(
           options.agentRun,
           prompt,
-          options.signal
+          options.signal,
+          options.promptOptions
         );
         handle = r.handle;
         const result = await settle2(handle.box, r.events);
@@ -3577,7 +3835,7 @@ async function openSandboxRun(client, options, deliverable) {
       try {
         const result = await settle2(
           handle.box,
-          await lineage.continue(handle, prompt, options.signal)
+          await lineage.continue(handle, prompt, options.signal, options.promptOptions)
         );
         turnCount += 1;
         emit({
@@ -3645,138 +3903,8 @@ function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
-// src/runtime/strategy-author.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
-var strategyAuthorContract = `
-You author an OPTIMIZATION STRATEGY for an agentic loop system. A strategy decides how to
-spend a compute budget to beat a task's deployable check. You compose exactly two steps:
-
-  shot(spec?: { handle?, messages?, steer?, persona?, tools? }): Promise<ShotResult | null>
-    Runs ONE worker attempt (a bounded tool loop) over an artifact.
-    - omit handle  => the shot opens its OWN fresh artifact and closes it after (a sample).
-    - pass handle  => the shot CONTINUES that artifact (state accumulates across shots).
-    - messages     => the carried conversation (pass the previous ShotResult.messages to continue).
-    - steer        => a corrective instruction injected before the shot.
-    - persona      => { systemPrompt?, model? } \u2014 give THIS shot its own role and/or model
-      (multi-agent strategies: a researcher shot then an engineer shot, a panel of k
-      personas over one budget). On a fresh shot the systemPrompt replaces the task's; on
-      a carried conversation it arrives as a hand-off message. Same conserved budget.
-    - tools        => string[] \u2014 restrict THIS shot to a subset of the task's tools by
-      name (focus an explore shot on read-only tools, an execute shot on write tools).
-      Restriction-only; unknown names make the shot fail. ALWAYS select from
-      await listTools(handle) \u2014 never hardcode. Omitted => the shot sees every tool.
-    ShotResult = { messages, score (0..1 on the task's check), passes, total, completions, toolErrors }
-    Returns null if the attempt failed infra-wise.
-
-  critique(messages): Promise<string | null>
-    A firewalled trace-analyst reads the attempt's trajectory and returns ONE corrective
-    instruction (or null when it judges the work complete). Costs ~1 completion.
-
-  consult(messages, instruction): Promise<string | null>
-    The RAW analyst channel: the same firewalled critic answers YOUR instruction over the
-    trajectory verbatim (no reformatting) \u2014 use it when you need a specific reply format
-    (a decision, a prediction). Costs ~1 completion.
-
-  surface.open(task) / surface.close(handle)
-    Open a persistent artifact you manage yourself (remember to close in a finally).
-    close is idempotent \u2014 closing an already-closed handle is a safe no-op.
-
-  listTools(handle): Promise<Array<{ name, description? }>>
-    The tools THIS task actually offers. TOOL SETS VARY PER TASK \u2014 if you restrict a
-    shot with \`tools\`, you MUST pick names from await listTools(handle); hardcoding
-    names from an example kills your shots on every task whose tools differ.
-
-Rules:
-- ALWAYS await every shot/critique/surface call \u2014 a floating promise that rejects
-  crashes the whole benchmark run.
-- Stay within ~budget total shots; every shot/critique spends from a conserved pool.
-- For a FRESH attempt OMIT \`messages\` entirely (never pass \`[]\` \u2014 an empty array is a
-  fresh conversation too, but be explicit). To CONTINUE, pass the previous
-  ShotResult.messages unchanged.
-- Return { score, resolved, completions, progression, shots } \u2014 score = the BEST checkpoint
-  you reached (keep-best, never final-state), progression = score after each shot.
-- The module must be EXACTLY this shape (no other imports, no commentary outside code):
-
-import { defineStrategy } from '@tangle-network/agent-runtime/loops'
-export default defineStrategy('your-strategy-name', async ({ surface, task, budget, shot, critique, listTools }) => {
-  // your composition (listTools comes from the destructured context \u2014 it is NOT a global)
-})
-`;
-function assertStrategyContract(code) {
-  const allowedImport = /^\s*import\s+\{[^}]*\}\s+from\s+['"]@tangle-network\/agent-runtime\/loops['"]/;
-  for (const line of code.split("\n")) {
-    if (/^\s*import\s/.test(line) && !allowedImport.test(line)) {
-      throw new Error(`authored code rejected: foreign import \u2014 ${line.trim().slice(0, 120)}`);
-    }
-  }
-  const banned = [
-    [/\brequire\s*\(/, "require()"],
-    [/\bimport\s*\(/, "dynamic import()"],
-    [/\beval\s*\(/, "eval()"],
-    [/new\s+Function\s*\(/, "new Function()"],
-    [/\bprocess\s*[.[]/, "process access"],
-    [/\bglobalThis\s*[.[]/, "globalThis access"],
-    [/\bfetch\s*\(/, "network access"],
-    [/child_process|node:fs|node:net|node:http|worker_threads/, "node builtin access"]
-  ];
-  for (const [re, what] of banned) {
-    if (re.test(code)) throw new Error(`authored code rejected: ${what}`);
-  }
-}
-async function requestAuthoredCode(opts, model) {
-  const res = await opts.chat.chat(
-    {
-      ...model ? { model } : {},
-      ...opts.temperature !== void 0 ? { temperature: opts.temperature } : {},
-      ...opts.maxTokens !== void 0 ? { maxTokens: opts.maxTokens } : {},
-      messages: [
-        {
-          role: "system",
-          content: "You are a senior engineer authoring optimization strategies for agent loops. Output exactly one fenced ```ts code block and nothing else."
-        },
-        {
-          role: "user",
-          content: `${opts.contract ?? strategyAuthorContract}
-
-BASELINE RESULTS on the "${opts.environmentName}" environment (budget=${opts.budget}):
-${opts.lossesJson}
-
-Author ONE new strategy that you expect to beat the baselines on THIS environment at the same budget. Use the losses to target the observed failure mode. Output only the module code block.`
-        }
-      ]
-    },
-    { ...opts.signal ? { signal: opts.signal } : {} }
-  );
-  const match = res.content.match(/```(?:ts|typescript)?\s*\n([\s\S]*?)```/);
-  if (!match?.[1]) {
-    throw new Error(
-      `authorStrategy: no code block in the author's reply (model=${model ?? "default"}): ${res.content.slice(0, 300)}`
-    );
-  }
-  return match[1];
-}
-async function authorStrategy(opts) {
-  let code;
-  try {
-    code = await requestAuthoredCode(opts, opts.model);
-  } catch (primaryError) {
-    if (!opts.fallbackModel) throw primaryError;
-    code = await requestAuthoredCode(opts, opts.fallbackModel);
-  }
-  assertStrategyContract(code);
-  mkdirSync2(opts.outDir, { recursive: true });
-  const file = join3(opts.outDir, `authored-${Date.now()}.mts`);
-  writeFileSync2(file, code);
-  const mod = await import(`file://${file}`);
-  if (!mod.default || typeof mod.default.driver !== "function" || !mod.default.name) {
-    throw new Error(`authorStrategy: ${file} does not export a default Strategy`);
-  }
-  return { strategy: mod.default, file, code };
-}
-
 // src/runtime/strategy-evolution.ts
-import { existsSync, readFileSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync, readFileSync, writeFileSync as writeFileSync4 } from "fs";
 import { gzipSync } from "zlib";
 function discriminatingMeans(report, fieldOrder) {
   const rows = report.perTask.filter((r) => {
@@ -3888,7 +4016,7 @@ async function runStrategyEvolution(cfg) {
   }
   const save = (state) => {
     if (cfg.checkpoint)
-      writeFileSync3(cfg.checkpoint.path, JSON.stringify({ ...state, fingerprint }, null, 1));
+      writeFileSync4(cfg.checkpoint.path, JSON.stringify({ ...state, fingerprint }, null, 1));
   };
   const bench = async (phase, tasks, strategies) => {
     await cfg.onPhase?.(phase);
@@ -5786,8 +5914,8 @@ function jjWorkspace(opts) {
 async function runInWorkspace(ws, body, opts = {}) {
   const { mkdtempSync: mkdtempSync2, rmSync: rmSync2 } = await import("fs");
   const { tmpdir: tmpdir3 } = await import("os");
-  const { join: join4 } = await import("path");
-  const dir = mkdtempSync2(join4(tmpdir3(), opts.tmpPrefix ?? "ws-run-"));
+  const { join: join5 } = await import("path");
+  const dir = mkdtempSync2(join5(tmpdir3(), opts.tmpPrefix ?? "ws-run-"));
   try {
     await ws.materialize(dir);
     const r = await body(dir);
@@ -5841,6 +5969,11 @@ export {
   renderReport,
   harvestCorpus,
   inProcessSandboxClient,
+  strategyAuthorContract,
+  assertStrategyContract,
+  authorStrategy,
+  loopAuthorContract,
+  authorLoop,
   createMcpEnvironment,
   assertTraceDerivedFindings,
   createScopeAnalyst,
@@ -5877,9 +6010,6 @@ export {
   printBenchmarkReport,
   SandboxRunAbortError,
   openSandboxRun,
-  strategyAuthorContract,
-  assertStrategyContract,
-  authorStrategy,
   discriminatingMeans,
   pickChampion,
   selectChampion,
@@ -5906,4 +6036,4 @@ export {
   computeFindingId,
   makeFinding2 as makeFinding
 };
-//# sourceMappingURL=chunk-VKVNDNG4.js.map
+//# sourceMappingURL=chunk-22HPUH77.js.map