@rcrsr/rill 0.16.0 → 0.18.0

package/README.md

@@ -13,24 +13,34 @@ npm install @rcrsr/rill
 ## Quick Start
 
 ```typescript
-import { parse, execute, createRuntimeContext } from '@rcrsr/rill';
+import { parse, execute, createRuntimeContext, toCallable } from '@rcrsr/rill';
+import type { ExtensionFactoryResult } from '@rcrsr/rill';
+
+function createMyExtension(): ExtensionFactoryResult {
+  return {
+    value: {
+      prompt: toCallable({
+        params: [{ name: 'message', type: { kind: 'string' } }],
+        fn: async (args) => await callYourLLM(args.message),
+        annotations: { description: 'Call your LLM' },
+        returnType: { kind: 'string' },
+      }),
+    },
+  };
+}
+
+const ext = createMyExtension();
+const ctx = createRuntimeContext({
+  variables: { app: ext.value },
+});
 
 const script = `
-  prompt("Analyze this code for issues")
+  app.prompt("Analyze this code for issues")
     -> .contains("ERROR") ? error($) ! "Analysis complete"
 `;
 
-const ctx = createRuntimeContext({
-  functions: {
-    prompt: {
-      params: [{ name: 'message', type: 'string' }],
-      fn: async (args) => await callYourLLM(args[0]),
-    },
-  },
-});
-
 const result = await execute(parse(script), ctx);
-console.log(result.value);
+console.log(result.result);
 ```
 
 ## API
@@ -47,25 +57,31 @@ Source Text → parse() → AST → execute() → Result
 | `execute(ast, ctx)` | Execute an AST with a runtime context |
 | `createRuntimeContext(opts)` | Create a configured runtime context |
 | `callable(fn, isProperty?)` | Wrap a function as a rill-callable value |
