@pikku/core 0.12.71 → 0.12.74

package/dist/wirings/cli/cli.types.d.ts

@@ -1,6 +1,6 @@
 import type { CorePikkuMiddleware, CoreSingletonServices, CoreUserSession, CoreServices, MiddlewareMetadata } from '../../types/core.types.js';
 import type { CorePikkuFunctionConfig, CorePikkuPermission, CorePikkuFunction, CorePikkuFunctionSessionless } from '../../function/functions.types.js';
-import type { PikkuChannel } from '../channel/channel.types.js';
+import type { ChannelRemote, PikkuChannel } from '../channel/channel.types.js';
 /**
  * CLI option definition
  */
@@ -29,11 +29,11 @@ export interface CLIPositional {
 /**
  * CLI wire context
  */
-export type PikkuCLI = {
+export type PikkuCLI<Remote extends (...args: any[]) => any = ChannelRemote> = {
     program: string;
     command: string[];
     data: Record<string, any>;
-    channel: PikkuChannel<unknown, unknown>;
+    channel: PikkuChannel<unknown, unknown, Remote>;
 };
 /**
  * Runtime CLI program state
@@ -72,6 +72,12 @@ export type CLIProgramMeta = {
     commands: Record<string, CLICommandMeta>;
     options: Record<string, CLIOption>;
     defaultRenderName?: string;
+    /**
+     * Whether the channel serving this program over a websocket requires a
+     * session. Only meaningful for the generated channel backend — a locally
+     * executed CLI has no connection to authenticate.
+     */
+    auth?: boolean;
 };
 /**
  * Renderer metadata for CLI commands
@@ -195,6 +201,11 @@ export interface CoreCLI<Commands extends Record<string, CoreCLICommandConfig<an
     summary?: string;
     errors?: string[];
     tags?: string[];
+    /**
+     * Requires a session on the websocket serving this program remotely. Has no
+     * effect on local execution, where there is no connection to authenticate.
+     */
+    auth?: boolean;
 }
 /**
  * Generic renderer type that can transform data into any output format.

package/dist/wirings/cli/command-parser.d.ts

@@ -1,21 +1,12 @@
 import type { CLIMeta } from './cli.types.js';
-/**
- * Result of parsing CLI arguments
- */
 export interface ParsedCommand {
     program: string;
     commandPath: string[];
     positionals: Record<string, any>;
     options: Record<string, any>;
     errors: string[];
-    /** Non-fatal diagnostics (e.g. unknown options that were accepted+ignored) */
+    /** Non-fatal: the command still runs. */
     warnings: string[];
 }
-/**
- * Parses raw CLI arguments into structured data for a specific program
- */
 export declare function parseCLIArguments(args: string[], programName: string, allMeta: CLIMeta): ParsedCommand;
-/**
- * Generates help text for a command in a specific program
- */
 export declare function generateCommandHelp(programName: string, allMeta: CLIMeta, commandPath?: string[]): string;

package/dist/wirings/cli/command-parser.js

@@ -1,17 +1,13 @@
-/** Convert kebab-case to camelCase: "from-plan" → "fromPlan" */
+/** "from-plan" → "fromPlan"; the parser accepts either spelling. */
 function toCamelCase(str) {
     return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
 }
-/** Convert camelCase to kebab-case for display: "autoApply" → "auto-apply".
- *  Flags are stored camelCase (matching the function input field) but shown
- *  kebab; the parser accepts both forms via toCamelCase. */
 function toKebabCase(str) {
     return str.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();
 }
 /** Options the runner handles itself — never reported as unknown. */
 const RESERVED_OPTIONS = new Set(['help']);
-/** Levenshtein distance, capped-free and dependency-free. Used only to suggest
- *  a near-miss option name, so the naive O(n*m) implementation is fine. */
+/** Naive O(n*m); only ever used to suggest a near-miss option name. */
 function levenshtein(a, b) {
     if (a === b)
         return 0;
@@ -30,8 +26,7 @@ function levenshtein(a, b) {
     }
     return prev[b.length];
 }
