@almadar/evaluator 2.12.1 → 2.13.0

package/dist/{index-BNm52R6a.d.ts → index-DbN8OE5Y.d.ts}

@@ -325,6 +325,15 @@ declare function evalIncludes(args: SExpr[], evaluate: Evaluator$1, ctx: Evaluat
  * Evaluate empty: ["empty", collection]
  */
 declare function evalEmpty(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): boolean;
+/**
+ * `(list a b c …)` — literal array constructor. Evaluates each argument and
+ * returns them as a plain array. Lowering wraps a literal list bound for a
+ * literal-array slot in `list` so it is unambiguously data, never a call — the
+ * deterministic disambiguation for a list whose first element collides with an
+ * operator name (e.g. `[path method …]` would otherwise be read as the `path`
+ * operator call and collapse to a string).
+ */
+declare function evalList(args: SExpr[], evaluate: Evaluator$1, ctx: EvaluationContext): unknown[];
 
 /**
  * Effect Operator Implementations
@@ -421,4 +430,4 @@ declare function evalWatch(args: SExpr[], evaluate: Evaluator, ctx: EvaluationCo
  */
 declare function evalAtomic(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
 
-export { evalSetDynamic as $, evalGreaterThanOrEqual as A, evalIf as B, evalIncludes as C, evalIncrement as D, type EvaluationContext as E, evalLast as F, evalLessThan as G, evalLessThanOrEqual as H, evalLet as I, evalMap as J, evalMatches as K, evalMax as L, evalMin as M, evalModulo as N, evalMultiply as O, evalNavigate as P, evalNot as Q, evalNotEqual as R, evalNotify as S, evalNth as T, type UserContext as U, evalOr as V, evalPersist as W, evalRef as X, evalRenderUI as Y, evalRound as Z, evalSet as _, createEffectContext as a, evalSpawn as a0, evalSubtract as a1, evalSum as a2, evalSwap as a3, evalWatch as a4, evalWhen as a5, resolveBinding as a6, createMinimalContext as b, createChildContext as c, evalAdd as d, evalAbs as e, evalAnd as f, evalAtomic as g, evalCallService as h, evalCeil as i, evalClamp as j, evalConcat as k, evalCount as l, evalDecrement as m, evalDeref as n, evalDespawn as o, evalDivide as p, evalDo as q, evalEmit as r, evalEmpty as s, evalEqual as t, evalFilter as u, evalFind as v, evalFirst as w, evalFloor as x, evalFn as y, evalGreaterThan as z };
+export { evalSet as $, evalGreaterThanOrEqual as A, evalIf as B, evalIncludes as C, evalIncrement as D, type EvaluationContext as E, evalLast as F, evalLessThan as G, evalLessThanOrEqual as H, evalLet as I, evalList as J, evalMap as K, evalMatches as L, evalMax as M, evalMin as N, evalModulo as O, evalMultiply as P, evalNavigate as Q, evalNot as R, evalNotEqual as S, evalNotify as T, type UserContext as U, evalNth as V, evalOr as W, evalPersist as X, evalRef as Y, evalRenderUI as Z, evalRound as _, createEffectContext as a, evalSetDynamic as a0, evalSpawn as a1, evalSubtract as a2, evalSum as a3, evalSwap as a4, evalWatch as a5, evalWhen as a6, resolveBinding as a7, createMinimalContext as b, createChildContext as c, evalAdd as d, evalAbs as e, evalAnd as f, evalAtomic as g, evalCallService as h, evalCeil as i, evalClamp as j, evalConcat as k, evalCount as l, evalDecrement as m, evalDeref as n, evalDespawn as o, evalDivide as p, evalDo as q, evalEmit as r, evalEmpty as s, evalEqual as t, evalFilter as u, evalFind as v, evalFirst as w, evalFloor as x, evalFn as y, evalGreaterThan as z };

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { SExpr } from '@almadar/core';
 export { CORE_BINDINGS, CoreBinding, Expression, ExpressionSchema, ParsedBinding, SExpr, SExprAtom, SExprSchema, collectBindings, getArgs, getOperator, isBinding, isSExpr, isSExprAtom, isSExprCall, isValidBinding, parseBinding, sexpr, walkSExpr } from '@almadar/core';
-import { E as EvaluationContext } from './index-BNm52R6a.js';
-export { U as UserContext, c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalAtomic, h as evalCallService, i as evalCeil, j as evalClamp, k as evalConcat, l as evalCount, m as evalDecrement, n as evalDeref, o as evalDespawn, p as evalDivide, q as evalDo, r as evalEmit, s as evalEmpty, t as evalEqual, u as evalFilter, v as evalFind, w as evalFirst, x as evalFloor, y as evalFn, z as evalGreaterThan, A as evalGreaterThanOrEqual, B as evalIf, C as evalIncludes, D as evalIncrement, F as evalLast, G as evalLessThan, H as evalLessThanOrEqual, I as evalLet, J as evalMap, K as evalMatches, L as evalMax, M as evalMin, N as evalModulo, O as evalMultiply, P as evalNavigate, Q as evalNot, R as evalNotEqual, S as evalNotify, T as evalNth, V as evalOr, W as evalPersist, X as evalRef, Y as evalRenderUI, Z as evalRound, _ as evalSet, $ as evalSetDynamic, a0 as evalSpawn, a1 as evalSubtract, a2 as evalSum, a3 as evalSwap, a4 as evalWatch, a5 as evalWhen, a6 as resolveBinding } from './index-BNm52R6a.js';
+import { E as EvaluationContext } from './index-DbN8OE5Y.js';
+export { U as UserContext, c as createChildContext, a as createEffectContext, b as createMinimalContext, e as evalAbs, d as evalAdd, f as evalAnd, g as evalAtomic, h as evalCallService, i as evalCeil, j as evalClamp, k as evalConcat, l as evalCount, m as evalDecrement, n as evalDeref, o as evalDespawn, p as evalDivide, q as evalDo, r as evalEmit, s as evalEmpty, t as evalEqual, u as evalFilter, v as evalFind, w as evalFirst, x as evalFloor, y as evalFn, z as evalGreaterThan, A as evalGreaterThanOrEqual, B as evalIf, C as evalIncludes, D as evalIncrement, F as evalLast, G as evalLessThan, H as evalLessThanOrEqual, I as evalLet, J as evalList, K as evalMap, L as evalMatches, M as evalMax, N as evalMin, O as evalModulo, P as evalMultiply, Q as evalNavigate, R as evalNot, S as evalNotEqual, T as evalNotify, V as evalNth, W as evalOr, X as evalPersist, Y as evalRef, Z as evalRenderUI, _ as evalRound, $ as evalSet, a0 as evalSetDynamic, a1 as evalSpawn, a2 as evalSubtract, a3 as evalSum, a4 as evalSwap, a5 as evalWatch, a6 as evalWhen, a7 as resolveBinding } from './index-DbN8OE5Y.js';
 
 /**
  * S-Expression Evaluator

package/dist/index.js

@@ -380,6 +380,9 @@ function evalEmpty(args, evaluate2, ctx) {
   const collection = toArray(evaluate2(args[0], ctx));
   return collection.length === 0;
 }
+function evalList(args, evaluate2, ctx) {
+  return args.map((arg) => evaluate2(arg, ctx));
+}
 function toArray(value) {
   if (Array.isArray(value)) return value;
   if (value === null || value === void 0) return [];
@@ -730,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) {
@@ -2572,6 +2619,454 @@ 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 p = asVec2(evaluate2(args[0], ctx));
+  const r = asRect(evaluate2(args[1], ctx));
+  return p.x >= r.x && p.x <= r.x + r.w && p.y >= r.y && p.y <= r.y + r.h;
+}
+function evalGeoPointInCircle(args, evaluate2, ctx) {
+  const p = asVec2(evaluate2(args[0], ctx));
+  const c = asCircle(evaluate2(args[1], ctx));
+  const dx = p.x - c.x, dy = p.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);
+}
+
 // SExpressionEvaluator.ts
 var jitCache = /* @__PURE__ */ new Map();
 var MAX_JIT_CACHE_SIZE = 1e3;
@@ -2752,6 +3247,8 @@ var SExpressionEvaluator = class {
         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);
@@ -2836,6 +3333,111 @@ 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: str/*
       // ===============================
@@ -3306,6 +3908,6 @@ function executeEffects(effects, ctx) {
   evaluator.executeEffects(effects, ctx);
 }
 
-export { SExpressionEvaluator, createChildContext, createEffectContext, createMinimalContext, evalAbs, evalAdd, evalAnd, evalAtomic, evalCallService, evalCeil, evalClamp, evalConcat, evalCount, evalDecrement, evalDeref, evalDespawn, evalDivide, evalDo, evalEmit, evalEmpty, evalEqual, evalFilter, evalFind, evalFirst, evalFloor, evalFn, evalGreaterThan, evalGreaterThanOrEqual, evalIf, evalIncludes, evalIncrement, evalLast, evalLessThan, evalLessThanOrEqual, evalLet, evalMap, evalMatches, evalMax, evalMin, evalModulo, evalMultiply, evalNavigate, evalNot, evalNotEqual, evalNotify, evalNth, evalOr, evalPersist, evalRef, evalRenderUI, evalRound, evalSet, evalSetDynamic, evalSpawn, evalSubtract, evalSum, evalSwap, evalWatch, evalWhen, evaluate, evaluateGuard, evaluator, executeEffect, executeEffects, resolveBinding };
+export { SExpressionEvaluator, createChildContext, createEffectContext, createMinimalContext, evalAbs, evalAdd, evalAnd, evalAtomic, evalCallService, evalCeil, evalClamp, evalConcat, evalCount, evalDecrement, evalDeref, evalDespawn, evalDivide, evalDo, evalEmit, evalEmpty, evalEqual, evalFilter, evalFind, evalFirst, evalFloor, evalFn, evalGreaterThan, evalGreaterThanOrEqual, evalIf, evalIncludes, evalIncrement, evalLast, evalLessThan, evalLessThanOrEqual, evalLet, evalList, evalMap, evalMatches, evalMax, evalMin, evalModulo, evalMultiply, evalNavigate, evalNot, evalNotEqual, evalNotify, evalNth, evalOr, evalPersist, evalRef, evalRenderUI, evalRound, evalSet, evalSetDynamic, evalSpawn, evalSubtract, evalSum, evalSwap, evalWatch, evalWhen, evaluate, evaluateGuard, evaluator, executeEffect, executeEffects, resolveBinding };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map