@almadar/evaluator 2.35.0 → 2.36.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SExpr } from '@almadar/core';
+import { SExpr, ListenPayloadEvaluator } 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-rPqsFqVO.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-rPqsFqVO.js';
@@ -72,4 +72,24 @@ declare function evaluateGuard(expr: SExpr, ctx: EvaluationContext): boolean;
 declare function executeEffect(expr: SExpr, ctx: EvaluationContext): void;
 declare function executeEffects(effects: SExpr[], ctx: EvaluationContext): void;
 
-export { EvaluationContext, SExpressionEvaluator, evaluate, evaluateGuard, evaluator, executeEffect, executeEffects };
+/**
+ * The canonical evaluator for `listens { … with { field: <expr> } }` mapping
+ * values.
+ *
+ * `@almadar/core` owns the mapping contract (`applyListenPayloadMapping`) but
+ * sits upstream of this package and cannot evaluate. Every delivery path — the
+ * server runtime and the client cross-trait wiring — passes THIS function, so
+ * the two paths cannot drift into different `with{}` semantics.
+ *
+ * The binding context is payload-only, matching `orbital-core`'s listener
+ * fan-out (`runtime/listener.rs:107-109`, `runtime/kernel.rs:687-689`), which
+ * builds `BindingContextBuilder::new().payload(…).build()`. Binding `@entity`
+ * or `@config` here would let a mapping resolve on the JS path and silently
+ * yield nothing on the compiled one.
+ *
+ * @packageDocumentation
+ */
+
+declare const evaluateListenPayloadExpr: ListenPayloadEvaluator;
+
+export { EvaluationContext, SExpressionEvaluator, evaluate, evaluateGuard, evaluateListenPayloadExpr, evaluator, executeEffect, executeEffects };

package/dist/index.js

@@ -1288,6 +1288,56 @@ function evalArrayDropLast(args, evaluate2, ctx) {
   const n = evaluate2(args[1], ctx);
   return (arr ?? []).slice(0, -n);
 }
+function cosineSimilarity(a, b) {
+  if (a.length !== b.length) {
+    throw new Error(`array/cosine: vector length mismatch (${a.length} vs ${b.length})`);
+  }
+  if (a.length === 0) {
+    throw new Error("array/cosine: empty vector has no defined similarity");
+  }
+  let dot = 0;
+  let normA = 0;
+  let normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    const av = a[i];
+    const bv = b[i];
+    dot += av * bv;
+    normA += av * av;
+    normB += bv * bv;
+  }
+  if (normA === 0 || normB === 0) {
+    throw new Error("array/cosine: zero-magnitude vector has no defined direction to compare");
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+function evalArrayCosine(args, evaluate2, ctx) {
+  const a = evaluate2(args[0], ctx);
+  const b = evaluate2(args[1], ctx);
+  return cosineSimilarity(a, b);
+}
+function evalArrayNearest(args, evaluate2, ctx) {
+  const query = evaluate2(args[0], ctx);
+  const candidates = evaluate2(args[1], ctx);
+  if (candidates.length === 0) {
+    throw new Error("array/nearest: candidates array is empty, no nearest match exists");
+  }
+  const scores = candidates.map((c) => cosineSimilarity(query, c));
+  let bestIdx = 0;
+  let bestScore = scores[0];
+  for (let i = 1; i < scores.length; i++) {
+    if (scores[i] > bestScore) {
+      bestScore = scores[i];
+      bestIdx = i;
+    }
+  }
+  let secondBest = -Infinity;
+  for (let i = 0; i < scores.length; i++) {
+    if (i === bestIdx) continue;
+    if (scores[i] > secondBest) secondBest = scores[i];
+  }
+  const margin = scores.length === 1 ? 0 : bestScore - secondBest;
+  return { index: bestIdx, score: bestScore, margin };
+}
 
 // std/object.ts
 var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
@@ -1778,11 +1828,11 @@ function evalTimeFormat(args, evaluate2, ctx) {
       "December"
     ][date.getMonth()]
   };
