@mak-98/dirvi-app 0.0.0-stage → 0.11.0-beta.13

package/dist/domain/app-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-input.d.ts","sourceRoot":"","sources":["../../src/domain/app-input.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC"}

package/dist/domain/app-input.js

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

package/dist/domain/app-pack-ref.d.ts

@@ -0,0 +1,17 @@
+export type NpmAppReference = {
+    readonly source: 'npm';
+    readonly packageName: string;
+    readonly version: string;
+};
+export type AppPackageReference = NpmAppReference;
+/**
+ * Parses and validates an app package reference supplied by init.mjs.
+ *
+ * init.mjs is runtime JavaScript, so TypeScript's AppPackageReference type is
+ * not sufficient to establish that a received value is safe to interpret as an
+ * npm package reference.
+ */
+export declare const AppPackageReference: {
+    parse(input: unknown): AppPackageReference;
+};
+//# sourceMappingURL=app-pack-ref.d.ts.map

package/dist/domain/app-pack-ref.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-pack-ref.d.ts","sourceRoot":"","sources":["../../src/domain/app-pack-ref.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,eAAe,CAAC;AAElD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;iBACjB,OAAO,GAAG,mBAAmB;CA+C3C,CAAC"}

package/dist/domain/app-pack-ref.js

@@ -0,0 +1,37 @@
+/**
+ * Parses and validates an app package reference supplied by init.mjs.
+ *
+ * init.mjs is runtime JavaScript, so TypeScript's AppPackageReference type is
+ * not sufficient to establish that a received value is safe to interpret as an
+ * npm package reference.
+ */
+export const AppPackageReference = {
+    parse(input) {
+        if (!isRecord(input)) {
+            throw new Error('Dirvi app package reference must be an object.');
+        }
+        if (input.source !== 'npm') {
+            throw new Error(`Unsupported Dirvi app package source "${String(input.source)}".`);
+        }
+        if (typeof input.packageName !== 'string') {
+            throw new Error('Dirvi npm app package name must be a string.');
+        }
+        if (!/^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(input.packageName)) {
+            throw new Error(`Invalid npm package name "${input.packageName}" for a Dirvi app.`);
+        }
+        if (typeof input.version !== 'string') {
+            throw new Error(`Dirvi app package "${input.packageName}" version must be a string.`);
+        }
+        if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(input.version)) {
+            throw new Error(`Dirvi app package "${input.packageName}" must use an exact version.`);
+        }
+        return {
+            source: 'npm',
+            packageName: input.packageName,
+            version: input.version,
+        };
+    },
+};
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/dist/domain/app.d.ts

@@ -0,0 +1,39 @@
+import type { AppApiApplicator, AppPlugin } from 'dirvi-apis';
+/**
+ * Unique symbol used as computed property name.
+ *
+ * DO NOT EXPORT: Meant to be private to the file, so `App` has opaque
+ * `AppPlugin`.
+ */
+declare const appPlugin: unique symbol;
+export type App = {
+    /**
+     * User-owned identifier from init.mjs.
+     *
+     * This is intentionally not package-owned plugin metadata. It identifies a
+     * configured app instance, so users can register the same plugin more than
+     * once under different IDs.
+     */
+    readonly id: string;
+    /**
+     * Opaque storage for the plugin implementation.
+     *
+     * Consumers can inspect the configured app ID, but only this module can
+     * obtain and invoke the underlying AppPlugin.
+     */
+    readonly [appPlugin]: AppPlugin;
+};
+/**
+ * Creates one configured app instance from a user-selected ID and a plugin.
+ */
+export declare function createApp(id: string, plugin: AppPlugin): App;
+export type AppInput = string | undefined;
+/**
+ * Creates the app API applicator for a configured app without exposing the
+ * `AppPlugin`.
+ *
+ * The concrete AppApi generic parameters remain owned by the plugin.
+ */
+export declare function createAppApiApplicator(app: App, input: AppInput): AppApiApplicator;
+export {};
+//# sourceMappingURL=app.d.ts.map

package/dist/domain/app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.d.ts","sourceRoot":"","sources":["../../src/domain/app.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;;GAKG;AACH,QAAA,MAAM,SAAS,eAAsB,CAAC;AAEtC,MAAM,MAAM,GAAG,GAAG;IAChB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,GAAG,CAK5D;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,QAAQ,GACd,gBAAgB,CAElB"}

package/dist/domain/app.js

