@far-world-labs/verblets 0.3.2 → 0.5.0

package/README.md

@@ -24,19 +24,21 @@ Primitive verblets extract basic data types from natural language with high reli
 
 - [bool](./src/verblets/bool) - Interpret yes/no, true/false, and conditional statements
 - [date](./src/chains/date) - Parse dates from relative expressions, natural language, standard formats, and longer descriptions
-- [enum](./src/verblets/enum) - Convert free-form input to exactly one of several predefined options
+- [classify](./src/verblets/enum) - Classify free-form input into exactly one of several predefined options
 - [number](./src/verblets/number) - Convert a block of text to a single number
 - [number-with-units](./src/verblets/number-with-units) - Parse measurements and convert between unit systems
 
 ### Math
 
-Math chains transform values using conceptual reasoning and subjective judgments beyond simple calculations.
+Math chains transform values using conceptual reasoning and subjective judgment beyond simple calculations.
 
-- [scale](./src/chains/scale) - Convert qualitative descriptions to numeric values. Uses a specification generator to maintain consistency across invocations.
+- [scale](./src/chains/scale) - Convert qualitative descriptions to numeric values using a specification generator for consistency across invocations
+- [calibrate](./src/chains/calibrate) - Build and apply specification-based classifiers with adjustable sensitivity
+- [probe-scan](./src/chains/probe-scan) - Scan items for relevance using embedding similarity with configurable detection thresholds
 
 ### Lists
 
-List operations transform, filter, and organize collections. They handle both individual items and batch processing for datasets larger than a context window. Many list operations support bulk operation with built-in retry. Many have alternative single invocation versions in the verblets directory. Many utilities have list support via specification-generators that maintain continuity, or prompt fragments that adapt single-invcation behavior to list processing.
+List operations transform, filter, and organize collections. They handle both individual items and batch processing for datasets larger than a context window. Many support bulk operation with built-in retry. Some have single-invocation alternatives in the verblets directory. Several use specification-generators that maintain continuity across batches, or prompt fragments that adapt single-invocation behavior to list processing.
 
 - [central-tendency](./src/chains/central-tendency) - Find the most representative examples from a collection
 - [detect-patterns](./src/chains/detect-patterns) - Identify repeating structures, sequences, or relationships in data
@@ -57,16 +59,16 @@ List operations transform, filter, and organize collections. They handle both in
 
 ### Content
 
-Content utilities generate, transform, and analyze text while maintaining structure and meaning. They handle creative tasks, system analysis, and privacy-aware text processing.
+Content utilities generate, transform, and analyze text while maintaining structure and meaning.
 
-- [anonymize](./src/chains/anonymize) - Replace names, dates, and identifying details with placeholders
-- [category-samples](./src/chains/category-samples) - Create examples ranging from typical to edge cases
+- [category-samples](./src/chains/category-samples) - Generate examples ranging from prototypical to edge cases using cognitive science sampling
 - [collect-terms](./src/chains/collect-terms) - Find domain-specific or complex vocabulary
 - [commonalities](./src/verblets/commonalities) - Identify what items share conceptually, not just literally
-- [conversation](./src/chains/conversation) - Manage multi-turn dialogues with memory and context tracking
+- [Conversation](./src/chains/conversation) - Generate multi-speaker transcripts with contextual turn-taking and distinct personas
 - [disambiguate](./src/chains/disambiguate) - Determine which meaning of ambiguous terms fits the context
 - [dismantle](./src/chains/dismantle) - Break down systems into parts, subparts, and their connections
-- [document-shrink](./src/chains/document-shrink) - Remove less relevant sections while keeping query-related content
+- [document-shrink](./src/chains/document-shrink) - Compress documents using adaptive TF-IDF scoring while preserving query-relevant content
+- [extract-blocks](./src/chains/extract-blocks) - Extract structured blocks from text with windowed parallel processing
 - [fill-missing](./src/verblets/fill-missing) - Predict likely content for redacted or corrupted sections
 - [filter-ambiguous](./src/chains/filter-ambiguous) - Flag items that need human clarification
 - [join](./src/chains/join) - Connect text fragments by adding transitions and maintaining flow