-| `prefixFunctions(prefix, fns)` | Namespace host functions (e.g., `app::`) |
+| `toCallable(def)` | Convert a `RillFunction` to an `ApplicationCallable` |
+| `createTestContext(extensions)` | Wire extensions for testing without config infrastructure |
 
 ### Runtime Options
 
 ```typescript
+const ext = createMyExtension();
+
 const ctx = createRuntimeContext({
-  // Host functions available to scripts
+  // Extension values injected as variables (recommended)
+  variables: {
+    app: ext.value,
+    config: { greeting: 'hello' },
+  },
+
+  // Legacy: direct function registration (still supported)
   functions: {
     prompt: {
-      params: [{ name: 'text', type: 'string' }],
+      params: [{ name: 'text', type: { kind: 'string' } }],
       fn: async (args, ctx, location) => { /* ... */ },
+      annotations: {},
+      returnType: { kind: 'string' },
     },
   },
 
-  // Variables injected into script scope
-  variables: {
-    config: { greeting: 'hello' },
-  },
-
   // Callbacks
   callbacks: {
     onLog: (value) => console.log(value),
@@ -159,7 +175,7 @@ import { createCryptoExtension } from '@rcrsr/rill/ext/crypto';
 | `@rcrsr/rill/ext/kv` | `createKvExtension(config)` | Key-value store with JSON persistence and schema validation |
 | `@rcrsr/rill/ext/crypto` | `createCryptoExtension(config)` | Cryptographic functions (hash, hmac, uuid, random) |
 
-Each factory returns an `ExtensionResult` with host function definitions ready to integrate into your runtime context.
+Each factory returns an `ExtensionFactoryResult` with a `value` dict of host functions and optional lifecycle hooks (`dispose`, `suspend`, `restore`) ready to integrate into your runtime context.
 
 > **Note:** These extensions require Node.js APIs and are not compatible with browser environments.
 

package/dist/ast-nodes.d.ts

@@ -129,6 +129,15 @@ export interface BreakNode extends BaseNode {
 export interface ReturnNode extends BaseNode {
     readonly type: 'Return';
 }
+/**
+ * Yield: emit value from a stream closure.
+ * Used as chain terminator: $x -> yield
+ * Or bare: yield (implicit $ -> yield)
+ * Only valid inside a closure with :stream(T):R return type annotation.
+ */
+export interface YieldNode extends BaseNode {
+    readonly type: 'Yield';
+}
 /**
  * Pass: pass through pipe value unchanged.
  * Used as chain terminator: $x -> pass
@@ -157,8 +166,8 @@ export interface ErrorNode extends BaseNode {
     readonly message: StringLiteralNode | null;
 }
 export type ExpressionNode = PipeChainNode;
-/** Chain terminator: capture, break, or return */
-export type ChainTerminator = CaptureNode | BreakNode | ReturnNode;
+/** Chain terminator: capture, break, return, or yield */
+export type ChainTerminator = CaptureNode | BreakNode | ReturnNode | YieldNode;
 export interface PipeChainNode extends BaseNode {
     readonly type: 'PipeChain';
     readonly head: ArithHead;
@@ -244,7 +253,7 @@ export interface DictEntryNode extends BaseNode {
  */
 export interface TypeConstructorNode extends BaseNode {
     readonly type: 'TypeConstructor';
-    readonly constructorName: 'list' | 'dict' | 'tuple' | 'ordered';
+    readonly constructorName: 'list' | 'dict' | 'tuple' | 'ordered' | 'stream';
     readonly args: FieldArg[];
 }
 /**
@@ -797,8 +806,9 @@ export interface UseExprNode extends BaseNode {
     readonly closureAnnotation: ReadonlyArray<{
         readonly name: string;
         readonly typeRef: TypeRef;
+        readonly defaultValue?: LiteralNode;
     }> | null;
 }
 export type SimplePrimaryNode = LiteralNode | VariableNode | HostCallNode | MethodCallNode | BlockNode | BinaryExprNode | UnaryExprNode | GroupedExprNode | PostfixExprNode | TypeAssertionNode | TypeCheckNode;
-export type ASTNode = ScriptNode | FrontmatterNode | ClosureNode | ClosureParamNode | StatementNode | CaptureNode | BreakNode | ReturnNode | PassNode | AssertNode | PipeChainNode | PostfixExprNode | MethodCallNode | InvokeNode | AnnotationAccessNode | HostCallNode | HostRefNode | ClosureCallNode | PipeInvokeNode | VariableNode | ConditionalNode | WhileLoopNode | DoWhileLoopNode | BlockNode | StringLiteralNode | InterpolationNode | NumberLiteralNode | BoolLiteralNode | ListSpreadNode | DictNode | DictEntryNode | BinaryExprNode | UnaryExprNode | GroupedExprNode | DestructureNode | DestructPatternNode | SliceNode | TypeAssertionNode | TypeCheckNode | TypeConstructorNode | ClosureSigLiteralNode | AnnotatedStatementNode | AnnotatedExprNode | NamedArgNode | SpreadArgNode | EachExprNode | MapExprNode | FoldExprNode | FilterExprNode | RecoveryErrorNode | ErrorNode | TypeNameExprNode | ListLiteralNode | DictLiteralNode | TupleLiteralNode | OrderedLiteralNode | DestructNode | ConvertNode | UseExprNode;
+export type ASTNode = ScriptNode | FrontmatterNode | ClosureNode | ClosureParamNode | StatementNode | CaptureNode | BreakNode | ReturnNode | YieldNode | PassNode | AssertNode | PipeChainNode | PostfixExprNode | MethodCallNode | InvokeNode | AnnotationAccessNode | HostCallNode | HostRefNode | ClosureCallNode | PipeInvokeNode | VariableNode | ConditionalNode | WhileLoopNode | DoWhileLoopNode | BlockNode | StringLiteralNode | InterpolationNode | NumberLiteralNode | BoolLiteralNode | ListSpreadNode | DictNode | DictEntryNode | BinaryExprNode | UnaryExprNode | GroupedExprNode | DestructureNode | DestructPatternNode | SliceNode | TypeAssertionNode | TypeCheckNode | TypeConstructorNode | ClosureSigLiteralNode | AnnotatedStatementNode | AnnotatedExprNode | NamedArgNode | SpreadArgNode | EachExprNode | MapExprNode | FoldExprNode | FilterExprNode | RecoveryErrorNode | ErrorNode | TypeNameExprNode | ListLiteralNode | DictLiteralNode | TupleLiteralNode | OrderedLiteralNode | DestructNode | ConvertNode | UseExprNode;
 export {};

package/dist/ast-unions.d.ts

@@ -2,4 +2,4 @@
  * AST Type Unions
  * String union of all AST node type literals.
  */
-export type NodeType = 'Script' | 'Frontmatter' | 'Closure' | 'ClosureParam' | 'Statement' | 'PipeChain' | 'PostfixExpr' | 'MethodCall' | 'Invoke' | 'AnnotationAccess' | 'HostCall' | 'HostRef' | 'ClosureCall' | 'PipeInvoke' | 'Variable' | 'Capture' | 'Conditional' | 'WhileLoop' | 'DoWhileLoop' | 'Block' | 'StringLiteral' | 'Interpolation' | 'NumberLiteral' | 'BoolLiteral' | 'ListSpread' | 'Dict' | 'DictEntry' | 'Break' | 'Return' | 'Pass' | 'Assert' | 'BinaryExpr' | 'UnaryExpr' | 'GroupedExpr' | 'Destructure' | 'DestructPattern' | 'Slice' | 'TypeAssertion' | 'TypeCheck' | 'AnnotatedStatement' | 'AnnotatedExpr' | 'NamedArg' | 'SpreadArg' | 'EachExpr' | 'MapExpr' | 'FoldExpr' | 'FilterExpr' | 'RecoveryError' | 'Error' | 'TypeNameExpr' | 'TypeConstructor' | 'ClosureSigLiteral' | 'ListLiteral' | 'DictLiteral' | 'TupleLiteral' | 'OrderedLiteral' | 'Destruct' | 'Convert' | 'UseExpr';
+export type NodeType = 'Script' | 'Frontmatter' | 'Closure' | 'ClosureParam' | 'Statement' | 'PipeChain' | 'PostfixExpr' | 'MethodCall' | 'Invoke' | 'AnnotationAccess' | 'HostCall' | 'HostRef' | 'ClosureCall' | 'PipeInvoke' | 'Variable' | 'Capture' | 'Conditional' | 'WhileLoop' | 'DoWhileLoop' | 'Block' | 'StringLiteral' | 'Interpolation' | 'NumberLiteral' | 'BoolLiteral' | 'ListSpread' | 'Dict' | 'DictEntry' | 'Break' | 'Return' | 'Yield' | 'Pass' | 'Assert' | 'BinaryExpr' | 'UnaryExpr' | 'GroupedExpr' | 'Destructure' | 'DestructPattern' | 'Slice' | 'TypeAssertion' | 'TypeCheck' | 'AnnotatedStatement' | 'AnnotatedExpr' | 'NamedArg' | 'SpreadArg' | 'EachExpr' | 'MapExpr' | 'FoldExpr' | 'FilterExpr' | 'RecoveryError' | 'Error' | 'TypeNameExpr' | 'TypeConstructor' | 'ClosureSigLiteral' | 'ListLiteral' | 'DictLiteral' | 'TupleLiteral' | 'OrderedLiteral' | 'Destruct' | 'Convert' | 'UseExpr';

package/dist/constants.d.ts

@@ -10,4 +10,4 @@
  * - Parser: array iteration for token validation
  * - Runtime: Set-based O(1) membership lookup
  */
-export declare const VALID_TYPE_NAMES: readonly ["string", "number", "bool", "closure", "list", "dict", "tuple", "ordered", "vector", "any", "type", "iterator"];
+export declare const VALID_TYPE_NAMES: readonly ["string", "number", "bool", "closure", "list", "dict", "tuple", "ordered", "vector", "any", "type", "iterator", "stream"];

package/dist/constants.js

@@ -26,4 +26,5 @@ export const VALID_TYPE_NAMES = [
     'any',
     'type',
     'iterator',
+    'stream',
 ];

package/dist/error-registry.js

@@ -228,6 +228,24 @@ const ERROR_DEFINITIONS = [
             },
         ],
     },
+    {
+        errorId: 'RILL-P006',
+        category: 'parse',
+        description: 'Invalid syntax in context',
+        messageTemplate: '{message}',
+        cause: 'A syntactic construct was used in a context where it is not allowed.',
+        resolution: 'Check that the construct is used in the correct context.',
+        examples: [
+            {
+                description: 'Spread in unsupported position',
+                code: '$x.method(...$args)  # spread not supported in method calls',
+            },
+            {
+                description: 'yield outside stream closure',
+                code: '|x| yield  # yield requires :stream() return type',
+            },
+        ],
+    },
     {
         errorId: 'RILL-P007',
         category: 'parse',
@@ -1330,6 +1348,216 @@ const ERROR_DEFINITIONS = [
             },
         ],
     },
+    // Type conversion: string to number (RILL-R064)
+    {
+        errorId: 'RILL-R064',
+        category: 'runtime',
+        description: 'Cannot convert string to number',
+        messageTemplate: 'Cannot convert string "{value}" to number',
+        cause: 'The string value is not a valid numeric representation or is empty/whitespace.',
+        resolution: 'Ensure the string contains a valid number before converting. Use as(number) only on numeric strings.',
+        examples: [
+            {
+                description: 'Non-numeric string conversion',
+                code: '"hello" -> as(number)  # Error: not a valid number',
+            },
+        ],
+    },
+    // Type conversion: string to bool (RILL-R065)
+    {
+        errorId: 'RILL-R065',
+        category: 'runtime',
+        description: 'Cannot convert string to bool',
+        messageTemplate: 'Cannot convert string "{value}" to bool',
+        cause: 'Only the strings "true" and "false" can convert to bool.',
+        resolution: 'Use the exact strings "true" or "false" for bool conversion.',
+        examples: [
+            {
+                description: 'Invalid bool string',
+                code: '"yes" -> as(bool)  # Error: only "true"/"false" allowed',
+            },
+        ],
+    },
+    // Type conversion: number to bool (RILL-R066)
+    {
+        errorId: 'RILL-R066',
+        category: 'runtime',
+        description: 'Cannot convert number to bool',
+        messageTemplate: 'Cannot convert number {value} to bool',
+        cause: 'Only the numbers 0 and 1 can convert to bool. Other numeric values have no bool equivalent.',
+        resolution: 'Use 0 (false) or 1 (true) for number-to-bool conversion.',
+        examples: [
+            {
+                description: 'Non-binary number conversion',
+                code: '42 -> as(bool)  # Error: only 0 and 1 allowed',
+            },
+        ],
+    },
+    // JSON serialization: value not serializable (RILL-R067)
+    {
+        errorId: 'RILL-R067',
+        category: 'runtime',
+        description: 'Value is not JSON-serializable',
+        messageTemplate: '{typeName} are not JSON-serializable',
+        cause: 'The value type cannot be represented in JSON. Only strings, numbers, bools, lists, and dicts serialize.',
+        resolution: 'Convert the value to a serializable type before JSON operations. Extract data from closures or iterators first.',
+        examples: [
+            {
+                description: 'Closure in JSON context',
+                code: '|x| $x + 1 -> as(string)  # Error: closures not serializable',
+            },
+        ],
+    },
+    // Method registration: frozen type registration (RILL-R068)
+    {
+        errorId: 'RILL-R068',
+        category: 'runtime',
+        description: 'Type registration is frozen',
+        messageTemplate: "Cannot populate methods on type '{typeName}': registration is frozen",
+        cause: 'The type registration object was deep-frozen, preventing method assignment.',
+        resolution: 'Ensure type registrations are not deep-frozen before calling populateBuiltinMethods.',
+        examples: [
+            {
+                description: 'Frozen registration object',
+                code: '# Object.freeze(registration) prevents method population',
+            },
+        ],
+    },
+    // Context validation: function missing description (RILL-R069)
+    {
+        errorId: 'RILL-R069',
+        category: 'runtime',
+        description: 'Function missing required description',
+        messageTemplate: "Function '{name}' requires description (requireDescriptions enabled)",
+        cause: 'The requireDescriptions option is enabled but the function has no description.',
+        resolution: 'Add a description field to the function definition, or disable requireDescriptions.',
+        examples: [
+            {
+                description: 'Missing function description',
+                code: '# registerFunction("greet", { fn: ... }) with requireDescriptions: true',
+            },
+        ],
+    },
+    // Context validation: parameter missing description (RILL-R070)
+    {
+        errorId: 'RILL-R070',
+        category: 'runtime',
+        description: 'Parameter missing required description',
+        messageTemplate: "Parameter '{paramName}' of function '{functionName}' requires description (requireDescriptions enabled)",
+        cause: 'The requireDescriptions option is enabled but a parameter has no description annotation.',
+        resolution: 'Add a description annotation to each parameter, or disable requireDescriptions.',
+        examples: [
+            {
+                description: 'Missing parameter description',
+                code: '# param { name: "x", annotations: {} } with requireDescriptions: true',
+            },
+        ],
+    },
+    // Context validation: duplicate type registration (RILL-R071)
+    {
+        errorId: 'RILL-R071',
+        category: 'runtime',
+        description: 'Duplicate type registration',
+        messageTemplate: "Duplicate type registration '{typeName}'",
+        cause: 'Two type registrations share the same name. Each type name must be unique.',
+        resolution: 'Remove or rename the duplicate type registration.',
+        examples: [
+            {
+                description: 'Duplicate type name',
+                code: '# Two registrations both named "string"',
+            },
+        ],
+    },
+    // Context validation: missing format protocol (RILL-R072)
+    {
+        errorId: 'RILL-R072',
+        category: 'runtime',
+        description: 'Type missing format protocol',
+        messageTemplate: "Type '{typeName}' missing required format protocol",
+        cause: 'Every type registration must include a format function in its protocol.',
+        resolution: 'Add a format function to the type registration protocol.',
+        examples: [
+            {
+                description: 'Missing format in protocol',
+                code: '# TypeRegistration { name: "custom", protocol: {} } missing format',
+            },
+        ],
+    },
+    // Context validation: duplicate method on type (RILL-R073)
+    {
+        errorId: 'RILL-R073',
+        category: 'runtime',
+        description: 'Duplicate method on type',
+        messageTemplate: "Duplicate method '{methodName}' on type '{typeName}'",
+        cause: 'A method with the same name is registered twice on the same type.',
+        resolution: 'Remove the duplicate method registration or rename one of them.',
+        examples: [
+            {
+                description: 'Method registered twice',
+                code: '# Type "string" has two methods both named "split"',
+            },
+        ],
+    },
+    // Value validation: empty vector (RILL-R074)
+    {
+        errorId: 'RILL-R074',
+        category: 'runtime',
+        description: 'Vector requires at least one dimension',
+        messageTemplate: 'Vector data must have at least one dimension',
+        cause: 'An empty Float32Array was passed to createVector. Vectors must have at least one element.',
+        resolution: 'Provide a non-empty Float32Array when creating vectors.',
+        examples: [
+            {
+                description: 'Zero-dimension vector',
+                code: '# createVector(new Float32Array([]), "model") fails',
+            },
+        ],
+    },
+    // Extension validation: missing event field (RILL-R075)
+    {
+        errorId: 'RILL-R075',
+        category: 'runtime',
+        description: 'Event missing event field',
+        messageTemplate: 'Event must include non-empty event field',
+        cause: 'The event object passed to emitExtensionEvent has no event field or the field is empty.',
+        resolution: 'Include a non-empty string event field in the event object.',
+        examples: [
+            {
+                description: 'Empty event field',
+                code: '# emitExtensionEvent(ctx, { event: "" }) fails',
+            },
+        ],
+    },
+    // Module resolution: unknown module (RILL-R076)
+    {
+        errorId: 'RILL-R076',
+        category: 'runtime',
+        description: 'Unknown module resource',
+        messageTemplate: "Unknown module '{resource}'",
+        cause: 'The module resolver received a resource identifier it does not recognize.',
+        resolution: 'Use a valid module resource. The ext module resolver only handles the "ext" resource.',
+        examples: [
+            {
+                description: 'Invalid module resource',
+                code: 'use<module:unknown>  # Error: unknown module',
+            },
+        ],
+    },
+    // Callable validation: invalid default value (RILL-R077)
+    {
+        errorId: 'RILL-R077',
+        category: 'runtime',
+        description: 'Invalid parameter default value',
+        messageTemplate: "Invalid defaultValue for parameter '{paramName}': expected {expectedType}, got {actualType}",
+        cause: 'The default value type does not match the declared parameter type.',
+        resolution: 'Ensure the defaultValue matches the parameter type in the function definition.',
+        examples: [
+            {
+                description: 'Type mismatch in default',
+                code: '# param { name: "x", type: "number", defaultValue: "hello" }',
+            },
+        ],
+    },
     // Check Errors (RILL-C0xx)
     {
         errorId: 'RILL-C001',

package/dist/ext/crypto/index.d.ts

@@ -4,7 +4,7 @@
  * Provides cryptographic functions via thin wrapper around node:crypto.
  * Functions: hash, hmac, uuid, random
  */
-import type { ExtensionResult, ExtensionConfigSchema, ExtensionManifest } from '../../runtime/ext/extensions.js';
+import type { ExtensionFactoryResult, ExtensionConfigSchema, ExtensionManifest } from '../../runtime/ext/extensions.js';
 export declare const configSchema: ExtensionConfigSchema;
 /** Crypto extension configuration */
 export interface CryptoConfig {
@@ -19,7 +19,7 @@ export interface CryptoConfig {
  * Returns 4 functions: hash, hmac, uuid, random.
  *
  * @param config - Crypto configuration
- * @returns ExtensionResult with 4 crypto functions
+ * @returns ExtensionFactoryResult with 4 crypto functions
  *
  * @example
  * ```typescript
