@almadar/std 1.0.0

package/dist/registry.js

@@ -0,0 +1,3240 @@
+// types.ts
+var STD_MODULES = [
+  "math",
+  "str",
+  "array",
+  "object",
+  "time",
+  "validate",
+  "format",
+  "async",
+  "nn",
+  "tensor",
+  "train"
+];
+function getModuleFromOperator(operator) {
+  const parts = operator.split("/");
+  if (parts.length !== 2) return null;
+  const module = parts[0];
+  return STD_MODULES.includes(module) ? module : null;
+}
+function isStdOperator(operator) {
+  return getModuleFromOperator(operator) !== null;
+}
+
+// modules/math.ts
+var MATH_OPERATORS = {
+  "math/abs": {
+    module: "math",
+    category: "std-math",
+    minArity: 1,
+    maxArity: 1,
+    description: "Absolute value",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "n", type: "number", description: "The number" }],
+    example: '["math/abs", -5] // => 5'
+  },
+  "math/min": {
+    module: "math",
+    category: "std-math",
+    minArity: 2,
+    maxArity: null,
+    description: "Minimum of values",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "...nums", type: "number[]", description: "Numbers to compare" }],
+    example: '["math/min", 3, 1, 4] // => 1'
+  },
+  "math/max": {
+    module: "math",
+    category: "std-math",
+    minArity: 2,
+    maxArity: null,
+    description: "Maximum of values",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "...nums", type: "number[]", description: "Numbers to compare" }],
+    example: '["math/max", 3, 1, 4] // => 4'
+  },
+  "math/clamp": {
+    module: "math",
+    category: "std-math",
+    minArity: 3,
+    maxArity: 3,
+    description: "Constrain value to range [min, max]",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "n", type: "number", description: "The value to clamp" },
+      { name: "min", type: "number", description: "Minimum bound" },
+      { name: "max", type: "number", description: "Maximum bound" }
+    ],
+    example: '["math/clamp", 150, 0, 100] // => 100'
+  },
+  "math/floor": {
+    module: "math",
+    category: "std-math",
+    minArity: 1,
+    maxArity: 1,
+    description: "Round down to integer",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "n", type: "number", description: "The number" }],
+    example: '["math/floor", 3.7] // => 3'
+  },
+  "math/ceil": {
+    module: "math",
+    category: "std-math",
+    minArity: 1,
+    maxArity: 1,
+    description: "Round up to integer",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "n", type: "number", description: "The number" }],
+    example: '["math/ceil", 3.2] // => 4'
+  },
+  "math/round": {
+    module: "math",
+    category: "std-math",
+    minArity: 1,
+    maxArity: 2,
+    description: "Round to nearest integer or specified decimals",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "n", type: "number", description: "The number" },
+      { name: "decimals", type: "number", description: "Decimal places", optional: true, defaultValue: 0 }
+    ],
+    example: '["math/round", 3.456, 2] // => 3.46'
+  },
+  "math/pow": {
+    module: "math",
+    category: "std-math",
+    minArity: 2,
+    maxArity: 2,
+    description: "Exponentiation (base^exp)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "base", type: "number", description: "The base" },
+      { name: "exp", type: "number", description: "The exponent" }
+    ],
+    example: '["math/pow", 2, 8] // => 256'
+  },
+  "math/sqrt": {
+    module: "math",
+    category: "std-math",
+    minArity: 1,
+    maxArity: 1,
+    description: "Square root",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "n", type: "number", description: "The number" }],
+    example: '["math/sqrt", 16] // => 4'
+  },
+  "math/mod": {
+    module: "math",
+    category: "std-math",
+    minArity: 2,
+    maxArity: 2,
+    description: "Modulo (remainder)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "a", type: "number", description: "Dividend" },
+      { name: "b", type: "number", description: "Divisor" }
+    ],
+    example: '["math/mod", 7, 3] // => 1'
+  },
+  "math/sign": {
+    module: "math",
+    category: "std-math",
+    minArity: 1,
+    maxArity: 1,
+    description: "Returns -1, 0, or 1 indicating sign",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "n", type: "number", description: "The number" }],
+    example: '["math/sign", -42] // => -1'
+  },
+  "math/lerp": {
+    module: "math",
+    category: "std-math",
+    minArity: 3,
+    maxArity: 3,
+    description: "Linear interpolation between a and b by factor t",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "a", type: "number", description: "Start value" },
+      { name: "b", type: "number", description: "End value" },
+      { name: "t", type: "number", description: "Interpolation factor (0-1)" }
+    ],
+    example: '["math/lerp", 0, 100, 0.5] // => 50'
+  },
+  "math/map": {
+    module: "math",
+    category: "std-math",
+    minArity: 5,
+    maxArity: 5,
+    description: "Map value from one range to another",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "n", type: "number", description: "The value" },
+      { name: "inMin", type: "number", description: "Input range minimum" },
+      { name: "inMax", type: "number", description: "Input range maximum" },
+      { name: "outMin", type: "number", description: "Output range minimum" },
+      { name: "outMax", type: "number", description: "Output range maximum" }
+    ],
+    example: '["math/map", 5, 0, 10, 0, 100] // => 50'
+  },
+  "math/random": {
+    module: "math",
+    category: "std-math",
+    minArity: 0,
+    maxArity: 0,
+    description: "Random number between 0 (inclusive) and 1 (exclusive)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [],
+    example: '["math/random"] // => 0.7234...'
+  },
+  "math/randomInt": {
+    module: "math",
+    category: "std-math",
+    minArity: 2,
+    maxArity: 2,
+    description: "Random integer in range [min, max] (inclusive)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "min", type: "number", description: "Minimum (inclusive)" },
+      { name: "max", type: "number", description: "Maximum (inclusive)" }
+    ],
+    example: '["math/randomInt", 1, 6] // => 4'
+  },
+  "math/default": {
+    module: "math",
+    category: "std-math",
+    minArity: 2,
+    maxArity: 2,
+    description: "Return default if value is null, undefined, or NaN",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "n", type: "number | null", description: "The value" },
+      { name: "default", type: "number", description: "Default value" }
+    ],
+    example: '["math/default", null, 0] // => 0'
+  }
+};
+
+// modules/str.ts
+var STR_OPERATORS = {
+  "str/len": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "String length",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/len", "hello"] // => 5'
+  },
+  "str/upper": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert to uppercase",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/upper", "hello"] // => "HELLO"'
+  },
+  "str/lower": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert to lowercase",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/lower", "HELLO"] // => "hello"'
+  },
+  "str/trim": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Remove leading and trailing whitespace",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/trim", "  hello  "] // => "hello"'
+  },
+  "str/trimStart": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Remove leading whitespace",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/trimStart", "  hello"] // => "hello"'
+  },
+  "str/trimEnd": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Remove trailing whitespace",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/trimEnd", "hello  "] // => "hello"'
+  },
+  "str/split": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Split string into array by delimiter",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "delim", type: "string", description: "Delimiter" }
+    ],
+    example: '["str/split", "a,b,c", ","] // => ["a", "b", "c"]'
+  },
+  "str/join": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Join array elements into string",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "arr", type: "array", description: "Array to join" },
+      { name: "delim", type: "string", description: "Delimiter" }
+    ],
+    example: '["str/join", ["a", "b", "c"], ", "] // => "a, b, c"'
+  },
+  "str/slice": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 3,
+    description: "Extract substring",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "start", type: "number", description: "Start index" },
+      { name: "end", type: "number", description: "End index (exclusive)", optional: true }
+    ],
+    example: '["str/slice", "hello", 1, 4] // => "ell"'
+  },
+  "str/replace": {
+    module: "str",
+    category: "std-str",
+    minArity: 3,
+    maxArity: 3,
+    description: "Replace first occurrence",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "find", type: "string", description: "String to find" },
+      { name: "replace", type: "string", description: "Replacement" }
+    ],
+    example: '["str/replace", "hello world", "world", "there"] // => "hello there"'
+  },
+  "str/replaceAll": {
+    module: "str",
+    category: "std-str",
+    minArity: 3,
+    maxArity: 3,
+    description: "Replace all occurrences",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "find", type: "string", description: "String to find" },
+      { name: "replace", type: "string", description: "Replacement" }
+    ],
+    example: '["str/replaceAll", "a-b-c", "-", "_"] // => "a_b_c"'
+  },
+  "str/includes": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if string contains substring",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "search", type: "string", description: "Substring to find" }
+    ],
+    example: '["str/includes", "hello world", "world"] // => true'
+  },
+  "str/startsWith": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if string starts with prefix",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "prefix", type: "string", description: "Prefix to check" }
+    ],
+    example: '["str/startsWith", "hello", "hel"] // => true'
+  },
+  "str/endsWith": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if string ends with suffix",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "suffix", type: "string", description: "Suffix to check" }
+    ],
+    example: '["str/endsWith", "hello", "lo"] // => true'
+  },
+  "str/padStart": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 3,
+    description: "Pad string from start to target length",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "len", type: "number", description: "Target length" },
+      { name: "char", type: "string", description: "Padding character", optional: true, defaultValue: " " }
+    ],
+    example: '["str/padStart", "5", 3, "0"] // => "005"'
+  },
+  "str/padEnd": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 3,
+    description: "Pad string from end to target length",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "len", type: "number", description: "Target length" },
+      { name: "char", type: "string", description: "Padding character", optional: true, defaultValue: " " }
+    ],
+    example: '["str/padEnd", "5", 3, "0"] // => "500"'
+  },
+  "str/repeat": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Repeat string n times",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "count", type: "number", description: "Repeat count" }
+    ],
+    example: '["str/repeat", "ab", 3] // => "ababab"'
+  },
+  "str/reverse": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Reverse string",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/reverse", "hello"] // => "olleh"'
+  },
+  "str/capitalize": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Capitalize first character",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/capitalize", "hello"] // => "Hello"'
+  },
+  "str/titleCase": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert to Title Case",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/titleCase", "hello world"] // => "Hello World"'
+  },
+  "str/camelCase": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert to camelCase",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/camelCase", "hello world"] // => "helloWorld"'
+  },
+  "str/kebabCase": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert to kebab-case",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/kebabCase", "Hello World"] // => "hello-world"'
+  },
+  "str/snakeCase": {
+    module: "str",
+    category: "std-str",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert to snake_case",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "s", type: "string", description: "The string" }],
+    example: '["str/snakeCase", "Hello World"] // => "hello_world"'
+  },
+  "str/default": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Return default if value is null/undefined/empty",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string | null", description: "The value" },
+      { name: "default", type: "string", description: "Default value" }
+    ],
+    example: '["str/default", null, "N/A"] // => "N/A"'
+  },
+  "str/template": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 2,
+    description: "Variable substitution in template string",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "template", type: "string", description: "Template with {placeholders}" },
+      { name: "vars", type: "object", description: "Variables to substitute" }
+    ],
+    example: '["str/template", "Hello, {name}!", {"name": "World"}] // => "Hello, World!"'
+  },
+  "str/truncate": {
+    module: "str",
+    category: "std-str",
+    minArity: 2,
+    maxArity: 3,
+    description: "Truncate string with optional suffix",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "s", type: "string", description: "The string" },
+      { name: "len", type: "number", description: "Maximum length" },
+      { name: "suffix", type: "string", description: "Suffix for truncated strings", optional: true, defaultValue: "..." }
+    ],
+    example: '["str/truncate", "Hello World", 8, "..."] // => "Hello..."'
+  }
+};
+
+// modules/array.ts
+var ARRAY_OPERATORS = {
+  "array/len": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Array length",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/len", [1, 2, 3]] // => 3'
+  },
+  "array/empty?": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if array is empty",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/empty?", []] // => true'
+  },
+  "array/first": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get first element",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/first", [1, 2, 3]] // => 1'
+  },
+  "array/last": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get last element",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/last", [1, 2, 3]] // => 3'
+  },
+  "array/nth": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get element at index",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "index", type: "number", description: "Index (0-based)" }
+    ],
+    example: '["array/nth", [1, 2, 3], 1] // => 2'
+  },
+  "array/slice": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 3,
+    description: "Extract subarray",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "start", type: "number", description: "Start index" },
+      { name: "end", type: "number", description: "End index (exclusive)", optional: true }
+    ],
+    example: '["array/slice", [1, 2, 3, 4], 1, 3] // => [2, 3]'
+  },
+  "array/concat": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: null,
+    description: "Concatenate arrays",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "...arrs", type: "array[]", description: "Arrays to concatenate" }],
+    example: '["array/concat", [1, 2], [3, 4]] // => [1, 2, 3, 4]'
+  },
+  "array/append": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Add item to end (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "item", type: "any", description: "Item to add" }
+    ],
+    example: '["array/append", [1, 2], 3] // => [1, 2, 3]'
+  },
+  "array/prepend": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Add item to start (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "item", type: "any", description: "Item to add" }
+    ],
+    example: '["array/prepend", [2, 3], 1] // => [1, 2, 3]'
+  },
+  "array/insert": {
+    module: "array",
+    category: "std-array",
+    minArity: 3,
+    maxArity: 3,
+    description: "Insert item at index (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "index", type: "number", description: "Index to insert at" },
+      { name: "item", type: "any", description: "Item to insert" }
+    ],
+    example: '["array/insert", [1, 3], 1, 2] // => [1, 2, 3]'
+  },
+  "array/remove": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Remove item at index (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "index", type: "number", description: "Index to remove" }
+    ],
+    example: '["array/remove", [1, 2, 3], 1] // => [1, 3]'
+  },
+  "array/removeItem": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Remove first matching item (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "item", type: "any", description: "Item to remove" }
+    ],
+    example: '["array/removeItem", [1, 2, 3, 2], 2] // => [1, 3, 2]'
+  },
+  "array/reverse": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Reverse array order (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/reverse", [1, 2, 3]] // => [3, 2, 1]'
+  },
+  "array/sort": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 3,
+    description: "Sort array (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "key", type: "string", description: "Field to sort by (for objects)", optional: true },
+      { name: "dir", type: "string", description: '"asc" or "desc"', optional: true, defaultValue: "asc" }
+    ],
+    example: '["array/sort", "@items", "price", "desc"]'
+  },
+  "array/shuffle": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Randomly shuffle array (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/shuffle", [1, 2, 3, 4, 5]]'
+  },
+  "array/unique": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Remove duplicates (returns new array)",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/unique", [1, 2, 2, 3, 1]] // => [1, 2, 3]'
+  },
+  "array/flatten": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 1,
+    description: "Flatten nested arrays one level",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "arr", type: "array", description: "The array" }],
+    example: '["array/flatten", [[1, 2], [3, 4]]] // => [1, 2, 3, 4]'
+  },
+  "array/zip": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Pair elements from two arrays",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr1", type: "array", description: "First array" },
+      { name: "arr2", type: "array", description: "Second array" }
+    ],
+    example: '["array/zip", [1, 2], ["a", "b"]] // => [[1, "a"], [2, "b"]]'
+  },
+  "array/includes": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if array contains item",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "item", type: "any", description: "Item to find" }
+    ],
+    example: '["array/includes", [1, 2, 3], 2] // => true'
+  },
+  "array/indexOf": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Find index of item (-1 if not found)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "item", type: "any", description: "Item to find" }
+    ],
+    example: '["array/indexOf", [1, 2, 3], 2] // => 1'
+  },
+  "array/find": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Find first element matching predicate",
+    hasSideEffects: false,
+    returnType: "any",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function" }
+    ],
+    example: '["array/find", "@items", ["fn", "x", ["=", "@x.status", "active"]]]'
+  },
+  "array/findIndex": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Find index of first element matching predicate (-1 if none)",
+    hasSideEffects: false,
+    returnType: "number",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function" }
+    ],
+    example: '["array/findIndex", "@items", ["fn", "x", ["=", "@x.status", "active"]]]'
+  },
+  "array/filter": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Keep elements matching predicate",
+    hasSideEffects: false,
+    returnType: "array",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function" }
+    ],
+    example: '["array/filter", "@items", ["fn", "x", [">", "@x.price", 100]]]'
+  },
+  "array/reject": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Remove elements matching predicate",
+    hasSideEffects: false,
+    returnType: "array",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function" }
+    ],
+    example: '["array/reject", "@items", ["fn", "x", ["=", "@x.status", "deleted"]]]'
+  },
+  "array/map": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Transform each element",
+    hasSideEffects: false,
+    returnType: "array",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "fn", type: "lambda", description: "Transform function" }
+    ],
+    example: '["array/map", "@items", ["fn", "x", ["*", "@x.price", 1.1]]]'
+  },
+  "array/reduce": {
+    module: "array",
+    category: "std-array",
+    minArity: 3,
+    maxArity: 3,
+    description: "Reduce array to single value",
+    hasSideEffects: false,
+    returnType: "any",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "fn", type: "lambda", description: "Reducer function (acc, item) => newAcc" },
+      { name: "init", type: "any", description: "Initial accumulator value" }
+    ],
+    example: '["array/reduce", "@items", ["fn", ["acc", "x"], ["+", "@acc", "@x.price"]], 0]'
+  },
+  "array/every": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if all elements match predicate",
+    hasSideEffects: false,
+    returnType: "boolean",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function" }
+    ],
+    example: '["array/every", "@items", ["fn", "x", [">", "@x.price", 0]]]'
+  },
+  "array/some": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if any element matches predicate",
+    hasSideEffects: false,
+    returnType: "boolean",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function" }
+    ],
+    example: '["array/some", "@items", ["fn", "x", ["=", "@x.status", "active"]]]'
+  },
+  "array/count": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 2,
+    description: "Count elements (optionally matching predicate)",
+    hasSideEffects: false,
+    returnType: "number",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function", optional: true }
+    ],
+    example: '["array/count", "@tasks", ["fn", "t", ["=", "@t.status", "done"]]]'
+  },
+  "array/sum": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 2,
+    description: "Sum values (optionally by field)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "key", type: "string", description: "Field to sum", optional: true }
+    ],
+    example: '["array/sum", "@cart.items", "price"]'
+  },
+  "array/avg": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 2,
+    description: "Average of values (optionally by field)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "key", type: "string", description: "Field to average", optional: true }
+    ],
+    example: '["array/avg", "@ratings", "score"]'
+  },
+  "array/min": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 2,
+    description: "Minimum value (optionally by field)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "key", type: "string", description: "Field to compare", optional: true }
+    ],
+    example: '["array/min", "@products", "price"]'
+  },
+  "array/max": {
+    module: "array",
+    category: "std-array",
+    minArity: 1,
+    maxArity: 2,
+    description: "Maximum value (optionally by field)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "key", type: "string", description: "Field to compare", optional: true }
+    ],
+    example: '["array/max", "@products", "price"]'
+  },
+  "array/groupBy": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Group elements by field value",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "key", type: "string", description: "Field to group by" }
+    ],
+    example: '["array/groupBy", "@orders", "status"]'
+  },
+  "array/partition": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Split array by predicate into [matches, nonMatches]",
+    hasSideEffects: false,
+    returnType: "array",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "pred", type: "lambda", description: "Predicate function" }
+    ],
+    example: '["array/partition", "@items", ["fn", "x", [">", "@x.price", 50]]]'
+  },
+  "array/take": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Take first n elements",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "n", type: "number", description: "Number of elements" }
+    ],
+    example: '["array/take", "@items", 5]'
+  },
+  "array/drop": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Skip first n elements",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "n", type: "number", description: "Number of elements to skip" }
+    ],
+    example: '["array/drop", "@items", 5]'
+  },
+  "array/takeLast": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Take last n elements",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "n", type: "number", description: "Number of elements" }
+    ],
+    example: '["array/takeLast", "@items", 3]'
+  },
+  "array/dropLast": {
+    module: "array",
+    category: "std-array",
+    minArity: 2,
+    maxArity: 2,
+    description: "Skip last n elements",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "arr", type: "array", description: "The array" },
+      { name: "n", type: "number", description: "Number of elements to skip" }
+    ],
+    example: '["array/dropLast", "@items", 2]'
+  }
+};
+
+// modules/object.ts
+var OBJECT_OPERATORS = {
+  "object/keys": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get object keys as array",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "obj", type: "object", description: "The object" }],
+    example: '["object/keys", {"a": 1, "b": 2}] // => ["a", "b"]'
+  },
+  "object/values": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get object values as array",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "obj", type: "object", description: "The object" }],
+    example: '["object/values", {"a": 1, "b": 2}] // => [1, 2]'
+  },
+  "object/entries": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get [key, value] pairs as array",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [{ name: "obj", type: "object", description: "The object" }],
+    example: '["object/entries", {"a": 1}] // => [["a", 1]]'
+  },
+  "object/fromEntries": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: 1,
+    description: "Create object from [key, value] pairs",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [{ name: "entries", type: "array", description: "Array of [key, value] pairs" }],
+    example: '["object/fromEntries", [["a", 1], ["b", 2]]] // => {"a": 1, "b": 2}'
+  },
+  "object/get": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 3,
+    description: "Get nested value by path",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "path", type: "string", description: 'Dot-separated path (e.g., "user.name")' },
+      { name: "default", type: "any", description: "Default if path not found", optional: true }
+    ],
+    example: '["object/get", "@user", "profile.name", "Anonymous"]'
+  },
+  "object/set": {
+    module: "object",
+    category: "std-object",
+    minArity: 3,
+    maxArity: 3,
+    description: "Set nested value by path (returns new object)",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "path", type: "string", description: "Dot-separated path" },
+      { name: "value", type: "any", description: "Value to set" }
+    ],
+    example: '["object/set", "@user", "profile.name", "John"]'
+  },
+  "object/has": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if path exists",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "path", type: "string", description: "Dot-separated path" }
+    ],
+    example: '["object/has", "@user", "profile.name"]'
+  },
+  "object/merge": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: null,
+    description: "Shallow merge objects (later wins)",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [{ name: "...objs", type: "object[]", description: "Objects to merge" }],
+    example: '["object/merge", {"a": 1}, {"b": 2}] // => {"a": 1, "b": 2}'
+  },
+  "object/deepMerge": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: null,
+    description: "Deep merge objects (later wins)",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [{ name: "...objs", type: "object[]", description: "Objects to merge" }],
+    example: '["object/deepMerge", {"a": {"b": 1}}, {"a": {"c": 2}}]'
+  },
+  "object/pick": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 2,
+    description: "Select only specified keys",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "keys", type: "array", description: "Keys to keep" }
+    ],
+    example: '["object/pick", "@entity", ["name", "email"]]'
+  },
+  "object/omit": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 2,
+    description: "Exclude specified keys",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "keys", type: "array", description: "Keys to exclude" }
+    ],
+    example: '["object/omit", "@entity", ["password", "secret"]]'
+  },
+  "object/mapValues": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 2,
+    description: "Transform all values",
+    hasSideEffects: false,
+    returnType: "any",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "fn", type: "lambda", description: "Transform function" }
+    ],
+    example: '["object/mapValues", "@stats", ["fn", "v", ["*", "@v", 100]]]'
+  },
+  "object/mapKeys": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 2,
+    description: "Transform all keys",
+    hasSideEffects: false,
+    returnType: "any",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "fn", type: "lambda", description: "Transform function" }
+    ],
+    example: '["object/mapKeys", "@data", ["fn", "k", ["str/upper", "@k"]]]'
+  },
+  "object/filter": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 2,
+    description: "Filter entries by predicate",
+    hasSideEffects: false,
+    returnType: "any",
+    acceptsLambda: true,
+    lambdaArgPosition: 1,
+    params: [
+      { name: "obj", type: "object", description: "The object" },
+      { name: "pred", type: "lambda", description: "Predicate (key, value) => boolean" }
+    ],
+    example: '["object/filter", "@data", ["fn", ["k", "v"], ["!=", "@v", null]]]'
+  },
+  "object/empty?": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if object has no keys",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "obj", type: "object", description: "The object" }],
+    example: '["object/empty?", {}] // => true'
+  },
+  "object/equals": {
+    module: "object",
+    category: "std-object",
+    minArity: 2,
+    maxArity: 2,
+    description: "Deep equality check",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "a", type: "object", description: "First object" },
+      { name: "b", type: "object", description: "Second object" }
+    ],
+    example: '["object/equals", {"a": 1}, {"a": 1}] // => true'
+  },
+  "object/clone": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: 1,
+    description: "Shallow clone object",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [{ name: "obj", type: "object", description: "The object" }],
+    example: '["object/clone", "@entity"]'
+  },
+  "object/deepClone": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: 1,
+    description: "Deep clone object",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [{ name: "obj", type: "object", description: "The object" }],
+    example: '["object/deepClone", "@entity"]'
+  },
+  "path": {
+    module: "object",
+    category: "std-object",
+    minArity: 1,
+    maxArity: null,
+    // variadic
+    description: "Build a dot-separated path string from segments. Used with set effect for dynamic field paths.",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "...segments", type: "string[]", description: "Path segments to join with dots" }
+    ],
+    example: '["path", "formValues", "@payload.fieldId"] // => "formValues.customerName"'
+  }
+};
+
+// modules/time.ts
+var TIME_OPERATORS = {
+  "time/now": {
+    module: "time",
+    category: "std-time",
+    minArity: 0,
+    maxArity: 0,
+    description: "Current timestamp",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [],
+    example: '["time/now"] // => 1705593600000'
+  },
+  "time/today": {
+    module: "time",
+    category: "std-time",
+    minArity: 0,
+    maxArity: 0,
+    description: "Today at midnight (local time)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [],
+    example: '["time/today"]'
+  },
+  "time/parse": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 2,
+    description: "Parse string to timestamp",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "str", type: "string", description: "Date string" },
+      { name: "format", type: "string", description: "Format pattern", optional: true }
+    ],
+    example: '["time/parse", "2024-01-18", "YYYY-MM-DD"]'
+  },
+  "time/format": {
+    module: "time",
+    category: "std-time",
+    minArity: 2,
+    maxArity: 2,
+    description: "Format timestamp to string",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "date", type: "number", description: "Timestamp" },
+      { name: "format", type: "string", description: "Format pattern" }
+    ],
+    example: '["time/format", "@entity.createdAt", "MMM DD, YYYY"]'
+  },
+  "time/year": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get year from timestamp",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/year", "@entity.createdAt"] // => 2024'
+  },
+  "time/month": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get month from timestamp (1-12)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/month", "@entity.createdAt"] // => 1'
+  },
+  "time/day": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get day of month from timestamp (1-31)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/day", "@entity.createdAt"] // => 18'
+  },
+  "time/weekday": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get day of week (0=Sunday, 6=Saturday)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/weekday", "@entity.createdAt"] // => 4 (Thursday)'
+  },
+  "time/hour": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get hour from timestamp (0-23)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/hour", "@entity.createdAt"] // => 14'
+  },
+  "time/minute": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get minute from timestamp (0-59)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/minute", "@entity.createdAt"] // => 30'
+  },
+  "time/second": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get second from timestamp (0-59)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/second", "@entity.createdAt"] // => 45'
+  },
+  "time/add": {
+    module: "time",
+    category: "std-time",
+    minArity: 3,
+    maxArity: 3,
+    description: "Add time to timestamp",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "date", type: "number", description: "Timestamp" },
+      { name: "amount", type: "number", description: "Amount to add" },
+      { name: "unit", type: "string", description: "Time unit (year/month/week/day/hour/minute/second/ms)" }
+    ],
+    example: '["time/add", ["time/now"], 7, "day"]'
+  },
+  "time/subtract": {
+    module: "time",
+    category: "std-time",
+    minArity: 3,
+    maxArity: 3,
+    description: "Subtract time from timestamp",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "date", type: "number", description: "Timestamp" },
+      { name: "amount", type: "number", description: "Amount to subtract" },
+      { name: "unit", type: "string", description: "Time unit" }
+    ],
+    example: '["time/subtract", ["time/now"], 1, "hour"]'
+  },
+  "time/diff": {
+    module: "time",
+    category: "std-time",
+    minArity: 2,
+    maxArity: 3,
+    description: "Difference between timestamps",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "a", type: "number", description: "First timestamp" },
+      { name: "b", type: "number", description: "Second timestamp" },
+      { name: "unit", type: "string", description: "Result unit", optional: true, defaultValue: "ms" }
+    ],
+    example: '["time/diff", "@entity.birthDate", ["time/now"], "year"]'
+  },
+  "time/startOf": {
+    module: "time",
+    category: "std-time",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get start of time period",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "date", type: "number", description: "Timestamp" },
+      { name: "unit", type: "string", description: "Time unit (year/month/week/day/hour/minute)" }
+    ],
+    example: '["time/startOf", ["time/now"], "month"]'
+  },
+  "time/endOf": {
+    module: "time",
+    category: "std-time",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get end of time period",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "date", type: "number", description: "Timestamp" },
+      { name: "unit", type: "string", description: "Time unit" }
+    ],
+    example: '["time/endOf", ["time/now"], "month"]'
+  },
+  "time/isBefore": {
+    module: "time",
+    category: "std-time",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if a is before b",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "a", type: "number", description: "First timestamp" },
+      { name: "b", type: "number", description: "Second timestamp" }
+    ],
+    example: '["time/isBefore", "@entity.startDate", "@entity.endDate"]'
+  },
+  "time/isAfter": {
+    module: "time",
+    category: "std-time",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if a is after b",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "a", type: "number", description: "First timestamp" },
+      { name: "b", type: "number", description: "Second timestamp" }
+    ],
+    example: '["time/isAfter", ["time/now"], "@entity.deadline"]'
+  },
+  "time/isBetween": {
+    module: "time",
+    category: "std-time",
+    minArity: 3,
+    maxArity: 3,
+    description: "Check if date is between start and end",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "date", type: "number", description: "Timestamp to check" },
+      { name: "start", type: "number", description: "Range start" },
+      { name: "end", type: "number", description: "Range end" }
+    ],
+    example: '["time/isBetween", ["time/now"], "@entity.startDate", "@entity.endDate"]'
+  },
+  "time/isSame": {
+    module: "time",
+    category: "std-time",
+    minArity: 2,
+    maxArity: 3,
+    description: "Check if timestamps are same (optionally by unit)",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "a", type: "number", description: "First timestamp" },
+      { name: "b", type: "number", description: "Second timestamp" },
+      { name: "unit", type: "string", description: "Comparison unit", optional: true }
+    ],
+    example: '["time/isSame", "@a", "@b", "day"]'
+  },
+  "time/isPast": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if timestamp is in the past",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/isPast", "@entity.expiresAt"]'
+  },
+  "time/isFuture": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if timestamp is in the future",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/isFuture", "@entity.scheduledAt"]'
+  },
+  "time/isToday": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if timestamp is today",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/isToday", "@entity.createdAt"]'
+  },
+  "time/relative": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: 'Format as relative time ("2 hours ago", "in 3 days")',
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "date", type: "number", description: "Timestamp" }],
+    example: '["time/relative", "@entity.lastActivityAt"] // => "2 hours ago"'
+  },
+  "time/duration": {
+    module: "time",
+    category: "std-time",
+    minArity: 1,
+    maxArity: 1,
+    description: 'Format milliseconds as duration ("2h 30m")',
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "ms", type: "number", description: "Duration in milliseconds" }],
+    example: '["time/duration", 9000000] // => "2h 30m"'
+  }
+};
+
+// modules/validate.ts
+var VALIDATE_OPERATORS = {
+  "validate/required": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is not null, undefined, or empty string",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "any", description: "Value to check" }],
+    example: '["validate/required", "@payload.name"]'
+  },
+  "validate/string": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a string",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "any", description: "Value to check" }],
+    example: '["validate/string", "@payload.name"]'
+  },
+  "validate/number": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a number",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "any", description: "Value to check" }],
+    example: '["validate/number", "@payload.age"]'
+  },
+  "validate/boolean": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a boolean",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "any", description: "Value to check" }],
+    example: '["validate/boolean", "@payload.active"]'
+  },
+  "validate/array": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is an array",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "any", description: "Value to check" }],
+    example: '["validate/array", "@payload.items"]'
+  },
+  "validate/object": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is an object",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "any", description: "Value to check" }],
+    example: '["validate/object", "@payload.data"]'
+  },
+  "validate/email": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a valid email format",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "string", description: "Email to validate" }],
+    example: '["validate/email", "@payload.email"]'
+  },
+  "validate/url": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a valid URL format",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "string", description: "URL to validate" }],
+    example: '["validate/url", "@payload.website"]'
+  },
+  "validate/uuid": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a valid UUID",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "string", description: "UUID to validate" }],
+    example: '["validate/uuid", "@payload.id"]'
+  },
+  "validate/phone": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a valid phone number",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "string", description: "Phone number to validate" }],
+    example: '["validate/phone", "@payload.phone"]'
+  },
+  "validate/creditCard": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a valid credit card number (Luhn algorithm)",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "string", description: "Card number to validate" }],
+    example: '["validate/creditCard", "@payload.cardNumber"]'
+  },
+  "validate/date": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 1,
+    maxArity: 1,
+    description: "Check if value is a valid date",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [{ name: "value", type: "any", description: "Value to check" }],
+    example: '["validate/date", "@payload.birthDate"]'
+  },
+  "validate/minLength": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if string/array has minimum length",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "string | array", description: "Value to check" },
+      { name: "min", type: "number", description: "Minimum length" }
+    ],
+    example: '["validate/minLength", "@payload.password", 8]'
+  },
+  "validate/maxLength": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if string/array has maximum length",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "string | array", description: "Value to check" },
+      { name: "max", type: "number", description: "Maximum length" }
+    ],
+    example: '["validate/maxLength", "@payload.name", 50]'
+  },
+  "validate/length": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if string/array has exact length",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "string | array", description: "Value to check" },
+      { name: "exact", type: "number", description: "Required length" }
+    ],
+    example: '["validate/length", "@payload.code", 6]'
+  },
+  "validate/min": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if number is >= minimum",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "number", description: "Number to check" },
+      { name: "min", type: "number", description: "Minimum value" }
+    ],
+    example: '["validate/min", "@payload.age", 18]'
+  },
+  "validate/max": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if number is <= maximum",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "number", description: "Number to check" },
+      { name: "max", type: "number", description: "Maximum value" }
+    ],
+    example: '["validate/max", "@payload.quantity", 100]'
+  },
+  "validate/range": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 3,
+    maxArity: 3,
+    description: "Check if number is within range [min, max]",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "number", description: "Number to check" },
+      { name: "min", type: "number", description: "Minimum value" },
+      { name: "max", type: "number", description: "Maximum value" }
+    ],
+    example: '["validate/range", "@payload.rating", 1, 5]'
+  },
+  "validate/pattern": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if string matches regex pattern",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "string", description: "String to check" },
+      { name: "regex", type: "string", description: "Regex pattern" }
+    ],
+    example: '["validate/pattern", "@payload.code", "^[A-Z]{3}[0-9]{3}$"]'
+  },
+  "validate/oneOf": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if value is in list of allowed values",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "any", description: "Value to check" },
+      { name: "options", type: "array", description: "Allowed values" }
+    ],
+    example: '["validate/oneOf", "@payload.role", ["admin", "user", "guest"]]'
+  },
+  "validate/noneOf": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if value is not in list of disallowed values",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "value", type: "any", description: "Value to check" },
+      { name: "options", type: "array", description: "Disallowed values" }
+    ],
+    example: '["validate/noneOf", "@payload.username", ["admin", "root", "system"]]'
+  },
+  "validate/equals": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Deep equality check",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "a", type: "any", description: "First value" },
+      { name: "b", type: "any", description: "Second value" }
+    ],
+    example: '["validate/equals", "@payload.password", "@payload.confirmPassword"]'
+  },
+  "validate/check": {
+    module: "validate",
+    category: "std-validate",
+    minArity: 2,
+    maxArity: 2,
+    description: "Run multiple validation rules, return { valid, errors }",
+    hasSideEffects: false,
+    returnType: "any",
+    params: [
+      { name: "value", type: "any", description: "Value or object to validate" },
+      { name: "rules", type: "object", description: "Validation rules by field" }
+    ],
+    example: `["validate/check", "@payload.data", {
+  "name": [["required"], ["minLength", 2], ["maxLength", 50]],
+  "email": [["required"], ["email"]],
+  "age": [["number"], ["min", 18]]
+}]`
+  }
+};
+
+// modules/format.ts
+var FORMAT_OPERATORS = {
+  "format/number": {
+    module: "format",
+    category: "std-format",
+    minArity: 1,
+    maxArity: 2,
+    description: "Format number with locale-aware separators",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "n", type: "number", description: "Number to format" },
+      { name: "opts", type: "object", description: "Format options (decimals, locale)", optional: true }
+    ],
+    example: '["format/number", 1234567.89] // => "1,234,567.89"'
+  },
+  "format/currency": {
+    module: "format",
+    category: "std-format",
+    minArity: 2,
+    maxArity: 3,
+    description: "Format as currency",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "n", type: "number", description: "Amount" },
+      { name: "currency", type: "string", description: "Currency code (USD, EUR, etc.)" },
+      { name: "locale", type: "string", description: "Locale", optional: true, defaultValue: "en-US" }
+    ],
+    example: '["format/currency", 1234.56, "USD"] // => "$1,234.56"'
+  },
+  "format/percent": {
+    module: "format",
+    category: "std-format",
+    minArity: 1,
+    maxArity: 2,
+    description: "Format as percentage",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "n", type: "number", description: "Number (0.5 = 50%)" },
+      { name: "decimals", type: "number", description: "Decimal places", optional: true, defaultValue: 0 }
+    ],
+    example: '["format/percent", 0.856, 1] // => "85.6%"'
+  },
+  "format/bytes": {
+    module: "format",
+    category: "std-format",
+    minArity: 1,
+    maxArity: 1,
+    description: "Format bytes as human-readable size",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "n", type: "number", description: "Bytes" }],
+    example: '["format/bytes", 2500000] // => "2.4 MB"'
+  },
+  "format/ordinal": {
+    module: "format",
+    category: "std-format",
+    minArity: 1,
+    maxArity: 1,
+    description: "Format number as ordinal (1st, 2nd, 3rd)",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "n", type: "number", description: "Number" }],
+    example: '["format/ordinal", 42] // => "42nd"'
+  },
+  "format/plural": {
+    module: "format",
+    category: "std-format",
+    minArity: 3,
+    maxArity: 3,
+    description: "Format count with singular/plural word",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "n", type: "number", description: "Count" },
+      { name: "singular", type: "string", description: "Singular form" },
+      { name: "plural", type: "string", description: "Plural form" }
+    ],
+    example: '["format/plural", 5, "item", "items"] // => "5 items"'
+  },
+  "format/list": {
+    module: "format",
+    category: "std-format",
+    minArity: 1,
+    maxArity: 2,
+    description: "Format array as natural language list",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "arr", type: "array", description: "Array of strings" },
+      { name: "style", type: "string", description: '"and" or "or"', optional: true, defaultValue: "and" }
+    ],
+    example: '["format/list", ["Alice", "Bob", "Charlie"], "and"] // => "Alice, Bob, and Charlie"'
+  },
+  "format/phone": {
+    module: "format",
+    category: "std-format",
+    minArity: 1,
+    maxArity: 2,
+    description: "Format phone number",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [
+      { name: "str", type: "string", description: "Phone number digits" },
+      { name: "format", type: "string", description: "Format pattern", optional: true, defaultValue: "US" }
+    ],
+    example: '["format/phone", "5551234567"] // => "(555) 123-4567"'
+  },
+  "format/creditCard": {
+    module: "format",
+    category: "std-format",
+    minArity: 1,
+    maxArity: 1,
+    description: "Format credit card with masked digits",
+    hasSideEffects: false,
+    returnType: "string",
+    params: [{ name: "str", type: "string", description: "Card number" }],
+    example: '["format/creditCard", "4111111111111234"] // => "\u2022\u2022\u2022\u2022 \u2022\u2022\u2022\u2022 \u2022\u2022\u2022\u2022 1234"'
+  }
+};
+
+// modules/async.ts
+var ASYNC_OPERATORS = {
+  "async/delay": {
+    module: "async",
+    category: "std-async",
+    minArity: 1,
+    maxArity: 1,
+    description: "Wait for specified milliseconds",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [{ name: "ms", type: "number", description: "Milliseconds to wait" }],
+    example: '["async/delay", 2000] // Wait 2 seconds'
+  },
+  "async/timeout": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: 2,
+    description: "Add timeout to an effect",
+    hasSideEffects: true,
+    returnType: "any",
+    params: [
+      { name: "effect", type: "expression", description: "Effect to execute" },
+      { name: "ms", type: "number", description: "Timeout in milliseconds" }
+    ],
+    example: '["async/timeout", ["call", "api", "fetchData"], 5000]'
+  },
+  "async/debounce": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: 2,
+    description: "Debounce an event (wait for pause in events)",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [
+      { name: "event", type: "string", description: "Event name to emit" },
+      { name: "ms", type: "number", description: "Debounce delay in milliseconds" }
+    ],
+    example: '["async/debounce", "SEARCH", 300]'
+  },
+  "async/throttle": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: 2,
+    description: "Throttle an event (emit at most once per interval)",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [
+      { name: "event", type: "string", description: "Event name to emit" },
+      { name: "ms", type: "number", description: "Throttle interval in milliseconds" }
+    ],
+    example: '["async/throttle", "SCROLL", 100]'
+  },
+  "async/retry": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: 2,
+    description: "Retry an effect with configurable backoff",
+    hasSideEffects: true,
+    returnType: "any",
+    params: [
+      { name: "effect", type: "expression", description: "Effect to retry" },
+      { name: "opts", type: "object", description: "{ attempts, backoff, baseDelay }" }
+    ],
+    example: `["async/retry",
+  ["call", "api", "fetchData", { "id": "@entity.id" }],
+  { "attempts": 3, "backoff": "exponential", "baseDelay": 1000 }]`
+  },
+  "async/race": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: null,
+    description: "Execute effects in parallel, return first to complete",
+    hasSideEffects: true,
+    returnType: "any",
+    params: [{ name: "...effects", type: "expression[]", description: "Effects to race" }],
+    example: '["async/race", ["call", "api1"], ["call", "api2"]]'
+  },
+  "async/all": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: null,
+    description: "Execute effects in parallel, wait for all to complete",
+    hasSideEffects: true,
+    returnType: "array",
+    params: [{ name: "...effects", type: "expression[]", description: "Effects to execute" }],
+    example: '["async/all", ["call", "api1"], ["call", "api2"]]'
+  },
+  "async/sequence": {
+    module: "async",
+    category: "std-async",
+    minArity: 2,
+    maxArity: null,
+    description: "Execute effects in sequence (one after another)",
+    hasSideEffects: true,
+    returnType: "array",
+    params: [{ name: "...effects", type: "expression[]", description: "Effects to execute in order" }],
+    example: '["async/sequence", ["call", "validate"], ["call", "save"]]'
+  }
+};
+
+// modules/nn.ts
+var NN_OPERATORS = {
+  "nn/sequential": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 1,
+    maxArity: null,
+    description: "Create a sequential neural network from layers",
+    hasSideEffects: false,
+    returnType: "nn/module",
+    params: [
+      { name: "...layers", type: "nn/layer[]", description: "Layers to stack sequentially" }
+    ],
+    example: '["nn/sequential", ["nn/linear", 16, 64], ["nn/relu"], ["nn/linear", 64, 4]]'
+  },
+  "nn/linear": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 2,
+    maxArity: 2,
+    description: "Fully connected linear layer (output = input * weights + bias)",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [
+      { name: "inFeatures", type: "number", description: "Input dimension" },
+      { name: "outFeatures", type: "number", description: "Output dimension" }
+    ],
+    example: '["nn/linear", 16, 64] // 16 inputs -> 64 outputs'
+  },
+  "nn/relu": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 0,
+    maxArity: 0,
+    description: "ReLU activation function: max(0, x)",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [],
+    example: '["nn/relu"]'
+  },
+  "nn/tanh": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 0,
+    maxArity: 0,
+    description: "Tanh activation function: (e^x - e^-x) / (e^x + e^-x)",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [],
+    example: '["nn/tanh"]'
+  },
+  "nn/sigmoid": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 0,
+    maxArity: 0,
+    description: "Sigmoid activation function: 1 / (1 + e^-x)",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [],
+    example: '["nn/sigmoid"]'
+  },
+  "nn/softmax": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 0,
+    maxArity: 1,
+    description: "Softmax activation function (normalizes to probability distribution)",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [
+      { name: "dim", type: "number", description: "Dimension to apply softmax", optional: true, defaultValue: -1 }
+    ],
+    example: '["nn/softmax"]'
+  },
+  "nn/dropout": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 0,
+    maxArity: 1,
+    description: "Dropout layer for regularization (randomly zeros elements during training)",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [
+      { name: "p", type: "number", description: "Dropout probability", optional: true, defaultValue: 0.5 }
+    ],
+    example: '["nn/dropout", 0.3] // 30% dropout'
+  },
+  "nn/batchnorm": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 1,
+    maxArity: 1,
+    description: "Batch normalization layer",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [
+      { name: "numFeatures", type: "number", description: "Number of features to normalize" }
+    ],
+    example: '["nn/batchnorm", 64]'
+  },
+  "nn/layernorm": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 1,
+    maxArity: 1,
+    description: "Layer normalization",
+    hasSideEffects: false,
+    returnType: "nn/layer",
+    params: [
+      { name: "normalizedShape", type: "number | number[]", description: "Shape to normalize over" }
+    ],
+    example: '["nn/layernorm", 64]'
+  },
+  "nn/forward": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 2,
+    maxArity: 2,
+    description: "Execute forward pass through network",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network module" },
+      { name: "input", type: "tensor", description: "Input tensor" }
+    ],
+    example: '["nn/forward", "@entity.architecture", "@entity.sensors"]'
+  },
+  "nn/getWeights": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get network weights as a flat tensor",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network module" }
+    ],
+    example: '["nn/getWeights", "@entity.architecture"]'
+  },
+  "nn/setWeights": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 2,
+    maxArity: 2,
+    description: "Set network weights from a flat tensor",
+    hasSideEffects: true,
+    returnType: "nn/module",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network module" },
+      { name: "weights", type: "tensor", description: "New weights as flat tensor" }
+    ],
+    example: '["nn/setWeights", "@entity.architecture", "@payload.newWeights"]'
+  },
+  "nn/paramCount": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get total number of trainable parameters",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network module" }
+    ],
+    example: '["nn/paramCount", "@entity.architecture"] // => 3300'
+  },
+  "nn/clone": {
+    module: "nn",
+    category: "std-nn",
+    minArity: 1,
+    maxArity: 1,
+    description: "Create a deep copy of the network with same weights",
+    hasSideEffects: false,
+    returnType: "nn/module",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network module to clone" }
+    ],
+    example: '["nn/clone", "@entity.architecture"]'
+  }
+};
+
+// modules/tensor.ts
+var TENSOR_OPERATORS = {
+  // ============================================================================
+  // Creation
+  // ============================================================================
+  "tensor/from": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Create tensor from array",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "data", type: "array", description: "Array of numbers (can be nested for multi-dimensional)" }
+    ],
+    example: '["tensor/from", [1.0, 2.0, 3.0]]'
+  },
+  "tensor/zeros": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Create tensor filled with zeros",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "shape", type: "number[]", description: "Shape of the tensor" }
+    ],
+    example: '["tensor/zeros", [3, 4]] // 3x4 tensor of zeros'
+  },
+  "tensor/ones": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Create tensor filled with ones",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "shape", type: "number[]", description: "Shape of the tensor" }
+    ],
+    example: '["tensor/ones", [3, 4]] // 3x4 tensor of ones'
+  },
+  "tensor/rand": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Create tensor with random values in [0, 1)",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "shape", type: "number[]", description: "Shape of the tensor" }
+    ],
+    example: '["tensor/rand", [16]] // Random 16-element vector'
+  },
+  "tensor/randn": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Create tensor with random values from standard normal distribution",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "shape", type: "number[]", description: "Shape of the tensor" }
+    ],
+    example: '["tensor/randn", [16]] // Random normal 16-element vector'
+  },
+  // ============================================================================
+  // Shape & Indexing
+  // ============================================================================
+  "tensor/shape": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get tensor shape as array",
+    hasSideEffects: false,
+    returnType: "number[]",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" }
+    ],
+    example: '["tensor/shape", "@entity.sensors"] // => [16]'
+  },
+  "tensor/get": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get element at index",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "index", type: "number | number[]", description: "Index (single for 1D, array for multi-D)" }
+    ],
+    example: '["tensor/get", "@entity.output", 3] // Get 4th element'
+  },
+  "tensor/slice": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 3,
+    maxArity: 3,
+    description: "Get slice of tensor",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "start", type: "number", description: "Start index" },
+      { name: "end", type: "number", description: "End index (exclusive)" }
+    ],
+    example: '["tensor/slice", "@entity.output", 0, 3] // First 3 elements'
+  },
+  "tensor/reshape": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Reshape tensor to new shape (total elements must match)",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "shape", type: "number[]", description: "New shape" }
+    ],
+    example: '["tensor/reshape", "@entity.data", [4, 4]] // Reshape to 4x4'
+  },
+  "tensor/flatten": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Flatten tensor to 1D",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" }
+    ],
+    example: '["tensor/flatten", "@entity.data"]'
+  },
+  // ============================================================================
+  // Math Operations
+  // ============================================================================
+  "tensor/add": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Element-wise addition",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "a", type: "tensor", description: "First tensor" },
+      { name: "b", type: "tensor | number", description: "Second tensor or scalar" }
+    ],
+    example: '["tensor/add", "@entity.a", "@entity.b"]'
+  },
+  "tensor/sub": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Element-wise subtraction",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "a", type: "tensor", description: "First tensor" },
+      { name: "b", type: "tensor | number", description: "Second tensor or scalar" }
+    ],
+    example: '["tensor/sub", "@entity.a", "@entity.b"]'
+  },
+  "tensor/mul": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Element-wise multiplication",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "a", type: "tensor", description: "First tensor" },
+      { name: "b", type: "tensor | number", description: "Second tensor or scalar" }
+    ],
+    example: '["tensor/mul", "@entity.weights", 0.99] // Decay weights'
+  },
+  "tensor/div": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Element-wise division",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "a", type: "tensor", description: "First tensor" },
+      { name: "b", type: "tensor | number", description: "Second tensor or scalar" }
+    ],
+    example: '["tensor/div", "@entity.gradient", "@entity.batchSize"]'
+  },
+  "tensor/matmul": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Matrix multiplication",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "a", type: "tensor", description: "First tensor (NxM)" },
+      { name: "b", type: "tensor", description: "Second tensor (MxK)" }
+    ],
+    example: '["tensor/matmul", "@entity.input", "@entity.weights"]'
+  },
+  "tensor/dot": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Dot product of two 1D tensors",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "a", type: "tensor", description: "First vector" },
+      { name: "b", type: "tensor", description: "Second vector" }
+    ],
+    example: '["tensor/dot", "@entity.a", "@entity.b"]'
+  },
+  // ============================================================================
+  // Reductions
+  // ============================================================================
+  "tensor/sum": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 2,
+    description: "Sum of tensor elements",
+    hasSideEffects: false,
+    returnType: "number | tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "dim", type: "number", description: "Dimension to reduce", optional: true }
+    ],
+    example: '["tensor/sum", "@entity.rewards"] // Total reward'
+  },
+  "tensor/mean": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 2,
+    description: "Mean of tensor elements",
+    hasSideEffects: false,
+    returnType: "number | tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "dim", type: "number", description: "Dimension to reduce", optional: true }
+    ],
+    example: '["tensor/mean", "@entity.losses"]'
+  },
+  "tensor/max": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 2,
+    description: "Maximum value in tensor",
+    hasSideEffects: false,
+    returnType: "number | tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "dim", type: "number", description: "Dimension to reduce", optional: true }
+    ],
+    example: '["tensor/max", "@entity.qValues"]'
+  },
+  "tensor/min": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 2,
+    description: "Minimum value in tensor",
+    hasSideEffects: false,
+    returnType: "number | tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "dim", type: "number", description: "Dimension to reduce", optional: true }
+    ],
+    example: '["tensor/min", "@entity.distances"]'
+  },
+  "tensor/argmax": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 2,
+    description: "Index of maximum value",
+    hasSideEffects: false,
+    returnType: "number | tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "dim", type: "number", description: "Dimension to reduce", optional: true }
+    ],
+    example: '["tensor/argmax", "@entity.qValues"] // Best action index'
+  },
+  "tensor/norm": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 2,
+    description: "L2 norm of tensor",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "p", type: "number", description: "Norm order (default 2)", optional: true, defaultValue: 2 }
+    ],
+    example: '["tensor/norm", "@entity.gradient"]'
+  },
+  // ============================================================================
+  // Range Validation (for contracts)
+  // ============================================================================
+  "tensor/allInRange": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if all elements are within range [min, max]",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "range", type: "[number, number]", description: "Range as [min, max]" }
+    ],
+    example: '["tensor/allInRange", "@payload.input", [-1.0, 1.0]]'
+  },
+  "tensor/outOfRangeIndices": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get indices of elements outside range",
+    hasSideEffects: false,
+    returnType: "number[]",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "range", type: "[number, number]", description: "Range as [min, max]" }
+    ],
+    example: '["tensor/outOfRangeIndices", "@payload.input", [-1.0, 1.0]]'
+  },
+  "tensor/clamp": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 3,
+    maxArity: 3,
+    description: "Clamp all elements to range [min, max]",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "min", type: "number", description: "Minimum value" },
+      { name: "max", type: "number", description: "Maximum value" }
+    ],
+    example: '["tensor/clamp", "@entity.output", -10.0, 10.0]'
+  },
+  "tensor/clampPerDim": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Clamp each dimension to its specified range",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "ranges", type: "object", description: 'Per-dimension ranges { "0": {min, max}, ... }' }
+    ],
+    example: '["tensor/clampPerDim", "@entity.rawOutput", "@entity.outputContract.ranges"]'
+  },
+  "tensor/outOfRangeDims": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 2,
+    maxArity: 2,
+    description: "Get dimensions that exceed their specified ranges",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" },
+      { name: "ranges", type: "object", description: 'Per-dimension ranges { "0": {min, max}, ... }' }
+    ],
+    example: '["tensor/outOfRangeDims", "@entity.rawOutput", "@entity.outputContract.ranges"]'
+  },
+  // ============================================================================
+  // Conversion
+  // ============================================================================
+  "tensor/toArray": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert tensor to nested array",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor" }
+    ],
+    example: '["tensor/toArray", "@entity.output"]'
+  },
+  "tensor/toList": {
+    module: "tensor",
+    category: "std-tensor",
+    minArity: 1,
+    maxArity: 1,
+    description: "Convert 1D tensor to flat array",
+    hasSideEffects: false,
+    returnType: "number[]",
+    params: [
+      { name: "tensor", type: "tensor", description: "The tensor (must be 1D)" }
+    ],
+    example: '["tensor/toList", "@entity.output"]'
+  }
+};
+
+// modules/train.ts
+var TRAIN_OPERATORS = {
+  // ============================================================================
+  // Training Loop
+  // ============================================================================
+  "train/loop": {
+    module: "train",
+    category: "std-train",
+    minArity: 3,
+    maxArity: 3,
+    description: "Execute training loop with constraints",
+    hasSideEffects: true,
+    returnType: "train/result",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network to train" },
+      { name: "data", type: "array", description: "Training data (array of {input, target} or experiences)" },
+      { name: "config", type: "train/config", description: "Training configuration with constraints" }
+    ],
+    example: '["train/loop", "@entity.architecture", "@entity.buffer", "@entity.trainingConfig"]'
+  },
+  "train/step": {
+    module: "train",
+    category: "std-train",
+    minArity: 4,
+    maxArity: 4,
+    description: "Execute single training step (forward, loss, backward, update)",
+    hasSideEffects: true,
+    returnType: "train/stepResult",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "input", type: "tensor", description: "Input tensor" },
+      { name: "target", type: "tensor", description: "Target tensor" },
+      { name: "config", type: "train/config", description: "Training configuration" }
+    ],
+    example: '["train/step", "@entity.architecture", "@batch.input", "@batch.target", "@entity.config"]'
+  },
+  // ============================================================================
+  // Validation
+  // ============================================================================
+  "train/validate": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Validate model on test cases, returns pass/fail metrics",
+    hasSideEffects: false,
+    returnType: "train/validationResult",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "testCases", type: "array", description: "Array of {input, expected, tolerance?}" }
+    ],
+    example: '["train/validate", "@entity.architecture", "@entity.validationSet"]'
+  },
+  "train/checkRegression": {
+    module: "train",
+    category: "std-train",
+    minArity: 3,
+    maxArity: 3,
+    description: "Check if new model regresses on required invariants",
+    hasSideEffects: false,
+    returnType: "train/regressionResult",
+    params: [
+      { name: "newModule", type: "nn/module", description: "Newly trained network" },
+      { name: "oldModule", type: "nn/module", description: "Previous network" },
+      { name: "invariants", type: "array", description: "Test cases that must not regress" }
+    ],
+    example: '["train/checkRegression", "@payload.newWeights", "@entity.architecture", "@entity.requiredInvariants"]'
+  },
+  // ============================================================================
+  // Constraint Checking
+  // ============================================================================
+  "train/checkConstraints": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if network weights satisfy all constraints",
+    hasSideEffects: false,
+    returnType: "train/constraintResult",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "constraints", type: "train/constraints", description: "Constraint specification" }
+    ],
+    example: '["train/checkConstraints", "@payload.newWeights", "@entity.constraints"]'
+  },
+  "train/checkWeightMagnitude": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Check if all weights are within magnitude limit",
+    hasSideEffects: false,
+    returnType: "boolean",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "maxMagnitude", type: "number", description: "Maximum allowed weight magnitude" }
+    ],
+    example: '["train/checkWeightMagnitude", "@entity.architecture", 10.0]'
+  },
+  "train/checkForbiddenOutputs": {
+    module: "train",
+    category: "std-train",
+    minArity: 3,
+    maxArity: 3,
+    description: "Check if model produces outputs in forbidden regions",
+    hasSideEffects: false,
+    returnType: "train/forbiddenResult",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "testInputs", type: "array", description: "Inputs to test" },
+      { name: "forbiddenRegions", type: "array", description: "Forbidden output regions" }
+    ],
+    example: '["train/checkForbiddenOutputs", "@entity.architecture", "@entity.testInputs", "@entity.forbiddenOutputRegions"]'
+  },
+  // ============================================================================
+  // Gradient Operations
+  // ============================================================================
+  "train/clipGradients": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Clip gradients to max norm (modifies in place)",
+    hasSideEffects: true,
+    returnType: "number",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "maxNorm", type: "number", description: "Maximum gradient norm" }
+    ],
+    example: '["train/clipGradients", "@entity.architecture", 1.0]'
+  },
+  "train/getGradientNorm": {
+    module: "train",
+    category: "std-train",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get current gradient norm",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" }
+    ],
+    example: '["train/getGradientNorm", "@entity.architecture"]'
+  },
+  // ============================================================================
+  // Weight Operations
+  // ============================================================================
+  "train/clipWeights": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Clip weights to max magnitude (modifies in place)",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "maxMagnitude", type: "number", description: "Maximum weight magnitude" }
+    ],
+    example: '["train/clipWeights", "@entity.architecture", 10.0]'
+  },
+  "train/getMaxWeightMagnitude": {
+    module: "train",
+    category: "std-train",
+    minArity: 1,
+    maxArity: 1,
+    description: "Get maximum weight magnitude in network",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" }
+    ],
+    example: '["train/getMaxWeightMagnitude", "@entity.architecture"]'
+  },
+  // ============================================================================
+  // Loss Functions
+  // ============================================================================
+  "train/mse": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Mean squared error loss",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "predicted", type: "tensor", description: "Predicted values" },
+      { name: "target", type: "tensor", description: "Target values" }
+    ],
+    example: '["train/mse", "@entity.output", "@batch.target"]'
+  },
+  "train/crossEntropy": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Cross-entropy loss for classification",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "logits", type: "tensor", description: "Raw model outputs (logits)" },
+      { name: "labels", type: "tensor", description: "Target class labels" }
+    ],
+    example: '["train/crossEntropy", "@entity.logits", "@batch.labels"]'
+  },
+  "train/huber": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 3,
+    description: "Huber loss (smooth L1, robust to outliers)",
+    hasSideEffects: false,
+    returnType: "number",
+    params: [
+      { name: "predicted", type: "tensor", description: "Predicted values" },
+      { name: "target", type: "tensor", description: "Target values" },
+      { name: "delta", type: "number", description: "Threshold for quadratic vs linear", optional: true, defaultValue: 1 }
+    ],
+    example: '["train/huber", "@entity.qValues", "@batch.targets", 1.0]'
+  },
+  // ============================================================================
+  // Optimizers
+  // ============================================================================
+  "train/sgd": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 3,
+    description: "Stochastic gradient descent optimizer step",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "lr", type: "number", description: "Learning rate" },
+      { name: "momentum", type: "number", description: "Momentum factor", optional: true, defaultValue: 0 }
+    ],
+    example: '["train/sgd", "@entity.architecture", 0.01, 0.9]'
+  },
+  "train/adam": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 4,
+    description: "Adam optimizer step",
+    hasSideEffects: true,
+    returnType: "void",
+    params: [
+      { name: "module", type: "nn/module", description: "The neural network" },
+      { name: "lr", type: "number", description: "Learning rate" },
+      { name: "beta1", type: "number", description: "First moment decay", optional: true, defaultValue: 0.9 },
+      { name: "beta2", type: "number", description: "Second moment decay", optional: true, defaultValue: 0.999 }
+    ],
+    example: '["train/adam", "@entity.architecture", 0.001]'
+  },
+  // ============================================================================
+  // Experience Replay (for RL)
+  // ============================================================================
+  "train/sampleBatch": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Sample random batch from experience buffer",
+    hasSideEffects: false,
+    returnType: "array",
+    params: [
+      { name: "buffer", type: "array", description: "Experience buffer" },
+      { name: "batchSize", type: "number", description: "Number of samples" }
+    ],
+    example: '["train/sampleBatch", "@entity.experienceBuffer", 32]'
+  },
+  "train/computeReturns": {
+    module: "train",
+    category: "std-train",
+    minArity: 2,
+    maxArity: 2,
+    description: "Compute discounted returns from rewards",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "rewards", type: "array", description: "Array of rewards" },
+      { name: "gamma", type: "number", description: "Discount factor" }
+    ],
+    example: '["train/computeReturns", "@episode.rewards", 0.99]'
+  },
+  "train/computeAdvantages": {
+    module: "train",
+    category: "std-train",
+    minArity: 3,
+    maxArity: 3,
+    description: "Compute GAE advantages for policy gradient",
+    hasSideEffects: false,
+    returnType: "tensor",
+    params: [
+      { name: "rewards", type: "array", description: "Array of rewards" },
+      { name: "values", type: "tensor", description: "Value estimates" },
+      { name: "config", type: "object", description: "Config with gamma, lambda" }
+    ],
+    example: '["train/computeAdvantages", "@episode.rewards", "@episode.values", { "gamma": 0.99, "lambda": 0.95 }]'
+  }
+};
+
+// registry.ts
+var STD_OPERATORS = {
+  ...MATH_OPERATORS,
+  ...STR_OPERATORS,
+  ...ARRAY_OPERATORS,
+  ...OBJECT_OPERATORS,
+  ...TIME_OPERATORS,
+  ...VALIDATE_OPERATORS,
+  ...FORMAT_OPERATORS,
+  ...ASYNC_OPERATORS,
+  ...NN_OPERATORS,
+  ...TENSOR_OPERATORS,
+  ...TRAIN_OPERATORS
+};
+var STD_OPERATORS_BY_MODULE = {
+  math: MATH_OPERATORS,
+  str: STR_OPERATORS,
+  array: ARRAY_OPERATORS,
+  object: OBJECT_OPERATORS,
+  time: TIME_OPERATORS,
+  validate: VALIDATE_OPERATORS,
+  format: FORMAT_OPERATORS,
+  async: ASYNC_OPERATORS,
+  nn: NN_OPERATORS,
+  tensor: TENSOR_OPERATORS,
+  train: TRAIN_OPERATORS
+};
+function getStdOperatorMeta(operator) {
+  return STD_OPERATORS[operator];
+}
+function isKnownStdOperator(operator) {
+  return operator in STD_OPERATORS;
+}
+function getModuleOperators(module) {
+  return STD_OPERATORS_BY_MODULE[module] || {};
+}
+function getAllStdOperators() {
+  return Object.keys(STD_OPERATORS);
+}
+function getStdOperatorsByModule(module) {
+  return Object.keys(STD_OPERATORS_BY_MODULE[module] || {});
+}
+function getLambdaOperators() {
+  return Object.entries(STD_OPERATORS).filter(([, meta]) => meta.acceptsLambda).map(([name]) => name);
+}
+function getStdEffectOperators() {
+  return Object.entries(STD_OPERATORS).filter(([, meta]) => meta.hasSideEffects).map(([name]) => name);
+}
+function getStdPureOperators() {
+  return Object.entries(STD_OPERATORS).filter(([, meta]) => !meta.hasSideEffects).map(([name]) => name);
+}
+function validateStdOperatorArity(operator, argCount) {
+  const meta = STD_OPERATORS[operator];
+  if (!meta) {
+    return `Unknown std operator: ${operator}`;
+  }
+  if (argCount < meta.minArity) {
+    return `Operator '${operator}' requires at least ${meta.minArity} argument(s), got ${argCount}`;
+  }
+  if (meta.maxArity !== null && argCount > meta.maxArity) {
+    return `Operator '${operator}' accepts at most ${meta.maxArity} argument(s), got ${argCount}`;
+  }
+  return null;
+}
+function isStdGuardOperator(operator) {
+  const meta = STD_OPERATORS[operator];
+  return meta !== void 0 && !meta.hasSideEffects;
+}
+function isStdEffectOperator(operator) {
+  const meta = STD_OPERATORS[operator];
+  return meta?.hasSideEffects ?? false;
+}
+function getOperatorMetaExtended(operator, coreOperators) {
+  if (isStdOperator(operator)) {
+    return STD_OPERATORS[operator];
+  }
+  return coreOperators[operator];
+}
+function isKnownOperatorExtended(operator, coreOperators) {
+  if (isStdOperator(operator)) {
+    return operator in STD_OPERATORS;
+  }
+  return operator in coreOperators;
+}
+function validateOperatorArityExtended(operator, argCount, coreOperators) {
+  if (isStdOperator(operator)) {
+    return validateStdOperatorArity(operator, argCount);
+  }
+  const meta = coreOperators[operator];
+  if (!meta) {
+    return `Unknown operator: ${operator}`;
+  }
+  if (argCount < meta.minArity) {
+    return `Operator '${operator}' requires at least ${meta.minArity} argument(s), got ${argCount}`;
+  }
+  if (meta.maxArity !== null && argCount > meta.maxArity) {
+    return `Operator '${operator}' accepts at most ${meta.maxArity} argument(s), got ${argCount}`;
+  }
+  return null;
+}
+function isEffectOperatorExtended(operator, coreOperators) {
+  if (isStdOperator(operator)) {
+    return isStdEffectOperator(operator);
+  }
+  const meta = coreOperators[operator];
+  return meta?.hasSideEffects ?? false;
+}
+function getStdLibStats() {
+  const byModule = {};
+  for (const module of STD_MODULES) {
+    byModule[module] = Object.keys(STD_OPERATORS_BY_MODULE[module] || {}).length;
+  }
+  return {
+    totalOperators: Object.keys(STD_OPERATORS).length,
+    byModule,
+    pureOperators: getStdPureOperators().length,
+    effectOperators: getStdEffectOperators().length,
+    lambdaOperators: getLambdaOperators().length
+  };
+}
+
+export { STD_OPERATORS, STD_OPERATORS_BY_MODULE, getAllStdOperators, getLambdaOperators, getModuleOperators, getOperatorMetaExtended, getStdEffectOperators, getStdLibStats, getStdOperatorMeta, getStdOperatorsByModule, getStdPureOperators, isEffectOperatorExtended, isKnownOperatorExtended, isKnownStdOperator, isStdEffectOperator, isStdGuardOperator, validateOperatorArityExtended, validateStdOperatorArity };
+//# sourceMappingURL=registry.js.map
+//# sourceMappingURL=registry.js.map