npm - @almadar/evaluator - Versions diffs - 2.41.0 → 2.43.0 - Mend

@almadar/evaluator 2.41.0 → 2.43.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/dist/{index-BIg56YY8.d.ts → index-DY9A18IY.d.ts} +86 -84
package/dist/index.d.ts +41 -11
package/dist/index.js +558 -874
package/dist/index.js.map +1 -1
package/dist/operators/index.d.ts +1 -1
package/dist/operators/index.js +15 -8
package/dist/operators/index.js.map +1 -1
package/package.json +4 -4

package/dist/index.js CHANGED Viewed

@@ -29,11 +29,10 @@ function createChildContext(parent, locals) {
   };
 }
 var CLIENT_ONLY_BINDING_ROOTS = /* @__PURE__ */ new Set(["trait"]);
-function resolveBinding(binding, ctx) {
-  if (!binding.startsWith("@")) {
-    return void 0;
-  }
-  const withoutPrefix = binding.slice(1);
+var PARSED_PATH_CACHE = /* @__PURE__ */ new Map();
+function parseBindingPath(withoutPrefix) {
+  const cached = PARSED_PATH_CACHE.get(withoutPrefix);
+  if (cached) return cached;
   const parts = withoutPrefix.split(".").flatMap((seg) => {
     const m = seg.match(/^([\w]+)((?:\[\d+\])+)$/);
     if (!m) return [seg];
@@ -41,8 +40,15 @@ function resolveBinding(binding, ctx) {
     const indices = Array.from(m[2].matchAll(/\[(\d+)\]/g)).map((x) => x[1]);
     return [head, ...indices];
   });
-  const root = parts[0];
-  const path = parts.slice(1);
+  const parsed = { root: parts[0], path: parts.slice(1) };
+  PARSED_PATH_CACHE.set(withoutPrefix, parsed);
+  return parsed;
+}
+function resolveBinding(binding, ctx) {
+  if (!binding.startsWith("@")) {
+    return void 0;
+  }
+  const { root, path } = parseBindingPath(binding.slice(1));
   if (CLIENT_ONLY_BINDING_ROOTS.has(root)) {
     return void 0;
   }
@@ -301,6 +307,7 @@ function evalWhen(args, evaluate2, ctx) {
   if (Boolean(condition)) {
     evaluate2(args[1], ctx);
   }
+  return void 0;
 }
 function evalFn(args, _evaluate, _ctx) {
   const params = args[0];
@@ -619,7 +626,7 @@ function evalDeref(args, evaluate2, ctx) {
   if (id && ctx.effectHandlers?.fetch) {
     return ctx.effectHandlers.fetch(entityType, id);
   }
-  return ctx.entity?.[entityType] ?? [];
+  return ctx.entity[entityType] ?? [];
 }
 function evalSwap(args, evaluate2, ctx) {
   const entityType = args[0];
@@ -4155,18 +4162,491 @@ function evalPathReachable(args, evaluate2, ctx) {
 }
 // SExpressionEvaluator.ts
-var jitCache = /* @__PURE__ */ new Map();
-var MAX_JIT_CACHE_SIZE = 1e3;
 var UNKNOWN_OPERATOR = /* @__PURE__ */ Symbol("unknown-operator");
+var OPERATOR_TABLE = {
+  "+": evalAdd,
+  "-": evalSubtract,
+  "*": evalMultiply,
+  "/": evalDivide,
+  "%": evalModulo,
+  "abs": evalAbs,
+  "min": evalMin,
+  "max": evalMax,
+  "floor": evalFloor,
+  "ceil": evalCeil,
+  "round": evalRound,
+  "clamp": evalClamp,
+  "=": evalEqual,
+  "==": evalEqual,
+  "!=": evalNotEqual,
+  "<": evalLessThan,
+  ">": evalGreaterThan,
+  "<=": evalLessThanOrEqual,
+  ">=": evalGreaterThanOrEqual,
+  "matches": evalMatches,
+  "and": evalAnd,
+  "or": evalOr,
+  "not": evalNot,
+  "if": evalIf,
+  "let": evalLet,
+  "do": evalDo,
+  "when": evalWhen,
+  "fn": evalFn,
+  "lambda": evalFn,
+  "map": evalMap,
+  "filter": evalFilter,
+  "find": evalFind,
+  "count": evalCount,
+  "sum": evalSum,
+  "first": evalFirst,
+  "last": evalLast,
+  "nth": evalNth,
+  "concat": evalConcat,
+  "includes": evalIncludes,
+  "empty": evalEmpty,
+  "list": evalList,
+  "set": (args, evaluate2, ctx) => {
+    evalSet(args, evaluate2, ctx);
+    return void 0;
+  },
+  "set-dynamic": (args, evaluate2, ctx) => {
+    evalSetDynamic(args, evaluate2, ctx);
+    return void 0;
+  },
+  "increment": (args, evaluate2, ctx) => {
+    evalIncrement(args, evaluate2, ctx);
+    return void 0;
+  },
+  "decrement": (args, evaluate2, ctx) => {
+    evalDecrement(args, evaluate2, ctx);
+    return void 0;
+  },
+  "emit": (args, evaluate2, ctx) => {
+    evalEmit(args, evaluate2, ctx);
+    return void 0;
+  },
+  "persist": (args, evaluate2, ctx) => {
+    evalPersist(args, evaluate2, ctx);
+    return void 0;
+  },
+  "navigate": (args, evaluate2, ctx) => {
+    evalNavigate(args, evaluate2, ctx);
+    return void 0;
+  },
+  "notify": (args, evaluate2, ctx) => {
+    evalNotify(args, evaluate2, ctx);
+    return void 0;
+  },
+  "spawn": (args, evaluate2, ctx) => {
+    evalSpawn(args, evaluate2, ctx);
+    return void 0;
+  },
+  "despawn": (args, evaluate2, ctx) => {
+    evalDespawn(args, evaluate2, ctx);
+    return void 0;
+  },
+  "call-service": (args, evaluate2, ctx) => {
+    evalCallService(args, evaluate2, ctx);
+    return void 0;
+  },
+  "render-ui": (args, evaluate2, ctx) => {
+    evalRenderUI(args, evaluate2, ctx);
+    return void 0;
+  },
+  "ref": evalRef,
+  "deref": evalDeref,
+  "swap!": evalSwap,
+  "watch": (args, evaluate2, ctx) => {
+    evalWatch(args, evaluate2, ctx);
+    return void 0;
+  },
+  "atomic": evalAtomic,
+  "math/abs": evalMathAbs,
+  "math/min": evalMathMin,
+  "math/max": evalMathMax,
+  "math/clamp": evalMathClamp,
+  "math/floor": evalMathFloor,
+  "math/ceil": evalMathCeil,
+  "math/round": evalMathRound,
+  "math/pow": evalMathPow,
+  "math/sqrt": evalMathSqrt,
+  "math/mod": evalMathMod,
+  "math/sign": evalMathSign,
+  "math/lerp": evalMathLerp,
+  "math/map": evalMathMap,
+  "math/random": () => evalMathRandom(),
+  "math/randomInt": evalMathRandomInt,
+  "math/default": evalMathDefault,
+  "math/sin": evalMathSin,
+  "math/cos": evalMathCos,
+  "math/tan": evalMathTan,
+  "math/atan2": evalMathAtan2,
+  "math/asin": evalMathAsin,
+  "math/acos": evalMathAcos,
+  "math/atan": evalMathAtan,
+  "math/hypot": evalMathHypot,
+  "math/deg-rad": evalMathDegRad,
+  "math/rad-deg": evalMathRadDeg,
+  "math/wrap": evalMathWrap,
+  "math/approach": evalMathApproach,
+  "vec/add": evalVecAdd,
+  "vec/sub": evalVecSub,
+  "vec/scale": evalVecScale,
+  "vec/dot": evalVecDot,
+  "vec/cross": evalVecCross,
+  "vec/length": evalVecLength,
+  "vec/length-sq": evalVecLengthSq,
+  "vec/normalize": evalVecNormalize,
+  "vec/distance": evalVecDistance,
+  "vec/distance-sq": evalVecDistanceSq,
+  "vec/lerp": evalVecLerp,
+  "vec/angle": evalVecAngle,
+  "vec/rotate": evalVecRotate,
+  "vec/clamp-length": evalVecClampLength,
+  "geo/aabb-overlap": evalGeoAabbOverlap,
+  "geo/circle-overlap": evalGeoCircleOverlap,
+  "geo/rect-circle-overlap": evalGeoRectCircleOverlap,
+  "geo/point-in-rect": evalGeoPointInRect,
+  "geo/point-in-circle": evalGeoPointInCircle,
+  "geo/reflect": evalGeoReflect,
+  "geo/segment-intersect": evalGeoSegmentIntersect,
+  "grid/to-world": evalGridToWorld,
+  "grid/from-world": evalGridFromWorld,
+  "grid/iso-to-screen": evalGridIsoToScreen,
+  "grid/screen-to-iso": evalGridScreenToIso,
+  "grid/distance": evalGridDistance,
+  "grid/manhattan-distance": evalGridManhattanDistance,
+  "grid/neighbors": evalGridNeighbors,
+  "grid/cells-in-radius": evalGridCellsInRadius,
+  "grid/line": evalGridLine,
+  "grid/in-bounds": evalGridInBounds,
+  "anim/frame-at": evalAnimFrameAt,
+  "anim/sheet-rect": evalAnimSheetRect,
+  "anim/direction-from-delta": evalAnimDirectionFromDelta,
+  "ease/apply": evalEaseApply,
+  "ease/smoothstep": evalEaseSmoothstep,
+  "noise/perlin": evalNoisePerlin,
+  "noise/simplex": evalNoiseSimplex,
+  "noise/fbm": evalNoiseFbm,
+  "path/astar": evalPathAstar,
+  "path/reachable": evalPathReachable,
+  "str/len": evalStrLen,
+  "str/concat": evalStrConcat,
+  "str/upper": evalStrUpper,
+  "str/lower": evalStrLower,
+  "str/trim": evalStrTrim,
+  "str/trimStart": evalStrTrimStart,
+  "str/trimEnd": evalStrTrimEnd,
+  "str/split": evalStrSplit,
+  "str/join": evalStrJoin,
+  "str/slice": evalStrSlice,
+  "str/replace": evalStrReplace,
+  "str/replaceAll": evalStrReplaceAll,
+  "str/includes": evalStrIncludes,
+  "str/startsWith": evalStrStartsWith,
+  "str/endsWith": evalStrEndsWith,
+  "str/padStart": evalStrPadStart,
+  "str/padEnd": evalStrPadEnd,
+  "str/repeat": evalStrRepeat,
+  "str/reverse": evalStrReverse,
+  "str/capitalize": evalStrCapitalize,
+  "str/titleCase": evalStrTitleCase,
+  "str/camelCase": evalStrCamelCase,
+  "str/kebabCase": evalStrKebabCase,
+  "str/snakeCase": evalStrSnakeCase,
+  "str/default": evalStrDefault,
+  "str/template": evalStrTemplate,
+  "str/truncate": evalStrTruncate,
+  "to-string": (args, evaluate2, ctx) => String(evaluate2(args[0], ctx)),
+  "array/len": evalArrayLen,
+  "array/range": evalArrayRange,
+  "array/empty?": evalArrayEmpty,
+  "array/first": evalArrayFirst,
+  "array/last": evalArrayLast,
+  "array/nth": evalArrayNth,
+  "array/slice": evalArraySlice,
+  "array/concat": evalArrayConcat,
+  "array/append": evalArrayAppend,
+  "array/prepend": evalArrayPrepend,
+  "array/insert": evalArrayInsert,
+  "array/remove": evalArrayRemove,
+  "array/removeItem": evalArrayRemoveItem,
+  "array/reverse": evalArrayReverse,
+  "array/sort": evalArraySort,
+  "array/shuffle": evalArrayShuffle,
+  "array/unique": evalArrayUnique,
+  "array/flatten": evalArrayFlatten,
+  "array/zip": evalArrayZip,
+  "array/includes": evalArrayIncludes,
+  "array/indexOf": evalArrayIndexOf,
+  "array/find": evalArrayFind,
+  "array/findIndex": evalArrayFindIndex,
+  "array/filter": evalArrayFilter,
+  "array/reject": evalArrayReject,
+  "array/map": evalArrayMap,
+  "array/reduce": evalArrayReduce,
+  "array/every": evalArrayEvery,
+  "array/some": evalArraySome,
+  "array/count": evalArrayCount,
+  "array/sum": evalArraySum,
+  "array/avg": evalArrayAvg,
+  "array/min": evalArrayMin,
+  "array/max": evalArrayMax,
+  "array/groupBy": evalArrayGroupBy,
+  "array/partition": evalArrayPartition,
+  "array/take": evalArrayTake,
+  "array/drop": evalArrayDrop,
+  "array/takeLast": evalArrayTakeLast,
+  "array/dropLast": evalArrayDropLast,
+  "array/cosine": evalArrayCosine,
+  "array/nearest": evalArrayNearest,
+  "object/keys": evalObjectKeys,
+  "object/values": evalObjectValues,
+  "object/entries": evalObjectEntries,
+  "object/fromEntries": evalObjectFromEntries,
+  "object/get": evalObjectGet,
+  "object/set": evalObjectSet,
+  "object/has": evalObjectHas,
+  "object/merge": evalObjectMerge,
+  "object/deepMerge": evalObjectDeepMerge,
+  "object/pick": evalObjectPick,
+  "object/omit": evalObjectOmit,
+  "object/mapValues": evalObjectMapValues,
+  "object/mapKeys": evalObjectMapKeys,
+  "object/filter": evalObjectFilter,
+  "object/empty?": evalObjectEmpty,
+  "object/equals": evalObjectEquals,
+  "object/clone": evalObjectClone,
+  "object/deepClone": evalObjectDeepClone,
+  "path": evalPath,
+  "validate/required": evalValidateRequired,
+  "validate/string": evalValidateString,
+  "validate/number": evalValidateNumber,
+  "validate/boolean": evalValidateBoolean,
+  "validate/array": evalValidateArray,
+  "validate/object": evalValidateObject,
+  "validate/email": evalValidateEmail,
+  "validate/url": evalValidateUrl,
+  "validate/uuid": evalValidateUuid,
+  "validate/phone": evalValidatePhone,
+  "validate/creditCard": evalValidateCreditCard,
+  "validate/date": evalValidateDate,
+  "validate/minLength": evalValidateMinLength,
+  "validate/maxLength": evalValidateMaxLength,
+  "validate/length": evalValidateLength,
+  "validate/min": evalValidateMin,
+  "validate/max": evalValidateMax,
+  "validate/range": evalValidateRange,
+  "validate/pattern": evalValidatePattern,
+  "validate/oneOf": evalValidateOneOf,
+  "validate/noneOf": evalValidateNoneOf,
+  "validate/equals": evalValidateEquals,
+  "validate/check": evalValidateCheck,
+  "time/now": () => evalTimeNow(),
+  "time/today": () => evalTimeToday(),
+  "time/parse": evalTimeParse,
+  "time/format": evalTimeFormat,
+  "time/year": evalTimeYear,
+  "time/month": evalTimeMonth,
+  "time/day": evalTimeDay,
+  "time/weekday": evalTimeWeekday,
+  "time/hour": evalTimeHour,
+  "time/minute": evalTimeMinute,
+  "time/second": evalTimeSecond,
+  "time/add": evalTimeAdd,
+  "time/subtract": evalTimeSubtract,
+  "time/diff": evalTimeDiff,
+  "time/startOf": evalTimeStartOf,
+  "time/endOf": evalTimeEndOf,
+  "time/isBefore": evalTimeIsBefore,
+  "time/isAfter": evalTimeIsAfter,
+  "time/isBetween": evalTimeIsBetween,
+  "time/isSame": evalTimeIsSame,
+  "time/isPast": evalTimeIsPast,
+  "time/isFuture": evalTimeIsFuture,
+  "time/isToday": evalTimeIsToday,
+  "time/relative": evalTimeRelative,
+  "time/duration": evalTimeDuration,
+  "format/number": evalFormatNumber,
+  "format/currency": evalFormatCurrency,
+  "format/percent": evalFormatPercent,
+  "format/bytes": evalFormatBytes,
+  "format/ordinal": evalFormatOrdinal,
+  "format/plural": evalFormatPlural,
+  "format/list": evalFormatList,
+  "format/phone": evalFormatPhone,
+  "format/creditCard": evalFormatCreditCard,
+  "async/delay": evalAsyncDelay,
+  "async/interval": evalAsyncInterval,
+  "async/timeout": evalAsyncTimeout,
+  "async/debounce": (args, evaluate2, ctx) => {
+    evalAsyncDebounce(args, evaluate2, ctx);
+    return void 0;
+  },
+  "async/throttle": (args, evaluate2, ctx) => {
+    evalAsyncThrottle(args, evaluate2, ctx);
+    return void 0;
+  },
+  "async/retry": evalAsyncRetry,
+  "async/race": evalAsyncRace,
+  "async/all": evalAsyncAll,
+  "async/sequence": evalAsyncSequence,
+  "prob/seed": (args, evaluate2, ctx) => {
+    evalProbSeed(args, evaluate2, ctx);
+    return void 0;
+  },
+  "prob/flip": evalProbFlip,
+  "prob/gaussian": evalProbGaussian,
+  "prob/uniform": evalProbUniform,
+  "prob/beta": evalProbBeta,
+  "prob/categorical": evalProbCategorical,
+  "prob/poisson": evalProbPoisson,
+  "prob/condition": (args, evaluate2, ctx) => {
+    evalProbCondition(args, evaluate2, ctx);
+    return void 0;
+  },
+  "prob/sample": evalProbSample,
+  "prob/posterior": evalProbPosterior,
+  "prob/infer": evalProbInfer,
+  "prob/expected-value": evalProbExpectedValue,
+  "prob/variance": evalProbVariance,
+  "prob/histogram": evalProbHistogram,
+  "prob/percentile": evalProbPercentile,
+  "prob/credible-interval": evalProbCredibleInterval,
+  "os/watch-files": (args, evaluate2, ctx) => {
+    evalOsWatchFiles(args, evaluate2, ctx);
+    return void 0;
+  },
+  "os/watch-process": (args, evaluate2, ctx) => {
+    evalOsWatchProcess(args, evaluate2, ctx);
+    return void 0;
+  },
+  "os/watch-port": (args, evaluate2, ctx) => {
+    evalOsWatchPort(args, evaluate2, ctx);
+    return void 0;
+  },
+  "os/watch-http": (args, evaluate2, ctx) => {
+    evalOsWatchHttp(args, evaluate2, ctx);
+    return void 0;
+  },
+  "os/watch-cron": (args, evaluate2, ctx) => {
+    evalOsWatchCron(args, evaluate2, ctx);
+    return void 0;
+  },
+  "os/watch-signal": (args, evaluate2, ctx) => {
+    evalOsWatchSignal(args, evaluate2, ctx);
+    return void 0;
+  },
+  "os/watch-env": (args, evaluate2, ctx) => {
+    evalOsWatchEnv(args, evaluate2, ctx);
+    return void 0;
+  },
+  "os/debounce": (args, evaluate2, ctx) => {
+    evalOsDebounce(args, evaluate2, ctx);
+    return void 0;
+  },
+  "llm/generate": evalLlmGenerate,
+  "llm/call-tools": evalLlmCallTools,
+  "llm/embed": evalLlmEmbed,
+  "llm/token-count": evalLlmTokenCount,
+  "llm/switch": evalLlmSwitch,
+  "llm/compact": evalLlmCompact,
+  "workspace/read-orbital": evalWorkspaceReadOrbital,
+  "workspace/write-orbital": evalWorkspaceWriteOrbital,
+  "workspace/read-file": evalWorkspaceReadFile,
+  "workspace/write-file": evalWorkspaceWriteFile,
+  "workspace/exists": evalWorkspaceExists,
+  "workspace/list-orbitals": evalWorkspaceListOrbitals,
+  "workspace/read-schema": evalWorkspaceReadSchema,
+  "workspace/write-schema": evalWorkspaceWriteSchema,
+  "workspace/read-plan": evalWorkspaceReadPlan,
+  "workspace/write-plan": evalWorkspaceWritePlan,
+  "workspace/archive-orbital": evalWorkspaceArchiveOrbital,
+  "session/read-spec": evalSessionReadSpec,
+  "session/write-spec": evalSessionWriteSpec,
+  "session/read-memory": evalSessionReadMemory,
+  "session/write-memory": evalSessionWriteMemory,
+  "session/read-history": evalSessionReadHistory,
+  "session/append-history": evalSessionAppendHistory,
+  "session/read-errors": evalSessionReadErrors,
+  "session/write-errors": evalSessionWriteErrors,
+  "session/read-analysis": evalSessionReadAnalysis,
+  "memory/recall": evalMemoryRecall,
+  "memory/store": evalMemoryStore,
+  "memory/list": evalMemoryList,
+  "trace/emit": evalTraceEmit,
+  "trace/log": evalTraceLog,
+  "integration/http": evalIntegrationHttp,
+  "integration/github-get-repo": evalIntegrationGithubGetRepo,
+  "integration/github-create-issue": evalIntegrationGithubCreateIssue,
+  "contract/validate-input": evalContractValidateInput,
+  "contract/validate-output": evalContractValidateOutput,
+  "contract/clamp-output": evalContractClampOutput,
+  "contract/violations": evalContractViolations,
+  "contract/entity-to-tensor": evalContractEntityToTensor,
+  "contract/tensor-to-payload": evalContractTensorToPayload,
+  "graph/from-entities": evalGraphFromEntities,
+  "graph/from-adjacency": evalGraphFromAdjacency,
+  "graph/from-edge-list": evalGraphFromEdgeList,
+  "graph/add-self-loops": evalGraphAddSelfLoops,
+  "graph/to-undirected": evalGraphToUndirected,
+  "graph/subgraph": evalGraphSubgraph,
+  "graph/k-hop": evalGraphKHop,
+  "graph/node-features": evalGraphNodeFeatures,
+  "graph/edge-index": evalGraphEdgeIndex,
+  "graph/edge-features": evalGraphEdgeFeatures,
+  "graph/num-nodes": evalGraphNumNodes,
+  "graph/num-edges": evalGraphNumEdges,
+  "graph/degree": evalGraphDegree,
+  "graph/batch": evalGraphBatch,
+  "data/dataset": evalDataDataset,
+  "data/dataloader": evalDataDataloader,
+  "data/split": evalDataSplit,
+  "data/normalize": evalDataNormalize,
+  "data/augment": evalDataAugment,
+  "data/tokenize": evalDataTokenize,
+  "data/pad": evalDataPad
+};
 var SExpressionEvaluator = class {
+  constructor() {
+    /**
+     * Tier-up compilation cache, keyed by node IDENTITY: schema trees are
+     * long-lived parsed objects, so a WeakMap costs no key serialization and
+     * is collected with the schema. First sight of a node interprets it and
+     * marks it seen; the second sight compiles it — one-off dynamically built
+     * expressions never pay compile cost.
+     */
+    this.compileCache = /* @__PURE__ */ new WeakMap();
+    /** Single bound interpreter handed to operator impls — was allocated per dispatch. */
+    this.boundInterpret = (expr, c) => this.interpret(expr, c);
+  }
   /**
    * Evaluate an S-expression in the given context.
+   * Hot trees promote to compiled closures on second use; everything else
+   * runs through the interpreter.
    *
    * @param expr - S-expression to evaluate
    * @param ctx - Evaluation context with bindings and effect handlers
    * @returns Result of evaluation
    */
   evaluate(expr, ctx) {
+    if (typeof expr === "object" && expr !== null) {
+      const entry = this.compileCache.get(expr);
+      if (typeof entry === "function") return entry(ctx);
+      if (entry === true) {
+        const fn = this.compileNode(expr, /* @__PURE__ */ new Map(), void 0);
+        this.compileCache.set(expr, fn);
+        return fn(ctx);
+      }
+      this.compileCache.set(expr, true);
+    }
+    return this.interpret(expr, ctx);
+  }
+  /**
+   * The tree-walking interpreter of record — first-use path and the
+   * compiler's fallback for foreign subtrees.
+   */
+  interpret(expr, ctx) {
     if (!isSExpr(expr)) {
       if (isBinding(expr)) {
         return resolveBinding(expr, ctx);
@@ -4191,6 +4671,57 @@ var SExpressionEvaluator = class {
     }
     return result;
   }
+  /**
+   * Compile one tree into composed closures. Every node of the tree is
+   * registered in `into` so the impls' `evaluate` callback (childDispatch)
+   * resolves in-tree children by identity and falls back to interpretation
+   * only for foreign subtrees. Arity is asserted HERE, once — a tree that
+   * compiles never re-validates.
+   */
+  compileNode(expr, into, childDispatch) {
+    const dispatch = childDispatch ?? ((e, c) => {
+      const f = into.get(e);
+      return f !== void 0 ? f(c) : this.interpret(e, c);
+    });
+    let fn;
+    if (!isSExpr(expr)) {
+      if (isBinding(expr)) {
+        fn = (ctx) => resolveBinding(expr, ctx);
+      } else if (this.isPlainObject(expr)) {
+        const entries = Object.entries(expr).map(
+          ([k, v]) => [k, this.compileNode(v, into, dispatch)]
+        );
+        fn = (ctx) => {
+          const out = {};
+          for (const [k, f] of entries) out[k] = f(ctx);
+          return out;
+        };
+      } else if (Array.isArray(expr)) {
+        const items = expr.map((item) => this.compileNode(item, into, dispatch));
+        fn = (ctx) => items.map((f) => f(ctx));
+      } else {
+        fn = () => expr;
+      }
+    } else {
+      const op = getOperator(expr);
+      const args = getArgs(expr);
+      assertOperatorArity(op, args.length);
+      const impl = OPERATOR_TABLE[op];
+      for (const item of expr) {
+        if (!into.has(item)) this.compileNode(item, into, dispatch);
+      }
+      if (impl === void 0) {
+        fn = (ctx) => expr.map((item) => {
+          const f = into.get(item);
+          return f !== void 0 ? f(ctx) : this.interpret(item, ctx);
+        });
+      } else {
+        fn = (ctx) => impl(args, dispatch, ctx);
+      }
+    }
+    into.set(expr, fn);
+    return fn;
+  }
   isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && Object.getPrototypeOf(value) === Object.prototype;
   }
@@ -4227,886 +4758,39 @@ var SExpressionEvaluator = class {
   }
   /**
    * Compile an S-expression to a function for faster repeated evaluation.
-   * Uses a cache to avoid recompilation.
+   * Same machinery as the automatic tier-up in `evaluate`; explicit callers
+   * promote immediately instead of on second use.
    *
    * @param expr - S-expression to compile
    * @returns Function that evaluates the expression given a context
    */
   compile(expr) {
-    const key2 = JSON.stringify(expr);
-    const cached = jitCache.get(key2);
-    if (cached) {
-      return cached;
-    }
-    const fn = (ctx) => this.evaluate(expr, ctx);
-    if (jitCache.size >= MAX_JIT_CACHE_SIZE) {
-      const firstKey = jitCache.keys().next().value;
-      if (firstKey) {
-        jitCache.delete(firstKey);
-      }
+    if (typeof expr === "object" && expr !== null) {
+      const entry = this.compileCache.get(expr);
+      if (typeof entry === "function") return entry;
+      const fn = this.compileNode(expr, /* @__PURE__ */ new Map(), void 0);
+      this.compileCache.set(expr, fn);
+      return fn;
     }
-    jitCache.set(key2, fn);
-    return fn;
+    return this.compileNode(expr, /* @__PURE__ */ new Map(), void 0);
   }
   /**
-   * Clear the JIT compilation cache.
+   * Clear the compilation cache.
    */
   clearCache() {
-    jitCache.clear();
+    this.compileCache = /* @__PURE__ */ new WeakMap();
   }
+  /**
+   * Dispatch to the appropriate operator implementation.
+   */
   /**
    * Dispatch to the appropriate operator implementation.
    */
   dispatchOperator(op, args, ctx) {
     assertOperatorArity(op, args.length);
-    const evaluate2 = (expr, c) => this.evaluate(expr, c);
-    switch (op) {
-      // Arithmetic
-      case "+":
-        return evalAdd(args, evaluate2, ctx);
-      case "-":
-        return evalSubtract(args, evaluate2, ctx);
-      case "*":
-        return evalMultiply(args, evaluate2, ctx);
-      case "/":
-        return evalDivide(args, evaluate2, ctx);
-      case "%":
-        return evalModulo(args, evaluate2, ctx);
-      case "abs":
-        return evalAbs(args, evaluate2, ctx);
-      case "min":
-        return evalMin(args, evaluate2, ctx);
-      case "max":
-        return evalMax(args, evaluate2, ctx);
-      case "floor":
-        return evalFloor(args, evaluate2, ctx);
-      case "ceil":
-        return evalCeil(args, evaluate2, ctx);
-      case "round":
-        return evalRound(args, evaluate2, ctx);
-      case "clamp":
-        return evalClamp(args, evaluate2, ctx);
-      // Comparison
-      case "=":
-      case "==":
-        return evalEqual(args, evaluate2, ctx);
-      case "!=":
-        return evalNotEqual(args, evaluate2, ctx);
-      case "<":
-        return evalLessThan(args, evaluate2, ctx);
-      case ">":
-        return evalGreaterThan(args, evaluate2, ctx);
-      case "<=":
-        return evalLessThanOrEqual(args, evaluate2, ctx);
-      case ">=":
-        return evalGreaterThanOrEqual(args, evaluate2, ctx);
-      case "matches":
-        return evalMatches(args, evaluate2, ctx);
-      // Logic
-      case "and":
-        return evalAnd(args, evaluate2, ctx);
-      case "or":
-        return evalOr(args, evaluate2, ctx);
-      case "not":
-        return evalNot(args, evaluate2, ctx);
-      case "if":
-        return evalIf(args, evaluate2, ctx);
-      // Control
-      case "let":
-        return evalLet(args, evaluate2, ctx);
-      case "do":
-        return evalDo(args, evaluate2, ctx);
-      case "when":
-        return evalWhen(args, evaluate2, ctx);
-      case "fn":
-      case "lambda":
-        return evalFn(args);
-      // Collections
-      case "map":
-        return evalMap(args, evaluate2, ctx);
-      case "filter":
-        return evalFilter(args, evaluate2, ctx);
-      case "find":
-        return evalFind(args, evaluate2, ctx);
-      case "count":
-        return evalCount(args, evaluate2, ctx);
-      case "sum":
-        return evalSum(args, evaluate2, ctx);
-      case "first":
-        return evalFirst(args, evaluate2, ctx);
-      case "last":
-        return evalLast(args, evaluate2, ctx);
-      case "nth":
-        return evalNth(args, evaluate2, ctx);
-      case "concat":
-        return evalConcat(args, evaluate2, ctx);
-      case "includes":
-        return evalIncludes(args, evaluate2, ctx);
-      case "empty":
-        return evalEmpty(args, evaluate2, ctx);
-      case "list":
-        return evalList(args, evaluate2, ctx);
-      // Effects
-      case "set":
-        evalSet(args, evaluate2, ctx);
-        return void 0;
-      case "set-dynamic":
-        evalSetDynamic(args, evaluate2, ctx);
-        return void 0;
-      case "increment":
-        evalIncrement(args, evaluate2, ctx);
-        return void 0;
-      case "decrement":
-        evalDecrement(args, evaluate2, ctx);
-        return void 0;
-      case "emit":
-        evalEmit(args, evaluate2, ctx);
-        return void 0;
-      case "persist":
-        evalPersist(args, evaluate2, ctx);
-        return void 0;
-      case "navigate":
-        evalNavigate(args, evaluate2, ctx);
-        return void 0;
-      case "notify":
-        evalNotify(args, evaluate2, ctx);
-        return void 0;
-      case "spawn":
-        evalSpawn(args, evaluate2, ctx);
-        return void 0;
-      case "despawn":
-        evalDespawn(args, evaluate2, ctx);
-        return void 0;
-      case "call-service":
-        evalCallService(args, evaluate2, ctx);
-        return void 0;
-      case "render-ui":
-        evalRenderUI(args, evaluate2, ctx);
-        return void 0;
-      // Resource operators
-      case "ref":
-        return evalRef(args, evaluate2, ctx);
-      case "deref":
-        return evalDeref(args, evaluate2, ctx);
-      case "swap!":
-        return evalSwap(args, evaluate2, ctx);
-      case "watch":
-        evalWatch(args, evaluate2, ctx);
-        return void 0;
-      case "atomic":
-        return evalAtomic(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: math/*
-      // ===============================
-      case "math/abs":
-        return evalMathAbs(args, evaluate2, ctx);
-      case "math/min":
-        return evalMathMin(args, evaluate2, ctx);
-      case "math/max":
-        return evalMathMax(args, evaluate2, ctx);
-      case "math/clamp":
-        return evalMathClamp(args, evaluate2, ctx);
-      case "math/floor":
-        return evalMathFloor(args, evaluate2, ctx);
-      case "math/ceil":
-        return evalMathCeil(args, evaluate2, ctx);
-      case "math/round":
-        return evalMathRound(args, evaluate2, ctx);
-      case "math/pow":
-        return evalMathPow(args, evaluate2, ctx);
-      case "math/sqrt":
-        return evalMathSqrt(args, evaluate2, ctx);
-      case "math/mod":
-        return evalMathMod(args, evaluate2, ctx);
-      case "math/sign":
-        return evalMathSign(args, evaluate2, ctx);
-      case "math/lerp":
-        return evalMathLerp(args, evaluate2, ctx);
-      case "math/map":
-        return evalMathMap(args, evaluate2, ctx);
-      case "math/random":
-        return evalMathRandom();
-      case "math/randomInt":
-        return evalMathRandomInt(args, evaluate2, ctx);
-      case "math/default":
-        return evalMathDefault(args, evaluate2, ctx);
-      case "math/sin":
-        return evalMathSin(args, evaluate2, ctx);
-      case "math/cos":
-        return evalMathCos(args, evaluate2, ctx);
-      case "math/tan":
-        return evalMathTan(args, evaluate2, ctx);
-      case "math/atan2":
-        return evalMathAtan2(args, evaluate2, ctx);
-      case "math/asin":
-        return evalMathAsin(args, evaluate2, ctx);
-      case "math/acos":
-        return evalMathAcos(args, evaluate2, ctx);
-      case "math/atan":
-        return evalMathAtan(args, evaluate2, ctx);
-      case "math/hypot":
-        return evalMathHypot(args, evaluate2, ctx);
-      case "math/deg-rad":
-        return evalMathDegRad(args, evaluate2, ctx);
-      case "math/rad-deg":
-        return evalMathRadDeg(args, evaluate2, ctx);
-      case "math/wrap":
-        return evalMathWrap(args, evaluate2, ctx);
-      case "math/approach":
-        return evalMathApproach(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: vec/*
-      // ===============================
-      case "vec/add":
-        return evalVecAdd(args, evaluate2, ctx);
-      case "vec/sub":
-        return evalVecSub(args, evaluate2, ctx);
-      case "vec/scale":
-        return evalVecScale(args, evaluate2, ctx);
-      case "vec/dot":
-        return evalVecDot(args, evaluate2, ctx);
-      case "vec/cross":
-        return evalVecCross(args, evaluate2, ctx);
-      case "vec/length":
-        return evalVecLength(args, evaluate2, ctx);
-      case "vec/length-sq":
-        return evalVecLengthSq(args, evaluate2, ctx);
-      case "vec/normalize":
-        return evalVecNormalize(args, evaluate2, ctx);
-      case "vec/distance":
-        return evalVecDistance(args, evaluate2, ctx);
-      case "vec/distance-sq":
-        return evalVecDistanceSq(args, evaluate2, ctx);
-      case "vec/lerp":
-        return evalVecLerp(args, evaluate2, ctx);
-      case "vec/angle":
-        return evalVecAngle(args, evaluate2, ctx);
-      case "vec/rotate":
-        return evalVecRotate(args, evaluate2, ctx);
-      case "vec/clamp-length":
-        return evalVecClampLength(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: geo/*
-      // ===============================
-      case "geo/aabb-overlap":
-        return evalGeoAabbOverlap(args, evaluate2, ctx);
-      case "geo/circle-overlap":
-        return evalGeoCircleOverlap(args, evaluate2, ctx);
-      case "geo/rect-circle-overlap":
-        return evalGeoRectCircleOverlap(args, evaluate2, ctx);
-      case "geo/point-in-rect":
-        return evalGeoPointInRect(args, evaluate2, ctx);
-      case "geo/point-in-circle":
-        return evalGeoPointInCircle(args, evaluate2, ctx);
-      case "geo/reflect":
-        return evalGeoReflect(args, evaluate2, ctx);
-      case "geo/segment-intersect":
-        return evalGeoSegmentIntersect(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: grid/*
-      // ===============================
-      case "grid/to-world":
-        return evalGridToWorld(args, evaluate2, ctx);
-      case "grid/from-world":
-        return evalGridFromWorld(args, evaluate2, ctx);
-      case "grid/iso-to-screen":
-        return evalGridIsoToScreen(args, evaluate2, ctx);
-      case "grid/screen-to-iso":
-        return evalGridScreenToIso(args, evaluate2, ctx);
-      case "grid/distance":
-        return evalGridDistance(args, evaluate2, ctx);
-      case "grid/manhattan-distance":
-        return evalGridManhattanDistance(args, evaluate2, ctx);
-      case "grid/neighbors":
-        return evalGridNeighbors(args, evaluate2, ctx);
-      case "grid/cells-in-radius":
-        return evalGridCellsInRadius(args, evaluate2, ctx);
-      case "grid/line":
-        return evalGridLine(args, evaluate2, ctx);
-      case "grid/in-bounds":
-        return evalGridInBounds(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: anim/*
-      // ===============================
-      case "anim/frame-at":
-        return evalAnimFrameAt(args, evaluate2, ctx);
-      case "anim/sheet-rect":
-        return evalAnimSheetRect(args, evaluate2, ctx);
-      case "anim/direction-from-delta":
-        return evalAnimDirectionFromDelta(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: ease/*
-      // ===============================
-      case "ease/apply":
-        return evalEaseApply(args, evaluate2, ctx);
-      case "ease/smoothstep":
-        return evalEaseSmoothstep(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: noise/*
-      // ===============================
-      case "noise/perlin":
-        return evalNoisePerlin(args, evaluate2, ctx);
-      case "noise/simplex":
-        return evalNoiseSimplex(args, evaluate2, ctx);
-      case "noise/fbm":
-        return evalNoiseFbm(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: path/*
-      // ===============================
-      case "path/astar":
-        return evalPathAstar(args, evaluate2, ctx);
-      case "path/reachable":
-        return evalPathReachable(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: str/*
-      // ===============================
-      case "str/len":
-        return evalStrLen(args, evaluate2, ctx);
-      case "str/concat":
-        return evalStrConcat(args, evaluate2, ctx);
-      case "str/upper":
-        return evalStrUpper(args, evaluate2, ctx);
-      case "str/lower":
-        return evalStrLower(args, evaluate2, ctx);
-      case "str/trim":
-        return evalStrTrim(args, evaluate2, ctx);
-      case "str/trimStart":
-        return evalStrTrimStart(args, evaluate2, ctx);
-      case "str/trimEnd":
-        return evalStrTrimEnd(args, evaluate2, ctx);
-      case "str/split":
-        return evalStrSplit(args, evaluate2, ctx);
-      case "str/join":
-        return evalStrJoin(args, evaluate2, ctx);
-      case "str/slice":
-        return evalStrSlice(args, evaluate2, ctx);
-      case "str/replace":
-        return evalStrReplace(args, evaluate2, ctx);
-      case "str/replaceAll":
-        return evalStrReplaceAll(args, evaluate2, ctx);
-      case "str/includes":
-        return evalStrIncludes(args, evaluate2, ctx);
-      case "str/startsWith":
-        return evalStrStartsWith(args, evaluate2, ctx);
-      case "str/endsWith":
-        return evalStrEndsWith(args, evaluate2, ctx);
-      case "str/padStart":
-        return evalStrPadStart(args, evaluate2, ctx);
-      case "str/padEnd":
-        return evalStrPadEnd(args, evaluate2, ctx);
-      case "str/repeat":
-        return evalStrRepeat(args, evaluate2, ctx);
-      case "str/reverse":
-        return evalStrReverse(args, evaluate2, ctx);
-      case "str/capitalize":
-        return evalStrCapitalize(args, evaluate2, ctx);
-      case "str/titleCase":
-        return evalStrTitleCase(args, evaluate2, ctx);
-      case "str/camelCase":
-        return evalStrCamelCase(args, evaluate2, ctx);
-      case "str/kebabCase":
-        return evalStrKebabCase(args, evaluate2, ctx);
-      case "str/snakeCase":
-        return evalStrSnakeCase(args, evaluate2, ctx);
-      case "str/default":
-        return evalStrDefault(args, evaluate2, ctx);
-      case "str/template":
-        return evalStrTemplate(args, evaluate2, ctx);
-      case "str/truncate":
-        return evalStrTruncate(args, evaluate2, ctx);
-      case "to-string":
-        return String(evaluate2(args[0], ctx));
-      // ===============================
-      // Standard Library: array/*
-      // ===============================
-      case "array/len":
-        return evalArrayLen(args, evaluate2, ctx);
-      case "array/range":
-        return evalArrayRange(args, evaluate2, ctx);
-      case "array/empty?":
-        return evalArrayEmpty(args, evaluate2, ctx);
-      case "array/first":
-        return evalArrayFirst(args, evaluate2, ctx);
-      case "array/last":
-        return evalArrayLast(args, evaluate2, ctx);
-      case "array/nth":
-        return evalArrayNth(args, evaluate2, ctx);
-      case "array/slice":
-        return evalArraySlice(args, evaluate2, ctx);
-      case "array/concat":
-        return evalArrayConcat(args, evaluate2, ctx);
-      case "array/append":
-        return evalArrayAppend(args, evaluate2, ctx);
-      case "array/prepend":
-        return evalArrayPrepend(args, evaluate2, ctx);
-      case "array/insert":
-        return evalArrayInsert(args, evaluate2, ctx);
-      case "array/remove":
-        return evalArrayRemove(args, evaluate2, ctx);
-      case "array/removeItem":
-        return evalArrayRemoveItem(args, evaluate2, ctx);
-      case "array/reverse":
-        return evalArrayReverse(args, evaluate2, ctx);
-      case "array/sort":
-        return evalArraySort(args, evaluate2, ctx);
-      case "array/shuffle":
-        return evalArrayShuffle(args, evaluate2, ctx);
-      case "array/unique":
-        return evalArrayUnique(args, evaluate2, ctx);
-      case "array/flatten":
-        return evalArrayFlatten(args, evaluate2, ctx);
-      case "array/zip":
-        return evalArrayZip(args, evaluate2, ctx);
-      case "array/includes":
-        return evalArrayIncludes(args, evaluate2, ctx);
-      case "array/indexOf":
-        return evalArrayIndexOf(args, evaluate2, ctx);
-      case "array/find":
-        return evalArrayFind(args, evaluate2, ctx);
-      case "array/findIndex":
-        return evalArrayFindIndex(args, evaluate2, ctx);
-      case "array/filter":
-        return evalArrayFilter(args, evaluate2, ctx);
-      case "array/reject":
-        return evalArrayReject(args, evaluate2, ctx);
-      case "array/map":
-        return evalArrayMap(args, evaluate2, ctx);
-      case "array/reduce":
-        return evalArrayReduce(args, evaluate2, ctx);
-      case "array/every":
-        return evalArrayEvery(args, evaluate2, ctx);
-      case "array/some":
-        return evalArraySome(args, evaluate2, ctx);
-      case "array/count":
-        return evalArrayCount(args, evaluate2, ctx);
-      case "array/sum":
-        return evalArraySum(args, evaluate2, ctx);
-      case "array/avg":
-        return evalArrayAvg(args, evaluate2, ctx);
-      case "array/min":
-        return evalArrayMin(args, evaluate2, ctx);
-      case "array/max":
-        return evalArrayMax(args, evaluate2, ctx);
-      case "array/groupBy":
-        return evalArrayGroupBy(args, evaluate2, ctx);
-      case "array/partition":
-        return evalArrayPartition(args, evaluate2, ctx);
-      case "array/take":
-        return evalArrayTake(args, evaluate2, ctx);
-      case "array/drop":
-        return evalArrayDrop(args, evaluate2, ctx);
-      case "array/takeLast":
-        return evalArrayTakeLast(args, evaluate2, ctx);
-      case "array/dropLast":
-        return evalArrayDropLast(args, evaluate2, ctx);
-      case "array/cosine":
-        return evalArrayCosine(args, evaluate2, ctx);
-      case "array/nearest":
-        return evalArrayNearest(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: object/*
-      // ===============================
-      case "object/keys":
-        return evalObjectKeys(args, evaluate2, ctx);
-      case "object/values":
-        return evalObjectValues(args, evaluate2, ctx);
-      case "object/entries":
-        return evalObjectEntries(args, evaluate2, ctx);
-      case "object/fromEntries":
-        return evalObjectFromEntries(args, evaluate2, ctx);
-      case "object/get":
-        return evalObjectGet(args, evaluate2, ctx);
-      case "object/set":
-        return evalObjectSet(args, evaluate2, ctx);
-      case "object/has":
-        return evalObjectHas(args, evaluate2, ctx);
-      case "object/merge":
-        return evalObjectMerge(args, evaluate2, ctx);
-      case "object/deepMerge":
-        return evalObjectDeepMerge(args, evaluate2, ctx);
-      case "object/pick":
-        return evalObjectPick(args, evaluate2, ctx);
-      case "object/omit":
-        return evalObjectOmit(args, evaluate2, ctx);
-      case "object/mapValues":
-        return evalObjectMapValues(args, evaluate2, ctx);
-      case "object/mapKeys":
-        return evalObjectMapKeys(args, evaluate2, ctx);
-      case "object/filter":
-        return evalObjectFilter(args, evaluate2, ctx);
-      case "object/empty?":
-        return evalObjectEmpty(args, evaluate2, ctx);
-      case "object/equals":
-        return evalObjectEquals(args, evaluate2, ctx);
-      case "object/clone":
-        return evalObjectClone(args, evaluate2, ctx);
-      case "object/deepClone":
-        return evalObjectDeepClone(args, evaluate2, ctx);
-      // Path operator (for dynamic field access)
-      case "path":
-        return evalPath(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: validate/*
-      // ===============================
-      case "validate/required":
-        return evalValidateRequired(args, evaluate2, ctx);
-      case "validate/string":
-        return evalValidateString(args, evaluate2, ctx);
-      case "validate/number":
-        return evalValidateNumber(args, evaluate2, ctx);
-      case "validate/boolean":
-        return evalValidateBoolean(args, evaluate2, ctx);
-      case "validate/array":
-        return evalValidateArray(args, evaluate2, ctx);
-      case "validate/object":
-        return evalValidateObject(args, evaluate2, ctx);
-      case "validate/email":
-        return evalValidateEmail(args, evaluate2, ctx);
-      case "validate/url":
-        return evalValidateUrl(args, evaluate2, ctx);
-      case "validate/uuid":
-        return evalValidateUuid(args, evaluate2, ctx);
-      case "validate/phone":
-        return evalValidatePhone(args, evaluate2, ctx);
-      case "validate/creditCard":
-        return evalValidateCreditCard(args, evaluate2, ctx);
-      case "validate/date":
-        return evalValidateDate(args, evaluate2, ctx);
-      case "validate/minLength":
-        return evalValidateMinLength(args, evaluate2, ctx);
-      case "validate/maxLength":
-        return evalValidateMaxLength(args, evaluate2, ctx);
-      case "validate/length":
-        return evalValidateLength(args, evaluate2, ctx);
-      case "validate/min":
-        return evalValidateMin(args, evaluate2, ctx);
-      case "validate/max":
-        return evalValidateMax(args, evaluate2, ctx);
-      case "validate/range":
-        return evalValidateRange(args, evaluate2, ctx);
-      case "validate/pattern":
-        return evalValidatePattern(args, evaluate2, ctx);
-      case "validate/oneOf":
-        return evalValidateOneOf(args, evaluate2, ctx);
-      case "validate/noneOf":
-        return evalValidateNoneOf(args, evaluate2, ctx);
-      case "validate/equals":
-        return evalValidateEquals(args, evaluate2, ctx);
-      case "validate/check":
-        return evalValidateCheck(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: time/*
-      // ===============================
-      case "time/now":
-        return evalTimeNow();
-      case "time/today":
-        return evalTimeToday();
-      case "time/parse":
-        return evalTimeParse(args, evaluate2, ctx);
-      case "time/format":
-        return evalTimeFormat(args, evaluate2, ctx);
-      case "time/year":
-        return evalTimeYear(args, evaluate2, ctx);
-      case "time/month":
-        return evalTimeMonth(args, evaluate2, ctx);
-      case "time/day":
-        return evalTimeDay(args, evaluate2, ctx);
-      case "time/weekday":
-        return evalTimeWeekday(args, evaluate2, ctx);
-      case "time/hour":
-        return evalTimeHour(args, evaluate2, ctx);
-      case "time/minute":
-        return evalTimeMinute(args, evaluate2, ctx);
-      case "time/second":
-        return evalTimeSecond(args, evaluate2, ctx);
-      case "time/add":
-        return evalTimeAdd(args, evaluate2, ctx);
-      case "time/subtract":
-        return evalTimeSubtract(args, evaluate2, ctx);
-      case "time/diff":
-        return evalTimeDiff(args, evaluate2, ctx);
-      case "time/startOf":
-        return evalTimeStartOf(args, evaluate2, ctx);
-      case "time/endOf":
-        return evalTimeEndOf(args, evaluate2, ctx);
-      case "time/isBefore":
-        return evalTimeIsBefore(args, evaluate2, ctx);
-      case "time/isAfter":
-        return evalTimeIsAfter(args, evaluate2, ctx);
-      case "time/isBetween":
-        return evalTimeIsBetween(args, evaluate2, ctx);
-      case "time/isSame":
-        return evalTimeIsSame(args, evaluate2, ctx);
-      case "time/isPast":
-        return evalTimeIsPast(args, evaluate2, ctx);
-      case "time/isFuture":
-        return evalTimeIsFuture(args, evaluate2, ctx);
-      case "time/isToday":
-        return evalTimeIsToday(args, evaluate2, ctx);
-      case "time/relative":
-        return evalTimeRelative(args, evaluate2, ctx);
-      case "time/duration":
-        return evalTimeDuration(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: format/*
-      // ===============================
-      case "format/number":
-        return evalFormatNumber(args, evaluate2, ctx);
-      case "format/currency":
-        return evalFormatCurrency(args, evaluate2, ctx);
-      case "format/percent":
-        return evalFormatPercent(args, evaluate2, ctx);
-      case "format/bytes":
-        return evalFormatBytes(args, evaluate2, ctx);
-      case "format/ordinal":
-        return evalFormatOrdinal(args, evaluate2, ctx);
-      case "format/plural":
-        return evalFormatPlural(args, evaluate2, ctx);
-      case "format/list":
-        return evalFormatList(args, evaluate2, ctx);
-      case "format/phone":
-        return evalFormatPhone(args, evaluate2, ctx);
-      case "format/creditCard":
-        return evalFormatCreditCard(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: async/*
-      // ===============================
-      case "async/delay":
-        return evalAsyncDelay(args, evaluate2, ctx);
-      case "async/interval":
-        return evalAsyncInterval(args, evaluate2, ctx);
-      case "async/timeout":
-        return evalAsyncTimeout(args, evaluate2, ctx);
-      case "async/debounce":
-        evalAsyncDebounce(args, evaluate2, ctx);
-        return void 0;
-      case "async/throttle":
-        evalAsyncThrottle(args, evaluate2, ctx);
-        return void 0;
-      case "async/retry":
-        return evalAsyncRetry(args, evaluate2, ctx);
-      case "async/race":
-        return evalAsyncRace(args, evaluate2, ctx);
-      case "async/all":
-        return evalAsyncAll(args, evaluate2, ctx);
-      case "async/sequence":
-        return evalAsyncSequence(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: prob/*
-      // ===============================
-      case "prob/seed":
-        evalProbSeed(args, evaluate2, ctx);
-        return void 0;
-      case "prob/flip":
-        return evalProbFlip(args, evaluate2, ctx);
-      case "prob/gaussian":
-        return evalProbGaussian(args, evaluate2, ctx);
-      case "prob/uniform":
-        return evalProbUniform(args, evaluate2, ctx);
-      case "prob/beta":
-        return evalProbBeta(args, evaluate2, ctx);
-      case "prob/categorical":
-        return evalProbCategorical(args, evaluate2, ctx);
-      case "prob/poisson":
-        return evalProbPoisson(args, evaluate2, ctx);
-      case "prob/condition":
-        evalProbCondition(args, evaluate2, ctx);
-        return void 0;
-      case "prob/sample":
-        return evalProbSample(args, evaluate2, ctx);
-      case "prob/posterior":
-        return evalProbPosterior(args, evaluate2, ctx);
-      case "prob/infer":
-        return evalProbInfer(args, evaluate2, ctx);
-      case "prob/expected-value":
-        return evalProbExpectedValue(args, evaluate2, ctx);
-      case "prob/variance":
-        return evalProbVariance(args, evaluate2, ctx);
-      case "prob/histogram":
-        return evalProbHistogram(args, evaluate2, ctx);
-      case "prob/percentile":
-        return evalProbPercentile(args, evaluate2, ctx);
-      case "prob/credible-interval":
-        return evalProbCredibleInterval(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: os/*
-      // ===============================
-      case "os/watch-files":
-        evalOsWatchFiles(args, evaluate2, ctx);
-        return void 0;
-      case "os/watch-process":
-        evalOsWatchProcess(args, evaluate2, ctx);
-        return void 0;
-      case "os/watch-port":
-        evalOsWatchPort(args, evaluate2, ctx);
-        return void 0;
-      case "os/watch-http":
-        evalOsWatchHttp(args, evaluate2, ctx);
-        return void 0;
-      case "os/watch-cron":
-        evalOsWatchCron(args, evaluate2, ctx);
-        return void 0;
-      case "os/watch-signal":
-        evalOsWatchSignal(args, evaluate2, ctx);
-        return void 0;
-      case "os/watch-env":
-        evalOsWatchEnv(args, evaluate2, ctx);
-        return void 0;
-      case "os/debounce":
-        evalOsDebounce(args, evaluate2, ctx);
-        return void 0;
-      // ===============================
-      // Standard Library: llm/*
-      // ===============================
-      case "llm/generate":
-        return evalLlmGenerate(args, evaluate2, ctx);
-      case "llm/call-tools":
-        return evalLlmCallTools(args, evaluate2, ctx);
-      case "llm/embed":
-        return evalLlmEmbed(args, evaluate2, ctx);
-      case "llm/token-count":
-        return evalLlmTokenCount(args, evaluate2, ctx);
-      case "llm/switch":
-        return evalLlmSwitch(args, evaluate2, ctx);
-      case "llm/compact":
-        return evalLlmCompact(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: workspace/*
-      // ===============================
-      case "workspace/read-orbital":
-        return evalWorkspaceReadOrbital(args, evaluate2, ctx);
-      case "workspace/write-orbital":
-        return evalWorkspaceWriteOrbital(args, evaluate2, ctx);
-      case "workspace/read-file":
-        return evalWorkspaceReadFile(args, evaluate2, ctx);
-      case "workspace/write-file":
-        return evalWorkspaceWriteFile(args, evaluate2, ctx);
-      case "workspace/exists":
-        return evalWorkspaceExists(args, evaluate2, ctx);
-      case "workspace/list-orbitals":
-        return evalWorkspaceListOrbitals(args, evaluate2, ctx);
-      case "workspace/read-schema":
-        return evalWorkspaceReadSchema(args, evaluate2, ctx);
-      case "workspace/write-schema":
-        return evalWorkspaceWriteSchema(args, evaluate2, ctx);
-      case "workspace/read-plan":
-        return evalWorkspaceReadPlan(args, evaluate2, ctx);
-      case "workspace/write-plan":
-        return evalWorkspaceWritePlan(args, evaluate2, ctx);
-      case "workspace/archive-orbital":
-        return evalWorkspaceArchiveOrbital(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: session/*
-      // ===============================
-      case "session/read-spec":
-        return evalSessionReadSpec(args, evaluate2, ctx);
-      case "session/write-spec":
-        return evalSessionWriteSpec(args, evaluate2, ctx);
-      case "session/read-memory":
-        return evalSessionReadMemory(args, evaluate2, ctx);
-      case "session/write-memory":
-        return evalSessionWriteMemory(args, evaluate2, ctx);
-      case "session/read-history":
-        return evalSessionReadHistory(args, evaluate2, ctx);
-      case "session/append-history":
-        return evalSessionAppendHistory(args, evaluate2, ctx);
-      case "session/read-errors":
-        return evalSessionReadErrors(args, evaluate2, ctx);
-      case "session/write-errors":
-        return evalSessionWriteErrors(args, evaluate2, ctx);
-      case "session/read-analysis":
-        return evalSessionReadAnalysis(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: memory/*
-      // ===============================
-      case "memory/recall":
-        return evalMemoryRecall(args, evaluate2, ctx);
-      case "memory/store":
-        return evalMemoryStore(args, evaluate2, ctx);
-      case "memory/list":
-        return evalMemoryList(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: trace/*
-      // ===============================
-      case "trace/emit":
-        return evalTraceEmit(args, evaluate2, ctx);
-      case "trace/log":
-        return evalTraceLog(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: integration/*
-      // ===============================
-      case "integration/http":
-        return evalIntegrationHttp(args, evaluate2, ctx);
-      case "integration/github-get-repo":
-        return evalIntegrationGithubGetRepo(args, evaluate2, ctx);
-      case "integration/github-create-issue":
-        return evalIntegrationGithubCreateIssue(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: contract/*
-      // ===============================
-      case "contract/validate-input":
-        return evalContractValidateInput(args, evaluate2, ctx);
-      case "contract/validate-output":
-        return evalContractValidateOutput(args, evaluate2, ctx);
-      case "contract/clamp-output":
-        return evalContractClampOutput(args, evaluate2, ctx);
-      case "contract/violations":
-        return evalContractViolations(args, evaluate2, ctx);
-      case "contract/entity-to-tensor":
-        return evalContractEntityToTensor(args, evaluate2, ctx);
-      case "contract/tensor-to-payload":
-        return evalContractTensorToPayload(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: graph/*
-      // ===============================
-      case "graph/from-entities":
-        return evalGraphFromEntities(args, evaluate2, ctx);
-      case "graph/from-adjacency":
-        return evalGraphFromAdjacency(args, evaluate2, ctx);
-      case "graph/from-edge-list":
-        return evalGraphFromEdgeList(args, evaluate2, ctx);
-      case "graph/add-self-loops":
-        return evalGraphAddSelfLoops(args, evaluate2, ctx);
-      case "graph/to-undirected":
-        return evalGraphToUndirected(args, evaluate2, ctx);
-      case "graph/subgraph":
-        return evalGraphSubgraph(args, evaluate2, ctx);
-      case "graph/k-hop":
-        return evalGraphKHop(args, evaluate2, ctx);
-      case "graph/node-features":
-        return evalGraphNodeFeatures(args, evaluate2, ctx);
-      case "graph/edge-index":
-        return evalGraphEdgeIndex(args, evaluate2, ctx);
-      case "graph/edge-features":
-        return evalGraphEdgeFeatures(args, evaluate2, ctx);
-      case "graph/num-nodes":
-        return evalGraphNumNodes(args, evaluate2, ctx);
-      case "graph/num-edges":
-        return evalGraphNumEdges(args, evaluate2, ctx);
-      case "graph/degree":
-        return evalGraphDegree(args, evaluate2, ctx);
-      case "graph/batch":
-        return evalGraphBatch(args, evaluate2, ctx);
-      // ===============================
-      // Standard Library: data/*
-      // ===============================
-      case "data/dataset":
-        return evalDataDataset(args, evaluate2, ctx);
-      case "data/dataloader":
-        return evalDataDataloader(args, evaluate2, ctx);
-      case "data/split":
-        return evalDataSplit(args, evaluate2, ctx);
-      case "data/normalize":
-        return evalDataNormalize(args, evaluate2, ctx);
-      case "data/augment":
-        return evalDataAugment(args, evaluate2, ctx);
-      case "data/tokenize":
-        return evalDataTokenize(args, evaluate2, ctx);
-      case "data/pad":
-        return evalDataPad(args, evaluate2, ctx);
-      default:
-        return UNKNOWN_OPERATOR;
-    }
+    const impl = OPERATOR_TABLE[op];
+    if (impl === void 0) return UNKNOWN_OPERATOR;
+    return impl(args, this.boundInterpret, ctx);
   }
 };
 var evaluator = new SExpressionEvaluator();