@@ -77,29 +79,42 @@ Content utilities generate, transform, and analyze text while maintaining struct
 - [questions](./src/chains/questions) - Generate follow-up questions that branch from initial inquiry
 - [relations](./src/chains/relations) - Extract relationship tuples from text
 - [schema-org](./src/verblets/schema-org) - Convert unstructured data to schema.org JSON-LD format
-- [socratic](./src/chains/socratic) - Ask questions that reveal hidden assumptions and logic gaps
+- [SocraticMethod](./src/chains/socratic) - Progressive questioning dialogue with configurable challenge intensity
 - [split](./src/chains/split) - Find topic boundaries in continuous text
-- [summary-map](./src/chains/summary-map) - Build layered summaries for navigating large documents
+- [SummaryMap](./src/chains/summary-map) - Token-budget hash table that compresses values to fit a target size
 - [tag-vocabulary](./src/chains/tag-vocabulary) - Generate and refine tag vocabularies through iterative analysis
 - [themes](./src/chains/themes) - Surface recurring ideas through multi-pass extraction and merging
 - [timeline](./src/chains/timeline) - Order events chronologically from scattered mentions
 - [to-object](./src/chains/to-object) - Extract key-value pairs from natural language descriptions
 - [truncate](./src/chains/truncate) - Remove trailing content after a semantic boundary
-- [veiled-variants](./src/chains/veiled-variants) - Reword queries to avoid triggering content filters
+- [veiled-variants](./src/chains/veiled-variants) - Reframe queries through scientific, causal, and soft-cover strategies
+
+
+### Retrieval
+
+Retrieval utilities transform queries and prepare text for search and RAG (retrieval-augmented generation) workflows. All query-rewriting verblets accept a `divergence` option controlling how far variants stray from the original.
+
+- [embed-rewrite-query](./src/verblets/embed-rewrite-query) - Rewrite search queries for clarity and specificity
+- [embed-multi-query](./src/verblets/embed-multi-query) - Generate diverse query variants for broader retrieval
+- [embed-step-back](./src/verblets/embed-step-back) - Broaden queries to underlying concepts and principles
+- [embed-subquestions](./src/verblets/embed-subquestions) - Split complex queries into atomic sub-questions
+- [embed-rewrite-to-output-doc](./src/verblets/embed-rewrite-to-output-doc) - Rewrite a query as if it were the answer document
+- [embed-score](./src/lib/embed-score) - Score and rank items against a query using embedding similarity
 
 
 ### Utility Operations
 
-Utility operations are uncategorized functionality like automatic tool selection, intent parsing, and context compression.
+Utility operations handle automatic tool selection, intent parsing, prompt enhancement, and scheduling.
 
-- [ai-arch-expect](./src/chains/ai-arch-expect) - Validate AI architecture constraints and patterns
 - [auto](./src/verblets/auto) - Match task descriptions to available tools using function calling
-- [expect](./src/verblets/expect) - Check if conditions are met and explain why if not
-- [expect chain](./src/chains/expect) - Validate complex data relationships with detailed failure analysis
+- [expect](./src/verblets/expect) - Jest-style AI assertions: `expect(actual).toEqual(expected)`
+- [aiExpect](./src/chains/expect) - AI-powered test expectations with source introspection and debugging advice
 - [intent](./src/verblets/intent) - Extract action and parameters from natural language commands
-- [llm-logger](./src/chains/llm-logger) - Summarize log patterns and detect anomalies across time windows
-- [sentiment](./src/verblets/sentiment) - Classify as positive, negative, or neutral with nuance detection
+- [phail-forge / makePrompt](./src/verblets/phail-forge) - Transform simple prompts into expert-level prompts with precise terminology
+- [sentiment](./src/verblets/sentiment) - Classify text as positive, negative, or neutral
 - [set-interval](./src/chains/set-interval) - Schedule tasks using natural language time descriptions