@@ -0,0 +1,25 @@
+/**
+ * Unique symbol used as computed property name.
+ *
+ * DO NOT EXPORT: Meant to be private to the file, so `App` has opaque
+ * `AppPlugin`.
+ */
+const appPlugin = Symbol('appPlugin');
+/**
+ * Creates one configured app instance from a user-selected ID and a plugin.
+ */
+export function createApp(id, plugin) {
+    return {
+        id,
+        [appPlugin]: plugin,
+    };
+}
+/**
+ * Creates the app API applicator for a configured app without exposing the
+ * `AppPlugin`.
+ *
+ * The concrete AppApi generic parameters remain owned by the plugin.
+ */
+export function createAppApiApplicator(app, input) {
+    return app[appPlugin].createAppApiApplicator(input);
+}

package/dist/domain/config.d.ts

@@ -0,0 +1,386 @@
+import { z } from 'zod';
+import type { Config } from 'dirvi-apis';
+export declare const ConfigSchema: z.ZodObject<{
+    indentSize: z.ZodDefault<z.ZodNumber>;
+    firstIndent: z.ZodOptional<z.ZodString>;
+    theme: z.ZodDefault<z.ZodObject<{
+        statusBar: z.ZodDefault<z.ZodObject<{
+            command: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            normal: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            background: z.ZodDefault<z.ZodObject<{
+                bg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        tree: z.ZodDefault<z.ZodObject<{
+            leaf: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            branch: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            folded: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            cursorLine: z.ZodDefault<z.ZodObject<{
+                bg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            indentGuide: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodOptional<z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        feedbackBar: z.ZodDefault<z.ZodObject<{
+            message: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+                bg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            success: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+                bg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            error: z.ZodDefault<z.ZodObject<{
+                fg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+                bg: z.ZodObject<{
+                    hex: z.ZodOptional<z.ZodString>;
+                    ansi256: z.ZodOptional<z.ZodNumber>;
+                    basic: z.ZodOptional<z.ZodEnum<{
+                        black: "black";
+                        red: "red";
+                        green: "green";
+                        yellow: "yellow";
+                        blue: "blue";
+                        cyan: "cyan";
+                        magenta: "magenta";
+                        white: "white";
+                        gray: "gray";
+                        grey: "grey";
+                        blackBright: "blackBright";
+                        redBright: "redBright";
+                        greenBright: "greenBright";
+                        yellowBright: "yellowBright";
+                        blueBright: "blueBright";
+                        cyanBright: "cyanBright";
+                        magentaBright: "magentaBright";
+                        whiteBright: "whiteBright";
+                    }>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const defaultConfig: Config;
+export type DeepPartial<Value> = Value extends readonly unknown[] ? Value : Value extends object ? {
+    readonly [Key in keyof Value]?: DeepPartial<Value[Key]>;
+} : Value;
+/**
+ * Deeply merges plain configuration objects without mutating either input.
+ *
+ * Nested records merge recursively. Scalars, undefined values, and arrays
+ * replace the corresponding current value. ConfigSchema validates the result
+ * immediately after this operation, since TypeScript cannot prove that a
+ * generic runtime merge preserves all domain invariants.
+ */
+export declare function merge<Value>(current: Value, patch: DeepPartial<Value>): Value;
+//# sourceMappingURL=config.d.ts.map

package/dist/domain/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/domain/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAKzC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMK,CAAC;AAE/B,eAAO,MAAM,aAAa,EAAE,MAA+B,CAAC;AAK5D,MAAM,MAAM,WAAW,CAAC,KAAK,IAAI,KAAK,SAAS,SAAS,OAAO,EAAE,GAC7D,KAAK,GACL,KAAK,SAAS,MAAM,GAClB;IAAE,QAAQ,EAAE,GAAG,IAAI,MAAM,KAAK,CAAC,CAAC,EAAE,WAAW,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;CAAE,GAC3D,KAAK,CAAC;AAEZ;;;;;;;GAOG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,GAAG,KAAK,CAiB7E"}

package/dist/domain/config.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { defaultTheme, ThemeSchema } from './theme.js';
+// =============================================================================
+// Configuration
+// =============================================================================
+export const ConfigSchema = z.object({
+    indentSize: z.number().int().min(0).default(2),
+    // When omitted, ViewRowComponent uses `indentSize` spaces.
+    // An empty string is valid and removes the first indentation prefix.
+    firstIndent: z.string().optional(),
+    theme: ThemeSchema.default(defaultTheme),
+});
+export const defaultConfig = ConfigSchema.parse({});
+/**
+ * Deeply merges plain configuration objects without mutating either input.
+ *
+ * Nested records merge recursively. Scalars, undefined values, and arrays
+ * replace the corresponding current value. ConfigSchema validates the result
+ * immediately after this operation, since TypeScript cannot prove that a
+ * generic runtime merge preserves all domain invariants.
+ */
+export function merge(current, patch) {
+    if (!isRecord(current) || !isRecord(patch)) {
+        return patch;
+    }
+    const result = { ...current };
+    for (const [key, patchValue] of Object.entries(patch)) {
+        const currentValue = result[key];
+        result[key] =
+            isRecord(currentValue) && isRecord(patchValue)
+                ? merge(currentValue, patchValue)
+                : patchValue;
+    }
+    return result;
+}
+/**
+ * Returns whether a value can participate in the object-merge branch.
+ *
+ * Arrays are deliberately excluded: they are configuration values to replace
+ * atomically rather than collections to merge by numeric index.
+ */
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/domain/dirvi-api/app-api.d.ts

@@ -0,0 +1,7 @@
+/**
+ * API exposing methods at the dirvi app-level.
+ *
+ * Used in registering commands specific to an app in {@link PublicInitApi}.
+ */
+export type AppApi = {};
+//# sourceMappingURL=app-api.d.ts.map

package/dist/domain/dirvi-api/app-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-api.d.ts","sourceRoot":"","sources":["../../../src/domain/dirvi-api/app-api.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,MAAM,GAAG,EAEpB,CAAA"}

package/dist/domain/dirvi-api/app-api.js

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

package/dist/domain/dirvi-api/dirvi-api.d.ts

@@ -0,0 +1,17 @@
+import { ShellApi } from './shell-api.js';
+import { AppApi } from './app-api.js';
+/**
+ * General API for performing actions in a running Dirvi session.
+ *
+ * This type describes the available actions; it does not implement them.
+ * Dirvi must create an API object whose methods are backed by the live session.
+ *
+ * One use is in {@link PublicInitApi}: init.mjs can register closures that
+ * receive this API and call its methods to perform actions. Dirvi passes the
+ * object to a closure when it runs, not when it is registered.
+ */
+export type DirviApi = {
+    shell: ShellApi;
+    app: AppApi;
+};
+//# sourceMappingURL=dirvi-api.d.ts.map

package/dist/domain/dirvi-api/dirvi-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirvi-api.d.ts","sourceRoot":"","sources":["../../../src/domain/dirvi-api/dirvi-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;GASG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,QAAQ,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb,CAAC"}

package/dist/domain/dirvi-api/dirvi-api.js

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

package/dist/domain/dirvi-api/shell-api.d.ts

@@ -0,0 +1,35 @@
+import type { AppInput } from '../app-input.js';
+export type OpenAppResult = {
+    readonly kind: 'loaded';
+} | {
+    readonly kind: 'notRegistered';
+    readonly appId: string;
+    readonly message: string;
+} | {
+    readonly kind: 'loadFailed';
+    readonly appId: string;
+    readonly message: string;
+};
+/**
+ * API exposing methods at the dirvi shell-level.
+ *
+ * Not specific to any app.
+ */
+export type ShellApi = {
+    /**
+     * Loads an app by ID and input.
+     *
+     * A successful `loaded` result means the app's methods have been prepared and
+     * the shell update was scheduled. App initialization may still fail if the
+     * app definition methods fail.
+     *
+     * @param appId - ID of the registered app to load.
+     * @param input - Input to be interpreted by the selected app.
+     * @returns A result describing whether the app was loaded or why loading
+     * failed. Loading failures do not cause the promise to throw.
+     */
+    readonly loadApp: (appId: string, input: AppInput) => Promise<OpenAppResult>;
+    /** Optional exit message to display. */
+    readonly quit: (message?: string) => void;
+};
+//# sourceMappingURL=shell-api.d.ts.map

package/dist/domain/dirvi-api/shell-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-api.d.ts","sourceRoot":"","sources":["../../../src/domain/dirvi-api/shell-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,MAAM,MAAM,aAAa,GACrB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IACE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,GACD;IACE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEN;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC,aAAa,CAAC,CAAC;IAE7E,wCAAwC;IACxC,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;CAC3C,CAAC"}

package/dist/domain/dirvi-api/shell-api.js

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