@far-world-labs/verblets 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,12 +1,12 @@
-import R from "dotenv";
-import p, { readFileSync as T } from "node:fs";
+import P from "dotenv";
+import p, { readFileSync as F } from "node:fs";
 import { resolve as x } from "node:path";
-import { r as v, a as C, s as $, b as A, c as O, j as N } from "./shared-CMgpfDG4.js";
-import { cv as Ie, B as Ce, C as Ee, F as Pe, D as we, E as Fe, a8 as Re, Q as Te, bN as xe, bM as ve, z as $e, U as Ae, aT as Oe, m as Ne, ae as ke, ao as De, bf as Le, b_ as Me, f as Be, ay as _e, R as je, x as Ue, y as ze, ax as Ge, bd as Je, M as Ve, N as qe, cd as We, bG as He, az as Xe, bE as Ke, aA as Ye, ce as Qe, b5 as Ze, cx as es, d as ss, aB as ts, aC as as, cf as rs, bZ as ns, bY as is, bI as os, A as cs, G as ls, V as us, aU as ds, o as ps, ap as ms, aq as hs, g as bs, bH as fs, O as ys, P as gs, a9 as Ss, aD as Is, aF as Cs, aH as Es, aI as Ps, bn as ws, bC as Fs, bo as Rs, bA as Ts, bp as xs, bB as vs, bu as $s, bz as As, by as Os, bt as Ns, bx as ks, bs as Ds, bD as Ls, bv as Ms, bw as Bs, bq as _s, bV as js, bW as Us, bU as zs, bS as Gs, bX as Js, bQ as Vs, bR as qs, bT as Ws, S as Hs, X as Xs, Z as Ks, _ as Ys, W as Qs, Y as Zs, T as et, i as st, bg as tt, bh as at, $ as rt, aw as nt, c4 as it, aJ as ot, a0 as ct, aK as lt, c0 as ut, a1 as dt, a6 as pt, cu as mt, aE as ht, J as bt, K as ft, a2 as yt, a3 as gt, cw as St, bi as It, a4 as Ct, aL as Et, cg as Pt, a5 as wt, a7 as Ft, aa as Rt, bj as Tt, bk as xt, ab as vt, aM as $t, aN as At, bJ as Ot, n as Nt, h as kt, H as Dt, I as Lt, ch as Mt, bK as Bt, bL as _t, cc as jt, aV as Ut, aW as zt, aO as Gt, bk as Jt, ci as Vt, co as qt, aP as Wt, w as Ht, cr as Xt, cs as Kt, cp as Yt, aQ as Qt, bF as Zt, aS as ea, aR as sa, aY as ta, a_ as aa, a$ as ra, aX as na, aZ as ia, ct as oa, bP as ca, k as la, q as ua, u as da, v as pa, p as ma, t as ha, l as ba, b0 as fa, cq as ya, bc as ga, b$ as Sa, ac as Ia, ah as Ca, aj as Ea, ak as Pa, af as wa, ag as Fa, ai as Ra, ad as Ta, bl as xa, e as va, br as $a, bm as Aa, cn as Oa, aG as Na, b1 as ka, be as Da, al as La, cj as Ma, b2 as Ba, c6 as _a, c5 as ja, b3 as Ua, an as za, b4 as Ga, am as Ja, as as Va, au as qa, av as Wa, ar as Ha, at as Xa, bO as Ka, b6 as Ya, b7 as Qa, c7 as Za, c9 as er, ca as sr, c8 as tr, cb as ar, b8 as rr, b9 as nr, ck as ir, cl as or, bb as cr, ba as lr, c1 as ur, c2 as dr, c3 as pr, L as mr, cm as hr } from "./shared-CMgpfDG4.js";
+import { r as A, a as E, n as $, c as O, b as D, d as N, j as L } from "./shared-C2_d1bKV.js";
+import { cz as Ee, F as Te, C as Re, G as we, aQ as ve, D as Pe, E as Fe, ao as xe, Q as Ae, bg as $e, bj as Oe, c1 as De, bx as Ne, c0 as Le, $ as Me, A as ke, a8 as _e, _ as Be, b6 as je, o as Ue, au as ze, aE as Ge, bv as Je, f as Ve, aN as qe, a5 as We, y as He, z as Xe, aM as Ke, bt as Ye, a1 as Qe, a2 as Ze, ch as es, bW as ss, i as as, aO as ts, bU as rs, aP as ns, ci as is, bl as os, cB as cs, e as ls, aR as us, cj as ds, bY as ps, B as ms, H as hs, a9 as fs, b7 as bs, p as gs, aF as ys, aG as Ss, R as Is, g as Cs, bX as Es, O as Ts, a3 as Rs, a4 as ws, ap as vs, aS as Ps, aU as Fs, aW as xs, aX as As, bD as $s, bS as Os, bE as Ds, bQ as Ns, bF as Ls, bR as Ms, bK as ks, bP as _s, bO as Bs, bJ as js, bN as Us, bI as zs, bT as Gs, bL as Js, bM as Vs, bG as qs, a6 as Ws, ab as Hs, ad as Xs, ae as Ks, aa as Ys, ac as Qs, a7 as Zs, Y as ea, Z as sa, S as aa, bw as ta, af as ra, c8 as na, aY as ia, ag as oa, aZ as ca, ah as la, am as ua, cy as da, aT as pa, K as ma, L as ha, M as fa, ai as ba, aj as ga, cA as ya, by as Sa, ak as Ia, a_ as Ca, ck as Ea, al as Ta, an as Ra, aq as wa, bz as va, bA as Pa, ar as Fa, a$ as xa, b0 as Aa, bZ as $a, h as Oa, k as Da, I as Na, J as La, cl as Ma, b_ as ka, b$ as _a, cg as Ba, b8 as ja, b9 as Ua, b1 as za, bA as Ga, cm as Ja, cs as Va, b2 as qa, x as Wa, cv as Ha, cw as Xa, ct as Ka, b3 as Ya, bV as Qa, b5 as Za, b4 as et, bb as st, bd as at, be as tt, ba as rt, bc as nt, cx as it, c3 as ot, l as ct, t as lt, v as ut, w as dt, q as pt, u as mt, m as ht, bf as ft, cu as bt, bs as gt, c4 as yt, as as St, ax as It, az as Ct, aA as Et, av as Tt, aw as Rt, ay as wt, at as vt, bB as Pt, s as Ft, bH as xt, bC as At, cr as $t, aV as Ot, bh as Dt, bu as Nt, aB as Lt, cn as Mt, bi as kt, ca as _t, c9 as Bt, a0 as jt, aD as Ut, bk as zt, aC as Gt, aI as Jt, aK as Vt, aL as qt, aH as Wt, aJ as Ht, U as Xt, V as Kt, T as Yt, X as Qt, c2 as Zt, bm as er, bn as sr, cb as ar, cd as tr, ce as rr, cc as nr, cf as ir, bo as or, bp as cr, co as lr, W as ur, P as dr, cp as pr, br as mr, bq as hr, c5 as fr, c6 as br, c7 as gr, N as yr, cq as Sr } from "./shared-C2_d1bKV.js";
 import "glob";
