@almadar/evaluator 2.12.2 → 2.14.0

package/dist/index.js

@@ -21,7 +21,7 @@ function createEffectContext(base, handlers) {
 }
 function createChildContext(parent, locals) {
   const mergedLocals = new Map(parent.locals);
-  locals.forEach((value, key) => mergedLocals.set(key, value));
+  locals.forEach((value, key2) => mergedLocals.set(key2, value));
   return {
     ...parent,
     locals: mergedLocals
@@ -222,7 +222,7 @@ function deepEqual(a, b) {
     const keysB = Object.keys(b);
     if (keysA.length !== keysB.length) return false;
     return keysA.every(
-      (key) => deepEqual(a[key], b[key])
+      (key2) => deepEqual(a[key2], b[key2])
     );
   }
   return false;
@@ -518,13 +518,13 @@ function evalCallService(args, evaluate2, ctx) {
 }
 function evaluateNestedProps(obj, evaluate2, ctx) {
   const result = {};
-  for (const [key, value] of Object.entries(obj)) {
+  for (const [key2, value] of Object.entries(obj)) {
     if (Array.isArray(value) && value.length > 0 && typeof value[0] === "string") {
-      result[key] = evaluate2(value, ctx);
+      result[key2] = evaluate2(value, ctx);
     } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-      result[key] = evaluateNestedProps(value, evaluate2, ctx);
+      result[key2] = evaluateNestedProps(value, evaluate2, ctx);
     } else {
-      result[key] = value;
+      result[key2] = value;
     }
   }
   return result;
@@ -733,6 +733,50 @@ function evalMathDefault(args, evaluate2, ctx) {
   }
   return n;
 }
+function evalMathSin(args, evaluate2, ctx) {
+  return Math.sin(evaluate2(args[0], ctx));
+}
+function evalMathCos(args, evaluate2, ctx) {
+  return Math.cos(evaluate2(args[0], ctx));
+}
+function evalMathTan(args, evaluate2, ctx) {
+  return Math.tan(evaluate2(args[0], ctx));
+}
+function evalMathAtan2(args, evaluate2, ctx) {
+  const y = evaluate2(args[0], ctx);
+  const x = evaluate2(args[1], ctx);
+  return Math.atan2(y, x);
+}
+function evalMathHypot(args, evaluate2, ctx) {
+  const a = evaluate2(args[0], ctx);
+  const b = evaluate2(args[1], ctx);
+  return Math.hypot(a, b);
+}
+function evalMathDegRad(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx) * (Math.PI / 180);
+}
+function evalMathRadDeg(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx) * (180 / Math.PI);
+}
+function evalMathWrap(args, evaluate2, ctx) {
+  const v = evaluate2(args[0], ctx);
+  const min = evaluate2(args[1], ctx);
+  const max = evaluate2(args[2], ctx);
+  const r = max - min;
+  if (r <= 0) {
+    return min;
+  }
+  return min + ((v - min) % r + r) % r;
+}
+function evalMathApproach(args, evaluate2, ctx) {
+  const cur = evaluate2(args[0], ctx);
+  const target = evaluate2(args[1], ctx);
+  const maxD = evaluate2(args[2], ctx);
+  if (Math.abs(target - cur) <= maxD) {
+    return target;
+  }
+  return cur + Math.sign(target - cur) * maxD;
+}
 
 // std/str.ts
 function evalStrLen(args, evaluate2, ctx) {
@@ -871,8 +915,8 @@ function evalStrTemplate(args, evaluate2, ctx) {
   const template = evaluate2(args[0], ctx);
   const vars = evaluate2(args[1], ctx);
   if (!template) return "";
-  return template.replace(/\{(\w+)\}/g, (_, key) => {
-    const value = vars?.[key];
+  return template.replace(/\{(\w+)\}/g, (_, key2) => {
+    const value = vars?.[key2];
     return value !== void 0 ? String(value) : "";
   });
 }
@@ -896,15 +940,15 @@ function evalWithItem(expr, evaluate2, ctx, item, index) {
       const params = fnArgs[0];
       const body = fnArgs[1];
       if (typeof params === "string") {
-        const key = params.startsWith("@") ? params.slice(1) : params;
-        locals.set(key, item);
+        const key2 = params.startsWith("@") ? params.slice(1) : params;
+        locals.set(key2, item);
       } else if (Array.isArray(params)) {
         const paramNames = params;
         const values = [item, index];
         for (let i = 0; i < paramNames.length; i++) {
-          const p = paramNames[i];
-          const key = p.startsWith("@") ? p.slice(1) : p;
-          locals.set(key, values[i]);
+          const p2 = paramNames[i];
+          const key2 = p2.startsWith("@") ? p2.slice(1) : p2;
+          locals.set(key2, values[i]);
         }
       }
       const childCtx2 = createChildContext(ctx, locals);
@@ -927,13 +971,13 @@ function evalReduceLambda(lambdaExpr, evaluate2, ctx, acc, item) {
     if (Array.isArray(params)) {
       const paramNames = params;
       const values = [acc, item];
-      paramNames.forEach((p, i) => {
-        const key = p.startsWith("@") ? p.slice(1) : p;
-        locals.set(key, values[i]);
+      paramNames.forEach((p2, i) => {
+        const key2 = p2.startsWith("@") ? p2.slice(1) : p2;
+        locals.set(key2, values[i]);
       });
     } else if (typeof params === "string") {
-      const key = params.startsWith("@") ? params.slice(1) : params;
-      locals.set(key, acc);
+      const key2 = params.startsWith("@") ? params.slice(1) : params;
+      locals.set(key2, acc);
     }
     const childCtx2 = createChildContext(ctx, locals);
     return evaluate2(body, childCtx2);
@@ -1015,13 +1059,13 @@ function evalArrayReverse(args, evaluate2, ctx) {
 }
 function evalArraySort(args, evaluate2, ctx) {
   const arr = evaluate2(args[0], ctx);
-  const key = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  const key2 = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
   const dir = args.length > 2 ? evaluate2(args[2], ctx) : "asc";
   const result = [...arr ?? []];
-  if (key) {
+  if (key2) {
     result.sort((a, b) => {
-      const aVal = a[key];
-      const bVal = b[key];
+      const aVal = a[key2];
+      const bVal = b[key2];
       if (aVal < bVal) return dir === "asc" ? -1 : 1;
       if (aVal > bVal) return dir === "asc" ? 1 : -1;
       return 0;
@@ -1128,18 +1172,18 @@ function evalArrayCount(args, evaluate2, ctx) {
 }
 function evalArraySum(args, evaluate2, ctx) {
   const arr = evaluate2(args[0], ctx);
-  const key = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  const key2 = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
   return (arr ?? []).reduce((sum, item) => {
-    const value = key ? item[key] : item;
+    const value = key2 ? item[key2] : item;
     return sum + (typeof value === "number" ? value : 0);
   }, 0);
 }
 function evalArrayAvg(args, evaluate2, ctx) {
   const arr = evaluate2(args[0], ctx);
   if (!arr || arr.length === 0) return 0;
-  const key = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  const key2 = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
   const sum = arr.reduce((s, item) => {
-    const value = key ? item[key] : item;
+    const value = key2 ? item[key2] : item;
     return s + (typeof value === "number" ? value : 0);
   }, 0);
   return sum / arr.length;
@@ -1147,9 +1191,9 @@ function evalArrayAvg(args, evaluate2, ctx) {
 function evalArrayMin(args, evaluate2, ctx) {
   const arr = evaluate2(args[0], ctx);
   if (!arr || arr.length === 0) return 0;
-  const key = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  const key2 = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
   const values = arr.map((item) => {
-    const value = key ? item[key] : item;
+    const value = key2 ? item[key2] : item;
     return typeof value === "number" ? value : Infinity;
   });
   return Math.min(...values);
@@ -1157,19 +1201,19 @@ function evalArrayMin(args, evaluate2, ctx) {
 function evalArrayMax(args, evaluate2, ctx) {
   const arr = evaluate2(args[0], ctx);
   if (!arr || arr.length === 0) return 0;
-  const key = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
+  const key2 = args.length > 1 ? evaluate2(args[1], ctx) : void 0;
   const values = arr.map((item) => {
-    const value = key ? item[key] : item;
+    const value = key2 ? item[key2] : item;
     return typeof value === "number" ? value : -Infinity;
   });
   return Math.max(...values);
 }
 function evalArrayGroupBy(args, evaluate2, ctx) {
   const arr = evaluate2(args[0], ctx);
-  const key = evaluate2(args[1], ctx);
+  const key2 = evaluate2(args[1], ctx);
   const result = {};
   for (const item of arr ?? []) {
-    const groupKey = String(item[key] ?? "undefined");
+    const groupKey = String(item[key2] ?? "undefined");
     if (!result[groupKey]) {
       result[groupKey] = [];
     }
@@ -1227,8 +1271,8 @@ function evalLambda(lambdaExpr, evaluate2, ctx, ...values) {
     values.forEach((v, i) => {
       if (paramNames[i]) {
         const paramName = paramNames[i];
-        const key = paramName.startsWith("@") ? paramName.slice(1) : paramName;
-        newLocals.set(key, v);
+        const key2 = paramName.startsWith("@") ? paramName.slice(1) : paramName;
+        newLocals.set(key2, v);
       }
     });
   } else if (typeof params === "string") {
@@ -1276,7 +1320,7 @@ function evalObjectSet(args, evaluate2, ctx) {
   if (!path) return obj ?? {};
   const result = structuredClone(obj ?? {});
   const parts = path.split(".");
-  if (parts.some((p) => FORBIDDEN_KEYS.has(p))) {
+  if (parts.some((p2) => FORBIDDEN_KEYS.has(p2))) {
     return result;
   }
   let current = result;
@@ -1315,15 +1359,15 @@ function evalObjectDeepMerge(args, evaluate2, ctx) {
   const objects = args.map((a) => evaluate2(a, ctx));
   function deepMerge(target, source) {
     const result = { ...target };
-    for (const key of Object.keys(source)) {
-      if (FORBIDDEN_KEYS.has(key)) continue;
-      if (source[key] !== null && typeof source[key] === "object" && !Array.isArray(source[key]) && target[key] !== null && typeof target[key] === "object" && !Array.isArray(target[key])) {
-        result[key] = deepMerge(
-          target[key],
-          source[key]
+    for (const key2 of Object.keys(source)) {
+      if (FORBIDDEN_KEYS.has(key2)) continue;
+      if (source[key2] !== null && typeof source[key2] === "object" && !Array.isArray(source[key2]) && target[key2] !== null && typeof target[key2] === "object" && !Array.isArray(target[key2])) {
+        result[key2] = deepMerge(
+          target[key2],
+          source[key2]
         );
       } else {
-        result[key] = source[key];
+        result[key2] = source[key2];
       }
     }
     return result;
@@ -1334,9 +1378,9 @@ function evalObjectPick(args, evaluate2, ctx) {
   const obj = evaluate2(args[0], ctx);
   const keys = evaluate2(args[1], ctx);
   const result = {};
-  for (const key of keys ?? []) {
-    if (obj && Object.prototype.hasOwnProperty.call(obj, key)) {
-      result[key] = obj[key];
+  for (const key2 of keys ?? []) {
+    if (obj && Object.prototype.hasOwnProperty.call(obj, key2)) {
+      result[key2] = obj[key2];
     }
   }
   return result;
@@ -1346,9 +1390,9 @@ function evalObjectOmit(args, evaluate2, ctx) {
   const keys = evaluate2(args[1], ctx);
   const keysSet = new Set(keys ?? []);
   const result = {};
-  for (const key of Object.keys(obj ?? {})) {
-    if (!keysSet.has(key)) {
-      result[key] = obj[key];
+  for (const key2 of Object.keys(obj ?? {})) {
+    if (!keysSet.has(key2)) {
+      result[key2] = obj[key2];
     }
   }
   return result;
@@ -1357,8 +1401,8 @@ function evalObjectMapValues(args, evaluate2, ctx) {
   const obj = evaluate2(args[0], ctx);
   const lambda = args[1];
   const result = {};
-  for (const [key, value] of Object.entries(obj ?? {})) {
-    result[key] = evalLambda(lambda, evaluate2, ctx, value);
+  for (const [key2, value] of Object.entries(obj ?? {})) {
+    result[key2] = evalLambda(lambda, evaluate2, ctx, value);
   }
   return result;
 }
@@ -1366,8 +1410,8 @@ function evalObjectMapKeys(args, evaluate2, ctx) {
   const obj = evaluate2(args[0], ctx);
   const lambda = args[1];
   const result = {};
-  for (const [key, value] of Object.entries(obj ?? {})) {
-    const newKey = String(evalLambda(lambda, evaluate2, ctx, key));
+  for (const [key2, value] of Object.entries(obj ?? {})) {
+    const newKey = String(evalLambda(lambda, evaluate2, ctx, key2));
     result[newKey] = value;
   }
   return result;
@@ -1376,9 +1420,9 @@ function evalObjectFilter(args, evaluate2, ctx) {
   const obj = evaluate2(args[0], ctx);
   const lambda = args[1];
   const result = {};
-  for (const [key, value] of Object.entries(obj ?? {})) {
-    if (evalLambda(lambda, evaluate2, ctx, key, value)) {
-      result[key] = value;
+  for (const [key2, value] of Object.entries(obj ?? {})) {
+    if (evalLambda(lambda, evaluate2, ctx, key2, value)) {
+      result[key2] = value;
     }
   }
   return result;
@@ -1398,8 +1442,8 @@ function evalObjectEquals(args, evaluate2, ctx) {
     const xKeys = Object.keys(x);
     const yKeys = Object.keys(y);
     if (xKeys.length !== yKeys.length) return false;
-    for (const key of xKeys) {
-      if (!deepEqual2(x[key], y[key])) {
+    for (const key2 of xKeys) {
+      if (!deepEqual2(x[key2], y[key2])) {
         return false;
       }
     }
@@ -1577,8 +1621,8 @@ function evalValidateEquals(args, evaluate2, ctx) {
     const xKeys = Object.keys(x);
     const yKeys = Object.keys(y);
     if (xKeys.length !== yKeys.length) return false;
-    for (const key of xKeys) {
-      if (!deepEqual2(x[key], y[key])) {
+    for (const key2 of xKeys) {
+      if (!deepEqual2(x[key2], y[key2])) {
         return false;
       }
     }
@@ -2248,8 +2292,8 @@ function evalProbSeed(args, evaluate2, ctx) {
   ctx._probSeed = { state: n | 0 };
 }
 function evalProbFlip(args, evaluate2, ctx) {
-  const p = evaluate2(args[0], ctx);
-  return getRandom(ctx) < p;
+  const p2 = evaluate2(args[0], ctx);
+  return getRandom(ctx) < p2;
 }
 function evalProbGaussian(args, evaluate2, ctx) {
   const mu = evaluate2(args[0], ctx);
@@ -2283,11 +2327,11 @@ function evalProbPoisson(args, evaluate2, ctx) {
   const lambda = evaluate2(args[0], ctx);
   const limit = Math.exp(-lambda);
   let k = 0;
-  let p = 1;
+  let p2 = 1;
   do {
     k++;
-    p *= getRandom(ctx);
-  } while (p > limit);
+    p2 *= getRandom(ctx);
+  } while (p2 > limit);
   return k - 1;
 }
 function evalProbCondition(args, evaluate2, ctx) {
@@ -2399,10 +2443,10 @@ function evalProbHistogram(args, evaluate2, ctx) {
 }
 function evalProbPercentile(args, evaluate2, ctx) {
   const samples = evaluate2(args[0], ctx);
-  const p = evaluate2(args[1], ctx);
+  const p2 = evaluate2(args[1], ctx);
   if (samples.length === 0) return 0;
   const sorted = [...samples].sort((a, b) => a - b);
-  const idx = p / 100 * (sorted.length - 1);
+  const idx = p2 / 100 * (sorted.length - 1);
   const lo = Math.floor(idx);
   const hi = Math.ceil(idx);
   if (lo === hi) return sorted[lo];
@@ -2575,6 +2619,948 @@ function evalAgentSearchCode(args, evaluate2, ctx) {
   return ctx.agent.searchCode(query, language);
 }
 
+// std/vector.ts
+function asVec(v) {
+  const o = v ?? {};
+  const x = typeof o.x === "number" ? o.x : 0;
+  const y = typeof o.y === "number" ? o.y : 0;
+  const z2 = typeof o.z === "number" ? o.z : void 0;
+  return z2 === void 0 ? { x, y } : { x, y, z: z2 };
+}
+function has3(v) {
+  return v.z !== void 0;
+}
+function z(v) {
+  return v.z ?? 0;
+}
+function make(x, y, zVal, is3d) {
+  return is3d ? { x, y, z: zVal } : { x, y };
+}
+function evalVecAdd(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  return make(a.x + b.x, a.y + b.y, z(a) + z(b), has3(a));
+}
+function evalVecSub(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  return make(a.x - b.x, a.y - b.y, z(a) - z(b), has3(a));
+}
+function evalVecScale(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const k = evaluate2(args[1], ctx);
+  return make(a.x * k, a.y * k, z(a) * k, has3(a));
+}
+function evalVecDot(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  return a.x * b.x + a.y * b.y + z(a) * z(b);
+}
+function evalVecCross(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  if (has3(a)) {
+    const ax = a.x, ay = a.y, az = z(a);
+    const bx = b.x, by = b.y, bz = z(b);
+    return { x: ay * bz - az * by, y: az * bx - ax * bz, z: ax * by - ay * bx };
+  }
+  return a.x * b.y - a.y * b.x;
+}
+function evalVecLength(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  return Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+}
+function evalVecLengthSq(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  return a.x * a.x + a.y * a.y + z(a) * z(a);
+}
+function evalVecNormalize(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const len = Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+  if (len === 0) {
+    return make(0, 0, 0, has3(a));
+  }
+  return make(a.x / len, a.y / len, z(a) / len, has3(a));
+}
+function evalVecDistance(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  const dx = a.x - b.x, dy = a.y - b.y, dz = z(a) - z(b);
+  return Math.sqrt(dx * dx + dy * dy + dz * dz);
+}
+function evalVecDistanceSq(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  const dx = a.x - b.x, dy = a.y - b.y, dz = z(a) - z(b);
+  return dx * dx + dy * dy + dz * dz;
+}
+function evalVecLerp(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const b = asVec(evaluate2(args[1], ctx));
+  const t = evaluate2(args[2], ctx);
+  return make(
+    a.x + (b.x - a.x) * t,
+    a.y + (b.y - a.y) * t,
+    z(a) + (z(b) - z(a)) * t,
+    has3(a)
+  );
+}
+function evalVecAngle(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  if (args.length < 2) {
+    return Math.atan2(a.y, a.x);
+  }
+  const b = asVec(evaluate2(args[1], ctx));
+  const la = Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+  const lb = Math.sqrt(b.x * b.x + b.y * b.y + z(b) * z(b));
+  if (la === 0 || lb === 0) {
+    return 0;
+  }
+  const d = (a.x * b.x + a.y * b.y + z(a) * z(b)) / (la * lb);
+  const clamped = Math.min(Math.max(d, -1), 1);
+  return Math.acos(clamped);
+}
+function evalVecRotate(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const rad = evaluate2(args[1], ctx);
+  const c = Math.cos(rad), s = Math.sin(rad);
+  return make(a.x * c - a.y * s, a.x * s + a.y * c, z(a), has3(a));
+}
+function evalVecClampLength(args, evaluate2, ctx) {
+  const a = asVec(evaluate2(args[0], ctx));
+  const max = evaluate2(args[1], ctx);
+  const len = Math.sqrt(a.x * a.x + a.y * a.y + z(a) * z(a));
+  if (len > max) {
+    if (len === 0) {
+      return make(0, 0, 0, has3(a));
+    }
+    const k = max / len;
+    return make(a.x * k, a.y * k, z(a) * k, has3(a));
+  }
+  return make(a.x, a.y, z(a), has3(a));
+}
+
+// std/geo.ts
+function num(o, k) {
+  return typeof o[k] === "number" ? o[k] : 0;
+}
+function asVec2(v) {
+  const o = v ?? {};
+  const z2 = typeof o.z === "number" ? o.z : void 0;
+  return z2 === void 0 ? { x: num(o, "x"), y: num(o, "y") } : { x: num(o, "x"), y: num(o, "y"), z: z2 };
+}
+function asRect(v) {
+  const o = v ?? {};
+  return { x: num(o, "x"), y: num(o, "y"), w: num(o, "w"), h: num(o, "h") };
+}
+function asCircle(v) {
+  const o = v ?? {};
+  return { x: num(o, "x"), y: num(o, "y"), r: num(o, "r") };
+}
+function asSegment(v) {
+  const o = v ?? {};
+  return { x1: num(o, "x1"), y1: num(o, "y1"), x2: num(o, "x2"), y2: num(o, "y2") };
+}
+function clamp(n, lo, hi) {
+  return Math.min(Math.max(n, lo), hi);
+}
+function evalGeoAabbOverlap(args, evaluate2, ctx) {
+  const a = asRect(evaluate2(args[0], ctx));
+  const b = asRect(evaluate2(args[1], ctx));
+  return a.x < b.x + b.w && a.x + a.w > b.x && a.y < b.y + b.h && a.y + a.h > b.y;
+}
+function evalGeoCircleOverlap(args, evaluate2, ctx) {
+  const a = asCircle(evaluate2(args[0], ctx));
+  const b = asCircle(evaluate2(args[1], ctx));
+  const dx = a.x - b.x, dy = a.y - b.y;
+  return Math.sqrt(dx * dx + dy * dy) <= a.r + b.r;
+}
+function evalGeoRectCircleOverlap(args, evaluate2, ctx) {
+  const r = asRect(evaluate2(args[0], ctx));
+  const c = asCircle(evaluate2(args[1], ctx));
+  const cx = clamp(c.x, r.x, r.x + r.w);
+  const cy = clamp(c.y, r.y, r.y + r.h);
+  const dx = c.x - cx, dy = c.y - cy;
+  return dx * dx + dy * dy <= c.r * c.r;
+}
+function evalGeoPointInRect(args, evaluate2, ctx) {
+  const p2 = asVec2(evaluate2(args[0], ctx));
+  const r = asRect(evaluate2(args[1], ctx));
+  return p2.x >= r.x && p2.x <= r.x + r.w && p2.y >= r.y && p2.y <= r.y + r.h;
+}
+function evalGeoPointInCircle(args, evaluate2, ctx) {
+  const p2 = asVec2(evaluate2(args[0], ctx));
+  const c = asCircle(evaluate2(args[1], ctx));
+  const dx = p2.x - c.x, dy = p2.y - c.y;
+  return dx * dx + dy * dy <= c.r * c.r;
+}
+function evalGeoReflect(args, evaluate2, ctx) {
+  const v = asVec2(evaluate2(args[0], ctx));
+  const n = asVec2(evaluate2(args[1], ctx));
+  const is3d = v.z !== void 0;
+  const vz = v.z ?? 0, nz = n.z ?? 0;
+  const d = v.x * n.x + v.y * n.y + vz * nz;
+  const rx = v.x - n.x * 2 * d;
+  const ry = v.y - n.y * 2 * d;
+  const rz = vz - nz * 2 * d;
+  return is3d ? { x: rx, y: ry, z: rz } : { x: rx, y: ry };
+}
+function evalGeoSegmentIntersect(args, evaluate2, ctx) {
+  const s1 = asSegment(evaluate2(args[0], ctx));
+  const s2 = asSegment(evaluate2(args[1], ctx));
+  const r_x = s1.x2 - s1.x1, r_y = s1.y2 - s1.y1;
+  const s_x = s2.x2 - s2.x1, s_y = s2.y2 - s2.y1;
+  const denom = r_x * s_y - r_y * s_x;
+  if (denom === 0) {
+    return null;
+  }
+  const qpx = s2.x1 - s1.x1, qpy = s2.y1 - s1.y1;
+  const t = (qpx * s_y - qpy * s_x) / denom;
+  const u = (qpx * r_y - qpy * r_x) / denom;
+  if (t < 0 || t > 1 || u < 0 || u > 1) {
+    return null;
+  }
+  return { x: s1.x1 + t * r_x, y: s1.y1 + t * r_y };
+}
+
+// std/grid.ts
+function num2(o, k) {
+  return typeof o[k] === "number" ? o[k] : 0;
+}
+function asCell(v) {
+  const o = v ?? {};
+  return { x: num2(o, "x"), y: num2(o, "y") };
+}
+function evalGridToWorld(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const cellSize = evaluate2(args[1], ctx);
+  return { x: (cell.x + 0.5) * cellSize, y: (cell.y + 0.5) * cellSize };
+}
+function evalGridFromWorld(args, evaluate2, ctx) {
+  const point = asCell(evaluate2(args[0], ctx));
+  const cellSize = evaluate2(args[1], ctx);
+  return { x: Math.floor(point.x / cellSize), y: Math.floor(point.y / cellSize) };
+}
+function evalGridIsoToScreen(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const tileW = evaluate2(args[1], ctx);
+  const tileH = evaluate2(args[2], ctx);
+  return { x: (cell.x - cell.y) * tileW / 2, y: (cell.x + cell.y) * tileH / 2 };
+}
+function evalGridScreenToIso(args, evaluate2, ctx) {
+  const point = asCell(evaluate2(args[0], ctx));
+  const tileW = evaluate2(args[1], ctx);
+  const tileH = evaluate2(args[2], ctx);
+  const halfW = tileW / 2;
+  const halfH = tileH / 2;
+  return {
+    x: (point.x / halfW + point.y / halfH) / 2,
+    y: (point.y / halfH - point.x / halfW) / 2
+  };
+}
+function evalGridDistance(args, evaluate2, ctx) {
+  const a = asCell(evaluate2(args[0], ctx));
+  const b = asCell(evaluate2(args[1], ctx));
+  return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
+}
+function evalGridManhattanDistance(args, evaluate2, ctx) {
+  const a = asCell(evaluate2(args[0], ctx));
+  const b = asCell(evaluate2(args[1], ctx));
+  return Math.abs(a.x - b.x) + Math.abs(a.y - b.y);
+}
+function evalGridNeighbors(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const diagonal = args.length > 1 ? Boolean(evaluate2(args[1], ctx)) : false;
+  const result = [
+    { x: cell.x, y: cell.y - 1 },
+    // N
+    { x: cell.x + 1, y: cell.y },
+    // E
+    { x: cell.x, y: cell.y + 1 },
+    // S
+    { x: cell.x - 1, y: cell.y }
+    // W
+  ];
+  if (diagonal) {
+    result.push(
+      { x: cell.x + 1, y: cell.y - 1 },
+      // NE
+      { x: cell.x + 1, y: cell.y + 1 },
+      // SE
+      { x: cell.x - 1, y: cell.y + 1 },
+      // SW
+      { x: cell.x - 1, y: cell.y - 1 }
+      // NW
+    );
+  }
+  return result;
+}
+function evalGridCellsInRadius(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const r = evaluate2(args[1], ctx);
+  const rf = Math.floor(r);
+  const r2 = r * r;
+  const result = [];
+  for (let dy = -rf; dy <= rf; dy++) {
+    for (let dx = -rf; dx <= rf; dx++) {
+      if (dx * dx + dy * dy <= r2) {
+        result.push({ x: cell.x + dx, y: cell.y + dy });
+      }
+    }
+  }
+  return result;
+}
+function evalGridLine(args, evaluate2, ctx) {
+  const a = asCell(evaluate2(args[0], ctx));
+  const b = asCell(evaluate2(args[1], ctx));
+  let x0 = a.x, y0 = a.y;
+  const x1 = b.x, y1 = b.y;
+  const dx = Math.abs(x1 - x0);
+  const dy = Math.abs(y1 - y0);
+  const sx = x0 < x1 ? 1 : -1;
+  const sy = y0 < y1 ? 1 : -1;
+  let err = dx - dy;
+  const result = [];
+  for (; ; ) {
+    result.push({ x: x0, y: y0 });
+    if (x0 === x1 && y0 === y1) {
+      break;
+    }
+    const e2 = 2 * err;
+    if (e2 > -dy) {
+      err -= dy;
+      x0 += sx;
+    }
+    if (e2 < dx) {
+      err += dx;
+      y0 += sy;
+    }
+  }
+  return result;
+}
+function evalGridInBounds(args, evaluate2, ctx) {
+  const cell = asCell(evaluate2(args[0], ctx));
+  const w = evaluate2(args[1], ctx);
+  const h = evaluate2(args[2], ctx);
+  return cell.x >= 0 && cell.x < w && cell.y >= 0 && cell.y < h;
+}
+
+// std/anim.ts
+function evalAnimFrameAt(args, evaluate2, ctx) {
+  const elapsed = evaluate2(args[0], ctx);
+  const frameDur = evaluate2(args[1], ctx);
+  const frameCount = evaluate2(args[2], ctx);
+  const loop = args.length > 3 ? Boolean(evaluate2(args[3], ctx)) : true;
+  if (frameCount <= 0) {
+    return 0;
+  }
+  const i = Math.floor(elapsed / frameDur);
+  if (loop) {
+    return (i % frameCount + frameCount) % frameCount;
+  }
+  return Math.min(i, frameCount - 1);
+}
+function evalAnimSheetRect(args, evaluate2, ctx) {
+  const frameIndex = evaluate2(args[0], ctx);
+  const cols = evaluate2(args[1], ctx);
+  const frameW = evaluate2(args[2], ctx);
+  const frameH = evaluate2(args[3], ctx);
+  return {
+    sx: frameIndex % cols * frameW,
+    sy: Math.floor(frameIndex / cols) * frameH,
+    sw: frameW,
+    sh: frameH
+  };
+}
+function evalAnimDirectionFromDelta(args, evaluate2, ctx) {
+  const dx = evaluate2(args[0], ctx);
+  const dy = evaluate2(args[1], ctx);
+  const ways = args.length > 2 ? evaluate2(args[2], ctx) : 4;
+  const angle = Math.atan2(dy, dx);
+  if (ways === 8) {
+    const sector2 = Math.round(angle / (Math.PI / 4));
+    const idx2 = (sector2 % 8 + 8) % 8;
+    const dirs8 = [
+      "right",
+      "down-right",
+      "down",
+      "down-left",
+      "left",
+      "up-left",
+      "up",
+      "up-right"
+    ];
+    return dirs8[idx2];
+  }
+  const sector = Math.round(angle / (Math.PI / 2));
+  const idx = (sector % 4 + 4) % 4;
+  const dirs4 = ["right", "down", "left", "up"];
+  return dirs4[idx];
+}
+
+// std/ease.ts
+function clamp01(t) {
+  return Math.min(Math.max(t, 0), 1);
+}
+function applyCurve(curve, tRaw) {
+  const t = clamp01(tRaw);
+  switch (curve) {
+    case "in-quad":
+      return t * t;
+    case "out-quad":
+      return t * (2 - t);
+    case "in-out-quad":
+      return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+    case "in-cubic":
+      return t * t * t;
+    case "out-cubic": {
+      const u = t - 1;
+      return u * u * u + 1;
+    }
+    case "in-out-cubic":
+      return t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
+    case "elastic-out": {
+      if (t === 0) {
+        return 0;
+      }
+      if (t === 1) {
+        return 1;
+      }
+      const c4 = 2 * Math.PI / 3;
+      return Math.pow(2, -10 * t) * Math.sin((t * 10 - 0.75) * c4) + 1;
+    }
+    case "bounce-out": {
+      const n1 = 7.5625;
+      const d1 = 2.75;
+      let u = t;
+      if (u < 1 / d1) {
+        return n1 * u * u;
+      } else if (u < 2 / d1) {
+        u -= 1.5 / d1;
+        return n1 * u * u + 0.75;
+      } else if (u < 2.5 / d1) {
+        u -= 2.25 / d1;
+        return n1 * u * u + 0.9375;
+      } else {
+        u -= 2.625 / d1;
+        return n1 * u * u + 0.984375;
+      }
+    }
+    case "linear":
+    default:
+      return t;
+  }
+}
+function evalEaseApply(args, evaluate2, ctx) {
+  const curve = evaluate2(args[0], ctx);
+  const t = evaluate2(args[1], ctx);
+  return applyCurve(curve, t);
+}
+function evalEaseSmoothstep(args, evaluate2, ctx) {
+  const edge0 = evaluate2(args[0], ctx);
+  const edge1 = evaluate2(args[1], ctx);
+  const x = evaluate2(args[2], ctx);
+  if (edge0 === edge1) {
+    return 0;
+  }
+  const t = clamp01((x - edge0) / (edge1 - edge0));
+  return t * t * (3 - 2 * t);
+}
+
+// std/noise.ts
+var PERM = [
+  151,
+  160,
+  137,
+  91,
+  90,
+  15,
+  131,
+  13,
+  201,
+  95,
+  96,
+  53,
+  194,
+  233,
+  7,
+  225,
+  140,
+  36,
+  103,
+  30,
+  69,
+  142,
+  8,
+  99,
+  37,
+  240,
+  21,
+  10,
+  23,
+  190,
+  6,
+  148,
+  247,
+  120,
+  234,
+  75,
+  0,
+  26,
+  197,
+  62,
+  94,
+  252,
+  219,
+  203,
+  117,
+  35,
+  11,
+  32,
+  57,
+  177,
+  33,
+  88,
+  237,
+  149,
+  56,
+  87,
+  174,
+  20,
+  125,
+  136,
+  171,
+  168,
+  68,
+  175,
+  74,
+  165,
+  71,
+  134,
+  139,
+  48,
+  27,
+  166,
+  77,
+  146,
+  158,
+  231,
+  83,
+  111,
+  229,
+  122,
+  60,
+  211,
+  133,
+  230,
+  220,
+  105,
+  92,
+  41,
+  55,
+  46,
+  245,
+  40,
+  244,
+  102,
+  143,
+  54,
+  65,
+  25,
+  63,
+  161,
+  1,
+  216,
+  80,
+  73,
+  209,
+  76,
+  132,
+  187,
+  208,
+  89,
+  18,
+  169,
+  200,
+  196,
+  135,
+  130,
+  116,
+  188,
+  159,
+  86,
+  164,
+  100,
+  109,
+  198,
+  173,
+  186,
+  3,
+  64,
+  52,
+  217,
+  226,
+  250,
+  124,
+  123,
+  5,
+  202,
+  38,
+  147,
+  118,
+  126,
+  255,
+  82,
+  85,
+  212,
+  207,
+  206,
+  59,
+  227,
+  47,
+  16,
+  58,
+  17,
+  182,
+  189,
+  28,
+  42,
+  223,
+  183,
+  170,
+  213,
+  119,
+  248,
+  152,
+  2,
+  44,
+  154,
+  163,
+  70,
+  221,
+  153,
+  101,
+  155,
+  167,
+  43,
+  172,
+  9,
+  129,
+  22,
+  39,
+  253,
+  19,
+  98,
+  108,
+  110,
+  79,
+  113,
+  224,
+  232,
+  178,
+  185,
+  112,
+  104,
+  218,
+  246,
+  97,
+  228,
+  251,
+  34,
+  242,
+  193,
+  238,
+  210,
+  144,
+  12,
+  191,
+  179,
+  162,
+  241,
+  81,
+  51,
+  145,
+  235,
+  249,
+  14,
+  239,
+  107,
+  49,
+  192,
+  214,
+  31,
+  181,
+  199,
+  106,
+  157,
+  184,
+  84,
+  204,
+  176,
+  115,
+  121,
+  50,
+  45,
+  127,
+  4,
+  150,
+  254,
+  138,
+  236,
+  205,
+  93,
+  222,
+  114,
+  67,
+  29,
+  24,
+  72,
+  243,
+  141,
+  128,
+  195,
+  78,
+  66,
+  215,
+  61,
+  156,
+  180
+];
+function p(i) {
+  return PERM[i & 255];
+}
+function fade(t) {
+  return t * t * t * (t * (t * 6 - 15) + 10);
+}
+function lerp(a, b, t) {
+  return a + t * (b - a);
+}
+function grad2(hash, x, y) {
+  const h = hash & 7;
+  const u = h < 4 ? x : y;
+  const v = h < 4 ? y : x;
+  return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
+}
+function perlin(x, y, seed) {
+  const s = Math.floor(seed) & 255;
+  const X = Math.floor(x) + s & 255;
+  const Y = Math.floor(y) + s & 255;
+  const xf = x - Math.floor(x);
+  const yf = y - Math.floor(y);
+  const u = fade(xf);
+  const v = fade(yf);
+  const aa = p(p(X) + Y);
+  const ab = p(p(X) + Y + 1);
+  const ba = p(p(X + 1) + Y);
+  const bb = p(p(X + 1) + Y + 1);
+  const x1 = lerp(grad2(aa, xf, yf), grad2(ba, xf - 1, yf), u);
+  const x2 = lerp(grad2(ab, xf, yf - 1), grad2(bb, xf - 1, yf - 1), u);
+  return lerp(x1, x2, v);
+}
+function simplex(x, y, seed) {
+  return (perlin(x, y, seed) + perlin(x * 2 + 5.2, y * 2 + 1.3, seed) * 0.5 + perlin(x * 4 + 9.1, y * 4 + 7.7, seed) * 0.25) / 1.75;
+}
+function fbm(x, y, octaves, seed) {
+  let n = Math.floor(octaves);
+  if (n < 1) n = 1;
+  if (n > 8) n = 8;
+  let total = 0;
+  let freq = 1;
+  let amp = 1;
+  let max = 0;
+  for (let i = 0; i < n; i++) {
+    total += perlin(x * freq, y * freq, seed) * amp;
+    max += amp;
+    freq *= 2;
+    amp *= 0.5;
+  }
+  return total / max;
+}
+function evalNoisePerlin(args, evaluate2, ctx) {
+  const x = evaluate2(args[0], ctx);
+  const y = args.length > 1 ? evaluate2(args[1], ctx) : 0;
+  const seed = args.length > 2 ? evaluate2(args[2], ctx) : 0;
+  return perlin(x, y, seed);
+}
+function evalNoiseSimplex(args, evaluate2, ctx) {
+  const x = evaluate2(args[0], ctx);
+  const y = evaluate2(args[1], ctx);
+  const seed = args.length > 2 ? evaluate2(args[2], ctx) : 0;
+  return simplex(x, y, seed);
+}
+function evalNoiseFbm(args, evaluate2, ctx) {
+  const x = evaluate2(args[0], ctx);
+  const y = evaluate2(args[1], ctx);
+  const octaves = evaluate2(args[2], ctx);
+  const seed = args.length > 3 ? evaluate2(args[3], ctx) : 0;
+  return fbm(x, y, octaves, seed);
+}
+
+// std/path.ts
+function asCell2(v) {
+  const o = v ?? {};
+  const x = typeof o.x === "number" ? o.x : 0;
+  const y = typeof o.y === "number" ? o.y : 0;
+  return { x, y };
+}
+function key(x, y) {
+  return `${x},${y}`;
+}
+var DIRS4 = [
+  [0, -1],
+  [1, 0],
+  [0, 1],
+  [-1, 0]
+];
+var DIRS_DIAG = [
+  [1, -1],
+  [1, 1],
+  [-1, 1],
+  [-1, -1]
+];
+function neighbors(diagonal) {
+  return diagonal ? [...DIRS4, ...DIRS_DIAG] : DIRS4;
+}
+function blockedSet(blocked) {
+  const set = /* @__PURE__ */ new Set();
+  for (const b of blocked) {
+    const c = asCell2(b);
+    set.add(key(c.x, c.y));
+  }
+  return set;
+}
+function evalPathAstar(args, evaluate2, ctx) {
+  const start = asCell2(evaluate2(args[0], ctx));
+  const goal = asCell2(evaluate2(args[1], ctx));
+  const blockedArr = evaluate2(args[2], ctx) ?? [];
+  const w = evaluate2(args[3], ctx);
+  const h = evaluate2(args[4], ctx);
+  const diagonal = args.length > 5 ? Boolean(evaluate2(args[5], ctx)) : false;
+  const blocked = blockedSet(blockedArr);
+  const dirs = neighbors(diagonal);
+  const heuristic = (x, y) => {
+    const dx = Math.abs(x - goal.x);
+    const dy = Math.abs(y - goal.y);
+    return diagonal ? Math.max(dx, dy) : dx + dy;
+  };
+  const startKey = key(start.x, start.y);
+  const goalKey = key(goal.x, goal.y);
+  if (start.x < 0 || start.x >= w || start.y < 0 || start.y >= h || goal.x < 0 || goal.x >= w || goal.y < 0 || goal.y >= h || blocked.has(startKey) || blocked.has(goalKey)) {
+    return [];
+  }
+  const open = [];
+  const gScore = /* @__PURE__ */ new Map();
+  const cameFrom = /* @__PURE__ */ new Map();
+  let counter = 0;
+  gScore.set(startKey, 0);
+  open.push({
+    x: start.x,
+    y: start.y,
+    g: 0,
+    h: heuristic(start.x, start.y),
+    f: heuristic(start.x, start.y),
+    order: counter++
+  });
+  while (open.length > 0) {
+    let bestIdx = 0;
+    for (let i = 1; i < open.length; i++) {
+      const a = open[i];
+      const b = open[bestIdx];
+      if (a.f < b.f || a.f === b.f && a.h < b.h || a.f === b.f && a.h === b.h && a.order < b.order) {
+        bestIdx = i;
+      }
+    }
+    const current = open[bestIdx];
+    open.splice(bestIdx, 1);
+    const curKey = key(current.x, current.y);
+    if (curKey === goalKey) {
+      const path = [];
+      let k = curKey;
+      while (k !== void 0) {
+        const parts = k.split(",");
+        path.push({ x: Number(parts[0]), y: Number(parts[1]) });
+        k = cameFrom.get(k);
+      }
+      path.reverse();
+      return path;
+    }
+    const recordedG = gScore.get(curKey);
+    if (recordedG !== void 0 && current.g > recordedG) {
+      continue;
+    }
+    for (const [dx, dy] of dirs) {
+      const nx = current.x + dx;
+      const ny = current.y + dy;
+      if (nx < 0 || nx >= w || ny < 0 || ny >= h) {
+        continue;
+      }
+      const nKey = key(nx, ny);
+      if (blocked.has(nKey)) {
+        continue;
+      }
+      const tentativeG = current.g + 1;
+      const existingG = gScore.get(nKey);
+      if (existingG === void 0 || tentativeG < existingG) {
+        gScore.set(nKey, tentativeG);
+        cameFrom.set(nKey, curKey);
+        const nh = heuristic(nx, ny);
+        open.push({
+          x: nx,
+          y: ny,
+          g: tentativeG,
+          h: nh,
+          f: tentativeG + nh,
+          order: counter++
+        });
+      }
+    }
+  }
+  return [];
+}
+function evalPathReachable(args, evaluate2, ctx) {
+  const start = asCell2(evaluate2(args[0], ctx));
+  const steps = Math.floor(evaluate2(args[1], ctx));
+  const blockedArr = evaluate2(args[2], ctx) ?? [];
+  const w = evaluate2(args[3], ctx);
+  const h = evaluate2(args[4], ctx);
+  const diagonal = args.length > 5 ? Boolean(evaluate2(args[5], ctx)) : false;
+  const blocked = blockedSet(blockedArr);
+  const dirs = neighbors(diagonal);
+  const startKey = key(start.x, start.y);
+  const visited = /* @__PURE__ */ new Set();
+  if (start.x < 0 || start.x >= w || start.y < 0 || start.y >= h || blocked.has(startKey)) {
+    return [];
+  }
+  visited.add(startKey);
+  let frontier = [{ x: start.x, y: start.y }];
+  for (let depth = 0; depth < steps; depth++) {
+    const next = [];
+    for (const cell of frontier) {
+      for (const [dx, dy] of dirs) {
+        const nx = cell.x + dx;
+        const ny = cell.y + dy;
+        if (nx < 0 || nx >= w || ny < 0 || ny >= h) {
+          continue;
+        }
+        const nKey = key(nx, ny);
+        if (blocked.has(nKey) || visited.has(nKey)) {
+          continue;
+        }
+        visited.add(nKey);
+        next.push({ x: nx, y: ny });
+      }
+    }
+    frontier = next;
+  }
+  const result = [];
+  for (const k of visited) {
+    const parts = k.split(",");
+    result.push({ x: Number(parts[0]), y: Number(parts[1]) });
+  }
+  result.sort((a, b) => a.y !== b.y ? a.y - b.y : a.x - b.x);
+  return result;
+}
+
 // SExpressionEvaluator.ts
 var jitCache = /* @__PURE__ */ new Map();
 var MAX_JIT_CACHE_SIZE = 1e3;
@@ -2646,8 +3632,8 @@ var SExpressionEvaluator = class {
    * @returns Function that evaluates the expression given a context
    */
   compile(expr) {
-    const key = JSON.stringify(expr);
-    const cached = jitCache.get(key);
+    const key2 = JSON.stringify(expr);
+    const cached = jitCache.get(key2);
     if (cached) {
       return cached;
     }
@@ -2658,7 +3644,7 @@ var SExpressionEvaluator = class {
         jitCache.delete(firstKey);
       }
     }
-    jitCache.set(key, fn);
+    jitCache.set(key2, fn);
     return fn;
   }
   /**
@@ -2841,6 +3827,127 @@ var SExpressionEvaluator = class {
         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/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/*
       // ===============================