-/** Finds the closest declared option (distance <= 2) to what the user typed.
- *  Compares against the kebab-case rendering, since that is what is typed. */
+/** Returns null beyond a distance of 2. */
 function suggestOption(typed, availableOptions) {
     let best = null;
     let bestDistance = 3;
@@ -45,9 +40,7 @@ function suggestOption(typed, availableOptions) {
     }
     return best;
 }
-/** Records a warning that an unknown long option was accepted but ignored.
- *  Unknown options stay non-fatal for forward compatibility (a newer command
- *  version may understand them) — they are just no longer silent. */
+// knowledge: decisions/internals/cli-unknown-long-options-warn-instead-of-failing.md
 function warnUnknownOption(typed, availableOptions, result) {
     if (RESERVED_OPTIONS.has(toCamelCase(typed))) {
         return;
@@ -56,9 +49,6 @@ function warnUnknownOption(typed, availableOptions, result) {
     result.warnings.push(`Unknown option: --${typed} (ignored)` +
         (suggestion ? ` Did you mean --${suggestion}?` : ''));
 }
-/**
- * Parses raw CLI arguments into structured data for a specific program
- */
 export function parseCLIArguments(args, programName, allMeta) {
     const result = {
         program: programName,
@@ -75,10 +65,8 @@ export function parseCLIArguments(args, programName, allMeta) {
     }
     let currentIndex = 0;
     let currentMeta = meta;
-    // Parse command path (non-flag arguments at the beginning)
     while (currentIndex < args.length && !args[currentIndex].startsWith('-')) {
         const arg = args[currentIndex];
-        // Check if this is a known subcommand
         if (currentMeta.commands && currentMeta.commands[arg]) {
             result.commandPath.push(arg);
             currentMeta = {
@@ -93,12 +81,10 @@ export function parseCLIArguments(args, programName, allMeta) {
             currentIndex++;
         }
         else {
-            // Not a subcommand, must be a positional argument
             break;
         }
     }
-    // If no command was parsed, check for a default command
-    // Only use default if user didn't provide any non-flag arguments
+    // A default command only applies when the user named no command at all.
     const hasNonFlagArgs = args.some((arg, idx) => idx >= currentIndex && !arg.startsWith('-'));
     if (result.commandPath.length === 0 && meta.commands && !hasNonFlagArgs) {
         for (const [name, cmd] of Object.entries(meta.commands)) {
@@ -117,10 +103,8 @@ export function parseCLIArguments(args, programName, allMeta) {
             }
         }
     }
-    // Get the final command metadata
     const commandMeta = getCommandMeta(meta, result.commandPath);
     if (!commandMeta) {
-        // If we have no command path but there are non-flag args, the first arg is likely an unknown command
         if (result.commandPath.length === 0 &&
             hasNonFlagArgs &&
             args.length > 0 &&
@@ -132,41 +116,32 @@ export function parseCLIArguments(args, programName, allMeta) {
         }
         return result;
     }
-    // A group/parent command — has subcommands but no runnable function of its
-    // own — cannot be executed directly. Surface a routable error so the runner
-    // shows its subcommand help instead of attempting to run a missing function.
+    // knowledge: decisions/internals/cli-parse-errors-are-routed-by-message-prefix.md
     if (!commandMeta.pikkuFuncId &&
         commandMeta.subcommands &&
         Object.keys(commandMeta.subcommands).length > 0) {
         result.errors.push(`Missing subcommand: ${result.commandPath.join(' ')}`);
         return result;
     }
-    // Collect all available options (global + inherited)
     const availableOptions = collectAvailableOptions(meta, result.commandPath);
-    // Parse remaining arguments as positionals and options
     const positionalArgs = [];
     const optionArgs = {};
     while (currentIndex < args.length) {
         const arg = args[currentIndex];
         if (arg.startsWith('--')) {
-            // Long option (--from-plan → fromPlan)
             const negatedKey = arg.startsWith('--no-')
                 ? toCamelCase(arg.slice(5))
                 : undefined;
             const equalIndex = arg.indexOf('=');
             if (negatedKey &&
                 typeof availableOptions[negatedKey]?.default === 'boolean') {
-                // --no-<flag> turns a boolean option off. Only options that declare a
-                // boolean default can be negated, so a literal `--no-something` option
-                // name still parses as itself.
+                // Requiring a boolean default keeps a literal `--no-something` option
+                // name parsing as itself rather than as a negation.
                 optionArgs[negatedKey] = false;
             }
             else if (equalIndex > 0) {
-                // --option=value format
                 const key = toCamelCase(arg.slice(2, equalIndex));
                 const optionDef = availableOptions[key];
-                // Unknown options are allowed for forward compatibility, but warned
-                // about so they are not silently dropped by the input schema.
                 if (!optionDef) {
                     warnUnknownOption(arg.slice(2, equalIndex), availableOptions, result);
                 }
@@ -174,16 +149,12 @@ export function parseCLIArguments(args, programName, allMeta) {
                 optionArgs[key] = parseOptionValue(value, optionDef);
             }
             else {
-                // --option value format
                 const key = toCamelCase(arg.slice(2));
                 const optionDef = availableOptions[key];
-                // Unknown options are allowed for forward compatibility, but warned
-                // about so they are not silently dropped by the input schema.
                 if (!optionDef) {
                     warnUnknownOption(arg.slice(2), availableOptions, result);
                 }
                 if (optionDef && optionDef.array) {
-                    // Array option - collect all following non-flag values
                     currentIndex++;
                     const values = [];
                     while (currentIndex < args.length &&
@@ -196,24 +167,20 @@ export function parseCLIArguments(args, programName, allMeta) {
                 }
                 else if (currentIndex + 1 < args.length &&
                     !args[currentIndex + 1].startsWith('-')) {
-                    // Next arg is the value
                     currentIndex++;
                     optionArgs[key] = parseOptionValue(args[currentIndex], optionDef);
                 }
                 else {
-                    // Boolean flag
                     optionArgs[key] = true;
                 }
             }
         }
         else if (arg.startsWith('-') && arg.length > 1) {
-            // Short option(s)
             for (let i = 1; i < arg.length; i++) {
                 const shortFlag = arg[i];
-                // Find the corresponding long option
                 const longOption = findLongOption(shortFlag, availableOptions);
                 if (longOption) {
-                    // Check if this is the last character and there's a value
+                    // Only the last flag in a cluster can take a value.
                     if (i === arg.length - 1 &&
                         currentIndex + 1 < args.length &&
                         !args[currentIndex + 1].startsWith('-')) {
@@ -221,7 +188,6 @@ export function parseCLIArguments(args, programName, allMeta) {
                         optionArgs[longOption] = parseOptionValue(args[currentIndex], availableOptions[longOption]);
                     }
                     else {
-                        // Boolean flag
                         optionArgs[longOption] = true;
                     }
                 }
@@ -231,21 +197,15 @@ export function parseCLIArguments(args, programName, allMeta) {
             }
         }
         else {
-            // Positional argument
             positionalArgs.push(arg);
         }
         currentIndex++;
     }
-    // Map positional arguments to named parameters
     mapPositionalArguments(commandMeta.positionals, positionalArgs, result);
-    // Apply option defaults and validation
     applyOptionDefaults(availableOptions, optionArgs, result);
     result.options = optionArgs;
     return result;
 }
-/**
- * Gets the command metadata for a given path
- */
 function getCommandMeta(meta, path) {
     if (path.length === 0) {
         return null;
@@ -262,15 +222,11 @@ function getCommandMeta(meta, path) {
     }
     return current;
 }
-/**
- * Collects all available options through the inheritance chain
- */
 function collectAvailableOptions(meta, path) {
     let options = { ...meta.options };
     if (path.length === 0) {
         return options;
     }
-    // Walk through the command path, merging options
     let current = meta.commands[path[0]];
     if (current) {
         options = { ...options, ...current.options };
@@ -283,9 +239,6 @@ function collectAvailableOptions(meta, path) {
     }
     return options;
 }
-/**
- * Finds the long option name for a short flag
- */
 function findLongOption(shortFlag, options) {
     for (const [name, option] of Object.entries(options)) {
         if (option.short === shortFlag) {
@@ -294,12 +247,8 @@ function findLongOption(shortFlag, options) {
     }
     return null;
 }
-/**
- * Parses an option value based on its definition
- */
 function parseOptionValue(value, optionDef) {
     if (!optionDef) {
-        // No definition, try to infer type
         if (value === 'true')
             return true;
         if (value === 'false')
@@ -310,7 +259,6 @@ function parseOptionValue(value, optionDef) {
             return parseFloat(value);
         return value;
     }
-    // Use default type from option definition
     const defaultValue = optionDef.default;
     if (typeof defaultValue === 'boolean') {
         return value === 'true' || value === '1' || value === 'yes';
@@ -318,21 +266,16 @@ function parseOptionValue(value, optionDef) {
     if (typeof defaultValue === 'number') {
         return parseFloat(value);
     }
-    // Check choices
     if (optionDef.choices && !optionDef.choices.includes(value)) {
-        // Invalid choice, but return anyway (validation will catch it)
+        // Deliberately not an error here — applyOptionDefaults reports bad choices.
         return value;
     }
     return value;
 }
-/**
- * Maps positional arguments to named parameters
- */
 function mapPositionalArguments(positionalDefs, args, result) {
     let argIndex = 0;
     for (const def of positionalDefs) {
         if (def.variadic) {
-            // Collect all remaining arguments
             if (argIndex < args.length) {
                 result.positionals[def.name] = args.slice(argIndex);
                 argIndex = args.length;
@@ -345,7 +288,6 @@ function mapPositionalArguments(positionalDefs, args, result) {
             }
         }
         else {
-            // Single argument
             if (argIndex < args.length) {
                 result.positionals[def.name] = args[argIndex];
                 argIndex++;
@@ -355,25 +297,18 @@ function mapPositionalArguments(positionalDefs, args, result) {
             }
         }
     }
-    // Check for extra positional arguments
     if (argIndex < args.length) {
         result.errors.push(`Unexpected arguments: ${args.slice(argIndex).join(' ')}`);
     }
 }
-/**
- * Applies option defaults and validates choices
- */
 function applyOptionDefaults(optionDefs, options, result) {
     for (const [name, def] of Object.entries(optionDefs)) {
-        // Apply default if not provided
         if (!(name in options) && def.default !== undefined) {
             options[name] = def.default;
         }
-        // Check required
         if (def.required && !(name in options)) {
             result.errors.push(`Missing required option: --${toKebabCase(name)}`);
         }
-        // Validate choices
         if (def.choices && name in options) {
             const value = options[name];
             if (Array.isArray(value)) {
@@ -389,9 +324,6 @@ function applyOptionDefaults(optionDefs, options, result) {
         }
     }
 }
-/**
- * Generates help text for a command in a specific program
- */
 export function generateCommandHelp(programName, allMeta, commandPath = []) {
     const lines = [];
     const meta = allMeta.programs[programName];
@@ -399,7 +331,6 @@ export function generateCommandHelp(programName, allMeta, commandPath = []) {
         return `Program not found: ${programName}`;
     }
     if (commandPath.length === 0) {
-        // Root help for the program
         lines.push(`Usage: ${programName} <command> [options]`);
         lines.push('');
         lines.push('Commands:');
@@ -415,12 +346,10 @@ export function generateCommandHelp(programName, allMeta, commandPath = []) {
         }
     }
     else {
-        // Command-specific help
         const commandMeta = getCommandMeta(meta, commandPath);
         if (!commandMeta) {
             return `Unknown command: ${commandPath.join(' ')}`;
         }
-        // Usage line
         let usage = `${programName} ${commandPath.join(' ')}`;
         if (commandMeta.parameters) {
             usage += ' ' + commandMeta.parameters;
@@ -430,7 +359,6 @@ export function generateCommandHelp(programName, allMeta, commandPath = []) {
             lines.push('');
             lines.push(commandMeta.description);
         }
-        // Positional arguments
         if (commandMeta.positionals.length > 0) {
             lines.push('');
             lines.push('Arguments:');
@@ -440,7 +368,6 @@ export function generateCommandHelp(programName, allMeta, commandPath = []) {
                 lines.push(`  ${pos.name}${variadic} ${marker}`);
             }
         }
-        // Subcommands
         if (commandMeta.subcommands &&
             Object.keys(commandMeta.subcommands).length > 0) {
             lines.push('');
@@ -450,7 +377,6 @@ export function generateCommandHelp(programName, allMeta, commandPath = []) {
                 lines.push(`  ${name.padEnd(20)} ${desc}`);
             }
         }
-        // Options
         const availableOptions = collectAvailableOptions(meta, commandPath);
         if (Object.keys(availableOptions).length > 0) {
             lines.push('');
@@ -460,9 +386,6 @@ export function generateCommandHelp(programName, allMeta, commandPath = []) {
     }
     return lines.join('\n');
 }
-/**
- * Formats options for help text
- */
 function formatOptions(options, lines) {
     for (const [name, opt] of Object.entries(options)) {
         let line = '  ';

package/dist/wirings/cli/define-cli-commands.d.ts

@@ -1,19 +1,3 @@
 import type { CoreCLICommandConfig } from './cli.types.js';
-/**
- * Type-safe helper for defining CLI commands that can be composed.
- * Returns the commands record as-is (identity function) for use with `wireCLI`.
- *
- * @example
- * ```typescript
- * export const chatCommands = defineCLICommands({
- *   chat: pikkuCLICommand({ func: chatFunc }),
- *   'chat:history': pikkuCLICommand({ func: historyFunc }),
- * })
- *
- * wireCLI({
- *   program: 'my-app',
- *   commands: { ...chatCommands, other: pikkuCLICommand({ func: otherFunc }) }
- * })
- * ```
- */
+/** Identity at runtime; exists so a commands record can be typed and composed before `wireCLI`. */
 export declare function defineCLICommands<T extends Record<string, CoreCLICommandConfig<any, any, any, any>>>(commands: T): T;

package/dist/wirings/cli/define-cli-commands.js

@@ -1,20 +1,4 @@
-/**
- * Type-safe helper for defining CLI commands that can be composed.
- * Returns the commands record as-is (identity function) for use with `wireCLI`.
- *
- * @example
- * ```typescript
- * export const chatCommands = defineCLICommands({
- *   chat: pikkuCLICommand({ func: chatFunc }),
- *   'chat:history': pikkuCLICommand({ func: historyFunc }),
- * })
- *
- * wireCLI({
- *   program: 'my-app',
- *   commands: { ...chatCommands, other: pikkuCLICommand({ func: otherFunc }) }
- * })
- * ```
- */
+/** Identity at runtime; exists so a commands record can be typed and composed before `wireCLI`. */
 export function defineCLICommands(commands) {
     return commands;
 }

package/dist/wirings/credential/credential.types.d.ts

@@ -5,12 +5,6 @@ export type CoreCredential<T = unknown> = {
     description?: string;
     type: 'singleton' | 'wire';
     schema: T;
-    /**
-     * Link to documentation explaining how to obtain this value — a provider's
-     * API-key page, a setup guide, an internal runbook. Surfaced by consoles and
-     * deploy UIs so a user facing a missing value has somewhere to go instead of
-     * an opaque identifier.
-     */
     docsUrl?: string;
     oauth2?: OAuth2CredentialConfig & {
         appCredentialSecretId: string;
@@ -22,12 +16,6 @@ export type CredentialDefinitionMeta = {
     description?: string;
     type: 'singleton' | 'wire';
     schema?: Record<string, unknown> | string;
-    /**
-     * Link to documentation explaining how to obtain this value — a provider's
-     * API-key page, a setup guide, an internal runbook. Surfaced by consoles and
-     * deploy UIs so a user facing a missing value has somewhere to go instead of
-     * an opaque identifier.
-     */
     docsUrl?: string;
     oauth2?: OAuth2CredentialConfig & {
         appCredentialSecretId: string;

package/dist/wirings/credential/define-credential.d.ts

@@ -0,0 +1,48 @@
+import type { CoreCredential } from './credential.types.js';
+/**
+ * Declares a credential. The body is a no-op that tree-shakes away — the CLI
+ * reads the call by AST, so the declaration must be a top-level literal.
+ * `type: 'wire'` is per-user, `type: 'singleton'` is platform-wide.
+ *
+ * @example
+ * ```typescript
+ * // Per-user API key
+ * defineCredential({
+ *   name: 'stripe',
+ *   displayName: 'Stripe API Key',
+ *   type: 'wire',
+ *   schema: z.object({ apiKey: z.string() }),
+ * })
+ *
+ * // Per-user OAuth
+ * defineCredential({
+ *   name: 'google-sheets',
+ *   displayName: 'Google Sheets',
+ *   type: 'wire',
+ *   schema: z.object({ accessToken: z.string(), refreshToken: z.string() }),
+ *   oauth2: {
+ *     appCredentialSecretId: 'GOOGLE_OAUTH_APP',
+ *     authorizationUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+ *     tokenUrl: 'https://oauth2.googleapis.com/token',
+ *     scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+ *     tokenSecretId: 'GOOGLE_OAUTH_TOKENS',
+ *   }
+ * })
+ *
+ * // Platform-level OAuth (singleton)
+ * defineCredential({
+ *   name: 'slack',
+ *   displayName: 'Slack',
+ *   type: 'singleton',
+ *   schema: z.object({ accessToken: z.string(), refreshToken: z.string() }),
+ *   oauth2: {
+ *     appCredentialSecretId: 'SLACK_OAUTH_APP',
+ *     authorizationUrl: 'https://slack.com/oauth/v2/authorize',
+ *     tokenUrl: 'https://slack.com/api/oauth.v2.access',
+ *     scopes: ['chat:write', 'channels:read'],
+ *     tokenSecretId: 'SLACK_OAUTH_TOKENS',
+ *   }
+ * })
+ * ```
+ */
+export declare const defineCredential: <T>(_config: CoreCredential<T>) => void;

package/dist/wirings/credential/define-credential.js

@@ -0,0 +1,47 @@
+/**
+ * Declares a credential. The body is a no-op that tree-shakes away — the CLI
+ * reads the call by AST, so the declaration must be a top-level literal.
+ * `type: 'wire'` is per-user, `type: 'singleton'` is platform-wide.
+ *
+ * @example
+ * ```typescript
+ * // Per-user API key
+ * defineCredential({
+ *   name: 'stripe',
+ *   displayName: 'Stripe API Key',
+ *   type: 'wire',
+ *   schema: z.object({ apiKey: z.string() }),
+ * })
+ *
+ * // Per-user OAuth
+ * defineCredential({
+ *   name: 'google-sheets',
+ *   displayName: 'Google Sheets',
+ *   type: 'wire',
+ *   schema: z.object({ accessToken: z.string(), refreshToken: z.string() }),
+ *   oauth2: {
+ *     appCredentialSecretId: 'GOOGLE_OAUTH_APP',
+ *     authorizationUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+ *     tokenUrl: 'https://oauth2.googleapis.com/token',
+ *     scopes: ['https://www.googleapis.com/auth/spreadsheets'],
+ *     tokenSecretId: 'GOOGLE_OAUTH_TOKENS',
+ *   }
+ * })
+ *
+ * // Platform-level OAuth (singleton)
+ * defineCredential({
+ *   name: 'slack',
+ *   displayName: 'Slack',
+ *   type: 'singleton',
+ *   schema: z.object({ accessToken: z.string(), refreshToken: z.string() }),
+ *   oauth2: {
+ *     appCredentialSecretId: 'SLACK_OAUTH_APP',
+ *     authorizationUrl: 'https://slack.com/oauth/v2/authorize',
+ *     tokenUrl: 'https://slack.com/api/oauth.v2.access',
+ *     scopes: ['chat:write', 'channels:read'],
+ *     tokenSecretId: 'SLACK_OAUTH_TOKENS',
+ *   }
+ * })
+ * ```
+ */
+export const defineCredential = (_config) => { };

package/dist/wirings/credential/index.d.ts

@@ -1,3 +1,3 @@
-export { wireCredential } from './wire-credential.js';
+export { defineCredential } from './define-credential.js';
 export { validateAndBuildCredentialDefinitionsMeta } from './validate-credential-definitions.js';
 export type { CoreCredential, CredentialDefinitionMeta, CredentialDefinitionsMeta, CredentialDefinitions, } from './credential.types.js';

package/dist/wirings/credential/index.js

@@ -1,2 +1,2 @@
-export { wireCredential } from './wire-credential.js';
+export { defineCredential } from './define-credential.js';
 export { validateAndBuildCredentialDefinitionsMeta } from './validate-credential-definitions.js';

package/dist/wirings/credential/validate-credential-definitions.d.ts

@@ -1,6 +1,4 @@
 import type { CredentialDefinitions, CredentialDefinitionsMeta } from './credential.types.js';
-export interface SchemaRefLike {
-    variableName: string;
-    sourceFile: string;
-}
+import type { SchemaRefLike } from '../../types/core.types.js';
+export type { SchemaRefLike };
 export declare function validateAndBuildCredentialDefinitionsMeta(definitions: CredentialDefinitions, schemaLookup: Map<string, SchemaRefLike>): CredentialDefinitionsMeta;

package/dist/wirings/gateway/gateway-runner.d.ts

@@ -1,25 +1,6 @@
 import type { CoreGateway, GatewayAdapter } from './gateway.types.js';
 export declare const resolveGatewayAdapter: (config: CoreGateway, services: CoreSingletonServices) => Promise<GatewayAdapter>;
 import type { CoreSingletonServices } from '../../types/core.types.js';
-/**
- * Register a messaging gateway.
- *
- * `wireGateway` is a meta-wiring that composes existing primitives
- * (`wireHTTP`, `wireChannel`) under the hood.  It does not replace them;
- * it layers on top.
- *
- * @param config - Gateway configuration (name, type, adapter, func, middleware, etc.)
- */
 export declare const wireGateway: (config: CoreGateway) => void;
-/**
- * Create the message handler callback for a listener gateway.
- *
- * Returns a function `(rawData: unknown) => Promise<void>` that can be
- * passed to `adapter.init()`.  Used by `LocalGatewayService` (and any
- * other GatewayService implementation) to wire up listener gateways.
- *
- * @param name   - Gateway name (for wire.gateway metadata)
- * @param config - The gateway configuration (adapter, func, middleware)
- * @param singletonServices - Singleton services to pass to handler/middleware
- */
+/** The returned callback is what a GatewayService passes to `adapter.init()`. */
 export declare const createListenerMessageHandler: (name: string, config: CoreGateway, singletonServices: CoreSingletonServices) => ((rawData: unknown) => Promise<void>);