@almadar/evaluator 2.32.0 → 2.33.0

package/dist/index.js

@@ -1,6 +1,5 @@
 import { isSExpr, isBinding, getOperator, getArgs, isFieldValue, isEventPayloadValue, isSessionHistoryEntry, isPlanSnapshot, OrbitalZodSchema, safeParseOrbitalSchema } from '@almadar/core';
 export { CORE_BINDINGS, ExpressionSchema, SExprSchema, collectBindings, getArgs, getOperator, isBinding, isSExpr, isSExprAtom, isSExprCall, isValidBinding, parseBinding, sexpr, walkSExpr } from '@almadar/core';
-import { createRequire } from 'module';
 
 // types/expression.ts
 
@@ -104,10 +103,3683 @@ function resolveBinding(binding, ctx) {
   }
   return value;
 }
-var require2 = createRequire(import.meta.url);
-var canonicalOperators = require2("@almadar/std/canonical-operators.json");
+
+// node_modules/.pnpm/@almadar+std@16.142.0/node_modules/@almadar/std/canonical-operators.json
+var canonical_operators_default = {
+  operators: {
+    "!=": {
+      category: "comparison",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Not equal to",
+      module: "core"
+    },
+    "%": {
+      category: "arithmetic",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Modulo (remainder)",
+      module: "core"
+    },
+    "*": {
+      category: "arithmetic",
+      minArity: 2,
+      maxArity: null,
+      returnType: "number",
+      description: "Multiply numbers",
+      module: "core"
+    },
+    "+": {
+      category: "arithmetic",
+      minArity: 2,
+      maxArity: null,
+      returnType: "number",
+      description: "Add numbers",
+      module: "core"
+    },
+    "-": {
+      category: "arithmetic",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Subtract or negate",
+      module: "core"
+    },
+    "/": {
+      category: "arithmetic",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Divide numbers",
+      module: "core"
+    },
+    "<": {
+      category: "comparison",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Less than",
+      module: "core"
+    },
+    "<=": {
+      category: "comparison",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Less than or equal",
+      module: "core"
+    },
+    "=": {
+      category: "comparison",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Equal to",
+      module: "core"
+    },
+    ">": {
+      category: "comparison",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Greater than",
+      module: "core"
+    },
+    ">=": {
+      category: "comparison",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Greater than or equal",
+      module: "core"
+    },
+    and: {
+      category: "logic",
+      minArity: 2,
+      maxArity: null,
+      returnType: "boolean",
+      description: "Logical AND (returns the last truthy value, NOT a boolean \u2014 short-circuit)",
+      module: "core",
+      returnSemantics: "last-truthy-of-args"
+    },
+    "anim/direction-from-delta": {
+      category: "std-anim",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "string",
+      description: "Facing direction string from (dx,dy); 4-way (default) or 8-way",
+      module: "anim"
+    },
+    "anim/frame-at": {
+      category: "std-anim",
+      minArity: 3,
+      maxArity: 4,
+      returnType: "number",
+      description: "Frame index for elapsed time; loops by default, else clamps to last",
+      module: "anim"
+    },
+    "anim/sheet-rect": {
+      category: "std-anim",
+      minArity: 4,
+      maxArity: 4,
+      returnType: "object",
+      description: "Source rect {sx,sy,sw,sh} for a frame index on a sprite sheet",
+      module: "anim"
+    },
+    "array/append": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Add item to end (returns new array)",
+      module: "array"
+    },
+    "array/avg": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Average of values (optionally by field)",
+      module: "array"
+    },
+    "array/concat": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: null,
+      returnType: "array",
+      description: "Concatenate arrays",
+      module: "array"
+    },
+    "array/count": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Count elements (optionally matching predicate)",
+      module: "array"
+    },
+    "array/drop": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Skip first n elements",
+      module: "array"
+    },
+    "array/dropLast": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Skip last n elements",
+      module: "array"
+    },
+    "array/empty?": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if array is empty",
+      module: "array"
+    },
+    "array/every": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if all elements match predicate",
+      module: "array"
+    },
+    "array/filter": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Keep elements matching predicate (returns same array element type as input)",
+      module: "array",
+      returnSemantics: "identity-of-arg<0>"
+    },
+    "array/find": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Find first element matching predicate (element type of input array, undefined when no match)",
+      module: "array",
+      returnSemantics: "element-of-arg<0>?"
+    },
+    "array/findIndex": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Find index of first element matching predicate (-1 if none)",
+      module: "array"
+    },
+    "array/first": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "any",
+      description: "Get first element (element type of input array, may be undefined when empty)",
+      module: "array",
+      returnSemantics: "element-of-arg<0>?"
+    },
+    "array/flatten": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Flatten nested arrays one level",
+      module: "array"
+    },
+    "array/groupBy": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Group elements by field value",
+      module: "array"
+    },
+    "array/includes": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if array contains item",
+      module: "array"
+    },
+    "array/indexOf": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Find index of item (-1 if not found)",
+      module: "array"
+    },
+    "array/insert": {
+      category: "std-array",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "array",
+      description: "Insert item at index (returns new array)",
+      module: "array"
+    },
+    "array/last": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "any",
+      description: "Get last element (element type of input array, may be undefined when empty)",
+      module: "array",
+      returnSemantics: "element-of-arg<0>?"
+    },
+    "array/len": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Array length",
+      module: "array"
+    },
+    "array/map": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Transform each element (return type wraps the lambda result in an array)",
+      module: "array",
+      returnSemantics: "lambda-result"
+    },
+    "array/max": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Maximum value (optionally by field)",
+      module: "array"
+    },
+    "array/min": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Minimum value (optionally by field)",
+      module: "array"
+    },
+    "array/nth": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Get element at index (element type of input array, may be undefined out-of-bounds)",
+      module: "array",
+      returnSemantics: "element-of-arg<0>?"
+    },
+    "array/partition": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Split array by predicate into [matches, nonMatches]",
+      module: "array"
+    },
+    "array/prepend": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Add item to start (returns new array)",
+      module: "array"
+    },
+    "array/range": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 3,
+      returnType: "array",
+      description: "Generate numbers: (range n) => [0,n); (range start end) => [start,end); optional step",
+      module: "array"
+    },
+    "array/reduce": {
+      category: "std-array",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "any",
+      description: "Reduce array to single value (return type matches the lambda result / init type)",
+      module: "array",
+      returnSemantics: "lambda-result"
+    },
+    "array/reject": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Remove elements matching predicate (returns same array element type as input)",
+      module: "array",
+      returnSemantics: "identity-of-arg<0>"
+    },
+    "array/remove": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Remove item at index (returns new array)",
+      module: "array"
+    },
+    "array/removeItem": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Remove first matching item (returns new array)",
+      module: "array"
+    },
+    "array/reverse": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Reverse array order (returns new array)",
+      module: "array"
+    },
+    "array/shuffle": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Randomly shuffle array (returns new array)",
+      module: "array"
+    },
+    "array/slice": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "array",
+      description: "Extract subarray",
+      module: "array"
+    },
+    "array/some": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if any element matches predicate",
+      module: "array"
+    },
+    "array/sort": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 3,
+      returnType: "array",
+      description: "Sort array (returns new array)",
+      module: "array"
+    },
+    "array/sum": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Sum values (optionally by field)",
+      module: "array"
+    },
+    "array/take": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Take first n elements",
+      module: "array"
+    },
+    "array/takeLast": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Take last n elements",
+      module: "array"
+    },
+    "array/unique": {
+      category: "std-array",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Remove duplicates (returns new array)",
+      module: "array"
+    },
+    "array/zip": {
+      category: "std-array",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Pair elements from two arrays",
+      module: "array"
+    },
+    "async/all": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: null,
+      returnType: "array",
+      description: "Execute effects in parallel, wait for all to complete",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/debounce": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Debounce an event (wait for pause in events)",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/delay": {
+      category: "std-async",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "any",
+      description: "Wait for specified milliseconds, optionally execute an effect after",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/interval": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "string",
+      description: "Execute an effect periodically at a fixed interval",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/race": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: null,
+      returnType: "any",
+      description: "Execute effects in parallel, return first to complete",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/retry": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Retry an effect with configurable backoff",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/sequence": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: null,
+      returnType: "array",
+      description: "Execute effects in sequence (one after another)",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/throttle": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Throttle an event (emit at most once per interval)",
+      module: "async",
+      hasSideEffects: true
+    },
+    "async/timeout": {
+      category: "std-async",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Add timeout to an effect",
+      module: "async",
+      hasSideEffects: true
+    },
+    "behavior/call": {
+      category: "std-behavior",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "ServiceCallResult",
+      description: "Call a behavior service action. Returns the ServiceCallResult union \u2014 resolves to the specific member when the (behavior, action) pair is a literal.",
+      module: "behavior",
+      hasSideEffects: true
+    },
+    "behavior/compose": {
+      category: "std-composition",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "object",
+      description: "Compose N orbitals into one application schema. Wires events, picks layout, generates pages.",
+      module: "composition"
+    },
+    "behavior/detect-layout": {
+      category: "std-composition",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "string",
+      description: "Auto-detect layout from orbital count and wiring topology. Returns single, tabs, sidebar, dashboard, or wizard-flow.",
+      module: "composition"
+    },
+    "behavior/instantiate": {
+      category: "std-behavior",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "BuilderResult",
+      description: "Instantiate a behavior from the registry at runtime (meta-programming). Equivalent to compile-time `uses` but dynamic \u2014 the behavior name is a runtime value. Applies the same override surface (linkedEntity, events, config, fields).",
+      module: "behavior",
+      hasSideEffects: true
+    },
+    "behavior/pipe": {
+      category: "std-composition",
+      minArity: 2,
+      maxArity: null,
+      returnType: "any",
+      description: "Left-to-right composition. Each step receives the previous result as its first arg.",
+      module: "composition"
+    },
+    "behavior/wire": {
+      category: "std-composition",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Apply cross-orbital event wiring. Adds external emits/listens to inline traits.",
+      module: "composition"
+    },
+    "browser/clipboard-read": {
+      category: "std-browser",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "string",
+      description: "Read text from the system clipboard (navigator.clipboard.readText / host clipboard). Requires a user gesture and clipboard permission. Resolves with the clipboard text via the trailing { emit } envelope.",
+      module: "browser",
+      hasSideEffects: true,
+      effect: {
+        kind: "custom",
+        produces: "string"
+      }
+    },
+    "browser/clipboard-write": {
+      category: "std-browser",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Write text to the system clipboard (navigator.clipboard.writeText / host clipboard). Requires a user gesture. Emits success/failure via the trailing { emit } envelope.",
+      module: "browser",
+      hasSideEffects: true,
+      effect: {
+        kind: "custom",
+        produces: "string"
+      }
+    },
+    "browser/geolocation-current": {
+      category: "std-browser",
+      minArity: 0,
+      maxArity: 1,
+      returnType: "object",
+      description: "Read the current device position (navigator.geolocation.getCurrentPosition / host geolocation). Requires location permission. Resolves with { latitude, longitude, accuracy } via the trailing { emit } envelope.",
+      module: "browser",
+      hasSideEffects: true,
+      effect: {
+        kind: "custom",
+        produces: {
+          kind: "object",
+          fields: {
+            latitude: "number",
+            longitude: "number",
+            accuracy: "number"
+          }
+        }
+      }
+    },
+    "browser/open-file-picker": {
+      category: "std-browser",
+      minArity: 0,
+      maxArity: 1,
+      returnType: "array",
+      description: "Open the OS file picker (window.showOpenFilePicker / host dialog). Resolves with the selected file metadata list, or emits failure when the user cancels or the capability is denied. Async; use the trailing { emit } envelope for success/failure events.",
+      module: "browser",
+      hasSideEffects: true,
+      effect: {
+        kind: "custom",
+        produces: {
+          kind: "array",
+          of: {
+            kind: "object",
+            fields: {
+              name: "string",
+              size: "number",
+              type: "string",
+              lastModified: "number"
+            }
+          }
+        }
+      }
+    },
+    "call-service": {
+      category: "effect",
+      minArity: 2,
+      maxArity: 4,
+      returnType: "void",
+      description: "Invoke an external service action. Optional trailing { emit: { success, failure } } options object attaches closed-circuit emit routing (V2 frame contract).",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "call-service",
+        produces: "any"
+      }
+    },
+    "checkpoint/load": {
+      category: "ml-effect",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "object",
+      description: "Load a model checkpoint (ML effect)",
+      module: "train"
+    },
+    "checkpoint/save": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Save a model checkpoint (ML effect)",
+      module: "train",
+      hasSideEffects: true
+    },
+    "compose/compose-all": {
+      category: "std-behavior",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "ComposeAllResult",
+      description: "Compose all orbitals in the workspace into a single schema. Backed by composeBehaviors.",
+      module: "behavior",
+      hasSideEffects: true
+    },
+    "compose/compose-children": {
+      category: "std-behavior",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "ComposeChildrenResult",
+      description: "Compose child orbitals under a parent for recursive builds.",
+      module: "behavior",
+      hasSideEffects: true
+    },
+    "contract/clamp-output": {
+      category: "ml-contract",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Clamp output tensor to contract ranges",
+      module: "contract"
+    },
+    "contract/entity-to-tensor": {
+      category: "ml-contract",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Convert entity fields to tensor via contract",
+      module: "contract"
+    },
+    "contract/tensor-to-payload": {
+      category: "ml-contract",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "object",
+      description: "Convert output tensor to event payload via contract",
+      module: "contract"
+    },
+    "contract/validate-input": {
+      category: "ml-contract",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Validate tensor against input contract",
+      module: "contract"
+    },
+    "contract/validate-output": {
+      category: "ml-contract",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Validate tensor against output contract",
+      module: "contract"
+    },
+    "contract/violations": {
+      category: "ml-contract",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "List contract violations",
+      module: "contract"
+    },
+    "data/augment": {
+      category: "ml-data",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "object",
+      description: "Apply data augmentation",
+      module: "data"
+    },
+    "data/dataloader": {
+      category: "ml-data",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "object",
+      description: "Create batched dataloader from dataset",
+      module: "data"
+    },
+    "data/dataset": {
+      category: "ml-data",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "object",
+      description: "Create dataset from entity collection and contracts",
+      module: "data"
+    },
+    "data/normalize": {
+      category: "ml-data",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Normalize features (mean/std or min/max)",
+      module: "data"
+    },
+    "data/pad": {
+      category: "ml-data",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Pad sequences to uniform length",
+      module: "data"
+    },
+    "data/split": {
+      category: "ml-data",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Train/val/test split",
+      module: "data"
+    },
+    "data/tokenize": {
+      category: "ml-data",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Tokenize text fields",
+      module: "data"
+    },
+    despawn: {
+      category: "effect",
+      minArity: 0,
+      maxArity: 1,
+      returnType: "void",
+      description: "Despawn an entity instance (games)",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "despawn"
+      }
+    },
+    do: {
+      category: "control",
+      minArity: 1,
+      maxArity: null,
+      returnType: "any",
+      description: "Sequential execution of multiple effects/expressions",
+      module: "core"
+    },
+    "ease/apply": {
+      category: "std-ease",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Apply an easing curve to t\u2208[0,1]: linear, in-quad, out-quad, in-out-quad, in-cubic, out-cubic, in-out-cubic, elastic-out, bounce-out (unknown \u2192 linear)",
+      module: "ease"
+    },
+    "ease/smoothstep": {
+      category: "std-ease",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "number",
+      description: "Smoothstep: clamp((x-edge0)/(edge1-edge0),0,1) then t*t*(3-2*t)",
+      module: "ease"
+    },
+    emit: {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Emit an event onto the bus",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "emit",
+        produces: {
+          kind: "object",
+          fields: {
+            event: {
+              kind: "eventKey"
+            },
+            payload: "any"
+          },
+          open: true
+        }
+      }
+    },
+    evaluate: {
+      category: "ml-effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "object",
+      description: "Evaluate a model against test cases (ML effect)",
+      module: "train"
+    },
+    fetch: {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Fetch an entity (by id) or a collection (by filter) from persistence",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "fetch",
+        produces: {
+          kind: "union",
+          of: [
+            {
+              kind: "entity"
+            },
+            {
+              kind: "array",
+              of: {
+                kind: "entity"
+              }
+            }
+          ]
+        }
+      }
+    },
+    "fetch-stream": {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Stream an LLM or HTTP response, emitting on_message per chunk, success on completion, failure on error",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "fetch-stream",
+        produces: {
+          kind: "entity"
+        }
+      }
+    },
+    fn: {
+      category: "control",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "function",
+      description: "Lambda expression (used for per-item renders and transforms)",
+      module: "core"
+    },
+    "format/bytes": {
+      category: "std-format",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Format bytes as human-readable size",
+      module: "format"
+    },
+    "format/creditCard": {
+      category: "std-format",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Format credit card with masked digits",
+      module: "format"
+    },
+    "format/currency": {
+      category: "std-format",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "string",
+      description: "Format as currency",
+      module: "format"
+    },
+    "format/list": {
+      category: "std-format",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "string",
+      description: "Format array as natural language list",
+      module: "format"
+    },
+    "format/number": {
+      category: "std-format",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "string",
+      description: "Format number with locale-aware separators",
+      module: "format"
+    },
+    "format/ordinal": {
+      category: "std-format",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Format number as ordinal (1st, 2nd, 3rd)",
+      module: "format"
+    },
+    "format/percent": {
+      category: "std-format",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "string",
+      description: "Format as percentage",
+      module: "format"
+    },
+    "format/phone": {
+      category: "std-format",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "string",
+      description: "Format phone number",
+      module: "format"
+    },
+    "format/plural": {
+      category: "std-format",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "string",
+      description: "Format count with singular/plural word",
+      module: "format"
+    },
+    forward: {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Run a forward pass through a model (ML effect)",
+      module: "nn"
+    },
+    "geo/aabb-overlap": {
+      category: "std-geo",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Axis-aligned bounding box overlap test",
+      module: "geo"
+    },
+    "geo/circle-overlap": {
+      category: "std-geo",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Circle overlap test: distance(centers) <= a.r+b.r",
+      module: "geo"
+    },
+    "geo/point-in-circle": {
+      category: "std-geo",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Point containment in circle (inclusive)",
+      module: "geo"
+    },
+    "geo/point-in-rect": {
+      category: "std-geo",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Point containment in rect (inclusive bounds)",
+      module: "geo"
+    },
+    "geo/rect-circle-overlap": {
+      category: "std-geo",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Rect-circle overlap via closest point on rect to circle center",
+      module: "geo"
+    },
+    "geo/reflect": {
+      category: "std-geo",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "vector",
+      description: "Reflect vector v across normal n (assumed normalized)",
+      module: "geo"
+    },
+    "geo/segment-intersect": {
+      category: "std-geo",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "point | null",
+      description: "Intersection point of two segments, or null when parallel/none",
+      module: "geo"
+    },
+    "graph/add-self-loops": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "graph",
+      description: "Add self-loop edges to graph",
+      module: "graph"
+    },
+    "graph/batch": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "graph",
+      description: "Batch multiple graphs into one",
+      module: "graph"
+    },
+    "graph/degree": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Get node degree tensor",
+      module: "graph"
+    },
+    "graph/edge-features": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Get edge feature matrix",
+      module: "graph"
+    },
+    "graph/edge-index": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Get edge index tensor",
+      module: "graph"
+    },
+    "graph/from-adjacency": {
+      category: "ml-graph",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "graph",
+      description: "Build graph from adjacency matrix and features",
+      module: "graph"
+    },
+    "graph/from-edge-list": {
+      category: "ml-graph",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "graph",
+      description: "Build graph from edge list and features",
+      module: "graph"
+    },
+    "graph/from-entities": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "graph",
+      description: "Build PyG graph from entity collections",
+      module: "graph"
+    },
+    "graph/k-hop": {
+      category: "ml-graph",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "graph",
+      description: "K-hop neighborhood subgraph",
+      module: "graph"
+    },
+    "graph/node-features": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Get node feature matrix",
+      module: "graph"
+    },
+    "graph/num-edges": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get edge count",
+      module: "graph"
+    },
+    "graph/num-nodes": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get node count",
+      module: "graph"
+    },
+    "graph/subgraph": {
+      category: "ml-graph",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "graph",
+      description: "Extract subgraph by node mask",
+      module: "graph"
+    },
+    "graph/to-undirected": {
+      category: "ml-graph",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "graph",
+      description: "Convert directed graph to undirected",
+      module: "graph"
+    },
+    "grid/cells-in-radius": {
+      category: "std-grid",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "All cells within Euclidean radius r (row-major order)",
+      module: "grid"
+    },
+    "grid/distance": {
+      category: "std-grid",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Chebyshev distance max(|dx|,|dy|)",
+      module: "grid"
+    },
+    "grid/from-world": {
+      category: "std-grid",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "cell",
+      description: "World point to grid cell (floor)",
+      module: "grid"
+    },
+    "grid/in-bounds": {
+      category: "std-grid",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "boolean",
+      description: "Whether cell lies within a w\xD7h grid",
+      module: "grid"
+    },
+    "grid/iso-to-screen": {
+      category: "std-grid",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "point",
+      description: "Isometric cell to screen point",
+      module: "grid"
+    },
+    "grid/line": {
+      category: "std-grid",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Bresenham line cells from a to b, inclusive, in step order",
+      module: "grid"
+    },
+    "grid/manhattan-distance": {
+      category: "std-grid",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Manhattan distance |dx|+|dy|",
+      module: "grid"
+    },
+    "grid/neighbors": {
+      category: "std-grid",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "array",
+      description: "Adjacent cells in order N,E,S,W (+NE,SE,SW,NW if diagonal)",
+      module: "grid"
+    },
+    "grid/screen-to-iso": {
+      category: "std-grid",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "point",
+      description: "Screen point to isometric cell coordinates",
+      module: "grid"
+    },
+    "grid/to-world": {
+      category: "std-grid",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "point",
+      description: "Cell to world-space center point",
+      module: "grid"
+    },
+    if: {
+      category: "logic",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "any",
+      description: "Conditional expression (ternary). Return type is union of branch types.",
+      module: "core",
+      returnSemantics: "branch-union"
+    },
+    "integration/github-create-issue": {
+      category: "std-integration",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "object",
+      description: "Create a GitHub issue. Typed wrapper for the GitHub API.",
+      module: "integration",
+      hasSideEffects: true
+    },
+    "integration/github-get-repo": {
+      category: "std-integration",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "object",
+      description: "Get a GitHub repository. Typed wrapper for the GitHub API.",
+      module: "integration",
+      hasSideEffects: true
+    },
+    "integration/http": {
+      category: "std-integration",
+      minArity: 3,
+      maxArity: 4,
+      returnType: "object",
+      description: "HTTP request with caller-declared response schema. Validates the response against the schema before returning.",
+      module: "integration",
+      hasSideEffects: true
+    },
+    let: {
+      category: "control",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Bind local variables for a body expression",
+      module: "core"
+    },
+    list: {
+      category: "control",
+      minArity: 0,
+      maxArity: null,
+      returnType: "array",
+      description: "Literal array constructor \u2014 evaluates each argument and returns them as an array. Lowering wraps a literal list bound for a literal-array slot in `list` so it is unambiguously data, never a call (disambiguates a list whose first element collides with an operator name, e.g. [path method \u2026]).",
+      module: "core"
+    },
+    "llm/call-tools": {
+      category: "std-llm",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "LlmCallToolsResult",
+      description: "Call the LLM with tool definitions. Returns the assistant response with optional tool calls and token usage.",
+      module: "llm",
+      hasSideEffects: true
+    },
+    "llm/compact": {
+      category: "std-llm",
+      minArity: 0,
+      maxArity: 1,
+      returnType: "object",
+      description: "Compact the context window. Returns before/after token counts.",
+      module: "llm",
+      hasSideEffects: true
+    },
+    "llm/embed": {
+      category: "std-llm",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Generate embeddings for an array of texts. Returns a 2D array of floats.",
+      module: "llm",
+      hasSideEffects: true
+    },
+    "llm/generate": {
+      category: "std-llm",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "string",
+      description: "Generate text from an LLM. Returns the generated string.",
+      module: "llm",
+      hasSideEffects: true
+    },
+    "llm/switch": {
+      category: "std-llm",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Switch the active LLM provider and optionally the model.",
+      module: "llm",
+      hasSideEffects: true
+    },
+    "llm/token-count": {
+      category: "std-llm",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "number",
+      description: "Get the current token count in the context window.",
+      module: "llm"
+    },
+    log: {
+      category: "effect",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Emit a structured info log line (compiled + runtime)",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "log"
+      }
+    },
+    "lolo/emit-body": {
+      category: "std-behavior",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "LoloEmitResult",
+      description: "Emit a .lolo orbital body from the LLM (free-lolo path). Returns the emitted lolo source.",
+      module: "behavior",
+      hasSideEffects: true
+    },
+    "math/abs": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Absolute value",
+      module: "math"
+    },
+    "math/acos": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Arccosine (inverse cosine) in radians",
+      module: "math"
+    },
+    "math/approach": {
+      category: "std-math",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "number",
+      description: "Move cur toward target by at most maxDelta",
+      module: "math"
+    },
+    "math/asin": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Arcsine (inverse sine) in radians",
+      module: "math"
+    },
+    "math/atan": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Arctangent (inverse tangent) in radians",
+      module: "math"
+    },
+    "math/atan2": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Angle in radians from the positive x-axis to point (x, y)",
+      module: "math"
+    },
+    "math/ceil": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Round up to integer",
+      module: "math"
+    },
+    "math/clamp": {
+      category: "std-math",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "number",
+      description: "Constrain value to range [min, max]",
+      module: "math"
+    },
+    "math/cos": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Cosine of an angle in radians",
+      module: "math"
+    },
+    "math/default": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Return default if value is null, undefined, or NaN",
+      module: "math"
+    },
+    "math/deg-rad": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Convert degrees to radians",
+      module: "math"
+    },
+    "math/floor": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Round down to integer",
+      module: "math"
+    },
+    "math/hypot": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Euclidean length sqrt(a\xB2+b\xB2)",
+      module: "math"
+    },
+    "math/lerp": {
+      category: "std-math",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "number",
+      description: "Linear interpolation between a and b by factor t",
+      module: "math"
+    },
+    "math/map": {
+      category: "std-math",
+      minArity: 5,
+      maxArity: 5,
+      returnType: "number",
+      description: "Map value from one range to another",
+      module: "math"
+    },
+    "math/max": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: null,
+      returnType: "number",
+      description: "Maximum of values",
+      module: "math"
+    },
+    "math/min": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: null,
+      returnType: "number",
+      description: "Minimum of values",
+      module: "math"
+    },
+    "math/mod": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Modulo (remainder)",
+      module: "math"
+    },
+    "math/pow": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Exponentiation (base^exp)",
+      module: "math"
+    },
+    "math/rad-deg": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Convert radians to degrees",
+      module: "math"
+    },
+    "math/random": {
+      category: "std-math",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "number",
+      description: "Random number between 0 (inclusive) and 1 (exclusive)",
+      module: "math"
+    },
+    "math/randomInt": {
+      category: "std-math",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Random integer in range [min, max] (inclusive)",
+      module: "math"
+    },
+    "math/round": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Round to nearest integer or specified decimals",
+      module: "math"
+    },
+    "math/sign": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Returns -1, 0, or 1 indicating sign",
+      module: "math"
+    },
+    "math/sin": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Sine of an angle in radians",
+      module: "math"
+    },
+    "math/sqrt": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Square root",
+      module: "math"
+    },
+    "math/tan": {
+      category: "std-math",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Tangent of an angle in radians",
+      module: "math"
+    },
+    "math/wrap": {
+      category: "std-math",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "number",
+      description: "Wrap a value into the half-open range [min, max)",
+      module: "math"
+    },
+    "memory/list": {
+      category: "std-memory",
+      minArity: 0,
+      maxArity: 1,
+      returnType: "array",
+      description: "List all memories, optionally filtered by category.",
+      module: "memory"
+    },
+    "memory/recall": {
+      category: "std-memory",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "array",
+      description: "Search memories by semantic query. Returns matching memory records.",
+      module: "memory"
+    },
+    "memory/store": {
+      category: "std-memory",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "string",
+      description: "Store a new memory. Returns the new memory ID.",
+      module: "memory",
+      hasSideEffects: true
+    },
+    navigate: {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Navigate to a route",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "navigate"
+      }
+    },
+    "nn/batchnorm": {
+      category: "ml-arch",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "nn/layer",
+      description: "Batch normalization layer",
+      module: "nn"
+    },
+    "nn/clone": {
+      category: "ml-arch",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "nn/module",
+      description: "Create a deep copy of the network with same weights",
+      module: "nn"
+    },
+    "nn/dropout": {
+      category: "ml-arch",
+      minArity: 0,
+      maxArity: 1,
+      returnType: "nn/layer",
+      description: "Dropout layer for regularization (randomly zeros elements during training)",
+      module: "nn"
+    },
+    "nn/forward": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Execute forward pass through network",
+      module: "nn"
+    },
+    "nn/getWeights": {
+      category: "ml-arch",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Get network weights as a flat tensor",
+      module: "nn"
+    },
+    "nn/layernorm": {
+      category: "ml-arch",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "nn/layer",
+      description: "Layer normalization",
+      module: "nn"
+    },
+    "nn/linear": {
+      category: "ml-arch",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "nn/layer",
+      description: "Fully connected linear layer (output = input * weights + bias)",
+      module: "nn"
+    },
+    "nn/paramCount": {
+      category: "ml-arch",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get total number of trainable parameters",
+      module: "nn"
+    },
+    "nn/relu": {
+      category: "ml-arch",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "nn/layer",
+      description: "ReLU activation function: max(0, x)",
+      module: "nn"
+    },
+    "nn/sequential": {
+      category: "ml-arch",
+      minArity: 1,
+      maxArity: null,
+      returnType: "nn/module",
+      description: "Create a sequential neural network from layers",
+      module: "nn"
+    },
+    "nn/setWeights": {
+      category: "ml-arch",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "nn/module",
+      description: "Set network weights from a flat tensor",
+      module: "nn",
+      hasSideEffects: true
+    },
+    "nn/sigmoid": {
+      category: "ml-arch",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "nn/layer",
+      description: "Sigmoid activation function: 1 / (1 + e^-x)",
+      module: "nn"
+    },
+    "nn/softmax": {
+      category: "ml-arch",
+      minArity: 0,
+      maxArity: 1,
+      returnType: "nn/layer",
+      description: "Softmax activation function (normalizes to probability distribution)",
+      module: "nn"
+    },
+    "nn/tanh": {
+      category: "ml-arch",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "nn/layer",
+      description: "Tanh activation function: (e^x - e^-x) / (e^x + e^-x)",
+      module: "nn"
+    },
+    "noise/fbm": {
+      category: "std-noise",
+      minArity: 3,
+      maxArity: 4,
+      returnType: "number",
+      description: "Fractal Brownian motion: summed perlin octaves (clamped 1..8); output [-1,1]",
+      module: "noise"
+    },
+    "noise/perlin": {
+      category: "std-noise",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "number",
+      description: "2D Perlin noise at (x,y) with optional seed; output [-1,1]",
+      module: "noise"
+    },
+    "noise/simplex": {
+      category: "std-noise",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "number",
+      description: "Value-coherent noise (perlin-derived) at (x,y) with optional seed; output [-1,1]",
+      module: "noise"
+    },
+    not: {
+      category: "logic",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Logical NOT",
+      module: "core"
+    },
+    notify: {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Show a notification (in-app, email, push, sms)",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "notify"
+      }
+    },
+    "object/clone": {
+      category: "std-object",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "any",
+      description: "Shallow clone object",
+      module: "object"
+    },
+    "object/deepClone": {
+      category: "std-object",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "any",
+      description: "Deep clone object",
+      module: "object"
+    },
+    "object/deepMerge": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: null,
+      returnType: "any",
+      description: "Deep merge objects (later wins)",
+      module: "object"
+    },
+    "object/empty?": {
+      category: "std-object",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if object has no keys",
+      module: "object"
+    },
+    "object/entries": {
+      category: "std-object",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Get [key, value] pairs as array",
+      module: "object"
+    },
+    "object/equals": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Deep equality check",
+      module: "object"
+    },
+    "object/filter": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Filter entries by predicate",
+      module: "object"
+    },
+    "object/fromEntries": {
+      category: "std-object",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "any",
+      description: "Create object from [key, value] pairs",
+      module: "object"
+    },
+    "object/get": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "any",
+      description: "Get nested value by path (return type derived from input object shape and key)",
+      module: "object",
+      returnSemantics: "object-key-lookup"
+    },
+    "object/has": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if path exists",
+      module: "object"
+    },
+    "object/keys": {
+      category: "std-object",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Get object keys as array",
+      module: "object"
+    },
+    "object/mapKeys": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Transform all keys",
+      module: "object"
+    },
+    "object/mapValues": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Transform all values",
+      module: "object"
+    },
+    "object/merge": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: null,
+      returnType: "any",
+      description: "Shallow merge objects (later wins)",
+      module: "object"
+    },
+    "object/omit": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Exclude specified keys",
+      module: "object"
+    },
+    "object/pick": {
+      category: "std-object",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Select only specified keys (return type is subset of input object shape)",
+      module: "object",
+      returnSemantics: "object-key-lookup"
+    },
+    "object/set": {
+      category: "std-object",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "any",
+      description: "Set nested value by path (returns new object)",
+      module: "object"
+    },
+    "object/values": {
+      category: "std-object",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Get object values as array",
+      module: "object"
+    },
+    or: {
+      category: "logic",
+      minArity: 2,
+      maxArity: null,
+      returnType: "boolean",
+      description: "Logical OR (returns the first truthy value, NOT a boolean \u2014 short-circuit)",
+      module: "core",
+      returnSemantics: "first-truthy-of-args"
+    },
+    "os/debounce": {
+      category: "std-os",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Configure debounce interval for an OS event type. Prevents trigger storms during rapid changes.",
+      module: "os",
+      hasSideEffects: true
+    },
+    "os/watch-cron": {
+      category: "std-os",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Register cron schedule. Emits OS_CRON_FIRE events with { expression, timestamp } payload.",
+      module: "os",
+      hasSideEffects: true
+    },
+    "os/watch-env": {
+      category: "std-os",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Register environment variable watcher. Emits OS_ENV_CHANGED events with { variable, oldValue, newValue } payload.",
+      module: "os",
+      hasSideEffects: true
+    },
+    "os/watch-files": {
+      category: "std-os",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Register file system watcher. Emits OS_FILE_MODIFIED, OS_FILE_CREATED, OS_FILE_DELETED events with { path, name, dir, timestamp } payload.",
+      module: "os",
+      hasSideEffects: true
+    },
+    "os/watch-http": {
+      category: "std-os",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Register HTTP response interceptor. Emits OS_HTTP_RESPONSE events with { url, method, status, headers, body, duration } payload.",
+      module: "os",
+      hasSideEffects: true
+    },
+    "os/watch-port": {
+      category: "std-os",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Register port monitor. Emits OS_PORT_OPENED, OS_PORT_CLOSED events with { port, protocol, pid, address } payload.",
+      module: "os",
+      hasSideEffects: true
+    },
+    "os/watch-process": {
+      category: "std-os",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Register process monitor. Emits OS_PROCESS_EXITED, OS_PROCESS_STARTED events with { pid, name, exitCode, signal, args, duration } payload.",
+      module: "os",
+      hasSideEffects: true
+    },
+    "os/watch-signal": {
+      category: "std-os",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Register OS signal handler. Emits OS_SIGNAL_USR1, OS_SIGNAL_HUP, etc. with { pid, timestamp } payload.",
+      module: "os",
+      hasSideEffects: true
+    },
+    path: {
+      category: "std-object",
+      minArity: 1,
+      maxArity: null,
+      returnType: "string",
+      description: "Build a dot-separated path string from segments. Used with set effect for dynamic field paths.",
+      module: "object"
+    },
+    "path/astar": {
+      category: "std-path",
+      minArity: 5,
+      maxArity: 6,
+      returnType: "array",
+      description: "A* shortest path on a w\xD7h grid; returns cells start\u2192goal (incl. both) or [] if none",
+      module: "path"
+    },
+    "path/reachable": {
+      category: "std-path",
+      minArity: 5,
+      maxArity: 6,
+      returnType: "array",
+      description: "BFS cells reachable within N moves from start (incl. start); sorted row-major",
+      module: "path"
+    },
+    persist: {
+      category: "effect",
+      minArity: 2,
+      maxArity: 4,
+      returnType: "void",
+      description: "Create, update, delete, clear, or batch entity records. Optional trailing { emit: { success, failure } } options object attaches closed-circuit emit routing.",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "persist",
+        produces: {
+          kind: "union",
+          of: [
+            {
+              kind: "entity"
+            },
+            {
+              kind: "object",
+              fields: {
+                id: "string",
+                deleted: "boolean"
+              },
+              open: false
+            },
+            {
+              kind: "object",
+              fields: {
+                operations: {
+                  kind: "array",
+                  of: "any"
+                },
+                completedCount: "number",
+                totalCount: "number"
+              },
+              open: false
+            }
+          ]
+        }
+      }
+    },
+    "prob/beta": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Sample from a Beta(alpha, beta) distribution",
+      module: "prob"
+    },
+    "prob/categorical": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Weighted random selection from items",
+      module: "prob"
+    },
+    "prob/condition": {
+      category: "std-prob",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Mark current sample as rejected if predicate is false",
+      module: "prob",
+      hasSideEffects: true
+    },
+    "prob/credible-interval": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Compute symmetric credible interval from samples",
+      module: "prob"
+    },
+    "prob/expected-value": {
+      category: "std-prob",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Mean of numeric samples",
+      module: "prob"
+    },
+    "prob/flip": {
+      category: "std-prob",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Bernoulli trial: returns true with probability p",
+      module: "prob"
+    },
+    "prob/gaussian": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Sample from a Gaussian (normal) distribution",
+      module: "prob"
+    },
+    "prob/histogram": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "object",
+      description: "Bin numeric samples into a histogram",
+      module: "prob"
+    },
+    "prob/infer": {
+      category: "std-prob",
+      minArity: 4,
+      maxArity: 4,
+      returnType: "object",
+      description: "Like posterior but returns {mean, variance, samples, acceptRate}",
+      module: "prob"
+    },
+    "prob/percentile": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Get the p-th percentile (0-100) from samples",
+      module: "prob"
+    },
+    "prob/poisson": {
+      category: "std-prob",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Sample from a Poisson distribution",
+      module: "prob"
+    },
+    "prob/posterior": {
+      category: "std-prob",
+      minArity: 4,
+      maxArity: 4,
+      returnType: "array",
+      description: "Rejection sampling: returns accepted query values",
+      module: "prob"
+    },
+    "prob/sample": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Evaluate an expression n times and collect results",
+      module: "prob"
+    },
+    "prob/seed": {
+      category: "std-prob",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Set seeded PRNG for deterministic probabilistic sampling",
+      module: "prob",
+      hasSideEffects: true
+    },
+    "prob/uniform": {
+      category: "std-prob",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Sample from a uniform distribution [lo, hi)",
+      module: "prob"
+    },
+    "prob/variance": {
+      category: "std-prob",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Population variance of numeric samples",
+      module: "prob"
+    },
+    ref: {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Reactive entity reference (deprecated, use fetch with listens in V2)",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "ref",
+        produces: {
+          kind: "union",
+          of: [
+            {
+              kind: "entity"
+            },
+            {
+              kind: "array",
+              of: {
+                kind: "entity"
+              }
+            }
+          ]
+        }
+      }
+    },
+    "render-ui": {
+      category: "effect",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "void",
+      description: "Render a pattern into a UI slot",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "render-ui"
+      }
+    },
+    "send-server": {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Send an orbital event to the server over WebSocket (client-side; chat/real-time trigger)",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "send-server"
+      }
+    },
+    "session/append-history": {
+      category: "std-session",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Append an entry to the per-orbital conversation history.",
+      module: "session",
+      hasSideEffects: true
+    },
+    "session/read-analysis": {
+      category: "std-session",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "object",
+      description: "Read the pre-computed analysis result.",
+      module: "session"
+    },
+    "session/read-errors": {
+      category: "std-session",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Read validation errors for an orbital.",
+      module: "session"
+    },
+    "session/read-history": {
+      category: "std-session",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Read the per-orbital conversation history.",
+      module: "session"
+    },
+    "session/read-memory": {
+      category: "std-session",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "object",
+      description: "Read the per-orbital memory from the session store.",
+      module: "session"
+    },
+    "session/read-spec": {
+      category: "std-session",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "object",
+      description: "Read the per-orbital spec.json from the session store.",
+      module: "session"
+    },
+    "session/write-errors": {
+      category: "std-session",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Write validation errors for an orbital.",
+      module: "session",
+      hasSideEffects: true
+    },
+    "session/write-memory": {
+      category: "std-session",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Write per-orbital memory to the session store.",
+      module: "session",
+      hasSideEffects: true
+    },
+    "session/write-spec": {
+      category: "std-session",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Write the per-orbital spec.json to the session store.",
+      module: "session",
+      hasSideEffects: true
+    },
+    set: {
+      category: "effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Set a binding to a value",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "set",
+        produces: "any",
+        config: {
+          operation: {
+            kind: "union",
+            of: [
+              {
+                kind: "literal",
+                value: "increment"
+              },
+              {
+                kind: "literal",
+                value: "decrement"
+              },
+              {
+                kind: "literal",
+                value: "multiply"
+              },
+              {
+                kind: "literal",
+                value: "append"
+              },
+              {
+                kind: "literal",
+                value: "remove"
+              }
+            ]
+          }
+        }
+      }
+    },
+    spawn: {
+      category: "effect",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Spawn a new entity instance (games)",
+      module: "core",
+      hasSideEffects: true,
+      effect: {
+        kind: "spawn"
+      }
+    },
+    "str/camelCase": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Convert to camelCase",
+      module: "str"
+    },
+    "str/capitalize": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Capitalize first character",
+      module: "str"
+    },
+    "str/concat": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 99,
+      returnType: "string",
+      description: "Concatenate strings together",
+      module: "str"
+    },
+    "str/default": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "string",
+      description: "Return default if value is null/undefined/empty",
+      module: "str"
+    },
+    "str/endsWith": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if string ends with suffix",
+      module: "str"
+    },
+    "str/includes": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if string contains substring",
+      module: "str"
+    },
+    "str/join": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "string",
+      description: "Join array elements into string",
+      module: "str"
+    },
+    "str/kebabCase": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Convert to kebab-case",
+      module: "str"
+    },
+    "str/len": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "String length",
+      module: "str"
+    },
+    "str/lower": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Convert to lowercase",
+      module: "str"
+    },
+    "str/padEnd": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "string",
+      description: "Pad string from end to target length",
+      module: "str"
+    },
+    "str/padStart": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "string",
+      description: "Pad string from start to target length",
+      module: "str"
+    },
+    "str/repeat": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "string",
+      description: "Repeat string n times",
+      module: "str"
+    },
+    "str/replace": {
+      category: "std-str",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "string",
+      description: "Replace first occurrence",
+      module: "str"
+    },
+    "str/replaceAll": {
+      category: "std-str",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "string",
+      description: "Replace all occurrences",
+      module: "str"
+    },
+    "str/reverse": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Reverse string",
+      module: "str"
+    },
+    "str/slice": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "string",
+      description: "Extract substring",
+      module: "str"
+    },
+    "str/snakeCase": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Convert to snake_case",
+      module: "str"
+    },
+    "str/split": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Split string into array by delimiter",
+      module: "str"
+    },
+    "str/startsWith": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if string starts with prefix",
+      module: "str"
+    },
+    "str/template": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "string",
+      description: "Variable substitution in template string",
+      module: "str"
+    },
+    "str/titleCase": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Convert to Title Case",
+      module: "str"
+    },
+    "str/trim": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Remove leading and trailing whitespace",
+      module: "str"
+    },
+    "str/trimEnd": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Remove trailing whitespace",
+      module: "str"
+    },
+    "str/trimStart": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Remove leading whitespace",
+      module: "str"
+    },
+    "str/truncate": {
+      category: "std-str",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "string",
+      description: "Truncate string with optional suffix",
+      module: "str"
+    },
+    "str/upper": {
+      category: "std-str",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Convert to uppercase",
+      module: "str"
+    },
+    "tensor/add": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Element-wise addition",
+      module: "tensor"
+    },
+    "tensor/allInRange": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if all elements are within range [min, max]",
+      module: "tensor"
+    },
+    "tensor/argmax": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number | tensor",
+      description: "Index of maximum value",
+      module: "tensor"
+    },
+    "tensor/cat": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Concatenate two tensors along the last dimension",
+      module: "tensor"
+    },
+    "tensor/clamp": {
+      category: "ml-tensor",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "tensor",
+      description: "Clamp all elements to range [min, max]",
+      module: "tensor"
+    },
+    "tensor/clampPerDim": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Clamp each dimension to its specified range",
+      module: "tensor"
+    },
+    "tensor/div": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Element-wise division",
+      module: "tensor"
+    },
+    "tensor/dot": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Dot product of two 1D tensors",
+      module: "tensor"
+    },
+    "tensor/flatten": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Flatten tensor to 1D",
+      module: "tensor"
+    },
+    "tensor/from": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Create tensor from array",
+      module: "tensor"
+    },
+    "tensor/get": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Get element at index",
+      module: "tensor"
+    },
+    "tensor/matmul": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Matrix multiplication",
+      module: "tensor"
+    },
+    "tensor/max": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number | tensor",
+      description: "Maximum value in tensor",
+      module: "tensor"
+    },
+    "tensor/mean": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number | tensor",
+      description: "Mean of tensor elements",
+      module: "tensor"
+    },
+    "tensor/min": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number | tensor",
+      description: "Minimum value in tensor",
+      module: "tensor"
+    },
+    "tensor/mul": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Element-wise multiplication",
+      module: "tensor"
+    },
+    "tensor/norm": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "L2 norm of tensor",
+      module: "tensor"
+    },
+    "tensor/ones": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Create tensor filled with ones",
+      module: "tensor"
+    },
+    "tensor/outOfRangeDims": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Get dimensions that exceed their specified ranges",
+      module: "tensor"
+    },
+    "tensor/outOfRangeIndices": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number[]",
+      description: "Get indices of elements outside range",
+      module: "tensor"
+    },
+    "tensor/rand": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Create tensor with random values in [0, 1)",
+      module: "tensor"
+    },
+    "tensor/randn": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Create tensor with random values from standard normal distribution",
+      module: "tensor"
+    },
+    "tensor/reshape": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Reshape tensor to new shape (total elements must match)",
+      module: "tensor"
+    },
+    "tensor/shape": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number[]",
+      description: "Get tensor shape as array",
+      module: "tensor"
+    },
+    "tensor/slice": {
+      category: "ml-tensor",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "tensor",
+      description: "Get slice of tensor",
+      module: "tensor"
+    },
+    "tensor/squeeze": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Remove all dimensions of size one",
+      module: "tensor"
+    },
+    "tensor/stack": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Stack two tensors along a new leading dimension",
+      module: "tensor"
+    },
+    "tensor/sub": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Element-wise subtraction",
+      module: "tensor"
+    },
+    "tensor/sum": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number | tensor",
+      description: "Sum of tensor elements",
+      module: "tensor"
+    },
+    "tensor/toArray": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "array",
+      description: "Convert tensor to nested array",
+      module: "tensor"
+    },
+    "tensor/toList": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number[]",
+      description: "Convert 1D tensor to flat array",
+      module: "tensor"
+    },
+    "tensor/transpose": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 3,
+      returnType: "tensor",
+      description: "Transpose a tensor (optionally swapping two named dimensions)",
+      module: "tensor"
+    },
+    "tensor/unsqueeze": {
+      category: "ml-tensor",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Insert a dimension of size one at the given position",
+      module: "tensor"
+    },
+    "tensor/zeros": {
+      category: "ml-tensor",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "tensor",
+      description: "Create tensor filled with zeros",
+      module: "tensor"
+    },
+    "time/add": {
+      category: "std-time",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "number",
+      description: "Add time to timestamp",
+      module: "time"
+    },
+    "time/day": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get day of month from timestamp (1-31)",
+      module: "time"
+    },
+    "time/diff": {
+      category: "std-time",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "number",
+      description: "Difference between timestamps",
+      module: "time"
+    },
+    "time/duration": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: 'Format milliseconds as duration ("2h 30m")',
+      module: "time"
+    },
+    "time/endOf": {
+      category: "std-time",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Get end of time period",
+      module: "time"
+    },
+    "time/format": {
+      category: "std-time",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "string",
+      description: "Format timestamp to string",
+      module: "time"
+    },
+    "time/hour": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get hour from timestamp (0-23)",
+      module: "time"
+    },
+    "time/isAfter": {
+      category: "std-time",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if a is after b",
+      module: "time"
+    },
+    "time/isBefore": {
+      category: "std-time",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if a is before b",
+      module: "time"
+    },
+    "time/isBetween": {
+      category: "std-time",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "boolean",
+      description: "Check if date is between start and end",
+      module: "time"
+    },
+    "time/isFuture": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if timestamp is in the future",
+      module: "time"
+    },
+    "time/isPast": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if timestamp is in the past",
+      module: "time"
+    },
+    "time/isSame": {
+      category: "std-time",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "boolean",
+      description: "Check if timestamps are same (optionally by unit)",
+      module: "time"
+    },
+    "time/isToday": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if timestamp is today",
+      module: "time"
+    },
+    "time/minute": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get minute from timestamp (0-59)",
+      module: "time"
+    },
+    "time/month": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get month from timestamp (1-12)",
+      module: "time"
+    },
+    "time/now": {
+      category: "std-time",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "number",
+      description: "Current timestamp",
+      module: "time"
+    },
+    "time/parse": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Parse string to timestamp",
+      module: "time"
+    },
+    "time/relative": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: 'Format as relative time ("2 hours ago", "in 3 days")',
+      module: "time"
+    },
+    "time/second": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get second from timestamp (0-59)",
+      module: "time"
+    },
+    "time/startOf": {
+      category: "std-time",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Get start of time period",
+      module: "time"
+    },
+    "time/subtract": {
+      category: "std-time",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "number",
+      description: "Subtract time from timestamp",
+      module: "time"
+    },
+    "time/today": {
+      category: "std-time",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "number",
+      description: "Today at midnight (local time)",
+      module: "time"
+    },
+    "time/weekday": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get day of week (0=Sunday, 6=Saturday)",
+      module: "time"
+    },
+    "time/year": {
+      category: "std-time",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get year from timestamp",
+      module: "time"
+    },
+    "trace/emit": {
+      category: "std-trace",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "void",
+      description: "Emit a structured trace event for observability (115 call sites in rabit today).",
+      module: "trace",
+      hasSideEffects: true
+    },
+    "trace/log": {
+      category: "std-trace",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Log a message at the given level.",
+      module: "trace",
+      hasSideEffects: true
+    },
+    train: {
+      category: "ml-effect",
+      minArity: 1,
+      maxArity: 3,
+      returnType: "object",
+      description: "Train a model over a dataset (ML effect)",
+      module: "train",
+      hasSideEffects: true
+    },
+    "train/adam": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 4,
+      returnType: "void",
+      description: "Adam optimizer step",
+      module: "train",
+      hasSideEffects: true
+    },
+    "train/checkConstraints": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "train/constraintResult",
+      description: "Check if network weights satisfy all constraints",
+      module: "train"
+    },
+    "train/checkForbiddenOutputs": {
+      category: "ml-effect",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "train/forbiddenResult",
+      description: "Check if model produces outputs in forbidden regions",
+      module: "train"
+    },
+    "train/checkRegression": {
+      category: "ml-effect",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "train/regressionResult",
+      description: "Check if new model regresses on required invariants",
+      module: "train"
+    },
+    "train/checkWeightMagnitude": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if all weights are within magnitude limit",
+      module: "train"
+    },
+    "train/clipGradients": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Clip gradients to max norm (modifies in place)",
+      module: "train",
+      hasSideEffects: true
+    },
+    "train/clipWeights": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Clip weights to max magnitude (modifies in place)",
+      module: "train",
+      hasSideEffects: true
+    },
+    "train/computeAdvantages": {
+      category: "ml-effect",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "tensor",
+      description: "Compute GAE advantages for policy gradient",
+      module: "train"
+    },
+    "train/computeReturns": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "tensor",
+      description: "Compute discounted returns from rewards",
+      module: "train"
+    },
+    "train/crossEntropy": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Cross-entropy loss for classification",
+      module: "train"
+    },
+    "train/getGradientNorm": {
+      category: "ml-effect",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get current gradient norm",
+      module: "train"
+    },
+    "train/getMaxWeightMagnitude": {
+      category: "ml-effect",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Get maximum weight magnitude in network",
+      module: "train"
+    },
+    "train/huber": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "number",
+      description: "Huber loss (smooth L1, robust to outliers)",
+      module: "train"
+    },
+    "train/loop": {
+      category: "ml-effect",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "train/result",
+      description: "Execute training loop with constraints",
+      module: "train",
+      hasSideEffects: true
+    },
+    "train/mse": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Mean squared error loss",
+      module: "train"
+    },
+    "train/sampleBatch": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "array",
+      description: "Sample random batch from experience buffer",
+      module: "train"
+    },
+    "train/sgd": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 3,
+      returnType: "void",
+      description: "Stochastic gradient descent optimizer step",
+      module: "train",
+      hasSideEffects: true
+    },
+    "train/step": {
+      category: "ml-effect",
+      minArity: 4,
+      maxArity: 4,
+      returnType: "train/stepResult",
+      description: "Execute single training step (forward, loss, backward, update)",
+      module: "train",
+      hasSideEffects: true
+    },
+    "train/validate": {
+      category: "ml-effect",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "train/validationResult",
+      description: "Validate model on test cases, returns pass/fail metrics",
+      module: "train"
+    },
+    "validate/array": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is an array",
+      module: "validate"
+    },
+    "validate/boolean": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a boolean",
+      module: "validate"
+    },
+    "validate/check": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "any",
+      description: "Run multiple validation rules, return { valid, errors }",
+      module: "validate"
+    },
+    "validate/creditCard": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a valid credit card number (Luhn algorithm)",
+      module: "validate"
+    },
+    "validate/date": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a valid date",
+      module: "validate"
+    },
+    "validate/email": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a valid email format",
+      module: "validate"
+    },
+    "validate/equals": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Deep equality check",
+      module: "validate"
+    },
+    "validate/length": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if string/array has exact length",
+      module: "validate"
+    },
+    "validate/max": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if number is <= maximum",
+      module: "validate"
+    },
+    "validate/maxLength": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if string/array has maximum length",
+      module: "validate"
+    },
+    "validate/min": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if number is >= minimum",
+      module: "validate"
+    },
+    "validate/minLength": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if string/array has minimum length",
+      module: "validate"
+    },
+    "validate/noneOf": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if value is not in list of disallowed values",
+      module: "validate"
+    },
+    "validate/number": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a number",
+      module: "validate"
+    },
+    "validate/object": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is an object",
+      module: "validate"
+    },
+    "validate/oneOf": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if value is in list of allowed values",
+      module: "validate"
+    },
+    "validate/pattern": {
+      category: "std-validate",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "boolean",
+      description: "Check if string matches regex pattern",
+      module: "validate"
+    },
+    "validate/phone": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a valid phone number",
+      module: "validate"
+    },
+    "validate/range": {
+      category: "std-validate",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "boolean",
+      description: "Check if number is within range [min, max]",
+      module: "validate"
+    },
+    "validate/required": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is not null, undefined, or empty string",
+      module: "validate"
+    },
+    "validate/string": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a string",
+      module: "validate"
+    },
+    "validate/url": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a valid URL format",
+      module: "validate"
+    },
+    "validate/uuid": {
+      category: "std-validate",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if value is a valid UUID",
+      module: "validate"
+    },
+    "validate/validate": {
+      category: "std-behavior",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "ValidateResult",
+      description: "Validate an orbital or the composed schema using orb validate.",
+      module: "behavior",
+      hasSideEffects: true
+    },
+    "vec/add": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "vector",
+      description: "Componentwise vector addition a+b",
+      module: "vec"
+    },
+    "vec/angle": {
+      category: "std-vec",
+      minArity: 1,
+      maxArity: 2,
+      returnType: "number",
+      description: "Heading atan2(y,x) (1 arg) or angle between two vectors (2 args), radians",
+      module: "vec"
+    },
+    "vec/clamp-length": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "vector",
+      description: "Clamp magnitude to max (preserves direction)",
+      module: "vec"
+    },
+    "vec/cross": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "vector | number",
+      description: "3D cross product \u2192 vector; 2D \u2192 scalar ax\xB7by-ay\xB7bx",
+      module: "vec"
+    },
+    "vec/distance": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Euclidean distance length(sub(a,b))",
+      module: "vec"
+    },
+    "vec/distance-sq": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Squared distance length-sq(sub(a,b))",
+      module: "vec"
+    },
+    "vec/dot": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "number",
+      description: "Dot product ax\xB7bx+ay\xB7by(+az\xB7bz)",
+      module: "vec"
+    },
+    "vec/length": {
+      category: "std-vec",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Vector magnitude sqrt(dot(a,a))",
+      module: "vec"
+    },
+    "vec/length-sq": {
+      category: "std-vec",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "number",
+      description: "Squared magnitude dot(a,a)",
+      module: "vec"
+    },
+    "vec/lerp": {
+      category: "std-vec",
+      minArity: 3,
+      maxArity: 3,
+      returnType: "vector",
+      description: "Componentwise linear interpolation a+(b-a)*t",
+      module: "vec"
+    },
+    "vec/normalize": {
+      category: "std-vec",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "vector",
+      description: "Unit vector a/len; zero-length \u2192 zero vector (same dim)",
+      module: "vec"
+    },
+    "vec/rotate": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "vector",
+      description: "2D rotate by rad (z preserved): x'=x\xB7cos-y\xB7sin, y'=x\xB7sin+y\xB7cos",
+      module: "vec"
+    },
+    "vec/scale": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "vector",
+      description: "Componentwise scalar multiply a*k",
+      module: "vec"
+    },
+    "vec/sub": {
+      category: "std-vec",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "vector",
+      description: "Componentwise vector subtraction a-b",
+      module: "vec"
+    },
+    when: {
+      category: "control",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Conditional effect without an else branch",
+      module: "core"
+    },
+    "workspace/archive-orbital": {
+      category: "std-workspace",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Archive (remove from active set) an orbital from the workspace.",
+      module: "workspace",
+      hasSideEffects: true
+    },
+    "workspace/exists": {
+      category: "std-workspace",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "boolean",
+      description: "Check if a file exists in the workspace.",
+      module: "workspace"
+    },
+    "workspace/list-orbitals": {
+      category: "std-workspace",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "array",
+      description: "List all orbital names in the workspace.",
+      module: "workspace"
+    },
+    "workspace/read-file": {
+      category: "std-workspace",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "string",
+      description: "Read a file from the workspace.",
+      module: "workspace"
+    },
+    "workspace/read-orbital": {
+      category: "std-workspace",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "object",
+      description: "Read an orbital definition from the workspace by name.",
+      module: "workspace"
+    },
+    "workspace/read-plan": {
+      category: "std-workspace",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "object",
+      description: "Read the plan snapshot from the workspace.",
+      module: "workspace"
+    },
+    "workspace/read-schema": {
+      category: "std-workspace",
+      minArity: 0,
+      maxArity: 0,
+      returnType: "object",
+      description: "Read the composed schema.orb from the workspace.",
+      module: "workspace"
+    },
+    "workspace/write-file": {
+      category: "std-workspace",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Write a file to the workspace.",
+      module: "workspace",
+      hasSideEffects: true
+    },
+    "workspace/write-orbital": {
+      category: "std-workspace",
+      minArity: 2,
+      maxArity: 2,
+      returnType: "void",
+      description: "Write an orbital definition to the workspace.",
+      module: "workspace",
+      hasSideEffects: true
+    },
+    "workspace/write-plan": {
+      category: "std-workspace",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Write the plan snapshot to the workspace.",
+      module: "workspace",
+      hasSideEffects: true
+    },
+    "workspace/write-schema": {
+      category: "std-workspace",
+      minArity: 1,
+      maxArity: 1,
+      returnType: "void",
+      description: "Write the composed schema.orb to the workspace.",
+      module: "workspace",
+      hasSideEffects: true
+    }
+  }
+};
+
+// operator-arity.ts
 var ARITY = new Map(
-  Object.entries(canonicalOperators.operators).map(
+  Object.entries(canonical_operators_default.operators).map(
     ([name, meta]) => [
       name,
       { min: meta.minArity ?? 0, max: meta.maxArity === void 0 ? null : meta.maxArity }