taias 0.6.0 → 0.7.1

package/README.md

@@ -80,11 +80,13 @@ return {
 
 ### `defineFlow(flowId, builder)`
 
-Creates a flow definition. Each step is a logic statement: a match condition paired with a decision.
+Creates a flow definition. Each step is a logic statement: a match condition paired with a decision. Match condition fields support operators (`is`, `isNot`); bare strings are sugar for `{ is: "..." }`.
 
 ```ts
 const myFlow = defineFlow("my_flow", (flow) => {
-  flow.step({ toolName: "tool_name" }, { nextTool: "next_tool_name" });
+  flow.step({ toolName: { is: "tool_a" } }, { nextTool: "tool_b" });      // explicit equality
+  flow.step({ toolName: { isNot: "abort" } }, { nextTool: "continue" });   // negation
+  flow.step({ toolName: "tool_a" }, { nextTool: "tool_b" });              // bare string = sugar for { is: "tool_a" }
 });
 ```
 

package/dist/index.cjs

@@ -111,11 +111,33 @@ function selectUiAffordances(decision, index, opts = {}) {
 function generateAdvice(nextTool) {
   return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;
 }
+function normalizeFieldCondition(field) {
+  return typeof field === "string" ? { is: field } : field;
+}
+function evaluateCondition(condition, value) {
+  if ("is" in condition) return value === condition.is;
+  if ("isNot" in condition) return value !== condition.isNot;
+  return false;
+}
+function evaluateMatch(match, ctx) {
+  const toolCondition = normalizeFieldCondition(match.toolName);
+  return evaluateCondition(toolCondition, ctx.toolName);
+}
+function isIndexable(field) {
+  if (typeof field === "string") return true;
+  return "is" in field;
+}
+function indexKey(field) {
+  if (typeof field === "string") return field;
+  if ("is" in field) return field.is;
+  throw new Error("Cannot derive index key from non-indexable condition");
+}
 function getMatch(step) {
   return step.kind === "logic" ? step.statement.match : step.match;
 }
-function deriveIndexKey(match) {
-  return match.toolName;
+function serializeMatch(match) {
+  const normalized = normalizeFieldCondition(match.toolName);
+  return JSON.stringify({ toolName: normalized });
 }
 function createTaias(options) {
   const {
@@ -129,23 +151,43 @@ function createTaias(options) {
   if (devMode) {
     const seenKeys = /* @__PURE__ */ new Set();
     for (const step of flow.steps) {
-      const key = deriveIndexKey(getMatch(step));
+      const key = serializeMatch(getMatch(step));
       if (seenKeys.has(key)) {
+        const match = getMatch(step);
+        const normalized = normalizeFieldCondition(match.toolName);
+        const label = "is" in normalized ? normalized.is : `isNot:${normalized.isNot}`;
         throw new Error(
-          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`
+          `Taias: Duplicate match condition '${label}' in flow '${flow.id}'. Each step must have a unique match condition.`
         );
       }
       seenKeys.add(key);
     }
   }
-  const stepIndex = /* @__PURE__ */ new Map();
+  const exactIndex = /* @__PURE__ */ new Map();
+  const broadSteps = [];
   for (const step of flow.steps) {
-    stepIndex.set(deriveIndexKey(getMatch(step)), step);
+    const match = getMatch(step);
+    if (isIndexable(match.toolName)) {
+      exactIndex.set(indexKey(match.toolName), step);
+    } else {
+      broadSteps.push(step);
+    }
   }
+  const hasBroadSteps = broadSteps.length > 0;
   const registryIndex = buildRegistryIndex(affordances);
   return {
     async resolve(ctx) {
-      const step = stepIndex.get(ctx.toolName);
+      let step;
+      if (!hasBroadSteps) {
+        step = exactIndex.get(ctx.toolName);
+      } else {
+        for (const candidate of flow.steps) {
+          if (evaluateMatch(getMatch(candidate), ctx)) {
+            step = candidate;
+            break;
+          }
+        }
+      }
       if (!step) {
         onMissingStep?.(ctx);
         return null;

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts","../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["// Main exports\nexport { defineFlow } from \"./flow\";\nexport { createTaias } from \"./createTaias\";\n\n// UI affordances exports\nexport { defineAffordances } from \"./uiAffordances/defineAffordances\";\nexport { mergeAffordances } from \"./uiAffordances/mergeAffordances\";\nexport type { AffordanceRegistrar } from \"./uiAffordances/defineAffordances\";\nexport type {\n  DefaultSlots,\n  CanonicalSlot,\n  Binding,\n  BindingInput,\n  HandleRegistration,\n  Selection,\n  UiSelections,\n  AffordanceRegistry,\n} from \"./uiAffordances/types\";\n\n// Core + flow type exports\nexport type {\n  Decision,\n  TaiasContext,\n  StepDecision,\n  Affordances,\n  StepHandler,\n  StepInput,\n  MatchCondition,\n  LogicStatement,\n  FlowStep,\n  FlowDefinition,\n  FlowBuilder,\n  TaiasOptions,\n  Taias,\n} from \"./types\";\n","import type { FlowBuilder, FlowDefinition, FlowStep, MatchCondition, StepInput } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example Logic statement with match condition object\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step({ toolName: \"scan_repo\" }, { nextTool: \"configure_app\" });\n * });\n * ```\n *\n * @example Backwards compatibility\n * A string match and handler functions are also supported:\n * ```ts\n * flow.step(\"scan_repo\", { nextTool: \"configure_app\" }); // string is sugar for { toolName: \"scan_repo\" }\n * flow.step(\"scan_repo\", (ctx) => ({ nextTool: \"configure_app\" })); // handler function\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(match: string | MatchCondition, input: StepInput): void {\n      // Normalize: string is sugar for { toolName: string }\n      const condition: MatchCondition =\n        typeof match === \"string\" ? { toolName: match } : match;\n\n      if (typeof input === \"function\") {\n        // Handler function -- backwards-compatible escape hatch.\n        // The match condition is stored alongside the handler since\n        // the function itself has no formal match conditions.\n        steps.push({ kind: \"handler\", match: condition, handler: input });\n      } else {\n        // Static logic statement -- the core primitive.\n        // The statement is the sole source of truth for its match\n        // conditions and decision.\n        steps.push({\n          kind: \"logic\",\n          statement: {\n            match: condition,\n            decision: input,\n          },\n        });\n      }\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, FlowStep, MatchCondition, StepDecision, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n/**\n * Get the match condition from a FlowStep.\n *\n * - Logic-based steps: match comes from statement.match (the statement is\n *   the sole source of truth for its match conditions)\n * - Handler-based steps (backwards compatibility): match is stored directly on the step\n */\nfunction getMatch(step: FlowStep): MatchCondition {\n  return step.kind === \"logic\" ? step.statement.match : step.match;\n}\n\n/**\n * Derive an index key from a match condition.\n *\n * Currently all match conditions use toolName, so the key is simply\n * the toolName value. When match conditions gain additional fields,\n * this function will evolve to produce compound keys or the indexing\n * strategy will change entirely.\n */\nfunction deriveIndexKey(match: MatchCondition): string {\n  return match.toolName;\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic is expressed as logic statements -- structured data that\n * Taias understands. (Handler functions remain as a backwards-compatible\n * escape hatch.)\n * \n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate match conditions\n  if (devMode) {\n    const seenKeys = new Set<string>();\n    for (const step of flow.steps) {\n      const key = deriveIndexKey(getMatch(step));\n      if (seenKeys.has(key)) {\n        throw new Error(\n          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`\n        );\n      }\n      seenKeys.add(key);\n    }\n  }\n\n  // Build an internal index for efficient resolution.\n  //\n  // Currently all match conditions use toolName as the sole field, so a\n  // Map keyed by toolName is the right index. This is a performance\n  // optimization derived from the current set of match conditions, not a\n  // permanent architectural choice -- it will evolve when match conditions\n  // gain additional fields.\n  const stepIndex = new Map<string, FlowStep>();\n  for (const step of flow.steps) {\n    stepIndex.set(deriveIndexKey(getMatch(step)), step);\n  }\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      // Find the step whose match conditions are satisfied by the context.\n      // Currently, match conditions only contain toolName, so we use the\n      // index keyed by toolName. When match conditions expand, this lookup\n      // will evolve to evaluate all relevant conditions.\n      const step = stepIndex.get(ctx.toolName);\n\n      if (!step) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      // Evaluate the step based on its kind:\n      // - Logic statements: return the decision directly (no function call)\n      // - Handler functions (backwards compatibility): call the handler and await the result\n      let result: StepDecision | null;\n\n      if (step.kind === \"logic\") {\n        result = step.statement.decision;\n      } else {\n        result = await step.handler(ctx);\n      }\n\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["// Main exports\nexport { defineFlow } from \"./flow\";\nexport { createTaias } from \"./createTaias\";\n\n// UI affordances exports\nexport { defineAffordances } from \"./uiAffordances/defineAffordances\";\nexport { mergeAffordances } from \"./uiAffordances/mergeAffordances\";\nexport type { AffordanceRegistrar } from \"./uiAffordances/defineAffordances\";\nexport type {\n  DefaultSlots,\n  CanonicalSlot,\n  Binding,\n  BindingInput,\n  HandleRegistration,\n  Selection,\n  UiSelections,\n  AffordanceRegistry,\n} from \"./uiAffordances/types\";\n\n// Core + flow type exports\nexport type {\n  Condition,\n  FieldCondition,\n  Decision,\n  TaiasContext,\n  StepDecision,\n  Affordances,\n  StepHandler,\n  StepInput,\n  MatchCondition,\n  LogicStatement,\n  FlowStep,\n  FlowDefinition,\n  FlowBuilder,\n  TaiasOptions,\n  Taias,\n} from \"./types\";\n","import type { FlowBuilder, FlowDefinition, FlowStep, MatchCondition, StepInput } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example Logic statement with explicit operator\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step({ toolName: { is: \"scan_repo\" } }, { nextTool: \"configure_app\" });\n * });\n * ```\n *\n * @example isNot operator\n * ```ts\n * flow.step({ toolName: { isNot: \"abort_session\" } }, { nextTool: \"continue_flow\" });\n * ```\n *\n * @example Sugar forms (backwards compatible)\n * Bare strings are sugar for { toolName: { is: string } }:\n * ```ts\n * flow.step({ toolName: \"scan_repo\" }, { nextTool: \"configure_app\" }); // sugar for { is: \"scan_repo\" }\n * flow.step(\"scan_repo\", { nextTool: \"configure_app\" }); // string sugar for { toolName: { is: \"scan_repo\" } }\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(match: string | MatchCondition, input: StepInput): void {\n      // Normalize: string is sugar for { toolName: string }\n      const condition: MatchCondition =\n        typeof match === \"string\" ? { toolName: match } : match;\n\n      if (typeof input === \"function\") {\n        // Handler function -- backwards-compatible escape hatch.\n        // The match condition is stored alongside the handler since\n        // the function itself has no formal match conditions.\n        steps.push({ kind: \"handler\", match: condition, handler: input });\n      } else {\n        // Static logic statement -- the core primitive.\n        // The statement is the sole source of truth for its match\n        // conditions and decision.\n        steps.push({\n          kind: \"logic\",\n          statement: {\n            match: condition,\n            decision: input,\n          },\n        });\n      }\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, Condition, FieldCondition, FlowStep, MatchCondition, StepDecision, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n// ---------------------------------------------------------------------------\n// Condition normalization and evaluation\n// ---------------------------------------------------------------------------\n\n/**\n * Normalize a FieldCondition to a canonical Condition object.\n * A bare string is sugar for { is: string }.\n */\nfunction normalizeFieldCondition(field: FieldCondition): Condition {\n  return typeof field === \"string\" ? { is: field } : field;\n}\n\n/**\n * Evaluate a single Condition against a value.\n */\nfunction evaluateCondition(condition: Condition, value: string): boolean {\n  if (\"is\" in condition) return value === condition.is;\n  if (\"isNot\" in condition) return value !== condition.isNot;\n  return false;\n}\n\n/**\n * Evaluate a full MatchCondition against a TaiasContext.\n * All conditions in the match must be satisfied.\n */\nfunction evaluateMatch(match: MatchCondition, ctx: TaiasContext): boolean {\n  const toolCondition = normalizeFieldCondition(match.toolName);\n  return evaluateCondition(toolCondition, ctx.toolName);\n}\n\n/**\n * Check whether a FieldCondition is indexable (i.e., uses the `is` operator).\n * Indexable conditions enable O(1) Map lookup at resolve time.\n */\nfunction isIndexable(field: FieldCondition): boolean {\n  if (typeof field === \"string\") return true;\n  return \"is\" in field;\n}\n\n/**\n * Extract the index key from an indexable FieldCondition.\n * Only call this when isIndexable() returns true.\n */\nfunction indexKey(field: FieldCondition): string {\n  if (typeof field === \"string\") return field;\n  if (\"is\" in field) return field.is;\n  throw new Error(\"Cannot derive index key from non-indexable condition\");\n}\n\n// ---------------------------------------------------------------------------\n// Step access helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Get the match condition from a FlowStep.\n *\n * - Logic-based steps: match comes from statement.match (the statement is\n *   the sole source of truth for its match conditions)\n * - Handler-based steps (backwards compatibility): match is stored directly on the step\n */\nfunction getMatch(step: FlowStep): MatchCondition {\n  return step.kind === \"logic\" ? step.statement.match : step.match;\n}\n\n/**\n * Serialize a MatchCondition into a stable string for duplicate detection.\n * Normalizes sugar forms so that equivalent conditions produce the same key.\n */\nfunction serializeMatch(match: MatchCondition): string {\n  const normalized = normalizeFieldCondition(match.toolName);\n  return JSON.stringify({ toolName: normalized });\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic is expressed as logic statements -- structured data that\n * Taias understands. (Handler functions remain as a backwards-compatible\n * escape hatch.)\n * \n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate match conditions.\n  // Two steps with structurally identical normalized conditions are duplicates.\n  if (devMode) {\n    const seenKeys = new Set<string>();\n    for (const step of flow.steps) {\n      const key = serializeMatch(getMatch(step));\n      if (seenKeys.has(key)) {\n        const match = getMatch(step);\n        const normalized = normalizeFieldCondition(match.toolName);\n        const label = \"is\" in normalized ? normalized.is : `isNot:${normalized.isNot}`;\n        throw new Error(\n          `Taias: Duplicate match condition '${label}' in flow '${flow.id}'. Each step must have a unique match condition.`\n        );\n      }\n      seenKeys.add(key);\n    }\n  }\n\n  // Build internal indexes for efficient resolution.\n  //\n  // Steps with indexable conditions (is / string sugar) go into an exact\n  // Map for O(1) lookup. Steps with non-indexable conditions (isNot) go\n  // into a separate list. When no broad steps exist, resolve uses the\n  // fast path (Map only). When broad steps exist, resolve evaluates all\n  // steps in definition order.\n  //\n  // This indexing is a performance optimization derived from the current\n  // set of operators, not a permanent architectural choice. It will evolve\n  // as operators and match condition fields expand.\n  const exactIndex = new Map<string, FlowStep>();\n  const broadSteps: FlowStep[] = [];\n\n  for (const step of flow.steps) {\n    const match = getMatch(step);\n    if (isIndexable(match.toolName)) {\n      exactIndex.set(indexKey(match.toolName), step);\n    } else {\n      broadSteps.push(step);\n    }\n  }\n\n  const hasBroadSteps = broadSteps.length > 0;\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      let step: FlowStep | undefined;\n\n      if (!hasBroadSteps) {\n        // Fast path: all steps use indexable conditions (is / string sugar).\n        // O(1) Map lookup -- same performance as before operators were introduced.\n        step = exactIndex.get(ctx.toolName);\n      } else {\n        // Full evaluation: some steps use non-indexable conditions (isNot).\n        // Evaluate all steps in definition order; first match wins.\n        for (const candidate of flow.steps) {\n          if (evaluateMatch(getMatch(candidate), ctx)) {\n            step = candidate;\n            break;\n          }\n        }\n      }\n\n      if (!step) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      // Evaluate the step based on its kind:\n      // - Logic statements: return the decision directly (no function call)\n      // - Handler functions (backwards compatibility): call the handler and await the result\n      let result: StepDecision | null;\n\n      if (step.kind === \"logic\") {\n        result = step.statement.decision;\n      } else {\n        result = await step.handler(ctx);\n      }\n\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}

package/dist/index.d.cts

@@ -92,13 +92,37 @@ type Affordances<S extends string = DefaultSlots> = {
  * Can return synchronously or asynchronously.
  */
 type StepHandler = (ctx: TaiasContext) => StepDecision | null | Promise<StepDecision | null>;
+/**
+ * A condition operator applied to a single field value.
+ *
+ * - { is: "value" }    -- exact equality (field === value)
+ * - { isNot: "value" } -- not equal    (field !== value)
+ *
+ * The operator system is pure data (not wrapper functions), aligning with
+ * the logic-as-data philosophy. New operators (oneOf, contains, etc.) can
+ * be added as union members without changing the evaluation architecture.
+ */
+type Condition = {
+    is: string;
+} | {
+    isNot: string;
+};
+/**
+ * A field condition is either:
+ * - A bare string: sugar for { is: string }
+ * - An explicit Condition object
+ */
+type FieldCondition = string | Condition;
 /**
  * Match condition for a logic statement.
- * Currently only supports toolName matching.
- * Designed to expand with additional fields (params conditions, state, etc.).
+ *
+ * Each field accepts a FieldCondition -- either a bare value (sugar for
+ * { is: value }) or an explicit operator object ({ is: ... }, { isNot: ... }).
+ *
+ * Designed to expand with additional fields (params, result, state, etc.).
  */
 type MatchCondition = {
-    toolName: string;
+    toolName: FieldCondition;
 };
 /**
  * A declarative logic statement -- the core primitive of the decision engine.
@@ -180,18 +204,23 @@ interface Taias<S extends string = DefaultSlots> {
  * @param builder - Callback that receives a FlowBuilder to define steps
  * @returns A FlowDefinition object
  *
- * @example Logic statement with match condition object
+ * @example Logic statement with explicit operator
  * ```ts
  * const onboardRepoFlow = defineFlow("onboard_repo", (flow) => {
- *   flow.step({ toolName: "scan_repo" }, { nextTool: "configure_app" });
+ *   flow.step({ toolName: { is: "scan_repo" } }, { nextTool: "configure_app" });
  * });
  * ```
  *
- * @example Backwards compatibility
- * A string match and handler functions are also supported:
+ * @example isNot operator
+ * ```ts
+ * flow.step({ toolName: { isNot: "abort_session" } }, { nextTool: "continue_flow" });
+ * ```
+ *
+ * @example Sugar forms (backwards compatible)
+ * Bare strings are sugar for { toolName: { is: string } }:
  * ```ts
- * flow.step("scan_repo", { nextTool: "configure_app" }); // string is sugar for { toolName: "scan_repo" }
- * flow.step("scan_repo", (ctx) => ({ nextTool: "configure_app" })); // handler function
+ * flow.step({ toolName: "scan_repo" }, { nextTool: "configure_app" }); // sugar for { is: "scan_repo" }
+ * flow.step("scan_repo", { nextTool: "configure_app" }); // string sugar for { toolName: { is: "scan_repo" } }
  * ```
  */
 declare function defineFlow(flowId: string, builder: (flow: FlowBuilder) => void): FlowDefinition;
@@ -287,4 +316,4 @@ type MergeAffordancesOptions = {
  */
 declare function mergeAffordances<S extends string = DefaultSlots>(registries: AffordanceRegistry<S>[], opts?: MergeAffordancesOptions): AffordanceRegistry<S>;
 
-export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Decision, type DefaultSlots, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type LogicStatement, type MatchCondition, type Selection, type StepDecision, type StepHandler, type StepInput, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };
+export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Condition, type Decision, type DefaultSlots, type FieldCondition, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type LogicStatement, type MatchCondition, type Selection, type StepDecision, type StepHandler, type StepInput, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };

package/dist/index.d.ts

@@ -92,13 +92,37 @@ type Affordances<S extends string = DefaultSlots> = {
  * Can return synchronously or asynchronously.
  */
 type StepHandler = (ctx: TaiasContext) => StepDecision | null | Promise<StepDecision | null>;
+/**
+ * A condition operator applied to a single field value.
+ *
+ * - { is: "value" }    -- exact equality (field === value)
+ * - { isNot: "value" } -- not equal    (field !== value)
+ *
+ * The operator system is pure data (not wrapper functions), aligning with
+ * the logic-as-data philosophy. New operators (oneOf, contains, etc.) can
+ * be added as union members without changing the evaluation architecture.
+ */
+type Condition = {
+    is: string;
+} | {
+    isNot: string;
+};
+/**
+ * A field condition is either:
+ * - A bare string: sugar for { is: string }
+ * - An explicit Condition object
+ */
+type FieldCondition = string | Condition;
 /**
  * Match condition for a logic statement.
- * Currently only supports toolName matching.
- * Designed to expand with additional fields (params conditions, state, etc.).
+ *
+ * Each field accepts a FieldCondition -- either a bare value (sugar for
+ * { is: value }) or an explicit operator object ({ is: ... }, { isNot: ... }).
+ *
+ * Designed to expand with additional fields (params, result, state, etc.).
  */
 type MatchCondition = {
-    toolName: string;
+    toolName: FieldCondition;
 };
 /**
  * A declarative logic statement -- the core primitive of the decision engine.
@@ -180,18 +204,23 @@ interface Taias<S extends string = DefaultSlots> {
  * @param builder - Callback that receives a FlowBuilder to define steps
  * @returns A FlowDefinition object
  *
- * @example Logic statement with match condition object
+ * @example Logic statement with explicit operator
  * ```ts
  * const onboardRepoFlow = defineFlow("onboard_repo", (flow) => {
- *   flow.step({ toolName: "scan_repo" }, { nextTool: "configure_app" });
+ *   flow.step({ toolName: { is: "scan_repo" } }, { nextTool: "configure_app" });
  * });
  * ```
  *
- * @example Backwards compatibility
- * A string match and handler functions are also supported:
+ * @example isNot operator
+ * ```ts
+ * flow.step({ toolName: { isNot: "abort_session" } }, { nextTool: "continue_flow" });
+ * ```
+ *
+ * @example Sugar forms (backwards compatible)
+ * Bare strings are sugar for { toolName: { is: string } }:
  * ```ts
- * flow.step("scan_repo", { nextTool: "configure_app" }); // string is sugar for { toolName: "scan_repo" }
- * flow.step("scan_repo", (ctx) => ({ nextTool: "configure_app" })); // handler function
+ * flow.step({ toolName: "scan_repo" }, { nextTool: "configure_app" }); // sugar for { is: "scan_repo" }
+ * flow.step("scan_repo", { nextTool: "configure_app" }); // string sugar for { toolName: { is: "scan_repo" } }
  * ```
  */
 declare function defineFlow(flowId: string, builder: (flow: FlowBuilder) => void): FlowDefinition;
@@ -287,4 +316,4 @@ type MergeAffordancesOptions = {
  */
 declare function mergeAffordances<S extends string = DefaultSlots>(registries: AffordanceRegistry<S>[], opts?: MergeAffordancesOptions): AffordanceRegistry<S>;
 
-export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Decision, type DefaultSlots, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type LogicStatement, type MatchCondition, type Selection, type StepDecision, type StepHandler, type StepInput, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };
+export { type AffordanceRegistrar, type AffordanceRegistry, type Affordances, type Binding, type BindingInput, type CanonicalSlot, type Condition, type Decision, type DefaultSlots, type FieldCondition, type FlowBuilder, type FlowDefinition, type FlowStep, type HandleRegistration, type LogicStatement, type MatchCondition, type Selection, type StepDecision, type StepHandler, type StepInput, type Taias, type TaiasContext, type TaiasOptions, type UiSelections, createTaias, defineAffordances, defineFlow, mergeAffordances };

package/dist/index.js

@@ -82,11 +82,33 @@ function selectUiAffordances(decision, index, opts = {}) {
 function generateAdvice(nextTool) {
   return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;
 }
+function normalizeFieldCondition(field) {
+  return typeof field === "string" ? { is: field } : field;
+}
+function evaluateCondition(condition, value) {
+  if ("is" in condition) return value === condition.is;
+  if ("isNot" in condition) return value !== condition.isNot;
+  return false;
+}
+function evaluateMatch(match, ctx) {
+  const toolCondition = normalizeFieldCondition(match.toolName);
+  return evaluateCondition(toolCondition, ctx.toolName);
+}
+function isIndexable(field) {
+  if (typeof field === "string") return true;
+  return "is" in field;
+}
+function indexKey(field) {
+  if (typeof field === "string") return field;
+  if ("is" in field) return field.is;
+  throw new Error("Cannot derive index key from non-indexable condition");
+}
 function getMatch(step) {
   return step.kind === "logic" ? step.statement.match : step.match;
 }
-function deriveIndexKey(match) {
-  return match.toolName;
+function serializeMatch(match) {
+  const normalized = normalizeFieldCondition(match.toolName);
+  return JSON.stringify({ toolName: normalized });
 }
 function createTaias(options) {
   const {
@@ -100,23 +122,43 @@ function createTaias(options) {
   if (devMode) {
     const seenKeys = /* @__PURE__ */ new Set();
     for (const step of flow.steps) {
-      const key = deriveIndexKey(getMatch(step));
+      const key = serializeMatch(getMatch(step));
       if (seenKeys.has(key)) {
+        const match = getMatch(step);
+        const normalized = normalizeFieldCondition(match.toolName);
+        const label = "is" in normalized ? normalized.is : `isNot:${normalized.isNot}`;
         throw new Error(
-          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`
+          `Taias: Duplicate match condition '${label}' in flow '${flow.id}'. Each step must have a unique match condition.`
         );
       }
       seenKeys.add(key);
     }
   }
-  const stepIndex = /* @__PURE__ */ new Map();
+  const exactIndex = /* @__PURE__ */ new Map();
+  const broadSteps = [];
   for (const step of flow.steps) {
-    stepIndex.set(deriveIndexKey(getMatch(step)), step);
+    const match = getMatch(step);
+    if (isIndexable(match.toolName)) {
+      exactIndex.set(indexKey(match.toolName), step);
+    } else {
+      broadSteps.push(step);
+    }
   }
+  const hasBroadSteps = broadSteps.length > 0;
   const registryIndex = buildRegistryIndex(affordances);
   return {
     async resolve(ctx) {
-      const step = stepIndex.get(ctx.toolName);
+      let step;
+      if (!hasBroadSteps) {
+        step = exactIndex.get(ctx.toolName);
+      } else {
+        for (const candidate of flow.steps) {
+          if (evaluateMatch(getMatch(candidate), ctx)) {
+            step = candidate;
+            break;
+          }
+        }
+      }
       if (!step) {
         onMissingStep?.(ctx);
         return null;

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["import type { FlowBuilder, FlowDefinition, FlowStep, MatchCondition, StepInput } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example Logic statement with match condition object\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step({ toolName: \"scan_repo\" }, { nextTool: \"configure_app\" });\n * });\n * ```\n *\n * @example Backwards compatibility\n * A string match and handler functions are also supported:\n * ```ts\n * flow.step(\"scan_repo\", { nextTool: \"configure_app\" }); // string is sugar for { toolName: \"scan_repo\" }\n * flow.step(\"scan_repo\", (ctx) => ({ nextTool: \"configure_app\" })); // handler function\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(match: string | MatchCondition, input: StepInput): void {\n      // Normalize: string is sugar for { toolName: string }\n      const condition: MatchCondition =\n        typeof match === \"string\" ? { toolName: match } : match;\n\n      if (typeof input === \"function\") {\n        // Handler function -- backwards-compatible escape hatch.\n        // The match condition is stored alongside the handler since\n        // the function itself has no formal match conditions.\n        steps.push({ kind: \"handler\", match: condition, handler: input });\n      } else {\n        // Static logic statement -- the core primitive.\n        // The statement is the sole source of truth for its match\n        // conditions and decision.\n        steps.push({\n          kind: \"logic\",\n          statement: {\n            match: condition,\n            decision: input,\n          },\n        });\n      }\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, FlowStep, MatchCondition, StepDecision, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n/**\n * Get the match condition from a FlowStep.\n *\n * - Logic-based steps: match comes from statement.match (the statement is\n *   the sole source of truth for its match conditions)\n * - Handler-based steps (backwards compatibility): match is stored directly on the step\n */\nfunction getMatch(step: FlowStep): MatchCondition {\n  return step.kind === \"logic\" ? step.statement.match : step.match;\n}\n\n/**\n * Derive an index key from a match condition.\n *\n * Currently all match conditions use toolName, so the key is simply\n * the toolName value. When match conditions gain additional fields,\n * this function will evolve to produce compound keys or the indexing\n * strategy will change entirely.\n */\nfunction deriveIndexKey(match: MatchCondition): string {\n  return match.toolName;\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic is expressed as logic statements -- structured data that\n * Taias understands. (Handler functions remain as a backwards-compatible\n * escape hatch.)\n * \n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate match conditions\n  if (devMode) {\n    const seenKeys = new Set<string>();\n    for (const step of flow.steps) {\n      const key = deriveIndexKey(getMatch(step));\n      if (seenKeys.has(key)) {\n        throw new Error(\n          `Taias: Duplicate match condition '${key}' in flow '${flow.id}'. Each step must have a unique match condition.`\n        );\n      }\n      seenKeys.add(key);\n    }\n  }\n\n  // Build an internal index for efficient resolution.\n  //\n  // Currently all match conditions use toolName as the sole field, so a\n  // Map keyed by toolName is the right index. This is a performance\n  // optimization derived from the current set of match conditions, not a\n  // permanent architectural choice -- it will evolve when match conditions\n  // gain additional fields.\n  const stepIndex = new Map<string, FlowStep>();\n  for (const step of flow.steps) {\n    stepIndex.set(deriveIndexKey(getMatch(step)), step);\n  }\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      // Find the step whose match conditions are satisfied by the context.\n      // Currently, match conditions only contain toolName, so we use the\n      // index keyed by toolName. When match conditions expand, this lookup\n      // will evolve to evaluate all relevant conditions.\n      const step = stepIndex.get(ctx.toolName);\n\n      if (!step) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      // Evaluate the step based on its kind:\n      // - Logic statements: return the decision directly (no function call)\n      // - Handler functions (backwards compatibility): call the handler and await the result\n      let result: StepDecision | null;\n\n      if (step.kind === \"logic\") {\n        result = step.statement.decision;\n      } else {\n        result = await step.handler(ctx);\n      }\n\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/flow.ts","../src/uiAffordances/types.ts","../src/uiAffordances/indexing.ts","../src/uiAffordances/select.ts","../src/createTaias.ts","../src/uiAffordances/defineAffordances.ts","../src/uiAffordances/mergeAffordances.ts"],"sourcesContent":["import type { FlowBuilder, FlowDefinition, FlowStep, MatchCondition, StepInput } from \"./types\";\n\n/**\n * Define a flow with its steps.\n *\n * @param flowId - Unique identifier for the flow\n * @param builder - Callback that receives a FlowBuilder to define steps\n * @returns A FlowDefinition object\n *\n * @example Logic statement with explicit operator\n * ```ts\n * const onboardRepoFlow = defineFlow(\"onboard_repo\", (flow) => {\n *   flow.step({ toolName: { is: \"scan_repo\" } }, { nextTool: \"configure_app\" });\n * });\n * ```\n *\n * @example isNot operator\n * ```ts\n * flow.step({ toolName: { isNot: \"abort_session\" } }, { nextTool: \"continue_flow\" });\n * ```\n *\n * @example Sugar forms (backwards compatible)\n * Bare strings are sugar for { toolName: { is: string } }:\n * ```ts\n * flow.step({ toolName: \"scan_repo\" }, { nextTool: \"configure_app\" }); // sugar for { is: \"scan_repo\" }\n * flow.step(\"scan_repo\", { nextTool: \"configure_app\" }); // string sugar for { toolName: { is: \"scan_repo\" } }\n * ```\n */\nexport function defineFlow(\n  flowId: string,\n  builder: (flow: FlowBuilder) => void\n): FlowDefinition {\n  const steps: FlowStep[] = [];\n\n  const flowBuilder: FlowBuilder = {\n    step(match: string | MatchCondition, input: StepInput): void {\n      // Normalize: string is sugar for { toolName: string }\n      const condition: MatchCondition =\n        typeof match === \"string\" ? { toolName: match } : match;\n\n      if (typeof input === \"function\") {\n        // Handler function -- backwards-compatible escape hatch.\n        // The match condition is stored alongside the handler since\n        // the function itself has no formal match conditions.\n        steps.push({ kind: \"handler\", match: condition, handler: input });\n      } else {\n        // Static logic statement -- the core primitive.\n        // The statement is the sole source of truth for its match\n        // conditions and decision.\n        steps.push({\n          kind: \"logic\",\n          statement: {\n            match: condition,\n            decision: input,\n          },\n        });\n      }\n    },\n  };\n\n  builder(flowBuilder);\n\n  return {\n    id: flowId,\n    steps,\n  };\n}\n\n","/**\n * Default slots for backwards compatibility.\n * Users can define custom slots by passing a type parameter.\n */\nexport type DefaultSlots = \"primaryCta\" | \"secondaryCta\" | \"widgetVariant\";\n\n/**\n * Alias for backwards compatibility in exports.\n * @deprecated Use DefaultSlots or define your own slot type\n */\nexport type CanonicalSlot = DefaultSlots;\n\nexport type Binding = {\n  key: string;\n  value: string;\n};\n\n/**\n * Input format for registering affordance bindings.\n * - { toolName } is shorthand for { key: \"nextTool\", value: toolName }\n * - { key, value } is the generalized form for custom bindings\n */\nexport type BindingInput = { toolName: string } | { key: string; value: string };\n\n/**\n * A registered UI affordance handle.\n * Generic over slot type S for custom slot support.\n */\nexport type HandleRegistration<S extends string = DefaultSlots> = {\n  slot: S;\n  handleId: string;\n  bindsTo: Binding;\n};\n\nexport type Selection = {\n  handleId: string;\n  bindsTo: Binding;\n};\n\n/**\n * UI selections keyed by slot name.\n * Generic over slot type S for custom slot support.\n */\nexport type UiSelections<S extends string = DefaultSlots> = Partial<Record<S, Selection>>;\n\n/**\n * Collection of registered handles.\n * Generic over slot type S for custom slot support.\n */\nexport type AffordanceRegistry<S extends string = DefaultSlots> = {\n  handles: HandleRegistration<S>[];\n};\n\nexport function normalizeBinding(input: BindingInput): Binding {\n  if (\"toolName\" in input) return { key: \"nextTool\", value: input.toolName };\n  return { key: input.key, value: input.value };\n}\n\n/**\n * Creates a binding key for indexing.\n * Accepts any string for slot to support custom slots.\n */\nexport function makeBindingKey(slot: string, binding: Binding): string {\n  return `${slot}::${binding.key}::${binding.value}`;\n}\n","import type { AffordanceRegistry, DefaultSlots, HandleRegistration } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\n/**\n * Index structure for efficient affordance lookup.\n * Generic over slot type S for custom slot support.\n */\nexport type RegistryIndex<S extends string = DefaultSlots> = {\n  byBindingKey: Map<string, HandleRegistration<S>>;\n  slots: Set<S>;\n  /** Inferred decision field for each slot, derived from handle bindings. */\n  slotKeyMap: Map<S, string>;\n};\n\n/**\n * Build an index from a registry for efficient lookup during selection.\n * Tracks which slots have registered handles and infers the decision field\n * for each slot from its handle bindings.\n *\n * @throws Error if handles for the same slot bind to different keys\n */\nexport function buildRegistryIndex<S extends string = DefaultSlots>(\n  registry?: AffordanceRegistry<S>\n): RegistryIndex<S> {\n  const byBindingKey = new Map<string, HandleRegistration<S>>();\n  const slots = new Set<S>();\n  const slotKeyMap = new Map<S, string>();\n\n  if (!registry) return { byBindingKey, slots, slotKeyMap };\n\n  for (const h of registry.handles) {\n    slots.add(h.slot);\n\n    // Infer and validate slot key\n    const existingKey = slotKeyMap.get(h.slot);\n    if (existingKey && existingKey !== h.bindsTo.key) {\n      throw new Error(\n        `[Taias] Slot \"${h.slot}\" has handles bound to different keys: \"${existingKey}\" and \"${h.bindsTo.key}\". ` +\n          `All handles for a slot must use the same decision field.`\n      );\n    }\n    slotKeyMap.set(h.slot, h.bindsTo.key);\n\n    byBindingKey.set(makeBindingKey(h.slot, h.bindsTo), h);\n  }\n\n  return { byBindingKey, slots, slotKeyMap };\n}\n","import type { Decision } from \"../types\";\nimport type { DefaultSlots, UiSelections } from \"./types\";\nimport type { RegistryIndex } from \"./indexing\";\nimport { makeBindingKey } from \"./types\";\n\nexport type SelectOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Select UI affordances based on flow decision.\n * Uses the inferred decision field for each slot from the registry index.\n */\nexport function selectUiAffordances<S extends string = DefaultSlots>(\n  decision: Decision,\n  index: RegistryIndex<S>,\n  opts: SelectOptions = {}\n): UiSelections<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const selections: UiSelections<S> = {};\n\n  for (const slot of index.slots) {\n    // Use inferred key from handle bindings\n    const field = index.slotKeyMap.get(slot);\n    if (!field) continue;\n\n    const value = decision[field];\n    if (!value) continue;\n\n    const k = makeBindingKey(slot, { key: field, value });\n    const handle = index.byBindingKey.get(k);\n\n    if (!handle) {\n      if (devMode) warn(`[Taias] No affordance for slot \"${slot}\" when ${field}=\"${value}\"`);\n      continue;\n    }\n\n    (selections as Record<string, unknown>)[slot] = {\n      handleId: handle.handleId,\n      bindsTo: handle.bindsTo,\n    };\n  }\n\n  return selections;\n}\n","import type { Affordances, Condition, FieldCondition, FlowStep, MatchCondition, StepDecision, Taias, TaiasContext, TaiasOptions, Decision } from \"./types\";\nimport type { DefaultSlots } from \"./uiAffordances/types\";\nimport { buildRegistryIndex } from \"./uiAffordances/indexing\";\nimport { selectUiAffordances } from \"./uiAffordances/select\";\n\n/**\n * Generate advice text for a given next tool.\n */\nfunction generateAdvice(nextTool: string): string {\n  return `FOR THE BEST USER EXPERIENCE, TELL THE USER TO USE THE ${nextTool} TOOL NEXT!!!!!`;\n}\n\n// ---------------------------------------------------------------------------\n// Condition normalization and evaluation\n// ---------------------------------------------------------------------------\n\n/**\n * Normalize a FieldCondition to a canonical Condition object.\n * A bare string is sugar for { is: string }.\n */\nfunction normalizeFieldCondition(field: FieldCondition): Condition {\n  return typeof field === \"string\" ? { is: field } : field;\n}\n\n/**\n * Evaluate a single Condition against a value.\n */\nfunction evaluateCondition(condition: Condition, value: string): boolean {\n  if (\"is\" in condition) return value === condition.is;\n  if (\"isNot\" in condition) return value !== condition.isNot;\n  return false;\n}\n\n/**\n * Evaluate a full MatchCondition against a TaiasContext.\n * All conditions in the match must be satisfied.\n */\nfunction evaluateMatch(match: MatchCondition, ctx: TaiasContext): boolean {\n  const toolCondition = normalizeFieldCondition(match.toolName);\n  return evaluateCondition(toolCondition, ctx.toolName);\n}\n\n/**\n * Check whether a FieldCondition is indexable (i.e., uses the `is` operator).\n * Indexable conditions enable O(1) Map lookup at resolve time.\n */\nfunction isIndexable(field: FieldCondition): boolean {\n  if (typeof field === \"string\") return true;\n  return \"is\" in field;\n}\n\n/**\n * Extract the index key from an indexable FieldCondition.\n * Only call this when isIndexable() returns true.\n */\nfunction indexKey(field: FieldCondition): string {\n  if (typeof field === \"string\") return field;\n  if (\"is\" in field) return field.is;\n  throw new Error(\"Cannot derive index key from non-indexable condition\");\n}\n\n// ---------------------------------------------------------------------------\n// Step access helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Get the match condition from a FlowStep.\n *\n * - Logic-based steps: match comes from statement.match (the statement is\n *   the sole source of truth for its match conditions)\n * - Handler-based steps (backwards compatibility): match is stored directly on the step\n */\nfunction getMatch(step: FlowStep): MatchCondition {\n  return step.kind === \"logic\" ? step.statement.match : step.match;\n}\n\n/**\n * Serialize a MatchCondition into a stable string for duplicate detection.\n * Normalizes sugar forms so that equivalent conditions produce the same key.\n */\nfunction serializeMatch(match: MatchCondition): string {\n  const normalized = normalizeFieldCondition(match.toolName);\n  return JSON.stringify({ toolName: normalized });\n}\n\n/**\n * createTaias constructs a decision engine.\n *\n * Taias resolves context into a generalized Decision object,\n * and then manifests that decision into concrete affordances:\n *\n *   - LLM guidance (advice)\n *   - UI affordance selections\n *\n * Flow logic is expressed as logic statements -- structured data that\n * Taias understands. (Handler functions remain as a backwards-compatible\n * escape hatch.)\n * \n * Flow logic determines *what should happen next*.\n * UI affordances determine *how that decision appears in the interface*.\n *\n * This file is the boundary where:\n *\n *   Inputs → Decision → Manifestations\n *\n * are unified into a single resolve() call.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const taias = createTaias({ flow, affordances });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta\", { key: \"nextTool\", value: \"createUser\" });\n *   r.contentArea(\"content\", { key: \"contentArea\", value: \"form\" });\n *   r.headerStyle(\"header\", { key: \"headerStyle\", value: \"progress\" });\n * });\n * const taias = createTaias<MySlots>({ flow, affordances });\n * ```\n */\nexport function createTaias<S extends string = DefaultSlots>(\n  options: TaiasOptions<S>\n): Taias<S> {\n  const {\n    flow,\n    affordances,\n    devMode = false,\n    onMissingStep,\n    onWarn,\n  } = options;\n\n  const warn = onWarn ?? ((msg: string) => console.warn(msg));\n\n  // Dev mode: Check for duplicate match conditions.\n  // Two steps with structurally identical normalized conditions are duplicates.\n  if (devMode) {\n    const seenKeys = new Set<string>();\n    for (const step of flow.steps) {\n      const key = serializeMatch(getMatch(step));\n      if (seenKeys.has(key)) {\n        const match = getMatch(step);\n        const normalized = normalizeFieldCondition(match.toolName);\n        const label = \"is\" in normalized ? normalized.is : `isNot:${normalized.isNot}`;\n        throw new Error(\n          `Taias: Duplicate match condition '${label}' in flow '${flow.id}'. Each step must have a unique match condition.`\n        );\n      }\n      seenKeys.add(key);\n    }\n  }\n\n  // Build internal indexes for efficient resolution.\n  //\n  // Steps with indexable conditions (is / string sugar) go into an exact\n  // Map for O(1) lookup. Steps with non-indexable conditions (isNot) go\n  // into a separate list. When no broad steps exist, resolve uses the\n  // fast path (Map only). When broad steps exist, resolve evaluates all\n  // steps in definition order.\n  //\n  // This indexing is a performance optimization derived from the current\n  // set of operators, not a permanent architectural choice. It will evolve\n  // as operators and match condition fields expand.\n  const exactIndex = new Map<string, FlowStep>();\n  const broadSteps: FlowStep[] = [];\n\n  for (const step of flow.steps) {\n    const match = getMatch(step);\n    if (isIndexable(match.toolName)) {\n      exactIndex.set(indexKey(match.toolName), step);\n    } else {\n      broadSteps.push(step);\n    }\n  }\n\n  const hasBroadSteps = broadSteps.length > 0;\n\n  // Build affordance index once (if provided)\n  const registryIndex = buildRegistryIndex<S>(affordances);\n\n  return {\n    async resolve(ctx: TaiasContext): Promise<Affordances<S> | null> {\n      let step: FlowStep | undefined;\n\n      if (!hasBroadSteps) {\n        // Fast path: all steps use indexable conditions (is / string sugar).\n        // O(1) Map lookup -- same performance as before operators were introduced.\n        step = exactIndex.get(ctx.toolName);\n      } else {\n        // Full evaluation: some steps use non-indexable conditions (isNot).\n        // Evaluate all steps in definition order; first match wins.\n        for (const candidate of flow.steps) {\n          if (evaluateMatch(getMatch(candidate), ctx)) {\n            step = candidate;\n            break;\n          }\n        }\n      }\n\n      if (!step) {\n        onMissingStep?.(ctx);\n        return null;\n      }\n\n      // Evaluate the step based on its kind:\n      // - Logic statements: return the decision directly (no function call)\n      // - Handler functions (backwards compatibility): call the handler and await the result\n      let result: StepDecision | null;\n\n      if (step.kind === \"logic\") {\n        result = step.statement.decision;\n      } else {\n        result = await step.handler(ctx);\n      }\n\n      if (!result) return null;\n\n      if (devMode && result.nextTool === \"\") {\n        warn(`Taias: nextTool for tool '${ctx.toolName}' is empty.`);\n      }\n\n      // Build decision object from flow result (spread all fields)\n      const decision: Decision = { ...result };\n\n      // Compute UI selections (may be empty if no registry passed)\n      const selections = selectUiAffordances<S>(decision, registryIndex, {\n        devMode,\n        onWarn: warn,\n      });\n\n      return {\n        advice: generateAdvice(result.nextTool),\n        decision,\n        selections,\n      };\n    },\n  };\n}\n","import type {\n  AffordanceRegistry,\n  BindingInput,\n  DefaultSlots,\n  HandleRegistration,\n} from \"./types\";\nimport { normalizeBinding } from \"./types\";\n\n/**\n * Mapped type that creates a registration method for each slot in S.\n * This enables fully typed custom slots via generics.\n */\nexport type AffordanceRegistrar<S extends string = DefaultSlots> = {\n  [K in S]: (handleId: string, bindsTo: BindingInput) => void;\n};\n\n/**\n * Define UI affordances for a widget using a builder pattern.\n *\n * @example Default slots (backwards compatible)\n * ```ts\n * const affordances = defineAffordances((r) => {\n *   r.primaryCta(\"cta.recommend\", { toolName: \"get_recommendations\" });\n *   r.widgetVariant(\"variant.discovery\", { toolName: \"get_recommendations\" });\n * });\n * ```\n *\n * @example Custom slots (fully type-safe)\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\" | \"headerStyle\";\n * const affordances = defineAffordances<MySlots>((r) => {\n *   r.primaryCta(\"cta.create\", { toolName: \"createUser\" });\n *   r.contentArea(\"content.form\", { key: \"contentArea\", value: \"email-form\" });\n *   r.headerStyle(\"header.progress\", { key: \"headerStyle\", value: \"step-1\" });\n * });\n * ```\n */\nexport function defineAffordances<S extends string = DefaultSlots>(\n  builder: (r: AffordanceRegistrar<S>) => void\n): AffordanceRegistry<S> {\n  const handles: HandleRegistration<S>[] = [];\n\n  // Proxy creates methods on-the-fly for any slot name.\n  // TypeScript ensures only valid slot names (from S) are called.\n  const registrar = new Proxy({} as AffordanceRegistrar<S>, {\n    get(_, slot: string) {\n      return (handleId: string, bindsTo: BindingInput) => {\n        handles.push({\n          slot: slot as S,\n          handleId,\n          bindsTo: normalizeBinding(bindsTo),\n        });\n      };\n    },\n  });\n\n  builder(registrar);\n  return { handles };\n}\n","import type { AffordanceRegistry, DefaultSlots } from \"./types\";\nimport { makeBindingKey } from \"./types\";\n\nexport type MergeAffordancesOptions = {\n  devMode?: boolean;\n  onWarn?: (msg: string) => void;\n};\n\n/**\n * Merge multiple affordance registries into one.\n * Generic over slot type S for custom slot support.\n *\n * @example Default slots\n * ```ts\n * const merged = mergeAffordances([widgetA, widgetB]);\n * ```\n *\n * @example Custom slots\n * ```ts\n * type MySlots = \"primaryCta\" | \"contentArea\";\n * const merged = mergeAffordances<MySlots>([widgetA, widgetB]);\n * ```\n */\nexport function mergeAffordances<S extends string = DefaultSlots>(\n  registries: AffordanceRegistry<S>[],\n  opts: MergeAffordancesOptions = {}\n): AffordanceRegistry<S> {\n  const devMode = !!opts.devMode;\n  const warn = opts.onWarn ?? (() => {});\n\n  const merged: AffordanceRegistry<S> = { handles: registries.flatMap((r) => r.handles) };\n\n  if (!devMode) return merged;\n\n  // Check for duplicate handleIds\n  const seenHandleIds = new Set<string>();\n  for (const h of merged.handles) {\n    if (seenHandleIds.has(h.handleId)) {\n      throw new Error(`[Taias] Duplicate handleId \"${h.handleId}\"`);\n    }\n    seenHandleIds.add(h.handleId);\n  }\n\n  // Check for ambiguous bindings (same slot + key + value)\n  const seenTriples = new Set<string>();\n  for (const h of merged.handles) {\n    const k = makeBindingKey(h.slot, h.bindsTo);\n    if (seenTriples.has(k)) {\n      throw new Error(\n        `[Taias] Ambiguous affordance: slot \"${h.slot}\" has multiple handles bound to (${h.bindsTo.key}=\"${h.bindsTo.value}\")`\n      );\n    }\n    seenTriples.add(k);\n  }\n\n  warn(`[Taias] Loaded ${merged.handles.length} UI affordance handles`);\n  return merged;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taias",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "type": "module",
   "description": "Taias - Give your MCP server an opinion, guide your users to achieve outcomes",
   "license": "Apache-2.0",