@rcrsr/rill 0.15.0 → 0.17.0

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

@@ -19,4 +19,3 @@ export declare const BUILTIN_METHODS: {
     bool: Record<string, RillFunction>;
     vector: Record<string, RillFunction>;
 };
-//# sourceMappingURL=builtins.d.ts.map

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,26 +71,28 @@ export const BUILTIN_FUNCTIONS = {
         params: [
             {
                 name: 'value',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
         ],
         returnType: anyTypeValue,
-        fn: (args) => args[0] ?? null,
+        fn: (args) => args['value'] ?? null,
     },
     /** Log a value and return it unchanged (passthrough) */
     log: {
         params: [
             {
                 name: 'message',
-                type: { type: 'any' },
+                type: { kind: 'any' },
                 defaultValue: undefined,
                 annotations: {},
             },
         ],
         returnType: anyTypeValue,
         fn: (args, ctx) => {
+            // log is in UNTYPED_BUILTINS (allows excess args), receives positional array cast as Record.
+            // Use index 0 for the message value.
             const value = args[0] ?? null;
             const message = formatValue(value);
             ctx.callbacks.onLog(message);
@@ -101,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[0] ?? null;
+            const value = args['value'] ?? null;
             try {
-                const jsonValue = valueToJSON(value);
+                const jsonValue = serializeValue(value);
                 return JSON.stringify(jsonValue);
             }
             catch (err) {
@@ -133,16 +136,16 @@ 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[0] ?? null;
+            const input = args['items'] ?? null;
             if (Array.isArray(input)) {
                 return input.map((value, index) => ({ index, value }));
             }
@@ -165,28 +168,28 @@ 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: {},
             },
         ],
         returnType: anyTypeValue,
         fn: (args, _ctx, location) => {
-            const start = typeof args[0] === 'number' ? args[0] : 0;
-            const end = typeof args[1] === 'number' ? args[1] : 0;
-            const step = typeof args[2] === 'number' ? args[2] : 1;
+            const start = typeof args['start'] === 'number' ? args['start'] : 0;
+            const end = typeof args['stop'] === 'number' ? args['stop'] : 0;
+            const step = typeof args['step'] === 'number' ? args['step'] : 1;
             if (step === 0) {
                 throw new RuntimeError('RILL-R001', 'range step cannot be zero', location);
             }
@@ -215,21 +218,21 @@ 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: {},
             },
         ],
         returnType: anyTypeValue,
         fn: (args, _ctx, location) => {
-            const value = args[0] ?? '';
-            const count = typeof args[1] === 'number' ? Math.floor(args[1]) : 0;
+            const value = args['value'] ?? '';
+            const count = typeof args['count'] === 'number' ? Math.floor(args['count']) : 0;
             if (count < 0) {
                 throw new RuntimeError('RILL-R001', 'repeat count cannot be negative', location);
             }
@@ -260,30 +263,32 @@ 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: {},
             },
         ],
         returnType: anyTypeValue,
         fn: async (args, ctx, location) => {
+            // chain is in UNTYPED_BUILTINS, receives positional array cast as Record.
             // Pipe position: 5 -> chain($closure) sends args=[$closure] with pipeValue=5.
             // Detect this by checking if there is exactly one arg and a pipe value is set.
+            const positional = args;
             let value;
             let arg;
-            if (args.length === 1 && ctx.pipeValue !== null) {
+            if (positional.length === 1 && ctx.pipeValue !== null) {
                 value = ctx.pipeValue;
-                arg = args[0] ?? null;
+                arg = positional[0] ?? null;
             }
             else {
-                value = args[0] ?? null;
-                arg = args[1] ?? null;
+                value = positional[0] ?? null;
+                arg = positional[1] ?? null;
             }
             if (Array.isArray(arg)) {
                 // List of closures: fold left-to-right
@@ -307,33 +312,47 @@ 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: { kind: 'any' },
+    defaultValue: undefined,
+    annotations: {},
+};
 /**
  * Build a RillFunction entry from a method body and its signature string.
  * Wraps `method(receiver, args, ctx, location)` as `fn(args, ctx, location)`
- * where `args[0]` is the receiver. Parses the signature to extract params and
- * returnType so that task 1.4 can use them directly without re-parsing.
+ * where receiver is the first param by declaration order (named 'receiver').
+ * Parses the signature to extract params and returnType so that task 1.4
+ * can use them directly without re-parsing.
+ *
+ * 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 {
-        params: parsed.params,
-        fn: (args, ctx, location) => method(args[0] ?? null, args.slice(1), ctx, location),
+        params: [RECEIVER_PARAM, ...methodParams],
+        fn: (args, ctx, location) => {
+            if (!('receiver' in args)) {
+                throw new RuntimeError('RILL-R044', "Missing required parameter 'receiver'", location);
+            }
+            const receiver = args['receiver'] ?? null;
+            // Reconstruct positional args array for RillMethod from named params in order.
+            // UNVALIDATED_METHOD_PARAMS methods pass __positionalArgs to preserve actual
+            // arg count so method body arity checks (args.length !== 1) fire correctly.
+            const positionalArgs = '__positionalArgs' in args
+                ? args['__positionalArgs']
+                : methodParams.map((p) => args[p.name] ?? null);
+            return method(receiver, positionalArgs, ctx, location);
+        },
         annotations: parsed.description !== undefined
             ? { description: parsed.description }
             : {},
         returnType: parsed.returnType !== undefined
             ? rillTypeToTypeValue(parsed.returnType)
             : anyTypeValue,
+        ...(skipReceiverValidation ? { skipReceiverValidation: true } : {}),
     };
 }
 export const BUILTIN_METHODS = {
@@ -525,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 */
@@ -730,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),
@@ -750,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),
@@ -759,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),
@@ -792,19 +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),
 });
-//# sourceMappingURL=builtins.js.map
+// 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.
@@ -227,4 +133,3 @@ export declare function emitExtensionEvent(ctx: RuntimeContextLike, event: Omit<
     timestamp?: string | undefined;
 }): void;
 export {};
-//# sourceMappingURL=extensions.d.ts.map