@almadar/evaluator 2.13.0 → 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;
@@ -915,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) : "";
   });
 }
@@ -940,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);
@@ -971,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);
@@ -1059,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;
@@ -1172,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;
@@ -1191,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);
@@ -1201,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] = [];
     }
@@ -1271,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") {
@@ -1320,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;
@@ -1359,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;
@@ -1378,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;
@@ -1390,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;
@@ -1401,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;
 }
@@ -1410,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;
@@ -1420,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;
@@ -1442,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;
       }
     }
@@ -1621,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;
       }
     }
@@ -2292,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);
@@ -2327,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) {
@@ -2443,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];
@@ -2784,14 +2784,14 @@ function evalGeoRectCircleOverlap(args, evaluate2, ctx) {
   return dx * dx + dy * dy <= c.r * c.r;
 }
 function evalGeoPointInRect(args, evaluate2, ctx) {
-  const p = asVec2(evaluate2(args[0], ctx));
+  const p2 = 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;
+  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 p = asVec2(evaluate2(args[0], ctx));
+  const p2 = asVec2(evaluate2(args[0], ctx));
   const c = asCircle(evaluate2(args[1], ctx));
-  const dx = p.x - c.x, dy = p.y - c.y;
+  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) {
@@ -3067,6 +3067,500 @@ function evalEaseSmoothstep(args, evaluate2, ctx) {
   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;
@@ -3138,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;
     }
@@ -3150,7 +3644,7 @@ var SExpressionEvaluator = class {
         jitCache.delete(firstKey);
       }
     }
-    jitCache.set(key, fn);
+    jitCache.set(key2, fn);
     return fn;
   }
   /**
@@ -3439,6 +3933,22 @@ var SExpressionEvaluator = class {
       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":