+- [llm-logger](./src/chains/llm-logger) - Summarize log patterns and detect anomalies across time windows
+- [ai-arch-expect](./src/chains/ai-arch-expect) - Validate architecture constraints using AI analysis
 
 ### Codebase
 
@@ -107,16 +122,21 @@ Codebase utilities analyze, test, and improve code quality using AI reasoning.
 
 - [scan-js](./src/chains/scan-js) - Examine JavaScript for patterns, anti-patterns, and potential issues
 - [test](./src/chains/test) - Generate test cases covering happy paths, edge cases, and error conditions
-- [test-advice](./src/chains/test-advice) - Identify untested code paths and suggest test scenarios
 
-## Library Helpers
 
-Helpers support higher-level operations. They make no LLM calls and are often synchronous.
+## Library Helpers
 
-- [chatgpt](./src/lib/chatgpt) - OpenAI ChatGPT wrapper
-- [prompt-cache](./src/lib/prompt-cache) - Cache prompts and responses
-- [retry](./src/lib/retry) - Retry asynchronous calls
-- [ring-buffer](./src/lib/ring-buffer) - Circular buffer implementation for running LLMs on streams of data
+Low-level utilities that support chains and verblets. Most are synchronous and make no LLM calls.
+
+- [llm](./src/lib/llm) - Core LLM wrapper with capability-based model selection and structured output
+- [context](./src/lib/context) - Config resolution: `getOption`, `getOptions`, `withPolicy`, `scopeOperation`
+- [prompt-cache](./src/lib/prompt-cache) - Cache LLM prompts and responses
+- [retry](./src/lib/retry) - Config-aware async retry
+- [parallel-batch](./src/lib/parallel-batch) - Parallel execution with concurrency limits
+- [ring-buffer](./src/lib/ring-buffer) - Circular buffer for running LLMs on streams of data
+- [embed-normalize-text](./src/lib/embed-normalize-text) - Normalize text (NFC, whitespace, line endings) for consistent embedding
+- [embed-neighbor-chunks](./src/lib/embed-neighbor-chunks) - Expand retrieved chunks with neighboring context
+- [progress](./src/lib/progress) - Progress event system: lifecycle tracking, batch progress, event emission
 
 ## Contributing
 

package/dist/index.browser.js

