@almadar/std 6.4.1 → 6.5.1

package/dist/{types-hu1LavLs.d.ts → types-D7dG8fBF.d.ts}

@@ -11,6 +11,10 @@
  */
 declare const OPERATOR_CATEGORIES: readonly ["arithmetic", "comparison", "logic", "control", "effect", "collection", "std-math", "std-str", "std-array", "std-object", "std-validate", "std-time", "std-format", "std-async", "std-nn", "std-tensor", "std-train", "std-prob", "std-os", "std-agent", "std-composition", "ml-arch", "ml-effect", "ml-tensor", "ml-graph", "ml-contract", "ml-data"];
 type OperatorCategory = (typeof OPERATOR_CATEGORIES)[number];
+/**
+ * Basic return types for core operators.
+ */
+type BasicReturnType = 'number' | 'boolean' | 'string' | 'any' | 'void' | 'array';
 /**
  * Base metadata for an operator.
  */
@@ -33,7 +37,7 @@ interface OperatorMeta {
  * Each module provides a set of operators prefixed with the module name.
  * E.g., 'math' provides 'math/abs', 'math/clamp', etc.
  */
-declare const STD_MODULES: readonly ["math", "str", "array", "object", "time", "validate", "format", "async", "nn", "tensor", "train", "prob", "os", "agent", "graph", "contract", "data", "composition"];
+declare const STD_MODULES: readonly ["core", "math", "str", "array", "object", "time", "validate", "format", "async", "nn", "tensor", "train", "prob", "os", "agent", "graph", "contract", "data", "composition"];
 type StdModule = (typeof STD_MODULES)[number];
 /**
  * Standard library operator categories.
@@ -41,6 +45,59 @@ type StdModule = (typeof STD_MODULES)[number];
  */
 declare const STD_OPERATOR_CATEGORIES: readonly ["std-math", "std-str", "std-array", "std-object", "std-time", "std-validate", "std-format", "std-async", "std-nn", "std-tensor", "std-train", "std-prob", "std-os", "std-agent", "std-composition", "ml-arch", "ml-effect", "ml-tensor", "ml-graph", "ml-contract", "ml-data"];
 type StdOperatorCategory = (typeof STD_OPERATOR_CATEGORIES)[number];
+/**
+ * Structured parameter type reference (Schema v2).
+ *
+ * A plain string (e.g. `'number'`, `'string'`) is still accepted for
+ * backward compatibility with simple primitives. Richer shapes let effect
+ * operators declare literal unions, UI slots, event keys, and entity refs
+ * so compilers, LLM prompt generators, and validators can reason about the
+ * argument shape without string heuristics.
+ */
+type OperatorTypeRef = string | {
+    kind: 'union';
+    of: OperatorTypeRef[];
+} | {
+    kind: 'literal';
+    value: string | number | boolean;
+} | {
+    kind: 'array';
+    of: OperatorTypeRef;
+} | {
+    kind: 'object';
+    fields: Record<string, OperatorTypeRef>;
+    open?: boolean;
+} | {
+    kind: 'entity';
+    collection?: string;
+} | {
+    kind: 'entityRef';
+} | {
+    kind: 'eventKey';
+    scope?: 'internal' | 'external';
+} | {
+    kind: 'uiSlot';
+} | {
+    kind: 'patternType';
+} | {
+    kind: 'binding';
+    shape?: OperatorTypeRef;
+} | {
+    kind: 'sexpr';
+};
+/**
+ * Effect-specific metadata (Schema v2).
+ * Populated only when `hasSideEffects: true`. Describes what the effect
+ * produces back onto the runtime bus or state tree so consumers (Rust
+ * validator, LLM skill gen, verify) can trace downstream reactions.
+ */
+interface OperatorEffectMeta {
+    kind: 'emit' | 'persist' | 'fetch' | 'ref' | 'render-ui' | 'navigate' | 'notify' | 'spawn' | 'despawn' | 'set' | 'call-service' | 'log' | 'custom';
+    /** What the effect puts onto the bus / state when it resolves. */
+    produces?: OperatorTypeRef;
+    /** Effect-specific config keys and their declared types. */
+    config?: Record<string, OperatorTypeRef>;
+}
 /**
  * Extended operator metadata for std library operators.
  * Adds parameter descriptions and examples.
@@ -51,7 +108,7 @@ interface StdOperatorMeta extends OperatorMeta {
     /** Parameter names and descriptions */
     params?: {
         name: string;
-        type: string;
+        type: OperatorTypeRef;
         description: string;
         optional?: boolean;
         defaultValue?: unknown;
@@ -64,6 +121,8 @@ interface StdOperatorMeta extends OperatorMeta {
     lambdaArgPosition?: number;
     /** Compile-time operator (resolved during .lolo lowering, not at runtime) */
     compileTime?: boolean;
+    /** Schema v2: structured metadata for effect operators */
+    effect?: OperatorEffectMeta;
 }
 /**
  * Type guard to check if an operator category is a std category.
@@ -90,4 +149,4 @@ declare function isStdOperator(operator: string): boolean;
  */
 declare function makeStdOperator(module: StdModule, fn: string): string;
 
-export { type StdOperatorMeta as S, type StdModule as a, STD_MODULES as b, STD_OPERATOR_CATEGORIES as c, type StdOperatorCategory as d, getModuleFromOperator as e, isStdOperator as f, getFunctionFromOperator as g, isStdCategory as i, makeStdOperator as m };
+export { type BasicReturnType as B, type OperatorMeta as O, type StdOperatorMeta as S, type StdModule as a, OPERATOR_CATEGORIES as b, type OperatorCategory as c, type OperatorEffectMeta as d, type OperatorTypeRef as e, STD_MODULES as f, STD_OPERATOR_CATEGORIES as g, type StdOperatorCategory as h, getFunctionFromOperator as i, getModuleFromOperator as j, isStdCategory as k, isStdOperator as l, makeStdOperator as m };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/std",
-  "version": "6.4.1",
+  "version": "6.5.1",
   "description": "Standard library operators for Almadar (math, string, array, etc.)",
   "type": "module",
   "main": "./dist/index.js",
@@ -41,8 +41,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@almadar/core": ">=4.8.2",
-    "@almadar/operators": ">=3.0.0"
+    "@almadar/core": ">=4.8.2"
   },
   "devDependencies": {
     "@almadar/eslint-plugin": ">=2.3.0",