@@ -29,5 +29,5 @@ export interface CryptoConfig {
  * });
  * ```
  */
-export declare function createCryptoExtension(config?: CryptoConfig): ExtensionResult;
+export declare function createCryptoExtension(config?: CryptoConfig): ExtensionFactoryResult;
 export declare const extensionManifest: ExtensionManifest;

package/dist/ext/crypto/index.js

@@ -6,7 +6,8 @@
  */
 import crypto from 'node:crypto';
 import { RuntimeError } from '../../error-classes.js';
-import { rillTypeToTypeValue, } from '../../runtime/core/values.js';
+import { toCallable } from '../../runtime/core/callable.js';
+import { structureToTypeValue } from '../../runtime/core/values.js';
 // ============================================================
 // TYPES
 // ============================================================
@@ -23,7 +24,7 @@ export const configSchema = {
  * Returns 4 functions: hash, hmac, uuid, random.
  *
  * @param config - Crypto configuration
- * @returns ExtensionResult with 4 crypto functions
+ * @returns ExtensionFactoryResult with 4 crypto functions
  *
  * @example
  * ```typescript
@@ -100,64 +101,66 @@ export function createCryptoExtension(config = {}) {
     // EXTENSION RESULT
     // ============================================================
     return {
-        hash: {
-            params: [
-                {
-                    name: 'input',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Content to hash' },
+        value: {
+            hash: toCallable({
+                params: [
+                    {
+                        name: 'input',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Content to hash' },
+                    },
+                    {
+                        name: 'algorithm',
+                        type: { kind: 'string' },
+                        defaultValue: defaultAlgorithm,
+                        annotations: { description: 'Hash algorithm' },
+                    },
+                ],
+                fn: hash,
+                annotations: { description: 'Hash content, returns hex output' },
+                returnType: structureToTypeValue({ kind: 'string' }),
+            }),
+            hmac: toCallable({
+                params: [
+                    {
+                        name: 'input',
+                        type: { kind: 'string' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Content to authenticate' },
+                    },
+                    {
+                        name: 'algorithm',
+                        type: { kind: 'string' },
+                        defaultValue: defaultAlgorithm,
+                        annotations: { description: 'Hash algorithm' },
+                    },
+                ],
+                fn: hmac,
+                annotations: {
+                    description: 'Generate HMAC signature, returns hex output',
                 },
-                {
-                    name: 'algorithm',
-                    type: { type: 'string' },
-                    defaultValue: defaultAlgorithm,
-                    annotations: { description: 'Hash algorithm' },
-                },
-            ],
-            fn: hash,
-            annotations: { description: 'Hash content, returns hex output' },
-            returnType: rillTypeToTypeValue({ type: 'string' }),
-        },
-        hmac: {
-            params: [
-                {
-                    name: 'input',
-                    type: { type: 'string' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Content to authenticate' },
-                },
-                {
-                    name: 'algorithm',
-                    type: { type: 'string' },
-                    defaultValue: defaultAlgorithm,
-                    annotations: { description: 'Hash algorithm' },
-                },
-            ],
-            fn: hmac,
-            annotations: {
-                description: 'Generate HMAC signature, returns hex output',
-            },
-            returnType: rillTypeToTypeValue({ type: 'string' }),
-        },
-        uuid: {
-            params: [],
-            fn: uuid,
-            annotations: { description: 'Generate random UUID v4' },
-            returnType: rillTypeToTypeValue({ type: 'string' }),
-        },
-        random: {
-            params: [
-                {
-                    name: 'bytes',
-                    type: { type: 'number' },
-                    defaultValue: undefined,
-                    annotations: { description: 'Number of bytes' },
-                },
-            ],
-            fn: random,
-            annotations: { description: 'Generate random bytes as hex string' },
-            returnType: rillTypeToTypeValue({ type: 'string' }),
+                returnType: structureToTypeValue({ kind: 'string' }),
+            }),
+            uuid: toCallable({
+                params: [],
+                fn: uuid,
+                annotations: { description: 'Generate random UUID v4' },
+                returnType: structureToTypeValue({ kind: 'string' }),
+            }),
+            random: toCallable({
+                params: [
+                    {
+                        name: 'bytes',
+                        type: { kind: 'number' },
+                        defaultValue: undefined,
+                        annotations: { description: 'Number of bytes' },
+                    },
+                ],
+                fn: random,
+                annotations: { description: 'Generate random bytes as hex string' },
+                returnType: structureToTypeValue({ kind: 'string' }),
+            }),
         },
     };
 }

package/dist/ext/exec/index.d.ts

@@ -4,7 +4,7 @@
  * Provides sandboxed command execution via allowlist/blocklist security controls.
  * Each declared command becomes a function with argument validation and process isolation.
  */
-import type { ExtensionResult, ExtensionConfigSchema, ExtensionManifest } from '../../runtime/ext/extensions.js';
+import type { ExtensionFactoryResult, ExtensionConfigSchema, ExtensionManifest } from '../../runtime/ext/extensions.js';
 import { type CommandConfig } from './runner.js';
 export declare const configSchema: ExtensionConfigSchema;
 /** exec extension configuration */
@@ -27,7 +27,7 @@ export type { CommandConfig };
  * Returns dispose() function to abort in-flight processes.
  *
  * @param config - Command definitions and defaults
- * @returns ExtensionResult with command functions and dispose
+ * @returns ExtensionFactoryResult with command functions and dispose
  *
  * @example
  * ```typescript
@@ -42,5 +42,5 @@ export type { CommandConfig };
  * });
  * ```
  */
-export declare function createExecExtension(config: ExecConfig): ExtensionResult;
+export declare function createExecExtension(config: ExecConfig): ExtensionFactoryResult;
 export declare const extensionManifest: ExtensionManifest;