@almadar/evaluator 2.35.0 → 2.37.0

package/dist/{index-rPqsFqVO.d.ts → index-dAA7DJ-s.d.ts}

@@ -1,4 +1,4 @@
-import { TraitConfig, AgentContext, LlmContext, WorkspaceContext, SessionContext, MemoryContext, TraceContext, IntegrationContext, SExpr } from '@almadar/core';
+import { UserContext, TraitConfig, AgentContext, LlmContext, WorkspaceContext, SessionContext, MemoryContext, TraceContext, IntegrationContext, SExpr } from '@almadar/core';
 
 /**
  * Evaluation Context
@@ -9,23 +9,6 @@ import { TraitConfig, AgentContext, LlmContext, WorkspaceContext, SessionContext
  * @packageDocumentation
  */
 
-/**
- * User context for @user bindings (role-based UI).
- */
-interface UserContext {
-    /** User's unique ID */
-    id: string;
-    /** User's email */
-    email?: string;
-    /** User's display name */
-    name?: string;
-    /** User's role (for RBAC) */
-    role?: string;
-    /** User's permissions */
-    permissions?: string[];
-    /** Additional custom profile fields */
-    [key: string]: unknown;
-}
 /**
  * Evaluation context for S-expression evaluation.
  * Provides all bindings and effect handlers needed at runtime.
@@ -456,4 +439,4 @@ declare function evalWatch(args: SExpr[], evaluate: Evaluator, ctx: EvaluationCo
  */
 declare function evalAtomic(args: SExpr[], evaluate: Evaluator, ctx: EvaluationContext): unknown;
 
-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 };
+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, 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, evalNth 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 };

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-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';
+import { SExpr, ListenPayloadEvaluator } from '@almadar/core';
+export { CORE_BINDINGS, CoreBinding, Expression, ExpressionSchema, ParsedBinding, SExpr, SExprAtom, SExprSchema, UserContext, collectBindings, getArgs, getOperator, isBinding, isSExpr, isSExprAtom, isSExprCall, isValidBinding, parseBinding, sexpr, walkSExpr } from '@almadar/core';
+import { E as EvaluationContext } from './index-dAA7DJ-s.js';
+export { 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, U 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-dAA7DJ-s.js';
 
 /**
  * S-Expression Evaluator
@@ -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

@@ -1,4 +1,4 @@
-import { isSExpr, isBinding, getOperator, getArgs, isFieldValue, isEventPayloadValue, isSessionHistoryEntry, isPlanSnapshot, OrbitalZodSchema, safeParseOrbitalSchema } from '@almadar/core';
+import { isSExpr, isBinding, getOperator, getArgs, isTensorValue, describeTensorMismatch, contractFieldName, validateContract, isFieldValue, isEventPayloadValue, isSessionHistoryEntry, isPlanSnapshot, tensorLastDimSize, mapTensorLastDim, OrbitalZodSchema, safeParseOrbitalSchema } from '@almadar/core';
 export { CORE_BINDINGS, ExpressionSchema, SExprSchema, collectBindings, getArgs, getOperator, isBinding, isSExpr, isSExprAtom, isSExprCall, isValidBinding, parseBinding, sexpr, walkSExpr } from '@almadar/core';
 import { assertOperatorArity } from '@almadar/std/registry';
 
@@ -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);
@@ -2537,6 +2587,407 @@ function evalOsDebounce(args, evaluate2, ctx) {
   const eventType = evaluate2(args[1], ctx);
   registerTrigger(ctx, "debounce", { ms, eventType });
 }
+function clampContract(tensor, contract) {
+  if (!isTensorValue(tensor)) {
+    throw new Error(
+      `contract/clamp-output: expected a tensor (a number, or nested arrays of numbers), received ${describeTensorMismatch(tensor)}. Validate with contract/validate-output before clamping.`
+    );
+  }
+  const ranges = contract.ranges ?? {};
+  const size = tensorLastDimSize(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 = mapTensorLastDim(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[contractFieldName(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 ${describeTensorMismatch(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[contractFieldName(f)] = values[i];
+  });
+  return result;
+}
+
+// std/graph.ts
+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 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 = tensorShape(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 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 rank(t) {
+  return tensorShape2(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 = tensorShape2(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) {
@@ -4255,6 +4706,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 +5048,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 +5130,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