@far-world-labs/verblets 0.7.1 → 0.7.3

package/dist/{shared-CNTi6iN9.js → shared-CHG_x1Br.js}

@@ -878,7 +878,7 @@ const Sl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     ...y,
     content: ko(y.content)
   }))), o !== void 0 && (d.max_completion_tokens = o), $l(d.model) || (i !== void 0 && (d.temperature = i), a !== void 0 && (d.top_p = a), c !== void 0 && (d.frequency_penalty = c), l !== void 0 && (d.presence_penalty = l));
-  const m = {
+  const h = {
     method: "POST",
     headers: {
       Authorization: `Bearer ${t}`,
@@ -886,7 +886,7 @@ const Sl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     },
     body: JSON.stringify(d)
   };
-  return { url: s, fetchOptions: m };
+  return { url: s, fetchOptions: h };
 }, Tl = (e) => e, El = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   buildRequest: Pl,
@@ -922,34 +922,34 @@ const Sl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     // eslint-disable-line no-unused-vars
     top_p: d,
     // eslint-disable-line no-unused-vars
-    frequency_penalty: m,
+    frequency_penalty: h,
     // eslint-disable-line no-unused-vars
     presence_penalty: y,
     // eslint-disable-line no-unused-vars
-    ...w
-  } = r, { instructions: f, messages: g } = Il(o), h = {
+    ...b
+  } = r, { instructions: f, messages: g } = Il(o), m = {
     model: i,
     input: g,
-    ...w
+    ...b
   };
-  f && (h.instructions = f), a && (h.max_output_tokens = a), l && (h.tools = l.map((S) => S.type === "function" ? {
+  f && (m.instructions = f), a && (m.max_output_tokens = a), l && (m.tools = l.map((v) => v.type === "function" ? {
     type: "function",
-    name: S.function.name,
-    description: S.function.description,
-    parameters: S.function.parameters,
-    strict: S.function.strict
-  } : S), u && (h.tool_choice = u));
-  const b = kl(c);
-  Object.assign(h, b);
-  const v = {
+    name: v.function.name,
+    description: v.function.description,
+    parameters: v.function.parameters,
+    strict: v.function.strict
+  } : v), u && (m.tool_choice = u));
+  const w = kl(c);
+  Object.assign(m, w);
+  const S = {
     method: "POST",
     headers: {
       Authorization: `Bearer ${t}`,
       "Content-Type": "application/json"
     },
-    body: JSON.stringify(h)
+    body: JSON.stringify(m)
   };
-  return { url: s, fetchOptions: v };
+  return { url: s, fetchOptions: S };
 }, Ol = (e) => {
   const t = e.output || [], n = t.find((i) => i.type === "message"), r = t.filter((i) => i.type === "function_call");
   let s = "";
@@ -1082,29 +1082,29 @@ const Sl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     // Strip unsupported params
     top_p: d,
     // eslint-disable-line no-unused-vars
-    frequency_penalty: m,
+    frequency_penalty: h,
     // eslint-disable-line no-unused-vars
     presence_penalty: y,
     // eslint-disable-line no-unused-vars
-    ...w
-  } = r, { systemText: f, messages: g } = Nl(o), h = g.map((x) => ({
+    ...b
+  } = r, { systemText: f, messages: g } = Nl(o), m = g.map((x) => ({
     ...x,
     content: Ao(x.content)
-  })), b = {
+  })), w = {
     model: i,
-    messages: h,
+    messages: m,
     max_tokens: a || 4096,
-    ...w
+    ...b
   };
