@almadar/std 16.24.0 → 16.24.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/canonical-operators.json +2855 -0
- package/package.json +3 -2
|
@@ -0,0 +1,2855 @@
|
|
|
1
|
+
{
|
|
2
|
+
"version": "2.0.0",
|
|
3
|
+
"description": "Canonical operator registry for Almadar. Generated from @almadar/std/modules. Consumed by orbital-compiler via include_str!.",
|
|
4
|
+
"generated": "2026-06-04T18:20:04.559Z",
|
|
5
|
+
"categories": {
|
|
6
|
+
"arithmetic": {
|
|
7
|
+
"description": "Numeric operations",
|
|
8
|
+
"target": [
|
|
9
|
+
"ts",
|
|
10
|
+
"rust"
|
|
11
|
+
]
|
|
12
|
+
},
|
|
13
|
+
"comparison": {
|
|
14
|
+
"description": "Value comparison",
|
|
15
|
+
"target": [
|
|
16
|
+
"ts",
|
|
17
|
+
"rust"
|
|
18
|
+
]
|
|
19
|
+
},
|
|
20
|
+
"logic": {
|
|
21
|
+
"description": "Boolean logic",
|
|
22
|
+
"target": [
|
|
23
|
+
"ts",
|
|
24
|
+
"rust"
|
|
25
|
+
]
|
|
26
|
+
},
|
|
27
|
+
"control": {
|
|
28
|
+
"description": "Control flow",
|
|
29
|
+
"target": [
|
|
30
|
+
"ts",
|
|
31
|
+
"rust"
|
|
32
|
+
]
|
|
33
|
+
},
|
|
34
|
+
"effect": {
|
|
35
|
+
"description": "Side effects (runtime only)",
|
|
36
|
+
"target": [
|
|
37
|
+
"ts"
|
|
38
|
+
]
|
|
39
|
+
},
|
|
40
|
+
"collection": {
|
|
41
|
+
"description": "Collection operations",
|
|
42
|
+
"target": [
|
|
43
|
+
"ts",
|
|
44
|
+
"rust"
|
|
45
|
+
]
|
|
46
|
+
},
|
|
47
|
+
"std-math": {
|
|
48
|
+
"description": "Math utilities",
|
|
49
|
+
"target": [
|
|
50
|
+
"ts",
|
|
51
|
+
"rust"
|
|
52
|
+
]
|
|
53
|
+
},
|
|
54
|
+
"std-str": {
|
|
55
|
+
"description": "String utilities",
|
|
56
|
+
"target": [
|
|
57
|
+
"ts",
|
|
58
|
+
"rust"
|
|
59
|
+
]
|
|
60
|
+
},
|
|
61
|
+
"std-array": {
|
|
62
|
+
"description": "Array utilities",
|
|
63
|
+
"target": [
|
|
64
|
+
"ts",
|
|
65
|
+
"rust"
|
|
66
|
+
]
|
|
67
|
+
},
|
|
68
|
+
"std-object": {
|
|
69
|
+
"description": "Object utilities",
|
|
70
|
+
"target": [
|
|
71
|
+
"ts",
|
|
72
|
+
"rust"
|
|
73
|
+
]
|
|
74
|
+
},
|
|
75
|
+
"std-time": {
|
|
76
|
+
"description": "Date/time utilities",
|
|
77
|
+
"target": [
|
|
78
|
+
"ts",
|
|
79
|
+
"rust"
|
|
80
|
+
]
|
|
81
|
+
},
|
|
82
|
+
"std-validate": {
|
|
83
|
+
"description": "Validation utilities",
|
|
84
|
+
"target": [
|
|
85
|
+
"ts",
|
|
86
|
+
"rust"
|
|
87
|
+
]
|
|
88
|
+
},
|
|
89
|
+
"std-format": {
|
|
90
|
+
"description": "Formatting utilities",
|
|
91
|
+
"target": [
|
|
92
|
+
"ts",
|
|
93
|
+
"rust"
|
|
94
|
+
]
|
|
95
|
+
},
|
|
96
|
+
"std-async": {
|
|
97
|
+
"description": "Async utilities (runtime only)",
|
|
98
|
+
"target": [
|
|
99
|
+
"ts"
|
|
100
|
+
]
|
|
101
|
+
},
|
|
102
|
+
"std-prob": {
|
|
103
|
+
"description": "Probabilistic programming",
|
|
104
|
+
"target": [
|
|
105
|
+
"ts"
|
|
106
|
+
]
|
|
107
|
+
},
|
|
108
|
+
"std-os": {
|
|
109
|
+
"description": "OS-level event watchers for system triggers",
|
|
110
|
+
"target": [
|
|
111
|
+
"ts"
|
|
112
|
+
]
|
|
113
|
+
},
|
|
114
|
+
"std-agent": {
|
|
115
|
+
"description": "Agent intelligence: memory, context, tools, LLM",
|
|
116
|
+
"target": [
|
|
117
|
+
"ts",
|
|
118
|
+
"rust"
|
|
119
|
+
]
|
|
120
|
+
},
|
|
121
|
+
"std-composition": {
|
|
122
|
+
"description": "Behavior composition (compile-time)",
|
|
123
|
+
"target": [
|
|
124
|
+
"ts",
|
|
125
|
+
"rust"
|
|
126
|
+
]
|
|
127
|
+
},
|
|
128
|
+
"std-nn": {
|
|
129
|
+
"description": "Neural network layer definitions",
|
|
130
|
+
"target": [
|
|
131
|
+
"python"
|
|
132
|
+
]
|
|
133
|
+
},
|
|
134
|
+
"std-tensor": {
|
|
135
|
+
"description": "Tensor operations",
|
|
136
|
+
"target": [
|
|
137
|
+
"python"
|
|
138
|
+
]
|
|
139
|
+
},
|
|
140
|
+
"std-train": {
|
|
141
|
+
"description": "Training operations",
|
|
142
|
+
"target": [
|
|
143
|
+
"python"
|
|
144
|
+
]
|
|
145
|
+
},
|
|
146
|
+
"ml-arch": {
|
|
147
|
+
"description": "Architecture layer definitions (Python compile target)",
|
|
148
|
+
"target": [
|
|
149
|
+
"python"
|
|
150
|
+
]
|
|
151
|
+
},
|
|
152
|
+
"ml-effect": {
|
|
153
|
+
"description": "ML execution effects (Python compile target)",
|
|
154
|
+
"target": [
|
|
155
|
+
"python"
|
|
156
|
+
]
|
|
157
|
+
},
|
|
158
|
+
"ml-tensor": {
|
|
159
|
+
"description": "Tensor manipulation (Python compile target)",
|
|
160
|
+
"target": [
|
|
161
|
+
"python"
|
|
162
|
+
]
|
|
163
|
+
},
|
|
164
|
+
"ml-graph": {
|
|
165
|
+
"description": "Graph construction (Python compile target)",
|
|
166
|
+
"target": [
|
|
167
|
+
"python"
|
|
168
|
+
]
|
|
169
|
+
},
|
|
170
|
+
"ml-contract": {
|
|
171
|
+
"description": "Input/output contract validation (Python compile target)",
|
|
172
|
+
"target": [
|
|
173
|
+
"python"
|
|
174
|
+
]
|
|
175
|
+
},
|
|
176
|
+
"ml-data": {
|
|
177
|
+
"description": "Data loading and preprocessing (Python compile target)",
|
|
178
|
+
"target": [
|
|
179
|
+
"python"
|
|
180
|
+
]
|
|
181
|
+
}
|
|
182
|
+
},
|
|
183
|
+
"operators": {
|
|
184
|
+
"!=": {
|
|
185
|
+
"category": "comparison",
|
|
186
|
+
"minArity": 2,
|
|
187
|
+
"maxArity": 2,
|
|
188
|
+
"returnType": "boolean",
|
|
189
|
+
"description": "Not equal to",
|
|
190
|
+
"module": "core"
|
|
191
|
+
},
|
|
192
|
+
"%": {
|
|
193
|
+
"category": "arithmetic",
|
|
194
|
+
"minArity": 2,
|
|
195
|
+
"maxArity": 2,
|
|
196
|
+
"returnType": "number",
|
|
197
|
+
"description": "Modulo (remainder)",
|
|
198
|
+
"module": "core"
|
|
199
|
+
},
|
|
200
|
+
"*": {
|
|
201
|
+
"category": "arithmetic",
|
|
202
|
+
"minArity": 2,
|
|
203
|
+
"maxArity": null,
|
|
204
|
+
"returnType": "number",
|
|
205
|
+
"description": "Multiply numbers",
|
|
206
|
+
"module": "core"
|
|
207
|
+
},
|
|
208
|
+
"+": {
|
|
209
|
+
"category": "arithmetic",
|
|
210
|
+
"minArity": 2,
|
|
211
|
+
"maxArity": null,
|
|
212
|
+
"returnType": "number",
|
|
213
|
+
"description": "Add numbers",
|
|
214
|
+
"module": "core"
|
|
215
|
+
},
|
|
216
|
+
"-": {
|
|
217
|
+
"category": "arithmetic",
|
|
218
|
+
"minArity": 1,
|
|
219
|
+
"maxArity": 2,
|
|
220
|
+
"returnType": "number",
|
|
221
|
+
"description": "Subtract or negate",
|
|
222
|
+
"module": "core"
|
|
223
|
+
},
|
|
224
|
+
"/": {
|
|
225
|
+
"category": "arithmetic",
|
|
226
|
+
"minArity": 2,
|
|
227
|
+
"maxArity": 2,
|
|
228
|
+
"returnType": "number",
|
|
229
|
+
"description": "Divide numbers",
|
|
230
|
+
"module": "core"
|
|
231
|
+
},
|
|
232
|
+
"<": {
|
|
233
|
+
"category": "comparison",
|
|
234
|
+
"minArity": 2,
|
|
235
|
+
"maxArity": 2,
|
|
236
|
+
"returnType": "boolean",
|
|
237
|
+
"description": "Less than",
|
|
238
|
+
"module": "core"
|
|
239
|
+
},
|
|
240
|
+
"<=": {
|
|
241
|
+
"category": "comparison",
|
|
242
|
+
"minArity": 2,
|
|
243
|
+
"maxArity": 2,
|
|
244
|
+
"returnType": "boolean",
|
|
245
|
+
"description": "Less than or equal",
|
|
246
|
+
"module": "core"
|
|
247
|
+
},
|
|
248
|
+
"=": {
|
|
249
|
+
"category": "comparison",
|
|
250
|
+
"minArity": 2,
|
|
251
|
+
"maxArity": 2,
|
|
252
|
+
"returnType": "boolean",
|
|
253
|
+
"description": "Equal to",
|
|
254
|
+
"module": "core"
|
|
255
|
+
},
|
|
256
|
+
">": {
|
|
257
|
+
"category": "comparison",
|
|
258
|
+
"minArity": 2,
|
|
259
|
+
"maxArity": 2,
|
|
260
|
+
"returnType": "boolean",
|
|
261
|
+
"description": "Greater than",
|
|
262
|
+
"module": "core"
|
|
263
|
+
},
|
|
264
|
+
">=": {
|
|
265
|
+
"category": "comparison",
|
|
266
|
+
"minArity": 2,
|
|
267
|
+
"maxArity": 2,
|
|
268
|
+
"returnType": "boolean",
|
|
269
|
+
"description": "Greater than or equal",
|
|
270
|
+
"module": "core"
|
|
271
|
+
},
|
|
272
|
+
"agent/compact": {
|
|
273
|
+
"category": "std-agent",
|
|
274
|
+
"minArity": 0,
|
|
275
|
+
"maxArity": 1,
|
|
276
|
+
"returnType": "object",
|
|
277
|
+
"description": "Compact the context window. Returns { before, after, strategy, summary? }.",
|
|
278
|
+
"module": "agent",
|
|
279
|
+
"hasSideEffects": true
|
|
280
|
+
},
|
|
281
|
+
"agent/context-usage": {
|
|
282
|
+
"category": "std-agent",
|
|
283
|
+
"minArity": 0,
|
|
284
|
+
"maxArity": 0,
|
|
285
|
+
"returnType": "number",
|
|
286
|
+
"description": "Get context window usage as a ratio (0-1).",
|
|
287
|
+
"module": "agent"
|
|
288
|
+
},
|
|
289
|
+
"agent/decay": {
|
|
290
|
+
"category": "std-agent",
|
|
291
|
+
"minArity": 0,
|
|
292
|
+
"maxArity": 0,
|
|
293
|
+
"returnType": "number",
|
|
294
|
+
"description": "Apply strength decay to all unpinned memories. Returns count of forgotten memories.",
|
|
295
|
+
"module": "agent",
|
|
296
|
+
"hasSideEffects": true
|
|
297
|
+
},
|
|
298
|
+
"agent/forget": {
|
|
299
|
+
"category": "std-agent",
|
|
300
|
+
"minArity": 1,
|
|
301
|
+
"maxArity": 1,
|
|
302
|
+
"returnType": "void",
|
|
303
|
+
"description": "Remove a memory by ID.",
|
|
304
|
+
"module": "agent",
|
|
305
|
+
"hasSideEffects": true
|
|
306
|
+
},
|
|
307
|
+
"agent/fork": {
|
|
308
|
+
"category": "std-agent",
|
|
309
|
+
"minArity": 0,
|
|
310
|
+
"maxArity": 1,
|
|
311
|
+
"returnType": "string",
|
|
312
|
+
"description": "Fork the current session. Returns new session ID.",
|
|
313
|
+
"module": "agent",
|
|
314
|
+
"hasSideEffects": true
|
|
315
|
+
},
|
|
316
|
+
"agent/generate": {
|
|
317
|
+
"category": "std-agent",
|
|
318
|
+
"minArity": 1,
|
|
319
|
+
"maxArity": 2,
|
|
320
|
+
"returnType": "string",
|
|
321
|
+
"description": "Generate text from the LLM. Returns generated string.",
|
|
322
|
+
"module": "agent",
|
|
323
|
+
"hasSideEffects": true
|
|
324
|
+
},
|
|
325
|
+
"agent/invoke": {
|
|
326
|
+
"category": "std-agent",
|
|
327
|
+
"minArity": 2,
|
|
328
|
+
"maxArity": 2,
|
|
329
|
+
"returnType": "any",
|
|
330
|
+
"description": "Invoke a tool by name with arguments. Returns tool result.",
|
|
331
|
+
"module": "agent",
|
|
332
|
+
"hasSideEffects": true
|
|
333
|
+
},
|
|
334
|
+
"agent/is-pinned": {
|
|
335
|
+
"category": "std-agent",
|
|
336
|
+
"minArity": 1,
|
|
337
|
+
"maxArity": 1,
|
|
338
|
+
"returnType": "boolean",
|
|
339
|
+
"description": "Check if a memory is pinned (immune to decay).",
|
|
340
|
+
"module": "agent"
|
|
341
|
+
},
|
|
342
|
+
"agent/label": {
|
|
343
|
+
"category": "std-agent",
|
|
344
|
+
"minArity": 1,
|
|
345
|
+
"maxArity": 1,
|
|
346
|
+
"returnType": "void",
|
|
347
|
+
"description": "Label the current session checkpoint for later reference.",
|
|
348
|
+
"module": "agent",
|
|
349
|
+
"hasSideEffects": true
|
|
350
|
+
},
|
|
351
|
+
"agent/memories": {
|
|
352
|
+
"category": "std-agent",
|
|
353
|
+
"minArity": 0,
|
|
354
|
+
"maxArity": 1,
|
|
355
|
+
"returnType": "array",
|
|
356
|
+
"description": "List all memories, optionally filtered by category.",
|
|
357
|
+
"module": "agent"
|
|
358
|
+
},
|
|
359
|
+
"agent/memorize": {
|
|
360
|
+
"category": "std-agent",
|
|
361
|
+
"minArity": 2,
|
|
362
|
+
"maxArity": 3,
|
|
363
|
+
"returnType": "string",
|
|
364
|
+
"description": "Store a new memory. Returns the new memory ID.",
|
|
365
|
+
"module": "agent",
|
|
366
|
+
"hasSideEffects": true
|
|
367
|
+
},
|
|
368
|
+
"agent/memory-strength": {
|
|
369
|
+
"category": "std-agent",
|
|
370
|
+
"minArity": 1,
|
|
371
|
+
"maxArity": 1,
|
|
372
|
+
"returnType": "number",
|
|
373
|
+
"description": "Get the strength value (0-1) of a specific memory.",
|
|
374
|
+
"module": "agent"
|
|
375
|
+
},
|
|
376
|
+
"agent/model": {
|
|
377
|
+
"category": "std-agent",
|
|
378
|
+
"minArity": 0,
|
|
379
|
+
"maxArity": 0,
|
|
380
|
+
"returnType": "string",
|
|
381
|
+
"description": "Get the name of the current LLM model.",
|
|
382
|
+
"module": "agent"
|
|
383
|
+
},
|
|
384
|
+
"agent/pin": {
|
|
385
|
+
"category": "std-agent",
|
|
386
|
+
"minArity": 1,
|
|
387
|
+
"maxArity": 1,
|
|
388
|
+
"returnType": "void",
|
|
389
|
+
"description": "Pin a memory to prevent decay.",
|
|
390
|
+
"module": "agent",
|
|
391
|
+
"hasSideEffects": true
|
|
392
|
+
},
|
|
393
|
+
"agent/provider": {
|
|
394
|
+
"category": "std-agent",
|
|
395
|
+
"minArity": 0,
|
|
396
|
+
"maxArity": 0,
|
|
397
|
+
"returnType": "string",
|
|
398
|
+
"description": "Get the name of the current LLM provider.",
|
|
399
|
+
"module": "agent"
|
|
400
|
+
},
|
|
401
|
+
"agent/recall": {
|
|
402
|
+
"category": "std-agent",
|
|
403
|
+
"minArity": 1,
|
|
404
|
+
"maxArity": 2,
|
|
405
|
+
"returnType": "array",
|
|
406
|
+
"description": "Search memories by semantic query. Returns matching AgentMemoryRecord array.",
|
|
407
|
+
"module": "agent"
|
|
408
|
+
},
|
|
409
|
+
"agent/reinforce": {
|
|
410
|
+
"category": "std-agent",
|
|
411
|
+
"minArity": 1,
|
|
412
|
+
"maxArity": 1,
|
|
413
|
+
"returnType": "void",
|
|
414
|
+
"description": "Increase a memory's strength (reinforcement learning signal).",
|
|
415
|
+
"module": "agent",
|
|
416
|
+
"hasSideEffects": true
|
|
417
|
+
},
|
|
418
|
+
"agent/search-code": {
|
|
419
|
+
"category": "std-agent",
|
|
420
|
+
"minArity": 1,
|
|
421
|
+
"maxArity": 2,
|
|
422
|
+
"returnType": "array",
|
|
423
|
+
"description": "Search code repositories. Returns array of { repo, path, url }.",
|
|
424
|
+
"module": "agent",
|
|
425
|
+
"hasSideEffects": true
|
|
426
|
+
},
|
|
427
|
+
"agent/session-id": {
|
|
428
|
+
"category": "std-agent",
|
|
429
|
+
"minArity": 0,
|
|
430
|
+
"maxArity": 0,
|
|
431
|
+
"returnType": "string",
|
|
432
|
+
"description": "Get the current session identifier.",
|
|
433
|
+
"module": "agent"
|
|
434
|
+
},
|
|
435
|
+
"agent/switch-provider": {
|
|
436
|
+
"category": "std-agent",
|
|
437
|
+
"minArity": 1,
|
|
438
|
+
"maxArity": 2,
|
|
439
|
+
"returnType": "void",
|
|
440
|
+
"description": "Switch the active LLM provider and optionally the model.",
|
|
441
|
+
"module": "agent",
|
|
442
|
+
"hasSideEffects": true
|
|
443
|
+
},
|
|
444
|
+
"agent/token-count": {
|
|
445
|
+
"category": "std-agent",
|
|
446
|
+
"minArity": 0,
|
|
447
|
+
"maxArity": 0,
|
|
448
|
+
"returnType": "number",
|
|
449
|
+
"description": "Get the current token count in the context window.",
|
|
450
|
+
"module": "agent"
|
|
451
|
+
},
|
|
452
|
+
"agent/tools": {
|
|
453
|
+
"category": "std-agent",
|
|
454
|
+
"minArity": 0,
|
|
455
|
+
"maxArity": 0,
|
|
456
|
+
"returnType": "array",
|
|
457
|
+
"description": "Get the list of available tool names.",
|
|
458
|
+
"module": "agent"
|
|
459
|
+
},
|
|
460
|
+
"and": {
|
|
461
|
+
"category": "logic",
|
|
462
|
+
"minArity": 2,
|
|
463
|
+
"maxArity": null,
|
|
464
|
+
"returnType": "boolean",
|
|
465
|
+
"description": "Logical AND (returns the last truthy value, NOT a boolean — short-circuit)",
|
|
466
|
+
"module": "core",
|
|
467
|
+
"returnSemantics": "last-truthy-of-args"
|
|
468
|
+
},
|
|
469
|
+
"array/append": {
|
|
470
|
+
"category": "std-array",
|
|
471
|
+
"minArity": 2,
|
|
472
|
+
"maxArity": 2,
|
|
473
|
+
"returnType": "array",
|
|
474
|
+
"description": "Add item to end (returns new array)",
|
|
475
|
+
"module": "array"
|
|
476
|
+
},
|
|
477
|
+
"array/avg": {
|
|
478
|
+
"category": "std-array",
|
|
479
|
+
"minArity": 1,
|
|
480
|
+
"maxArity": 2,
|
|
481
|
+
"returnType": "number",
|
|
482
|
+
"description": "Average of values (optionally by field)",
|
|
483
|
+
"module": "array"
|
|
484
|
+
},
|
|
485
|
+
"array/concat": {
|
|
486
|
+
"category": "std-array",
|
|
487
|
+
"minArity": 2,
|
|
488
|
+
"maxArity": null,
|
|
489
|
+
"returnType": "array",
|
|
490
|
+
"description": "Concatenate arrays",
|
|
491
|
+
"module": "array"
|
|
492
|
+
},
|
|
493
|
+
"array/count": {
|
|
494
|
+
"category": "std-array",
|
|
495
|
+
"minArity": 1,
|
|
496
|
+
"maxArity": 2,
|
|
497
|
+
"returnType": "number",
|
|
498
|
+
"description": "Count elements (optionally matching predicate)",
|
|
499
|
+
"module": "array"
|
|
500
|
+
},
|
|
501
|
+
"array/drop": {
|
|
502
|
+
"category": "std-array",
|
|
503
|
+
"minArity": 2,
|
|
504
|
+
"maxArity": 2,
|
|
505
|
+
"returnType": "array",
|
|
506
|
+
"description": "Skip first n elements",
|
|
507
|
+
"module": "array"
|
|
508
|
+
},
|
|
509
|
+
"array/dropLast": {
|
|
510
|
+
"category": "std-array",
|
|
511
|
+
"minArity": 2,
|
|
512
|
+
"maxArity": 2,
|
|
513
|
+
"returnType": "array",
|
|
514
|
+
"description": "Skip last n elements",
|
|
515
|
+
"module": "array"
|
|
516
|
+
},
|
|
517
|
+
"array/empty?": {
|
|
518
|
+
"category": "std-array",
|
|
519
|
+
"minArity": 1,
|
|
520
|
+
"maxArity": 1,
|
|
521
|
+
"returnType": "boolean",
|
|
522
|
+
"description": "Check if array is empty",
|
|
523
|
+
"module": "array"
|
|
524
|
+
},
|
|
525
|
+
"array/every": {
|
|
526
|
+
"category": "std-array",
|
|
527
|
+
"minArity": 2,
|
|
528
|
+
"maxArity": 2,
|
|
529
|
+
"returnType": "boolean",
|
|
530
|
+
"description": "Check if all elements match predicate",
|
|
531
|
+
"module": "array"
|
|
532
|
+
},
|
|
533
|
+
"array/filter": {
|
|
534
|
+
"category": "std-array",
|
|
535
|
+
"minArity": 2,
|
|
536
|
+
"maxArity": 2,
|
|
537
|
+
"returnType": "array",
|
|
538
|
+
"description": "Keep elements matching predicate (returns same array element type as input)",
|
|
539
|
+
"module": "array",
|
|
540
|
+
"returnSemantics": "identity-of-arg<0>"
|
|
541
|
+
},
|
|
542
|
+
"array/find": {
|
|
543
|
+
"category": "std-array",
|
|
544
|
+
"minArity": 2,
|
|
545
|
+
"maxArity": 2,
|
|
546
|
+
"returnType": "any",
|
|
547
|
+
"description": "Find first element matching predicate (element type of input array, undefined when no match)",
|
|
548
|
+
"module": "array",
|
|
549
|
+
"returnSemantics": "element-of-arg<0>?"
|
|
550
|
+
},
|
|
551
|
+
"array/findIndex": {
|
|
552
|
+
"category": "std-array",
|
|
553
|
+
"minArity": 2,
|
|
554
|
+
"maxArity": 2,
|
|
555
|
+
"returnType": "number",
|
|
556
|
+
"description": "Find index of first element matching predicate (-1 if none)",
|
|
557
|
+
"module": "array"
|
|
558
|
+
},
|
|
559
|
+
"array/first": {
|
|
560
|
+
"category": "std-array",
|
|
561
|
+
"minArity": 1,
|
|
562
|
+
"maxArity": 1,
|
|
563
|
+
"returnType": "any",
|
|
564
|
+
"description": "Get first element (element type of input array, may be undefined when empty)",
|
|
565
|
+
"module": "array",
|
|
566
|
+
"returnSemantics": "element-of-arg<0>?"
|
|
567
|
+
},
|
|
568
|
+
"array/flatten": {
|
|
569
|
+
"category": "std-array",
|
|
570
|
+
"minArity": 1,
|
|
571
|
+
"maxArity": 1,
|
|
572
|
+
"returnType": "array",
|
|
573
|
+
"description": "Flatten nested arrays one level",
|
|
574
|
+
"module": "array"
|
|
575
|
+
},
|
|
576
|
+
"array/groupBy": {
|
|
577
|
+
"category": "std-array",
|
|
578
|
+
"minArity": 2,
|
|
579
|
+
"maxArity": 2,
|
|
580
|
+
"returnType": "any",
|
|
581
|
+
"description": "Group elements by field value",
|
|
582
|
+
"module": "array"
|
|
583
|
+
},
|
|
584
|
+
"array/includes": {
|
|
585
|
+
"category": "std-array",
|
|
586
|
+
"minArity": 2,
|
|
587
|
+
"maxArity": 2,
|
|
588
|
+
"returnType": "boolean",
|
|
589
|
+
"description": "Check if array contains item",
|
|
590
|
+
"module": "array"
|
|
591
|
+
},
|
|
592
|
+
"array/indexOf": {
|
|
593
|
+
"category": "std-array",
|
|
594
|
+
"minArity": 2,
|
|
595
|
+
"maxArity": 2,
|
|
596
|
+
"returnType": "number",
|
|
597
|
+
"description": "Find index of item (-1 if not found)",
|
|
598
|
+
"module": "array"
|
|
599
|
+
},
|
|
600
|
+
"array/insert": {
|
|
601
|
+
"category": "std-array",
|
|
602
|
+
"minArity": 3,
|
|
603
|
+
"maxArity": 3,
|
|
604
|
+
"returnType": "array",
|
|
605
|
+
"description": "Insert item at index (returns new array)",
|
|
606
|
+
"module": "array"
|
|
607
|
+
},
|
|
608
|
+
"array/last": {
|
|
609
|
+
"category": "std-array",
|
|
610
|
+
"minArity": 1,
|
|
611
|
+
"maxArity": 1,
|
|
612
|
+
"returnType": "any",
|
|
613
|
+
"description": "Get last element (element type of input array, may be undefined when empty)",
|
|
614
|
+
"module": "array",
|
|
615
|
+
"returnSemantics": "element-of-arg<0>?"
|
|
616
|
+
},
|
|
617
|
+
"array/len": {
|
|
618
|
+
"category": "std-array",
|
|
619
|
+
"minArity": 1,
|
|
620
|
+
"maxArity": 1,
|
|
621
|
+
"returnType": "number",
|
|
622
|
+
"description": "Array length",
|
|
623
|
+
"module": "array"
|
|
624
|
+
},
|
|
625
|
+
"array/map": {
|
|
626
|
+
"category": "std-array",
|
|
627
|
+
"minArity": 2,
|
|
628
|
+
"maxArity": 2,
|
|
629
|
+
"returnType": "array",
|
|
630
|
+
"description": "Transform each element (return type wraps the lambda result in an array)",
|
|
631
|
+
"module": "array",
|
|
632
|
+
"returnSemantics": "lambda-result"
|
|
633
|
+
},
|
|
634
|
+
"array/max": {
|
|
635
|
+
"category": "std-array",
|
|
636
|
+
"minArity": 1,
|
|
637
|
+
"maxArity": 2,
|
|
638
|
+
"returnType": "number",
|
|
639
|
+
"description": "Maximum value (optionally by field)",
|
|
640
|
+
"module": "array"
|
|
641
|
+
},
|
|
642
|
+
"array/min": {
|
|
643
|
+
"category": "std-array",
|
|
644
|
+
"minArity": 1,
|
|
645
|
+
"maxArity": 2,
|
|
646
|
+
"returnType": "number",
|
|
647
|
+
"description": "Minimum value (optionally by field)",
|
|
648
|
+
"module": "array"
|
|
649
|
+
},
|
|
650
|
+
"array/nth": {
|
|
651
|
+
"category": "std-array",
|
|
652
|
+
"minArity": 2,
|
|
653
|
+
"maxArity": 2,
|
|
654
|
+
"returnType": "any",
|
|
655
|
+
"description": "Get element at index (element type of input array, may be undefined out-of-bounds)",
|
|
656
|
+
"module": "array",
|
|
657
|
+
"returnSemantics": "element-of-arg<0>?"
|
|
658
|
+
},
|
|
659
|
+
"array/partition": {
|
|
660
|
+
"category": "std-array",
|
|
661
|
+
"minArity": 2,
|
|
662
|
+
"maxArity": 2,
|
|
663
|
+
"returnType": "array",
|
|
664
|
+
"description": "Split array by predicate into [matches, nonMatches]",
|
|
665
|
+
"module": "array"
|
|
666
|
+
},
|
|
667
|
+
"array/prepend": {
|
|
668
|
+
"category": "std-array",
|
|
669
|
+
"minArity": 2,
|
|
670
|
+
"maxArity": 2,
|
|
671
|
+
"returnType": "array",
|
|
672
|
+
"description": "Add item to start (returns new array)",
|
|
673
|
+
"module": "array"
|
|
674
|
+
},
|
|
675
|
+
"array/reduce": {
|
|
676
|
+
"category": "std-array",
|
|
677
|
+
"minArity": 3,
|
|
678
|
+
"maxArity": 3,
|
|
679
|
+
"returnType": "any",
|
|
680
|
+
"description": "Reduce array to single value (return type matches the lambda result / init type)",
|
|
681
|
+
"module": "array",
|
|
682
|
+
"returnSemantics": "lambda-result"
|
|
683
|
+
},
|
|
684
|
+
"array/reject": {
|
|
685
|
+
"category": "std-array",
|
|
686
|
+
"minArity": 2,
|
|
687
|
+
"maxArity": 2,
|
|
688
|
+
"returnType": "array",
|
|
689
|
+
"description": "Remove elements matching predicate (returns same array element type as input)",
|
|
690
|
+
"module": "array",
|
|
691
|
+
"returnSemantics": "identity-of-arg<0>"
|
|
692
|
+
},
|
|
693
|
+
"array/remove": {
|
|
694
|
+
"category": "std-array",
|
|
695
|
+
"minArity": 2,
|
|
696
|
+
"maxArity": 2,
|
|
697
|
+
"returnType": "array",
|
|
698
|
+
"description": "Remove item at index (returns new array)",
|
|
699
|
+
"module": "array"
|
|
700
|
+
},
|
|
701
|
+
"array/removeItem": {
|
|
702
|
+
"category": "std-array",
|
|
703
|
+
"minArity": 2,
|
|
704
|
+
"maxArity": 2,
|
|
705
|
+
"returnType": "array",
|
|
706
|
+
"description": "Remove first matching item (returns new array)",
|
|
707
|
+
"module": "array"
|
|
708
|
+
},
|
|
709
|
+
"array/reverse": {
|
|
710
|
+
"category": "std-array",
|
|
711
|
+
"minArity": 1,
|
|
712
|
+
"maxArity": 1,
|
|
713
|
+
"returnType": "array",
|
|
714
|
+
"description": "Reverse array order (returns new array)",
|
|
715
|
+
"module": "array"
|
|
716
|
+
},
|
|
717
|
+
"array/shuffle": {
|
|
718
|
+
"category": "std-array",
|
|
719
|
+
"minArity": 1,
|
|
720
|
+
"maxArity": 1,
|
|
721
|
+
"returnType": "array",
|
|
722
|
+
"description": "Randomly shuffle array (returns new array)",
|
|
723
|
+
"module": "array"
|
|
724
|
+
},
|
|
725
|
+
"array/slice": {
|
|
726
|
+
"category": "std-array",
|
|
727
|
+
"minArity": 2,
|
|
728
|
+
"maxArity": 3,
|
|
729
|
+
"returnType": "array",
|
|
730
|
+
"description": "Extract subarray",
|
|
731
|
+
"module": "array"
|
|
732
|
+
},
|
|
733
|
+
"array/some": {
|
|
734
|
+
"category": "std-array",
|
|
735
|
+
"minArity": 2,
|
|
736
|
+
"maxArity": 2,
|
|
737
|
+
"returnType": "boolean",
|
|
738
|
+
"description": "Check if any element matches predicate",
|
|
739
|
+
"module": "array"
|
|
740
|
+
},
|
|
741
|
+
"array/sort": {
|
|
742
|
+
"category": "std-array",
|
|
743
|
+
"minArity": 1,
|
|
744
|
+
"maxArity": 3,
|
|
745
|
+
"returnType": "array",
|
|
746
|
+
"description": "Sort array (returns new array)",
|
|
747
|
+
"module": "array"
|
|
748
|
+
},
|
|
749
|
+
"array/sum": {
|
|
750
|
+
"category": "std-array",
|
|
751
|
+
"minArity": 1,
|
|
752
|
+
"maxArity": 2,
|
|
753
|
+
"returnType": "number",
|
|
754
|
+
"description": "Sum values (optionally by field)",
|
|
755
|
+
"module": "array"
|
|
756
|
+
},
|
|
757
|
+
"array/take": {
|
|
758
|
+
"category": "std-array",
|
|
759
|
+
"minArity": 2,
|
|
760
|
+
"maxArity": 2,
|
|
761
|
+
"returnType": "array",
|
|
762
|
+
"description": "Take first n elements",
|
|
763
|
+
"module": "array"
|
|
764
|
+
},
|
|
765
|
+
"array/takeLast": {
|
|
766
|
+
"category": "std-array",
|
|
767
|
+
"minArity": 2,
|
|
768
|
+
"maxArity": 2,
|
|
769
|
+
"returnType": "array",
|
|
770
|
+
"description": "Take last n elements",
|
|
771
|
+
"module": "array"
|
|
772
|
+
},
|
|
773
|
+
"array/unique": {
|
|
774
|
+
"category": "std-array",
|
|
775
|
+
"minArity": 1,
|
|
776
|
+
"maxArity": 1,
|
|
777
|
+
"returnType": "array",
|
|
778
|
+
"description": "Remove duplicates (returns new array)",
|
|
779
|
+
"module": "array"
|
|
780
|
+
},
|
|
781
|
+
"array/zip": {
|
|
782
|
+
"category": "std-array",
|
|
783
|
+
"minArity": 2,
|
|
784
|
+
"maxArity": 2,
|
|
785
|
+
"returnType": "array",
|
|
786
|
+
"description": "Pair elements from two arrays",
|
|
787
|
+
"module": "array"
|
|
788
|
+
},
|
|
789
|
+
"async/all": {
|
|
790
|
+
"category": "std-async",
|
|
791
|
+
"minArity": 2,
|
|
792
|
+
"maxArity": null,
|
|
793
|
+
"returnType": "array",
|
|
794
|
+
"description": "Execute effects in parallel, wait for all to complete",
|
|
795
|
+
"module": "async",
|
|
796
|
+
"hasSideEffects": true
|
|
797
|
+
},
|
|
798
|
+
"async/debounce": {
|
|
799
|
+
"category": "std-async",
|
|
800
|
+
"minArity": 2,
|
|
801
|
+
"maxArity": 2,
|
|
802
|
+
"returnType": "void",
|
|
803
|
+
"description": "Debounce an event (wait for pause in events)",
|
|
804
|
+
"module": "async",
|
|
805
|
+
"hasSideEffects": true
|
|
806
|
+
},
|
|
807
|
+
"async/delay": {
|
|
808
|
+
"category": "std-async",
|
|
809
|
+
"minArity": 1,
|
|
810
|
+
"maxArity": 2,
|
|
811
|
+
"returnType": "any",
|
|
812
|
+
"description": "Wait for specified milliseconds, optionally execute an effect after",
|
|
813
|
+
"module": "async",
|
|
814
|
+
"hasSideEffects": true
|
|
815
|
+
},
|
|
816
|
+
"async/interval": {
|
|
817
|
+
"category": "std-async",
|
|
818
|
+
"minArity": 2,
|
|
819
|
+
"maxArity": 2,
|
|
820
|
+
"returnType": "string",
|
|
821
|
+
"description": "Execute an effect periodically at a fixed interval",
|
|
822
|
+
"module": "async",
|
|
823
|
+
"hasSideEffects": true
|
|
824
|
+
},
|
|
825
|
+
"async/race": {
|
|
826
|
+
"category": "std-async",
|
|
827
|
+
"minArity": 2,
|
|
828
|
+
"maxArity": null,
|
|
829
|
+
"returnType": "any",
|
|
830
|
+
"description": "Execute effects in parallel, return first to complete",
|
|
831
|
+
"module": "async",
|
|
832
|
+
"hasSideEffects": true
|
|
833
|
+
},
|
|
834
|
+
"async/retry": {
|
|
835
|
+
"category": "std-async",
|
|
836
|
+
"minArity": 2,
|
|
837
|
+
"maxArity": 2,
|
|
838
|
+
"returnType": "any",
|
|
839
|
+
"description": "Retry an effect with configurable backoff",
|
|
840
|
+
"module": "async",
|
|
841
|
+
"hasSideEffects": true
|
|
842
|
+
},
|
|
843
|
+
"async/sequence": {
|
|
844
|
+
"category": "std-async",
|
|
845
|
+
"minArity": 2,
|
|
846
|
+
"maxArity": null,
|
|
847
|
+
"returnType": "array",
|
|
848
|
+
"description": "Execute effects in sequence (one after another)",
|
|
849
|
+
"module": "async",
|
|
850
|
+
"hasSideEffects": true
|
|
851
|
+
},
|
|
852
|
+
"async/throttle": {
|
|
853
|
+
"category": "std-async",
|
|
854
|
+
"minArity": 2,
|
|
855
|
+
"maxArity": 2,
|
|
856
|
+
"returnType": "void",
|
|
857
|
+
"description": "Throttle an event (emit at most once per interval)",
|
|
858
|
+
"module": "async",
|
|
859
|
+
"hasSideEffects": true
|
|
860
|
+
},
|
|
861
|
+
"async/timeout": {
|
|
862
|
+
"category": "std-async",
|
|
863
|
+
"minArity": 2,
|
|
864
|
+
"maxArity": 2,
|
|
865
|
+
"returnType": "any",
|
|
866
|
+
"description": "Add timeout to an effect",
|
|
867
|
+
"module": "async",
|
|
868
|
+
"hasSideEffects": true
|
|
869
|
+
},
|
|
870
|
+
"behavior/compose": {
|
|
871
|
+
"category": "std-composition",
|
|
872
|
+
"minArity": 1,
|
|
873
|
+
"maxArity": 1,
|
|
874
|
+
"returnType": "object",
|
|
875
|
+
"description": "Compose N orbitals into one application schema. Wires events, picks layout, generates pages.",
|
|
876
|
+
"module": "composition"
|
|
877
|
+
},
|
|
878
|
+
"behavior/detect-layout": {
|
|
879
|
+
"category": "std-composition",
|
|
880
|
+
"minArity": 1,
|
|
881
|
+
"maxArity": 2,
|
|
882
|
+
"returnType": "string",
|
|
883
|
+
"description": "Auto-detect layout from orbital count and wiring topology. Returns single, tabs, sidebar, dashboard, or wizard-flow.",
|
|
884
|
+
"module": "composition"
|
|
885
|
+
},
|
|
886
|
+
"behavior/pipe": {
|
|
887
|
+
"category": "std-composition",
|
|
888
|
+
"minArity": 2,
|
|
889
|
+
"maxArity": null,
|
|
890
|
+
"returnType": "any",
|
|
891
|
+
"description": "Left-to-right composition. Each step receives the previous result as its first arg.",
|
|
892
|
+
"module": "composition"
|
|
893
|
+
},
|
|
894
|
+
"behavior/wire": {
|
|
895
|
+
"category": "std-composition",
|
|
896
|
+
"minArity": 2,
|
|
897
|
+
"maxArity": 2,
|
|
898
|
+
"returnType": "array",
|
|
899
|
+
"description": "Apply cross-orbital event wiring. Adds external emits/listens to inline traits.",
|
|
900
|
+
"module": "composition"
|
|
901
|
+
},
|
|
902
|
+
"call-service": {
|
|
903
|
+
"category": "effect",
|
|
904
|
+
"minArity": 2,
|
|
905
|
+
"maxArity": 4,
|
|
906
|
+
"returnType": "void",
|
|
907
|
+
"description": "Invoke an external service action. Optional trailing { emit: { success, failure } } options object attaches closed-circuit emit routing (V2 frame contract).",
|
|
908
|
+
"module": "core",
|
|
909
|
+
"hasSideEffects": true,
|
|
910
|
+
"effect": {
|
|
911
|
+
"kind": "call-service",
|
|
912
|
+
"produces": "any"
|
|
913
|
+
}
|
|
914
|
+
},
|
|
915
|
+
"despawn": {
|
|
916
|
+
"category": "effect",
|
|
917
|
+
"minArity": 0,
|
|
918
|
+
"maxArity": 1,
|
|
919
|
+
"returnType": "void",
|
|
920
|
+
"description": "Despawn an entity instance (games)",
|
|
921
|
+
"module": "core",
|
|
922
|
+
"hasSideEffects": true,
|
|
923
|
+
"effect": {
|
|
924
|
+
"kind": "despawn"
|
|
925
|
+
}
|
|
926
|
+
},
|
|
927
|
+
"do": {
|
|
928
|
+
"category": "control",
|
|
929
|
+
"minArity": 1,
|
|
930
|
+
"maxArity": null,
|
|
931
|
+
"returnType": "any",
|
|
932
|
+
"description": "Sequential execution of multiple effects/expressions",
|
|
933
|
+
"module": "core"
|
|
934
|
+
},
|
|
935
|
+
"emit": {
|
|
936
|
+
"category": "effect",
|
|
937
|
+
"minArity": 1,
|
|
938
|
+
"maxArity": 2,
|
|
939
|
+
"returnType": "void",
|
|
940
|
+
"description": "Emit an event onto the bus",
|
|
941
|
+
"module": "core",
|
|
942
|
+
"hasSideEffects": true,
|
|
943
|
+
"effect": {
|
|
944
|
+
"kind": "emit",
|
|
945
|
+
"produces": {
|
|
946
|
+
"kind": "object",
|
|
947
|
+
"fields": {
|
|
948
|
+
"event": {
|
|
949
|
+
"kind": "eventKey"
|
|
950
|
+
},
|
|
951
|
+
"payload": "any"
|
|
952
|
+
},
|
|
953
|
+
"open": true
|
|
954
|
+
}
|
|
955
|
+
}
|
|
956
|
+
},
|
|
957
|
+
"fetch": {
|
|
958
|
+
"category": "effect",
|
|
959
|
+
"minArity": 1,
|
|
960
|
+
"maxArity": 2,
|
|
961
|
+
"returnType": "void",
|
|
962
|
+
"description": "Fetch an entity (by id) or a collection (by filter) from persistence",
|
|
963
|
+
"module": "core",
|
|
964
|
+
"hasSideEffects": true,
|
|
965
|
+
"effect": {
|
|
966
|
+
"kind": "fetch",
|
|
967
|
+
"produces": {
|
|
968
|
+
"kind": "union",
|
|
969
|
+
"of": [
|
|
970
|
+
{
|
|
971
|
+
"kind": "entity"
|
|
972
|
+
},
|
|
973
|
+
{
|
|
974
|
+
"kind": "array",
|
|
975
|
+
"of": {
|
|
976
|
+
"kind": "entity"
|
|
977
|
+
}
|
|
978
|
+
}
|
|
979
|
+
]
|
|
980
|
+
}
|
|
981
|
+
}
|
|
982
|
+
},
|
|
983
|
+
"fn": {
|
|
984
|
+
"category": "control",
|
|
985
|
+
"minArity": 2,
|
|
986
|
+
"maxArity": 2,
|
|
987
|
+
"returnType": "function",
|
|
988
|
+
"description": "Lambda expression (used for per-item renders and transforms)",
|
|
989
|
+
"module": "core"
|
|
990
|
+
},
|
|
991
|
+
"format/bytes": {
|
|
992
|
+
"category": "std-format",
|
|
993
|
+
"minArity": 1,
|
|
994
|
+
"maxArity": 1,
|
|
995
|
+
"returnType": "string",
|
|
996
|
+
"description": "Format bytes as human-readable size",
|
|
997
|
+
"module": "format"
|
|
998
|
+
},
|
|
999
|
+
"format/creditCard": {
|
|
1000
|
+
"category": "std-format",
|
|
1001
|
+
"minArity": 1,
|
|
1002
|
+
"maxArity": 1,
|
|
1003
|
+
"returnType": "string",
|
|
1004
|
+
"description": "Format credit card with masked digits",
|
|
1005
|
+
"module": "format"
|
|
1006
|
+
},
|
|
1007
|
+
"format/currency": {
|
|
1008
|
+
"category": "std-format",
|
|
1009
|
+
"minArity": 2,
|
|
1010
|
+
"maxArity": 3,
|
|
1011
|
+
"returnType": "string",
|
|
1012
|
+
"description": "Format as currency",
|
|
1013
|
+
"module": "format"
|
|
1014
|
+
},
|
|
1015
|
+
"format/list": {
|
|
1016
|
+
"category": "std-format",
|
|
1017
|
+
"minArity": 1,
|
|
1018
|
+
"maxArity": 2,
|
|
1019
|
+
"returnType": "string",
|
|
1020
|
+
"description": "Format array as natural language list",
|
|
1021
|
+
"module": "format"
|
|
1022
|
+
},
|
|
1023
|
+
"format/number": {
|
|
1024
|
+
"category": "std-format",
|
|
1025
|
+
"minArity": 1,
|
|
1026
|
+
"maxArity": 2,
|
|
1027
|
+
"returnType": "string",
|
|
1028
|
+
"description": "Format number with locale-aware separators",
|
|
1029
|
+
"module": "format"
|
|
1030
|
+
},
|
|
1031
|
+
"format/ordinal": {
|
|
1032
|
+
"category": "std-format",
|
|
1033
|
+
"minArity": 1,
|
|
1034
|
+
"maxArity": 1,
|
|
1035
|
+
"returnType": "string",
|
|
1036
|
+
"description": "Format number as ordinal (1st, 2nd, 3rd)",
|
|
1037
|
+
"module": "format"
|
|
1038
|
+
},
|
|
1039
|
+
"format/percent": {
|
|
1040
|
+
"category": "std-format",
|
|
1041
|
+
"minArity": 1,
|
|
1042
|
+
"maxArity": 2,
|
|
1043
|
+
"returnType": "string",
|
|
1044
|
+
"description": "Format as percentage",
|
|
1045
|
+
"module": "format"
|
|
1046
|
+
},
|
|
1047
|
+
"format/phone": {
|
|
1048
|
+
"category": "std-format",
|
|
1049
|
+
"minArity": 1,
|
|
1050
|
+
"maxArity": 2,
|
|
1051
|
+
"returnType": "string",
|
|
1052
|
+
"description": "Format phone number",
|
|
1053
|
+
"module": "format"
|
|
1054
|
+
},
|
|
1055
|
+
"format/plural": {
|
|
1056
|
+
"category": "std-format",
|
|
1057
|
+
"minArity": 3,
|
|
1058
|
+
"maxArity": 3,
|
|
1059
|
+
"returnType": "string",
|
|
1060
|
+
"description": "Format count with singular/plural word",
|
|
1061
|
+
"module": "format"
|
|
1062
|
+
},
|
|
1063
|
+
"if": {
|
|
1064
|
+
"category": "logic",
|
|
1065
|
+
"minArity": 3,
|
|
1066
|
+
"maxArity": 3,
|
|
1067
|
+
"returnType": "any",
|
|
1068
|
+
"description": "Conditional expression (ternary). Return type is union of branch types.",
|
|
1069
|
+
"module": "core",
|
|
1070
|
+
"returnSemantics": "branch-union"
|
|
1071
|
+
},
|
|
1072
|
+
"let": {
|
|
1073
|
+
"category": "control",
|
|
1074
|
+
"minArity": 2,
|
|
1075
|
+
"maxArity": 2,
|
|
1076
|
+
"returnType": "any",
|
|
1077
|
+
"description": "Bind local variables for a body expression",
|
|
1078
|
+
"module": "core"
|
|
1079
|
+
},
|
|
1080
|
+
"list": {
|
|
1081
|
+
"category": "control",
|
|
1082
|
+
"minArity": 0,
|
|
1083
|
+
"maxArity": null,
|
|
1084
|
+
"returnType": "array",
|
|
1085
|
+
"description": "Literal array constructor — evaluates each argument and returns them as an array. Lowering wraps a literal list bound for a literal-array slot in `list` so it is unambiguously data, never a call (disambiguates a list whose first element collides with an operator name, e.g. [path method …]).",
|
|
1086
|
+
"module": "core"
|
|
1087
|
+
},
|
|
1088
|
+
"math/abs": {
|
|
1089
|
+
"category": "std-math",
|
|
1090
|
+
"minArity": 1,
|
|
1091
|
+
"maxArity": 1,
|
|
1092
|
+
"returnType": "number",
|
|
1093
|
+
"description": "Absolute value",
|
|
1094
|
+
"module": "math"
|
|
1095
|
+
},
|
|
1096
|
+
"math/ceil": {
|
|
1097
|
+
"category": "std-math",
|
|
1098
|
+
"minArity": 1,
|
|
1099
|
+
"maxArity": 1,
|
|
1100
|
+
"returnType": "number",
|
|
1101
|
+
"description": "Round up to integer",
|
|
1102
|
+
"module": "math"
|
|
1103
|
+
},
|
|
1104
|
+
"math/clamp": {
|
|
1105
|
+
"category": "std-math",
|
|
1106
|
+
"minArity": 3,
|
|
1107
|
+
"maxArity": 3,
|
|
1108
|
+
"returnType": "number",
|
|
1109
|
+
"description": "Constrain value to range [min, max]",
|
|
1110
|
+
"module": "math"
|
|
1111
|
+
},
|
|
1112
|
+
"math/default": {
|
|
1113
|
+
"category": "std-math",
|
|
1114
|
+
"minArity": 2,
|
|
1115
|
+
"maxArity": 2,
|
|
1116
|
+
"returnType": "number",
|
|
1117
|
+
"description": "Return default if value is null, undefined, or NaN",
|
|
1118
|
+
"module": "math"
|
|
1119
|
+
},
|
|
1120
|
+
"math/floor": {
|
|
1121
|
+
"category": "std-math",
|
|
1122
|
+
"minArity": 1,
|
|
1123
|
+
"maxArity": 1,
|
|
1124
|
+
"returnType": "number",
|
|
1125
|
+
"description": "Round down to integer",
|
|
1126
|
+
"module": "math"
|
|
1127
|
+
},
|
|
1128
|
+
"math/lerp": {
|
|
1129
|
+
"category": "std-math",
|
|
1130
|
+
"minArity": 3,
|
|
1131
|
+
"maxArity": 3,
|
|
1132
|
+
"returnType": "number",
|
|
1133
|
+
"description": "Linear interpolation between a and b by factor t",
|
|
1134
|
+
"module": "math"
|
|
1135
|
+
},
|
|
1136
|
+
"math/map": {
|
|
1137
|
+
"category": "std-math",
|
|
1138
|
+
"minArity": 5,
|
|
1139
|
+
"maxArity": 5,
|
|
1140
|
+
"returnType": "number",
|
|
1141
|
+
"description": "Map value from one range to another",
|
|
1142
|
+
"module": "math"
|
|
1143
|
+
},
|
|
1144
|
+
"math/max": {
|
|
1145
|
+
"category": "std-math",
|
|
1146
|
+
"minArity": 2,
|
|
1147
|
+
"maxArity": null,
|
|
1148
|
+
"returnType": "number",
|
|
1149
|
+
"description": "Maximum of values",
|
|
1150
|
+
"module": "math"
|
|
1151
|
+
},
|
|
1152
|
+
"math/min": {
|
|
1153
|
+
"category": "std-math",
|
|
1154
|
+
"minArity": 2,
|
|
1155
|
+
"maxArity": null,
|
|
1156
|
+
"returnType": "number",
|
|
1157
|
+
"description": "Minimum of values",
|
|
1158
|
+
"module": "math"
|
|
1159
|
+
},
|
|
1160
|
+
"math/mod": {
|
|
1161
|
+
"category": "std-math",
|
|
1162
|
+
"minArity": 2,
|
|
1163
|
+
"maxArity": 2,
|
|
1164
|
+
"returnType": "number",
|
|
1165
|
+
"description": "Modulo (remainder)",
|
|
1166
|
+
"module": "math"
|
|
1167
|
+
},
|
|
1168
|
+
"math/pow": {
|
|
1169
|
+
"category": "std-math",
|
|
1170
|
+
"minArity": 2,
|
|
1171
|
+
"maxArity": 2,
|
|
1172
|
+
"returnType": "number",
|
|
1173
|
+
"description": "Exponentiation (base^exp)",
|
|
1174
|
+
"module": "math"
|
|
1175
|
+
},
|
|
1176
|
+
"math/random": {
|
|
1177
|
+
"category": "std-math",
|
|
1178
|
+
"minArity": 0,
|
|
1179
|
+
"maxArity": 0,
|
|
1180
|
+
"returnType": "number",
|
|
1181
|
+
"description": "Random number between 0 (inclusive) and 1 (exclusive)",
|
|
1182
|
+
"module": "math"
|
|
1183
|
+
},
|
|
1184
|
+
"math/randomInt": {
|
|
1185
|
+
"category": "std-math",
|
|
1186
|
+
"minArity": 2,
|
|
1187
|
+
"maxArity": 2,
|
|
1188
|
+
"returnType": "number",
|
|
1189
|
+
"description": "Random integer in range [min, max] (inclusive)",
|
|
1190
|
+
"module": "math"
|
|
1191
|
+
},
|
|
1192
|
+
"math/round": {
|
|
1193
|
+
"category": "std-math",
|
|
1194
|
+
"minArity": 1,
|
|
1195
|
+
"maxArity": 2,
|
|
1196
|
+
"returnType": "number",
|
|
1197
|
+
"description": "Round to nearest integer or specified decimals",
|
|
1198
|
+
"module": "math"
|
|
1199
|
+
},
|
|
1200
|
+
"math/sign": {
|
|
1201
|
+
"category": "std-math",
|
|
1202
|
+
"minArity": 1,
|
|
1203
|
+
"maxArity": 1,
|
|
1204
|
+
"returnType": "number",
|
|
1205
|
+
"description": "Returns -1, 0, or 1 indicating sign",
|
|
1206
|
+
"module": "math"
|
|
1207
|
+
},
|
|
1208
|
+
"math/sqrt": {
|
|
1209
|
+
"category": "std-math",
|
|
1210
|
+
"minArity": 1,
|
|
1211
|
+
"maxArity": 1,
|
|
1212
|
+
"returnType": "number",
|
|
1213
|
+
"description": "Square root",
|
|
1214
|
+
"module": "math"
|
|
1215
|
+
},
|
|
1216
|
+
"navigate": {
|
|
1217
|
+
"category": "effect",
|
|
1218
|
+
"minArity": 1,
|
|
1219
|
+
"maxArity": 2,
|
|
1220
|
+
"returnType": "void",
|
|
1221
|
+
"description": "Navigate to a route",
|
|
1222
|
+
"module": "core",
|
|
1223
|
+
"hasSideEffects": true,
|
|
1224
|
+
"effect": {
|
|
1225
|
+
"kind": "navigate"
|
|
1226
|
+
}
|
|
1227
|
+
},
|
|
1228
|
+
"nn/batchnorm": {
|
|
1229
|
+
"category": "ml-arch",
|
|
1230
|
+
"minArity": 1,
|
|
1231
|
+
"maxArity": 1,
|
|
1232
|
+
"returnType": "nn/layer",
|
|
1233
|
+
"description": "Batch normalization layer",
|
|
1234
|
+
"module": "nn"
|
|
1235
|
+
},
|
|
1236
|
+
"nn/clone": {
|
|
1237
|
+
"category": "ml-arch",
|
|
1238
|
+
"minArity": 1,
|
|
1239
|
+
"maxArity": 1,
|
|
1240
|
+
"returnType": "nn/module",
|
|
1241
|
+
"description": "Create a deep copy of the network with same weights",
|
|
1242
|
+
"module": "nn"
|
|
1243
|
+
},
|
|
1244
|
+
"nn/dropout": {
|
|
1245
|
+
"category": "ml-arch",
|
|
1246
|
+
"minArity": 0,
|
|
1247
|
+
"maxArity": 1,
|
|
1248
|
+
"returnType": "nn/layer",
|
|
1249
|
+
"description": "Dropout layer for regularization (randomly zeros elements during training)",
|
|
1250
|
+
"module": "nn"
|
|
1251
|
+
},
|
|
1252
|
+
"nn/forward": {
|
|
1253
|
+
"category": "ml-effect",
|
|
1254
|
+
"minArity": 2,
|
|
1255
|
+
"maxArity": 2,
|
|
1256
|
+
"returnType": "tensor",
|
|
1257
|
+
"description": "Execute forward pass through network",
|
|
1258
|
+
"module": "nn"
|
|
1259
|
+
},
|
|
1260
|
+
"nn/getWeights": {
|
|
1261
|
+
"category": "ml-arch",
|
|
1262
|
+
"minArity": 1,
|
|
1263
|
+
"maxArity": 1,
|
|
1264
|
+
"returnType": "tensor",
|
|
1265
|
+
"description": "Get network weights as a flat tensor",
|
|
1266
|
+
"module": "nn"
|
|
1267
|
+
},
|
|
1268
|
+
"nn/layernorm": {
|
|
1269
|
+
"category": "ml-arch",
|
|
1270
|
+
"minArity": 1,
|
|
1271
|
+
"maxArity": 1,
|
|
1272
|
+
"returnType": "nn/layer",
|
|
1273
|
+
"description": "Layer normalization",
|
|
1274
|
+
"module": "nn"
|
|
1275
|
+
},
|
|
1276
|
+
"nn/linear": {
|
|
1277
|
+
"category": "ml-arch",
|
|
1278
|
+
"minArity": 2,
|
|
1279
|
+
"maxArity": 2,
|
|
1280
|
+
"returnType": "nn/layer",
|
|
1281
|
+
"description": "Fully connected linear layer (output = input * weights + bias)",
|
|
1282
|
+
"module": "nn"
|
|
1283
|
+
},
|
|
1284
|
+
"nn/paramCount": {
|
|
1285
|
+
"category": "ml-arch",
|
|
1286
|
+
"minArity": 1,
|
|
1287
|
+
"maxArity": 1,
|
|
1288
|
+
"returnType": "number",
|
|
1289
|
+
"description": "Get total number of trainable parameters",
|
|
1290
|
+
"module": "nn"
|
|
1291
|
+
},
|
|
1292
|
+
"nn/relu": {
|
|
1293
|
+
"category": "ml-arch",
|
|
1294
|
+
"minArity": 0,
|
|
1295
|
+
"maxArity": 0,
|
|
1296
|
+
"returnType": "nn/layer",
|
|
1297
|
+
"description": "ReLU activation function: max(0, x)",
|
|
1298
|
+
"module": "nn"
|
|
1299
|
+
},
|
|
1300
|
+
"nn/sequential": {
|
|
1301
|
+
"category": "ml-arch",
|
|
1302
|
+
"minArity": 1,
|
|
1303
|
+
"maxArity": null,
|
|
1304
|
+
"returnType": "nn/module",
|
|
1305
|
+
"description": "Create a sequential neural network from layers",
|
|
1306
|
+
"module": "nn"
|
|
1307
|
+
},
|
|
1308
|
+
"nn/setWeights": {
|
|
1309
|
+
"category": "ml-arch",
|
|
1310
|
+
"minArity": 2,
|
|
1311
|
+
"maxArity": 2,
|
|
1312
|
+
"returnType": "nn/module",
|
|
1313
|
+
"description": "Set network weights from a flat tensor",
|
|
1314
|
+
"module": "nn",
|
|
1315
|
+
"hasSideEffects": true
|
|
1316
|
+
},
|
|
1317
|
+
"nn/sigmoid": {
|
|
1318
|
+
"category": "ml-arch",
|
|
1319
|
+
"minArity": 0,
|
|
1320
|
+
"maxArity": 0,
|
|
1321
|
+
"returnType": "nn/layer",
|
|
1322
|
+
"description": "Sigmoid activation function: 1 / (1 + e^-x)",
|
|
1323
|
+
"module": "nn"
|
|
1324
|
+
},
|
|
1325
|
+
"nn/softmax": {
|
|
1326
|
+
"category": "ml-arch",
|
|
1327
|
+
"minArity": 0,
|
|
1328
|
+
"maxArity": 1,
|
|
1329
|
+
"returnType": "nn/layer",
|
|
1330
|
+
"description": "Softmax activation function (normalizes to probability distribution)",
|
|
1331
|
+
"module": "nn"
|
|
1332
|
+
},
|
|
1333
|
+
"nn/tanh": {
|
|
1334
|
+
"category": "ml-arch",
|
|
1335
|
+
"minArity": 0,
|
|
1336
|
+
"maxArity": 0,
|
|
1337
|
+
"returnType": "nn/layer",
|
|
1338
|
+
"description": "Tanh activation function: (e^x - e^-x) / (e^x + e^-x)",
|
|
1339
|
+
"module": "nn"
|
|
1340
|
+
},
|
|
1341
|
+
"not": {
|
|
1342
|
+
"category": "logic",
|
|
1343
|
+
"minArity": 1,
|
|
1344
|
+
"maxArity": 1,
|
|
1345
|
+
"returnType": "boolean",
|
|
1346
|
+
"description": "Logical NOT",
|
|
1347
|
+
"module": "core"
|
|
1348
|
+
},
|
|
1349
|
+
"notify": {
|
|
1350
|
+
"category": "effect",
|
|
1351
|
+
"minArity": 1,
|
|
1352
|
+
"maxArity": 2,
|
|
1353
|
+
"returnType": "void",
|
|
1354
|
+
"description": "Show a notification (in-app, email, push, sms)",
|
|
1355
|
+
"module": "core",
|
|
1356
|
+
"hasSideEffects": true,
|
|
1357
|
+
"effect": {
|
|
1358
|
+
"kind": "notify"
|
|
1359
|
+
}
|
|
1360
|
+
},
|
|
1361
|
+
"object/clone": {
|
|
1362
|
+
"category": "std-object",
|
|
1363
|
+
"minArity": 1,
|
|
1364
|
+
"maxArity": 1,
|
|
1365
|
+
"returnType": "any",
|
|
1366
|
+
"description": "Shallow clone object",
|
|
1367
|
+
"module": "object"
|
|
1368
|
+
},
|
|
1369
|
+
"object/deepClone": {
|
|
1370
|
+
"category": "std-object",
|
|
1371
|
+
"minArity": 1,
|
|
1372
|
+
"maxArity": 1,
|
|
1373
|
+
"returnType": "any",
|
|
1374
|
+
"description": "Deep clone object",
|
|
1375
|
+
"module": "object"
|
|
1376
|
+
},
|
|
1377
|
+
"object/deepMerge": {
|
|
1378
|
+
"category": "std-object",
|
|
1379
|
+
"minArity": 2,
|
|
1380
|
+
"maxArity": null,
|
|
1381
|
+
"returnType": "any",
|
|
1382
|
+
"description": "Deep merge objects (later wins)",
|
|
1383
|
+
"module": "object"
|
|
1384
|
+
},
|
|
1385
|
+
"object/empty?": {
|
|
1386
|
+
"category": "std-object",
|
|
1387
|
+
"minArity": 1,
|
|
1388
|
+
"maxArity": 1,
|
|
1389
|
+
"returnType": "boolean",
|
|
1390
|
+
"description": "Check if object has no keys",
|
|
1391
|
+
"module": "object"
|
|
1392
|
+
},
|
|
1393
|
+
"object/entries": {
|
|
1394
|
+
"category": "std-object",
|
|
1395
|
+
"minArity": 1,
|
|
1396
|
+
"maxArity": 1,
|
|
1397
|
+
"returnType": "array",
|
|
1398
|
+
"description": "Get [key, value] pairs as array",
|
|
1399
|
+
"module": "object"
|
|
1400
|
+
},
|
|
1401
|
+
"object/equals": {
|
|
1402
|
+
"category": "std-object",
|
|
1403
|
+
"minArity": 2,
|
|
1404
|
+
"maxArity": 2,
|
|
1405
|
+
"returnType": "boolean",
|
|
1406
|
+
"description": "Deep equality check",
|
|
1407
|
+
"module": "object"
|
|
1408
|
+
},
|
|
1409
|
+
"object/filter": {
|
|
1410
|
+
"category": "std-object",
|
|
1411
|
+
"minArity": 2,
|
|
1412
|
+
"maxArity": 2,
|
|
1413
|
+
"returnType": "any",
|
|
1414
|
+
"description": "Filter entries by predicate",
|
|
1415
|
+
"module": "object"
|
|
1416
|
+
},
|
|
1417
|
+
"object/fromEntries": {
|
|
1418
|
+
"category": "std-object",
|
|
1419
|
+
"minArity": 1,
|
|
1420
|
+
"maxArity": 1,
|
|
1421
|
+
"returnType": "any",
|
|
1422
|
+
"description": "Create object from [key, value] pairs",
|
|
1423
|
+
"module": "object"
|
|
1424
|
+
},
|
|
1425
|
+
"object/get": {
|
|
1426
|
+
"category": "std-object",
|
|
1427
|
+
"minArity": 2,
|
|
1428
|
+
"maxArity": 3,
|
|
1429
|
+
"returnType": "any",
|
|
1430
|
+
"description": "Get nested value by path (return type derived from input object shape and key)",
|
|
1431
|
+
"module": "object",
|
|
1432
|
+
"returnSemantics": "object-key-lookup"
|
|
1433
|
+
},
|
|
1434
|
+
"object/has": {
|
|
1435
|
+
"category": "std-object",
|
|
1436
|
+
"minArity": 2,
|
|
1437
|
+
"maxArity": 2,
|
|
1438
|
+
"returnType": "boolean",
|
|
1439
|
+
"description": "Check if path exists",
|
|
1440
|
+
"module": "object"
|
|
1441
|
+
},
|
|
1442
|
+
"object/keys": {
|
|
1443
|
+
"category": "std-object",
|
|
1444
|
+
"minArity": 1,
|
|
1445
|
+
"maxArity": 1,
|
|
1446
|
+
"returnType": "array",
|
|
1447
|
+
"description": "Get object keys as array",
|
|
1448
|
+
"module": "object"
|
|
1449
|
+
},
|
|
1450
|
+
"object/mapKeys": {
|
|
1451
|
+
"category": "std-object",
|
|
1452
|
+
"minArity": 2,
|
|
1453
|
+
"maxArity": 2,
|
|
1454
|
+
"returnType": "any",
|
|
1455
|
+
"description": "Transform all keys",
|
|
1456
|
+
"module": "object"
|
|
1457
|
+
},
|
|
1458
|
+
"object/mapValues": {
|
|
1459
|
+
"category": "std-object",
|
|
1460
|
+
"minArity": 2,
|
|
1461
|
+
"maxArity": 2,
|
|
1462
|
+
"returnType": "any",
|
|
1463
|
+
"description": "Transform all values",
|
|
1464
|
+
"module": "object"
|
|
1465
|
+
},
|
|
1466
|
+
"object/merge": {
|
|
1467
|
+
"category": "std-object",
|
|
1468
|
+
"minArity": 2,
|
|
1469
|
+
"maxArity": null,
|
|
1470
|
+
"returnType": "any",
|
|
1471
|
+
"description": "Shallow merge objects (later wins)",
|
|
1472
|
+
"module": "object"
|
|
1473
|
+
},
|
|
1474
|
+
"object/omit": {
|
|
1475
|
+
"category": "std-object",
|
|
1476
|
+
"minArity": 2,
|
|
1477
|
+
"maxArity": 2,
|
|
1478
|
+
"returnType": "any",
|
|
1479
|
+
"description": "Exclude specified keys",
|
|
1480
|
+
"module": "object"
|
|
1481
|
+
},
|
|
1482
|
+
"object/pick": {
|
|
1483
|
+
"category": "std-object",
|
|
1484
|
+
"minArity": 2,
|
|
1485
|
+
"maxArity": 2,
|
|
1486
|
+
"returnType": "any",
|
|
1487
|
+
"description": "Select only specified keys (return type is subset of input object shape)",
|
|
1488
|
+
"module": "object",
|
|
1489
|
+
"returnSemantics": "object-key-lookup"
|
|
1490
|
+
},
|
|
1491
|
+
"object/set": {
|
|
1492
|
+
"category": "std-object",
|
|
1493
|
+
"minArity": 3,
|
|
1494
|
+
"maxArity": 3,
|
|
1495
|
+
"returnType": "any",
|
|
1496
|
+
"description": "Set nested value by path (returns new object)",
|
|
1497
|
+
"module": "object"
|
|
1498
|
+
},
|
|
1499
|
+
"object/values": {
|
|
1500
|
+
"category": "std-object",
|
|
1501
|
+
"minArity": 1,
|
|
1502
|
+
"maxArity": 1,
|
|
1503
|
+
"returnType": "array",
|
|
1504
|
+
"description": "Get object values as array",
|
|
1505
|
+
"module": "object"
|
|
1506
|
+
},
|
|
1507
|
+
"or": {
|
|
1508
|
+
"category": "logic",
|
|
1509
|
+
"minArity": 2,
|
|
1510
|
+
"maxArity": null,
|
|
1511
|
+
"returnType": "boolean",
|
|
1512
|
+
"description": "Logical OR (returns the first truthy value, NOT a boolean — short-circuit)",
|
|
1513
|
+
"module": "core",
|
|
1514
|
+
"returnSemantics": "first-truthy-of-args"
|
|
1515
|
+
},
|
|
1516
|
+
"os/debounce": {
|
|
1517
|
+
"category": "std-os",
|
|
1518
|
+
"minArity": 2,
|
|
1519
|
+
"maxArity": 2,
|
|
1520
|
+
"returnType": "void",
|
|
1521
|
+
"description": "Configure debounce interval for an OS event type. Prevents trigger storms during rapid changes.",
|
|
1522
|
+
"module": "os",
|
|
1523
|
+
"hasSideEffects": true
|
|
1524
|
+
},
|
|
1525
|
+
"os/watch-cron": {
|
|
1526
|
+
"category": "std-os",
|
|
1527
|
+
"minArity": 1,
|
|
1528
|
+
"maxArity": 1,
|
|
1529
|
+
"returnType": "void",
|
|
1530
|
+
"description": "Register cron schedule. Emits OS_CRON_FIRE events with { expression, timestamp } payload.",
|
|
1531
|
+
"module": "os",
|
|
1532
|
+
"hasSideEffects": true
|
|
1533
|
+
},
|
|
1534
|
+
"os/watch-env": {
|
|
1535
|
+
"category": "std-os",
|
|
1536
|
+
"minArity": 1,
|
|
1537
|
+
"maxArity": 1,
|
|
1538
|
+
"returnType": "void",
|
|
1539
|
+
"description": "Register environment variable watcher. Emits OS_ENV_CHANGED events with { variable, oldValue, newValue } payload.",
|
|
1540
|
+
"module": "os",
|
|
1541
|
+
"hasSideEffects": true
|
|
1542
|
+
},
|
|
1543
|
+
"os/watch-files": {
|
|
1544
|
+
"category": "std-os",
|
|
1545
|
+
"minArity": 1,
|
|
1546
|
+
"maxArity": 2,
|
|
1547
|
+
"returnType": "void",
|
|
1548
|
+
"description": "Register file system watcher. Emits OS_FILE_MODIFIED, OS_FILE_CREATED, OS_FILE_DELETED events with { path, name, dir, timestamp } payload.",
|
|
1549
|
+
"module": "os",
|
|
1550
|
+
"hasSideEffects": true
|
|
1551
|
+
},
|
|
1552
|
+
"os/watch-http": {
|
|
1553
|
+
"category": "std-os",
|
|
1554
|
+
"minArity": 1,
|
|
1555
|
+
"maxArity": 2,
|
|
1556
|
+
"returnType": "void",
|
|
1557
|
+
"description": "Register HTTP response interceptor. Emits OS_HTTP_RESPONSE events with { url, method, status, headers, body, duration } payload.",
|
|
1558
|
+
"module": "os",
|
|
1559
|
+
"hasSideEffects": true
|
|
1560
|
+
},
|
|
1561
|
+
"os/watch-port": {
|
|
1562
|
+
"category": "std-os",
|
|
1563
|
+
"minArity": 1,
|
|
1564
|
+
"maxArity": 2,
|
|
1565
|
+
"returnType": "void",
|
|
1566
|
+
"description": "Register port monitor. Emits OS_PORT_OPENED, OS_PORT_CLOSED events with { port, protocol, pid, address } payload.",
|
|
1567
|
+
"module": "os",
|
|
1568
|
+
"hasSideEffects": true
|
|
1569
|
+
},
|
|
1570
|
+
"os/watch-process": {
|
|
1571
|
+
"category": "std-os",
|
|
1572
|
+
"minArity": 1,
|
|
1573
|
+
"maxArity": 2,
|
|
1574
|
+
"returnType": "void",
|
|
1575
|
+
"description": "Register process monitor. Emits OS_PROCESS_EXITED, OS_PROCESS_STARTED events with { pid, name, exitCode, signal, args, duration } payload.",
|
|
1576
|
+
"module": "os",
|
|
1577
|
+
"hasSideEffects": true
|
|
1578
|
+
},
|
|
1579
|
+
"os/watch-signal": {
|
|
1580
|
+
"category": "std-os",
|
|
1581
|
+
"minArity": 1,
|
|
1582
|
+
"maxArity": 1,
|
|
1583
|
+
"returnType": "void",
|
|
1584
|
+
"description": "Register OS signal handler. Emits OS_SIGNAL_USR1, OS_SIGNAL_HUP, etc. with { pid, timestamp } payload.",
|
|
1585
|
+
"module": "os",
|
|
1586
|
+
"hasSideEffects": true
|
|
1587
|
+
},
|
|
1588
|
+
"path": {
|
|
1589
|
+
"category": "std-object",
|
|
1590
|
+
"minArity": 1,
|
|
1591
|
+
"maxArity": null,
|
|
1592
|
+
"returnType": "string",
|
|
1593
|
+
"description": "Build a dot-separated path string from segments. Used with set effect for dynamic field paths.",
|
|
1594
|
+
"module": "object"
|
|
1595
|
+
},
|
|
1596
|
+
"persist": {
|
|
1597
|
+
"category": "effect",
|
|
1598
|
+
"minArity": 2,
|
|
1599
|
+
"maxArity": 4,
|
|
1600
|
+
"returnType": "void",
|
|
1601
|
+
"description": "Create, update, delete, clear, or batch entity records. Optional trailing { emit: { success, failure } } options object attaches closed-circuit emit routing.",
|
|
1602
|
+
"module": "core",
|
|
1603
|
+
"hasSideEffects": true,
|
|
1604
|
+
"effect": {
|
|
1605
|
+
"kind": "persist",
|
|
1606
|
+
"produces": {
|
|
1607
|
+
"kind": "union",
|
|
1608
|
+
"of": [
|
|
1609
|
+
{
|
|
1610
|
+
"kind": "entity"
|
|
1611
|
+
},
|
|
1612
|
+
{
|
|
1613
|
+
"kind": "object",
|
|
1614
|
+
"fields": {
|
|
1615
|
+
"id": "string",
|
|
1616
|
+
"deleted": "boolean"
|
|
1617
|
+
},
|
|
1618
|
+
"open": false
|
|
1619
|
+
},
|
|
1620
|
+
{
|
|
1621
|
+
"kind": "object",
|
|
1622
|
+
"fields": {
|
|
1623
|
+
"operations": {
|
|
1624
|
+
"kind": "array",
|
|
1625
|
+
"of": "any"
|
|
1626
|
+
},
|
|
1627
|
+
"completedCount": "number",
|
|
1628
|
+
"totalCount": "number"
|
|
1629
|
+
},
|
|
1630
|
+
"open": false
|
|
1631
|
+
}
|
|
1632
|
+
]
|
|
1633
|
+
}
|
|
1634
|
+
}
|
|
1635
|
+
},
|
|
1636
|
+
"prob/beta": {
|
|
1637
|
+
"category": "std-prob",
|
|
1638
|
+
"minArity": 2,
|
|
1639
|
+
"maxArity": 2,
|
|
1640
|
+
"returnType": "number",
|
|
1641
|
+
"description": "Sample from a Beta(alpha, beta) distribution",
|
|
1642
|
+
"module": "prob"
|
|
1643
|
+
},
|
|
1644
|
+
"prob/categorical": {
|
|
1645
|
+
"category": "std-prob",
|
|
1646
|
+
"minArity": 2,
|
|
1647
|
+
"maxArity": 2,
|
|
1648
|
+
"returnType": "any",
|
|
1649
|
+
"description": "Weighted random selection from items",
|
|
1650
|
+
"module": "prob"
|
|
1651
|
+
},
|
|
1652
|
+
"prob/condition": {
|
|
1653
|
+
"category": "std-prob",
|
|
1654
|
+
"minArity": 1,
|
|
1655
|
+
"maxArity": 1,
|
|
1656
|
+
"returnType": "void",
|
|
1657
|
+
"description": "Mark current sample as rejected if predicate is false",
|
|
1658
|
+
"module": "prob",
|
|
1659
|
+
"hasSideEffects": true
|
|
1660
|
+
},
|
|
1661
|
+
"prob/credible-interval": {
|
|
1662
|
+
"category": "std-prob",
|
|
1663
|
+
"minArity": 2,
|
|
1664
|
+
"maxArity": 2,
|
|
1665
|
+
"returnType": "array",
|
|
1666
|
+
"description": "Compute symmetric credible interval from samples",
|
|
1667
|
+
"module": "prob"
|
|
1668
|
+
},
|
|
1669
|
+
"prob/expected-value": {
|
|
1670
|
+
"category": "std-prob",
|
|
1671
|
+
"minArity": 1,
|
|
1672
|
+
"maxArity": 1,
|
|
1673
|
+
"returnType": "number",
|
|
1674
|
+
"description": "Mean of numeric samples",
|
|
1675
|
+
"module": "prob"
|
|
1676
|
+
},
|
|
1677
|
+
"prob/flip": {
|
|
1678
|
+
"category": "std-prob",
|
|
1679
|
+
"minArity": 1,
|
|
1680
|
+
"maxArity": 1,
|
|
1681
|
+
"returnType": "boolean",
|
|
1682
|
+
"description": "Bernoulli trial: returns true with probability p",
|
|
1683
|
+
"module": "prob"
|
|
1684
|
+
},
|
|
1685
|
+
"prob/gaussian": {
|
|
1686
|
+
"category": "std-prob",
|
|
1687
|
+
"minArity": 2,
|
|
1688
|
+
"maxArity": 2,
|
|
1689
|
+
"returnType": "number",
|
|
1690
|
+
"description": "Sample from a Gaussian (normal) distribution",
|
|
1691
|
+
"module": "prob"
|
|
1692
|
+
},
|
|
1693
|
+
"prob/histogram": {
|
|
1694
|
+
"category": "std-prob",
|
|
1695
|
+
"minArity": 2,
|
|
1696
|
+
"maxArity": 2,
|
|
1697
|
+
"returnType": "object",
|
|
1698
|
+
"description": "Bin numeric samples into a histogram",
|
|
1699
|
+
"module": "prob"
|
|
1700
|
+
},
|
|
1701
|
+
"prob/infer": {
|
|
1702
|
+
"category": "std-prob",
|
|
1703
|
+
"minArity": 4,
|
|
1704
|
+
"maxArity": 4,
|
|
1705
|
+
"returnType": "object",
|
|
1706
|
+
"description": "Like posterior but returns {mean, variance, samples, acceptRate}",
|
|
1707
|
+
"module": "prob"
|
|
1708
|
+
},
|
|
1709
|
+
"prob/percentile": {
|
|
1710
|
+
"category": "std-prob",
|
|
1711
|
+
"minArity": 2,
|
|
1712
|
+
"maxArity": 2,
|
|
1713
|
+
"returnType": "number",
|
|
1714
|
+
"description": "Get the p-th percentile (0-100) from samples",
|
|
1715
|
+
"module": "prob"
|
|
1716
|
+
},
|
|
1717
|
+
"prob/poisson": {
|
|
1718
|
+
"category": "std-prob",
|
|
1719
|
+
"minArity": 1,
|
|
1720
|
+
"maxArity": 1,
|
|
1721
|
+
"returnType": "number",
|
|
1722
|
+
"description": "Sample from a Poisson distribution",
|
|
1723
|
+
"module": "prob"
|
|
1724
|
+
},
|
|
1725
|
+
"prob/posterior": {
|
|
1726
|
+
"category": "std-prob",
|
|
1727
|
+
"minArity": 4,
|
|
1728
|
+
"maxArity": 4,
|
|
1729
|
+
"returnType": "array",
|
|
1730
|
+
"description": "Rejection sampling: returns accepted query values",
|
|
1731
|
+
"module": "prob"
|
|
1732
|
+
},
|
|
1733
|
+
"prob/sample": {
|
|
1734
|
+
"category": "std-prob",
|
|
1735
|
+
"minArity": 2,
|
|
1736
|
+
"maxArity": 2,
|
|
1737
|
+
"returnType": "array",
|
|
1738
|
+
"description": "Evaluate an expression n times and collect results",
|
|
1739
|
+
"module": "prob"
|
|
1740
|
+
},
|
|
1741
|
+
"prob/seed": {
|
|
1742
|
+
"category": "std-prob",
|
|
1743
|
+
"minArity": 1,
|
|
1744
|
+
"maxArity": 1,
|
|
1745
|
+
"returnType": "void",
|
|
1746
|
+
"description": "Set seeded PRNG for deterministic probabilistic sampling",
|
|
1747
|
+
"module": "prob",
|
|
1748
|
+
"hasSideEffects": true
|
|
1749
|
+
},
|
|
1750
|
+
"prob/uniform": {
|
|
1751
|
+
"category": "std-prob",
|
|
1752
|
+
"minArity": 2,
|
|
1753
|
+
"maxArity": 2,
|
|
1754
|
+
"returnType": "number",
|
|
1755
|
+
"description": "Sample from a uniform distribution [lo, hi)",
|
|
1756
|
+
"module": "prob"
|
|
1757
|
+
},
|
|
1758
|
+
"prob/variance": {
|
|
1759
|
+
"category": "std-prob",
|
|
1760
|
+
"minArity": 1,
|
|
1761
|
+
"maxArity": 1,
|
|
1762
|
+
"returnType": "number",
|
|
1763
|
+
"description": "Population variance of numeric samples",
|
|
1764
|
+
"module": "prob"
|
|
1765
|
+
},
|
|
1766
|
+
"ref": {
|
|
1767
|
+
"category": "effect",
|
|
1768
|
+
"minArity": 1,
|
|
1769
|
+
"maxArity": 2,
|
|
1770
|
+
"returnType": "void",
|
|
1771
|
+
"description": "Reactive entity reference (deprecated, use fetch with listens in V2)",
|
|
1772
|
+
"module": "core",
|
|
1773
|
+
"hasSideEffects": true,
|
|
1774
|
+
"effect": {
|
|
1775
|
+
"kind": "ref",
|
|
1776
|
+
"produces": {
|
|
1777
|
+
"kind": "union",
|
|
1778
|
+
"of": [
|
|
1779
|
+
{
|
|
1780
|
+
"kind": "entity"
|
|
1781
|
+
},
|
|
1782
|
+
{
|
|
1783
|
+
"kind": "array",
|
|
1784
|
+
"of": {
|
|
1785
|
+
"kind": "entity"
|
|
1786
|
+
}
|
|
1787
|
+
}
|
|
1788
|
+
]
|
|
1789
|
+
}
|
|
1790
|
+
}
|
|
1791
|
+
},
|
|
1792
|
+
"render-ui": {
|
|
1793
|
+
"category": "effect",
|
|
1794
|
+
"minArity": 2,
|
|
1795
|
+
"maxArity": 3,
|
|
1796
|
+
"returnType": "void",
|
|
1797
|
+
"description": "Render a pattern into a UI slot",
|
|
1798
|
+
"module": "core",
|
|
1799
|
+
"hasSideEffects": true,
|
|
1800
|
+
"effect": {
|
|
1801
|
+
"kind": "render-ui"
|
|
1802
|
+
}
|
|
1803
|
+
},
|
|
1804
|
+
"set": {
|
|
1805
|
+
"category": "effect",
|
|
1806
|
+
"minArity": 2,
|
|
1807
|
+
"maxArity": 2,
|
|
1808
|
+
"returnType": "void",
|
|
1809
|
+
"description": "Set a binding to a value",
|
|
1810
|
+
"module": "core",
|
|
1811
|
+
"hasSideEffects": true,
|
|
1812
|
+
"effect": {
|
|
1813
|
+
"kind": "set",
|
|
1814
|
+
"produces": "any",
|
|
1815
|
+
"config": {
|
|
1816
|
+
"operation": {
|
|
1817
|
+
"kind": "union",
|
|
1818
|
+
"of": [
|
|
1819
|
+
{
|
|
1820
|
+
"kind": "literal",
|
|
1821
|
+
"value": "increment"
|
|
1822
|
+
},
|
|
1823
|
+
{
|
|
1824
|
+
"kind": "literal",
|
|
1825
|
+
"value": "decrement"
|
|
1826
|
+
},
|
|
1827
|
+
{
|
|
1828
|
+
"kind": "literal",
|
|
1829
|
+
"value": "multiply"
|
|
1830
|
+
},
|
|
1831
|
+
{
|
|
1832
|
+
"kind": "literal",
|
|
1833
|
+
"value": "append"
|
|
1834
|
+
},
|
|
1835
|
+
{
|
|
1836
|
+
"kind": "literal",
|
|
1837
|
+
"value": "remove"
|
|
1838
|
+
}
|
|
1839
|
+
]
|
|
1840
|
+
}
|
|
1841
|
+
}
|
|
1842
|
+
}
|
|
1843
|
+
},
|
|
1844
|
+
"spawn": {
|
|
1845
|
+
"category": "effect",
|
|
1846
|
+
"minArity": 1,
|
|
1847
|
+
"maxArity": 2,
|
|
1848
|
+
"returnType": "void",
|
|
1849
|
+
"description": "Spawn a new entity instance (games)",
|
|
1850
|
+
"module": "core",
|
|
1851
|
+
"hasSideEffects": true,
|
|
1852
|
+
"effect": {
|
|
1853
|
+
"kind": "spawn"
|
|
1854
|
+
}
|
|
1855
|
+
},
|
|
1856
|
+
"str/camelCase": {
|
|
1857
|
+
"category": "std-str",
|
|
1858
|
+
"minArity": 1,
|
|
1859
|
+
"maxArity": 1,
|
|
1860
|
+
"returnType": "string",
|
|
1861
|
+
"description": "Convert to camelCase",
|
|
1862
|
+
"module": "str"
|
|
1863
|
+
},
|
|
1864
|
+
"str/capitalize": {
|
|
1865
|
+
"category": "std-str",
|
|
1866
|
+
"minArity": 1,
|
|
1867
|
+
"maxArity": 1,
|
|
1868
|
+
"returnType": "string",
|
|
1869
|
+
"description": "Capitalize first character",
|
|
1870
|
+
"module": "str"
|
|
1871
|
+
},
|
|
1872
|
+
"str/concat": {
|
|
1873
|
+
"category": "std-str",
|
|
1874
|
+
"minArity": 1,
|
|
1875
|
+
"maxArity": 99,
|
|
1876
|
+
"returnType": "string",
|
|
1877
|
+
"description": "Concatenate strings together",
|
|
1878
|
+
"module": "str"
|
|
1879
|
+
},
|
|
1880
|
+
"str/default": {
|
|
1881
|
+
"category": "std-str",
|
|
1882
|
+
"minArity": 2,
|
|
1883
|
+
"maxArity": 2,
|
|
1884
|
+
"returnType": "string",
|
|
1885
|
+
"description": "Return default if value is null/undefined/empty",
|
|
1886
|
+
"module": "str"
|
|
1887
|
+
},
|
|
1888
|
+
"str/endsWith": {
|
|
1889
|
+
"category": "std-str",
|
|
1890
|
+
"minArity": 2,
|
|
1891
|
+
"maxArity": 2,
|
|
1892
|
+
"returnType": "boolean",
|
|
1893
|
+
"description": "Check if string ends with suffix",
|
|
1894
|
+
"module": "str"
|
|
1895
|
+
},
|
|
1896
|
+
"str/includes": {
|
|
1897
|
+
"category": "std-str",
|
|
1898
|
+
"minArity": 2,
|
|
1899
|
+
"maxArity": 2,
|
|
1900
|
+
"returnType": "boolean",
|
|
1901
|
+
"description": "Check if string contains substring",
|
|
1902
|
+
"module": "str"
|
|
1903
|
+
},
|
|
1904
|
+
"str/join": {
|
|
1905
|
+
"category": "std-str",
|
|
1906
|
+
"minArity": 2,
|
|
1907
|
+
"maxArity": 2,
|
|
1908
|
+
"returnType": "string",
|
|
1909
|
+
"description": "Join array elements into string",
|
|
1910
|
+
"module": "str"
|
|
1911
|
+
},
|
|
1912
|
+
"str/kebabCase": {
|
|
1913
|
+
"category": "std-str",
|
|
1914
|
+
"minArity": 1,
|
|
1915
|
+
"maxArity": 1,
|
|
1916
|
+
"returnType": "string",
|
|
1917
|
+
"description": "Convert to kebab-case",
|
|
1918
|
+
"module": "str"
|
|
1919
|
+
},
|
|
1920
|
+
"str/len": {
|
|
1921
|
+
"category": "std-str",
|
|
1922
|
+
"minArity": 1,
|
|
1923
|
+
"maxArity": 1,
|
|
1924
|
+
"returnType": "number",
|
|
1925
|
+
"description": "String length",
|
|
1926
|
+
"module": "str"
|
|
1927
|
+
},
|
|
1928
|
+
"str/lower": {
|
|
1929
|
+
"category": "std-str",
|
|
1930
|
+
"minArity": 1,
|
|
1931
|
+
"maxArity": 1,
|
|
1932
|
+
"returnType": "string",
|
|
1933
|
+
"description": "Convert to lowercase",
|
|
1934
|
+
"module": "str"
|
|
1935
|
+
},
|
|
1936
|
+
"str/padEnd": {
|
|
1937
|
+
"category": "std-str",
|
|
1938
|
+
"minArity": 2,
|
|
1939
|
+
"maxArity": 3,
|
|
1940
|
+
"returnType": "string",
|
|
1941
|
+
"description": "Pad string from end to target length",
|
|
1942
|
+
"module": "str"
|
|
1943
|
+
},
|
|
1944
|
+
"str/padStart": {
|
|
1945
|
+
"category": "std-str",
|
|
1946
|
+
"minArity": 2,
|
|
1947
|
+
"maxArity": 3,
|
|
1948
|
+
"returnType": "string",
|
|
1949
|
+
"description": "Pad string from start to target length",
|
|
1950
|
+
"module": "str"
|
|
1951
|
+
},
|
|
1952
|
+
"str/repeat": {
|
|
1953
|
+
"category": "std-str",
|
|
1954
|
+
"minArity": 2,
|
|
1955
|
+
"maxArity": 2,
|
|
1956
|
+
"returnType": "string",
|
|
1957
|
+
"description": "Repeat string n times",
|
|
1958
|
+
"module": "str"
|
|
1959
|
+
},
|
|
1960
|
+
"str/replace": {
|
|
1961
|
+
"category": "std-str",
|
|
1962
|
+
"minArity": 3,
|
|
1963
|
+
"maxArity": 3,
|
|
1964
|
+
"returnType": "string",
|
|
1965
|
+
"description": "Replace first occurrence",
|
|
1966
|
+
"module": "str"
|
|
1967
|
+
},
|
|
1968
|
+
"str/replaceAll": {
|
|
1969
|
+
"category": "std-str",
|
|
1970
|
+
"minArity": 3,
|
|
1971
|
+
"maxArity": 3,
|
|
1972
|
+
"returnType": "string",
|
|
1973
|
+
"description": "Replace all occurrences",
|
|
1974
|
+
"module": "str"
|
|
1975
|
+
},
|
|
1976
|
+
"str/reverse": {
|
|
1977
|
+
"category": "std-str",
|
|
1978
|
+
"minArity": 1,
|
|
1979
|
+
"maxArity": 1,
|
|
1980
|
+
"returnType": "string",
|
|
1981
|
+
"description": "Reverse string",
|
|
1982
|
+
"module": "str"
|
|
1983
|
+
},
|
|
1984
|
+
"str/slice": {
|
|
1985
|
+
"category": "std-str",
|
|
1986
|
+
"minArity": 2,
|
|
1987
|
+
"maxArity": 3,
|
|
1988
|
+
"returnType": "string",
|
|
1989
|
+
"description": "Extract substring",
|
|
1990
|
+
"module": "str"
|
|
1991
|
+
},
|
|
1992
|
+
"str/snakeCase": {
|
|
1993
|
+
"category": "std-str",
|
|
1994
|
+
"minArity": 1,
|
|
1995
|
+
"maxArity": 1,
|
|
1996
|
+
"returnType": "string",
|
|
1997
|
+
"description": "Convert to snake_case",
|
|
1998
|
+
"module": "str"
|
|
1999
|
+
},
|
|
2000
|
+
"str/split": {
|
|
2001
|
+
"category": "std-str",
|
|
2002
|
+
"minArity": 2,
|
|
2003
|
+
"maxArity": 2,
|
|
2004
|
+
"returnType": "array",
|
|
2005
|
+
"description": "Split string into array by delimiter",
|
|
2006
|
+
"module": "str"
|
|
2007
|
+
},
|
|
2008
|
+
"str/startsWith": {
|
|
2009
|
+
"category": "std-str",
|
|
2010
|
+
"minArity": 2,
|
|
2011
|
+
"maxArity": 2,
|
|
2012
|
+
"returnType": "boolean",
|
|
2013
|
+
"description": "Check if string starts with prefix",
|
|
2014
|
+
"module": "str"
|
|
2015
|
+
},
|
|
2016
|
+
"str/template": {
|
|
2017
|
+
"category": "std-str",
|
|
2018
|
+
"minArity": 2,
|
|
2019
|
+
"maxArity": 2,
|
|
2020
|
+
"returnType": "string",
|
|
2021
|
+
"description": "Variable substitution in template string",
|
|
2022
|
+
"module": "str"
|
|
2023
|
+
},
|
|
2024
|
+
"str/titleCase": {
|
|
2025
|
+
"category": "std-str",
|
|
2026
|
+
"minArity": 1,
|
|
2027
|
+
"maxArity": 1,
|
|
2028
|
+
"returnType": "string",
|
|
2029
|
+
"description": "Convert to Title Case",
|
|
2030
|
+
"module": "str"
|
|
2031
|
+
},
|
|
2032
|
+
"str/trim": {
|
|
2033
|
+
"category": "std-str",
|
|
2034
|
+
"minArity": 1,
|
|
2035
|
+
"maxArity": 1,
|
|
2036
|
+
"returnType": "string",
|
|
2037
|
+
"description": "Remove leading and trailing whitespace",
|
|
2038
|
+
"module": "str"
|
|
2039
|
+
},
|
|
2040
|
+
"str/trimEnd": {
|
|
2041
|
+
"category": "std-str",
|
|
2042
|
+
"minArity": 1,
|
|
2043
|
+
"maxArity": 1,
|
|
2044
|
+
"returnType": "string",
|
|
2045
|
+
"description": "Remove trailing whitespace",
|
|
2046
|
+
"module": "str"
|
|
2047
|
+
},
|
|
2048
|
+
"str/trimStart": {
|
|
2049
|
+
"category": "std-str",
|
|
2050
|
+
"minArity": 1,
|
|
2051
|
+
"maxArity": 1,
|
|
2052
|
+
"returnType": "string",
|
|
2053
|
+
"description": "Remove leading whitespace",
|
|
2054
|
+
"module": "str"
|
|
2055
|
+
},
|
|
2056
|
+
"str/truncate": {
|
|
2057
|
+
"category": "std-str",
|
|
2058
|
+
"minArity": 2,
|
|
2059
|
+
"maxArity": 3,
|
|
2060
|
+
"returnType": "string",
|
|
2061
|
+
"description": "Truncate string with optional suffix",
|
|
2062
|
+
"module": "str"
|
|
2063
|
+
},
|
|
2064
|
+
"str/upper": {
|
|
2065
|
+
"category": "std-str",
|
|
2066
|
+
"minArity": 1,
|
|
2067
|
+
"maxArity": 1,
|
|
2068
|
+
"returnType": "string",
|
|
2069
|
+
"description": "Convert to uppercase",
|
|
2070
|
+
"module": "str"
|
|
2071
|
+
},
|
|
2072
|
+
"tensor/add": {
|
|
2073
|
+
"category": "ml-tensor",
|
|
2074
|
+
"minArity": 2,
|
|
2075
|
+
"maxArity": 2,
|
|
2076
|
+
"returnType": "tensor",
|
|
2077
|
+
"description": "Element-wise addition",
|
|
2078
|
+
"module": "tensor"
|
|
2079
|
+
},
|
|
2080
|
+
"tensor/allInRange": {
|
|
2081
|
+
"category": "ml-tensor",
|
|
2082
|
+
"minArity": 2,
|
|
2083
|
+
"maxArity": 2,
|
|
2084
|
+
"returnType": "boolean",
|
|
2085
|
+
"description": "Check if all elements are within range [min, max]",
|
|
2086
|
+
"module": "tensor"
|
|
2087
|
+
},
|
|
2088
|
+
"tensor/argmax": {
|
|
2089
|
+
"category": "ml-tensor",
|
|
2090
|
+
"minArity": 1,
|
|
2091
|
+
"maxArity": 2,
|
|
2092
|
+
"returnType": "number | tensor",
|
|
2093
|
+
"description": "Index of maximum value",
|
|
2094
|
+
"module": "tensor"
|
|
2095
|
+
},
|
|
2096
|
+
"tensor/clamp": {
|
|
2097
|
+
"category": "ml-tensor",
|
|
2098
|
+
"minArity": 3,
|
|
2099
|
+
"maxArity": 3,
|
|
2100
|
+
"returnType": "tensor",
|
|
2101
|
+
"description": "Clamp all elements to range [min, max]",
|
|
2102
|
+
"module": "tensor"
|
|
2103
|
+
},
|
|
2104
|
+
"tensor/clampPerDim": {
|
|
2105
|
+
"category": "ml-tensor",
|
|
2106
|
+
"minArity": 2,
|
|
2107
|
+
"maxArity": 2,
|
|
2108
|
+
"returnType": "tensor",
|
|
2109
|
+
"description": "Clamp each dimension to its specified range",
|
|
2110
|
+
"module": "tensor"
|
|
2111
|
+
},
|
|
2112
|
+
"tensor/div": {
|
|
2113
|
+
"category": "ml-tensor",
|
|
2114
|
+
"minArity": 2,
|
|
2115
|
+
"maxArity": 2,
|
|
2116
|
+
"returnType": "tensor",
|
|
2117
|
+
"description": "Element-wise division",
|
|
2118
|
+
"module": "tensor"
|
|
2119
|
+
},
|
|
2120
|
+
"tensor/dot": {
|
|
2121
|
+
"category": "ml-tensor",
|
|
2122
|
+
"minArity": 2,
|
|
2123
|
+
"maxArity": 2,
|
|
2124
|
+
"returnType": "number",
|
|
2125
|
+
"description": "Dot product of two 1D tensors",
|
|
2126
|
+
"module": "tensor"
|
|
2127
|
+
},
|
|
2128
|
+
"tensor/flatten": {
|
|
2129
|
+
"category": "ml-tensor",
|
|
2130
|
+
"minArity": 1,
|
|
2131
|
+
"maxArity": 1,
|
|
2132
|
+
"returnType": "tensor",
|
|
2133
|
+
"description": "Flatten tensor to 1D",
|
|
2134
|
+
"module": "tensor"
|
|
2135
|
+
},
|
|
2136
|
+
"tensor/from": {
|
|
2137
|
+
"category": "ml-tensor",
|
|
2138
|
+
"minArity": 1,
|
|
2139
|
+
"maxArity": 1,
|
|
2140
|
+
"returnType": "tensor",
|
|
2141
|
+
"description": "Create tensor from array",
|
|
2142
|
+
"module": "tensor"
|
|
2143
|
+
},
|
|
2144
|
+
"tensor/get": {
|
|
2145
|
+
"category": "ml-tensor",
|
|
2146
|
+
"minArity": 2,
|
|
2147
|
+
"maxArity": 2,
|
|
2148
|
+
"returnType": "number",
|
|
2149
|
+
"description": "Get element at index",
|
|
2150
|
+
"module": "tensor"
|
|
2151
|
+
},
|
|
2152
|
+
"tensor/matmul": {
|
|
2153
|
+
"category": "ml-tensor",
|
|
2154
|
+
"minArity": 2,
|
|
2155
|
+
"maxArity": 2,
|
|
2156
|
+
"returnType": "tensor",
|
|
2157
|
+
"description": "Matrix multiplication",
|
|
2158
|
+
"module": "tensor"
|
|
2159
|
+
},
|
|
2160
|
+
"tensor/max": {
|
|
2161
|
+
"category": "ml-tensor",
|
|
2162
|
+
"minArity": 1,
|
|
2163
|
+
"maxArity": 2,
|
|
2164
|
+
"returnType": "number | tensor",
|
|
2165
|
+
"description": "Maximum value in tensor",
|
|
2166
|
+
"module": "tensor"
|
|
2167
|
+
},
|
|
2168
|
+
"tensor/mean": {
|
|
2169
|
+
"category": "ml-tensor",
|
|
2170
|
+
"minArity": 1,
|
|
2171
|
+
"maxArity": 2,
|
|
2172
|
+
"returnType": "number | tensor",
|
|
2173
|
+
"description": "Mean of tensor elements",
|
|
2174
|
+
"module": "tensor"
|
|
2175
|
+
},
|
|
2176
|
+
"tensor/min": {
|
|
2177
|
+
"category": "ml-tensor",
|
|
2178
|
+
"minArity": 1,
|
|
2179
|
+
"maxArity": 2,
|
|
2180
|
+
"returnType": "number | tensor",
|
|
2181
|
+
"description": "Minimum value in tensor",
|
|
2182
|
+
"module": "tensor"
|
|
2183
|
+
},
|
|
2184
|
+
"tensor/mul": {
|
|
2185
|
+
"category": "ml-tensor",
|
|
2186
|
+
"minArity": 2,
|
|
2187
|
+
"maxArity": 2,
|
|
2188
|
+
"returnType": "tensor",
|
|
2189
|
+
"description": "Element-wise multiplication",
|
|
2190
|
+
"module": "tensor"
|
|
2191
|
+
},
|
|
2192
|
+
"tensor/norm": {
|
|
2193
|
+
"category": "ml-tensor",
|
|
2194
|
+
"minArity": 1,
|
|
2195
|
+
"maxArity": 2,
|
|
2196
|
+
"returnType": "number",
|
|
2197
|
+
"description": "L2 norm of tensor",
|
|
2198
|
+
"module": "tensor"
|
|
2199
|
+
},
|
|
2200
|
+
"tensor/ones": {
|
|
2201
|
+
"category": "ml-tensor",
|
|
2202
|
+
"minArity": 1,
|
|
2203
|
+
"maxArity": 1,
|
|
2204
|
+
"returnType": "tensor",
|
|
2205
|
+
"description": "Create tensor filled with ones",
|
|
2206
|
+
"module": "tensor"
|
|
2207
|
+
},
|
|
2208
|
+
"tensor/outOfRangeDims": {
|
|
2209
|
+
"category": "ml-tensor",
|
|
2210
|
+
"minArity": 2,
|
|
2211
|
+
"maxArity": 2,
|
|
2212
|
+
"returnType": "array",
|
|
2213
|
+
"description": "Get dimensions that exceed their specified ranges",
|
|
2214
|
+
"module": "tensor"
|
|
2215
|
+
},
|
|
2216
|
+
"tensor/outOfRangeIndices": {
|
|
2217
|
+
"category": "ml-tensor",
|
|
2218
|
+
"minArity": 2,
|
|
2219
|
+
"maxArity": 2,
|
|
2220
|
+
"returnType": "number[]",
|
|
2221
|
+
"description": "Get indices of elements outside range",
|
|
2222
|
+
"module": "tensor"
|
|
2223
|
+
},
|
|
2224
|
+
"tensor/rand": {
|
|
2225
|
+
"category": "ml-tensor",
|
|
2226
|
+
"minArity": 1,
|
|
2227
|
+
"maxArity": 1,
|
|
2228
|
+
"returnType": "tensor",
|
|
2229
|
+
"description": "Create tensor with random values in [0, 1)",
|
|
2230
|
+
"module": "tensor"
|
|
2231
|
+
},
|
|
2232
|
+
"tensor/randn": {
|
|
2233
|
+
"category": "ml-tensor",
|
|
2234
|
+
"minArity": 1,
|
|
2235
|
+
"maxArity": 1,
|
|
2236
|
+
"returnType": "tensor",
|
|
2237
|
+
"description": "Create tensor with random values from standard normal distribution",
|
|
2238
|
+
"module": "tensor"
|
|
2239
|
+
},
|
|
2240
|
+
"tensor/reshape": {
|
|
2241
|
+
"category": "ml-tensor",
|
|
2242
|
+
"minArity": 2,
|
|
2243
|
+
"maxArity": 2,
|
|
2244
|
+
"returnType": "tensor",
|
|
2245
|
+
"description": "Reshape tensor to new shape (total elements must match)",
|
|
2246
|
+
"module": "tensor"
|
|
2247
|
+
},
|
|
2248
|
+
"tensor/shape": {
|
|
2249
|
+
"category": "ml-tensor",
|
|
2250
|
+
"minArity": 1,
|
|
2251
|
+
"maxArity": 1,
|
|
2252
|
+
"returnType": "number[]",
|
|
2253
|
+
"description": "Get tensor shape as array",
|
|
2254
|
+
"module": "tensor"
|
|
2255
|
+
},
|
|
2256
|
+
"tensor/slice": {
|
|
2257
|
+
"category": "ml-tensor",
|
|
2258
|
+
"minArity": 3,
|
|
2259
|
+
"maxArity": 3,
|
|
2260
|
+
"returnType": "tensor",
|
|
2261
|
+
"description": "Get slice of tensor",
|
|
2262
|
+
"module": "tensor"
|
|
2263
|
+
},
|
|
2264
|
+
"tensor/sub": {
|
|
2265
|
+
"category": "ml-tensor",
|
|
2266
|
+
"minArity": 2,
|
|
2267
|
+
"maxArity": 2,
|
|
2268
|
+
"returnType": "tensor",
|
|
2269
|
+
"description": "Element-wise subtraction",
|
|
2270
|
+
"module": "tensor"
|
|
2271
|
+
},
|
|
2272
|
+
"tensor/sum": {
|
|
2273
|
+
"category": "ml-tensor",
|
|
2274
|
+
"minArity": 1,
|
|
2275
|
+
"maxArity": 2,
|
|
2276
|
+
"returnType": "number | tensor",
|
|
2277
|
+
"description": "Sum of tensor elements",
|
|
2278
|
+
"module": "tensor"
|
|
2279
|
+
},
|
|
2280
|
+
"tensor/toArray": {
|
|
2281
|
+
"category": "ml-tensor",
|
|
2282
|
+
"minArity": 1,
|
|
2283
|
+
"maxArity": 1,
|
|
2284
|
+
"returnType": "array",
|
|
2285
|
+
"description": "Convert tensor to nested array",
|
|
2286
|
+
"module": "tensor"
|
|
2287
|
+
},
|
|
2288
|
+
"tensor/toList": {
|
|
2289
|
+
"category": "ml-tensor",
|
|
2290
|
+
"minArity": 1,
|
|
2291
|
+
"maxArity": 1,
|
|
2292
|
+
"returnType": "number[]",
|
|
2293
|
+
"description": "Convert 1D tensor to flat array",
|
|
2294
|
+
"module": "tensor"
|
|
2295
|
+
},
|
|
2296
|
+
"tensor/zeros": {
|
|
2297
|
+
"category": "ml-tensor",
|
|
2298
|
+
"minArity": 1,
|
|
2299
|
+
"maxArity": 1,
|
|
2300
|
+
"returnType": "tensor",
|
|
2301
|
+
"description": "Create tensor filled with zeros",
|
|
2302
|
+
"module": "tensor"
|
|
2303
|
+
},
|
|
2304
|
+
"time/add": {
|
|
2305
|
+
"category": "std-time",
|
|
2306
|
+
"minArity": 3,
|
|
2307
|
+
"maxArity": 3,
|
|
2308
|
+
"returnType": "number",
|
|
2309
|
+
"description": "Add time to timestamp",
|
|
2310
|
+
"module": "time"
|
|
2311
|
+
},
|
|
2312
|
+
"time/day": {
|
|
2313
|
+
"category": "std-time",
|
|
2314
|
+
"minArity": 1,
|
|
2315
|
+
"maxArity": 1,
|
|
2316
|
+
"returnType": "number",
|
|
2317
|
+
"description": "Get day of month from timestamp (1-31)",
|
|
2318
|
+
"module": "time"
|
|
2319
|
+
},
|
|
2320
|
+
"time/diff": {
|
|
2321
|
+
"category": "std-time",
|
|
2322
|
+
"minArity": 2,
|
|
2323
|
+
"maxArity": 3,
|
|
2324
|
+
"returnType": "number",
|
|
2325
|
+
"description": "Difference between timestamps",
|
|
2326
|
+
"module": "time"
|
|
2327
|
+
},
|
|
2328
|
+
"time/duration": {
|
|
2329
|
+
"category": "std-time",
|
|
2330
|
+
"minArity": 1,
|
|
2331
|
+
"maxArity": 1,
|
|
2332
|
+
"returnType": "string",
|
|
2333
|
+
"description": "Format milliseconds as duration (\"2h 30m\")",
|
|
2334
|
+
"module": "time"
|
|
2335
|
+
},
|
|
2336
|
+
"time/endOf": {
|
|
2337
|
+
"category": "std-time",
|
|
2338
|
+
"minArity": 2,
|
|
2339
|
+
"maxArity": 2,
|
|
2340
|
+
"returnType": "number",
|
|
2341
|
+
"description": "Get end of time period",
|
|
2342
|
+
"module": "time"
|
|
2343
|
+
},
|
|
2344
|
+
"time/format": {
|
|
2345
|
+
"category": "std-time",
|
|
2346
|
+
"minArity": 2,
|
|
2347
|
+
"maxArity": 2,
|
|
2348
|
+
"returnType": "string",
|
|
2349
|
+
"description": "Format timestamp to string",
|
|
2350
|
+
"module": "time"
|
|
2351
|
+
},
|
|
2352
|
+
"time/hour": {
|
|
2353
|
+
"category": "std-time",
|
|
2354
|
+
"minArity": 1,
|
|
2355
|
+
"maxArity": 1,
|
|
2356
|
+
"returnType": "number",
|
|
2357
|
+
"description": "Get hour from timestamp (0-23)",
|
|
2358
|
+
"module": "time"
|
|
2359
|
+
},
|
|
2360
|
+
"time/isAfter": {
|
|
2361
|
+
"category": "std-time",
|
|
2362
|
+
"minArity": 2,
|
|
2363
|
+
"maxArity": 2,
|
|
2364
|
+
"returnType": "boolean",
|
|
2365
|
+
"description": "Check if a is after b",
|
|
2366
|
+
"module": "time"
|
|
2367
|
+
},
|
|
2368
|
+
"time/isBefore": {
|
|
2369
|
+
"category": "std-time",
|
|
2370
|
+
"minArity": 2,
|
|
2371
|
+
"maxArity": 2,
|
|
2372
|
+
"returnType": "boolean",
|
|
2373
|
+
"description": "Check if a is before b",
|
|
2374
|
+
"module": "time"
|
|
2375
|
+
},
|
|
2376
|
+
"time/isBetween": {
|
|
2377
|
+
"category": "std-time",
|
|
2378
|
+
"minArity": 3,
|
|
2379
|
+
"maxArity": 3,
|
|
2380
|
+
"returnType": "boolean",
|
|
2381
|
+
"description": "Check if date is between start and end",
|
|
2382
|
+
"module": "time"
|
|
2383
|
+
},
|
|
2384
|
+
"time/isFuture": {
|
|
2385
|
+
"category": "std-time",
|
|
2386
|
+
"minArity": 1,
|
|
2387
|
+
"maxArity": 1,
|
|
2388
|
+
"returnType": "boolean",
|
|
2389
|
+
"description": "Check if timestamp is in the future",
|
|
2390
|
+
"module": "time"
|
|
2391
|
+
},
|
|
2392
|
+
"time/isPast": {
|
|
2393
|
+
"category": "std-time",
|
|
2394
|
+
"minArity": 1,
|
|
2395
|
+
"maxArity": 1,
|
|
2396
|
+
"returnType": "boolean",
|
|
2397
|
+
"description": "Check if timestamp is in the past",
|
|
2398
|
+
"module": "time"
|
|
2399
|
+
},
|
|
2400
|
+
"time/isSame": {
|
|
2401
|
+
"category": "std-time",
|
|
2402
|
+
"minArity": 2,
|
|
2403
|
+
"maxArity": 3,
|
|
2404
|
+
"returnType": "boolean",
|
|
2405
|
+
"description": "Check if timestamps are same (optionally by unit)",
|
|
2406
|
+
"module": "time"
|
|
2407
|
+
},
|
|
2408
|
+
"time/isToday": {
|
|
2409
|
+
"category": "std-time",
|
|
2410
|
+
"minArity": 1,
|
|
2411
|
+
"maxArity": 1,
|
|
2412
|
+
"returnType": "boolean",
|
|
2413
|
+
"description": "Check if timestamp is today",
|
|
2414
|
+
"module": "time"
|
|
2415
|
+
},
|
|
2416
|
+
"time/minute": {
|
|
2417
|
+
"category": "std-time",
|
|
2418
|
+
"minArity": 1,
|
|
2419
|
+
"maxArity": 1,
|
|
2420
|
+
"returnType": "number",
|
|
2421
|
+
"description": "Get minute from timestamp (0-59)",
|
|
2422
|
+
"module": "time"
|
|
2423
|
+
},
|
|
2424
|
+
"time/month": {
|
|
2425
|
+
"category": "std-time",
|
|
2426
|
+
"minArity": 1,
|
|
2427
|
+
"maxArity": 1,
|
|
2428
|
+
"returnType": "number",
|
|
2429
|
+
"description": "Get month from timestamp (1-12)",
|
|
2430
|
+
"module": "time"
|
|
2431
|
+
},
|
|
2432
|
+
"time/now": {
|
|
2433
|
+
"category": "std-time",
|
|
2434
|
+
"minArity": 0,
|
|
2435
|
+
"maxArity": 0,
|
|
2436
|
+
"returnType": "number",
|
|
2437
|
+
"description": "Current timestamp",
|
|
2438
|
+
"module": "time"
|
|
2439
|
+
},
|
|
2440
|
+
"time/parse": {
|
|
2441
|
+
"category": "std-time",
|
|
2442
|
+
"minArity": 1,
|
|
2443
|
+
"maxArity": 2,
|
|
2444
|
+
"returnType": "number",
|
|
2445
|
+
"description": "Parse string to timestamp",
|
|
2446
|
+
"module": "time"
|
|
2447
|
+
},
|
|
2448
|
+
"time/relative": {
|
|
2449
|
+
"category": "std-time",
|
|
2450
|
+
"minArity": 1,
|
|
2451
|
+
"maxArity": 1,
|
|
2452
|
+
"returnType": "string",
|
|
2453
|
+
"description": "Format as relative time (\"2 hours ago\", \"in 3 days\")",
|
|
2454
|
+
"module": "time"
|
|
2455
|
+
},
|
|
2456
|
+
"time/second": {
|
|
2457
|
+
"category": "std-time",
|
|
2458
|
+
"minArity": 1,
|
|
2459
|
+
"maxArity": 1,
|
|
2460
|
+
"returnType": "number",
|
|
2461
|
+
"description": "Get second from timestamp (0-59)",
|
|
2462
|
+
"module": "time"
|
|
2463
|
+
},
|
|
2464
|
+
"time/startOf": {
|
|
2465
|
+
"category": "std-time",
|
|
2466
|
+
"minArity": 2,
|
|
2467
|
+
"maxArity": 2,
|
|
2468
|
+
"returnType": "number",
|
|
2469
|
+
"description": "Get start of time period",
|
|
2470
|
+
"module": "time"
|
|
2471
|
+
},
|
|
2472
|
+
"time/subtract": {
|
|
2473
|
+
"category": "std-time",
|
|
2474
|
+
"minArity": 3,
|
|
2475
|
+
"maxArity": 3,
|
|
2476
|
+
"returnType": "number",
|
|
2477
|
+
"description": "Subtract time from timestamp",
|
|
2478
|
+
"module": "time"
|
|
2479
|
+
},
|
|
2480
|
+
"time/today": {
|
|
2481
|
+
"category": "std-time",
|
|
2482
|
+
"minArity": 0,
|
|
2483
|
+
"maxArity": 0,
|
|
2484
|
+
"returnType": "number",
|
|
2485
|
+
"description": "Today at midnight (local time)",
|
|
2486
|
+
"module": "time"
|
|
2487
|
+
},
|
|
2488
|
+
"time/weekday": {
|
|
2489
|
+
"category": "std-time",
|
|
2490
|
+
"minArity": 1,
|
|
2491
|
+
"maxArity": 1,
|
|
2492
|
+
"returnType": "number",
|
|
2493
|
+
"description": "Get day of week (0=Sunday, 6=Saturday)",
|
|
2494
|
+
"module": "time"
|
|
2495
|
+
},
|
|
2496
|
+
"time/year": {
|
|
2497
|
+
"category": "std-time",
|
|
2498
|
+
"minArity": 1,
|
|
2499
|
+
"maxArity": 1,
|
|
2500
|
+
"returnType": "number",
|
|
2501
|
+
"description": "Get year from timestamp",
|
|
2502
|
+
"module": "time"
|
|
2503
|
+
},
|
|
2504
|
+
"train/adam": {
|
|
2505
|
+
"category": "ml-effect",
|
|
2506
|
+
"minArity": 2,
|
|
2507
|
+
"maxArity": 4,
|
|
2508
|
+
"returnType": "void",
|
|
2509
|
+
"description": "Adam optimizer step",
|
|
2510
|
+
"module": "train",
|
|
2511
|
+
"hasSideEffects": true
|
|
2512
|
+
},
|
|
2513
|
+
"train/checkConstraints": {
|
|
2514
|
+
"category": "ml-effect",
|
|
2515
|
+
"minArity": 2,
|
|
2516
|
+
"maxArity": 2,
|
|
2517
|
+
"returnType": "train/constraintResult",
|
|
2518
|
+
"description": "Check if network weights satisfy all constraints",
|
|
2519
|
+
"module": "train"
|
|
2520
|
+
},
|
|
2521
|
+
"train/checkForbiddenOutputs": {
|
|
2522
|
+
"category": "ml-effect",
|
|
2523
|
+
"minArity": 3,
|
|
2524
|
+
"maxArity": 3,
|
|
2525
|
+
"returnType": "train/forbiddenResult",
|
|
2526
|
+
"description": "Check if model produces outputs in forbidden regions",
|
|
2527
|
+
"module": "train"
|
|
2528
|
+
},
|
|
2529
|
+
"train/checkRegression": {
|
|
2530
|
+
"category": "ml-effect",
|
|
2531
|
+
"minArity": 3,
|
|
2532
|
+
"maxArity": 3,
|
|
2533
|
+
"returnType": "train/regressionResult",
|
|
2534
|
+
"description": "Check if new model regresses on required invariants",
|
|
2535
|
+
"module": "train"
|
|
2536
|
+
},
|
|
2537
|
+
"train/checkWeightMagnitude": {
|
|
2538
|
+
"category": "ml-effect",
|
|
2539
|
+
"minArity": 2,
|
|
2540
|
+
"maxArity": 2,
|
|
2541
|
+
"returnType": "boolean",
|
|
2542
|
+
"description": "Check if all weights are within magnitude limit",
|
|
2543
|
+
"module": "train"
|
|
2544
|
+
},
|
|
2545
|
+
"train/clipGradients": {
|
|
2546
|
+
"category": "ml-effect",
|
|
2547
|
+
"minArity": 2,
|
|
2548
|
+
"maxArity": 2,
|
|
2549
|
+
"returnType": "number",
|
|
2550
|
+
"description": "Clip gradients to max norm (modifies in place)",
|
|
2551
|
+
"module": "train",
|
|
2552
|
+
"hasSideEffects": true
|
|
2553
|
+
},
|
|
2554
|
+
"train/clipWeights": {
|
|
2555
|
+
"category": "ml-effect",
|
|
2556
|
+
"minArity": 2,
|
|
2557
|
+
"maxArity": 2,
|
|
2558
|
+
"returnType": "void",
|
|
2559
|
+
"description": "Clip weights to max magnitude (modifies in place)",
|
|
2560
|
+
"module": "train",
|
|
2561
|
+
"hasSideEffects": true
|
|
2562
|
+
},
|
|
2563
|
+
"train/computeAdvantages": {
|
|
2564
|
+
"category": "ml-effect",
|
|
2565
|
+
"minArity": 3,
|
|
2566
|
+
"maxArity": 3,
|
|
2567
|
+
"returnType": "tensor",
|
|
2568
|
+
"description": "Compute GAE advantages for policy gradient",
|
|
2569
|
+
"module": "train"
|
|
2570
|
+
},
|
|
2571
|
+
"train/computeReturns": {
|
|
2572
|
+
"category": "ml-effect",
|
|
2573
|
+
"minArity": 2,
|
|
2574
|
+
"maxArity": 2,
|
|
2575
|
+
"returnType": "tensor",
|
|
2576
|
+
"description": "Compute discounted returns from rewards",
|
|
2577
|
+
"module": "train"
|
|
2578
|
+
},
|
|
2579
|
+
"train/crossEntropy": {
|
|
2580
|
+
"category": "ml-effect",
|
|
2581
|
+
"minArity": 2,
|
|
2582
|
+
"maxArity": 2,
|
|
2583
|
+
"returnType": "number",
|
|
2584
|
+
"description": "Cross-entropy loss for classification",
|
|
2585
|
+
"module": "train"
|
|
2586
|
+
},
|
|
2587
|
+
"train/getGradientNorm": {
|
|
2588
|
+
"category": "ml-effect",
|
|
2589
|
+
"minArity": 1,
|
|
2590
|
+
"maxArity": 1,
|
|
2591
|
+
"returnType": "number",
|
|
2592
|
+
"description": "Get current gradient norm",
|
|
2593
|
+
"module": "train"
|
|
2594
|
+
},
|
|
2595
|
+
"train/getMaxWeightMagnitude": {
|
|
2596
|
+
"category": "ml-effect",
|
|
2597
|
+
"minArity": 1,
|
|
2598
|
+
"maxArity": 1,
|
|
2599
|
+
"returnType": "number",
|
|
2600
|
+
"description": "Get maximum weight magnitude in network",
|
|
2601
|
+
"module": "train"
|
|
2602
|
+
},
|
|
2603
|
+
"train/huber": {
|
|
2604
|
+
"category": "ml-effect",
|
|
2605
|
+
"minArity": 2,
|
|
2606
|
+
"maxArity": 3,
|
|
2607
|
+
"returnType": "number",
|
|
2608
|
+
"description": "Huber loss (smooth L1, robust to outliers)",
|
|
2609
|
+
"module": "train"
|
|
2610
|
+
},
|
|
2611
|
+
"train/loop": {
|
|
2612
|
+
"category": "ml-effect",
|
|
2613
|
+
"minArity": 3,
|
|
2614
|
+
"maxArity": 3,
|
|
2615
|
+
"returnType": "train/result",
|
|
2616
|
+
"description": "Execute training loop with constraints",
|
|
2617
|
+
"module": "train",
|
|
2618
|
+
"hasSideEffects": true
|
|
2619
|
+
},
|
|
2620
|
+
"train/mse": {
|
|
2621
|
+
"category": "ml-effect",
|
|
2622
|
+
"minArity": 2,
|
|
2623
|
+
"maxArity": 2,
|
|
2624
|
+
"returnType": "number",
|
|
2625
|
+
"description": "Mean squared error loss",
|
|
2626
|
+
"module": "train"
|
|
2627
|
+
},
|
|
2628
|
+
"train/sampleBatch": {
|
|
2629
|
+
"category": "ml-effect",
|
|
2630
|
+
"minArity": 2,
|
|
2631
|
+
"maxArity": 2,
|
|
2632
|
+
"returnType": "array",
|
|
2633
|
+
"description": "Sample random batch from experience buffer",
|
|
2634
|
+
"module": "train"
|
|
2635
|
+
},
|
|
2636
|
+
"train/sgd": {
|
|
2637
|
+
"category": "ml-effect",
|
|
2638
|
+
"minArity": 2,
|
|
2639
|
+
"maxArity": 3,
|
|
2640
|
+
"returnType": "void",
|
|
2641
|
+
"description": "Stochastic gradient descent optimizer step",
|
|
2642
|
+
"module": "train",
|
|
2643
|
+
"hasSideEffects": true
|
|
2644
|
+
},
|
|
2645
|
+
"train/step": {
|
|
2646
|
+
"category": "ml-effect",
|
|
2647
|
+
"minArity": 4,
|
|
2648
|
+
"maxArity": 4,
|
|
2649
|
+
"returnType": "train/stepResult",
|
|
2650
|
+
"description": "Execute single training step (forward, loss, backward, update)",
|
|
2651
|
+
"module": "train",
|
|
2652
|
+
"hasSideEffects": true
|
|
2653
|
+
},
|
|
2654
|
+
"train/validate": {
|
|
2655
|
+
"category": "ml-effect",
|
|
2656
|
+
"minArity": 2,
|
|
2657
|
+
"maxArity": 2,
|
|
2658
|
+
"returnType": "train/validationResult",
|
|
2659
|
+
"description": "Validate model on test cases, returns pass/fail metrics",
|
|
2660
|
+
"module": "train"
|
|
2661
|
+
},
|
|
2662
|
+
"validate/array": {
|
|
2663
|
+
"category": "std-validate",
|
|
2664
|
+
"minArity": 1,
|
|
2665
|
+
"maxArity": 1,
|
|
2666
|
+
"returnType": "boolean",
|
|
2667
|
+
"description": "Check if value is an array",
|
|
2668
|
+
"module": "validate"
|
|
2669
|
+
},
|
|
2670
|
+
"validate/boolean": {
|
|
2671
|
+
"category": "std-validate",
|
|
2672
|
+
"minArity": 1,
|
|
2673
|
+
"maxArity": 1,
|
|
2674
|
+
"returnType": "boolean",
|
|
2675
|
+
"description": "Check if value is a boolean",
|
|
2676
|
+
"module": "validate"
|
|
2677
|
+
},
|
|
2678
|
+
"validate/check": {
|
|
2679
|
+
"category": "std-validate",
|
|
2680
|
+
"minArity": 2,
|
|
2681
|
+
"maxArity": 2,
|
|
2682
|
+
"returnType": "any",
|
|
2683
|
+
"description": "Run multiple validation rules, return { valid, errors }",
|
|
2684
|
+
"module": "validate"
|
|
2685
|
+
},
|
|
2686
|
+
"validate/creditCard": {
|
|
2687
|
+
"category": "std-validate",
|
|
2688
|
+
"minArity": 1,
|
|
2689
|
+
"maxArity": 1,
|
|
2690
|
+
"returnType": "boolean",
|
|
2691
|
+
"description": "Check if value is a valid credit card number (Luhn algorithm)",
|
|
2692
|
+
"module": "validate"
|
|
2693
|
+
},
|
|
2694
|
+
"validate/date": {
|
|
2695
|
+
"category": "std-validate",
|
|
2696
|
+
"minArity": 1,
|
|
2697
|
+
"maxArity": 1,
|
|
2698
|
+
"returnType": "boolean",
|
|
2699
|
+
"description": "Check if value is a valid date",
|
|
2700
|
+
"module": "validate"
|
|
2701
|
+
},
|
|
2702
|
+
"validate/email": {
|
|
2703
|
+
"category": "std-validate",
|
|
2704
|
+
"minArity": 1,
|
|
2705
|
+
"maxArity": 1,
|
|
2706
|
+
"returnType": "boolean",
|
|
2707
|
+
"description": "Check if value is a valid email format",
|
|
2708
|
+
"module": "validate"
|
|
2709
|
+
},
|
|
2710
|
+
"validate/equals": {
|
|
2711
|
+
"category": "std-validate",
|
|
2712
|
+
"minArity": 2,
|
|
2713
|
+
"maxArity": 2,
|
|
2714
|
+
"returnType": "boolean",
|
|
2715
|
+
"description": "Deep equality check",
|
|
2716
|
+
"module": "validate"
|
|
2717
|
+
},
|
|
2718
|
+
"validate/length": {
|
|
2719
|
+
"category": "std-validate",
|
|
2720
|
+
"minArity": 2,
|
|
2721
|
+
"maxArity": 2,
|
|
2722
|
+
"returnType": "boolean",
|
|
2723
|
+
"description": "Check if string/array has exact length",
|
|
2724
|
+
"module": "validate"
|
|
2725
|
+
},
|
|
2726
|
+
"validate/max": {
|
|
2727
|
+
"category": "std-validate",
|
|
2728
|
+
"minArity": 2,
|
|
2729
|
+
"maxArity": 2,
|
|
2730
|
+
"returnType": "boolean",
|
|
2731
|
+
"description": "Check if number is <= maximum",
|
|
2732
|
+
"module": "validate"
|
|
2733
|
+
},
|
|
2734
|
+
"validate/maxLength": {
|
|
2735
|
+
"category": "std-validate",
|
|
2736
|
+
"minArity": 2,
|
|
2737
|
+
"maxArity": 2,
|
|
2738
|
+
"returnType": "boolean",
|
|
2739
|
+
"description": "Check if string/array has maximum length",
|
|
2740
|
+
"module": "validate"
|
|
2741
|
+
},
|
|
2742
|
+
"validate/min": {
|
|
2743
|
+
"category": "std-validate",
|
|
2744
|
+
"minArity": 2,
|
|
2745
|
+
"maxArity": 2,
|
|
2746
|
+
"returnType": "boolean",
|
|
2747
|
+
"description": "Check if number is >= minimum",
|
|
2748
|
+
"module": "validate"
|
|
2749
|
+
},
|
|
2750
|
+
"validate/minLength": {
|
|
2751
|
+
"category": "std-validate",
|
|
2752
|
+
"minArity": 2,
|
|
2753
|
+
"maxArity": 2,
|
|
2754
|
+
"returnType": "boolean",
|
|
2755
|
+
"description": "Check if string/array has minimum length",
|
|
2756
|
+
"module": "validate"
|
|
2757
|
+
},
|
|
2758
|
+
"validate/noneOf": {
|
|
2759
|
+
"category": "std-validate",
|
|
2760
|
+
"minArity": 2,
|
|
2761
|
+
"maxArity": 2,
|
|
2762
|
+
"returnType": "boolean",
|
|
2763
|
+
"description": "Check if value is not in list of disallowed values",
|
|
2764
|
+
"module": "validate"
|
|
2765
|
+
},
|
|
2766
|
+
"validate/number": {
|
|
2767
|
+
"category": "std-validate",
|
|
2768
|
+
"minArity": 1,
|
|
2769
|
+
"maxArity": 1,
|
|
2770
|
+
"returnType": "boolean",
|
|
2771
|
+
"description": "Check if value is a number",
|
|
2772
|
+
"module": "validate"
|
|
2773
|
+
},
|
|
2774
|
+
"validate/object": {
|
|
2775
|
+
"category": "std-validate",
|
|
2776
|
+
"minArity": 1,
|
|
2777
|
+
"maxArity": 1,
|
|
2778
|
+
"returnType": "boolean",
|
|
2779
|
+
"description": "Check if value is an object",
|
|
2780
|
+
"module": "validate"
|
|
2781
|
+
},
|
|
2782
|
+
"validate/oneOf": {
|
|
2783
|
+
"category": "std-validate",
|
|
2784
|
+
"minArity": 2,
|
|
2785
|
+
"maxArity": 2,
|
|
2786
|
+
"returnType": "boolean",
|
|
2787
|
+
"description": "Check if value is in list of allowed values",
|
|
2788
|
+
"module": "validate"
|
|
2789
|
+
},
|
|
2790
|
+
"validate/pattern": {
|
|
2791
|
+
"category": "std-validate",
|
|
2792
|
+
"minArity": 2,
|
|
2793
|
+
"maxArity": 2,
|
|
2794
|
+
"returnType": "boolean",
|
|
2795
|
+
"description": "Check if string matches regex pattern",
|
|
2796
|
+
"module": "validate"
|
|
2797
|
+
},
|
|
2798
|
+
"validate/phone": {
|
|
2799
|
+
"category": "std-validate",
|
|
2800
|
+
"minArity": 1,
|
|
2801
|
+
"maxArity": 1,
|
|
2802
|
+
"returnType": "boolean",
|
|
2803
|
+
"description": "Check if value is a valid phone number",
|
|
2804
|
+
"module": "validate"
|
|
2805
|
+
},
|
|
2806
|
+
"validate/range": {
|
|
2807
|
+
"category": "std-validate",
|
|
2808
|
+
"minArity": 3,
|
|
2809
|
+
"maxArity": 3,
|
|
2810
|
+
"returnType": "boolean",
|
|
2811
|
+
"description": "Check if number is within range [min, max]",
|
|
2812
|
+
"module": "validate"
|
|
2813
|
+
},
|
|
2814
|
+
"validate/required": {
|
|
2815
|
+
"category": "std-validate",
|
|
2816
|
+
"minArity": 1,
|
|
2817
|
+
"maxArity": 1,
|
|
2818
|
+
"returnType": "boolean",
|
|
2819
|
+
"description": "Check if value is not null, undefined, or empty string",
|
|
2820
|
+
"module": "validate"
|
|
2821
|
+
},
|
|
2822
|
+
"validate/string": {
|
|
2823
|
+
"category": "std-validate",
|
|
2824
|
+
"minArity": 1,
|
|
2825
|
+
"maxArity": 1,
|
|
2826
|
+
"returnType": "boolean",
|
|
2827
|
+
"description": "Check if value is a string",
|
|
2828
|
+
"module": "validate"
|
|
2829
|
+
},
|
|
2830
|
+
"validate/url": {
|
|
2831
|
+
"category": "std-validate",
|
|
2832
|
+
"minArity": 1,
|
|
2833
|
+
"maxArity": 1,
|
|
2834
|
+
"returnType": "boolean",
|
|
2835
|
+
"description": "Check if value is a valid URL format",
|
|
2836
|
+
"module": "validate"
|
|
2837
|
+
},
|
|
2838
|
+
"validate/uuid": {
|
|
2839
|
+
"category": "std-validate",
|
|
2840
|
+
"minArity": 1,
|
|
2841
|
+
"maxArity": 1,
|
|
2842
|
+
"returnType": "boolean",
|
|
2843
|
+
"description": "Check if value is a valid UUID",
|
|
2844
|
+
"module": "validate"
|
|
2845
|
+
},
|
|
2846
|
+
"when": {
|
|
2847
|
+
"category": "control",
|
|
2848
|
+
"minArity": 2,
|
|
2849
|
+
"maxArity": 2,
|
|
2850
|
+
"returnType": "void",
|
|
2851
|
+
"description": "Conditional effect without an else branch",
|
|
2852
|
+
"module": "core"
|
|
2853
|
+
}
|
|
2854
|
+
}
|
|
2855
|
+
}
|