@db3.ai/app 0.1.0-beta.1

package/dist/cache/drivers/createCacheDriver.js

@@ -0,0 +1,147 @@
+import { createKeyv as createMemoryStore } from 'cacheable';
+import { createCache } from 'cache-manager';
+import { createKeyv as createRedisStore } from '@keyv/redis';
+import { CacheManagerDriver } from './CacheManagerDriver.js';
+const defaultMemoryStore = {
+    driver: 'memory',
+    maxEntries: 1000,
+};
+/**
+ * Creates the concrete cache driver selected by named application config.
+ *
+ * @param options - Named store configuration from `config.cache`.
+ * @returns Cache Manager driver using the selected memory or Redis store.
+ */
+export function createCacheDriver(options = {}) {
+    const storeName = nonEmptyString(options.default ?? 'memory', 'Cache default store');
+    const stores = options.stores ?? {
+        memory: defaultMemoryStore,
+    };
+    const store = stores[storeName];
+    if (!store) {
+        throw new Error(`Cache store "${storeName}" is not configured.`);
+    }
+    switch (store.driver) {
+        case 'memory':
+            return memoryCacheDriver(store);
+        case 'redis':
+            return redisCacheDriver(store);
+        default:
+            return unsupportedCacheDriver(store);
+    }
+}
+/**
+ * Creates a bounded CacheableMemory store behind Cache Manager.
+ *
+ * @param options - Memory TTL, LRU bound, and clone configuration.
+ * @returns Cache Manager driver using an in-process store.
+ */
+function memoryCacheDriver(options) {
+    const ttl = optionalPositiveNumber(options.ttl, 'Memory cache TTL');
+    const maxEntries = positiveInteger(options.maxEntries ?? defaultMemoryStore.maxEntries, 'Memory cache maxEntries');
+    const store = createMemoryStore({
+        ttl,
+        lruSize: maxEntries,
+        useClone: options.clone,
+    });
+    store.on('error', ignoreStoreError);
+    return new CacheManagerDriver(createCache({
+        stores: [store],
+        ttl,
+    }));
+}
+/**
+ * Creates a namespaced Redis Keyv store behind Cache Manager.
+ *
+ * `noNamespaceAffectsAll` remains false so a cache clear never becomes a broad
+ * Redis database flush.
+ *
+ * @param options - Redis connection, namespace, TTL, and failure configuration.
+ * @returns Cache Manager driver using the official Redis adapter.
+ */
+function redisCacheDriver(options) {
+    const url = nonEmptyString(options.url, 'Redis cache URL');
+    const namespace = nonEmptyString(options.namespace, 'Redis cache namespace');
+    const ttl = optionalPositiveNumber(options.ttl, 'Redis cache TTL');
+    const connectionTimeout = optionalPositiveNumber(options.connectionTimeoutMs, 'Redis cache connectionTimeoutMs');
+    const clearBatchSize = options.clearBatchSize === undefined
+        ? undefined
+        : positiveInteger(options.clearBatchSize, 'Redis cache clearBatchSize');
+    const store = createRedisStore(url, {
+        namespace,
+        keyPrefixSeparator: ':',
+        connectionTimeout,
+        clearBatchSize,
+        noNamespaceAffectsAll: false,
+        throwOnConnectError: options.throwOnConnectError,
+        throwOnErrors: options.throwOnErrors,
+        useUnlink: true,
+    });
+    store.on('error', ignoreStoreError);
+    return new CacheManagerDriver(createCache({
+        stores: [store],
+        ttl,
+    }));
+}
+/**
+ * Produces an exhaustive runtime error for config values outside the public union.
+ *
+ * @param store - Invalid store configuration received from untyped runtime config.
+ * @returns Never because unsupported drivers cannot be created.
+ */
+function unsupportedCacheDriver(store) {
+    const driver = store.driver;
+    throw new Error(`Unsupported cache driver "${String(driver)}".`);
+}
+/**
+ * Prevents storage-adapter EventEmitter errors from terminating the process.
+ *
+ * Cache operations still follow Cache Manager's own resolve/reject semantics.
+ *
+ * @param _error - Adapter error governed by the selected store's failure options.
+ */
+function ignoreStoreError(_error) { }
+/**
+ * Validates a required non-empty string config value.
+ *
+ * @param value - Candidate config value.
+ * @param label - Human-readable option name.
+ * @returns Trimmed non-empty string.
+ */
+function nonEmptyString(value, label) {
+    const normalized = typeof value === 'string'
+        ? value.trim()
+        : '';
+    if (!normalized) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return normalized;
+}
+/**
+ * Validates an optional positive finite number.
+ *
+ * @param value - Candidate numeric config value.
+ * @param label - Human-readable option name.
+ * @returns Validated value or undefined when omitted.
+ */
+function optionalPositiveNumber(value, label) {
+    if (value === undefined)
+        return undefined;
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new Error(`${label} must be greater than zero.`);
+    }
+    return value;
+}
+/**
+ * Validates a positive integer config value.
+ *
+ * @param value - Candidate numeric config value.
+ * @param label - Human-readable option name.
+ * @returns Validated positive integer.
+ */
+function positiveInteger(value, label) {
+    if (!Number.isInteger(value) || Number(value) <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return Number(value);
+}

package/dist/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './contracts/index.js';
+export * from './Cache.js';

package/dist/cache/index.js

@@ -0,0 +1,2 @@
+export * from './contracts/index.js';
+export * from './Cache.js';

package/dist/cli/Cli.d.ts

@@ -0,0 +1,17 @@
+import type * as cli from './contracts/index.js';
+/** Validates and executes registered service commands with one owned app lifecycle. */
+export declare class Cli {
+    #private;
+    /**
+     * Registers explicit commands without booting an application or its services.
+     * @param config - App factory and service-owned command definitions.
+     * @param options - Root directory and output adapters.
+     */
+    constructor(config: cli.CliConfig, options?: cli.CliOptions);
+    /**
+     * Runs one invocation, printing help without app startup and closing a created app on failure too.
+     * @param argv - Arguments after the executable name.
+     * @returns Process-compatible exit status; this method never exits the process.
+     */
+    run(argv: readonly string[]): Promise<number>;
+}

package/dist/cli/Cli.js

@@ -0,0 +1,120 @@
+import { resolve } from 'node:path';
+/** Validates and executes registered service commands with one owned app lifecycle. */
+export class Cli {
+    #commands = new Map();
+    #config;
+    #directory;
+    #write;
+    #writeError;
+    /**
+     * Registers explicit commands without booting an application or its services.
+     * @param config - App factory and service-owned command definitions.
+     * @param options - Root directory and output adapters.
+     */
+    constructor(config, options = {}) {
+        if (!config || !Array.isArray(config.commands))
+            throw new Error('CLI configuration must export a commands array.');
+        if (config.createApp !== undefined && typeof config.createApp !== 'function')
+            throw new Error('CLI createApp must be a function.');
+        this.#config = config;
+        this.#directory = resolve(options.directory ?? process.cwd());
+        this.#write = options.write ?? console.log;
+        this.#writeError = options.writeError ?? console.error;
+        for (const command of config.commands) {
+            if (!command || !/^[a-z][a-z0-9]*(?::[a-z][a-z0-9-]*)*$/.test(command.name) || typeof command.description !== 'string' || typeof command.run !== 'function')
+                throw new Error('Invalid CLI command definition.');
+            if (this.#commands.has(command.name))
+                throw new Error(`Duplicate CLI command: ${command.name}`);
+            let optional = false;
+            for (const argument of command.arguments ?? []) {
+                if (!/^[a-zA-Z][a-zA-Z0-9-]*$/.test(argument.name) || (optional && argument.required))
+                    throw new Error(`Invalid argument declaration for ${command.name}.`);
+                if (!argument.required)
+                    optional = true;
+            }
+            this.#commands.set(command.name, command);
+        }
+    }
+    /**
+     * Runs one invocation, printing help without app startup and closing a created app on failure too.
+     * @param argv - Arguments after the executable name.
+     * @returns Process-compatible exit status; this method never exits the process.
+     */
+    async run(argv) {
+        if (argv.length === 0 || (argv.length === 1 && ['--help', '-h'].includes(argv[0]))) {
+            this.#write(['Usage: db3 <command> [arguments]', '', ...[...this.#commands.values()].map(command => `${usage(command)}\n  ${command.description}`)].join('\n'));
+            return 0;
+        }
+        const command = this.#commands.get(argv[0]);
+        if (!command) {
+            this.#writeError(`Unknown command: ${argv[0]}. Run db3 --help from your app root; service commands are registered in server/cli.config.ts.`);
+            return 1;
+        }
+        const args = argv.slice(1);
+        if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
+            this.#write(`${usage(command)}\n${command.description}`);
+            return 0;
+        }
+        const parameters = command.arguments ?? [];
+        if (args.some(value => value.startsWith('-')) || args.length < parameters.filter(argument => argument.required).length || args.length > parameters.length) {
+            this.#writeError(`Invalid arguments. Usage: ${usage(command)}`);
+            return 1;
+        }
+        let application;
+        let pendingApplication;
+        let status = 0;
+        let reportedError;
+        try {
+            const result = await command.run({
+                args, directory: this.#directory, write: this.#write,
+                /** Creates the invocation's app once, even when multiple callers await it. */
+                app: () => {
+                    pendingApplication ??= Promise.resolve().then(async () => {
+                        if (!this.#config.createApp)
+                            throw new Error('This command requires createApp in server/cli.config.ts.');
+                        application = await this.#config.createApp();
+                        return application;
+                    });
+                    return pendingApplication;
+                },
+            });
+            status = result ?? 0;
+            if (!Number.isInteger(status) || status < 0 || status > 255)
+                throw new Error(`Command ${command.name} returned an invalid exit status.`);
+        }
+        catch (error) {
+            reportedError = error;
+            this.#writeError(errorMessage(error));
+            status = 1;
+        }
+        finally {
+            // Finish pending startup before releasing resources, including failed commands.
+            try {
+                await pendingApplication;
+            }
+            catch (error) {
+                if (error !== reportedError)
+                    this.#writeError(errorMessage(error));
+                status = 1;
+            }
+            if (application) {
+                try {
+                    await application.close();
+                }
+                catch (error) {
+                    this.#writeError(`Application shutdown failed: ${errorMessage(error)}`);
+                    status = 1;
+                }
+            }
+        }
+        return status;
+    }
+}
+/** Formats command usage from its declared positional arguments. */
+function usage(command) {
+    return [`db3 ${command.name}`, ...(command.arguments ?? []).map(argument => argument.required ? `<${argument.name}>` : `[${argument.name}]`)].join(' ');
+}
+/** Produces a concise terminal error without dumping application objects or configuration. */
+function errorMessage(error) {
+    return error instanceof Error ? error.message : 'Command failed.';
+}

package/dist/cli/commands/repl.d.ts

@@ -0,0 +1,9 @@
+import type { CliCommand, CliOptions } from '../contracts/index.js';
+/**
+ * Registers the application REPL using the same module scope as app bootstrap.
+ *
+ * @param loadModels - Loads the conventional app model registry only when invoked.
+ * @param options - Terminal stream adapters for interactive or embedded callers.
+ * @returns Built-in command whose app lifecycle remains owned by the CLI runner.
+ */
+export declare function createReplCommand(loadModels: () => Promise<Record<string, unknown>>, options: CliOptions): CliCommand;

package/dist/cli/commands/repl.js

@@ -0,0 +1,27 @@
+import { runRepl } from '../runRepl.js';
+/**
+ * Registers the application REPL using the same module scope as app bootstrap.
+ *
+ * @param loadModels - Loads the conventional app model registry only when invoked.
+ * @param options - Terminal stream adapters for interactive or embedded callers.
+ * @returns Built-in command whose app lifecycle remains owned by the CLI runner.
+ */
+export function createReplCommand(loadModels, options) {
+    return {
+        name: 'repl', description: 'Explore the application and its models in an interactive terminal.',
+        /** Boots the app without an HTTP listener and keeps it alive until REPL exit. */
+        async run(context) {
+            const application = await context.app();
+            const models = await loadModels();
+            context.write('DB3 REPL. Use app(), models and model names. Type .exit or press Ctrl+D to quit.');
+            await runRepl({
+                input: options.input, output: options.output,
+                values: {
+                    ...models, models,
+                    /** Returns the invocation's live application service hub. */
+                    app: () => application,
+                },
+            });
+        },
+    };
+}

package/dist/cli/contracts/CliCommand.d.ts

@@ -0,0 +1,30 @@
+import type { App } from '../../server/index.js';
+/** One positional value accepted by a command, in declaration order. */
+export interface CliArgument {
+    /** Name displayed in command usage. */
+    name: string;
+    /** Whether omission is a usage error. Required arguments precede optional ones. */
+    required?: boolean;
+}
+/** Invocation state supplied by the runner to a service-owned command. */
+export interface CliCommandContext {
+    /** Validated positional values, excluding the command name. */
+    args: readonly string[];
+    /** Absolute application root used for app-owned source generation. */
+    directory: string;
+    /** Lazily creates one application, which the runner closes after execution. */
+    app(): Promise<App>;
+    /** Writes one user-facing output message. */
+    write(message: string): void;
+}
+/** A service or application command, backed by its existing programmatic operation. */
+export interface CliCommand {
+    /** Unique command name, for example db:migrate or queue:make-job. */
+    name: string;
+    /** Short explanation shown by db3 --help. */
+    description: string;
+    /** Positional argument declarations used for validation and help. */
+    arguments?: readonly CliArgument[];
+    /** Executes the operation; return a nonzero status for a reported failure. */
+    run(context: CliCommandContext): number | void | Promise<number | void>;
+}

package/dist/cli/contracts/CliCommand.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/contracts/CliConfig.d.ts

@@ -0,0 +1,9 @@
+import type { App } from '../../server/index.js';
+import type { CliCommand } from './CliCommand.js';
+/** App-owned command registration exported by server/cli.config.ts. */
+export interface CliConfig {
+    /** Creates the app only when a command requests it; do not start an HTTP listener. */
+    createApp?: () => App | Promise<App>;
+    /** Commands exposed by configured services or by the application itself. */
+    commands: readonly CliCommand[];
+}

package/dist/cli/contracts/CliConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/contracts/CliOptions.d.ts

@@ -0,0 +1,13 @@
+/** Process adapters shared by direct CLI execution and embedded command runners. */
+export interface CliOptions {
+    /** Application root. Defaults to the current working directory. */
+    directory?: string;
+    /** Interactive input used by `db3 repl`. Defaults to process.stdin. */
+    input?: NodeJS.ReadableStream;
+    /** Interactive output used by `db3 repl`. Defaults to process.stdout. */
+    output?: NodeJS.WritableStream;
+    /** Standard output adapter. Defaults to console.log. */
+    write?: (message: string) => void;
+    /** Error output adapter. Defaults to console.error. */
+    writeError?: (message: string) => void;
+}

package/dist/cli/contracts/CliOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/contracts/CommandDefinition.d.ts

@@ -0,0 +1,18 @@
+import type { CliArgument, CliCommandContext } from './CliCommand.js';
+/** A named action adapted for terminal invocation without coupling the action to output or exit codes. */
+export interface CommandDefinition<TResult> {
+    /** Service:action command name, for example db:make-migration. */
+    name: string;
+    /** Short help description. */
+    description: string;
+    /** Positional arguments mapped by name before invoking the handler. */
+    parameters?: readonly CliArgument[];
+    /** Defaults to true; false is for source generators that need no running application. */
+    needsApp?: boolean;
+    /** Calls the service action with named arguments; validation remains in that action. */
+    handle(parameters: Readonly<Record<string, string | undefined>>, context: CliCommandContext): TResult | Promise<TResult>;
+    /** Maps a domain result to a terminal exit code. Defaults to success. */
+    exitCode?: (result: TResult) => number;
+    /** Optional terminal presentation; direct action callers still receive the original result. */
+    formatResult?: (result: TResult) => string;
+}

package/dist/cli/contracts/CommandDefinition.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/contracts/ReplOptions.d.ts

@@ -0,0 +1,11 @@
+/** Terminal REPL context and streams, reusable by application development tools. */
+export interface ReplOptions {
+    /** Named values available to expressions; installed again after `.clear`. */
+    values: Readonly<Record<string, unknown>>;
+    /** Prompt shown before each expression. Defaults to `db3> `. */
+    prompt?: string;
+    /** Input stream. Defaults to the current process's standard input. */
+    input?: NodeJS.ReadableStream;
+    /** Output stream. Defaults to the current process's standard output. */
+    output?: NodeJS.WritableStream;
+}

package/dist/cli/contracts/ReplOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/contracts/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './CliCommand.js';
+export type * from './CliConfig.js';
+export type * from './CliOptions.js';
+export type * from './CommandDefinition.js';
+export type * from './ReplOptions.js';

package/dist/cli/contracts/index.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/defineCommand.d.ts

@@ -0,0 +1,10 @@
+import type * as cli from './contracts/index.js';
+/**
+ * Registers an app-context action with named argument mapping and terminal result formatting.
+ *
+ * Export action functions separately so UI and programmatic callers receive normal
+ * results without terminal output. The runner owns the application lifecycle.
+ * @param definition - Service action, parameters and optional result-to-exit-code mapping.
+ * @returns Command suitable for app or service registration.
+ */
+export declare function defineCommand<TResult>(definition: cli.CommandDefinition<TResult>): cli.CliCommand;

package/dist/cli/defineCommand.js

@@ -0,0 +1,25 @@
+/**
+ * Registers an app-context action with named argument mapping and terminal result formatting.
+ *
+ * Export action functions separately so UI and programmatic callers receive normal
+ * results without terminal output. The runner owns the application lifecycle.
+ * @param definition - Service action, parameters and optional result-to-exit-code mapping.
+ * @returns Command suitable for app or service registration.
+ */
+export function defineCommand(definition) {
+    return {
+        name: definition.name,
+        description: definition.description,
+        arguments: definition.parameters,
+        /** Establishes app context, maps parameters and adapts the action result for the terminal. */
+        async run(context) {
+            if (definition.needsApp !== false)
+                await context.app();
+            const parameters = Object.fromEntries((definition.parameters ?? []).map((parameter, index) => [parameter.name, context.args[index]]));
+            const result = await definition.handle(parameters, context);
+            if (result !== undefined)
+                context.write(definition.formatResult ? definition.formatResult(result) : typeof result === 'string' ? result : JSON.stringify(result, null, 2));
+            return definition.exitCode?.(result) ?? 0;
+        },
+    };
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,5 @@
+export * from './contracts/index.js';
+export * from './Cli.js';
+export * from './runDb3.js';
+export * from './defineCommand.js';
+export * from './runRepl.js';

package/dist/cli/index.js

@@ -0,0 +1,5 @@
+export * from './contracts/index.js';
+export * from './Cli.js';
+export * from './runDb3.js';
+export * from './defineCommand.js';
+export * from './runRepl.js';

package/dist/cli/runDb3.d.ts

@@ -0,0 +1,11 @@
+import type * as cli from './contracts/index.js';
+/**
+ * Loads app registration and runs the framework CLI from source or an installed package.
+ *
+ * TypeScript config loading supports the same extensionless imports as the starter.
+ * No HTTP listener is started. Help and queue:make-job do not create the app.
+ * @param argv - Arguments after db3.
+ * @param options - Application root and optional output adapters.
+ * @returns Exit status to assign to process.exitCode.
+ */
+export declare function runDb3(argv: readonly string[], options?: cli.CliOptions): Promise<number>;

package/dist/cli/runDb3.js

@@ -0,0 +1,70 @@
+import { access } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { register } from 'tsx/esm/api';
+import { Cli } from './Cli.js';
+import { createReplCommand } from './commands/repl.js';
+/**
+ * Loads app registration and runs the framework CLI from source or an installed package.
+ *
+ * TypeScript config loading supports the same extensionless imports as the starter.
+ * No HTTP listener is started. Help and queue:make-job do not create the app.
+ * @param argv - Arguments after db3.
+ * @param options - Application root and optional output adapters.
+ * @returns Exit status to assign to process.exitCode.
+ */
+export async function runDb3(argv, options = {}) {
+    const loader = register({ namespace: `db3-cli-${randomUUID()}` });
+    try {
+        const { queueCommands } = await import('../queue/commands/index.js');
+        const directory = resolve(options.directory ?? process.cwd());
+        const configModule = await loadAppModule(directory, 'server/cli.config', loader.import);
+        const config = configModule ? configModule.default : { commands: [] };
+        // Validate app config before combining it with commands that need no app bootstrap.
+        if (!config || !Array.isArray(config.commands))
+            throw new Error('CLI configuration must export a commands array.');
+        const repl = createReplCommand(async () => loadReplModels(directory, loader.import), options);
+        return await new Cli({ ...config, commands: [repl, ...queueCommands, ...config.commands] }, { ...options, directory }).run(argv);
+    }
+    catch (error) {
+        (options.writeError ?? console.error)(error instanceof Error ? error.message : 'Unable to load CLI configuration.');
+        return 1;
+    }
+    finally {
+        await loader.unregister();
+    }
+}
+/** Loads an optional conventional app module without hiding errors from its imports. */
+async function loadAppModule(directory, path, importModule) {
+    for (const extension of ['ts', 'mjs', 'js']) {
+        const file = resolve(directory, `${path}.${extension}`);
+        try {
+            await access(file);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                continue;
+            throw error;
+        }
+        return importModule(pathToFileURL(file).href, import.meta.url);
+    }
+    return undefined;
+}
+/** Exposes named model constructors from the same registry used by app migrations. */
+async function loadReplModels(directory, importModule) {
+    const module = await loadAppModule(directory, 'server/database/models', importModule);
+    if (!module)
+        return {};
+    if (!Array.isArray(module.models))
+        throw new Error('server/database/models must export a models array for the REPL.');
+    const models = Object.create(null);
+    for (const model of module.models) {
+        if (typeof model !== 'function' || !/^[A-Za-z_$][\w$]*$/.test(model.name))
+            throw new Error('REPL models must be named constructors.');
+        if (['app', 'models', '__proto__', 'constructor', 'prototype'].includes(model.name) || Object.hasOwn(models, model.name))
+            throw new Error(`Duplicate or reserved REPL model name: ${model.name}`);
+        models[model.name] = model;
+    }
+    return models;
+}

package/dist/cli/runRepl.d.ts

@@ -0,0 +1,12 @@
+import type { ReplOptions } from './contracts/index.js';
+/**
+ * Runs a Node terminal REPL until `.exit`, end-of-input or a stream failure.
+ *
+ * Expressions support top-level await and persistent variables. Context values
+ * stay inside the REPL's VM rather than becoming process-wide globals. The
+ * caller retains ownership of its application and closes it after this resolves.
+ *
+ * @param options - Context values, prompt and optional terminal streams.
+ * @returns Resolves after the terminal session exits; rejects on stream errors.
+ */
+export declare function runRepl(options: ReplOptions): Promise<void>;

package/dist/cli/runRepl.js

@@ -0,0 +1,54 @@
+import { start } from 'node:repl';
+import { inspect } from 'node:util';
+/**
+ * Runs a Node terminal REPL until `.exit`, end-of-input or a stream failure.
+ *
+ * Expressions support top-level await and persistent variables. Context values
+ * stay inside the REPL's VM rather than becoming process-wide globals. The
+ * caller retains ownership of its application and closes it after this resolves.
+ *
+ * @param options - Context values, prompt and optional terminal streams.
+ * @returns Resolves after the terminal session exits; rejects on stream errors.
+ */
+export async function runRepl(options) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const terminal = Boolean(output.isTTY);
+    const session = start({
+        prompt: options.prompt ?? 'db3> ', input, output, terminal,
+        useGlobal: false, ignoreUndefined: true,
+        /** Formats results without invoking arbitrary model or service getters. */
+        writer: value => inspect(value, { colors: terminal, depth: 6, getters: false }),
+    });
+    /** Restores the app bindings when Node creates or clears the session context. */
+    function installValues() {
+        for (const [name, value] of Object.entries(options.values)) {
+            Object.defineProperty(session.context, name, { value, configurable: true, enumerable: true, writable: true });
+        }
+    }
+    try {
+        installValues();
+        session.on('reset', installValues);
+        await new Promise((resolve, reject) => {
+            /** Releases stream listeners after normal exit or failure. */
+            function cleanup() {
+                input.off('error', fail);
+                output.off('error', fail);
+                session.off('error', fail);
+                session.off('exit', finish);
+            }
+            /** Completes the session after Node has processed its exit command. */
+            function finish() { cleanup(); resolve(); }
+            /** Preserves the original stream failure while releasing the REPL. */
+            function fail(error) { cleanup(); session.close(); reject(error); }
+            input.once('error', fail);
+            output.once('error', fail);
+            session.once('error', fail);
+            session.once('exit', finish);
+        });
+    }
+    finally {
+        session.off('reset', installValues);
+        session.close();
+    }
+}