-  f && (b.system = f), c !== void 0 && (b.temperature = c);
-  const v = Dl(u);
-  if (v) {
-    b.tools = v;
+  f && (w.system = f), c !== void 0 && (w.temperature = c);
+  const S = Dl(u);
+  if (S) {
+    w.tools = S;
     const x = jl(p);
-    x && (b.tool_choice = x);
+    x && (w.tool_choice = x);
   }
-  const S = Bl(l);
-  Object.assign(b, S);
+  const v = Bl(l);
+  Object.assign(w, v);
   const P = {
     method: "POST",
     headers: {
@@ -1112,7 +1112,7 @@ const Sl = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
       "anthropic-version": Cl,
       "Content-Type": "application/json"
     },
-    body: JSON.stringify(b)
+    body: JSON.stringify(w)
   };
   return { url: s, fetchOptions: P };
 }, Be = (e) => {
@@ -1732,9 +1732,9 @@ class Sn {
     const { tools: n, toolChoice: r, modelName: s, prompt: o, systemPrompt: i, responseFormat: a } = t, c = this.getModel(s), l = i ?? c.systemPrompt;
     let u = { prompt: o };
     if (/chat|responses|messages/.test(c.endpoint)) {
-      const m = { role: "user", content: o };
+      const h = { role: "user", content: o };
       u = {
-        messages: [...l ? [{ role: "system", content: l }] : [], m],
+        messages: [...l ? [{ role: "system", content: l }] : [], h],
         tools: n,
         tool_choice: n && !r ? "auto" : r
       };
@@ -1745,10 +1745,10 @@ class Sn {
     };
     if (a)
       if (a.json_schema?.schema?.$schema) {
-        const m = { ...a.json_schema.schema };
-        delete m.$schema, d.responseFormat = {
+        const h = { ...a.json_schema.schema };
+        delete h.$schema, d.responseFormat = {
           ...a,
-          json_schema: { ...a.json_schema, schema: m }
+          json_schema: { ...a.json_schema, schema: h }
         };
       } else
         d.responseFormat = a;
@@ -1884,7 +1884,7 @@ function op(e, { forceHTML: t = !1, name: n, tag: r = "data", title: s, fit: o =
   const i = typeof e == "string" ? e : JSON.stringify(e, null, 2);
   return /\n/.test(i) || t || n ? $(i, { name: n, tag: r, title: s, fit: o }) : Qo(i, { title: s });
 }
-const ip = "0.7.1", ap = {
+const ip = "0.7.3", ap = {
   version: ip
 }, In = ap.version, fe = Object.freeze({
   /** Decisions, phases, meaningful outcomes. Audit-log-shaped. */
@@ -2012,7 +2012,7 @@ function dp(e, t) {
 function I(e, t, { operation: n, now: r, traceId: s, spanId: o, parentSpanId: i, eventFilter: a } = {}) {
   const c = dp(t, a), l = r, u = {};
   s && (u.traceId = s), o && (u.spanId = o), i && (u.parentSpanId = i);
-  const d = { step: e, operation: n, ...u, ...{ libraryName: "verblets", libraryVersion: In } }, m = {
+  const d = { step: e, operation: n, ...u, ...{ libraryName: "verblets", libraryVersion: In } }, h = {
     start() {
       xe(c, { kind: fe.telemetry, ...d, event: De.start });
     },
@@ -2044,7 +2044,7 @@ function I(e, t, { operation: n, now: r, traceId: s, spanId: o, parentSpanId: i,
       xe(c, { kind: fe.event, ...d, event: k.uncertainty, ...y });
     },
     complete(y = {}) {
-      const { durationMs: w, ...f } = y, g = w ?? (l ? Date.now() - l.getTime() : void 0);
+      const { durationMs: b, ...f } = y, g = b ?? (l ? Date.now() - l.getTime() : void 0);
       xe(c, {
         kind: fe.telemetry,
         ...d,
@@ -2054,32 +2054,32 @@ function I(e, t, { operation: n, now: r, traceId: s, spanId: o, parentSpanId: i,
         ...f
       });
     },
-    error(y, w = {}) {
-      const { durationMs: f, ...g } = w, h = f ?? (l ? Date.now() - l.getTime() : void 0);
+    error(y, b = {}) {
+      const { durationMs: f, ...g } = b, m = f ?? (l ? Date.now() - l.getTime() : void 0);
       xe(c, {
         kind: fe.telemetry,
         ...d,
         event: De.error,
         statusCode: Zt.error,
-        ...h !== void 0 && { durationMs: h },
+        ...m !== void 0 && { durationMs: m },
         error: { message: y.message, type: y.constructor?.name },
         ...g
       });
     },
     batch(y) {
-      let w = 0;
+      let b = 0;
       function f(g) {
-        return w += g, f.count = w, m.progress({
+        return b += g, f.count = b, h.progress({
           event: W.batchComplete,
           totalItems: y,
-          processedItems: w,
+          processedItems: b,
           batchSize: g
-        }), w;
+        }), b;
       }
       return f.count = 0, f;
     }
   };
-  return m;
+  return h;
 }
 function L(e, t) {
   if (!(!e || typeof e != "function"))
@@ -2221,34 +2221,34 @@ const xp = (e) => {
     onAfterRequest: u = Sp,
     onBeforeRequest: p = vp,
     shapeOutput: d = wp,
-    skipResponseParse: m,
+    skipResponseParse: h,
     unwrapValues: y,
-    unwrapCollections: w
-  } = t, f = en ? { ...en, ...t.policy } : t.policy, g = f ? { ...t, policy: f } : t, h = await re("forceQuery", g, !1), b = { ...Oo(c) };
+    unwrapCollections: b
+  } = t, f = en ? { ...en, ...t.policy } : t.policy, g = f ? { ...t, policy: f } : t, m = await re("forceQuery", g, !1), w = { ...Oo(c) };
   for (const B of $p) {
     const X = await re(B, g, void 0);
-    X !== void 0 && (b[B] = X);
+    X !== void 0 && (w[B] = X);
   }
   for (const B of Qe) {
     const X = await re(B, g, void 0);
-    X !== void 0 && (b[B] = X);
+    X !== void 0 && (w[B] = X);
   }
-  const v = Date.now(), S = {};
+  const S = Date.now(), v = {};
   let P = !1;
-  b.negotiate && (Object.assign(S, b.negotiate), P = !0);
+  w.negotiate && (Object.assign(v, w.negotiate), P = !0);
   for (const B of Qe)
-    B in b && (S[B] = b[B], P = !0);
-  const x = b.modelName;
+    B in w && (v[B] = w[B], P = !0);
+  const x = w.modelName;
   let E, O;
-  P ? (E = n.negotiateModel(x, S), O = E?.name) : (O = b.modelName, E = n.getModel(O));
-  const R = I("llm", t.onProgress, t), j = P ? Ge.negotiated : b.modelName ? Ge.config : Ge.default;
+  P ? (E = n.negotiateModel(x, v), O = E?.name) : (O = w.modelName, E = n.getModel(O));
+  const R = I("llm", t.onProgress, t), j = P ? Ge.negotiated : w.modelName ? Ge.config : Ge.default;
   R.metrics({
     event: ye.llmModel,
     model: O,
     provider: E?.provider || "openai",
     source: j,
-    negotiation: P ? S : void 0,
-    preferred: b.modelName
+    negotiation: P ? v : void 0,
+    preferred: w.modelName
   });
   const F = Array.isArray(e) ? e.reduce((B, X) => B + (X.type === "text" ? X.text.length : 0), 0) : e.length;
   l?.info && l.info({
@@ -2258,7 +2258,7 @@ const xp = (e) => {
   });
   const V = n.getDefaultModel(), Y = E?.apiUrl || V?.apiUrl, H = E?.apiKey || V?.apiKey, ee = n.getRequestConfig({
     prompt: e,
-    ...b,
+    ...w,
     modelName: O
   }), pe = E.structuredOutput === !1 && !!ee.responseFormat;
   let G = ee;
@@ -2285,8 +2285,8 @@ ${X}`, ve = ee.messages?.map(
   });
   try {
     let B = Z;
-    if (!Z || h) {
-      const le = b.requestTimeout || n.getModel(O).requestTimeout, Ne = new Lo(le), Ue = E.provider || "openai", nr = Yl(Ue), { url: Dc, fetchOptions: rr } = nr.buildRequest(
+    if (!Z || m) {
+      const le = w.requestTimeout || n.getModel(O).requestTimeout, Ne = new Lo(le), Ue = E.provider || "openai", nr = Yl(Ue), { url: Dc, fetchOptions: rr } = nr.buildRequest(
         Y,
         H,
         E.endpoint,
@@ -2331,9 +2331,9 @@ ${X}`, ve = ee.messages?.map(
       }
     }
     const X = d(B, ee, {
-      skipResponseParse: m,
+      skipResponseParse: h,
       unwrapValues: y,
-      unwrapCollections: w
+      unwrapCollections: b
     });
     u({
       debugResult: i,
@@ -2344,7 +2344,7 @@ ${X}`, ve = ee.messages?.map(
       resultShaped: X
     }), l?.info && l.info({
       event: "llm:end",
-      duration: Date.now() - v,
+      duration: Date.now() - S,
       cached: !!Z,
       model: O
     });
@@ -2371,7 +2371,7 @@ ${X}`, ve = ee.messages?.map(
       ...ce
     }), R.measure({
       metric: ge.llmDuration,
-      value: Date.now() - v,
+      value: Date.now() - S,
       ...ce
     }), X;
   } catch (B) {
@@ -2390,7 +2390,7 @@ ${X}`, ve = ee.messages?.map(
       }
     }), R.measure({
       metric: ge.llmDuration,
-      value: Date.now() - v,
+      value: Date.now() - S,
       ...X
     }), B;
   }
@@ -2547,8 +2547,8 @@ ${Xe}`;
   maxWords: a
 } = {}) => {
   const c = `Tone: ${t.join(", ")}`, l = `Vocabulary: ${n.join(", ")}`, u = `Sentence structure: ${r.join(", ")}`, p = `Point of view: ${s.join(", ")}`, d = `Use between ${i} and ${a ?? "any number"} of words`;
-  let m = "";
-  return o > 0.5 && (m = "Completely reshape the ideas here, don't stick with the original structure. Don't change the meaning of the content though."), `Rewrite the following content:
+  let h = "";
+  return o > 0.5 && (h = "Completely reshape the ideas here, don't stick with the original structure. Don't change the meaning of the content though."), `Rewrite the following content:
 \`\`\`
 ${e}
 \`\`\`
@@ -2559,7 +2559,7 @@ ${l}
 ${u}
 ${p}
 ${d}
-${m}
+${h}
 `;
 }, oi = (e = 10) => `Keep the output within ${e} tokens.`, ii = (e, t = "") => `Summarize the content below according to the instructions provided.
 
@@ -2800,7 +2800,7 @@ async function M(e, t = {}) {
       overloadBackoffCeiling: t.overloadBackoffCeiling
     }
   };
-  let p = 0, d = 0, m = new Error("Nothing to run"), y;
+  let p = 0, d = 0, h = new Error("Nothing to run"), y;
   const f = I(n || "retry", c, r);
   c && f.progress({
     event: W.start,
@@ -2809,24 +2809,24 @@ async function M(e, t = {}) {
     retryOnAll: i,
     retryMode: a
   });
-  const g = (b) => new Promise((v, S) => {
+  const g = (w) => new Promise((S, v) => {
     if (l?.aborted) {
-      S(Ot(l));
+      v(Ot(l));
       return;
     }
-    const P = setTimeout(v, b);
+    const P = setTimeout(S, w);
     l?.addEventListener(
       "abort",
       () => {
-        clearTimeout(P), S(Ot(l));
+        clearTimeout(P), v(Ot(l));
       },
       { once: !0 }
     );
-  }), h = async (b, v) => {
-    let S = b;
-    for (; S > 0; ) {
-      const P = Math.min(S, Sd);
-      await g(P), S -= P, S > 0 && f.progress({ ...v, remaining: S, elapsed: b - S });
+  }), m = async (w, S) => {
+    let v = w;
+    for (; v > 0; ) {
+      const P = Math.min(v, Sd);
+      await g(P), v -= P, v > 0 && f.progress({ ...S, remaining: v, elapsed: w - v });
     }
   };
   e: for (; p < s; ) {
@@ -2853,68 +2853,68 @@ async function M(e, t = {}) {
         y = x;
       }
     }
-    m = y;
-    const b = fr(y);
-    if (y = void 0, b.category === U.authFailure)
+    h = y;
+    const w = fr(y);
+    if (y = void 0, w.category === U.authFailure)
       throw f.progress({
         event: W.error,
         attemptNumber: p + 1,
         maxAttempts: s,
-        error: m.message,
+        error: h.message,
         category: U.authFailure,
         final: !0
-      }), m;
+      }), h;
     if (a !== qe.strict && d < vd) {
-      if (b.category === U.rateLimited) {
-        const x = b.retryAfterMs || Math.min(u.rateLimitCeiling, o * Math.pow(2, d));
+      if (w.category === U.rateLimited) {
+        const x = w.retryAfterMs || Math.min(u.rateLimitCeiling, o * Math.pow(2, d));
         if (x <= u.rateLimitCeiling) {
           const E = {
             event: W.providerWait,
             category: U.rateLimited,
-            provider: m.provider,
+            provider: h.provider,
             delay: x,
             attempt: d + 1,
             resumeAt: new Date(Date.now() + x).toISOString(),
-            error: { message: m.message, httpStatus: m.httpStatus }
+            error: { message: h.message, httpStatus: h.httpStatus }
           };
-          f.progress(E), await h(x, E), d++, f.progress({
+          f.progress(E), await m(x, E), d++, f.progress({
             event: W.providerRetry,
             category: U.rateLimited,
-            provider: m.provider,
+            provider: h.provider,
             attempt: d
           }), f.measure({
             metric: ge.providerWait,
             value: x,
             category: U.rateLimited,
-            provider: m.provider
+            provider: h.provider
           });
           continue e;
         }
       }
-      if (b.category === U.creditExhausted && u.creditRetryInterval > 0) {
+      if (w.category === U.creditExhausted && u.creditRetryInterval > 0) {
         let x = 0, E = 0;
         for (; ; ) {
           x++;
           const O = u.creditRetryInterval, R = {
             event: W.providerWait,
             category: U.creditExhausted,
-            provider: m.provider,
+            provider: h.provider,
             delay: O,
             attempt: x,
             elapsed: E,
-            error: { message: m.message, httpStatus: m.httpStatus }
+            error: { message: h.message, httpStatus: h.httpStatus }
           };
-          f.progress(R), await h(O, R), E += O, f.progress({
+          f.progress(R), await m(O, R), E += O, f.progress({
             event: W.providerRetry,
             category: U.creditExhausted,
-            provider: m.provider,
+            provider: h.provider,
             attempt: x,
             elapsed: E
           }), f.measure({
             metric: ge.providerWait,
             value: O,
             category: U.creditExhausted,
-            provider: m.provider
+            provider: h.provider
           });
           try {
             const j = await e();
@@ -2932,59 +2932,59 @@ async function M(e, t = {}) {
               y = j, d += x;
               continue e;
             }
-            m = j;
+            h = j;
           }
         }
       }
-      if (b.category === U.overloaded) {
+      if (w.category === U.overloaded) {
         const x = Math.min(
           u.overloadBackoffCeiling,
           o * Math.pow(2, d)
         ), E = {
           event: W.providerWait,
           category: U.overloaded,
-          provider: m.provider,
+          provider: h.provider,
           delay: x,
           attempt: d + 1,
           resumeAt: new Date(Date.now() + x).toISOString(),
-          error: { message: m.message, httpStatus: m.httpStatus }
+          error: { message: h.message, httpStatus: h.httpStatus }
         };
-        f.progress(E), await h(x, E), d++, f.progress({
+        f.progress(E), await m(x, E), d++, f.progress({
           event: W.providerRetry,
           category: U.overloaded,
-          provider: m.provider,
+          provider: h.provider,
           attempt: d
         }), f.measure({
           metric: ge.providerWait,
           value: x,
           category: U.overloaded,
-          provider: m.provider
+          provider: h.provider
         });
         continue e;
       }
-      if (b.category === U.serverError) {
+      if (w.category === U.serverError) {
         const x = Math.min(
           u.overloadBackoffCeiling,
           o * Math.pow(2, d)
         ), E = {
           event: W.providerWait,
           category: U.serverError,
-          provider: m.provider,
+          provider: h.provider,
           delay: x,
           attempt: d + 1,
-          error: { message: m.message, httpStatus: m.httpStatus }
+          error: { message: h.message, httpStatus: h.httpStatus }
         };
-        f.progress(E), await h(x, E), d++, f.progress({
+        f.progress(E), await m(x, E), d++, f.progress({
           event: W.providerRetry,
           category: U.serverError,
-          provider: m.provider,
+          provider: h.provider,
           attempt: d
         });
         continue e;
       }
     }
-    const v = m.httpStatus ?? m.response?.status, S = i || v === 429 || v >= 500 && v < 600, P = !S || p >= s - 1;
-    if (S && p < s - 1) {
+    const S = h.httpStatus ?? h.response?.status, v = i || S === 429 || S >= 500 && S < 600, P = !v || p >= s - 1;
+    if (v && p < s - 1) {
       const x = o * p;
       if (c) {
         const E = {
@@ -2992,7 +2992,7 @@ async function M(e, t = {}) {
           attemptNumber: p + 1,
           maxAttempts: s,
           delay: x,
-          error: m.message
+          error: h.message
         };
         p + 1 < s - 1 && (E.nextAttempt = p + 2), f.progress(E);
       }
@@ -3002,9 +3002,9 @@ async function M(e, t = {}) {
         maxAttempts: s,
         outcome: At.error,
         error: {
-          message: m.message,
-          httpStatus: m.httpStatus,
-          type: m.errorType
+          message: h.message,
+          httpStatus: h.httpStatus,
+          type: h.errorType
         }
       }), f.measure({
         metric: ge.retryDelay,
@@ -3017,7 +3017,7 @@ async function M(e, t = {}) {
         event: W.error,
         attemptNumber: p + 1,
         maxAttempts: s,
-        error: m.message,
+        error: h.message,
         totalAttempts: p + 1,
         final: !0
       }), f.metrics({
@@ -3026,13 +3026,13 @@ async function M(e, t = {}) {
         maxAttempts: s,
         outcome: At.exhaust,
         error: {
-          message: m.message,
-          httpStatus: m.httpStatus,
-          type: m.errorType
+          message: h.message,
+          httpStatus: h.httpStatus,
+          type: h.errorType
         }
       });
   }
-  throw m;
+  throw h;
 }
 const xd = {
   type: "object",
@@ -3143,51 +3143,51 @@ async function Q(e, t, n = {}) {
   if (!Array.isArray(e) || e.length === 0)
     return [];
   if (!(s !== void 0 && s < r)) {
-    const w = [], f = Ce(r)(e);
+    const b = [], f = Ce(r)(e);
     let g = 0;
-    for (const h of f) {
+    for (const m of f) {
       if (c?.aborted)
         throw c.reason ?? new Error("The operation was aborted.");
       if (a === z.resilient) {
-        const b = await Promise.allSettled(
-          h.map((v, S) => t(v, g + S))
+        const w = await Promise.allSettled(
+          m.map((S, v) => t(S, g + v))
         );
-        w.push(...b.map((v, S) => v.status === "fulfilled" ? v.value : h[S]));
+        b.push(...w.map((S, v) => S.status === "fulfilled" ? S.value : m[v]));
       } else {
-        const b = await Promise.all(
-          h.map((v, S) => t(v, g + S))
+        const w = await Promise.all(
+          m.map((S, v) => t(S, g + v))
         );
-        w.push(...b);
+        b.push(...w);
       }
-      g += h.length;
+      g += m.length;
     }
-    return w;
+    return b;
   }
   const u = Math.max(1, s), p = [], d = Cd(Ad);
-  let m = r, y = 0;
+  let h = r, y = 0;
   for (; y < e.length; ) {
     if (c?.aborted)
       throw c.reason ?? new Error("The operation was aborted.");
-    const w = e.slice(y, y + m), f = Date.now();
+    const b = e.slice(y, y + h), f = Date.now();
     let g = 0;
     if (a === z.resilient) {
-      const v = await Promise.allSettled(
-        w.map((S, P) => t(S, y + P))
+      const S = await Promise.allSettled(
+        b.map((v, P) => t(v, y + P))
       );
-      g = v.filter((S) => S.status === "rejected").length, p.push(...v.map((S, P) => S.status === "fulfilled" ? S.value : w[P]));
+      g = S.filter((v) => v.status === "rejected").length, p.push(...S.map((v, P) => v.status === "fulfilled" ? v.value : b[P]));
     } else {
-      const v = await Promise.all(
-        w.map((S, P) => t(S, y + P))
+      const S = await Promise.all(
+        b.map((v, P) => t(v, y + P))
       );
-      p.push(...v);
+      p.push(...S);
     }
-    const h = Date.now() - f, b = g / w.length;
-    d.record(h, b), m = jd(
-      m,
+    const m = Date.now() - f, w = g / b.length;
+    d.record(m, w), h = jd(
+      h,
       d,
       { min: u, max: r },
       { latency: o, error: i }
-    ), y += w.length;
+    ), y += b.length;
   }
   return p;
 }
@@ -3348,10 +3348,10 @@ ${r}` : n, o = A(yr, t), i = I(yr, o.onProgress, o);
   try {
     const u = Wd(s), p = br(s);
     if (!c) {
-      const v = await Ct(p, o);
-      return i.emit({ event: k.output, value: v }), i.complete({ outcome: T.success }), v;
+      const S = await Ct(p, o);
+      return i.emit({ event: k.output, value: S }), i.complete({ outcome: T.success }), S;
     }
-    const [d, m] = await Q(
+    const [d, h] = await Q(
       [
         () => _(u, {
           ...o,
@@ -3363,30 +3363,30 @@ ${r}` : n, o = A(yr, t), i = I(yr, o.onProgress, o);
           onProgress: L(o.onProgress, "extract")
         })
       ],
-      (v) => v(),
+      (S) => S(),
       { maxParallel: 2, abortSignal: o?.abortSignal }
     ), y = d.length > 0 ? d : ["The result is a valid date"];
-    if (!m) {
+    if (!h) {
       i.emit({ event: k.output, value: void 0 }), i.complete({ outcome: T.success });
       return;
     }
-    let w = m, f = e, g = 0;
-    const h = i.batch(a), b = await M(
+    let b = h, f = e, g = 0;
+    const m = i.batch(a), w = await M(
       async () => {
         g += 1, i.emit({
           event: k.step,
           stepName: "validation-attempt",
           attempt: g,
           maxAttempts: a,
-          currentDate: w?.toISOString()
+          currentDate: b?.toISOString()
         });
-        const v = await Kd(w, y, o);
-        if (h(1), v.passed)
-          return w;
-        f = `${s} The previous answer (${w.toISOString()}) failed to satisfy: "${v.failedCheck}". Try again.`;
-        const S = br(f), P = await Ct(S, o);
-        if (!P || (w = P, g >= a))
-          return l ? w : void 0;
+        const S = await Kd(b, y, o);
+        if (m(1), S.passed)
+          return b;
+        f = `${s} The previous answer (${b.toISOString()}) failed to satisfy: "${S.failedCheck}". Try again.`;
+        const v = br(f), P = await Ct(v, o);
+        if (!P || (b = P, g >= a))
+          return l ? b : void 0;
         throw new Error("Retrying after validation failure");
       },
       {
@@ -3396,7 +3396,7 @@ ${r}` : n, o = A(yr, t), i = I(yr, o.onProgress, o);
         retryOnAll: !0
       }
     );
-    return i.emit({ event: k.output, value: b }), i.complete({ outcome: T.success }), b;
+    return i.emit({ event: k.output, value: w }), i.complete({ outcome: T.success }), w;
   } catch (u) {
     throw i.error(u), u;
   }
@@ -3735,7 +3735,7 @@ ${$(i, { tag: "classification-instructions" })}` : "", u = {
 - Salience should reflect absolute significance, not relative standing`
   }, p = s !== "statistical" ? `
 
-Threshold derivation strategy: ${s}${u[s] || u.fixed}` : "", m = {
+Threshold derivation strategy: ${s}${u[s] || u.fixed}` : "", h = {
     low: `
 
 Classification posture: conservative. Prefer false negatives over false positives. Only flag items with strong, unambiguous signals. Set severity and salience thresholds high — routine items should classify as none/routine unless clearly elevated.`,
@@ -3744,7 +3744,7 @@ Classification posture: conservative. Prefer false negatives over false positive
 Classification posture: sensitive. Prefer false positives over false negatives. Flag items with even weak or ambiguous signals. Set severity and salience thresholds low to catch edge cases — when in doubt, classify higher.`
   }[o] || "", y = `Analyze these corpus scan statistics and generate a calibration specification.
 
-${$(a, { tag: "scan-statistics" })}${l}${p}${m}
+${$(a, { tag: "scan-statistics" })}${l}${p}${h}
 
 Provide a JSON object with exactly four string properties:
 - corpusProfile: Overview of the corpus sensitivity landscape — what categories appear, how prevalent, overall risk profile
@@ -3754,7 +3754,7 @@ Provide a JSON object with exactly four string properties:
 
 IMPORTANT: Each property must be a simple string value, not a nested object or array.`;
   try {
-    const w = await M(
+    const b = await M(
       () => _(y, {
         ...n,
         systemPrompt: c,
@@ -3768,9 +3768,9 @@ IMPORTANT: Each property must be a simple string value, not a nested object or a
         config: n
       }
     );
-    return r.complete({ outcome: T.success }), w;
-  } catch (w) {
-    throw r.error(w), w;
+    return r.complete({ outcome: T.success }), b;
+  } catch (b) {
+    throw r.error(b), b;
   }
 }
 async function _m(e, t, n = {}) {
@@ -4036,26 +4036,26 @@ async function Dm(e, t, n, r) {
       dimensions: n.map((g) => g.name)
     }), a?.length) {
       const g = () => {
-        const h = {};
-        for (const b of n) {
-          const v = l.get(b.name);
-          h[b.name] = v.selection ?? v.candidates[0];
+        const m = {};
+        for (const w of n) {
+          const S = l.get(w.name);
+          m[w.name] = S.selection ?? S.candidates[0];
         }
-        return h;
+        return m;
       };
-      for (const h of a) {
-        const b = g(), v = h.enforce(b);
-        if (v)
-          for (const [S, P] of Object.entries(v)) {
-            const x = n.find((F) => F.name === S);
+      for (const m of a) {
+        const w = g(), S = m.enforce(w);
+        if (S)
+          for (const [v, P] of Object.entries(S)) {
+            const x = n.find((F) => F.name === v);
             if (!x) continue;
             const E = x.values.indexOf(P);
             if (E < 0) continue;
-            const O = l.get(S);
+            const O = l.get(v);
             if (E <= O.floorIdx) continue;
             const R = x.values.slice(E);
             let j;
-            R.length <= 1 ? j = R[0] ?? x.values[x.values.length - 1] : O.selection !== void 0 && R.includes(O.selection) ? j = O.selection : j = P, l.set(S, {
+            R.length <= 1 ? j = R[0] ?? x.values[x.values.length - 1] : O.selection !== void 0 && R.includes(O.selection) ? j = O.selection : j = P, l.set(v, {
               ...O,
               floorIdx: E,
               candidates: R,
@@ -4071,32 +4071,32 @@ async function Dm(e, t, n, r) {
     if (u.length === 0)
       return o.complete({ outcome: T.success, dimensions: n.length }), n.map((g) => l.get(g.name).selection);
     const p = u.map((g) => {
-      const h = l.get(g.name), b = h.mayResults.filter((v) => h.candidates.includes(v.resolved));
-      return { dim: g, candidates: h.candidates, viableMays: b };
-    }), d = Lm(p, i), m = {}, y = {};
-    for (const { dim: g, candidates: h } of p)
-      y[g.name] = Object.fromEntries(h.map((b) => [String(b), b])), m[g.name] = {
+      const m = l.get(g.name), w = m.mayResults.filter((S) => m.candidates.includes(S.resolved));
+      return { dim: g, candidates: m.candidates, viableMays: w };
+    }), d = Lm(p, i), h = {}, y = {};
+    for (const { dim: g, candidates: m } of p)
+      y[g.name] = Object.fromEntries(m.map((w) => [String(w), w])), h[g.name] = {
         type: "string",
-        enum: h.map(String),
+        enum: m.map(String),
         description: `Selected value for ${g.name}`
       };
-    const w = {
+    const b = {
       type: "object",
-      properties: m,
+      properties: h,
       required: u.map((g) => g.name),
       additionalProperties: !1
     }, f = await M(
       () => _(d, {
         ...s,
-        responseFormat: C("value_arbitrate_multi", w)
+        responseFormat: C("value_arbitrate_multi", b)
       }),
       { label: "value-arbitrate", config: s }
     );
     for (const g of u) {
-      const h = l.get(g.name), b = f?.[g.name], v = y[g.name]?.[b];
+      const m = l.get(g.name), w = f?.[g.name], S = y[g.name]?.[w];
       l.set(g.name, {
-        ...h,
-        selection: v !== void 0 ? v : h.candidates[0]
+        ...m,
+        selection: S !== void 0 ? S : m.candidates[0]
       });
     }
     return o.complete({
@@ -4121,25 +4121,25 @@ async function Bi(e, t, n, r = {}) {
   try {
     const a = await Q(
       e,
-      async (b) => ({
-        name: b.name,
-        strictness: b.strictness,
-        weight: b.weight,
-        prompt: b.prompt,
-        resolved: await b.value(t)
+      async (w) => ({
+        name: w.name,
+        strictness: w.strictness,
+        weight: w.weight,
+        prompt: w.prompt,
+        resolved: await w.value(t)
       }),
       { maxParallel: 5, errorPosture: z.resilient, abortSignal: s.abortSignal }
-    ), c = a.filter((b) => b.strictness === "must"), l = a.filter((b) => b.strictness === "may"), u = c.length > 0 ? Li(c, n) : -1, p = u >= 0 ? n.slice(u) : [...n];
+    ), c = a.filter((w) => w.strictness === "must"), l = a.filter((w) => w.strictness === "may"), u = c.length > 0 ? Li(c, n) : -1, p = u >= 0 ? n.slice(u) : [...n];
     if (p.length === 0)
       return o.complete({ outcome: T.success }), n[n.length - 1];
     if (p.length === 1)
       return o.complete({ outcome: T.success }), p[0];
-    const d = l.filter((b) => p.includes(b.resolved)), m = [...new Set(d.map((b) => b.resolved))];
-    if (m.length === 1)
-      return o.complete({ outcome: T.success }), m[0];
+    const d = l.filter((w) => p.includes(w.resolved)), h = [...new Set(d.map((w) => w.resolved))];
+    if (h.length === 1)
+      return o.complete({ outcome: T.success }), h[0];
     if (d.length === 0)
       return o.complete({ outcome: T.success }), p[0];
-    const y = Mm(d, p, i), w = Object.fromEntries(p.map((b) => [String(b), b])), f = {
+    const y = Mm(d, p, i), b = Object.fromEntries(p.map((w) => [String(w), w])), f = {
       type: "object",
       properties: {
         value: {
@@ -4156,8 +4156,8 @@ async function Bi(e, t, n, r = {}) {
         responseFormat: C("value_arbitrate", f)
       }),
       { label: "value-arbitrate", config: s }
-    ), h = w[g];
-    return o.complete({ outcome: T.success }), h !== void 0 ? h : p[0];
+    ), m = b[g];
+    return o.complete({ outcome: T.success }), m !== void 0 ? m : p[0];
   } catch (a) {
     throw o.error(a), a;
   }
@@ -4652,10 +4652,10 @@ async function be(e, t, n) {
   if (typeof t == "function")
     r = t;
   else {
-    const { text: m, context: y } = N(t, []);
-    r = y ? `${m}
+    const { text: h, context: y } = N(t, []);
+    r = y ? `${h}
 
-${y}` : m;
+${y}` : h;
   }
   const s = A(kr, n), o = I(kr, s.onProgress, s);
   o.start();
@@ -4677,9 +4677,9 @@ ${y}` : m;
   }), !e || e.length === 0)
     return o.complete({ outcome: T.success }), [];
   try {
-    const m = je(i, e, a), y = ah(e, r, m), w = l ?? C("list_result", ch), f = {
+    const h = je(i, e, a), y = ah(e, r, h), b = l ?? C("list_result", ch), f = {
       ...c && { maxTokens: c },
-      responseFormat: w
+      responseFormat: b
     };
     p?.debug && p.debug("Calling llm", {
       promptLength: y.length,
@@ -4700,18 +4700,18 @@ ${y}` : m;
       hasAbortSignal: !!g.abortSignal,
       modelKeys: Object.keys(f)
     });
-    const h = await _(y, g);
+    const m = await _(y, g);
     return p?.debug && p.debug("LLM response received", {
-      outputType: Array.isArray(h) ? "array" : typeof h,
-      outputLength: Array.isArray(h) ? h.length : void 0
-    }), o.complete({ outcome: T.success }), h;
-  } catch (m) {
+      outputType: Array.isArray(m) ? "array" : typeof m,
+      outputLength: Array.isArray(m) ? m.length : void 0
+    }), o.complete({ outcome: T.success }), m;
+  } catch (h) {
     throw p?.error && p.error("LLM request failed in listBatch", {
-      error: m.message,
+      error: h.message,
       llmConfig: u,
       promptLength: e?.length,
       itemCount: e?.length
-    }), o.error(m), m;
+    }), o.error(h), h;
   }
 }
 be.knownTexts = [];
@@ -4751,29 +4751,30 @@ const Or = async function(e, t, n = {}) {
   return await Q(
     l,
     async ({ items: p, startIndex: d }) => {
-      const m = je(n.listStyle, p, n.autoModeThreshold), y = lh(
+      const h = je(n.listStyle, p, n.autoModeThreshold), y = lh(
         t,
         p,
-        m,
+        h,
         a,
         n.responseFormat
       );
       try {
-        const w = {
+        const b = {
           ...n,
           onProgress: L(o, "map:list-batch"),
-          listStyle: m
-        }, f = await M(() => be(p, y, w), {
+          listStyle: h
+        }, f = await M(() => be(p, y, b), {
           label: "map:batch",
           config: n
         });
         if (!Array.isArray(f))
           throw new Error(`Expected array from listBatch, got: ${typeof f}`);
-        f.forEach((g, h) => {
-          c[d + h] = g;
-        }), u(p.length);
-      } catch (w) {
-        if (w.name === "AbortError" || n?.abortSignal?.aborted || s === z.strict) throw w;
+        const g = Math.min(f.length, p.length);
+        for (let m = 0; m < g; m++)
+          c[d + m] = f[m];
+        u(p.length);
+      } catch (b) {
+        if (b.name === "AbortError" || n?.abortSignal?.aborted || s === z.strict) throw b;
         u(p.length);
       }
     },
@@ -4800,28 +4801,32 @@ const Or = async function(e, t, n = {}) {
       _batchDone: u,
       _context: s
     });
-    for (let w = 1; w < a; w += 1) {
+    for (let b = 1; b < a; b += 1) {
       const f = [], g = [];
-      if (p.forEach((b, v) => {
-        b === rn && (f.push(v), g.push(e[v]));
+      if (p.forEach((w, S) => {
+        w === rn && (f.push(S), g.push(e[S]));
       }), g.length === 0) break;
       (await Or(g, r, {
         ...o,
         maxAttempts: a,
         maxParallel: c,
         _context: s
-      })).forEach((b, v) => {
-        p[f[v]] = b;
+      })).forEach((w, S) => {
+        p[f[S]] = w;
       });
     }
     let d = 0;
-    for (let w = 0; w < p.length; w++)
-      p[w] === rn && (p[w] = e[w], d++);
-    const m = d > 0 ? T.partial : T.success, y = {
+    for (let b = 0; b < p.length; b++)
+      p[b] === rn && (p[b] = e[b], d++);
+    if (d === p.length && p.length > 0) {
+      const b = new Error(`map: all ${p.length} items failed to process`);
+      throw i.error(b), b;
+    }
+    const h = d > 0 ? T.partial : T.success, y = {
       totalItems: p.length,
       successCount: p.length - d,
       failedItems: d,
-      outcome: m
+      outcome: h
     };
     return i.emit({ event: k.output, value: p }), i.complete(y), p;
   } catch (a) {
@@ -5014,15 +5019,15 @@ const Nr = {
     });
     let l = i.initial;
     (c === "collection" || c === "auto" && Array.isArray(i.initial) && !i.responseFormat) && (l = { items: i.initial });
-    const p = await Ae(t, i), d = a.batch(t.length), m = p;
+    const p = await Ae(t, i), d = a.batch(t.length), h = p;
     a.progress({
       event: W.start,
       totalItems: t.length,
-      totalBatches: m.length
+      totalBatches: h.length
     });
-    for (const { items: w, skip: f } of p) {
+    for (const { items: b, skip: f } of p) {
       if (f) continue;
-      const g = je(i.listStyle, w, i.autoModeThreshold), h = ({ style: x, count: E }) => {
+      const g = je(i.listStyle, b, i.autoModeThreshold), m = ({ style: x, count: E }) => {
         const O = x === ue.XML ? "XML" : "", R = o ? `
 
 ${o}` : "";
@@ -5042,16 +5047,16 @@ ${$(l !== void 0 ? l : "No initial value - use first item as starting point", {
         })}
 
 Process exactly ${E} items from the ${O} list below and return the final accumulator value.${R}`;
-      }, b = i.responseFormat || Sh, v = h({ style: g, count: w.length }), S = {
+      }, w = i.responseFormat || Sh, S = m({ style: g, count: b.length }), v = {
         ...i,
         listStyle: g,
-        responseFormat: b
-      }, P = await M(() => be(w, v, S), {
+        responseFormat: w
+      }, P = await M(() => be(b, S, v), {
         label: "reduce:batch",
         config: i,
         onProgress: L(i.onProgress, "batch")
       });
-      !i.responseFormat && P?.accumulator !== void 0 ? l = P.accumulator : l = P, d(w.length);
+      !i.responseFormat && P?.accumulator !== void 0 ? l = P.accumulator : l = P, d(b.length);
     }
     a.progress({
       event: W.complete,
@@ -5060,7 +5065,7 @@ Process exactly ${E} items from the ${O} list below and return the final accumul
     });
     const y = {
       totalItems: t.length,
-      totalBatches: m.length,
+      totalBatches: h.length,
       outcome: T.success
     };
     return a.emit({ event: k.output, value: l }), a.complete(y), l;
@@ -5165,8 +5170,8 @@ async function Ji(e, t = {}) {
     });
     if (p(l.length), !Array.isArray(d))
       return r.complete({ outcome: T.success }), [];
-    const m = d.filter((y) => y.type === "pattern" && y.count >= 2).toSorted((y, w) => w.count - y.count).map((y) => y.template).slice(0, i);
-    return r.emit({ event: k.output, value: m }), r.complete({ outcome: T.success }), m;
+    const h = d.filter((y) => y.type === "pattern" && y.count >= 2).toSorted((y, b) => b.count - y.count).map((y) => y.template).slice(0, i);
+    return r.emit({ event: k.output, value: h }), r.complete({ outcome: T.success }), h;
   } catch (p) {
     throw r.error(p), p;
   }
@@ -5283,23 +5288,23 @@ Accumulator should track:
 
 Return the updated accumulator as valid JSON.`, o].filter(Boolean).join(`
 
-`), w = 20, f = [];
-    for (let P = 0; P < u.length; P += w) {
-      const x = u.slice(P, P + w);
+`), b = 20, f = [];
+    for (let P = 0; P < u.length; P += b) {
+      const x = u.slice(P, P + b);
       f.push(JSON.stringify(x));
     }
     a.emit({ event: k.phase, phase: "enriched", enrichedData: u });
-    const h = await Ie(f, y, {
+    const m = await Ie(f, y, {
       ...i,
       initial: JSON.stringify(d),
       batchSize: c,
       responseFormat: C("analysis_accumulator", p),
       onProgress: L(i.onProgress, "reduce:analysis")
-    }), v = [`Based on the following analysis of ${l.count} data points for property "${t}", generate threshold recommendations.
+    }), S = [`Based on the following analysis of ${l.count} data points for property "${t}", generate threshold recommendations.
 
 ${$(s, { tag: "goal" })}
 
-${$(JSON.stringify(h, null, 2), { tag: "accumulated-analysis" })}
+${$(JSON.stringify(m, null, 2), { tag: "accumulated-analysis" })}
 
 ${$(
       JSON.stringify(
@@ -5328,8 +5333,8 @@ Generate specific threshold recommendations that:
 
 Return threshold candidates with their rationales.`, o].filter(Boolean).join(`
 
-`), S = await M(
-      () => _(v, {
+`), v = await M(
+      () => _(S, {
         ...i,
         responseFormat: C("threshold_result", Oh)
       }),
@@ -5338,9 +5343,9 @@ Return threshold candidates with their rationales.`, o].filter(Boolean).join(`
         config: i
       }
     );
-    return S.thresholdCandidates && (S.thresholdCandidates = S.thresholdCandidates.filter((P) => P.value < l.min || P.value > l.max ? (ne(
+    return v.thresholdCandidates && (v.thresholdCandidates = v.thresholdCandidates.filter((P) => P.value < l.min || P.value > l.max ? (ne(
       `Threshold value ${P.value} is outside data range [${l.min}, ${l.max}]`
-    ), !1) : !0)), S.distributionAnalysis = {
+    ), !1) : !0)), v.distributionAnalysis = {
       mean: l.mean,
       median: l.median,
       standardDeviation: l.stdDev,
@@ -5348,7 +5353,7 @@ Return threshold candidates with their rationales.`, o].filter(Boolean).join(`
       max: l.max,
       percentiles: l.percentiles,
       dataPoints: l.count
-    }, a.complete({ outcome: T.success }), S;
+    }, a.complete({ outcome: T.success }), v;
   } catch (l) {
     throw a.error(l), l;
   }
@@ -5504,7 +5509,7 @@ async function Xi(e, t, n) {
 
 ${s}` : r, i = A(qr, n), a = I(qr, i.onProgress, i);
   a.start(), a.emit({ event: k.input, value: e });
-  const { maxParallel: c, windowSize: l, overlapSize: u, maxAttempts: p, retryMode: d, retryOnAll: m } = await q(i, {
+  const { maxParallel: c, windowSize: l, overlapSize: u, maxAttempts: p, retryMode: d, retryOnAll: h } = await q(i, {
     precision: J(qh, ["windowSize", "overlapSize"]),
     maxParallel: 3,
     maxAttempts: void 0,
@@ -5515,13 +5520,13 @@ ${s}` : r, i = A(qr, n), a = I(qr, i.onProgress, i);
     return a.complete({ blocksExtracted: 0, outcome: T.success }), [];
   try {
     const y = e.split(`
-`), w = y.length, f = [];
-    for (let x = 0; x < w; x += l - u)
+`), b = y.length, f = [];
+    for (let x = 0; x < b; x += l - u)
       f.push(x);
     a.emit({
       event: k.phase,
       phase: "windowing",
-      totalLines: w,
+      totalLines: b,
       windowCount: f.length,
       windowSize: l,
       overlapSize: u
@@ -5533,10 +5538,10 @@ ${s}` : r, i = A(qr, n), a = I(qr, i.onProgress, i);
       totalBatches: f.length,
       maxParallel: c
     }), a.emit({ event: k.phase, phase: "extraction" });
-    const h = await Q(
+    const m = await Q(
       f,
       async (x) => {
-        const E = Math.min(x + l, w), O = y.slice(x, E), R = zh(O, x, o), j = await M(
+        const E = Math.min(x + l, b), O = y.slice(x, E), R = zh(O, x, o), j = await M(
           async () => {
             const F = await _(R, {
               ...i,
@@ -5549,7 +5554,7 @@ ${s}` : r, i = A(qr, n), a = I(qr, i.onProgress, i);
             config: i,
             maxAttempts: p,
             retryMode: d,
-            retryOnAll: m,
+            retryOnAll: h,
             onProgress: L(i.onProgress, "window")
           }
         );
@@ -5564,24 +5569,24 @@ ${s}` : r, i = A(qr, n), a = I(qr, i.onProgress, i);
     a.emit({
       event: k.phase,
       phase: "merging",
-      rawBlocks: h.flat().length
+      rawBlocks: m.flat().length
     });
-    const b = h.flat().filter((x) => x && x.startLine !== void 0 && x.endLine !== void 0).toSorted((x, E) => x.startLine - E.startLine || E.endLine - x.endLine), v = [];
-    for (const x of b) {
-      const E = v[v.length - 1];
-      !E || x.startLine > E.endLine ? v.push({ ...x }) : x.endLine > E.endLine && (E.endLine = x.endLine);
+    const w = m.flat().filter((x) => x && x.startLine !== void 0 && x.endLine !== void 0).toSorted((x, E) => x.startLine - E.startLine || E.endLine - x.endLine), S = [];
+    for (const x of w) {
+      const E = S[S.length - 1];
+      !E || x.startLine > E.endLine ? S.push({ ...x }) : x.endLine > E.endLine && (E.endLine = x.endLine);
     }
-    const S = v.map(
+    const v = S.map(
       ({ startLine: x, endLine: E }) => y.slice(x, E + 1)
     );
     a.progress({
       event: W.complete,
       totalItems: f.length,
       processedItems: g.count,
-      blocksExtracted: S.length
+      blocksExtracted: v.length
     });
-    const P = { blocksExtracted: S.length, outcome: T.success };
-    return a.emit({ event: k.output, value: S }), a.complete(P), S;
+    const P = { blocksExtracted: v.length, outcome: T.success };
+    return a.emit({ event: k.output, value: v }), a.complete(P), v;
   } catch (y) {
     throw a.error(y), y;
   }
@@ -5628,13 +5633,13 @@ const zr = {
     maxParallel: p = 3
   } = await q(a, {
     strictness: J(Uh, ["guidance", "errorPosture"])
-  }), d = o.guidance ?? l, m = new Array(t.length), y = await Ae(t, a), w = c.batch(t.length);
+  }), d = o.guidance ?? l, h = new Array(t.length), y = await Ae(t, a), b = c.batch(t.length);
   c.progress({
     event: W.start,
     totalItems: t.length,
     totalBatches: y.length
   });
-  const f = ({ style: v, count: S }) => {
+  const f = ({ style: S, count: v }) => {
     const P = d ? `
 
 ${$(d, { tag: "borderline-handling" })}` : "", x = i ? `
@@ -5648,34 +5653,34 @@ IMPORTANT:
 - Consider all aspects of the filtering criteria
 - Return only "yes" or "no" for each item
 - Maintain the exact order of the input list${x}`;
-    return v === ue.NEWLINE ? `${E}
+    return S === ue.NEWLINE ? `${E}
 
-Process exactly ${S} items from the list below and return ${S} yes/no decisions.` : `${E}
+Process exactly ${v} items from the list below and return ${v} yes/no decisions.` : `${E}
 
-Process exactly ${S} items from the XML list below and return ${S} yes/no decisions.`;
+Process exactly ${v} items from the XML list below and return ${v} yes/no decisions.`;
   };
   await Q(
     y,
-    async ({ items: v, startIndex: S }) => {
-      const P = je(a.listStyle, v, a.autoModeThreshold), x = f({ style: P, count: v.length }), E = {
+    async ({ items: S, startIndex: v }) => {
+      const P = je(a.listStyle, S, a.autoModeThreshold), x = f({ style: P, count: S.length }), E = {
         ...a,
         listStyle: P,
         responseFormat: a.responseFormat ?? Wh
       };
       try {
-        const O = await M(() => be(v, x, E), {
+        const O = await M(() => be(S, x, E), {
           label: "filter:batch",
           config: a,
           onProgress: L(a.onProgress, "batch")
         });
-        v.forEach((R, j) => {
-          m[S + j] = O[j]?.toLowerCase().trim() === "yes";
-        }), w(v.length);
+        S.forEach((R, j) => {
+          h[v + j] = O[j]?.toLowerCase().trim() === "yes";
+        }), b(S.length);
       } catch (O) {
         if (O.name === "AbortError" || a?.abortSignal?.aborted || u === z.strict) throw O;
-        c.error(O, { startIndex: S, itemCount: v.length });
-        for (let R = 0; R < v.length; R++)
-          m[S + R] = !1;
+        c.error(O, { startIndex: v, itemCount: S.length });
+        for (let R = 0; R < S.length; R++)
+          h[v + R] = !1;
       }
     },
     {
@@ -5684,14 +5689,14 @@ Process exactly ${S} items from the XML list below and return ${S} yes/no decisi
       abortSignal: a.abortSignal
     }
   );
-  const g = t.filter((v, S) => m[S]);
+  const g = t.filter((S, v) => h[v]);
   c.progress({
     event: W.complete,
     totalItems: t.length,
-    processedItems: w.count
+    processedItems: b.count
   });
-  const h = m.some((v) => v === void 0) ? T.partial : T.success, b = { inputCount: t.length, outputCount: g.length, outcome: h };
-  return c.emit({ event: k.output, value: g }), c.complete(b), g;
+  const m = h.some((S) => S === void 0) ? T.partial : T.success, w = { inputCount: t.length, outputCount: g.length, outcome: m };
+  return c.emit({ event: k.output, value: g }), c.complete(w), g;
 };
 Zi.knownTexts = ["guidance"];
 const Wr = {
@@ -5719,10 +5724,10 @@ const Wr = {
   const { maxParallel: c, errorPosture: l } = await q(i, {
     maxParallel: 3,
     errorPosture: z.resilient
-  }), u = ({ style: g, count: h }) => {
-    const b = o ? `
+  }), u = ({ style: g, count: m }) => {
+    const w = o ? `
 
-${o}` : "", v = `From the list below, identify and return the SINGLE item that BEST matches the search criteria.
+${o}` : "", S = `From the list below, identify and return the SINGLE item that BEST matches the search criteria.
 
 ${$(s, { tag: "search-criteria" })}
 
@@ -5731,31 +5736,31 @@ IMPORTANT:
 - Choose the BEST match, not just any match
 - Return the complete original item text, unchanged
 - If NO items match the criteria, return an empty string
-- Return ONLY ONE item, even if multiple items match${b}`;
-    return g === ue.NEWLINE ? `${v}
+- Return ONLY ONE item, even if multiple items match${w}`;
+    return g === ue.NEWLINE ? `${S}
 
-Process exactly ${h} items from the list below and return the single best match.` : `${v}
+Process exactly ${m} items from the list below and return the single best match.` : `${S}
 
-Process exactly ${h} items from the XML list below and return the single best match.`;
+Process exactly ${m} items from the XML list below and return the single best match.`;
   }, p = [];
   let d = !1;
-  const m = await Ae(t, i), y = a.batch(t.length), w = m;
+  const h = await Ae(t, i), y = a.batch(t.length), b = h;
   a.progress({
     event: W.start,
     totalItems: t.length,
-    totalBatches: w.length
+    totalBatches: b.length
   });
-  for (let g = 0; g < w.length && !d; g += c) {
-    const h = w.slice(g, g + c);
+  for (let g = 0; g < b.length && !d; g += c) {
+    const m = b.slice(g, g + c);
     await Q(
-      h,
-      async ({ items: b, startIndex: v }) => {
-        const S = je(i.listStyle, b, i.autoModeThreshold);
+      m,
+      async ({ items: w, startIndex: S }) => {
+        const v = je(i.listStyle, w, i.autoModeThreshold);
         try {
           const P = await M(
-            () => be(b, u({ style: S, count: b.length }), {
+            () => be(w, u({ style: v, count: w.length }), {
               ...i,
-              listStyle: S,
+              listStyle: v,
               responseFormat: i.responseFormat || Vh
             }),
             {
@@ -5765,13 +5770,13 @@ Process exactly ${h} items from the XML list below and return the single best ma
             }
           ), x = Array.isArray(P) && P[0];
           if (x) {
-            const E = t.findIndex((R) => R === x), O = E !== -1 ? E : v;
+            const E = t.findIndex((R) => R === x), O = E !== -1 ? E : S;
             p.push({ result: x, index: O });
           }
-          y(b.length);
+          y(w.length);
         } catch (P) {
-          if (a.error(P, { startIndex: v, itemCount: b.length }), l === z.strict) throw P;
-          ne(`find batch at index ${v} failed: ${P.message}`);
+          if (a.error(P, { startIndex: S, itemCount: w.length }), l === z.strict) throw P;
+          ne(`find batch at index ${S} failed: ${P.message}`);
         }
       },
       {
@@ -5788,9 +5793,9 @@ Process exactly ${h} items from the XML list below and return the single best ma
     found: p.length > 0
   }), p.length > 0) {
     const g = p.reduce(
-      (b, v) => v.index < b.index ? v : b
-    ), h = { found: !0, totalItems: t.length, outcome: T.success };
-    return a.emit({ event: k.output, value: g.result }), a.complete(h), g.result;
+      (w, S) => S.index < w.index ? S : w
+    ), m = { found: !0, totalItems: t.length, outcome: T.success };
+    return a.emit({ event: k.output, value: g.result }), a.complete(m), g.result;
   }
   const f = { found: !1, totalItems: t.length, outcome: T.success };
   return a.emit({ event: k.output, value: "" }), a.complete(f), "";
@@ -5825,8 +5830,8 @@ const tf = 10, nf = (e) => [...new Set(e.filter((t) => t.trim() !== ""))], Bn =
       iterations: l,
       criteria: t
     });
-    const d = async (S) => {
-      const P = ef({ description: r }, S);
+    const d = async (v) => {
+      const P = ef({ description: r }, v);
       if (Array.isArray(P))
         return P;
       const x = s ? `${P}
@@ -5839,8 +5844,8 @@ ${s}` : P, E = await M(
         }
       ), O = E?.items || E;
       return Array.isArray(O) ? O.filter(Boolean) : [];
-    }, m = async (S, P) => {
-      const x = Ce(a)(S);
+    }, h = async (v, P) => {
+      const x = Ce(a)(v);
       let E = [], O = [], R = 0;
       const j = i.batch(x.length);
       for (const F of x) {
@@ -5872,40 +5877,40 @@ ${s}` : P, E = await M(
         bottom: u ? O : [],
         selected: /* @__PURE__ */ new Set([...E, ...u ? O : []])
       };
-    }, y = [], w = [];
+    }, y = [], b = [];
     let f = p;
-    for (let S = 0; S < l && f.length > 0; S++) {
+    for (let v = 0; v < l && f.length > 0; v++) {
       i.emit({
         event: k.step,
         stepName: "extracting-extremes",
-        iteration: S + 1,
+        iteration: v + 1,
         totalIterations: l,
         remainingItems: f.length
       });
-      const { top: P, bottom: x, selected: E } = await m(f, S + 1);
-      y.push(...P), u && w.unshift(...x), f = f.filter((O) => !E.has(O)), i.emit({
+      const { top: P, bottom: x, selected: E } = await h(f, v + 1);
+      y.push(...P), u && b.unshift(...x), f = f.filter((O) => !E.has(O)), i.emit({
         event: k.step,
         stepName: "iteration-complete",
-        iteration: S + 1,
+        iteration: v + 1,
         totalIterations: l,
         topCount: y.length,
-        bottomCount: w.length,
+        bottomCount: b.length,
         remainingItems: f.length
       });
     }
-    const g = u ? [...y, ...f, ...w] : [...y, ...f], h = new Set(p), b = /* @__PURE__ */ new Set(), v = [];
-    for (const S of g)
-      h.has(S) && !b.has(S) && (b.add(S), v.push(S));
-    for (const S of p)
-      b.has(S) || v.push(S);
+    const g = u ? [...y, ...f, ...b] : [...y, ...f], m = new Set(p), w = /* @__PURE__ */ new Set(), S = [];
+    for (const v of g)
+      m.has(v) && !w.has(v) && (w.add(v), S.push(v));
+    for (const v of p)
+      w.has(v) || S.push(v);
     return i.progress({
       event: W.complete,
       totalItems: p.length,
       iterations: l,
       topItems: y.length,
-      bottomItems: w.length,
+      bottomItems: b.length,
       remainingItems: f.length
-    }), i.complete({ outcome: T.success, totalItems: p.length }), v;
+    }), i.complete({ outcome: T.success, totalItems: p.length }), S;
   } catch (d) {
     throw i.error(d), d;
   }
@@ -5960,39 +5965,39 @@ async function ta(e, t = {}) {
     if (r.terms)
       p = r.terms.split(",").map((y) => y.trim()).filter(Boolean);
     else {
-      const w = fo(n).sentences().out("array");
-      if (w.length === 0)
+      const b = fo(n).sentences().out("array");
+      if (b.length === 0)
         return i.complete({ outcome: T.success, terms: 0 }), [];
       const f = [];
-      for (let P = 0; P < w.length; P += l - u) {
-        const x = w.slice(P, P + l);
+      for (let P = 0; P < b.length; P += l - u) {
+        const x = b.slice(P, P + l);
         x.length > 0 && f.push(x.join(" "));
       }
-      const g = i.batch(f.length), b = `Extract every proper noun and every term that a general reader would need to look up. Over-extract — the list will be filtered later.
+      const g = i.batch(f.length), w = `Extract every proper noun and every term that a general reader would need to look up. Over-extract — the list will be filtered later.
 
 Return a "terms" object containing an array of the extracted terms.${s ? `
 
-${s}` : ""}`, v = await Oe(f, b, {
+${s}` : ""}`, S = await Oe(f, w, {
         ...o,
         batchSize: o.batchSize ?? 1,
         responseFormat: rf,
         onProgress: L(o.onProgress, "glossary:extract")
       });
       g(f.length);
-      const S = /* @__PURE__ */ new Set();
-      v.forEach((P) => {
+      const v = /* @__PURE__ */ new Set();
+      S.forEach((P) => {
         P && P.terms && Array.isArray(P.terms) && P.terms.forEach((x) => {
-          x && typeof x == "string" && S.add(x);
+          x && typeof x == "string" && v.add(x);
         });
-      }), p = Array.from(S);
+      }), p = Array.from(v);
     }
     if (i.emit({ event: k.phase, phase: "extracted", terms: p }), p.length === 0)
       return i.complete({ outcome: T.success, terms: 0 }), [];
-    const m = (await Bn(p, c, {
+    const h = (await Bn(p, c, {
       ...o,
       onProgress: L(o.onProgress, "glossary:sort")
     })).slice(0, a);
-    return i.complete({ outcome: T.success, terms: m.length }), m;
+    return i.complete({ outcome: T.success, terms: h.length }), h;
   } catch (p) {
     throw i.error(p), p;
   }
@@ -6065,7 +6070,7 @@ async function na(e, t, n) {
     granularity: J(sf, ["guidance", "topN"]),
     maxParallel: 3,
     errorPosture: z.resilient
-  }), { categoryPrompt: d, listStyle: m, autoModeThreshold: y, now: w } = i;
+  }), { categoryPrompt: d, listStyle: h, autoModeThreshold: y, now: b } = i;
   let f;
   if (s.categories)
     f = Hr(s.categories);
@@ -6082,7 +6087,7 @@ async function na(e, t, n) {
     ), F = await Ie(e, j, {
       ...i,
       initial: "",
-      now: w,
+      now: b,
       onProgress: L(i.onProgress, "reduce:category-discovery")
     });
     f = Hr(F);
@@ -6094,13 +6099,13 @@ async function na(e, t, n) {
     categories: f,
     categoryCount: f.length
   });
-  const g = [], h = af(f), b = o ? (j) => `${h(j)}
+  const g = [], m = af(f), w = o ? (j) => `${m(j)}
 
-${o}` : h, S = await Ae(e, i), P = a.batch(e.length);
+${o}` : m, v = await Ae(e, i), P = a.batch(e.length);
   await Q(
-    S,
+    v,
     async ({ items: j, startIndex: F }) => {
-      const V = je(m, j, y);
+      const V = je(h, j, y);
       try {
         const Y = {
           ...i,
@@ -6108,7 +6113,7 @@ ${o}` : h, S = await Ae(e, i), P = a.batch(e.length);
         }, H = await M(
           () => be(
             j,
-            b({ style: V, count: j.length }),
+            w({ style: V, count: j.length }),
             Y
           ),
           {
@@ -6280,14 +6285,14 @@ async function oa(e, t, n) {
     const p = sa(e, c, l);
     if (p.length === 0)
       return i.complete({ outcome: T.success, combinations: 0 }), {};
-    const d = {}, m = i.batch(p.length), y = await Q(
+    const d = {}, h = i.batch(p.length), y = await Q(
       p,
-      async (w) => {
-        const f = await jf(w, r, s, {
+      async (b) => {
+        const f = await jf(b, r, s, {
           ...o,
           onProgress: L(o.onProgress, "combo")
         });
-        return m(1), f;
+        return h(1), f;
       },
       {
         maxParallel: u,
@@ -6296,8 +6301,8 @@ async function oa(e, t, n) {
         abortSignal: o.abortSignal
       }
     );
-    for (const w of y)
-      w?.key !== void 0 && (d[w.key] = w.intersection);
+    for (const b of y)
+      b?.key !== void 0 && (d[b.key] = b.intersection);
     if (a && Object.keys(d).length > 0) {
       const f = (await Rf(d, o)).intersections || d;
       return i.complete({ outcome: T.success, combinations: p.length }), f;
@@ -6363,8 +6368,8 @@ ${s}` : r, i = A("list:generate", {
     ...n
   }), a = [], c = {};
   let l = !1;
-  const { shouldSkip: u = Jf, shouldStop: p = Kf } = i, { queryLimit: d = 5, timeoutMs: m = zf } = i, y = /* @__PURE__ */ new Date();
-  let w = 0;
+  const { shouldSkip: u = Jf, shouldStop: p = Kf } = i, { queryLimit: d = 5, timeoutMs: h = zf } = i, y = /* @__PURE__ */ new Date();
+  let b = 0;
   for (; !l; ) {
     const f = ri(o, {
       ...i,
@@ -6372,49 +6377,49 @@ ${s}` : r, i = A("list:generate", {
     });
     let g = [];
     try {
-      const v = await M(
+      const S = await M(
         () => _(f, { ...i, ...aa() }),
         {
           label: "list-generate",
           config: i
         }
-      ), S = v?.items || v;
-      g = Array.isArray(S) ? S.filter(Boolean) : [];
-    } catch (v) {
-      if (v.name === "AbortError")
-        throw v;
+      ), v = S?.items || S;
+      g = Array.isArray(v) ? v.filter(Boolean) : [];
+    } catch (S) {
+      if (S.name === "AbortError")
+        throw S;
       ne(
-        `Generate list [error]: ${v.message} ${f.slice(0, 100).replace(`
+        `Generate list [error]: ${S.message} ${f.slice(0, 100).replace(`
 `, "\\n")}`
       ), l = !0;
       break;
     }
-    const h = g.filter((v) => !(v in c));
-    w += 1;
-    for (const v of h) {
-      const S = {
-        result: v,
+    const m = g.filter((S) => !(S in c));
+    b += 1;
+    for (const S of m) {
+      const v = {
+        result: S,
         resultsAll: a,
         resultsNew: g,
-        queryCount: w,
+        queryCount: b,
         startTime: y,
         queryLimit: d,
-        timeoutMs: m
+        timeoutMs: h
       };
-      if (await p(S)) {
+      if (await p(v)) {
         l = !0;
         break;
       }
-      await u(S) || (c[v] = !0, a.push(v), yield v);
+      await u(v) || (c[S] = !0, a.push(S), yield S);
     }
     await p({
       result: void 0,
       resultsAll: a,
       resultsNew: g,
-      queryCount: w,
+      queryCount: b,
       startTime: y,
       queryLimit: d,
-      timeoutMs: m
+      timeoutMs: h
     }) && (l = !0);
   }
 };
@@ -6434,16 +6439,16 @@ ${r}` : n, c = await M(
     if (i && u.length > 0) {
       o.emit({ event: k.step, stepName: "transform", itemCount: u.length });
       const p = o.batch(u.length), d = [];
-      for (const m of u) {
-        const y = Vf(m, i), w = await M(() => _(y, s), {
+      for (const h of u) {
+        const y = Vf(h, i), b = await M(() => _(y, s), {
           label: "list-transform",
           config: s
         });
         try {
-          const f = JSON.parse(w);
+          const f = JSON.parse(b);
           d.push(f);
         } catch (f) {
-          ne(`list-transform JSON.parse failed, keeping original item: ${f.message}`), d.push(m);
+          ne(`list-transform JSON.parse failed, keeping original item: ${f.message}`), d.push(h);
         }
         p(1);
       }
@@ -6555,14 +6560,14 @@ ${o}` : r, a = s.spec || await qn(i, n);
   return mg(e, a, n);
 }
 async function rs(e, t, n, r) {
-  const { maxParallel: s, errorPosture: o, onProgress: i, logger: a, anchoring: c, _providedAnchors: l } = r, p = await Ae(e, n), d = new Array(e.length).fill(void 0), m = I("score", i, r), y = m.batch(e.length);
-  m.progress({
+  const { maxParallel: s, errorPosture: o, onProgress: i, logger: a, anchoring: c, _providedAnchors: l } = r, p = await Ae(e, n), d = new Array(e.length).fill(void 0), h = I("score", i, r), y = h.batch(e.length);
+  h.progress({
     event: W.start,
     totalItems: e.length,
     totalBatches: p.length,
     maxParallel: s
   });
-  let w = l || "";
+  let b = l || "";
   if (!l && p.length > 0) {
     const f = p[0];
     try {
@@ -6571,15 +6576,15 @@ async function rs(e, t, n, r) {
         config: r,
         onProgress: L(i, "batch")
       });
-      ns(g, f.items.length).forEach((h, b) => {
-        d[f.startIndex + b] = h;
-      }), w = dg(f.items, g, c), m.emit({
+      ns(g, f.items.length).forEach((m, w) => {
+        d[f.startIndex + w] = m;
+      }), b = dg(f.items, g, c), h.emit({
         event: k.phase,
         phase: "anchors-established",
-        anchors: w
+        anchors: b
       });
     } catch (g) {
-      if (m.error(g, { batchIndex: 0, itemCount: f.items.length }), o === z.strict) throw g;
+      if (h.error(g, { batchIndex: 0, itemCount: f.items.length }), o === z.strict) throw g;
       a?.error && a.error("Score batch 0 failed", {
         error: g.message,
         itemCount: f.items.length
@@ -6588,24 +6593,24 @@ async function rs(e, t, n, r) {
     y(f.items.length);
   }
   if (p.length > 1) {
-    const f = w ? `${t}
-${w}` : t;
+    const f = b ? `${t}
+${b}` : t;
     await Q(
       p.slice(1),
-      async ({ items: g, startIndex: h }) => {
+      async ({ items: g, startIndex: m }) => {
         try {
-          const b = await M(() => be(g, f, n), {
+          const w = await M(() => be(g, f, n), {
             label: "score:batch",
             config: r,
             onProgress: L(i, "batch")
           });
-          ns(b, g.length).forEach((v, S) => {
-            d[h + S] = v;
+          ns(w, g.length).forEach((S, v) => {
+            d[m + v] = S;
           });
-        } catch (b) {
-          if (m.error(b, { itemCount: g.length }), o === z.strict) throw b;
+        } catch (w) {
+          if (h.error(w, { itemCount: g.length }), o === z.strict) throw w;
           a?.error && a.error("Score batch failed", {
-            error: b.message,
+            error: w.message,
             itemCount: g.length
           });
         }
@@ -6614,7 +6619,7 @@ ${w}` : t;
       { maxParallel: s, errorPosture: o, abortSignal: r.abortSignal }
     );
   }
-  return m.progress({
+  return h.progress({
     event: W.complete,
     totalItems: e.length,
     processedItems: y.count
@@ -6624,7 +6629,7 @@ async function ke(e, t, n) {
   [t, n] = K(t, n, ["spec", "anchors"]);
   const { text: r, known: s, context: o } = N(t, ["spec", "anchors"]), { now: i } = n, a = A(ts, n), c = I(ts, a.onProgress, a);
   c.start(), c.emit({ event: k.input, value: e });
-  const { maxParallel: l, maxAttempts: u, temperature: p, errorPosture: d, anchoring: m } = await q(
+  const { maxParallel: l, maxAttempts: u, temperature: p, errorPosture: d, anchoring: h } = await q(
     a,
     {
       maxParallel: 3,
@@ -6637,38 +6642,38 @@ async function ke(e, t, n) {
   c.emit({ event: k.phase, phase: "generating-specification" });
   const y = o ? `${r}
 
-${o}` : r, w = s.spec || await qn(y, a);
-  c.emit({ event: k.phase, phase: "scoring-items", specification: w });
+${o}` : r, b = s.spec || await qn(y, a);
+  c.emit({ event: k.phase, phase: "scoring-items", specification: b });
   const f = fg(
-    w,
+    b,
     "Return ONLY the numeric score for each item according to the specification range."
   ), g = {
     ...a,
     responseFormat: pg,
     temperature: p
-  }, h = {
+  }, m = {
     ...a,
     maxParallel: l,
     maxAttempts: u,
     errorPosture: d,
     now: i,
-    anchoring: m,
+    anchoring: h,
     _providedAnchors: s.anchors
-  }, b = await rs(e, f, g, h);
+  }, w = await rs(e, f, g, m);
   for (let x = 1; x < u; x += 1) {
     const E = [], O = [];
-    if (b.forEach((j, F) => {
+    if (w.forEach((j, F) => {
       j == null && (E.push(F), O.push(e[F]));
     }), O.length === 0) break;
     (await rs(O, f, g, {
-      ...h,
+      ...m,
       now: /* @__PURE__ */ new Date()
     })).forEach((j, F) => {
-      j !== void 0 && (b[E[F]] = j);
+      j !== void 0 && (w[E[F]] = j);
     });
   }
-  const v = b.filter((x) => x !== void 0).length, S = b.length - v, P = S > 0 ? T.partial : T.success;
-  return c.complete({ totalItems: b.length, successCount: v, failedItems: S, outcome: P }), b;
+  const S = w.filter((x) => x !== void 0).length, v = w.length - S, P = v > 0 ? T.partial : T.success;
+  return c.complete({ totalItems: w.length, successCount: S, failedItems: v, outcome: P }), w;
 }
 function fg(e, t = "") {
   const n = `Apply this score specification to evaluate each item:
@@ -6754,7 +6759,7 @@ function $g(e, t, n, r) {
   let o;
   if (r === "rich") {
     const c = Math.min(3, Math.ceil(s.length / 4)), l = Math.floor(s.length / 2), u = s.slice(Math.max(0, l - 1), l + 1), p = [...s.slice(0, c), ...u, ...s.slice(-c)], d = /* @__PURE__ */ new Set();
-    o = p.filter((m) => d.has(m.item) ? !1 : (d.add(m.item), !0));
+    o = p.filter((h) => d.has(h.item) ? !1 : (d.add(h.item), !0));
   } else {
     const c = Math.min(2, Math.ceil(s.length / 3));
     o = [...s.slice(0, c), ...s.slice(-c)];
@@ -6781,50 +6786,50 @@ ${s}` : os(e, t, n, r), a = xg(e.length, t.length), c = C("score_matrix_result",
   return Pg(l?.matrix, e.length, t.length);
 }
 async function as(e, t, n, r, s, o) {
-  const { maxParallel: i, errorPosture: a, onProgress: c, anchoring: l, _providedAnchors: u } = o, p = await Ae(e, { ...s, outputRatio: 4 }), d = Array.from({ length: e.length }), m = I("score-matrix", c, o), y = m.batch(e.length);
-  m.progress({
+  const { maxParallel: i, errorPosture: a, onProgress: c, anchoring: l, _providedAnchors: u } = o, p = await Ae(e, { ...s, outputRatio: 4 }), d = Array.from({ length: e.length }), h = I("score-matrix", c, o), y = h.batch(e.length);
+  h.progress({
     event: W.start,
     totalItems: e.length,
     totalBatches: p.length,
     maxParallel: i
   });
-  let w = u || "", f = 0;
+  let b = u || "", f = 0;
   if (!u && p.length > 0) {
     const g = p[0];
     try {
-      const h = await M(
+      const m = await M(
         () => is(g.items, t, n, r, "", s),
         { label: "score-matrix:batch", config: o, onProgress: L(c, "batch") }
       );
-      h.forEach((b, v) => {
-        d[g.startIndex + v] = b;
-      }), w = $g(g.items, h, t, l), m.emit({ event: k.phase, phase: "anchors-established" });
-    } catch (h) {
-      if (m.error(h, { batchIndex: 0, itemCount: g.items.length }), a === z.strict) throw h;
+      m.forEach((w, S) => {
+        d[g.startIndex + S] = w;
+      }), b = $g(g.items, m, t, l), h.emit({ event: k.phase, phase: "anchors-established" });
+    } catch (m) {
+      if (h.error(m, { batchIndex: 0, itemCount: g.items.length }), a === z.strict) throw m;
     }
     y(g.items.length), f = 1;
   }
   return f < p.length && await Q(
     p.slice(f),
-    async ({ items: g, startIndex: h }) => {
+    async ({ items: g, startIndex: m }) => {
       try {
         (await M(
-          () => is(g, t, n, r, w, s),
+          () => is(g, t, n, r, b, s),
           {
             label: "score-matrix:batch",
             config: o,
             onProgress: L(c, "batch")
           }
-        )).forEach((v, S) => {
-          d[h + S] = v;
+        )).forEach((S, v) => {
+          d[m + v] = S;
         });
-      } catch (b) {
-        if (m.error(b, { itemCount: g.length }), a === z.strict) throw b;
+      } catch (w) {
+        if (h.error(w, { itemCount: g.length }), a === z.strict) throw w;
       }
       y(g.length);
     },
     { maxParallel: i, errorPosture: a, abortSignal: o.abortSignal }
-  ), m.progress({
+  ), h.progress({
     event: W.complete,
     totalItems: e.length,
     processedItems: y.count
@@ -6845,7 +6850,7 @@ async function ua(e, t, n, r) {
 ${i}` : s, c = la(t), l = A(ss, r), u = I(ss, l.onProgress, l);
   if (u.start({ dimensions: c.length }), u.emit({ event: k.input, value: e }), e.length === 0)
     return u.complete({ rows: 0, columns: c.length, outcome: T.success }), { matrix: [], dimensions: c.map((x) => x.dimension), scale: Ve };
-  const { maxParallel: p, maxAttempts: d, temperature: m, errorPosture: y, anchoring: w } = await q(
+  const { maxParallel: p, maxAttempts: d, temperature: h, errorPosture: y, anchoring: b } = await q(
     l,
     {
       maxParallel: 3,
@@ -6854,16 +6859,16 @@ ${i}` : s, c = la(t), l = A(ss, r), u = I(ss, l.onProgress, l);
       errorPosture: z.resilient,
       anchoring: J(Sg)
     }
-  ), f = { ...l, temperature: m }, g = {
+  ), f = { ...l, temperature: h }, g = {
     ...l,
     maxParallel: p,
     maxAttempts: d,
     errorPosture: y,
-    anchoring: w,
+    anchoring: b,
     _providedAnchors: o.anchors
   };
   u.emit({ event: k.phase, phase: "scoring-matrix" });
-  const h = await as(
+  const m = await as(
     e,
     c,
     a,
@@ -6873,7 +6878,7 @@ ${i}` : s, c = la(t), l = A(ss, r), u = I(ss, l.onProgress, l);
   );
   for (let x = 1; x < d; x += 1) {
     const E = [], O = [];
-    if (h.forEach((j, F) => {
+    if (m.forEach((j, F) => {
       j == null && (E.push(F), O.push(e[F]));
     }), O.length === 0) break;
     u.emit({
@@ -6889,17 +6894,17 @@ ${i}` : s, c = la(t), l = A(ss, r), u = I(ss, l.onProgress, l);
       f,
       { ...g, now: /* @__PURE__ */ new Date() }
     )).forEach((j, F) => {
-      j !== void 0 && (h[E[F]] = j);
+      j !== void 0 && (m[E[F]] = j);
     });
   }
-  const b = h.map(
+  const w = m.map(
     (x) => x ?? c.map(() => ({ score: Ve.min, rationale: "scoring failed" }))
-  ), v = h.filter((x) => x !== void 0).length, S = h.length - v, P = S > 0 ? T.partial : T.success;
+  ), S = m.filter((x) => x !== void 0).length, v = m.length - S, P = v > 0 ? T.partial : T.success;
   return u.emit({
     event: k.output,
-    value: { rows: b.length, columns: c.length }
-  }), u.complete({ totalItems: e.length, successCount: v, failedItems: S, outcome: P }), {
-    matrix: b,
+    value: { rows: w.length, columns: c.length }
+  }), u.complete({ totalItems: e.length, successCount: S, failedItems: v, outcome: P }), {
+    matrix: w,
     dimensions: c.map((x) => x.dimension),
     scale: Ve
   };
@@ -7017,14 +7022,14 @@ ${a}` : o, p = i.spec || await Fn(u, r);
 Return only IDs from the available tags list.
 Return empty array when no tags apply.`,
       l
-    ), m = e.map(
+    ), h = e.map(
       (g) => typeof g == "object" && g !== null ? JSON.stringify(g) : g
-    ), y = s.batch(m.length), w = {
+    ), y = s.batch(h.length), b = {
       ...r,
       responseFormat: C("tags_map_result", Cg),
       onProgress: L(r.onProgress, "tags:map")
-    }, f = await Oe(m, d, w);
-    return y(m.length), s.complete({ outcome: T.success }), f;
+    }, f = await Oe(h, d, b);
+    return y(h.length), s.complete({ outcome: T.success }), f;
   } catch (o) {
     throw s.error(o), o;
   }
@@ -7109,7 +7114,7 @@ async function ha(e, t = {}) {
       diversity: i
     }), d = await Ze(p, {
       ...n,
-      shouldStop: ({ resultsAll: m }) => m.length >= a,
+      shouldStop: ({ resultsAll: h }) => h.length >= a,
       onProgress: L(n.onProgress, "list:sampling")
     });
     if (!d || d.length === 0)
@@ -7144,18 +7149,18 @@ async function zn(e, t = {}) {
   try {
     let l;
     if (r.uniqueTerms)
-      l = r.uniqueTerms.split(",").map((m) => m.trim()).filter(Boolean);
+      l = r.uniqueTerms.split(",").map((h) => h.trim()).filter(Boolean);
     else {
-      const m = Bg(n, c), y = i.batch(m.length), f = (await Q(
-        m,
+      const h = Bg(n, c), y = i.batch(h.length), f = (await Q(
+        h,
         async (g) => {
-          const h = s ? `
+          const m = s ? `
 
-${s}` : "", b = await Ze(
-            `key words and phrases that would help find documents about: ${g}${h}`,
+${s}` : "", w = await Ze(
+            `key words and phrases that would help find documents about: ${g}${m}`,
             { ...o, onProgress: L(o.onProgress, "list:extract") }
           );
-          return y(1), b;
+          return y(1), w;
         },
         {
           maxParallel: 3,
@@ -7172,8 +7177,8 @@ ${s}` : "", b = await Ze(
       l,
       "relevance as a search term for finding information (1-10, higher is more important)",
       { ...o, onProgress: L(o.onProgress, "score:rank") }
-    ), d = l.map((m, y) => ({ term: m, score: u[y] ?? 0 })).toSorted((m, y) => y.score - m.score);
-    return i.emit({ event: k.phase, phase: "scored", termsWithScores: d }), i.complete({ outcome: T.success }), d.slice(0, a).map((m) => m.term);
+    ), d = l.map((h, y) => ({ term: h, score: u[y] ?? 0 })).toSorted((h, y) => y.score - h.score);
+    return i.emit({ event: k.phase, phase: "scored", termsWithScores: d }), i.complete({ outcome: T.success }), d.slice(0, a).map((h) => h.term);
   } catch (l) {
     throw i.error(l), l;
   }
@@ -7199,17 +7204,17 @@ async function Un({
   const u = A(ps, i), p = I(ps, u.onProgress, u);
   p.start(), p.emit({ event: k.input, value: { speakers: e, topic: a } });
   try {
-    const d = r.length > 0 ? r.map((v) => `${v.time} ${v.name} (${v.id}): ${v.comment}`).join(`
+    const d = r.length > 0 ? r.map((S) => `${S.time} ${S.name} (${S.id}): ${S.comment}`).join(`
 `) : "", y = [
       o.customPrompt || "",
       d ? $(d, { tag: "conversation-history" }) : "",
       a ? $(a, { tag: "topic" }) : ""
     ].filter(Boolean).join(`
 
-`), w = e.map((v, S) => {
-      const x = [v.name || `Speaker ${S + 1}`];
-      v.bio && x.push(`Bio: ${v.bio}`), v.agenda && x.push(`Agenda: ${v.agenda}`);
-      const E = s.get?.(v.id) ?? [];
+`), b = e.map((S, v) => {
+      const x = [S.name || `Speaker ${v + 1}`];
+      S.bio && x.push(`Bio: ${S.bio}`), S.agenda && x.push(`Agenda: ${S.agenda}`);
+      const E = s.get?.(S.id) ?? [];
       if (E.length > 0) {
         const O = E.map((R) => `[${R.time}] ${R.comment}`).join(`
 `);
@@ -7225,11 +7230,11 @@ ${O}`);
       l
     ].filter(Boolean).join(`
 
-`), h = p.batch(e.length), b = await Oe(w, g, {
+`), m = p.batch(e.length), w = await Oe(b, g, {
       ...u,
       onProgress: L(u.onProgress, "conversation-turn-reduce:map")
     });
-    return h(e.length), p.emit({ event: k.output, value: b }), p.complete({ outcome: T.success, speakers: e.length }), b;
+    return m(e.length), p.emit({ event: k.output, value: w }), p.complete({ outcome: T.success, speakers: e.length }), w;
   } catch (d) {
     throw p.error(d), d;
   }
@@ -7310,9 +7315,9 @@ class vt {
       llm: u,
       clock: p,
       onProgress: d,
-      now: m,
+      now: h,
       operation: y,
-      ...w
+      ...b
     } = i;
     if (a.shouldContinue && typeof a.shouldContinue != "function")
       throw new Error("shouldContinue must be a function");
@@ -7324,7 +7329,7 @@ class vt {
         turnPolicy: a.turnPolicy || ds(this.speakers)
       },
       a
-    ), this.speakFn = c, this.bulkSpeakFn = l, this.maxParallel = s.maxParallel ?? 3, !this.speakFn && !this.bulkSpeakFn && (this.bulkSpeakFn = Un), this.llm = u, this.clock = p || (() => /* @__PURE__ */ new Date()), this.emitter || (this.emitter = I(st, i.onProgress, i)), this.onProgress = i.onProgress, this.runConfig = i, this.otherOptions = w, this.messages = [], this.speakerMemory = /* @__PURE__ */ new Map();
+    ), this.speakFn = c, this.bulkSpeakFn = l, this.maxParallel = s.maxParallel ?? 3, !this.speakFn && !this.bulkSpeakFn && (this.bulkSpeakFn = Un), this.llm = u, this.clock = p || (() => /* @__PURE__ */ new Date()), this.emitter || (this.emitter = I(st, i.onProgress, i)), this.onProgress = i.onProgress, this.runConfig = i, this.otherOptions = b, this.messages = [], this.speakerMemory = /* @__PURE__ */ new Map();
   }
   _push(t, n) {
     const r = (n ?? "").trim();
@@ -7614,9 +7619,9 @@ ${n}`;
 } = {}) => {
   try {
     const d = t ?? n;
-    let m = e;
+    let h = e;
     if (!e.isEnhanced) {
-      m = await s({
+      h = await s({
         name: d,
         rootName: n,
         fixes: a,
@@ -7624,8 +7629,8 @@ ${n}`;
         config: l,
         variety: u,
         now: p
-      }), m.isEnhanced = !0;
-      const y = e.options?.[0], w = await r({
+      }), h.isEnhanced = !0;
+      const y = e.options?.[0], b = await r({
         name: d,
         focus: y,
         rootName: n,
@@ -7635,18 +7640,18 @@ ${n}`;
         variety: u,
         now: p
       });
-      m.children = w.map((f) => ({
+      h.children = b.map((f) => ({
         id: i(),
         name: f
       }));
     }
-    return e.id || (m.id = i()), {
+    return e.id || (h.id = i()), {
       ...e,
-      ...m
+      ...h
     };
   } catch (d) {
-    const m = t ?? n;
-    throw d.message = `makeNode(${m}): ${d.message}`, d;
+    const h = t ?? n;
+    throw d.message = `makeNode(${h}): ${d.message}`, d;
   }
 }, on = async ({
   name: e,
@@ -7664,10 +7669,10 @@ ${n}`;
   now: d
 } = {}) => {
   try {
-    let m = { ...n ?? {} };
+    let h = { ...n ?? {} };
     const y = await py({
-      node: m,
-      name: e ?? m.name,
+      node: h,
+      name: e ?? h.name,
       rootName: t,
       enhance: o,
       decompose: s,
@@ -7679,13 +7684,13 @@ ${n}`;
       variety: p,
       now: d
     });
-    if (m = {
-      ...m,
+    if (h = {
+      ...h,
       ...y
     }, r <= 0)
-      return m;
-    const w = [];
-    for (const f of m.children) {
+      return h;
+    const b = [];
+    for (const f of h.children) {
       const g = await on({
         tree: f,
         rootName: t,
@@ -7700,12 +7705,12 @@ ${n}`;
         variety: p,
         now: d
       });
-      w.push(g);
+      b.push(g);
     }
-    return m.children = w, m;
-  } catch (m) {
+    return h.children = b, h;
+  } catch (h) {
     const y = e ?? n?.name ?? t;
-    throw m.message = `makeSubtree(${y}, depth=${r}): ${m.message}`, m;
+    throw h.message = `makeSubtree(${y}, depth=${r}): ${h.message}`, h;
   }
 }, wa = (e) => {
   if (!e.children || e.children.length === 0) {
@@ -7831,18 +7836,18 @@ class dy {
     if (c === 0)
       return [];
     const l = [];
-    for (const [d, m] of this.chunks.entries()) {
-      const y = this._getDocumentVector(this.tfidf, m.documentIndex), w = this._magnitude(y);
-      if (w === 0) continue;
-      const f = this._dotProduct(a, y) / (c * w);
+    for (const [d, h] of this.chunks.entries()) {
+      const y = this._getDocumentVector(this.tfidf, h.documentIndex), b = this._magnitude(y);
+      if (b === 0) continue;
+      const f = this._dotProduct(a, y) / (c * b);
       f >= s && l.push({
         id: d,
-        text: m.text,
+        text: h.text,
         score: f
       });
     }
-    const p = l.toSorted((d, m) => m.score - d.score).slice(0, r);
-    return o ? p : p.map(({ id: d, text: m }) => ({ id: d, text: m }));
+    const p = l.toSorted((d, h) => h.score - d.score).slice(0, r);
+    return o ? p : p.map(({ id: d, text: h }) => ({ id: d, text: h }));
   }
   findMatches(t, n = {}) {
     const { threshold: r = 0.1, includeScores: s = !0 } = n;
@@ -7998,15 +8003,15 @@ function Ey(e, t, n, r, s = St) {
     o,
     l,
     s
-  ), d = Math.max(1, Math.floor(u / Sa)), m = Math.max(
+  ), d = Math.max(1, Math.floor(u / Sa)), h = Math.max(
     1,
     Math.floor(p / xa)
-  ), y = m * a * (1 - Ye), w = o < Sy ? xy : $y, f = Math.min(t * w, y);
+  ), y = h * a * (1 - Ye), b = o < Sy ? xy : $y, f = Math.min(t * b, y);
   return {
     tfIdfBudget: t - f,
     reservedSpace: f,
     chunksWeCanScore: d,
-    chunksWeCanCompress: m,
+    chunksWeCanCompress: h,
     reductionRatio: o,
     avgChunkSize: a
   };
@@ -8088,9 +8093,9 @@ async function _y(e, t, n, r = {}) {
   };
 }
 async function Cy(e, t, n, r, s, o = {}) {
-  const { compressionRatio: i = Ye } = o, a = Math.min(s.avgChunkSize * 0.8, 400), c = e.filter((y) => y.size >= a).toSorted((y, w) => {
+  const { compressionRatio: i = Ye } = o, a = Math.min(s.avgChunkSize * 0.8, 400), c = e.filter((y) => y.size >= a).toSorted((y, b) => {
     const f = (y.tfIdfScore || 0) * Math.log(y.size);
-    return (w.tfIdfScore || 0) * Math.log(w.size) - f;
+    return (b.tfIdfScore || 0) * Math.log(b.size) - f;
   }).slice(0, n);
   if (c.length === 0)
     return { compressed: [], tokensUsed: 0 };
@@ -8103,17 +8108,17 @@ async function Cy(e, t, n, r, s, o = {}) {
       onProgress: L(o.onProgress, "map:compression")
     }
   ), d = [];
-  let m = 0;
-  return p.forEach((y, w) => {
+  let h = 0;
+  return p.forEach((y, b) => {
     const f = y ? Pa(y) : "";
-    f.length >= $a && f.length <= r - m && (d.push({
-      ...c[w],
-      originalText: c[w].text,
+    f.length >= $a && f.length <= r - h && (d.push({
+      ...c[b],
+      originalText: c[b].text,
       text: f,
       compressed: !0,
       size: f.length,
-      compressionRatio: f.length / c[w].size
-    }), m += f.length);
+      compressionRatio: f.length / c[b].size
+    }), h += f.length);
   }), {
     compressed: d,
     tokensUsed: c.length * xa
@@ -8180,9 +8185,9 @@ ${o}` : r, a = A(bs, n), c = I(bs, a.onProgress, a);
     tokenBudget: u,
     gapFillerBudgetRatio: p,
     compression: d,
-    ranking: m,
+    ranking: h,
     queryExpansion: y,
-    llmScoring: w,
+    llmScoring: b,
     llmCompression: f,
     scoringTokenRatio: g
   } = await q(a, {
@@ -8197,7 +8202,7 @@ ${o}` : r, a = A(bs, n), c = I(bs, a.onProgress, a);
       "llmCompression",
       "scoringTokenRatio"
     ])
-  }), h = {
+  }), m = {
     ..._e,
     ...a,
     targetSize: l,
@@ -8205,7 +8210,7 @@ ${o}` : r, a = A(bs, n), c = I(bs, a.onProgress, a);
     gapFillerBudgetRatio: p
   };
   if (!e || e.length === 0) {
-    const b = {
+    const w = {
       content: "",
       metadata: {
         originalSize: 0,
@@ -8216,60 +8221,60 @@ ${o}` : r, a = A(bs, n), c = I(bs, a.onProgress, a);
         tokens: { budget: 0, used: 0, breakdown: {} }
       }
     };
-    return c.complete({ outcome: T.success }), b;
+    return c.complete({ outcome: T.success }), w;
   }
   try {
-    h.targetSize <= 0 && (h.targetSize = _e.targetSize), h.chunkSize <= 0 && (h.chunkSize = _e.chunkSize), h.tokenBudget <= 0 && (h.tokenBudget = _e.tokenBudget);
-    let b = h.tokenBudget;
+    m.targetSize <= 0 && (m.targetSize = _e.targetSize), m.chunkSize <= 0 && (m.chunkSize = _e.chunkSize), m.tokenBudget <= 0 && (m.tokenBudget = _e.tokenBudget);
+    let w = m.tokenBudget;
     c.emit({ event: k.phase, phase: "chunking" });
-    const v = Iy(e, h.chunkSize, h.targetSize), S = Ey(
-      v,
-      h.targetSize,
-      b,
+    const S = Iy(e, m.chunkSize, m.targetSize), v = Ey(
+      S,
+      m.targetSize,
+      w,
       e.length,
       g
     );
-    !w && !f && (S.tfIdfBudget = h.targetSize, S.reservedSpace = 0), c.emit({ event: k.phase, phase: "query-expansion" });
+    !b && !f && (v.tfIdfBudget = m.targetSize, v.reservedSpace = 0), c.emit({ event: k.phase, phase: "query-expansion" });
     const P = a;
     let x, E = 0;
     if (s.expansions)
       x = s.expansions.split(",").map((B) => B.trim()).filter(Boolean), x.unshift(i);
     else if (y) {
-      const B = await ky(i, b, P);
+      const B = await ky(i, w, P);
       x = B.expansions, E = B.tokensUsed;
     } else
       x = [i];
-    b -= E, c.emit({ event: k.phase, phase: "tfidf-scoring", expansions: x });
-    const O = Ay(v, x), { selected: R, candidates: j, sizeUsed: F } = Oy(
+    w -= E, c.emit({ event: k.phase, phase: "tfidf-scoring", expansions: x });
+    const O = Ay(S, x), { selected: R, candidates: j, sizeUsed: F } = Oy(
       O,
-      S.tfIdfBudget
+      v.tfIdfBudget
     );
     c.emit({ event: k.phase, phase: "edge-scoring" });
-    const { scored: V, tokensUsed: Y } = w ? await _y(j, i, S.chunksWeCanScore, {
+    const { scored: V, tokensUsed: Y } = b ? await _y(j, i, v.chunksWeCanScore, {
       ...P,
-      llmWeight: m
+      llmWeight: h
     }) : { scored: [], tokensUsed: 0 };
-    b -= Y;
-    let H = vs(R, F, V, h.targetSize);
+    w -= Y;
+    let H = vs(R, F, V, m.targetSize);
     c.emit({ event: k.phase, phase: "compression" });
-    const ee = h.targetSize - H.size;
+    const ee = m.targetSize - H.size;
     let pe = 0;
-    const G = Math.min(S.avgChunkSize * 0.5, 200);
-    if (f && ee > G && S.chunksWeCanCompress > 0) {
+    const G = Math.min(v.avgChunkSize * 0.5, 200);
+    if (f && ee > G && v.chunksWeCanCompress > 0) {
       const B = jy(O, H.chunks), { compressed: X, tokensUsed: ce } = await Cy(
         B,
         i,
-        S.chunksWeCanCompress,
+        v.chunksWeCanCompress,
         ee,
-        S,
+        v,
         { ...P, compressionRatio: d }
       );
-      pe = ce, b -= ce, H = vs(H.chunks, H.size, X, h.targetSize);
+      pe = ce, w -= ce, H = vs(H.chunks, H.size, X, m.targetSize);
     }
     c.emit({ event: k.phase, phase: "assembly" });
     let te = H.chunks, ie = 0;
-    if (h.gapFillerBudgetRatio > 0) {
-      const B = Math.floor(h.targetSize * h.gapFillerBudgetRatio), X = h.targetSize - H.size, ce = Math.min(B, X);
+    if (m.gapFillerBudgetRatio > 0) {
+      const B = Math.floor(m.targetSize * m.gapFillerBudgetRatio), X = m.targetSize - H.size, ce = Math.min(B, X);
       if (ce > 0) {
         const ve = Ly(O, te, ce);
         ve.length > 0 && (te = [...te, ...ve], ie = ve.length);
@@ -8277,7 +8282,7 @@ ${o}` : r, a = A(bs, n), c = I(bs, a.onProgress, a);
     }
     const de = Ny(te);
     let Z = Ry(de);
-    Z.length > h.targetSize * 3 && (Z = Pa(Z.slice(0, h.targetSize * 2)));
+    Z.length > m.targetSize * 3 && (Z = Pa(Z.slice(0, m.targetSize * 2)));
     const we = {
       content: Z,
       metadata: {
@@ -8285,20 +8290,20 @@ ${o}` : r, a = A(bs, n), c = I(bs, a.onProgress, a);
         finalSize: Z.length,
         reductionRatio: (1 - Z.length / e.length).toFixed(2),
         allocation: {
-          tfIdfBudget: S.tfIdfBudget,
-          reservedForLLM: S.reservedSpace,
+          tfIdfBudget: v.tfIdfBudget,
+          reservedForLLM: v.reservedSpace,
           actualLLMSpace: te.filter((B) => B.llmScore).reduce((B, X) => B + X.size, 0)
         },
         chunks: {
-          total: v.length,
+          total: S.length,
           tfIdfSelected: R.length,
           llmSelected: te.filter((B) => B.llmScore && !B.compressed).length,
           compressed: te.filter((B) => B.compressed).length,
           gapFillers: ie
         },
         tokens: {
-          budget: h.tokenBudget,
-          used: h.tokenBudget - b,
+          budget: m.tokenBudget,
+          used: m.tokenBudget - w,
           breakdown: {
             expansion: E,
             scoring: Y || 0,
@@ -8308,8 +8313,8 @@ ${o}` : r, a = A(bs, n), c = I(bs, a.onProgress, a);
       }
     };
     return c.complete({ outcome: T.success }), we;
-  } catch (b) {
-    throw c.error(b), b;
+  } catch (w) {
+    throw c.error(w), w;
   }
 }
 Ea.knownTexts = ["expansions"];
@@ -8361,33 +8366,33 @@ async function ka(e, t = {}) {
     else {
       if (!n)
         return i.complete({ outcome: T.success }), [];
-      const w = n.split(`
-`).map((h) => h.trim()).filter(Boolean);
-      if (w.length === 0)
+      const b = n.split(`
+`).map((m) => m.trim()).filter(Boolean);
+      if (b.length === 0)
         return i.complete({ outcome: T.success }), [];
       const f = s ? `
 
 ${s}` : "", g = await ke(
-        w,
+        b,
         `How ambiguous or easily misinterpreted is this sentence?${f}`,
         {
           ...o,
           onProgress: L(o.onProgress, "score:sentence-ambiguity")
         }
       );
-      c = w.map((h, b) => ({ sentence: h, score: g[b] ?? 0 })).toSorted((h, b) => b.score - h.score).slice(0, a);
+      c = b.map((m, w) => ({ sentence: m, score: g[w] ?? 0 })).toSorted((m, w) => w.score - m.score).slice(0, a);
     }
     i.emit({ event: k.phase, phase: "ranked", rankedSentences: c });
     const l = i.batch(c.length), p = (await Q(
       c,
-      async ({ sentence: w }) => {
+      async ({ sentence: b }) => {
         const f = await Ze("Ambiguous words or short phrases", {
           ...o,
-          attachments: { text: w },
+          attachments: { text: b },
           targetNewItemsCount: 5,
           onProgress: L(o.onProgress, "list:extract")
         });
-        return l(1), f.map((g) => ({ term: g, sentence: w }));
+        return l(1), f.map((g) => ({ term: g, sentence: b }));
       },
       {
         maxParallel: 3,
@@ -8399,13 +8404,13 @@ ${s}` : "", g = await ke(
     if (p.length === 0)
       return i.complete({ outcome: T.success }), [];
     const d = await ke(
-      p.map((w) => `${w.term} | ${w.sentence}`),
+      p.map((b) => `${b.term} | ${b.sentence}`),
       "Score how ambiguous the term is within the sentence.",
       {
         ...o,
         onProgress: L(o.onProgress, "score:term-ambiguity")
       }
-    ), y = p.map((w, f) => ({ ...w, score: d[f] ?? 0 })).toSorted((w, f) => (f.score || 0) - (w.score || 0));
+    ), y = p.map((b, f) => ({ ...b, score: d[f] ?? 0 })).toSorted((b, f) => (f.score || 0) - (b.score || 0));
     return i.complete({ outcome: T.success }), y.slice(0, a);
   } catch (c) {
     throw i.error(c), c;
@@ -8451,22 +8456,22 @@ ${s}` : r, i = A($s, n), a = I($s, i.onProgress, i);
           windowNumber: g + 1,
           totalWindows: p.length
         });
-        const h = f.fragments.map((P, x) => `${x + 1}. ${P}`).join(`
-`), b = c ? `
+        const m = f.fragments.map((P, x) => `${x + 1}. ${P}`).join(`
+`), w = c ? `
 
-${$(c, { tag: "style-guidance" })}` : "", v = `${o}${b}
+${$(c, { tag: "style-guidance" })}` : "", S = `${o}${w}
 
 Window ${g + 1} of ${p.length} - Join these fragments:
 
-${$(h, { tag: "fragments" })}
+${$(m, { tag: "fragments" })}
 
-Important: This is part of a larger sequence. Join these fragments while being mindful that this result will be combined with other processed windows. Add necessary connecting words, prepositions, conjunctions, or other filler text to create a coherent, grammatically correct, and semantically meaningful result. Output only the joined result for this window.`, S = await M(() => _(v, i), {
+Important: This is part of a larger sequence. Join these fragments while being mindful that this result will be combined with other processed windows. Add necessary connecting words, prepositions, conjunctions, or other filler text to create a coherent, grammatically correct, and semantically meaningful result. Output only the joined result for this window.`, v = await M(() => _(S, i), {
           label: `join-window-${g + 1}`,
           config: i,
           onProgress: L(i.onProgress, "window")
         });
         return d(1), {
-          content: S || f.fragments.join(" "),
+          content: v || f.fragments.join(" "),
           window: f
         };
       },
@@ -8476,7 +8481,7 @@ Important: This is part of a larger sequence. Join these fragments while being m
       return a.complete({ outcome: T.success, windows: p.length }), e.join(" ");
     if (y.length === 1)
       return a.complete({ outcome: T.success, windows: p.length }), y[0].content;
-    let w = y[0].content;
+    let b = y[0].content;
     for (let f = 1; f < y.length; f++) {
       a.emit({
         event: k.step,
@@ -8484,15 +8489,15 @@ Important: This is part of a larger sequence. Join these fragments while being m
         stitchNumber: f,
         totalStitches: y.length - 1
       });
-      const g = y[f], h = y[f - 1].window, b = g.window, v = Math.max(h.startIndex, b.startIndex), S = Math.min(h.endIndex, b.endIndex);
-      if (v <= S) {
-        const P = e.slice(v, S + 1), x = c ? `
+      const g = y[f], m = y[f - 1].window, w = g.window, S = Math.max(m.startIndex, w.startIndex), v = Math.min(m.endIndex, w.endIndex);
+      if (S <= v) {
+        const P = e.slice(S, v + 1), x = c ? `
 
 ${$(c, { tag: "style-guidance" })}` : "", E = P.join(" | "), O = `${o}${x}
 
 Stitch these two sections by resolving their overlapping region:
 
-${$(w, { tag: "section-a", name: "preserve-terminals" })}
+${$(b, { tag: "section-a", name: "preserve-terminals" })}
 
 ${$(g.content, { tag: "section-b", name: "preserve-terminals" })}
 
@@ -8501,10 +8506,10 @@ ${$(E, { tag: "overlapping-fragments" })}
 The terminal ends of both sections should be preserved. Only resolve the overlapping middle region where these fragments appear.
 
 Add necessary connecting words, prepositions, conjunctions, or other filler text to create a coherent, grammatically correct, and semantically meaningful result. Output only the final stitched result with terminals preserved.`;
-        w = await M(() => _(O, i), {
+        b = await M(() => _(O, i), {
           label: `join-stitch-${f}`,
           config: i
-        }) || w;
+        }) || b;
       } else {
         const P = c ? `
 
@@ -8512,18 +8517,18 @@ ${$(c, { tag: "style-guidance" })}` : "", x = `${o}${P}
 
 Join these two non-overlapping sections:
 
-${$(w, { tag: "section-1" })}
+${$(b, { tag: "section-1" })}
 
 ${$(g.content, { tag: "section-2" })}
 
 Add necessary connecting words, prepositions, conjunctions, or other filler text to create a coherent, grammatically correct, and semantically meaningful result. Output only the joined result.`;
-        w = await M(() => _(x, i), {
+        b = await M(() => _(x, i), {
           label: `join-nonoverlap-${f}`,
           config: i
-        }) || w;
+        }) || b;
       }
     }
-    return a.complete({ outcome: T.success, windows: p.length }), w;
+    return a.complete({ outcome: T.success, windows: p.length }), b;
   } catch (p) {
     throw a.error(p), p;
   }
@@ -8692,9 +8697,9 @@ async function Na(e, t, n) {
     u = $(f.join(`
 `), { tag: "sources" });
   }
-  const p = $(e, { tag: "sentence" }), d = $(r, { tag: "description" }), m = a ? "Include a brief context description for each reference explaining the scene or idea being referenced." : "Do not include context descriptions.", y = s ? `
+  const p = $(e, { tag: "sentence" }), d = $(r, { tag: "description" }), h = a ? "Include a brief context description for each reference explaining the scene or idea being referenced." : "Do not include context descriptions.", y = s ? `
 
-${s}` : "", w = `Find pop culture references that metaphorically capture the sentence based on its description.
+${s}` : "", b = `Find pop culture references that metaphorically capture the sentence based on its description.
 
 ${d}
 
@@ -8710,7 +8715,7 @@ Process:
 3. Score each reference based on how well it fits (0-1 scale)
 4. Identify which part of the sentence each reference connects to
 
-${m}
+${h}
 
 Requirements:
 - Each reference should be a specific moment, scene, or concept (not just the source name)
@@ -8719,7 +8724,7 @@ Requirements:
 - Higher scores mean stronger metaphorical fit${y}`;
   try {
     const f = await M(
-      () => _(w, {
+      () => _(b, {
         ...o,
         responseFormat: ib
       }),
@@ -8792,8 +8797,8 @@ ${s}` : r, i = A(As, n), a = I(As, i.onProgress, i);
   const { exploration: c } = await q(i, {
     exploration: J(lb)
   }), l = [], u = {}, p = [];
-  let d = !1, m = o;
-  const { shouldSkip: y = mb, shouldStop: w = hb } = i, f = await re("temperature", i, 1);
+  let d = !1, h = o;
+  const { shouldSkip: y = mb, shouldStop: b = hb } = i, f = await re("temperature", i, 1);
   let g = 0;
   try {
     for (; !d; ) {
@@ -8803,10 +8808,10 @@ ${s}` : r, i = A(As, n), a = I(As, i.onProgress, i);
         attempt: g + 1,
         questionsFound: l.length
       }), l.length) {
-        const x = l.filter((R) => !p.includes(R)), E = db(m, {
+        const x = l.filter((R) => !p.includes(R)), E = db(h, {
           existing: x
         });
-        m = (await M(
+        h = (await M(
           () => _(E, {
             ...i,
             responseFormat: C("selected_question", cb)
@@ -8815,26 +8820,26 @@ ${s}` : r, i = A(As, n), a = I(As, i.onProgress, i);
             label: "questions-pick-interesting",
             config: i
           }
-        )).question, p.push(m);
+        )).question, p.push(h);
       }
-      const h = fb(m, {
+      const m = fb(h, {
         existing: l
-      }), b = {
+      }), w = {
         ...i,
         temperature: f,
         responseFormat: C("questions_list", ab)
-      }, v = await M(() => _(h, b), {
+      }, S = await M(() => _(m, w), {
         label: "questions-generate",
         config: i
-      }), S = pb(v, c);
+      }), v = pb(S, c);
       if (c < 0.5) {
-        const x = Math.floor(Math.random() * S.length);
-        m = S[x];
+        const x = Math.floor(Math.random() * v.length);
+        h = v[x];
       }
-      const P = S.filter((x) => !(x in u));
+      const P = v.filter((x) => !(x in u));
       g += 1;
       for (const x of P) {
-        if (await w(x, l, S, g)) {
+        if (await b(x, l, v, g)) {
           d = !0;
           break;
         }
@@ -8842,8 +8847,8 @@ ${s}` : r, i = A(As, n), a = I(As, i.onProgress, i);
       }
     }
     a.complete({ outcome: T.success, questions: l.length, attempts: g });
-  } catch (h) {
-    throw a.error(h), h;
+  } catch (m) {
+    throw a.error(m), m;
   }
 }, Ra = async (e, t = {}) => {
   const n = gb(e, t), r = [];
@@ -9446,16 +9451,16 @@ ${s}` : r, i = A(Ns, { llm: { fast: !0, good: !0, cheap: !0 }, ...n }), a = I(Ns
     temperature: 0.1,
     preservation: J(Pw),
     mode: "structural"
-  }), { delimiter: m = Tw } = i, y = await re(
+  }), { delimiter: h = Tw } = i, y = await re(
     "preservationShort",
     i,
     p.short
-  ), w = await re("preservationLong", i, p.long);
+  ), b = await re("preservationLong", i, p.long);
   try {
-    const f = Kn(e, c), g = a.batch(f.length), h = await Q(
+    const f = Kn(e, c), g = a.batch(f.length), m = await Q(
       f,
-      async (S, P) => {
-        const E = kw(S, o, m, {
+      async (v, P) => {
+        const E = kw(v, o, h, {
           targetSplitCount: l,
           mode: d
         }), O = {
@@ -9468,14 +9473,14 @@ ${s}` : r, i = A(Ns, { llm: { fast: !0, good: !0, cheap: !0 }, ...n }), a = I(Ns
             config: i,
             onProgress: L(i.onProgress, "chunk")
           }), j = R.replace(
-            new RegExp(m.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+            new RegExp(h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
             ""
-          ), F = S.trim(), V = F.length < 100 ? y : w;
+          ), F = v.trim(), V = F.length < 100 ? y : b;
           return Math.abs(j.length - F.length) > F.length * V ? (i.logger?.warn && i.logger.warn(
             `Split output differs significantly from input for chunk ${P + 1}, using original chunk`
-          ), g(1), S) : (g(1), R);
+          ), g(1), v) : (g(1), R);
         } catch (R) {
-          return i.logger?.warn && i.logger.warn(`Split failed for chunk ${P + 1}:`, R.message), g(1), S;
+          return i.logger?.warn && i.logger.warn(`Split failed for chunk ${P + 1}:`, R.message), g(1), v;
         }
       },
       {
@@ -9484,12 +9489,12 @@ ${s}` : r, i = A(Ns, { llm: { fast: !0, good: !0, cheap: !0 }, ...n }), a = I(Ns
         abortSignal: i.abortSignal,
         label: "split chunks"
       }
-    ), b = m.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), v = h.join("").split(new RegExp(b)).map((S) => S.trim()).filter(Boolean);
+    ), w = h.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), S = m.join("").split(new RegExp(w)).map((v) => v.trim()).filter(Boolean);
     return a.complete({
       outcome: T.success,
       chunks: f.length,
-      segments: v.length
-    }), v;
+      segments: S.length
+    }), S;
   } catch (f) {
     throw a.error(f), f;
   }
@@ -9516,8 +9521,8 @@ const Rs = (e) => /^\d+$/.test(e), Aw = /^([^.]+(\.[^.]+)*)$/, Ow = (e, t, n) =>
     const u = Math.max(
       Math.ceil((l - s) * a),
       t
-    ), p = Math.floor(c.length / 2), d = p - Math.ceil(u / 2), m = p + Math.floor(u / 2);
-    c = c.slice(0, d) + i + c.slice(m), l = o.toTokens(c).length;
+    ), p = Math.floor(c.length / 2), d = p - Math.ceil(u / 2), h = p + Math.floor(u / 2);
+    c = c.slice(0, d) + i + c.slice(h), l = o.toTokens(c).length;
   }
   return c;
 }, Cw = ({ budget: e, type: t, value: n, fixes: r = [], llmOptions: s, sensitivity: o }) => {
@@ -9574,22 +9579,22 @@ class Ka extends Map {
           targetTokenCount: this.maxTokensPerValue,
           model: c
         }), p = c.toTokens(u).length, d = p < l;
-        let m = u;
+        let h = u;
         if (o) {
-          const w = {
+          const b = {
             ...this.llmOptions,
             ...i.modelOptions
           };
-          (i.sensitivity?.whitelist || i.sensitivity?.blacklist) && (w.sensitive = !0), m = await Cw({
+          (i.sensitivity?.whitelist || i.sensitivity?.blacklist) && (b.sensitive = !0), h = await Cw({
             budget: o,
             fixes: i.fixes,
-            llmOptions: w,
+            llmOptions: b,
             sensitivity: i.sensitivity,
             type: i.type,
             value: u
           });
         }
-        const y = c.toTokens(m).length;
+        const y = c.toTokens(h).length;
         t.emit({
           event: k.step,
           stepName: "context-trim",
@@ -9600,7 +9605,7 @@ class Ka extends Map {
           budget: o,
           strategy: o ? "shorten+summarize" : "shorten",
           ratio: Number((y / l).toFixed(3))
-        }), this.cache.set(s, m), r(1);
+        }), this.cache.set(s, h), r(1);
       }
       this.isCacheValid = !0, t.complete({ outcome: T.success, entries: n.length });
     } catch (n) {
@@ -9673,42 +9678,42 @@ const Nw = "http://json-schema.org/draft-07/schema#", Rw = "object", Mw = { tags
 }, Ls = "tag-vocabulary";
 function Gn(e, t, n = {}) {
   const { topN: r = 3, bottomN: s = 3, problematicSampleSize: o = 3 } = n, i = {};
-  e.tags.forEach((h) => {
-    i[h.id] = 0;
-  }), t.forEach((h) => {
-    h && Array.isArray(h) && h.forEach((b) => {
-      i[b] !== void 0 && i[b]++;
+  e.tags.forEach((m) => {
+    i[m.id] = 0;
+  }), t.forEach((m) => {
+    m && Array.isArray(m) && m.forEach((w) => {
+      i[w] !== void 0 && i[w]++;
     });
   });
-  const a = Object.entries(i).map(([h, b]) => ({
-    tag: e.tags.find((v) => v.id === h),
-    count: b
-  })).toSorted((h, b) => b.count - h.count), c = a.slice(0, r), l = a.slice(-s), u = t.filter((h) => h && h.length > 0).length, p = t.reduce((h, b) => h + (b ? b.length : 0), 0), d = t.length > 0 ? p / t.length : 0, m = {
+  const a = Object.entries(i).map(([m, w]) => ({
+    tag: e.tags.find((S) => S.id === m),
+    count: w
+  })).toSorted((m, w) => w.count - m.count), c = a.slice(0, r), l = a.slice(-s), u = t.filter((m) => m && m.length > 0).length, p = t.reduce((m, w) => m + (w ? w.length : 0), 0), d = t.length > 0 ? p / t.length : 0, h = {
     totalItems: t.length,
     itemsWithTags: u,
     coveragePercent: t.length > 0 ? u / t.length * 100 : 0,
     avgTagsPerItem: d,
     totalTags: e.tags.length,
-    unusedTags: a.filter((h) => h.count === 0).length
-  }, y = [], w = [], f = [], g = [];
-  return t.forEach((h, b) => {
-    !h || h.length === 0 ? w.length < o && w.push({
+    unusedTags: a.filter((m) => m.count === 0).length
+  }, y = [], b = [], f = [], g = [];
+  return t.forEach((m, w) => {
+    !m || m.length === 0 ? b.length < o && b.push({
       type: "untagged",
-      itemIndex: b,
+      itemIndex: w,
       tags: []
-    }) : h.length > d * 2 ? f.length < o && f.push({
+    }) : m.length > d * 2 ? f.length < o && f.push({
       type: "overtagged",
-      itemIndex: b,
-      tags: h,
-      tagCount: h.length
-    }) : h.length === 1 && d > 1.5 && g.length < o && g.push({
+      itemIndex: w,
+      tags: m,
+      tagCount: m.length
+    }) : m.length === 1 && d > 1.5 && g.length < o && g.push({
       type: "ambiguous",
-      itemIndex: b,
-      tags: h,
+      itemIndex: w,
+      tags: m,
       tagCount: 1
     });
-  }), y.push(...w, ...f, ...g), {
-    stats: m,
+  }), y.push(...b, ...f, ...g), {
+    stats: h,
     mostUsed: c,
     leastUsed: l,
     problematicItems: y,
@@ -9793,12 +9798,12 @@ ${o}` : r, a = A(Ls, n), c = I(Ls, a.onProgress, a);
     if (s.initialVocab)
       p = JSON.parse(s.initialVocab);
     else {
-      const w = t.slice(0, Math.min(u, t.length));
+      const b = t.slice(0, Math.min(u, t.length));
       c.emit({
         event: k.step,
         stepName: "generate-initial-vocabulary",
-        sampleCount: w.length
-      }), p = await Dw(i, w, a);
+        sampleCount: b.length
+      }), p = await Dw(i, b, a);
     }
     c.emit({
       event: k.step,
@@ -9806,8 +9811,8 @@ ${o}` : r, a = A(Ls, n), c = I(Ls, a.onProgress, a);
       itemCount: t.length,
       initialVocab: p
     });
-    const d = await l(t, p), m = Gn(p, d);
-    c.emit({ event: k.step, stepName: "refine-vocabulary", statistics: m });
+    const d = await l(t, p), h = Gn(p, d);
+    c.emit({ event: k.step, stepName: "refine-vocabulary", statistics: h });
     const y = await qw(p, d, i, a);
     return c.complete({ outcome: T.success }), y;
   } catch (l) {
@@ -9825,20 +9830,20 @@ async function Ha(e, t = {}) {
   try {
     let c;
     if (r.rawThemes)
-      c = r.rawThemes.split(",").map((m) => m.trim()).filter(Boolean);
+      c = r.rawThemes.split(",").map((h) => h.trim()).filter(Boolean);
     else {
-      const m = Fw(n);
+      const h = Fw(n);
       i.emit({
         event: k.phase,
         phase: "extraction"
       });
-      const w = `Update the accumulator with short themes from this text. Avoid duplicates. Return ONLY a comma-separated list of themes with no explanation or additional text.${s ? `
+      const b = `Update the accumulator with short themes from this text. Avoid duplicates. Return ONLY a comma-separated list of themes with no explanation or additional text.${s ? `
 
-${s}` : ""}`, f = Wn(m);
-      c = (await Ie(f, w, {
+${s}` : ""}`, f = Wn(h);
+      c = (await Ie(f, b, {
         ...o,
         onProgress: L(o.onProgress, "themes:extract")
-      })).split(",").map((h) => h.trim()).filter(Boolean);
+      })).split(",").map((m) => m.trim()).filter(Boolean);
     }
     i.emit({
       event: k.phase,
@@ -9848,7 +9853,7 @@ ${s}` : ""}`, f = Wn(m);
     const u = `Refine the accumulator by merging similar themes. ${a ? `Limit to the top ${a} themes.` : "Return all meaningful themes."} Return ONLY a comma-separated list with no explanation or additional text.`, d = (await Ie(c, u, {
       ...o,
       onProgress: L(o.onProgress, "themes:refine")
-    })).split(",").map((m) => m.trim()).filter(Boolean);
+    })).split(",").map((h) => h.trim()).filter(Boolean);
     return i.complete({ outcome: T.success, themes: d.length }), d;
   } catch (c) {
     throw i.error(c), c;
@@ -9927,25 +9932,25 @@ async function Qa(e, t, n) {
     overlap: u,
     maxParallel: p,
     errorPosture: d,
-    llmDedup: m,
+    llmDedup: h,
     knowledgeBase: y,
-    enrichMap: w
+    enrichMap: b
   } = await q(i, {
     enrichment: J(zw, ["llmDedup", "knowledgeBase", "enrichMap"]),
     chunkSize: 2e3,
     overlap: 200,
     maxParallel: 3,
     errorPosture: z.resilient
-  }), f = s.knowledge, { onProgress: g, batchSize: h, now: b } = i;
+  }), f = s.knowledge, { onProgress: g, batchSize: m, now: w } = i;
   try {
-    const v = 1 + (m ? 1 : 0) + (y ? 2 : 0), S = c.batch(v), P = Kn(e, l, { overlap: u }), x = [];
+    const S = 1 + (h ? 1 : 0) + (y ? 2 : 0), v = c.batch(S), P = Kn(e, l, { overlap: u }), x = [];
     let E = 0;
     await Q(
       P,
       async (j, F) => {
         try {
           const V = await M(
-            () => Vw(j, { ...i, now: b, systemPrompt: a }),
+            () => Vw(j, { ...i, now: w, systemPrompt: a }),
             {
               label: `timeline chunk ${F + 1}`,
               config: i
@@ -9966,9 +9971,9 @@ async function Qa(e, t, n) {
         label: "timeline chunks",
         abortSignal: i.abortSignal
       }
-    ), ne(`Timeline: processed ${P.length} chunks, found ${x.length} total events`), S(1);
+    ), ne(`Timeline: processed ${P.length} chunks, found ${x.length} total events`), v(1);
     let O = Ww([x]);
-    if (m && O.length > 0) {
+    if (h && O.length > 0) {
       const j = O.map((H) => `- ${H.timestamp}: ${H.name}`).join(`
 `), F = `Consolidate these timeline events by merging duplicates that refer to the same occurrence. Keep the most descriptive version of each event and preserve ALL unique events.
 
@@ -9977,7 +9982,7 @@ ${$(j, { tag: "events" })}`, V = await _(F, {
         systemPrompt: "You are a timeline deduplication engine. Return all unique events, merging only true duplicates.",
         responseFormat: C(Le.name, Le.schema)
       }), Y = V?.events || V;
-      Array.isArray(Y) && Y.length > 0 && (O = Ke(Y)), S(1);
+      Array.isArray(Y) && Y.length > 0 && (O = Ke(Y)), v(1);
     }
     if ((y || f) && O.length > 0) {
       let j = [];
@@ -10002,7 +10007,7 @@ Return as JSON with the same event format, maintaining chronological order.`, ie
           ...i,
           initial: JSON.stringify({ events: [] }),
           responseFormat: C(Le.name, Le.schema),
-          ...h !== void 0 && { batchSize: h },
+          ...m !== void 0 && { batchSize: m },
           onProgress: L(i.onProgress, "reduce:knowledge-base")
         });
         try {
@@ -10011,7 +10016,7 @@ Return as JSON with the same event format, maintaining chronological order.`, ie
           ne("Failed to parse knowledge base:", Z.message);
         }
       }
-      c.emit({ event: k.phase, phase: "enrichment", knowledgeBase: j }), S(1);
+      c.emit({ event: k.phase, phase: "enrichment", knowledgeBase: j }), v(1);
       const F = j.map((G) => `- ${G.timestamp}: ${G.name}`).join(`
 `), V = `Given an extracted event, enrich it using this knowledge base:
 
@@ -10028,7 +10033,7 @@ Return the enriched event as: "YYYY-MM-DD: Event name" or with the appropriate t
         V,
         {
           ...i,
-          ...h !== void 0 && { batchSize: h },
+          ...m !== void 0 && { batchSize: m },
           maxParallel: p,
           onProgress: L(i.onProgress, "map:enrichment")
         }
@@ -10045,12 +10050,12 @@ Return the enriched event as: "YYYY-MM-DD: Event name" or with the appropriate t
         }
         return O[te];
       }), ee = new Set(H.map((G) => G.name.toLowerCase())), pe = j.filter((G) => !ee.has(G.name.toLowerCase()));
-      O = Ke([...H, ...pe]), S(1);
+      O = Ke([...H, ...pe]), v(1);
     }
     const R = E > 0 ? T.partial : T.success;
     return c.complete({ outcome: R }), O;
-  } catch (v) {
-    throw c.error(v), v;
+  } catch (S) {
+    throw c.error(S), S;
   }
 }
 Qa.knownTexts = ["knowledge"];
@@ -10175,19 +10180,19 @@ async function tc(e, t, n) {
   try {
     const l = Zw(e, a), p = [...l].reverse().map((g) => g.text), d = s ? `
 
-${s}` : "", m = `${$(r, { tag: "removal_criteria" })}
+${s}` : "", h = `${$(r, { tag: "removal_criteria" })}
 
 NOTE: These text blocks are in REVERSE order (from end to beginning of document).
 Score how important THE ENTIRE TEXT BLOCK is to KEEP in the document (0 = should be removed, 10 = must keep).
 Each item in the list is ONE complete text block - evaluate it as a whole unit.
-Consider the removal criteria above when scoring.${d}`, w = (await ke(p, m, {
+Consider the removal criteria above when scoring.${d}`, b = (await ke(p, h, {
       ...o,
       onProgress: L(o.onProgress, "score:relevance")
       // Don't use stopOnThreshold - we need all scores to find high ones
     })).findIndex((g) => (g ?? 1 / 0) < c);
     let f;
-    if (w >= 0) {
-      const g = l.length - 1 - w;
+    if (b >= 0) {
+      const g = l.length - 1 - b;
       g > 0 ? f = l[g - 1].endIndex : f = 0;
     } else
       f = e.length;
@@ -10254,12 +10259,12 @@ ${r}` : "", o = A(Us, { llm: { sensitive: !0 }, ...t }), i = I(Us, o.onProgress,
     const u = i.batch(l.length), p = await Q(
       l,
       async (d) => {
-        const m = await M(() => _(d, { ...o, responseFormat: tv }), {
+        const h = await M(() => _(d, { ...o, responseFormat: tv }), {
           label: "veiled-variants",
           config: o,
           onProgress: L(o.onProgress, "strategy")
         });
-        return u(1), m;
+        return u(1), h;
       },
       { maxParallel: 3, errorPosture: z.resilient, abortSignal: o.abortSignal }
     );
@@ -10363,22 +10368,22 @@ async function pv(e, { columns: t = 2, tileHeight: n = 300, gutter: r = 4, quali
     w: f.info.width,
     h: f.info.height
   })), l = Math.ceil(e.length / t), u = Array.from({ length: t }, (f, g) => {
-    const h = c.filter((b, v) => v % t === g);
-    return h.length > 0 ? Math.max(...h.map((b) => b.w)) : 0;
-  }), p = u.reduce((f, g) => f + g, 0) + r * (t - 1), d = l * n + r * (l - 1), m = [];
+    const m = c.filter((w, S) => S % t === g);
+    return m.length > 0 ? Math.max(...m.map((w) => w.w)) : 0;
+  }), p = u.reduce((f, g) => f + g, 0) + r * (t - 1), d = l * n + r * (l - 1), h = [];
   for (let f = 0; f < c.length; f++) {
-    const g = f % t, h = Math.floor(f / t), b = u.slice(0, g).reduce((S, P) => S + P, 0) + r * g, v = h * (n + r);
-    if (c[f].x = b, c[f].y = v, m.push({ input: a[f].data, left: b, top: v }), c[f].label) {
-      const S = Math.min(24, c[f].h), P = Math.min(14, S - 2), x = c[f].label.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), E = Buffer.from(
-        `<svg width="${c[f].w}" height="${S}">
-          <rect x="0" y="0" width="${c[f].w}" height="${S}" fill="rgba(0,0,0,0.6)"/>
-          <text x="4" y="${S - 3}" font-family="sans-serif" font-size="${P}" fill="white">${x}</text>
+    const g = f % t, m = Math.floor(f / t), w = u.slice(0, g).reduce((v, P) => v + P, 0) + r * g, S = m * (n + r);
+    if (c[f].x = w, c[f].y = S, h.push({ input: a[f].data, left: w, top: S }), c[f].label) {
+      const v = Math.min(24, c[f].h), P = Math.min(14, v - 2), x = c[f].label.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;"), E = Buffer.from(
+        `<svg width="${c[f].w}" height="${v}">
+          <rect x="0" y="0" width="${c[f].w}" height="${v}" fill="rgba(0,0,0,0.6)"/>
+          <text x="4" y="${v - 3}" font-family="sans-serif" font-size="${P}" fill="white">${x}</text>
         </svg>`
       );
-      m.push({
+      h.push({
         input: E,
-        left: b,
-        top: v + c[f].h - S
+        left: w,
+        top: S + c[f].h - v
       });
     }
   }
@@ -10390,13 +10395,13 @@ async function pv(e, { columns: t = 2, tileHeight: n = 300, gutter: r = 4, quali
       channels: 3,
       background: { r: 128, g: 128, b: 128 }
     }
-  }).composite(m).jpeg({ quality: s }).toFile(y);
-  const w = await go(y);
+  }).composite(h).jpeg({ quality: s }).toFile(y);
+  const b = await go(y);
   return {
     path: y,
     width: p,
     height: d,
-    sizeBytes: w.size,
+    sizeBytes: b.size,
     tiles: c
   };
 }
@@ -10426,28 +10431,28 @@ ${s}` : r, i = A(Vs, n), a = I(Vs, i.onProgress, i);
     }), p = u && c.length > 1;
     let d;
     if (p) {
-      const f = c.map((v) => v.path), g = c.map((v) => v.label).filter(Boolean), h = await pv(f, {
+      const f = c.map((S) => S.path), g = c.map((S) => S.label).filter(Boolean), m = await pv(f, {
         labels: g.length > 0 ? g : void 0
       });
       a.emit({
         event: "tile",
-        path: h.path,
-        width: h.width,
-        height: h.height,
-        sizeBytes: h.sizeBytes
-      }), d = [await Ws(h.path)];
+        path: m.path,
+        width: m.width,
+        height: m.height,
+        sizeBytes: m.sizeBytes
+      }), d = [await Ws(m.path)];
     } else
       d = await Q(c, (f) => Ws(f.path), {
         maxParallel: 4,
         label: "analyze-image:encode",
         abortSignal: i.abortSignal
       });
-    const m = Zo(o, d), y = i.responseFormat ? i : { ...i, responseFormat: dv }, w = await M(() => _(m, y), {
+    const h = Zo(o, d), y = i.responseFormat ? i : { ...i, responseFormat: dv }, b = await M(() => _(h, y), {
       label: "analyze-image:llm",
       config: i,
       onProgress: L(i.onProgress, "llm")
     });
-    return a.complete({ outcome: T.success, imageCount: l, tiled: p }), w;
+    return a.complete({ outcome: T.success, imageCount: l, tiled: p }), b;
   } catch (u) {
     throw a.error(u, { imageCount: l }), u;
   }
@@ -10491,7 +10496,7 @@ ${r}` : n, o = A(Js, t), i = I(Js, o.onProgress, o);
         functionArgsAsArray: [l]
       };
     else {
-      const m = p.arguments, y = Array.isArray(m) ? m : [m];
+      const h = p.arguments, y = Array.isArray(h) ? h : [h];
       d = {
         ...p,
         functionArgsAsArray: y,
@@ -10838,15 +10843,15 @@ function mc(e = {}) {
   const t = A(Qs, e), n = I(Qs, t.onProgress, t);
   n.start();
   try {
-    let g = function(h, b = "log", v = 0) {
-      const S = Ov(v), P = {
+    let g = function(m, w = "log", S = 0) {
+      const v = Ov(S), P = {
         id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
         ts: /* @__PURE__ */ new Date(),
-        raw: h,
+        raw: m,
         // Store original data as-is (any structure)
         meta: /* @__PURE__ */ new Map([
-          ["level", b],
-          ["fileContext", S]
+          ["level", w],
+          ["fileContext", v]
         ]),
         attachments: {},
         // AI enrichments to merge
@@ -10857,41 +10862,41 @@ function mc(e = {}) {
       for (const x of s)
         if (!x.filters || x.filters(P)) {
           let E;
-          h == null ? E = {
-            data: h,
+          m == null ? E = {
+            data: m,
             id: P.id,
             ts: P.ts,
-            level: b,
+            level: w,
             ...P.attachments
-          } : typeof h == "string" || typeof h == "number" || typeof h == "boolean" ? E = {
-            data: h,
+          } : typeof m == "string" || typeof m == "number" || typeof m == "boolean" ? E = {
+            data: m,
             id: P.id,
             ts: P.ts,
-            level: b,
+            level: w,
             ...P.attachments
-          } : typeof h == "object" ? E = {
-            ...h,
+          } : typeof m == "object" ? E = {
+            ...m,
             // Spread all original properties
             ...P.attachments,
             // Merge AI enrichments
             // Add internal metadata only if not already present
-            ...h.id ? {} : { id: P.id },
-            ...h.ts ? {} : { ts: P.ts },
-            ...h.level ? {} : { level: b },
+            ...m.id ? {} : { id: P.id },
+            ...m.ts ? {} : { ts: P.ts },
+            ...m.level ? {} : { level: w },
             // Add file context
-            ...h.file ? {} : { file: S.filePath },
-            ...h.line ? {} : { line: S.line }
+            ...m.file ? {} : { file: v.filePath },
+            ...m.line ? {} : { line: v.line }
           } : E = {
-            data: h,
+            data: m,
             id: P.id,
             ts: P.ts,
-            level: b,
+            level: w,
             ...P.attachments
           }, E.aiMeta = P.aiMeta, d.get(x.laneId).push(E);
         }
       if (a && f(), p) {
-        const x = `LLM Logger processed: ${JSON.stringify(h)}`;
-        switch (b) {
+        const x = `LLM Logger processed: ${JSON.stringify(m)}`;
+        switch (w) {
           case "error":
             p.error(x);
             break;
@@ -10923,19 +10928,19 @@ function mc(e = {}) {
       immediateFlush: a = !1,
       hostLogger: c = void 0
     } = e, l = new Mn(r), u = [], p = c ? Hs(c) : void 0, d = /* @__PURE__ */ new Map();
-    s.forEach((h) => {
-      Iv(h.laneId !== void 0, "Each lane must have an laneId property").toBe(!0), d.set(h.laneId, []);
+    s.forEach((m) => {
+      Iv(m.laneId !== void 0, "Each lane must have an laneId property").toBe(!0), d.set(m.laneId, []);
     });
-    const m = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map();
-    let w = !1;
-    o.forEach((h) => {
-      const b = l.registerReader();
-      y.set(h.processorId, b), m.set(h.processorId, -1);
-      const v = h.batchSize || 10, S = async () => {
-        if (!w)
+    const h = /* @__PURE__ */ new Map(), y = /* @__PURE__ */ new Map();
+    let b = !1;
+    o.forEach((m) => {
+      const w = l.registerReader();
+      y.set(m.processorId, w), h.set(m.processorId, -1);
+      const S = m.batchSize || 10, v = async () => {
+        if (!b)
           try {
-            const P = await l.readBatch(b, v, h.batchTimeout), x = Cv(P.data), O = `# Log Processing Context
-# Processor: ${h.processorId} (${h.description || "No description"})
+            const P = await l.readBatch(w, S, m.batchTimeout), x = Cv(P.data), O = `# Log Processing Context
+# Processor: ${m.processorId} (${m.description || "No description"})
 # Batch size: ${P.data.length} logs
 # Task: Analyze the following NDJSON log entries and return bulk adjustments
 # 
@@ -10955,7 +10960,7 @@ function mc(e = {}) {
 # ]
 #
 # NDJSON Log Data:
-` + x, R = await h.process(O);
+` + x, R = await m.process(O);
             if (Array.isArray(R))
               for (const j of R) {
                 const F = u.findIndex((V) => V.id === j.logId);
@@ -10967,53 +10972,53 @@ function mc(e = {}) {
                   j.aiMeta && (V.aiMeta || (V.aiMeta = {}), Object.assign(V.aiMeta, j.aiMeta));
                 }
               }
-            m.set(h.processorId, P.lastOffset), w || setTimeout(S, 0);
+            h.set(m.processorId, P.lastOffset), b || setTimeout(v, 0);
           } catch (P) {
-            p && p.error(`Processor ${h.processorId} error: ${P.message}`), w || setTimeout(S, 1e3);
+            p && p.error(`Processor ${m.processorId} error: ${P.message}`), b || setTimeout(v, 1e3);
           }
       };
-      S();
+      v();
     });
     const f = () => {
-      for (const [h, b] of d)
-        if (b.length > 0) {
-          const v = s.find((S) => S.laneId === h);
-          if (v) {
-            const S = b.filter((P) => !P.aiMeta?.skip);
-            S.length > 0 && v.writer(S), b.length = 0;
+      for (const [m, w] of d)
+        if (w.length > 0) {
+          const S = s.find((v) => v.laneId === m);
+          if (S) {
+            const v = w.filter((P) => !P.aiMeta?.skip);
+            v.length > 0 && S.writer(v), w.length = 0;
           }
         }
     };
-    return a || s.forEach((h) => {
-      const b = () => {
-        w || (f(), setTimeout(b, i));
+    return a || s.forEach((m) => {
+      const w = () => {
+        b || (f(), setTimeout(w, i));
       };
-      b();
+      w();
     }), n.complete({
       outcome: T.success,
       lanes: s.length,
       processors: o.length
     }), {
       // Standard logger interface - accepts any structured data
-      log: (h, b = 0) => g(h, "log", b),
-      info: (h, b = 0) => g(h, "info", b),
-      warn: (h, b = 0) => g(h, "warn", b),
-      error: (h, b = 0) => g(h, "error", b),
-      debug: (h, b = 0) => g(h, "debug", b),
-      trace: (h, b = 0) => g(h, "trace", b),
-      fatal: (h, b = 0) => g(h, "fatal", b),
+      log: (m, w = 0) => g(m, "log", w),
+      info: (m, w = 0) => g(m, "info", w),
+      warn: (m, w = 0) => g(m, "warn", w),
+      error: (m, w = 0) => g(m, "error", w),
+      debug: (m, w = 0) => g(m, "debug", w),
+      trace: (m, w = 0) => g(m, "trace", w),
+      fatal: (m, w = 0) => g(m, "fatal", w),
       // Enhanced attachment API
-      attachToLog: (h, b, v) => {
-        const S = u.findIndex((P) => P.id === h);
-        return S !== -1 ? (Ys(u[S].attachments, b, v), !0) : !1;
+      attachToLog: (m, w, S) => {
+        const v = u.findIndex((P) => P.id === m);
+        return v !== -1 ? (Ys(u[v].attachments, w, S), !0) : !1;
       },
-      getLogAttachment: (h, b) => {
-        const v = u.find((S) => S.id === h);
-        return v ? _v(v.attachments, b) : void 0;
+      getLogAttachment: (m, w) => {
+        const S = u.find((v) => v.id === m);
+        return S ? _v(S.attachments, w) : void 0;
       },
-      markLogSkippable: (h, b = !0) => {
-        const v = u.findIndex((S) => S.id === h);
-        return v !== -1 ? (u[v].aiMeta.skip = b, !0) : !1;
+      markLogSkippable: (m, w = !0) => {
+        const S = u.findIndex((v) => v.id === m);
+        return S !== -1 ? (u[S].aiMeta.skip = w, !0) : !1;
       },
       // Ring buffer access - legacy API compatibility
       ringBuffer: {
@@ -11022,27 +11027,27 @@ function mc(e = {}) {
         clear: () => {
           u.length = 0, l.clear();
         },
-        tail: (h) => u.slice(-h),
-        head: (h) => u.slice(0, h),
-        filter: (h) => u.filter(h)
+        tail: (m) => u.slice(-m),
+        head: (m) => u.slice(0, m),
+        filter: (m) => u.filter(m)
       },
       // Processor status
-      getProcessorOffsets: () => new Map(m),
+      getProcessorOffsets: () => new Map(h),
       // Host logger integration
-      setHostLogger: (h) => (e.hostLogger = h, Hs(h)),
+      setHostLogger: (m) => (e.hostLogger = m, Hs(m)),
       // Utility methods
       flush: () => {
         f();
       },
       clear: () => {
         u.length = 0, l.clear();
-        for (const h of d.values())
-          h.length = 0;
+        for (const m of d.values())
+          m.length = 0;
       },
       destroy: () => {
-        w = !0, f(), u.length = 0, l.clear();
-        for (const h of d.values())
-          h.length = 0;
+        b = !0, f(), u.length = 0, l.clear();
+        for (const m of d.values())
+          m.length = 0;
       },
       getConfig: () => ({
         ringBufferSize: r,
@@ -11053,22 +11058,22 @@ function mc(e = {}) {
       }),
       getStats: () => ({
         ...l.getStats(),
-        processorOffsets: Object.fromEntries(m),
-        processors: o.map((h) => ({
-          id: h.processorId,
-          processedOffset: m.get(h.processorId)
+        processorOffsets: Object.fromEntries(h),
+        processors: o.map((m) => ({
+          id: m.processorId,
+          processedOffset: h.get(m.processorId)
         }))
       }),
       // Wait for all processors to catch up to current write position
-      waitForProcessing: async (h = 3e4) => {
-        const b = Date.now(), S = l.getStats().writeOffset;
-        if (S === 0)
+      waitForProcessing: async (m = 3e4) => {
+        const w = Date.now(), v = l.getStats().writeOffset;
+        if (v === 0)
           return;
         f();
-        const P = (x, E) => E + 1 < S;
-        for (; Date.now() - b < h; ) {
+        const P = (x, E) => E + 1 < v;
+        for (; Date.now() - w < m; ) {
           let x = !0;
-          for (const [E, O] of m)
+          for (const [E, O] of h)
             if (P(E, O)) {
               x = !1;
               break;
@@ -11081,13 +11086,13 @@ function mc(e = {}) {
         }
         if (p) {
           const x = [];
-          for (const [E, O] of m)
+          for (const [E, O] of h)
             if (P(E, O)) {
-              const R = S - O - 1;
+              const R = v - O - 1;
               x.push(`${E} (${R} logs pending)`);
             }
           p.warn(
-            `waitForProcessing timeout after ${h}ms. Lagging processors: ${x.join(
+            `waitForProcessing timeout after ${m}ms. Lagging processors: ${x.join(
               ", "
             )}`
           );
@@ -11366,15 +11371,15 @@ function gc({
   const { text: a, context: c } = N(e, []), l = A(eo, { llm: o, ...i }), u = I(eo, l.onProgress, l);
   u.start(), u.emit({ event: k.input, value: a });
   const p = l.now ?? /* @__PURE__ */ new Date(), d = u.batch();
-  let m, y = 0, w = 0, f = r;
+  let h, y = 0, b = 0, f = r;
   const g = [];
-  let h = !0, b;
-  const v = async () => {
-    if (!h) return;
-    b || (b = await q(l, {
+  let m = !0, w;
+  const S = async () => {
+    if (!m) return;
+    w || (w = await q(l, {
       tolerance: J(Wv)
     }));
-    const { tolerance: P } = b;
+    const { tolerance: P } = w;
     try {
       u.emit({
         event: k.step,
@@ -11420,29 +11425,29 @@ function gc({
         metric: ge.tickDuration,
         value: Date.now() - p.getTime(),
         tickNumber: y + 1
-      }), w = 0, y += 1, d(1), h && (m = setTimeout(v, j));
+      }), b = 0, y += 1, d(1), m && (h = setTimeout(S, j));
     } catch (x) {
-      if (ne(`Error in setInterval step: ${x.message}`), w += 1, u.emit({
+      if (ne(`Error in setInterval step: ${x.message}`), b += 1, u.emit({
         event: k.step,
         stepName: "tick-error",
         tickNumber: y + 1,
         error: x.message,
-        consecutiveErrors: w
+        consecutiveErrors: b
       }), s && f && await s({
         timingString: "error - using fallback",
         data: f,
         nextDate: new Date(Date.now() + 1e3),
         // 1 second fallback
         error: x.message
-      }), y += 1, d(1), w >= P) {
-        h = !1, clearTimeout(m), u.error(x);
+      }), y += 1, d(1), b >= P) {
+        m = !1, clearTimeout(h), u.error(x);
         return;
       }
-      h && (m = setTimeout(v, 1e3));
+      m && (h = setTimeout(S, 1e3));
     }
   };
-  return m = setTimeout(v, 0), () => {
-    h = !1, clearTimeout(m), u.complete({ outcome: T.success, ticks: y });
+  return h = setTimeout(S, 0), () => {
+    m = !1, clearTimeout(h), u.complete({ outcome: T.success, ticks: y });
   };
 }
 gc.knownTexts = [];
@@ -11513,12 +11518,12 @@ async function Gv(e) {
   console.error(`[verblets:embed] Loading pipeline model "${t}"…`);
   const a = await Xc("feature-extraction", t, { dtype: n });
   return console.error(`[verblets:embed] Pipeline model "${t}" ready (${Date.now() - i}ms)`), { embedTexts: async (l, u = {}) => {
-    const { batchSize: p = o, abortSignal: d } = u, m = dn(l, p), y = [];
-    for (const w of m) {
+    const { batchSize: p = o, abortSignal: d } = u, h = dn(l, p), y = [];
+    for (const b of h) {
       d?.throwIfAborted();
-      const f = await a(w, { pooling: r, normalize: s }), g = f.dims.at(-1);
-      for (let h = 0; h < w.length; h++)
-        y.push(new Float32Array(f.data.slice(h * g, (h + 1) * g)));
+      const f = await a(b, { pooling: r, normalize: s }), g = f.dims.at(-1);
+      for (let m = 0; m < b.length; m++)
+        y.push(new Float32Array(f.data.slice(m * g, (m + 1) * g)));
     }
     return y;
   }, embedImages: void 0, dimensions: e.dimensions };
@@ -11532,21 +11537,21 @@ async function Yv(e) {
     Hc.from_pretrained(t),
     Qc.from_pretrained(t, { dtype: n })
   ]);
-  return console.error(`[verblets:embed] CLIP model "${t}" ready (${Date.now() - o}ms)`), { embedTexts: async (d, m = {}) => {
-    const { batchSize: y = r, abortSignal: w } = m, f = dn(d, y), g = [];
-    for (const h of f) {
-      w?.throwIfAborted();
-      const b = i(h, { padding: !0, truncation: !0 }), S = (await a(b)).text_embeds, P = S.dims[1];
-      for (let x = 0; x < h.length; x++)
-        g.push(no(new Float32Array(S.data.slice(x * P, (x + 1) * P))));
+  return console.error(`[verblets:embed] CLIP model "${t}" ready (${Date.now() - o}ms)`), { embedTexts: async (d, h = {}) => {
+    const { batchSize: y = r, abortSignal: b } = h, f = dn(d, y), g = [];
+    for (const m of f) {
+      b?.throwIfAborted();
+      const w = i(m, { padding: !0, truncation: !0 }), v = (await a(w)).text_embeds, P = v.dims[1];
+      for (let x = 0; x < m.length; x++)
+        g.push(no(new Float32Array(v.data.slice(x * P, (x + 1) * P))));
     }
     return g;
-  }, embedImages: async (d, m = {}) => {
-    const { batchSize: y = s, abortSignal: w } = m, f = dn(d, y), g = [];
-    for (const h of f) {
-      w?.throwIfAborted();
-      const b = await Promise.all(h.map((E) => Zc.read(E))), v = await c(b), P = (await l(v)).image_embeds, x = P.dims[1];
-      for (let E = 0; E < h.length; E++)
+  }, embedImages: async (d, h = {}) => {
+    const { batchSize: y = s, abortSignal: b } = h, f = dn(d, y), g = [];
+    for (const m of f) {
+      b?.throwIfAborted();
+      const w = await Promise.all(m.map((E) => Zc.read(E))), S = await c(w), P = (await l(S)).image_embeds, x = P.dims[1];
+      for (let E = 0; E < m.length; E++)
         g.push(no(new Float32Array(P.data.slice(E * x, (E + 1) * x))));
     }
     return g;
@@ -11717,8 +11722,8 @@ function Xv(e, t, n) {
     if (o && i + u > n && c(), u > n) {
       const p = l.split(new RegExp("(?<=[.!?])\\s+"));
       for (const d of p) {
-        const m = or(d).length;
-        o && i + m > n && c(), o += (o ? " " : "") + d, i += m;
+        const h = or(d).length;
+        o && i + h > n && c(), o += (o ? " " : "") + d, i += h;
       }
     } else
       o += (o ? `
@@ -11942,8 +11947,8 @@ function aS(e, t, n = {}) {
       i.push(u);
       continue;
     }
-    const d = Math.max(0, p - r), m = Math.min(t.length - 1, p + r);
-    o.push({ lo: d, hi: m, score: u.score ?? 0 });
+    const d = Math.max(0, p - r), h = Math.min(t.length - 1, p + r);
+    o.push({ lo: d, hi: h, score: u.score ?? 0 });
   }
   const a = o.toSorted((u, p) => u.lo - p.lo), l = _c(a).map(({ lo: u, hi: p, score: d }) => Cc(t, u, p, d));
   for (const u of i)
@@ -12118,24 +12123,24 @@ function TS(e, { cwd: t, timeout: n, abortSignal: r }) {
       env: PS()
     }), l = [], u = [];
     let p = !1;
-    c.stdout.on("data", (m) => l.push(m)), c.stderr.on("data", (m) => u.push(m));
+    c.stdout.on("data", (h) => l.push(h)), c.stderr.on("data", (h) => u.push(h));
     const d = n ? setTimeout(() => {
       c.kill("SIGTERM"), p || (p = !0, o(new Error(`Agent timed out after ${n}ms`)));
     }, n) : void 0;
-    if (c.on("close", (m) => {
+    if (c.on("close", (h) => {
       if (d && clearTimeout(d), p) return;
       p = !0;
-      const y = Buffer.concat(l).toString(), w = Buffer.concat(u).toString();
-      if (m !== 0 && !y.trim()) {
-        const f = w?.trim() || `exit code ${m}`;
-        o(new Error(`Agent exited with code ${m}: ${f}`));
+      const y = Buffer.concat(l).toString(), b = Buffer.concat(u).toString();
+      if (h !== 0 && !y.trim()) {
+        const f = b?.trim() || `exit code ${h}`;
+        o(new Error(`Agent exited with code ${h}: ${f}`));
       } else
         s(y);
     }), r) {
-      const m = () => {
+      const h = () => {
         c.kill("SIGTERM"), p || (p = !0, o(new Error("Agent execution aborted")));
       };
-      r.aborted ? (c.kill("SIGTERM"), p = !0, o(new Error("Agent execution aborted"))) : (r.addEventListener("abort", m, { once: !0 }), c.on("close", () => r.removeEventListener("abort", m)));
+      r.aborted ? (c.kill("SIGTERM"), p = !0, o(new Error("Agent execution aborted"))) : (r.addEventListener("abort", h, { once: !0 }), c.on("close", () => r.removeEventListener("abort", h)));
     }
   });
 }
@@ -12153,23 +12158,23 @@ async function ES(e, t, n = {}) {
   const l = c.batch(t.length), u = new Array(t.length), p = Ce(r)(t);
   let d = 0;
   try {
-    for (const m of p) {
+    for (const h of p) {
       if (o?.aborted) throw o.reason ?? new Error("Aborted");
-      const y = m.map(async (w, f) => {
+      const y = h.map(async (b, f) => {
         const g = d + f;
         try {
-          u[g] = await e(w, g);
-        } catch (h) {
-          if (s === z.strict) throw h;
-          u[g] = w;
+          u[g] = await e(b, g);
+        } catch (m) {
+          if (s === z.strict) throw m;
+          u[g] = b;
         }
         l(1);
       });
-      s === z.strict ? await Promise.all(y) : await Promise.allSettled(y), d += m.length;
+      s === z.strict ? await Promise.all(y) : await Promise.allSettled(y), d += h.length;
     }
     return c.complete({ outcome: T.success, totalItems: t.length }), u;
-  } catch (m) {
-    throw c.error(m), m;
+  } catch (h) {
+    throw c.error(h), h;
   }
 }
 async function IS(e, t, n = {}) {
@@ -12188,22 +12193,22 @@ async function IS(e, t, n = {}) {
   try {
     for (const y of p) {
       if (o?.aborted) throw o.reason ?? new Error("Aborted");
-      const w = y.map(async (f, g) => {
-        const h = d + g;
+      const b = y.map(async (f, g) => {
+        const m = d + g;
         try {
-          u[h] = await e(f, h);
-        } catch (b) {
-          if (s === z.strict) throw b;
-          u[h] = !1;
+          u[m] = await e(f, m);
+        } catch (w) {
+          if (s === z.strict) throw w;
+          u[m] = !1;
         }
         l(1);
       });
-      s === z.strict ? await Promise.all(w) : await Promise.allSettled(w), d += y.length;
+      s === z.strict ? await Promise.all(b) : await Promise.allSettled(b), d += y.length;
     }
-    const m = t.filter((y, w) => u[w]);
-    return c.complete({ outcome: T.success, totalItems: t.length, kept: m.length }), m;
-  } catch (m) {
-    throw c.error(m), m;
+    const h = t.filter((y, b) => u[b]);
+    return c.complete({ outcome: T.success, totalItems: t.length, kept: h.length }), h;
+  } catch (h) {
+    throw c.error(h), h;
   }
 }
 async function kS(e, t, n = {}) {
@@ -12222,19 +12227,19 @@ async function kS(e, t, n = {}) {
   try {
     for (const d of u) {
       if (o?.aborted) throw o.reason ?? new Error("Aborted");
-      const m = new Array(d.length), y = d.map(async (f, g) => {
+      const h = new Array(d.length), y = d.map(async (f, g) => {
         try {
-          m[g] = { item: f, matched: await e(f, p + g) };
-        } catch (h) {
-          if (s === z.strict) throw h;
-          m[g] = { item: f, matched: !1 };
+          h[g] = { item: f, matched: await e(f, p + g) };
+        } catch (m) {
+          if (s === z.strict) throw m;
+          h[g] = { item: f, matched: !1 };
         }
         l(1);
       });
       s === z.strict ? await Promise.all(y) : await Promise.allSettled(y);
-      const w = m.find((f) => f.matched);
-      if (w)
-        return c.complete({ outcome: T.success, found: !0 }), w.item;
+      const b = h.find((f) => f.matched);
+      if (b)
+        return c.complete({ outcome: T.success, found: !0 }), b.item;
       p += d.length;
     }
     c.complete({ outcome: T.success, found: !1 });
@@ -12274,29 +12279,29 @@ async function OS(e, t, n = {}) {
   try {
     for (const y of p) {
       if (o?.aborted) throw o.reason ?? new Error("Aborted");
-      const w = y.map(async (f, g) => {
-        const h = d + g;
+      const b = y.map(async (f, g) => {
+        const m = d + g;
         try {
-          u[h] = await e(f, h);
-        } catch (b) {
-          if (s === z.strict) throw b;
-          u[h] = "other";
+          u[m] = await e(f, m);
+        } catch (w) {
+          if (s === z.strict) throw w;
+          u[m] = "other";
         }
         l(1);
       });
-      s === z.strict ? await Promise.all(w) : await Promise.allSettled(w), d += y.length;
+      s === z.strict ? await Promise.all(b) : await Promise.allSettled(b), d += y.length;
     }
-    const m = {};
-    return t.forEach((y, w) => {
-      const f = String(u[w] ?? "other");
-      m[f] || (m[f] = []), m[f].push(y);
+    const h = {};
+    return t.forEach((y, b) => {
+      const f = String(u[b] ?? "other");
+      h[f] || (h[f] = []), h[f].push(y);
     }), c.complete({
       outcome: T.success,
       totalItems: t.length,
-      groupCount: Object.keys(m).length
-    }), m;
-  } catch (m) {
-    throw c.error(m), m;
+      groupCount: Object.keys(h).length
+    }), h;
+  } catch (h) {
+    throw c.error(h), h;
   }
 }
 async function _S(e, t, n = {}) {
@@ -12398,8 +12403,8 @@ function MS(e, t, n = {}) {
     }, t));
   }
   let l, u;
-  const p = new Promise((y, w) => {
-    l = y, u = w;
+  const p = new Promise((y, b) => {
+    l = y, u = b;
   }), d = () => {
     if (!i) {
       a();
@@ -12407,8 +12412,8 @@ function MS(e, t, n = {}) {
       r && r(void 0, y), u(y);
     }
   };
-  return s?.aborted ? (d(), p) : (s?.addEventListener("abort", d, { once: !0 }), c(), e((y, w) => {
-    r && r(y, w), c();
+  return s?.aborted ? (d(), p) : (s?.addEventListener("abort", d, { once: !0 }), c(), e((y, b) => {
+    r && r(y, b), c();
   }).then((y) => {
     i || (a(), l(y));
   }).catch((y) => {
@@ -12630,17 +12635,17 @@ const US = {
   const s = async (o, i = {}) => {
     const { untrusted: a = !1 } = i, c = A(e, { maxAttempts: 3, ...i }), l = typeof n == "function" ? n(o, c) : n, u = typeof t == "function" ? t(o, c) : t, p = I(e, c.onProgress, c);
     p.start(), p.emit({ event: k.step, stepName: "analyzing" });
-    const d = r(o, c), m = a ? u + ai : u, y = a ? [ci, ...d] : d, w = await M(
+    const d = r(o, c), h = a ? u + ai : u, y = a ? [ci, ...d] : d, b = await M(
       () => _(y.join(`
 
 `), {
         ...c,
-        systemPrompt: m,
+        systemPrompt: h,
         responseFormat: C(l.name, l.schema)
       }),
       { label: e, config: c }
     );
-    return ne(`${e}: complete`), p.complete({ outcome: T.success }), w;
+    return ne(`${e}: complete`), p.complete({ outcome: T.success }), b;
   };
   return s.with = (o = {}) => (i) => s(i, o), s;
 }, co = `You are a prompt structure advisor. You analyze prompt text and propose structural improvements — inputs to add, remove, or modify, and text changes to make the piece work better with external material.
@@ -12846,11 +12851,11 @@ async function wx({ sourceTexts: e, schema: t }, n = {}) {
     const l = s.batch(e.length), p = (await Q(
       c,
       async (d) => {
-        const m = await bx(d, t, {
+        const h = await bx(d, t, {
           ...r,
           onProgress: L(r.onProgress, "batch")
         });
-        return l(d.length), m;
+        return l(d.length), h;
       },
       { maxParallel: o }
     )).flat();
@@ -12971,25 +12976,25 @@ async function Ox(e, t) {
 async function _x({ fragmentSets: e, schema: t }, n = {}) {
   const o = e.flatMap((g) => g.fragments).some((g) => g.image) ? { ...n, embedding: { multi: !0 } } : n, i = [], a = /* @__PURE__ */ new Map(), c = [], l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map();
   for (const g of e)
-    for (const h of g.fragments) {
-      const b = !!h.image, v = b ? `img:${h.image}` : `txt:${h.text}`;
-      b && !l.has(h.image) && (l.set(h.image, c.length), c.push(h.image)), !b && !a.has(h.text) && (a.set(h.text, i.length), i.push(h.text));
-      const S = h.sourceIds?.[0] ?? g.fragmentSetId;
-      u.has(S) || u.set(S, /* @__PURE__ */ new Map());
-      const P = u.get(S);
-      P.has(h.projectionName) || P.set(h.projectionName, []), P.get(h.projectionName).push(v);
-    }
-  const p = i.length > 0 ? await nt(i, o) : [], d = c.length > 0 ? await er(c, o) : [], m = (g) => g.startsWith("img:") ? d[l.get(g.slice(4))] : p[a.get(g.slice(4))], y = [];
-  for (const [g, h] of u) {
-    const b = {}, v = [];
-    for (const [P, x] of h) {
-      const E = x.map(m), O = mn(E);
-      O && (b[P] = ft(O), v.push(...E));
-    }
-    const S = v.length > 0 ? ft(mn(v)) : void 0;
-    y.push({ stateId: g, vectorsByProjectionName: b, baseVector: S });
-  }
-  const w = await Ox(t, o), f = w !== t._poles ? { ...t, _poles: w } : t;
+    for (const m of g.fragments) {
+      const w = !!m.image, S = w ? `img:${m.image}` : `txt:${m.text}`;
+      w && !l.has(m.image) && (l.set(m.image, c.length), c.push(m.image)), !w && !a.has(m.text) && (a.set(m.text, i.length), i.push(m.text));
+      const v = m.sourceIds?.[0] ?? g.fragmentSetId;
+      u.has(v) || u.set(v, /* @__PURE__ */ new Map());
+      const P = u.get(v);
+      P.has(m.projectionName) || P.set(m.projectionName, []), P.get(m.projectionName).push(S);
+    }
+  const p = i.length > 0 ? await nt(i, o) : [], d = c.length > 0 ? await er(c, o) : [], h = (g) => g.startsWith("img:") ? d[l.get(g.slice(4))] : p[a.get(g.slice(4))], y = [];
+  for (const [g, m] of u) {
+    const w = {}, S = [];
+    for (const [P, x] of m) {
+      const E = x.map(h), O = mn(E);
+      O && (w[P] = ft(O), S.push(...E));
+    }
+    const v = S.length > 0 ? ft(mn(S)) : void 0;
+    y.push({ stateId: g, vectorsByProjectionName: w, baseVector: v });
+  }
+  const b = await Ox(t, o), f = b !== t._poles ? { ...t, _poles: b } : t;
   return { states: y, schema: f };
 }
 function Cx({ states: e, editsByProjectionName: t }) {
@@ -13033,17 +13038,17 @@ function Lc(e, t, n, r) {
       continue;
     }
     let u = 0, p = 0, d = 0;
-    for (const [h, b] of Object.entries(c.projectionWeights)) {
-      const v = e.vectorsByProjectionName[h];
-      if (!v) continue;
-      const S = n[h] ?? 1, P = b * S, x = Ix(v, l.low, l.high);
+    for (const [m, w] of Object.entries(c.projectionWeights)) {
+      const S = e.vectorsByProjectionName[m];
+      if (!S) continue;
+      const v = n[m] ?? 1, P = w * v, x = Ix(S, l.low, l.high);
       u += x * P, p += P, d += 1;
     }
     if (p === 0) {
       s[c.propertyName] = void 0, o[c.propertyName] = { value: void 0, confidence: 0 };
       continue;
     }
-    const m = u / p, y = Nx(m, c.valueRange), w = d / Math.max(1, Object.keys(c.projectionWeights).length), f = Math.min(1, a / 0.5), g = w * f;
+    const h = u / p, y = Nx(h, c.valueRange), b = d / Math.max(1, Object.keys(c.projectionWeights).length), f = Math.min(1, a / 0.5), g = b * f;
     s[c.propertyName] = y, o[c.propertyName] = { value: y, confidence: g };
   }
   return { values: s, details: o };
@@ -13072,20 +13077,20 @@ async function Lx({ leftStates: e, rightStates: t, intent: n }, r = {}) {
   const l = Object.entries(s).filter(([p]) => !a.has(p)).filter(([, p]) => p !== 0), u = [];
   for (const p of e)
     for (const d of t) {
-      let m = 0, y = 0;
+      let h = 0, y = 0;
       for (const [f, g] of l) {
-        const h = p.vectorsByProjectionName[f], b = d.vectorsByProjectionName[f];
-        if (h && b) {
-          let v = Pe(h, b);
+        const m = p.vectorsByProjectionName[f], w = d.vectorsByProjectionName[f];
+        if (m && w) {
+          let S = Pe(m, w);
           if (c) {
-            const S = Pe(c, h), P = Pe(c, b);
-            v = v * 0.6 + (S + P) * 0.2;
+            const v = Pe(c, m), P = Pe(c, w);
+            S = S * 0.6 + (v + P) * 0.2;
           }
-          m += v * g, y += g;
+          h += S * g, y += g;
         }
       }
-      const w = y > 0 ? m / y : 0;
-      u.push({ leftStateId: p.stateId, rightStateId: d.stateId, score: w });
+      const b = y > 0 ? h / y : 0;
+      u.push({ leftStateId: p.stateId, rightStateId: d.stateId, score: b });
     }
   return u;
 }
@@ -13167,22 +13172,28 @@ function zx(e = {}) {
     embedModels: a,
     embedRules: c,
     policy: l,
-    runtimeProvider: u
-  } = e, p = yn();
-  if (p.length > 0)
+    runtimeProvider: u,
+    llm: p
+  } = e, d = yn();
+  if (d.length > 0)
     throw new Error(`Config validation failed:
-  ${p.join(`
+  ${d.join(`
   `)}`);
   u && xo(u);
-  const d = t ?? (!!(a || c) || !1);
-  d && Zn(!0), n && ov(!0), r && qx(!0);
-  const m = new Sn();
-  o && m.addModels(o), i && m.setRules(i), l && xp(l);
-  let y;
-  d && (y = new Qn(), a && y.addModels(a), c && y.setRules(c));
-  const w = s ? () => Promise.resolve(s) : void 0, f = Ni();
-  f.setApplication(Ri()), f.setProviders(Mi());
-  const g = { modelService: m, embeddingService: y, getRedis: w }, h = /* @__PURE__ */ new Set([
+  const h = t ?? (!!(a || c) || !1);
+  h && Zn(!0), n && ov(!0), r && qx(!0);
+  const y = new Sn();
+  o && y.addModels(o), i && y.setRules(i), l && xp(l);
+  let b;
+  h && (b = new Qn(), a && b.addModels(a), c && b.setRules(c));
+  const f = s ? () => Promise.resolve(s) : void 0, g = Ni();
+  g.setApplication(Ri()), g.setProviders(Mi());
+  const m = {
+    modelService: y,
+    embeddingService: b,
+    getRedis: f,
+    ...p !== void 0 ? { llm: p } : {}
+  }, w = /* @__PURE__ */ new Set([
     "init",
     "config",
     "services",
@@ -13206,23 +13217,23 @@ function zx(e = {}) {
     "eventToTrace",
     "scopePhase",
     "nameStep"
-  ]), b = /* @__PURE__ */ new Set(["embedObject"]), v = {};
-  for (const [S, P] of Object.entries(rl))
-    if (!h.has(S)) {
-      if (b.has(S) && typeof P == "object" && P !== null) {
-        v[S] = Object.fromEntries(
-          Object.entries(P).map(([x, E]) => [x, hn(g, E)])
+  ]), S = /* @__PURE__ */ new Set(["embedObject"]), v = {};
+  for (const [P, x] of Object.entries(rl))
+    if (!w.has(P)) {
+      if (S.has(P) && typeof x == "object" && x !== null) {
+        v[P] = Object.fromEntries(
+          Object.entries(x).map(([E, O]) => [E, hn(m, O)])
         );
         continue;
       }
-      v[S] = hn(g, P);
+      v[P] = hn(m, x);
     }
   return {
     ...v,
-    config: g,
-    modelService: m,
-    embeddingService: y,
-    context: f
+    config: m,
+    modelService: y,
+    embeddingService: b,
+    context: g
   };
 }
 const Ux = {