@rcrsr/rill 0.15.0 → 0.17.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

@@ -1,5 +1,5 @@
 import type { SourceSpan } from './source-location.js';
-import type { RillTypeName, TypeRef } from './value-types.js';
+import type { FieldArg, RillTypeName, TypeRef } from './value-types.js';
 interface BaseNode {
     readonly span: SourceSpan;
 }
@@ -245,18 +245,8 @@ export interface DictEntryNode extends BaseNode {
 export interface TypeConstructorNode extends BaseNode {
     readonly type: 'TypeConstructor';
     readonly constructorName: 'list' | 'dict' | 'tuple' | 'ordered';
-    readonly args: TypeConstructorArg[];
+    readonly args: FieldArg[];
 }
-export type TypeConstructorArg = {
-    kind: 'positional';
-    value: ExpressionNode;
-    defaultValue?: LiteralNode;
-} | {
-    kind: 'named';
-    name: string;
-    value: ExpressionNode;
-    defaultValue?: LiteralNode;
-};
 /**
  * Closure signature literal: |param: type, ...| :returnType
  * Represents a closure type signature as a first-class value.
@@ -812,4 +802,3 @@ export interface UseExprNode extends BaseNode {
 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 {};
-//# sourceMappingURL=ast-nodes.d.ts.map

package/dist/ast-nodes.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=ast-nodes.js.map

package/dist/ast-unions.d.ts

@@ -3,4 +3,3 @@
  * 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';
-//# sourceMappingURL=ast-unions.d.ts.map

package/dist/ast-unions.js

@@ -3,4 +3,3 @@
  * String union of all AST node type literals.
  */
 export {};
-//# sourceMappingURL=ast-unions.js.map

package/dist/constants.d.ts

@@ -11,4 +11,3 @@
  * - 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"];
-//# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -27,4 +27,3 @@ export const VALID_TYPE_NAMES = [
     'type',
     'iterator',
 ];
-//# sourceMappingURL=constants.js.map

package/dist/error-classes.d.ts

@@ -94,4 +94,3 @@ export declare class AutoExceptionError extends RuntimeError {
 export declare class AbortError extends RuntimeError {
     constructor(location?: SourceLocation);
 }
-//# sourceMappingURL=error-classes.d.ts.map

package/dist/error-classes.js

@@ -191,4 +191,3 @@ export class AbortError extends RuntimeError {
         this.name = 'AbortError';
     }
 }
-//# sourceMappingURL=error-classes.js.map

package/dist/error-formatter.d.ts

@@ -53,4 +53,3 @@ export interface FormatErrorJsonOptions {
  * and callStack (when frames are present).
  */
 export declare function formatRillErrorJson(error: RillError, options?: FormatErrorJsonOptions): string;
-//# sourceMappingURL=error-formatter.d.ts.map

package/dist/error-formatter.js

@@ -274,4 +274,3 @@ function appendCallStack(parts, data, visibleFrames, sources, filePath) {
         }
     }
 }
-//# sourceMappingURL=error-formatter.js.map

package/dist/error-registry.d.ts

@@ -90,4 +90,3 @@ export declare function renderMessage(template: string, context: Record<string,
  * // Returns: ""
  */
 export declare function getHelpUrl(errorId: string, version: string): string;
-//# sourceMappingURL=error-registry.d.ts.map

package/dist/error-registry.js

@@ -336,6 +336,24 @@ const ERROR_DEFINITIONS = [
             },
         ],
     },
+    {
+        errorId: 'RILL-P014',
+        category: 'parse',
+        description: 'Malformed type argument list',
+        messageTemplate: '{details}',
+        cause: 'A type argument list has a syntax error: missing comma, closing paren, or invalid argument.',
+        resolution: 'Check the type argument list for missing commas or closing parentheses.',
+        examples: [
+            {
+                description: 'Missing comma between type arguments',
+                code: 'list(string number)  # Error: expected , or )',
+            },
+            {
+                description: 'Missing closing paren',
+                code: 'dict(key: string  # Error: expected )',
+            },
+        ],
+    },
     {
         errorId: 'RILL-P020',
         category: 'parse',
@@ -1093,6 +1111,20 @@ const ERROR_DEFINITIONS = [
             },
         ],
     },