-import k from "node:fs/promises";
-const D = (e) => {
-}, E = 1, L = 20, M = 5, B = 0.5, _ = 5, g = 8e3, y = 5, b = {
+import M from "node:fs/promises";
+const k = (e) => {
+}, T = 1, _ = 20, B = 5, j = 0.5, U = 5, y = 8e3, g = 5, f = {
   INDIVIDUAL: "individual",
   BULK: "bulk"
 }, m = {
@@ -14,89 +14,89 @@ const D = (e) => {
   COMPLETED: "completed",
   ERROR: "error"
 };
-function j(e, s) {
-  const a = [];
-  for (let t = 0; t < e.length; t += s)
-    a.push({
-      items: e.slice(t, t + s),
-      index: Math.floor(t / s) + 1,
-      startIndex: t
+function z(e, s) {
+  const t = [];
+  for (let a = 0; a < e.length; a += s)
+    t.push({
+      items: e.slice(a, a + s),
+      index: Math.floor(a / s) + 1,
+      startIndex: a
     });
-  return a;
+  return t;
 }
-function S(e, s, a, t, r, n) {
+function S(e, s, t, a, r, i) {
   return {
     chunkIndex: e.index,
     totalChunks: s,
     itemsInChunk: e.items.length,
-    totalItems: a,
-    status: t,
+    totalItems: t,
+    status: a,
     bulkSize: r.bulkSize,
     maxConcurrency: r.maxConcurrency,
-    processingMode: n,
+    processingMode: i,
     parallelMode: !0
   };
 }
-async function U(e, s, a, t, r) {
+async function G(e, s, t, a, r) {
   try {
-    const n = a.map((l) => F(l(e))).filter(Boolean).join(`
+    const i = t.map((l) => v(l(e))).filter(Boolean).join(`
 
-`), o = [s, n].filter(Boolean).join(`
+`), o = [s, i].filter(Boolean).join(`
 
-`), i = Q(o, e, t, r === "files"), c = await C(i, {
+`), n = ee(o, e, a, r === "files"), c = await E(n, {
       response_format: {
         type: "json_schema",
         json_schema: {
           name: "arch_result",
-          schema: X
+          schema: Y
         }
       }
     });
     return { item: e, ...c, error: void 0 };
-  } catch (n) {
-    return { item: e, passed: !1, reason: `Analysis failed: ${n.message}`, error: n };
+  } catch (i) {
+    return { item: e, passed: !1, reason: `Analysis failed: ${i.message}`, error: i };
   }
 }
-function z(e, s, a, t) {
-  const r = [], n = [];
-  let o = t;
-  for (const i of e)
-    if (r.push(i), i.passed || (o++, n.push(i.error || new Error(i.reason))), !s && o >= a)
+function J(e, s, t, a) {
+  const r = [], i = [];
+  let o = a;
+  for (const n of e)
+    if (r.push(n), n.passed || (o++, i.push(n.error || new Error(n.reason))), !s && o >= t)
       break;
   return {
     results: r,
-    errors: n,
+    errors: i,
     failures: o,
-    shouldStop: !s && o >= a
+    shouldStop: !s && o >= t
   };
 }
-function h(e, s, a, t) {
-  e && e(s, a, t);
+function h(e, s, t, a) {
+  e && e(s, t, a);
 }
-async function P(e, s, a, t, r) {
-  h(t, e, void 0, {
+async function R(e, s, t, a, r) {
+  h(a, e, void 0, {
     ...r,
     status: m.PROCESSING
   });
   try {
-    const n = Z(s, e, a), o = await v(e, n, {
+    const i = se(s, e, t), o = await A(e, i, {
       responseFormat: {
         type: "json_schema",
         json_schema: {
           name: "arch_bulk_result",
-          schema: K
+          schema: Q
         }
       }
-    }), i = o.results || o;
+    }), n = o.results || o;
     let c = [];
-    Array.isArray(i) ? c = i : c = e.map((f) => ({
-      path: f,
+    Array.isArray(n) ? c = n : c = e.map((b) => ({
+      path: b,
       passed: !1,
       reason: "Invalid response format"
     }));
-    const l = c.filter((f) => !f.passed).length, u = c.length - l;
+    const l = c.filter((b) => !b.passed).length, u = c.length - l;
     return h(
-      t,
+      a,
       e,
       l > 0 ? new Error(`${l} items failed`) : void 0,
       {
@@ -106,42 +106,42 @@ async function P(e, s, a, t, r) {
         failed: l
       }
     ), c;
-  } catch (n) {
-    const o = e.map((i) => ({
-      path: i,
+  } catch (i) {
+    const o = e.map((n) => ({
+      path: n,
       passed: !1,
-      reason: `Processing error: ${n.message}`
+      reason: `Processing error: ${i.message}`
     }));
-    return h(t, e, n, {
+    return h(a, e, i, {
       ...r,
       status: m.ERROR
     }), o;
   }
 }
-function G(e, s) {
-  const a = s.filter((i) => i.passed).length, t = s.length - a, r = t === 0, n = s.length < e.length, o = s.filter((i) => !i.passed);
+function V(e, s) {
+  const t = s.filter((n) => n.passed).length, a = s.length - t, r = a === 0, i = s.length < e.length, o = s.filter((n) => !n.passed);
   return {
-    passed: a,
-    failed: t,
+    passed: t,
+    failed: a,
     allPassed: r,
-    stoppedEarly: n,
+    stoppedEarly: i,
     failures: o,
     total: e.length,
     processed: s.length
   };
 }
-function J(e, s, a) {
+function q(e, s, t) {
   if (e.allPassed)
     return `All ${e.processed}/${e.total} items satisfy: ${s}`;
-  const t = e.failures.slice(0, y).map((n) => `  • ${n.item}: ${n.reason || "Failed"}`).join(`
-`), r = e.failures.length > y ? `
-  ... and ${e.failures.length - y} more failures` : "";
-  return `${e.failed}/${e.processed} items failed: ${s}${e.stoppedEarly && a !== E ? ` (stopped after ${a} failures)` : ""}
+  const a = e.failures.slice(0, g).map((i) => `  • ${i.item}: ${i.reason || "Failed"}`).join(`
+`), r = e.failures.length > g ? `
+  ... and ${e.failures.length - g} more failures` : "";
+  return `${e.failed}/${e.processed} items failed: ${s}${e.stoppedEarly && t !== T ? ` (stopped after ${t} failures)` : ""}
 
 Failures:
-${t}${r}`;
+${a}${r}`;
 }
-function V(e, s) {
+function W(e, s) {
   return {
     passed: e.allPassed,
     message: s,
@@ -154,127 +154,127 @@ function V(e, s) {
     }
   };
 }
-function q(e, s, a, t) {
-  const r = s || a.length > 0 || t <= _;
+function H(e, s, t, a) {
+  const r = s || t.length > 0 || a <= U;
   return {
-    mode: r ? b.INDIVIDUAL : b.BULK,
+    mode: r ? f.INDIVIDUAL : f.BULK,
     batchSize: r ? e.maxConcurrency : e.bulkSize,
-    processor: r ? (n, o, i) => w(n, o, i) : (n, o, i) => P(
-      n.items,
+    processor: r ? (i, o, n) => w(i, o, n) : (i, o, n) => R(
+      i.items,
       o,
-      i.description,
-      i.onProgress,
-      i.metadata
+      n.description,
+      n.onProgress,
+      n.metadata
     )
   };
 }
-async function w(e, s, a) {
-  const t = e.items.map(
-    (r) => U(
+async function w(e, s, t) {
+  const a = e.items.map(
+    (r) => G(
       r,
       s,
-      a.itemContextFns,
-      a.description,
-      a.targetType
+      t.itemContextFns,
+      t.description,
+      t.targetType
     )
   );
-  return await Promise.all(t);
+  return await Promise.all(a);
 }
-function W(e, s, a) {
-  if (s === b.INDIVIDUAL) {
-    const { results: t, errors: r, failures: n, shouldStop: o } = z(
+function X(e, s, t) {
+  if (s === f.INDIVIDUAL) {
+    const { results: a, errors: r, failures: i, shouldStop: o } = J(
       e,
-      a.isCoverageTest,
-      a.maxFailures,
-      a.currentFailures || 0
+      t.isCoverageTest,
+      t.maxFailures,
+      t.currentFailures || 0
     );
     return {
-      results: t,
+      results: a,
       errors: r,
-      failures: n,
+      failures: i,
       shouldStop: o,
       progressData: {
-        passed: t.filter((i) => i.passed).length,
+        passed: a.filter((n) => n.passed).length,
         failed: r.length
       }
     };
   } else {
-    const t = e.map((r) => ({
+    const a = e.map((r) => ({
       item: r.path,
       passed: r.passed,
       reason: r.reason
     }));
     return {
-      results: t,
+      results: a,
       errors: [],
-      failures: a.currentFailures || 0,
+      failures: t.currentFailures || 0,
       shouldStop: !1,
       progressData: {
-        passed: t.filter((r) => r.passed).length,
-        failed: t.filter((r) => !r.passed).length
+        passed: a.filter((r) => r.passed).length,
+        failed: a.filter((r) => !r.passed).length
       }
     };
   }
 }
-async function H(e, s, a, t) {
-  const r = j(e, a.batchSize), n = [];
+async function K(e, s, t, a) {
+  const r = z(e, t.batchSize), i = [];
   let o = 0;
-  for (const i of r) {
-    if (!t.isCoverageTest && o >= t.maxFailures)
+  for (const n of r) {
+    if (!a.isCoverageTest && o >= a.maxFailures)
       break;
     const c = S(
-      i,
+      n,
       r.length,
       e.length,
       m.PROCESSING,
-      t,
-      a.mode
+      a,
+      t.mode
     );
-    h(t.onChunkProcessed, i.items, void 0, c);
+    h(a.onChunkProcessed, n.items, void 0, c);
     let l;
-    a.mode === b.INDIVIDUAL ? l = await w(i, s, {
-      itemContextFns: t.itemContextFns,
-      description: t.description,
-      targetType: t.targetType
-    }) : l = await P(
-      i.items,
+    t.mode === f.INDIVIDUAL ? l = await w(n, s, {
+      itemContextFns: a.itemContextFns,
+      description: a.description,
+      targetType: a.targetType
+    }) : l = await R(
+      n.items,
       s,
-      t.description,
-      t.onChunkProcessed,
+      a.description,
+      a.onChunkProcessed,
       c
     );
-    const u = W(l, a.mode, {
-      ...t,
+    const u = X(l, t.mode, {
+      ...a,
       currentFailures: o
     });
-    if (n.push(...u.results), o = u.failures, h(
-      t.onChunkProcessed,
-      i.items,
+    if (i.push(...u.results), o = u.failures, h(
+      a.onChunkProcessed,
+      n.items,
       u.errors.length > 0 ? u.errors[0] : void 0,
       {
         ...S(
-          i,
+          n,
           r.length,
           e.length,
           m.COMPLETED,
-          t,
-          a.mode
+          a,
+          t.mode
         ),
         ...u.progressData
       }
     ), u.shouldStop)
       break;
   }
-  return n;
+  return i;
 }
-const X = {
+const Y = {
   type: "object",
   properties: {
     passed: { type: "boolean" },
     reason: { type: "string" }
   },
   required: ["passed", "reason"]
-}, K = {
+}, Q = {
   type: "object",
   properties: {
     results: {
@@ -292,7 +292,7 @@ const X = {
   },
   required: ["results"]
 };
-function F(e) {
+function v(e) {
   switch (e.type) {
     case "file":
       return p.existsSync(e.filePath) ? `<${e.name}>
@@ -315,38 +315,38 @@ ${s}
       return "";
   }
 }
-function Y(e) {
+function Z(e) {
   if (!p.existsSync(e)) return "Item does not exist";
   if (p.statSync(e).isDirectory())
     return p.readdirSync(e).join(", ");
   {
-    const a = p.readFileSync(e, "utf8");
-    return a.length > g ? `${a.substring(0, g)}
-... (truncated)` : a;
+    const t = p.readFileSync(e, "utf8");
+    return t.length > y ? `${t.substring(0, y)}
+... (truncated)` : t;
   }
 }
-function Q(e, s, a, t) {
-  const r = Y(s);
+function ee(e, s, t, a) {
+  const r = Z(s);
   return `${e}
-Analyze this ${t ? "file" : "directory"}: ${s}
+Analyze this ${a ? "file" : "directory"}: ${s}
 
 Content:
 ${r}
 
-Does it satisfy: "${a}"?
+Does it satisfy: "${t}"?
 
 Return JSON with "passed" (boolean) and "reason" (string).`;
 }
-function Z(e, s, a) {
+function se(e, s, t) {
   return `${e}
-Analyze each item and determine if it satisfies: "${a}"
+Analyze each item and determine if it satisfies: "${t}"
 Items: ${s.join(", ")}
 
 Return JSON with "results" array containing objects with "path", "passed" (boolean), and "reason" (string).`;
 }
-class ee {
-  constructor(s, a = {}) {
-    this.target = s, this.contexts = [], this.itemContextFns = [], this.maxFailures = a.maxFailures || E, this.bulkSize = a.bulkSize || L, this.maxConcurrency = a.maxConcurrency || M, this.onChunkProcessed = void 0, this.description = void 0, this.threshold = void 0, this.isCoverageTest = !1;
+class ae {
+  constructor(s, t = {}) {
+    this.target = s, this.contexts = [], this.itemContextFns = [], this.maxFailures = t.maxFailures || T, this.bulkSize = t.bulkSize || _, this.maxConcurrency = t.maxConcurrency || B, this.onChunkProcessed = void 0, this.description = void 0, this.threshold = void 0, this.isCoverageTest = !1;
   }
   withContext(s) {
     return this.contexts.push(s), this;
@@ -359,16 +359,16 @@ class ee {
     return this.description = s, this;
   }
   // Set up for a coverage test
-  coverage(s = B) {
+  coverage(s = j) {
     return this.threshold = s, this.isCoverageTest = !0, this;
   }
   // Start processing - this is the fluent terminator
   async start() {
     if (!this.description)
       throw new Error("Must call satisfies() before start()");
-    const s = await this.target.resolve(), a = this.contexts.map(F).filter(Boolean).join(`
+    const s = await this.target.resolve(), t = this.contexts.map(v).filter(Boolean).join(`
 
-`), t = q(
+`), a = H(
       this,
       this.onChunkProcessed,
       this.itemContextFns,
@@ -382,26 +382,26 @@ class ee {
       targetType: this.target.type,
       maxFailures: this.maxFailures,
       isCoverageTest: this.isCoverageTest
-    }, n = await H(s, a, t, r);
+    }, i = await K(s, t, a, r);
     if (this.isCoverageTest) {
-      const o = n.filter((u) => u.passed).length, i = s.length > 0 ? o / s.length : 0, c = i >= this.threshold, l = `Coverage: ${o}/${s.length} (${(i * 100).toFixed(1)}%) - ${c ? "meets" : "below"} ${(this.threshold * 100).toFixed(1)}% threshold`;
+      const o = i.filter((u) => u.passed).length, n = s.length > 0 ? o / s.length : 0, c = n >= this.threshold, l = `Coverage: ${o}/${s.length} (${(n * 100).toFixed(1)}%) - ${c ? "meets" : "below"} ${(this.threshold * 100).toFixed(1)}% threshold`;
       if (!c)
         throw new Error(l);
-      return { passed: c, coverage: i, message: l };
+      return { passed: c, coverage: n, message: l };
     }
-    return this.summarize(s, n);
+    return this.summarize(s, i);
   }
-  summarize(s, a) {
-    const t = G(s, a), r = J(t, this.description, this.maxFailures);
-    if (!t.allPassed)
+  summarize(s, t) {
+    const a = V(s, t), r = q(a, this.description, this.maxFailures);
+    if (!a.allPassed)
       throw new Error(r);
-    return V(t, r);
+    return W(a, r);
   }
 }
-function be(e, s = {}) {
-  return new ee(e, s);
+function ge(e, s = {}) {
+  return new ae(e, s);
 }
-function fe() {
+function ye() {
   return console.warn("scanJS is not available in browser environment"), Promise.resolve({});
 }
 const I = {
@@ -425,13 +425,14 @@ const I = {
     required: ["hasIssues", "issues"],
     additionalProperties: !1
   }
-};
-async function d(e, s, a = {}) {
-  a = $("test", a);
+}, C = "test";
+async function d(e, s, t = {}) {
+  const a = $(C, t), r = O(C, a.onProgress, a);
+  r.start();
   try {
-    const t = await k.readFile(e, "utf-8"), r = `Analyze this code and ${s}:
+    const i = await M.readFile(e, "utf-8"), o = `Analyze this code and ${s}:
 
-${A(t, { tag: "code-to-analyze" })}
+${D(i, { tag: "code-to-analyze" })}
 
 Return a JSON object with:
 - "hasIssues": boolean indicating if any issues were found
@@ -442,255 +443,259 @@ GUIDELINES:
 - Provide specific line numbers or code references when possible
 - Suggest concrete fixes for each issue identified
 - Be concise but clear in your feedback
-- If no issues are found, return {"hasIssues": false, "issues": []}`, n = await O(
-      () => C(r, {
+- If no issues are found, return {"hasIssues": false, "issues": []}`, n = await N(
+      () => E(o, {
         ...a,
-        response_format: N(I.name, I.schema)
+        response_format: L(I.name, I.schema)
       }),
       {
         label: "test chain",
         config: a
       }
-    );
-    return n.hasIssues ? n.issues : [];
-  } catch (t) {
-    return [`Error analyzing ${e}: ${t.message}`];
+    ), c = n.hasIssues ? n.issues : [];
+    return r.complete(), c;
+  } catch (i) {
+    return [`Error analyzing ${e}: ${i.message}`];
   }
 }
-const se = "Run the code with 5 boundary value test cases and report any that fail", te = "Identify 5 passing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate correctness.", ae = "Identify 5 failing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate the failure. Assume DBC, and don't complain when types are specified in jsDoc.", re = "Identify 5 defects in this code. Provide minimal input examples to demonstrate each defect.", ne = "Suggest 5 best practices improvements for this code.", ie = 'Suggest 5 "clean code" improvements for this code.', oe = "Identify 5 specific issues related to code quality, readability, and maintainability.", ce = "Suggest 5 refactors that would most improve the composibility of this code.", ye = async (e) => [
-  ...await d(e, se),
+const te = "Run the code with 5 boundary value test cases and report any that fail", re = "Identify 5 passing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate correctness.", ne = "Identify 5 failing scenarios and significant boundary conditions in this code. Provide minimal input examples for each scenario to demonstrate the failure. Assume DBC, and don't complain when types are specified in jsDoc.", ie = "Identify 5 defects in this code. Provide minimal input examples to demonstrate each defect.", oe = "Suggest 5 best practices improvements for this code.", ce = 'Suggest 5 "clean code" improvements for this code.', le = "Identify 5 specific issues related to code quality, readability, and maintainability.", ue = "Suggest 5 refactors that would most improve the composibility of this code.", Se = async (e) => [
   ...await d(e, te),
-  ...await d(e, ae),
   ...await d(e, re),
   ...await d(e, ne),
   ...await d(e, ie),
   ...await d(e, oe),
-  ...await d(e, ce)
+  ...await d(e, ce),
+  ...await d(e, le),
+  ...await d(e, ue)
 ];
-R.config();
+P.config();
 try {
-  D(JSON.parse(T(x(process.cwd(), ".verblets.json"), "utf8")));
+  k(JSON.parse(F(x(process.cwd(), ".verblets.json"), "utf8")));
 } catch {
 }
 export {
-  Ie as CAPABILITY_KEYS,
-  Ce as COMPLIANCE,
-  Ee as CONTEXT_KINDS,
-  Pe as COST_POSTURE,
-  we as DOMAIN,
+  Ee as CAPABILITY_KEYS,
+  Te as COMPLIANCE,
+  Re as CONTEXT_KINDS,
+  we as COST_POSTURE,
+  ve as Conversation,
+  Pe as DOMAIN,
   Fe as ENVIRONMENT,
-  Re as ListStyle,
-  Te as QUALITY_INTENT,
-  xe as TimedAbortController,
-  be as aiArchExpect,
-  ve as anySignal,
-  $e as applyCalibrate,
-  Ae as applyEntities,
-  Oe as applyRelations,
-  Ne as applyScale,
-  ke as applyScore,
-  De as applyTags,
-  Le as auto,
-  Me as batchTracker,
-  Be as bool,
-  _e as buildSeedGenerationPrompt,
-  je as calculateStatistics,
-  Ue as calibrate,
-  ze as calibrateSpec,
-  Ge as categorySamples,
-  Je as causalFramePrompt,
-  Ve as centralTendency,
-  qe as centralTendencyLines,
-  We as chunk,
-  He as chunkSentences,
-  Xe as collectTerms,
-  Ke as combinations,
-  Ye as commonalities,
-  Qe as compact,
-  Ze as computeTagStatistics,
-  es as config,
-  ss as constants,
-  ts as conversation,
-  as as conversationTurnReduce,
-  rs as cosineSimilarity,
-  ns as createBatchContext,
-  is as createBatchProgressCallback,
-  os as createBatches,
-  cs as createCalibratedClassifier,
-  ls as createContextBuilder,
-  us as createEntityExtractor,
-  ds as createRelationExtractor,
-  ps as createScale,
-  ms as createTagExtractor,
-  hs as createTagger,
-  bs as date,
-  fs as debug,
-  C as default,
-  ys as detectPatterns,
-  gs as detectThreshold,
-  Ss as determineStyle,
-  Is as disambiguate,
-  Cs as dismantle,
-  Es as dismantleFactory,
-  Ps as documentShrink,
-  ws as embed,
-  Fs as embedAssembleSpan,
-  Rs as embedBatch,
-  Ts as embedBuildIndex,
-  xs as embedChunked,
-  vs as embedMergeRanges,
-  $s as embedMultiQuery,
-  As as embedNeighborChunks,
-  Os as embedNormalizeText,
-  Ns as embedRewriteQuery,
-  ks as embedRewriteToOutputDoc,
-  Ds as embedScore,
-  Ls as embedStandaloneSpan,
-  Ms as embedStepBack,
-  Bs as embedSubquestions,
-  _s as embedWarmup,
-  js as emitBatchComplete,
-  Us as emitBatchProcessed,
-  zs as emitBatchStart,
-  Gs as emitComplete,
-  Js as emitPhaseProgress,
-  Vs as emitProgress,
-  qs as emitStart,
-  Ws as emitStepProgress,
-  Hs as entities,
-  Xs as entitiesFilterInstructions,
-  Ks as entitiesFindInstructions,
-  Ys as entitiesGroupInstructions,
-  Qs as entitiesMapInstructions,
-  Zs as entitiesReduceInstructions,
-  et as entitySpec,
-  st as enums,
-  tt as expect,
-  at as expectChain,
-  rt as extractBlocks,
-  nt as extractFeatures,
-  it as extractJson,
-  ot as fillMissing,
-  ct as filter,
-  lt as filterAmbiguous,
-  ut as filterProgress,
-  dt as find,
-  pt as generateList,
-  mt as getCapabilities,
-  ht as getMeanings,
-  bt as getOption,
-  ft as getOptions,
-  yt as glossary,
-  gt as group,
-  St as init,
-  It as intent,
-  Ct as intersections,
-  Et as join,
-  Pt as last,
-  wt as list,
-  Ft as listBatch,
-  Rt as listExpand,
-  C as llm,
-  Tt as llmLogger,
-  xt as makePrompt,
-  vt as map,
-  $t as name,
-  At as nameSimilarTo,
-  Ot as normalizeLlm,
-  Nt as number,
-  kt as numberWithUnits,
-  Dt as observeApplication,
-  Lt as observeProviders,
-  Mt as omit,
-  Bt as parallel,
-  _t as parallelMap,
-  jt as parseLLMList,
-  Ut as parseRDFLiteral,
-  zt as parseRelations,
-  Gt as people,
-  Jt as phailForge,
-  Vt as pick,
-  qt as pipe,
-  Wt as popReference,
-  Ht as probeScan,
-  Xt as promptCache,
-  Kt as promptPiece,
-  Yt as prompts,
-  Qt as questions,
-  Zt as rangeCombinations,
-  v as reduce,
-  ea as relationSpec,
-  sa as relations,
-  ta as relationsFilterInstructions,
-  aa as relationsFindInstructions,
-  ra as relationsGroupInstructions,
-  na as relationsMapInstructions,
-  ia as relationsReduceInstructions,
-  oa as resolveModel,
-  O as retry,
-  ca as ringBuffer,
-  la as scale,
-  ua as scaleFilterInstructions,
-  da as scaleFindInstructions,
-  pa as scaleGroupInstructions,
-  ma as scaleMapInstructions,
-  ha as scaleReduceInstructions,
-  ba as scaleSpec,
-  fe as scanJS,
-  fa as schemaOrg,
-  ya as schemas,
-  ga as scientificFramingPrompt,
-  $ as scopeOperation,
-  Sa as scopeProgress,
-  Ia as score,
-  Ca as scoreFilterInstructions,
-  Ea as scoreFindInstructions,
-  Pa as scoreGroupInstructions,
-  wa as scoreItem,
-  Fa as scoreMapInstructions,
-  Ra as scoreReduceInstructions,
-  Ta as scoreSpec,
-  xa as sentiment,
-  va as services,
-  $a as setEmbedEnabled,
-  Aa as setInterval,
-  Oa as shuffle,
-  Na as simplifyTree,
-  ka as socratic,
-  Da as softCoverPrompt,
-  La as sort,
-  Ma as sortBy,
-  Ba as split,
-  _a as stripNumeric,
-  ja as stripResponse,
-  Ua as summaryMap,
-  za as tagSpec,
-  Ga as tagVocabulary,
-  Ja as tags,
-  Va as tagsFilterInstructions,
-  qa as tagsFindInstructions,
-  Wa as tagsGroupInstructions,
-  Ha as tagsMapInstructions,
-  Xa as tagsReduceInstructions,
-  Ka as templateReplace,
+  xe as ListStyle,
+  Ae as QUALITY_INTENT,
+  $e as SocraticMethod,
+  Oe as SummaryMap,
+  De as TimedAbortController,
+  ge as aiArchExpect,
+  Ne as aiExpect,
+  Le as anySignal,
+  Me as applyAllTargetingRules,
+  ke as applyCalibrate,
+  _e as applyEntities,
+  Be as applyFirstTargetingRule,
+  je as applyRelations,
+  Ue as applyScale,
+  ze as applyScore,
+  Ge as applyTags,
+  Je as auto,
+  Ve as bool,
+  qe as buildSeedGenerationPrompt,
+  We as calculateStatistics,
+  He as calibrate,
+  Xe as calibrateSpec,
+  Ke as categorySamples,
+  Ye as causalFramePrompt,
+  Qe as centralTendency,
+  Ze as centralTendencyLines,
+  es as chunk,
+  ss as chunkSentences,
+  as as classify,
+  ts as collectTerms,
+  rs as combinations,
+  ns as commonalities,
+  is as compact,
+  os as computeTagStatistics,
+  cs as config,
+  ls as constants,
+  us as conversationTurnReduce,
+  ds as cosineSimilarity,
+  ps as createBatches,
+  ms as createCalibratedClassifier,
+  hs as createContextBuilder,
+  fs as createEntityExtractor,
+  O as createProgressEmitter,
+  bs as createRelationExtractor,
+  gs as createScale,
+  ys as createTagExtractor,
+  Ss as createTagger,
+  Is as createTraceCollector,
+  Cs as date,
+  Es as debug,
+  E as default,
+  Ts as descriptorToSchema,
+  Rs as detectPatterns,
+  ws as detectThreshold,
+  vs as determineStyle,
+  Ps as disambiguate,
+  Fs as dismantle,
+  xs as dismantleFactory,
+  As as documentShrink,
+  $s as embed,
+  Os as embedAssembleSpan,
+  Ds as embedBatch,
+  Ns as embedBuildIndex,
+  Ls as embedChunked,
+  Ms as embedMergeRanges,
+  ks as embedMultiQuery,
+  _s as embedNeighborChunks,
+  Bs as embedNormalizeText,
+  js as embedRewriteQuery,
+  Us as embedRewriteToOutputDoc,
+  zs as embedScore,
+  Gs as embedStandaloneSpan,
+  Js as embedStepBack,
+  Vs as embedSubquestions,
+  qs as embedWarmup,
+  Ws as entities,
+  Hs as entitiesFilterInstructions,
+  Xs as entitiesFindInstructions,
+  Ks as entitiesGroupInstructions,
+  Ys as entitiesMapInstructions,
+  Qs as entitiesReduceInstructions,
+  Zs as entitySpec,
+  ea as evaluateTargetingClause,
+  sa as evaluateTargetingRule,
+  aa as eventToTrace,
+  ta as expect,
+  ra as extractBlocks,
+  na as extractJson,
+  ia as fillMissing,
+  oa as filter,
+  ca as filterAmbiguous,
+  la as find,
+  ua as generateList,
+  da as getCapabilities,
+  pa as getMeanings,
+  ma as getOption,
+  ha as getOptionDetail,
+  fa as getOptions,
+  ba as glossary,
+  ga as group,
+  ya as init,
+  Sa as intent,
+  Ia as intersections,
+  Ca as join,
+  Ea as last,
+  Ta as list,
+  Ra as listBatch,
+  wa as listExpand,
+  E as llm,
+  va as llmLogger,
+  Pa as makePrompt,
+  Fa as map,
+  xa as name,
+  Aa as nameSimilarTo,
+  $ as nameStep,
+  $a as normalizeLlm,
+  Oa as number,
+  Da as numberWithUnits,
+  Na as observeApplication,
+  La as observeProviders,
+  Ma as omit,
+  ka as parallel,
+  _a as parallelMap,
+  Ba as parseLLMList,
+  ja as parseRDFLiteral,
+  Ua as parseRelations,
+  za as people,
+  Ga as phailForge,
+  Ja as pick,
+  Va as pipe,
+  qa as popReference,
+  Wa as probeScan,
+  Ha as promptCache,
+  Xa as promptPiece,
+  Ka as prompts,
+  Ya as questions,
+  Qa as rangeCombinations,
+  A as reduce,
+  Za as relationSpec,
+  et as relations,
+  st as relationsFilterInstructions,
+  at as relationsFindInstructions,
+  tt as relationsGroupInstructions,
+  rt as relationsMapInstructions,
+  nt as relationsReduceInstructions,
+  it as resolveModel,
+  N as retry,
+  ot as ringBuffer,
+  ct as scale,
+  lt as scaleFilterInstructions,
+  ut as scaleFindInstructions,
+  dt as scaleGroupInstructions,
+  pt as scaleMapInstructions,
+  mt as scaleReduceInstructions,
+  ht as scaleSpec,
+  ye as scanJS,
+  ft as schemaOrg,
+  bt as schemas,
+  gt as scientificFramingPrompt,
+  yt as scopePhase,
+  St as score,
+  It as scoreFilterInstructions,
+  Ct as scoreFindInstructions,
+  Et as scoreGroupInstructions,
+  Tt as scoreItem,
+  Rt as scoreMapInstructions,
+  wt as scoreReduceInstructions,
+  vt as scoreSpec,
+  Pt as sentiment,
+  Ft as services,
+  xt as setEmbedEnabled,
+  At as setInterval,
+  $t as shuffle,
+  Ot as simplifyTree,
+  Dt as socratic,
+  Nt as softCoverPrompt,
+  Lt as sort,
+  Mt as sortBy,
+  kt as split,
+  _t as stripNumeric,
+  Bt as stripResponse,
+  jt as suggestTargetingRules,
+  Ut as tagSpec,
+  zt as tagVocabulary,
+  Gt as tags,
+  Jt as tagsFilterInstructions,
+  Vt as tagsFindInstructions,
+  qt as tagsGroupInstructions,
+  Wt as tagsMapInstructions,
+  Ht as tagsReduceInstructions,
+  Xt as targetingClause,
+  Kt as targetingRule,
+  Yt as targetingRuleOps,
+  Qt as targetingRuleSchema,
+  Zt as templateReplace,
   d as test,
-  ye as testAdvice,
-  Ya as themes,
-  Qa as timeline,
-  Za as toBool,
-  er as toDate,
-  sr as toEnum,
-  tr as toNumber,
-  ar as toNumberWithUnits,
-  rr as toObject,
-  nr as truncate,
-  ir as unionBy,
-  or as vectorSearch,
-  cr as veiledVariantStrategies,
-  lr as veiledVariants,
-  ur as version,
-  dr as windowFor,
-  pr as withInactivityTimeout,
-  mr as withPolicy,
-  hr as zipWith
+  Se as testAdvice,
+  er as themes,
+  sr as timeline,
+  ar as toBool,
+  tr as toDate,
+  rr as toEnum,
+  nr as toNumber,
+  ir as toNumberWithUnits,
+  or as toObject,
+  cr as truncate,
+  lr as unionBy,
+  ur as validateTargetingRules,
+  dr as valueArbitrate,
+  pr as vectorSearch,
+  mr as veiledVariantStrategies,
+  hr as veiledVariants,
+  fr as version,
+  br as windowFor,
+  gr as withInactivityTimeout,
+  yr as withPolicy,
+  Sr as zipWith
 };