@@ -1,74 +1,225 @@
-import { ag as a } from "./shared-C6kPWghF.js";
-import { E as r, a3 as i, f as n, F as o, l as c, a as m, G as l, H as p, e as u, I as g, k as d, g as f, a as h, m as b, o as y, J as v, K as x, L as T, p as S, i as k, a4 as B, a5 as P, q as j, M as C, t as E, N as M, u as O, v as V, w as q, a6 as w, x as z, O as A, y as F, z as G, a7 as I, a8 as L, A as R, P as U, Q as W, n as D, h as H, R as J, a8 as K, S as N, ab as Q, ae as X, T as Y, r as Z, U as _, ac as $, ad as aa, j as sa, V as ea, af as ta, B as ra, a9 as ia, s as na, aa as oa, W as ca, C as ma, X as la, Y as pa, Z as ua, D as ga, _ as da, $ as fa, a0 as ha, a1 as ba, a2 as ya } from "./shared-C6kPWghF.js";
+import { cC as a } from "./shared-C2_d1bKV.js";
+import { cz as i, F as r, C as c, G as n, aQ as o, D as l, E as b, ao as p, Q as u, bg as m, bj as g, c1 as d, bx as S, c0 as I, $ as T, A as y, a8 as h, _ as R, b6 as v, o as C, au as f, aE as E, bv as F, f as M, aN as B, a5 as N, y as P, z as x, aM as A, bt as O, a1 as L, a2 as k, ch as w, bW as D, i as G, aO as z, bU as U, aP as V, ci as W, bl as _, cB as q, e as Q, aR as Y, cj as j, bY as K, B as J, H as X, a9 as H, c as Z, b7 as $, p as aa, aF as sa, aG as ea, R as ta, g as ia, bX as ra, a as ca, O as na, a3 as oa, a4 as la, ap as ba, aS as pa, aU as ua, aW as ma, aX as ga, bD as da, bS as Sa, bE as Ia, bQ as Ta, bF as ya, bR as ha, bK as Ra, bP as va, bO as Ca, bJ as fa, bN as Ea, bI as Fa, bT as Ma, bL as Ba, bM as Na, bG as Pa, a6 as xa, ab as Aa, ad as Oa, ae as La, aa as ka, ac as wa, a7 as Da, Y as Ga, Z as za, S as Ua, bw as Va, af as Wa, c8 as _a, aY as qa, ag as Qa, aZ as Ya, ah as ja, am as Ka, cy as Ja, aT as Xa, K as Ha, L as Za, M as $a, ai as as, aj as ss, cA as es, by as ts, ak as is, a_ as rs, ck as cs, al as ns, an as os, aq as ls, a as bs, bz as ps, bA as us, ar as ms, a$ as gs, b0 as ds, n as Ss, bZ as Is, h as Ts, k as ys, I as hs, J as Rs, cl as vs, b_ as Cs, b$ as fs, cg as Es, b8 as Fs, b9 as Ms, b1 as Bs, bA as Ns, cm as Ps, cs as xs, b2 as As, x as Os, cv as Ls, cw as ks, ct as ws, b3 as Ds, bV as Gs, r as zs, b5 as Us, b4 as Vs, bb as Ws, bd as _s, be as qs, ba as Qs, bc as Ys, cx as js, d as Ks, c3 as Js, l as Xs, t as Hs, v as Zs, w as $s, q as ae, u as se, m as ee, bf as te, cu as ie, bs as re, c4 as ce, as as ne, ax as oe, az as le, aA as be, av as pe, aw as ue, ay as me, at as ge, bB as de, s as Se, bH as Ie, bC as Te, cr as ye, aV as he, bh as Re, bu as ve, aB as Ce, cn as fe, bi as Ee, ca as Fe, c9 as Me, a0 as Be, aD as Ne, bk as Pe, aC as xe, aI as Ae, aK as Oe, aL as Le, aH as ke, aJ as we, U as De, V as Ge, T as ze, X as Ue, c2 as Ve, bm as We, bn as _e, cb as qe, cd as Qe, ce as Ye, cc as je, cf as Ke, bo as Je, bp as Xe, co as He, W as Ze, P as $e, cp as at, br as st, bq as et, c5 as tt, c6 as it, c7 as rt, N as ct, cq as nt } from "./shared-C2_d1bKV.js";
 a();
 export {
-  r as anonymize,
-  i as auto,
-  n as bool,
-  o as categorySamples,
-  c as centralTendency,
-  m as chatGPT,
-  l as collectTerms,
-  p as commonalities,
-  u as constants,
-  g as conversation,
-  d as createScale,
-  f as date,
-  h as default,
-  b as detectPatterns,
-  y as detectThreshold,
-  v as disambiguate,
-  x as dismantle,
-  T as documentShrink,
-  S as entities,
-  k as enums,
-  B as expect,
-  P as expectChain,
-  j as extractBlocks,
-  C as fillMissing,
-  E as filter,
-  M as filterAmbiguous,
-  O as find,
-  V as glossary,
-  q as group,
-  w as intent,
-  z as intersections,
-  A as join,
-  F as list,
-  G as listExpand,
-  I as llmLogger,
-  L as makePrompt,
-  R as map,
-  U as name,
-  W as nameSimilarTo,
-  D as number,
-  H as numberWithUnits,
-  J as people,
-  K as phailForge,
-  N as popReference,
-  Q as promptCache,
-  X as prompts,
-  Y as questions,
-  Z as reduce,
-  _ as relations,
-  $ as retry,
-  aa as ringBuffer,
-  sa as scale,
-  ea as schemaOrg,
-  ta as schemas,
-  ra as score,
-  ia as sentiment,
-  na as services,
-  oa as setInterval,
-  ca as socratic,
-  ma as sort,
-  la as split,
-  pa as summaryMap,
-  ua as tagVocabulary,
-  ga as tags,
-  da as themes,
-  fa as timeline,
-  ha as toObject,
-  ba as truncate,
-  ya as veiledVariants
+  i as CAPABILITY_KEYS,
+  r as COMPLIANCE,
+  c as CONTEXT_KINDS,
+  n as COST_POSTURE,
+  o as Conversation,
+  l as DOMAIN,
+  b as ENVIRONMENT,
+  p as ListStyle,
+  u as QUALITY_INTENT,
+  m as SocraticMethod,
+  g as SummaryMap,
+  d as TimedAbortController,
+  S as aiExpect,
+  I as anySignal,
+  T as applyAllTargetingRules,
+  y as applyCalibrate,
+  h as applyEntities,
+  R as applyFirstTargetingRule,
+  v as applyRelations,
+  C as applyScale,
+  f as applyScore,
+  E as applyTags,
+  F as auto,
+  M as bool,
+  B as buildSeedGenerationPrompt,
+  N as calculateStatistics,
+  P as calibrate,
+  x as calibrateSpec,
+  A as categorySamples,
+  O as causalFramePrompt,
+  L as centralTendency,
+  k as centralTendencyLines,
+  w as chunk,
+  D as chunkSentences,
+  G as classify,
+  z as collectTerms,
+  U as combinations,
+  V as commonalities,
+  W as compact,
+  _ as computeTagStatistics,
+  q as config,
+  Q as constants,
+  Y as conversationTurnReduce,
+  j as cosineSimilarity,
+  K as createBatches,
+  J as createCalibratedClassifier,
+  X as createContextBuilder,
+  H as createEntityExtractor,
+  Z as createProgressEmitter,
+  $ as createRelationExtractor,
+  aa as createScale,
+  sa as createTagExtractor,
+  ea as createTagger,
+  ta as createTraceCollector,
+  ia as date,
+  ra as debug,
+  ca as default,
+  na as descriptorToSchema,
+  oa as detectPatterns,
+  la as detectThreshold,
+  ba as determineStyle,
+  pa as disambiguate,
+  ua as dismantle,
+  ma as dismantleFactory,
+  ga as documentShrink,
+  da as embed,
+  Sa as embedAssembleSpan,
+  Ia as embedBatch,
+  Ta as embedBuildIndex,
+  ya as embedChunked,
+  ha as embedMergeRanges,
+  Ra as embedMultiQuery,
+  va as embedNeighborChunks,
+  Ca as embedNormalizeText,
+  fa as embedRewriteQuery,
+  Ea as embedRewriteToOutputDoc,
+  Fa as embedScore,
+  Ma as embedStandaloneSpan,
+  Ba as embedStepBack,
+  Na as embedSubquestions,
+  Pa as embedWarmup,
+  xa as entities,
+  Aa as entitiesFilterInstructions,
+  Oa as entitiesFindInstructions,
+  La as entitiesGroupInstructions,
+  ka as entitiesMapInstructions,
+  wa as entitiesReduceInstructions,
+  Da as entitySpec,
+  Ga as evaluateTargetingClause,
+  za as evaluateTargetingRule,
+  Ua as eventToTrace,
+  Va as expect,
+  Wa as extractBlocks,
+  _a as extractJson,
+  qa as fillMissing,
+  Qa as filter,
+  Ya as filterAmbiguous,
+  ja as find,
+  Ka as generateList,
+  Ja as getCapabilities,
+  Xa as getMeanings,
+  Ha as getOption,
+  Za as getOptionDetail,
+  $a as getOptions,
+  as as glossary,
+  ss as group,
+  es as init,
+  ts as intent,
+  is as intersections,
+  rs as join,
+  cs as last,
+  ns as list,
+  os as listBatch,
+  ls as listExpand,
+  bs as llm,
+  ps as llmLogger,
+  us as makePrompt,
+  ms as map,
+  gs as name,
+  ds as nameSimilarTo,
+  Ss as nameStep,
+  Is as normalizeLlm,
+  Ts as number,
+  ys as numberWithUnits,
+  hs as observeApplication,
+  Rs as observeProviders,
+  vs as omit,
+  Cs as parallel,
+  fs as parallelMap,
+  Es as parseLLMList,
+  Fs as parseRDFLiteral,
+  Ms as parseRelations,
+  Bs as people,
+  Ns as phailForge,
+  Ps as pick,
+  xs as pipe,
+  As as popReference,
+  Os as probeScan,
+  Ls as promptCache,
+  ks as promptPiece,
+  ws as prompts,
+  Ds as questions,
+  Gs as rangeCombinations,
+  zs as reduce,
+  Us as relationSpec,
+  Vs as relations,
+  Ws as relationsFilterInstructions,
+  _s as relationsFindInstructions,
+  qs as relationsGroupInstructions,
+  Qs as relationsMapInstructions,
+  Ys as relationsReduceInstructions,
+  js as resolveModel,
+  Ks as retry,
+  Js as ringBuffer,
+  Xs as scale,
+  Hs as scaleFilterInstructions,
+  Zs as scaleFindInstructions,
+  $s as scaleGroupInstructions,
+  ae as scaleMapInstructions,
+  se as scaleReduceInstructions,
+  ee as scaleSpec,
+  te as schemaOrg,
+  ie as schemas,
+  re as scientificFramingPrompt,
+  ce as scopePhase,
+  ne as score,
+  oe as scoreFilterInstructions,
+  le as scoreFindInstructions,
+  be as scoreGroupInstructions,
+  pe as scoreItem,
+  ue as scoreMapInstructions,
+  me as scoreReduceInstructions,
+  ge as scoreSpec,
+  de as sentiment,
+  Se as services,
+  Ie as setEmbedEnabled,
+  Te as setInterval,
+  ye as shuffle,
+  he as simplifyTree,
+  Re as socratic,
+  ve as softCoverPrompt,
+  Ce as sort,
+  fe as sortBy,
+  Ee as split,
+  Fe as stripNumeric,
+  Me as stripResponse,
+  Be as suggestTargetingRules,
+  Ne as tagSpec,
+  Pe as tagVocabulary,
+  xe as tags,
+  Ae as tagsFilterInstructions,
+  Oe as tagsFindInstructions,
+  Le as tagsGroupInstructions,
+  ke as tagsMapInstructions,
+  we as tagsReduceInstructions,
+  De as targetingClause,
+  Ge as targetingRule,
+  ze as targetingRuleOps,
+  Ue as targetingRuleSchema,
+  Ve as templateReplace,
+  We as themes,
+  _e as timeline,
+  qe as toBool,
+  Qe as toDate,
+  Ye as toEnum,
+  je as toNumber,
+  Ke as toNumberWithUnits,
+  Je as toObject,
+  Xe as truncate,
+  He as unionBy,
+  Ze as validateTargetingRules,
+  $e as valueArbitrate,
+  at as vectorSearch,
+  st as veiledVariantStrategies,
+  et as veiledVariants,
+  tt as version,
+  it as windowFor,
+  rt as withInactivityTimeout,
+  ct as withPolicy,
+  nt as zipWith
 };