+    {
+        errorId: 'RILL-R045',
+        category: 'runtime',
+        description: 'Too many arguments passed to callable',
+        messageTemplate: 'Expected {expected} args, got {actual}',
+        cause: 'The number of arguments passed to a callable exceeds the number of declared parameters.',
+        resolution: 'Remove the excess arguments or add more parameters to the callable definition.',
+        examples: [
+            {
+                description: 'Too many arguments to a two-param closure',
+                code: '|x: number, y: number| { x + y } -> app::call(1, 2, 3)  # 3 args, 2 params',
+            },
+        ],
+    },
     // Resolver errors (RILL-R050–RILL-R059)
     {
         errorId: 'RILL-R050',
@@ -1472,4 +1504,3 @@ export function getHelpUrl(errorId, version) {
     const anchor = errorId.toLowerCase();
     return `https://github.com/rcrsr/rill/blob/v${version}/docs/ref-errors.md#${anchor}`;
 }
-//# sourceMappingURL=error-registry.js.map

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,6 +29,5 @@ export interface CryptoConfig {
  * });
  * ```
  */
-export declare function createCryptoExtension(config?: CryptoConfig): ExtensionResult;
+export declare function createCryptoExtension(config?: CryptoConfig): ExtensionFactoryResult;
 export declare const extensionManifest: ExtensionManifest;
-//# sourceMappingURL=index.d.ts.map

package/dist/ext/crypto/index.js

@@ -6,6 +6,7 @@
  */
 import crypto from 'node:crypto';
 import { RuntimeError } from '../../error-classes.js';
+import { toCallable } from '../../runtime/core/callable.js';
 import { rillTypeToTypeValue, } 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
@@ -56,8 +57,8 @@ export function createCryptoExtension(config = {}) {
      * IR-23
      */
     const hash = async (args) => {
-        const input = args[0];
-        const algorithm = args[1] ?? defaultAlgorithm;
+        const input = args['input'];
+        const algorithm = args['algorithm'] ?? defaultAlgorithm;
         // EC-27: Invalid algorithm
         validateAlgorithm(algorithm);
         const hashObject = crypto.createHash(algorithm);
@@ -73,8 +74,8 @@ export function createCryptoExtension(config = {}) {
         if (!hmacKey) {
             throw new RuntimeError('RILL-R004', 'hmacKey required for hmac() — set in config', undefined, {});
         }
-        const input = args[0];
-        const algorithm = args[1] ?? defaultAlgorithm;
+        const input = args['input'];
+        const algorithm = args['algorithm'] ?? defaultAlgorithm;
         // EC-27: Invalid algorithm
         validateAlgorithm(algorithm);
         const hmacObject = crypto.createHmac(algorithm, hmacKey);
@@ -93,71 +94,73 @@ export function createCryptoExtension(config = {}) {
      * IR-26
      */
     const random = async (args) => {
-        const bytes = args[0];
+        const bytes = args['bytes'];
         return crypto.randomBytes(bytes).toString('hex');
     };
     // ============================================================
     // 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: rillTypeToTypeValue({ 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: rillTypeToTypeValue({ kind: 'string' }),
+            }),
+            uuid: toCallable({
+                params: [],
+                fn: uuid,
+                annotations: { description: 'Generate random UUID v4' },
+                returnType: rillTypeToTypeValue({ 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: rillTypeToTypeValue({ kind: 'string' }),
+            }),
         },
     };
 }
@@ -168,4 +171,3 @@ export const extensionManifest = {
     factory: createCryptoExtension,
     configSchema,
 };
-//# sourceMappingURL=index.js.map

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,6 +42,5 @@ export type { CommandConfig };
  * });
  * ```
  */
-export declare function createExecExtension(config: ExecConfig): ExtensionResult;
+export declare function createExecExtension(config: ExecConfig): ExtensionFactoryResult;
 export declare const extensionManifest: ExtensionManifest;
-//# sourceMappingURL=index.d.ts.map

package/dist/ext/exec/index.js

@@ -4,6 +4,7 @@
  * Provides sandboxed command execution via allowlist/blocklist security controls.
  * Each declared command becomes a function with argument validation and process isolation.
  */
