@rcrsr/rill 0.16.0 → 0.17.0

package/dist/runtime/ext/builtins.js

@@ -9,8 +9,9 @@
 import { callable, isCallable, isDict } from '../core/callable.js';
 import { RuntimeError } from '../../types.js';
 import { parseSignatureRegistration } from '../../signature-parser.js';
-import { anyTypeValue, deepEquals, formatValue, inferType, isEmpty, isRillIterator, isVector, rillTypeToTypeValue, valueToJSON, } from '../core/values.js';
+import { anyTypeValue, deepEquals, formatValue, inferType, isEmpty, isRillIterator, isVector, rillTypeToTypeValue, serializeValue, } from '../core/values.js';
 import { invokeCallable } from '../core/eval/index.js';
+import { populateBuiltinMethods } from '../core/type-registrations.js';
 // ============================================================
 // ITERATOR HELPERS
 // ============================================================
@@ -70,7 +71,7 @@ export const BUILTIN_FUNCTIONS = {
         params: [
             {
                 name: 'value',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
@@ -83,7 +84,7 @@ export const BUILTIN_FUNCTIONS = {
         params: [
             {
                 name: 'message',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
@@ -103,16 +104,16 @@ export const BUILTIN_FUNCTIONS = {
         params: [
             {
                 name: 'value',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
         ],
-        returnType: rillTypeToTypeValue({ type: 'string' }),
+        returnType: rillTypeToTypeValue({ kind: 'string' }),
         fn: (args, _ctx, location) => {
             const value = args['value'] ?? null;
             try {
-                const jsonValue = valueToJSON(value);
+                const jsonValue = serializeValue(value);
                 return JSON.stringify(jsonValue);
             }
             catch (err) {
@@ -135,14 +136,14 @@ export const BUILTIN_FUNCTIONS = {
             {
                 name: 'items',
                 type: {
-                    type: 'union',
-                    members: [{ type: 'list' }, { type: 'dict' }, { type: 'string' }],
+                    kind: 'union',
+                    members: [{ kind: 'list' }, { kind: 'dict' }, { kind: 'string' }],
                 },
                 defaultValue: undefined,
                 annotations: {},
             },
         ],
-        returnType: rillTypeToTypeValue({ type: 'list' }),
+        returnType: rillTypeToTypeValue({ kind: 'list' }),
         fn: (args) => {
             const input = args['items'] ?? null;
             if (Array.isArray(input)) {
@@ -167,19 +168,19 @@ export const BUILTIN_FUNCTIONS = {
         params: [
             {
                 name: 'start',
-                type: { type: 'number' },
+                type: { kind: 'number' },
                 defaultValue: undefined,
                 annotations: {},
             },
             {
                 name: 'stop',
-                type: { type: 'number' },
+                type: { kind: 'number' },
                 defaultValue: undefined,
                 annotations: {},
             },
             {
                 name: 'step',
-                type: { type: 'number' },
+                type: { kind: 'number' },
                 defaultValue: 1,
                 annotations: {},
             },
@@ -217,13 +218,13 @@ export const BUILTIN_FUNCTIONS = {
         params: [
             {
                 name: 'value',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
             {
                 name: 'count',
-                type: { type: 'number' },
+                type: { kind: 'number' },
                 defaultValue: undefined,
                 annotations: {},
             },
@@ -262,13 +263,13 @@ export const BUILTIN_FUNCTIONS = {
         params: [
             {
                 name: 'value',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
             {
                 name: 'transform',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
@@ -311,20 +312,10 @@ export const BUILTIN_FUNCTIONS = {
 // ============================================================
 // BUILT-IN METHODS
 // ============================================================
-/** Factory for comparison methods (lt, gt, le, ge) */
-function createComparisonMethod(compare) {
-    return (receiver, args) => {
-        const arg = args[0];
-        if (typeof receiver === 'number' && typeof arg === 'number') {
-            return compare(receiver, arg);
-        }
-        return compare(formatValue(receiver), formatValue(arg ?? ''));
-    };
-}
 /** Receiver param prepended to every method's param list */
 const RECEIVER_PARAM = {
     name: 'receiver',
-    type: { type: 'any' },
+    type: { kind: 'any' },
     defaultValue: undefined,
     annotations: {},
 };
@@ -337,7 +328,7 @@ const RECEIVER_PARAM = {
  *
  * EC-4: Receiver missing from record raises RILL-R044.
  */
-function buildMethodEntry(name, signature, method) {
+function buildMethodEntry(name, signature, method, skipReceiverValidation) {
     const parsed = parseSignatureRegistration(signature, name);
     const methodParams = parsed.params;
     return {
@@ -361,6 +352,7 @@ function buildMethodEntry(name, signature, method) {
         returnType: parsed.returnType !== undefined
             ? rillTypeToTypeValue(parsed.returnType)
             : anyTypeValue,
+        ...(skipReceiverValidation ? { skipReceiverValidation: true } : {}),
     };
 }
 export const BUILTIN_METHODS = {
@@ -552,10 +544,34 @@ const mPadEnd = (receiver, args) => {
 const mEq = (receiver, args) => deepEquals(receiver, args[0] ?? null);
 /** Inequality check (deep structural comparison) */
 const mNe = (receiver, args) => !deepEquals(receiver, args[0] ?? null);
-const mLt = createComparisonMethod((a, b) => a < b);
-const mGt = createComparisonMethod((a, b) => a > b);
-const mLe = createComparisonMethod((a, b) => a <= b);
-const mGe = createComparisonMethod((a, b) => a >= b);
+/** Less-than comparison (number or string) */
+const mLt = (receiver, args) => {
+    const arg = args[0];
+    if (typeof receiver === 'number' && typeof arg === 'number')
+        return receiver < arg;
+    return formatValue(receiver) < formatValue(arg ?? '');
+};
+/** Greater-than comparison (number or string) */
+const mGt = (receiver, args) => {
+    const arg = args[0];
+    if (typeof receiver === 'number' && typeof arg === 'number')
+        return receiver > arg;
+    return formatValue(receiver) > formatValue(arg ?? '');
+};
+/** Less-than-or-equal comparison (number or string) */
+const mLe = (receiver, args) => {
+    const arg = args[0];
+    if (typeof receiver === 'number' && typeof arg === 'number')
+        return receiver <= arg;
+    return formatValue(receiver) <= formatValue(arg ?? '');
+};
+/** Greater-than-or-equal comparison (number or string) */
+const mGe = (receiver, args) => {
+    const arg = args[0];
+    if (typeof receiver === 'number' && typeof arg === 'number')
+        return receiver >= arg;
+    return formatValue(receiver) >= formatValue(arg ?? '');
+};
 /** Get all keys of a dict as a list */
 const mKeys = (receiver) => isDict(receiver) ? Object.keys(receiver) : [];
 /** Get all values of a dict as a list */
@@ -757,10 +773,10 @@ const SIG_CMP = '|other: any|:bool';
 BUILTIN_METHODS.string = Object.freeze({
     len: buildMethodEntry('len', SIG_LEN, mLen),
     trim: buildMethodEntry('trim', '||:string', mTrim),
-    head: buildMethodEntry('head', SIG_HEAD, mHead),
-    tail: buildMethodEntry('tail', SIG_TAIL, mTail),
-    first: buildMethodEntry('first', SIG_FIRST, mFirst),
-    at: buildMethodEntry('at', SIG_AT, mAt),
+    head: buildMethodEntry('head', SIG_HEAD, mHead, true),
+    tail: buildMethodEntry('tail', SIG_TAIL, mTail, true),
+    first: buildMethodEntry('first', SIG_FIRST, mFirst, true),
+    at: buildMethodEntry('at', SIG_AT, mAt, true),
     split: buildMethodEntry('split', '|separator: string = "\\n"|:list', mSplit),
     lines: buildMethodEntry('lines', '||:list', mLines),
     empty: buildMethodEntry('empty', SIG_EMPTY, mEmpty),
@@ -777,8 +793,8 @@ BUILTIN_METHODS.string = Object.freeze({
     repeat: buildMethodEntry('repeat', '|count: number|:string', mRepeat),
     pad_start: buildMethodEntry('pad_start', '|length: number, fill: string = " "|:string', mPadStart),
     pad_end: buildMethodEntry('pad_end', '|length: number, fill: string = " "|:string', mPadEnd),
-    eq: buildMethodEntry('eq', SIG_EQ, mEq),
-    ne: buildMethodEntry('ne', SIG_NE, mNe),
+    eq: buildMethodEntry('eq', SIG_EQ, mEq, true),
+    ne: buildMethodEntry('ne', SIG_NE, mNe, true),
     lt: buildMethodEntry('lt', SIG_CMP, mLt),
     gt: buildMethodEntry('gt', SIG_CMP, mGt),
     le: buildMethodEntry('le', SIG_CMP, mLe),
@@ -786,32 +802,32 @@ BUILTIN_METHODS.string = Object.freeze({
 });
 BUILTIN_METHODS.list = Object.freeze({
     len: buildMethodEntry('len', SIG_LEN, mLen),
-    head: buildMethodEntry('head', SIG_HEAD, mHead),
-    tail: buildMethodEntry('tail', SIG_TAIL, mTail),
-    first: buildMethodEntry('first', SIG_FIRST, mFirst),
-    at: buildMethodEntry('at', SIG_AT, mAt),
+    head: buildMethodEntry('head', SIG_HEAD, mHead, true),
+    tail: buildMethodEntry('tail', SIG_TAIL, mTail, true),
+    first: buildMethodEntry('first', SIG_FIRST, mFirst, true),
+    at: buildMethodEntry('at', SIG_AT, mAt, true),
     join: buildMethodEntry('join', '|separator: string = ","|:string', mJoin),
     empty: buildMethodEntry('empty', SIG_EMPTY, mEmpty),
-    eq: buildMethodEntry('eq', SIG_EQ, mEq),
-    ne: buildMethodEntry('ne', SIG_NE, mNe),
-    has: buildMethodEntry('has', '|value: any|:bool', mHas),
-    has_any: buildMethodEntry('has_any', '|candidates: list|:bool', mHasAny),
-    has_all: buildMethodEntry('has_all', '|candidates: list|:bool', mHasAll),
+    eq: buildMethodEntry('eq', SIG_EQ, mEq, true),
+    ne: buildMethodEntry('ne', SIG_NE, mNe, true),
+    has: buildMethodEntry('has', '|value: any|:bool', mHas, true),
+    has_any: buildMethodEntry('has_any', '|candidates: list|:bool', mHasAny, true),
+    has_all: buildMethodEntry('has_all', '|candidates: list|:bool', mHasAll, true),
 });
 BUILTIN_METHODS.dict = Object.freeze({
     len: buildMethodEntry('len', SIG_LEN, mLen),
-    first: buildMethodEntry('first', SIG_FIRST, mFirst),
+    first: buildMethodEntry('first', SIG_FIRST, mFirst, true),
     empty: buildMethodEntry('empty', SIG_EMPTY, mEmpty),
-    eq: buildMethodEntry('eq', SIG_EQ, mEq),
-    ne: buildMethodEntry('ne', SIG_NE, mNe),
-    keys: buildMethodEntry('keys', '||:list', mKeys),
-    values: buildMethodEntry('values', '||:list', mValues),
-    entries: buildMethodEntry('entries', '||:list', mEntries),
+    eq: buildMethodEntry('eq', SIG_EQ, mEq, true),
+    ne: buildMethodEntry('ne', SIG_NE, mNe, true),
+    keys: buildMethodEntry('keys', '||:list', mKeys, true),
+    values: buildMethodEntry('values', '||:list', mValues, true),
+    entries: buildMethodEntry('entries', '||:list', mEntries, true),
 });
 BUILTIN_METHODS.number = Object.freeze({
     empty: buildMethodEntry('empty', SIG_EMPTY, mEmpty),
-    eq: buildMethodEntry('eq', SIG_EQ, mEq),
-    ne: buildMethodEntry('ne', SIG_NE, mNe),
+    eq: buildMethodEntry('eq', SIG_EQ, mEq, true),
+    ne: buildMethodEntry('ne', SIG_NE, mNe, true),
     lt: buildMethodEntry('lt', SIG_CMP, mLt),
     gt: buildMethodEntry('gt', SIG_CMP, mGt),
     le: buildMethodEntry('le', SIG_CMP, mLe),
@@ -819,18 +835,21 @@ BUILTIN_METHODS.number = Object.freeze({
 });
 BUILTIN_METHODS.bool = Object.freeze({
     empty: buildMethodEntry('empty', SIG_EMPTY, mEmpty),
-    eq: buildMethodEntry('eq', SIG_EQ, mEq),
-    ne: buildMethodEntry('ne', SIG_NE, mNe),
+    eq: buildMethodEntry('eq', SIG_EQ, mEq, true),
+    ne: buildMethodEntry('ne', SIG_NE, mNe, true),
 });
 // [ASSUMPTION] vector is a 6th group beyond the 5 specified basic types.
 // The 7 vector methods do not belong to string/list/dict/number/bool.
 // Adding this group ensures all 42 methods are accessible (AC-36).
 BUILTIN_METHODS.vector = Object.freeze({
-    dimensions: buildMethodEntry('dimensions', '||:number', mDimensions),
-    model: buildMethodEntry('model', '||:string', mModel),
-    similarity: buildMethodEntry('similarity', '|other: any|:number', mSimilarity),
-    dot: buildMethodEntry('dot', '|other: any|:number', mDot),
-    distance: buildMethodEntry('distance', '|other: any|:number', mDistance),
-    norm: buildMethodEntry('norm', '||:number', mNorm),
-    normalize: buildMethodEntry('normalize', '||:any', mNormalize),
+    dimensions: buildMethodEntry('dimensions', '||:number', mDimensions, true),
+    model: buildMethodEntry('model', '||:string', mModel, true),
+    similarity: buildMethodEntry('similarity', '|other: any|:number', mSimilarity, true),
+    dot: buildMethodEntry('dot', '|other: any|:number', mDot, true),
+    distance: buildMethodEntry('distance', '|other: any|:number', mDistance, true),
+    norm: buildMethodEntry('norm', '||:number', mNorm, true),
+    normalize: buildMethodEntry('normalize', '||:any', mNormalize, true),
 });
+// Populate registration methods from BUILTIN_METHODS at module load time.
+// No circular dependency: type-registrations.ts does not import builtins.ts.
+populateBuiltinMethods(BUILTIN_METHODS);

package/dist/runtime/ext/extensions.d.ts

@@ -1,5 +1,6 @@
-import type { RillFunction } from '../core/callable.js';
+import type { ApplicationCallable } from '../core/callable.js';
 import type { ExtensionEvent, RuntimeCallbacks } from '../core/types.js';
+import type { RillValue } from '../core/values.js';
 /**
  * Minimal interface for extension event emission.
  * Allows emitExtensionEvent to accept any context with callbacks.
@@ -9,27 +10,20 @@ interface RuntimeContextLike {
 }
 /**
  * Result object returned by extension factories.
- * Contains host function definitions with optional cleanup and session lifecycle hooks.
+ * Contains the mounted RillValue with optional lifecycle hooks.
+ * Lifecycle hooks live on the factory result, not on the value dict (DD-1).
  */
-export interface ExtensionResult {
-    [name: string]: RillFunction | ((...args: never[]) => unknown) | undefined;
+export interface ExtensionFactoryResult {
+    readonly value: RillValue;
     dispose?: () => void | Promise<void>;
     suspend?: () => unknown;
     restore?: (state: unknown) => void;
 }
-/**
- * Result object returned by hoistExtension.
- * Separates functions from dispose for safe createRuntimeContext usage.
- */
-export interface HoistedExtension {
-    functions: Record<string, RillFunction>;
-    dispose?: () => void | Promise<void>;
-}
 /**
  * Factory function contract for creating extensions.
  * Accepts typed configuration and returns isolated instance.
  */
-export type ExtensionFactory<TConfig> = (config: TConfig) => ExtensionResult | Promise<ExtensionResult>;
+export type ExtensionFactory<TConfig> = (config: TConfig) => ExtensionFactoryResult | Promise<ExtensionFactoryResult>;
 /**
  * Descriptor for a single configuration field in an extension schema.
  * The secret flag is advisory: harness tooling uses it to mask or omit values.
@@ -72,18 +66,17 @@ export interface ExtensionManifest {
  * - mounts(): List all configured mounts
  */
 export type KvExtensionContract = {
-    readonly get: RillFunction;
-    readonly get_or: RillFunction;
-    readonly set: RillFunction;
-    readonly merge: RillFunction;
-    readonly delete: RillFunction;
-    readonly keys: RillFunction;
-    readonly has: RillFunction;
-    readonly clear: RillFunction;
-    readonly getAll: RillFunction;
-    readonly schema: RillFunction;
-    readonly mounts: RillFunction;
-    readonly dispose?: (() => void | Promise<void>) | undefined;
+    readonly get: ApplicationCallable;
+    readonly get_or: ApplicationCallable;
+    readonly set: ApplicationCallable;
+    readonly merge: ApplicationCallable;
+    readonly delete: ApplicationCallable;
+    readonly keys: ApplicationCallable;
+    readonly has: ApplicationCallable;
+    readonly clear: ApplicationCallable;
+    readonly getAll: ApplicationCallable;
+    readonly schema: ApplicationCallable;
+    readonly mounts: ApplicationCallable;
 };
 /**
  * Contract type for fs extension implementations.
@@ -104,106 +97,19 @@ export type KvExtensionContract = {
  * - mounts(): List all configured mounts
  */
 export type FsExtensionContract = {
-    readonly read: RillFunction;
-    readonly write: RillFunction;
-    readonly append: RillFunction;
-    readonly list: RillFunction;
-    readonly find: RillFunction;
-    readonly exists: RillFunction;
-    readonly remove: RillFunction;
-    readonly stat: RillFunction;
-    readonly mkdir: RillFunction;
-    readonly copy: RillFunction;
-    readonly move: RillFunction;
-    readonly mounts: RillFunction;
-    readonly dispose?: (() => void | Promise<void>) | undefined;
-};
-/**
- * Contract type for llm extension implementations.
- * Enforces exact function structure for compile-time verification.
- *
- * Backend implementations must provide all 6 functions:
- * - message(text, options): Send single message
- * - messages(messages, options): Multi-turn conversation
- * - embed(text): Generate embedding vector
- * - embed_batch(texts): Batch embeddings
- * - tool_loop(prompt, options): Tool use orchestration
- * - generate(prompt, options): Structured output extraction
- */
-export type LlmExtensionContract = {
-    readonly message: RillFunction;
-    readonly messages: RillFunction;
-    readonly embed: RillFunction;
-    readonly embed_batch: RillFunction;
-    readonly tool_loop: RillFunction;
-    readonly generate: RillFunction;
-    readonly dispose?: (() => void | Promise<void>) | undefined;
-};
-/**
- * Contract type for vector extension implementations.
- * Enforces exact function structure for compile-time verification.
- *
- * Backend implementations must provide all 11 functions:
- * - upsert(id, vector, metadata): Insert or update vector
- * - upsert_batch(items): Batch insert/update
- * - search(vector, options): Search k nearest neighbors
- * - get(id): Fetch vector by ID
- * - delete(id): Delete vector by ID
- * - delete_batch(ids): Batch delete
- * - count(): Count vectors in collection
- * - create_collection(name, options): Create collection
- * - delete_collection(name): Delete collection
- * - list_collections(): List all collections
- * - describe(): Get collection metadata
- */
-export type VectorExtensionContract = {
-    readonly upsert: RillFunction;
-    readonly upsert_batch: RillFunction;
-    readonly search: RillFunction;
-    readonly get: RillFunction;
-    readonly delete: RillFunction;
-    readonly delete_batch: RillFunction;
-    readonly count: RillFunction;
-    readonly create_collection: RillFunction;
-    readonly delete_collection: RillFunction;
-    readonly list_collections: RillFunction;
-    readonly describe: RillFunction;
-    readonly dispose?: (() => void | Promise<void>) | undefined;
+    readonly read: ApplicationCallable;
+    readonly write: ApplicationCallable;
+    readonly append: ApplicationCallable;
+    readonly list: ApplicationCallable;
+    readonly find: ApplicationCallable;
+    readonly exists: ApplicationCallable;
+    readonly remove: ApplicationCallable;
+    readonly stat: ApplicationCallable;
+    readonly mkdir: ApplicationCallable;
+    readonly copy: ApplicationCallable;
+    readonly move: ApplicationCallable;
+    readonly mounts: ApplicationCallable;
 };
-/**
- * Prefix all function names in an extension with a namespace.
- *
- * @param namespace - Alphanumeric string with underscores/hyphens (e.g., "fs", "claude_code")
- * @param functions - Extension result with function definitions
- * @returns New ExtensionResult with prefixed function names (namespace::functionName)
- * @throws {RuntimeError} RUNTIME_TYPE_ERROR if namespace is invalid
- *
- * @example
- * ```typescript
- * const fs = createFsExtension();
- * const prefixed = prefixFunctions("fs", fs);
- * // { "fs::read": ..., "fs::write": ..., dispose: ... }
- * ```
- */
-export declare function prefixFunctions(namespace: string, functions: ExtensionResult): ExtensionResult;
-/**
- * Separate dispose from functions for safe createRuntimeContext usage.
- * Wraps prefixFunctions and returns separated structure.
- *
- * @param namespace - String matching /^[a-zA-Z0-9_-]+$/
- * @param extension - Output from extension factory
- * @returns Separated functions and dispose handler
- * @throws {Error} If namespace is empty
- * @throws {Error} If namespace has invalid format
- * @throws {TypeError} If extension is null or undefined
- *
- * @example
- * ```typescript
- * const { functions, dispose } = hoistExtension('db', dbExtension);
- * const ctx = createRuntimeContext({ functions });
- * ```
- */
-export declare function hoistExtension(namespace: string, extension: ExtensionResult): HoistedExtension;
 /**
  * Emit an extension event with auto-generated timestamp.
  * Adds ISO timestamp if event.timestamp is undefined, then calls onLogEvent callback.

package/dist/runtime/ext/extensions.js

@@ -1,96 +1,3 @@
-/**
- * Prefix all function names in an extension with a namespace.
- *
- * @param namespace - Alphanumeric string with underscores/hyphens (e.g., "fs", "claude_code")
- * @param functions - Extension result with function definitions
- * @returns New ExtensionResult with prefixed function names (namespace::functionName)
- * @throws {RuntimeError} RUNTIME_TYPE_ERROR if namespace is invalid
- *
- * @example
- * ```typescript
- * const fs = createFsExtension();
- * const prefixed = prefixFunctions("fs", fs);
- * // { "fs::read": ..., "fs::write": ..., dispose: ... }
- * ```
- */
-export function prefixFunctions(namespace, functions) {
-    // EC-7: Extension not object
-    if (typeof functions !== 'object' ||
-        functions === null ||
-        Array.isArray(functions)) {
-        throw new TypeError('Extension must be an object');
-    }
-    // EC-6: Invalid namespace format
-    const NAMESPACE_PATTERN = /^[a-zA-Z0-9_-]+$/;
-    if (!NAMESPACE_PATTERN.test(namespace)) {
-        throw new Error('Invalid namespace format: must match /^[a-zA-Z0-9_-]+$/');
-    }
-    // Create new object with prefixed keys
-    const result = {};
-    for (const [name, definition] of Object.entries(functions)) {
-        // Skip lifecycle hooks during prefixing
-        if (name === 'dispose' || name === 'suspend' || name === 'restore')
-            continue;
-        result[`${namespace}::${name}`] = definition;
-    }
-    // Preserve lifecycle hooks if present
-    const resultWithHooks = result;
-    if (functions.dispose !== undefined) {
-        resultWithHooks.dispose = functions.dispose;
-    }
-    if (functions.suspend !== undefined) {
-        resultWithHooks.suspend = functions.suspend;
-    }
-    if (functions.restore !== undefined) {
-        resultWithHooks.restore = functions.restore;
-    }
-    return resultWithHooks;
-}
-/**
- * Separate dispose from functions for safe createRuntimeContext usage.
- * Wraps prefixFunctions and returns separated structure.
- *
- * @param namespace - String matching /^[a-zA-Z0-9_-]+$/
- * @param extension - Output from extension factory
- * @returns Separated functions and dispose handler
- * @throws {Error} If namespace is empty
- * @throws {Error} If namespace has invalid format
- * @throws {TypeError} If extension is null or undefined
- *
- * @example
- * ```typescript
- * const { functions, dispose } = hoistExtension('db', dbExtension);
- * const ctx = createRuntimeContext({ functions });
- * ```
- */
-export function hoistExtension(namespace, extension) {
-    // EC-3: Null/undefined extension
-    if (extension === null || extension === undefined) {
-        throw new TypeError('Extension cannot be null or undefined');
-    }
-    // EC-2: Empty namespace
-    if (namespace === '') {
-        throw new Error('Namespace cannot be empty');
-    }
-    // EC-1: Invalid namespace format
-    const NAMESPACE_PATTERN = /^[a-zA-Z0-9_-]+$/;
-    if (!NAMESPACE_PATTERN.test(namespace)) {
-        throw new Error('Invalid namespace format: must match /^[a-zA-Z0-9_-]+$/');
-    }
-    // Call prefixFunctions internally
-    const prefixed = prefixFunctions(namespace, extension);
-    // Extract dispose from result
-    const { dispose, ...functions } = prefixed;
-    // Return separated structure
-    const result = {
-        functions: functions,
-    };
-    // Only add dispose if it exists (exactOptionalPropertyTypes)
-    if (dispose !== undefined) {
-        result.dispose = dispose;
-    }
-    return result;
-}
 /**
  * Emit an extension event with auto-generated timestamp.
  * Adds ISO timestamp if event.timestamp is undefined, then calls onLogEvent callback.

package/dist/runtime/ext/test-context.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Test Context Factory
+ *
+ * Creates a pre-wired RuntimeContext from extension value maps.
+ * Designed for testing and lightweight embedding without rill-config.
+ */
+import type { RuntimeContext } from '../core/types.js';
+import { type RillValue } from '../core/values.js';
+/**
+ * Error thrown when extension binding generation fails.
+ * Mirrors the ExtensionBindingError in rill-config for core-only usage.
+ */
+export declare class ExtensionBindingError extends Error {
+    readonly code: "EXTENSION_BINDING";
+    constructor(message: string);
+}
+/**
+ * Create a RuntimeContext pre-wired with extension values.
+ * Builds extension bindings, registers ext and module resolvers,
+ * and returns a context ready for execute().
+ *
+ * @throws {TypeError} when an extension value is undefined (EC-9)
+ * @throws {ExtensionBindingError} when binding generation fails (EC-10)
+ */
+export declare function createTestContext(extensions: Record<string, {
+    value: RillValue;
+    dispose?: () => void | Promise<void>;
+}>): RuntimeContext;