-  let result = format;
-  for (const [token, value] of Object.entries(tokens)) {
-    result = result.replace(new RegExp(token, "g"), value);
-  }
-  return result;
+  const pattern = new RegExp(
+    Object.keys(tokens).sort((a, b) => b.length - a.length).join("|"),
+    "g"
+  );
+  return format.replace(pattern, (token) => tokens[token]);
 }
 function evalTimeYear(args, evaluate2, ctx) {
   const timestamp = evaluate2(args[0], ctx);
@@ -2538,6 +2588,481 @@ function evalOsDebounce(args, evaluate2, ctx) {
   registerTrigger(ctx, "debounce", { ms, eventType });
 }
 
+// std/contract.ts
+function fieldName(f) {
+  return typeof f === "string" ? f : f.name;
+}
+function isTensorValue(v) {
+  if (typeof v === "number") return true;
+  return Array.isArray(v) && v.every(isTensorValue);
+}
+function describeType(v) {
+  if (v === null) return "null";
+  if (Array.isArray(v)) return "array containing non-numeric values";
+  return typeof v;
+}
+function tensorShape(t) {
+  if (typeof t === "number") return [];
+  if (t.length === 0) return [0];
+  const first = t[0];
+  if (typeof first === "number") return [t.length];
+  return [t.length, ...tensorShape(first)];
+}
+function lastDimSize(t) {
+  const shape = tensorShape(t);
+  return shape.length === 0 ? 0 : shape[shape.length - 1];
+}
+function arraysEqual(a, b) {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+function gatherLastDim(t, dim) {
+  if (typeof t === "number") return [];
+  if (t.length === 0) return [];
+  if (typeof t[0] === "number") return [t[dim]];
+  const out = [];
+  for (const sub of t) out.push(...gatherLastDim(sub, dim));
+  return out;
+}
+function mapLastDim(t, dim, fn) {
+  if (typeof t === "number") return t;
+  if (t.length === 0) return t;
+  if (typeof t[0] === "number") {
+    const copy = [...t];
+    copy[dim] = fn(copy[dim]);
+    return copy;
+  }
+  return t.map((sub) => mapLastDim(sub, dim, fn));
+}
+function validateContract(tensor, contract) {
+  if (!isTensorValue(tensor)) {
+    return {
+      valid: false,
+      violations: [{ type: "not_a_tensor", actualType: describeType(tensor) }]
+    };
+  }
+  const violations = [];
+  const shape = tensorShape(tensor);
+  if (contract.shape && !arraysEqual(shape, contract.shape)) {
+    violations.push({ type: "shape_mismatch", expected: contract.shape, actual: shape });
+  }
+  const ranges = contract.ranges ?? {};
+  const size = lastDimSize(tensor);
+  for (const [dimStr, bounds] of Object.entries(ranges)) {
+    const dim = Number(dimStr);
+    if (dim >= size) continue;
+    const vals = gatherLastDim(tensor, dim);
+    const min = bounds.min ?? -Infinity;
+    const max = bounds.max ?? Infinity;
+    const actualMin = Math.min(...vals);
+    const actualMax = Math.max(...vals);
+    if (actualMin < min || actualMax > max) {
+      violations.push({ type: "range_violation", dim, min, max, actualMin, actualMax });
+    }
+  }
+  return { valid: violations.length === 0, violations };
+}
+function clampContract(tensor, contract) {
+  if (!isTensorValue(tensor)) {
+    throw new Error(
+      `contract/clamp-output: expected a tensor (a number, or nested arrays of numbers), received ${describeType(tensor)}. Validate with contract/validate-output before clamping.`
+    );
+  }
+  const ranges = contract.ranges ?? {};
+  const size = lastDimSize(tensor);
+  let result = tensor;
+  for (const [dimStr, bounds] of Object.entries(ranges)) {
+    const dim = Number(dimStr);
+    if (dim >= size) continue;
+    const min = bounds.min ?? -Infinity;
+    const max = bounds.max ?? Infinity;
+    result = mapLastDim(result, dim, (v) => Math.min(Math.max(v, min), max));
+  }
+  return result;
+}
+function evalContractValidateInput(args, evaluate2, ctx) {
+  const tensor = evaluate2(args[0], ctx);
+  const contract = evaluate2(args[1], ctx);
+  return validateContract(tensor, contract);
+}
+function evalContractValidateOutput(args, evaluate2, ctx) {
+  return evalContractValidateInput(args, evaluate2, ctx);
+}
+function evalContractClampOutput(args, evaluate2, ctx) {
+  const tensor = evaluate2(args[0], ctx);
+  const contract = evaluate2(args[1], ctx);
+  return clampContract(tensor, contract);
+}
+function evalContractViolations(args, evaluate2, ctx) {
+  const tensor = evaluate2(args[0], ctx);
+  const contract = evaluate2(args[1], ctx);
+  return validateContract(tensor, contract).violations;
+}
+function evalContractEntityToTensor(args, evaluate2, ctx) {
+  const entity = evaluate2(args[0], ctx);
+  const contract = evaluate2(args[1], ctx);
+  const fields = contract.fields ?? [];
+  return fields.map((f) => {
+    const val = entity[fieldName(f)];
+    return typeof val === "number" ? val : 0;
+  });
+}
+function evalContractTensorToPayload(args, evaluate2, ctx) {
+  const tensor = evaluate2(args[0], ctx);
+  if (!isTensorValue(tensor)) {
+    throw new Error(
+      `contract/tensor-to-payload: expected a tensor (a number, or nested arrays of numbers), received ${describeType(tensor)}.`
+    );
+  }
+  const contract = evaluate2(args[1], ctx);
+  const fields = contract.fields ?? [];
+  const values = Array.isArray(tensor) ? tensor : [tensor];
+  const result = {};
+  fields.forEach((f, i) => {
+    if (i < values.length) result[fieldName(f)] = values[i];
+  });
+  return result;
+}
+
+// std/graph.ts
+function tensorShape2(t) {
+  if (typeof t === "number") return [];
+  if (t.length === 0) return [0];
+  const first = t[0];
+  if (typeof first === "number") return [t.length];
+  return [t.length, ...tensorShape2(first)];
+}
+function numNodes(g) {
+  return g.x.length;
+}
+function subgraphData(g, mask) {
+  const nodeMap = new Array(numNodes(g)).fill(-1);
+  const x = [];
+  let next = 0;
+  for (let i = 0; i < numNodes(g); i++) {
+    if (mask[i]) {
+      nodeMap[i] = next++;
+      x.push(g.x[i]);
+    }
+  }
+  const [srcAll, dstAll] = g.edgeIndex;
+  const src = [];
+  const dst = [];
+  for (let k = 0; k < srcAll.length; k++) {
+    const s = srcAll[k];
+    const d = dstAll[k];
+    if (mask[s] && mask[d]) {
+      src.push(nodeMap[s]);
+      dst.push(nodeMap[d]);
+    }
+  }
+  return { x, edgeIndex: [src, dst] };
+}
+function evalGraphFromEntities(args, evaluate2, ctx) {
+  const entities = evaluate2(args[0], ctx);
+  if (entities.length === 0) {
+    return { x: [], edgeIndex: [[], []] };
+  }
+  const features = entities.map((e) => {
+    const row = Object.values(e).filter((v) => typeof v === "number" || typeof v === "boolean").map((v) => typeof v === "boolean" ? v ? 1 : 0 : v);
+    return row.length > 0 ? row : [0];
+  });
+  const maxLen = Math.max(...features.map((r) => r.length));
+  const x = features.map((r) => [...r, ...new Array(maxLen - r.length).fill(0)]);
+  return { x, edgeIndex: [[], []] };
+}
+function evalGraphFromAdjacency(args, evaluate2, ctx) {
+  const adjacency = evaluate2(args[0], ctx);
+  const features = evaluate2(args[1], ctx);
+  const src = [];
+  const dst = [];
+  for (let i = 0; i < adjacency.length; i++) {
+    const row = adjacency[i];
+    for (let j = 0; j < row.length; j++) {
+      if (row[j] !== 0) {
+        src.push(i);
+        dst.push(j);
+      }
+    }
+  }
+  return { x: features, edgeIndex: [src, dst] };
+}
+function evalGraphFromEdgeList(args, evaluate2, ctx) {
+  const edges = evaluate2(args[0], ctx);
+  const features = evaluate2(args[1], ctx);
+  const shape = tensorShape2(edges);
+  let edgeIndex;
+  if (shape.length === 2 && shape[1] === 2) {
+    const rows = edges;
+    edgeIndex = [rows.map((r) => r[0]), rows.map((r) => r[1])];
+  } else {
+    const pair = edges;
+    edgeIndex = [pair[0] ?? [], pair[1] ?? []];
+  }
+  return { x: features, edgeIndex };
+}
+function evalGraphAddSelfLoops(args, evaluate2, ctx) {
+  const g = evaluate2(args[0], ctx);
+  const n = numNodes(g);
+  const loop = Array.from({ length: n }, (_, i) => i);
+  const [src, dst] = g.edgeIndex;
+  return { x: g.x, edgeIndex: [[...src, ...loop], [...dst, ...loop]], edgeAttr: g.edgeAttr };
+}
+function evalGraphToUndirected(args, evaluate2, ctx) {
+  const g = evaluate2(args[0], ctx);
+  const [src, dst] = g.edgeIndex;
+  return { x: g.x, edgeIndex: [[...src, ...dst], [...dst, ...src]], edgeAttr: g.edgeAttr };
+}
+function evalGraphSubgraph(args, evaluate2, ctx) {
+  const g = evaluate2(args[0], ctx);
+  const mask = evaluate2(args[1], ctx);
+  return subgraphData(g, mask);
+}
+function evalGraphKHop(args, evaluate2, ctx) {
+  const g = evaluate2(args[0], ctx);
+  const node = evaluate2(args[1], ctx);
+  const k = evaluate2(args[2], ctx);
+  const [src, dst] = g.edgeIndex;
+  const visited = /* @__PURE__ */ new Set([node]);
+  let frontier = /* @__PURE__ */ new Set([node]);
+  for (let hop = 0; hop < k; hop++) {
+    const next = /* @__PURE__ */ new Set();
+    for (const n of frontier) {
+      for (let e = 0; e < src.length; e++) {
+        if (src[e] === n && !visited.has(dst[e])) next.add(dst[e]);
+        if (dst[e] === n && !visited.has(src[e])) next.add(src[e]);
+      }
+    }
+    for (const v of next) visited.add(v);
+    frontier = next;
+  }
+  const mask = new Array(numNodes(g)).fill(false);
+  for (const n of visited) mask[n] = true;
+  return subgraphData(g, mask);
+}
+function evalGraphNodeFeatures(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx).x;
+}
+function evalGraphEdgeIndex(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx).edgeIndex;
+}
+function evalGraphEdgeFeatures(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx).edgeAttr;
+}
+function evalGraphNumNodes(args, evaluate2, ctx) {
+  return numNodes(evaluate2(args[0], ctx));
+}
+function evalGraphNumEdges(args, evaluate2, ctx) {
+  return evaluate2(args[0], ctx).edgeIndex[0].length;
+}
+function evalGraphDegree(args, evaluate2, ctx) {
+  const g = evaluate2(args[0], ctx);
+  const deg = new Array(numNodes(g)).fill(0);
+  for (const s of g.edgeIndex[0]) deg[s]++;
+  return deg;
+}
+function evalGraphBatch(args, evaluate2, ctx) {
+  const graphs = evaluate2(args[0], ctx);
+  if (graphs.length === 0) return { x: [], edgeIndex: [[], []] };
+  const x = [];
+  const src = [];
+  const dst = [];
+  let offset = 0;
+  for (const g of graphs) {
+    x.push(...g.x);
+    src.push(...g.edgeIndex[0].map((s) => s + offset));
+    dst.push(...g.edgeIndex[1].map((d) => d + offset));
+    offset += numNodes(g);
+  }
+  return { x, edgeIndex: [src, dst] };
+}
+
+// std/data.ts
+function isPlainRecord(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function datasetGetItem(dataset, idx) {
+  const item = dataset.data[idx];
+  if (isPlainRecord(item)) {
+    const x = item.input ?? item.observation ?? [];
+    const y = item.target ?? item.output ?? [];
+    return [x, y];
+  }
+  if (Array.isArray(item)) {
+    return [item, item];
+  }
+  return [item, item];
+}
+function seededRandom(ctx) {
+  if (ctx._probSeed) {
+    const seed = ctx._probSeed;
+    let t = seed.state += 1831565813;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  }
+  return Math.random();
+}
+function seededGaussian(ctx) {
+  const u1 = seededRandom(ctx);
+  const u2 = seededRandom(ctx);
+  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function shuffleInPlace(arr, ctx) {
+  for (let i = arr.length - 1; i > 0; i--) {
+    const j = Math.floor(seededRandom(ctx) * (i + 1));
+    const tmp = arr[i];
+    arr[i] = arr[j];
+    arr[j] = tmp;
+  }
+}
+function tensorShape3(t) {
+  if (typeof t === "number") return [];
+  if (t.length === 0) return [0];
+  const first = t[0];
+  if (typeof first === "number") return [t.length];
+  return [t.length, ...tensorShape3(first)];
+}
+function rank(t) {
+  return tensorShape3(t).length;
+}
+function sampleMean(vals) {
+  return vals.reduce((s, v) => s + v, 0) / vals.length;
+}
+function sampleStd(vals, mean) {
+  if (vals.length <= 1) return 0;
+  const variance = vals.reduce((s, v) => s + (v - mean) ** 2, 0) / (vals.length - 1);
+  return Math.sqrt(variance);
+}
+function normalizeZScore(t) {
+  if (rank(t) <= 1) {
+    const vals = t;
+    const mean = sampleMean(vals);
+    const std = Math.max(sampleStd(vals, mean), 1e-8);
+    return vals.map((v) => (v - mean) / std);
+  }
+  const rows = t;
+  const cols = rows[0].length;
+  const means = [];
+  const stds = [];
+  for (let c = 0; c < cols; c++) {
+    const col = rows.map((r) => r[c]);
+    const m = sampleMean(col);
+    means.push(m);
+    stds.push(Math.max(sampleStd(col, m), 1e-8));
+  }
+  return rows.map((r) => r.map((v, c) => (v - means[c]) / stds[c]));
+}
+function normalizeMinMax(t) {
+  if (rank(t) <= 1) {
+    const vals = t;
+    const mn = Math.min(...vals);
+    const mx = Math.max(...vals);
+    const denom = Math.max(mx - mn, 1e-8);
+    return vals.map((v) => (v - mn) / denom);
+  }
+  const rows = t;
+  const cols = rows[0].length;
+  const mins = [];
+  const maxs = [];
+  for (let c = 0; c < cols; c++) {
+    const col = rows.map((r) => r[c]);
+    mins.push(Math.min(...col));
+    maxs.push(Math.max(...col));
+  }
+  return rows.map((r) => r.map((v, c) => (v - mins[c]) / Math.max(maxs[c] - mins[c], 1e-8)));
+}
+function mapTensor(t, fn) {
+  if (typeof t === "number") return fn(t);
+  return t.map((sub) => mapTensor(sub, fn));
+}
+function padOrTruncateLastDim(t, targetLen, padValue) {
+  if (typeof t === "number") return t;
+  if (t.length === 0 || typeof t[0] === "number") {
+    const row = t;
+    if (row.length < targetLen) {
+      return [...row, ...new Array(targetLen - row.length).fill(padValue)];
+    }
+    return row.slice(0, targetLen);
+  }
+  return t.map((sub) => padOrTruncateLastDim(sub, targetLen, padValue));
+}
+function evalDataDataset(args, evaluate2, ctx) {
+  const data = evaluate2(args[0], ctx);
+  const config = evaluate2(args[1], ctx);
+  return { data: Array.isArray(data) ? data : [], config };
+}
+function evalDataDataloader(args, evaluate2, ctx) {
+  const dataset = evaluate2(args[0], ctx);
+  const config = evaluate2(args[1], ctx);
+  const batchSize = config.batchSize ?? config.batch_size ?? 32;
+  const shuffle = config.shuffle ?? true;
+  const indices = Array.from({ length: dataset.data.length }, (_, i) => i);
+  if (shuffle) shuffleInPlace(indices, ctx);
+  const batches = [];
+  for (let i = 0; i < indices.length; i += batchSize) {
+    const chunk = indices.slice(i, i + batchSize);
+    const x = [];
+    const y = [];
+    for (const idx of chunk) {
+      const [xi, yi] = datasetGetItem(dataset, idx);
+      x.push(xi);
+      y.push(yi);
+    }
+    batches.push({ x, y });
+  }
+  return { batches, batchSize, numBatches: batches.length };
+}
+function evalDataSplit(args, evaluate2, ctx) {
+  const dataset = evaluate2(args[0], ctx);
+  const config = evaluate2(args[1], ctx);
+  const ratio = config.trainRatio ?? config.train_ratio ?? 0.8;
+  const trainSize = Math.trunc(dataset.data.length * ratio);
+  const indices = Array.from({ length: dataset.data.length }, (_, i) => i);
+  shuffleInPlace(indices, ctx);
+  const trainIdx = indices.slice(0, trainSize);
+  const testIdx = indices.slice(trainSize);
+  return [
+    { data: trainIdx.map((i) => dataset.data[i]), config: dataset.config },
+    { data: testIdx.map((i) => dataset.data[i]), config: dataset.config }
+  ];
+}
+function evalDataNormalize(args, evaluate2, ctx) {
+  const data = evaluate2(args[0], ctx);
+  const config = evaluate2(args[1], ctx);
+  const method = config.method ?? "zscore";
+  if (method === "zscore") return normalizeZScore(data);
+  if (method === "minmax") return normalizeMinMax(data);
+  return data;
+}
+function evalDataAugment(args, evaluate2, ctx) {
+  const data = evaluate2(args[0], ctx);
+  const config = evaluate2(args[1], ctx);
+  const noiseScale = config.noiseScale ?? config.noise_scale ?? 0.01;
+  return mapTensor(data, (v) => v + seededGaussian(ctx) * noiseScale);
+}
+function evalDataTokenize(args, evaluate2, ctx) {
+  const text = evaluate2(args[0], ctx);
+  const config = evaluate2(args[1], ctx);
+  const mode = config.mode ?? "char";
+  const textStr = String(text);
+  if (mode === "word") {
+    const vocab = config.vocab ?? {};
+    return textStr.split(/\s+/).filter((w) => w.length > 0).map((w) => vocab[w] ?? 0);
+  }
+  return Array.from(textStr).map((c) => c.codePointAt(0) ?? 0);
+}
+function evalDataPad(args, evaluate2, ctx) {
+  const data = evaluate2(args[0], ctx);
+  const config = evaluate2(args[1], ctx);
+  const currentLen = (() => {
+    const shape = tensorShape3(data);
+    return shape.length === 0 ? 0 : shape[shape.length - 1];
+  })();
+  const targetLen = config.length ?? config.targetLength ?? currentLen;
+  const padValue = config.padValue ?? config.pad_value ?? 0;
+  return padOrTruncateLastDim(data, targetLen, padValue);
+}
+
 // std/llm.ts
 function evalLlmGenerate(args, evaluate2, ctx) {
   if (!ctx.llm) return null;
@@ -4255,6 +4780,10 @@ var SExpressionEvaluator = class {
         return evalArrayTakeLast(args, evaluate2, ctx);
       case "array/dropLast":
         return evalArrayDropLast(args, evaluate2, ctx);
+      case "array/cosine":
+        return evalArrayCosine(args, evaluate2, ctx);
+      case "array/nearest":
+        return evalArrayNearest(args, evaluate2, ctx);
       // ===============================
       // Standard Library: object/*
       // ===============================
@@ -4593,6 +5122,69 @@ var SExpressionEvaluator = class {
         return evalIntegrationGithubGetRepo(args, evaluate2, ctx);
       case "integration/github-create-issue":
         return evalIntegrationGithubCreateIssue(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: contract/*
+      // ===============================
+      case "contract/validate-input":
+        return evalContractValidateInput(args, evaluate2, ctx);
+      case "contract/validate-output":
+        return evalContractValidateOutput(args, evaluate2, ctx);
+      case "contract/clamp-output":
+        return evalContractClampOutput(args, evaluate2, ctx);
+      case "contract/violations":
+        return evalContractViolations(args, evaluate2, ctx);
+      case "contract/entity-to-tensor":
+        return evalContractEntityToTensor(args, evaluate2, ctx);
+      case "contract/tensor-to-payload":
+        return evalContractTensorToPayload(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: graph/*
+      // ===============================
+      case "graph/from-entities":
+        return evalGraphFromEntities(args, evaluate2, ctx);
+      case "graph/from-adjacency":
+        return evalGraphFromAdjacency(args, evaluate2, ctx);
+      case "graph/from-edge-list":
+        return evalGraphFromEdgeList(args, evaluate2, ctx);
+      case "graph/add-self-loops":
+        return evalGraphAddSelfLoops(args, evaluate2, ctx);
+      case "graph/to-undirected":
+        return evalGraphToUndirected(args, evaluate2, ctx);
+      case "graph/subgraph":
+        return evalGraphSubgraph(args, evaluate2, ctx);
+      case "graph/k-hop":
+        return evalGraphKHop(args, evaluate2, ctx);
+      case "graph/node-features":
+        return evalGraphNodeFeatures(args, evaluate2, ctx);
+      case "graph/edge-index":
+        return evalGraphEdgeIndex(args, evaluate2, ctx);
+      case "graph/edge-features":
+        return evalGraphEdgeFeatures(args, evaluate2, ctx);
+      case "graph/num-nodes":
+        return evalGraphNumNodes(args, evaluate2, ctx);
+      case "graph/num-edges":
+        return evalGraphNumEdges(args, evaluate2, ctx);
+      case "graph/degree":
+        return evalGraphDegree(args, evaluate2, ctx);
+      case "graph/batch":
+        return evalGraphBatch(args, evaluate2, ctx);
+      // ===============================
+      // Standard Library: data/*
+      // ===============================
+      case "data/dataset":
+        return evalDataDataset(args, evaluate2, ctx);
+      case "data/dataloader":
+        return evalDataDataloader(args, evaluate2, ctx);
+      case "data/split":
+        return evalDataSplit(args, evaluate2, ctx);
+      case "data/normalize":
+        return evalDataNormalize(args, evaluate2, ctx);
+      case "data/augment":
+        return evalDataAugment(args, evaluate2, ctx);
+      case "data/tokenize":
+        return evalDataTokenize(args, evaluate2, ctx);
+      case "data/pad":
+        return evalDataPad(args, evaluate2, ctx);
       default:
         return UNKNOWN_OPERATOR;
     }
@@ -4612,6 +5204,9 @@ 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, 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 };
+// listen-payload.ts
+var evaluateListenPayloadExpr = (expr, payload) => evaluate(expr, createMinimalContext({}, payload));
+
+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, evaluateListenPayloadExpr, evaluator, executeEffect, executeEffects, resolveBinding };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map