+import { toCallable } from '../../runtime/core/callable.js';
 import { rillTypeToTypeValue, } from '../../runtime/core/values.js';
 import { runCommand, } from './runner.js';
 // ============================================================
@@ -23,7 +24,7 @@ export const configSchema = {
  * 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
@@ -80,9 +81,9 @@ export function createExecExtension(config) {
     for (const [commandName, commandConfig] of Object.entries(config.commands)) {
         // Create function for this command
         const commandFn = async (args) => {
-            // Extract args and stdin from RillValue array
-            const argsParam = args[0] ?? [];
-            const stdinParam = args[1];
+            // Extract args and stdin from named arg map
+            const argsParam = args['args'] ?? [];
+            const stdinParam = args['stdin'];
             // Convert args to string array
             const stringArgs = argsParam.map((arg) => String(arg));
             // Create abort controller for this execution
@@ -118,13 +119,13 @@ export function createExecExtension(config) {
             params: [
                 {
                     name: 'args',
-                    type: { type: 'list' },
+                    type: { kind: 'list' },
                     defaultValue: [],
                     annotations: { description: 'Command arguments' },
                 },
                 {
                     name: 'stdin',
-                    type: { type: 'string' },
+                    type: { kind: 'string' },
                     defaultValue: '',
                     annotations: { description: 'Standard input data' },
                 },
@@ -133,7 +134,7 @@ export function createExecExtension(config) {
             annotations: {
                 description: commandConfig.description ?? `Execute ${commandName} command`,
             },
-            returnType: rillTypeToTypeValue({ type: 'dict' }),
+            returnType: rillTypeToTypeValue({ kind: 'dict' }),
         };
     }
     // ============================================================
@@ -153,7 +154,7 @@ export function createExecExtension(config) {
         params: [],
         fn: commands,
         annotations: { description: 'List all configured commands' },
-        returnType: rillTypeToTypeValue({ type: 'list' }),
+        returnType: rillTypeToTypeValue({ kind: 'list' }),
     };
     // ============================================================
     // DISPOSE FUNCTION
@@ -169,9 +170,14 @@ export function createExecExtension(config) {
     // ============================================================
     // EXTENSION RESULT
     // ============================================================
-    const result = functions;
-    result.dispose = dispose;
-    return result;
+    const callableDict = {};
+    for (const [name, def] of Object.entries(functions)) {
+        callableDict[name] = toCallable(def);
+    }
+    return {
+        value: callableDict,
+        dispose,
+    };
 }
 // ============================================================
 // MANIFEST
@@ -180,4 +186,3 @@ export const extensionManifest = {
     factory: createExecExtension,
     configSchema,
 };
-//# sourceMappingURL=index.js.map

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

@@ -59,4 +59,3 @@ export interface CommandResult {
  * ```
  */
 export declare function runCommand(commandName: string, config: CommandConfig, args: readonly string[], stdinData?: string | undefined, signal?: AbortSignal | undefined): Promise<CommandResult>;
-//# sourceMappingURL=runner.d.ts.map

package/dist/ext/exec/runner.js

@@ -165,4 +165,3 @@ export async function runCommand(commandName, config, args, stdinData, signal) {
         throw err;
     }
 }
-//# sourceMappingURL=runner.js.map

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

@@ -5,7 +5,7 @@
  * Scripts call endpoints with positional args or single dict argument.
  * All URLs are constructed from config - scripts cannot specify arbitrary URLs.
  */
-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;
 /** Parameter definition for endpoint */
 export interface EndpointParam {
@@ -46,7 +46,7 @@ export interface FetchConfig {
  * All URLs constructed from config - scripts cannot create arbitrary URLs.
  *
  * @param config - Fetch configuration with endpoints
- * @returns ExtensionResult with endpoint functions and introspection
+ * @returns ExtensionFactoryResult with endpoint functions and introspection
  * @throws Error on invalid configuration
  *
  * @example
@@ -65,6 +65,5 @@ export interface FetchConfig {
  * });
  * ```
  */
-export declare function createFetchExtension(config: FetchConfig): ExtensionResult;
+export declare function createFetchExtension(config: FetchConfig): ExtensionFactoryResult;
 export declare const extensionManifest: ExtensionManifest;
-//# sourceMappingURL=index.d.ts.map