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

package/dist/domain/config.d.ts

@@ -0,0 +1,402 @@
+import { z } from 'zod';
+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 type Config = z.infer<typeof ConfigSchema>;
+export declare const defaultConfig: Config;
+/**
+ * A recursively optional form of a configuration value.
+ *
+ * Config scripts submit patches rather than full Config values, so a script can
+ * change a nested option without repeating unrelated defaults. Arrays remain
+ * whole values because configuration arrays should be replaced, not merged by
+ * index.
+ */
+type DeepPartial<Value> = Value extends readonly unknown[] ? Value : Value extends object ? {
+    readonly [Key in keyof Value]?: DeepPartial<Value[Key]>;
+} : Value;
+/**
+ * A partial configuration update accepted from an init.mjs script.
+ *
+ * Every patch is merged with the current complete configuration and then
+ * validated with ConfigSchema before it becomes active.
+ */
+export type ConfigPatch = DeepPartial<Config>;
+/**
+ * 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;
+export {};
+//# 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;AAMxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,eAAO,MAAM,aAAa,EAAE,MAA+B,CAAC;AAK5D;;;;;;;GAOG;AACH,KAAK,WAAW,CAAC,KAAK,IAAI,KAAK,SAAS,SAAS,OAAO,EAAE,GACtD,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;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AAE9C;;;;;;;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.d.ts

@@ -0,0 +1,24 @@
+import type { Config } from './config.js';
+import type { AppInput } from './app.js';
+import type { AppApiApplicator } from 'dirvi-apis';
+import type { ExCommand } from './ex-command.js';
+/**
+ * The configured, long-lived Dirvi application API.
+ *
+ * This is created after init.mjs has finished evaluating. Unlike PublicInitApi,
+ * it cannot install packages or register apps: startup composition is sealed.
+ */
+export type DirviApi = {
+    readonly config: Config;
+    readonly initialAppId: string;
+    readonly appIds: readonly string[];
+    readonly customExCommands: readonly ExCommand[];
+    /**
+     * Opens a registered app using host-provided startup input.
+     *
+     * The returned applicator preserves the concrete AppApi generic parameters
+     * selected by the app plugin without exposing them to the host or Shell.
+     */
+    readonly openApp: (appId: string, input: AppInput) => AppApiApplicator;
+};
+//# sourceMappingURL=dirvi-api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dirvi-api.d.ts","sourceRoot":"","sources":["../../src/domain/dirvi-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,SAAS,EAAE,CAAC;IAEhD;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,KAAK,gBAAgB,CAAC;CACxE,CAAC"}

package/dist/domain/dirvi-api.js

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

package/dist/domain/ex-command.d.ts

@@ -0,0 +1,12 @@
+import { ShellApi } from './shell-api.js';
+/**
+ * A command registered by init.mjs and invoked through Ex mode.
+ *
+ * The command receives the live DirviApi only when it is executed. This keeps
+ * initialization separate from the running application lifecycle.
+ */
+export type ExCommand = {
+    readonly name: string;
+    readonly execute: (shell: ShellApi) => void | Promise<void>;
+};
+//# sourceMappingURL=ex-command.d.ts.map

package/dist/domain/ex-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ex-command.d.ts","sourceRoot":"","sources":["../../src/domain/ex-command.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7D,CAAC"}

package/dist/domain/ex-command.js

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

package/dist/domain/init-runtime.d.ts

@@ -0,0 +1,41 @@
+import { AppPlugin } from 'dirvi-apis';
+import { AppPackageReference } from './app-pack-ref.js';
+import { Config, ConfigPatch } from './config.js';
+import { App } from './app.js';
+/**
+ * The startup configuration API exposed to init.mjs as the global `dirvi`.
+ *
+ * This is intentionally a narrow facade. It is the public scripting boundary,
+ * rather than an escape hatch into UI state or infrastructure implementations.
+ */
+export type PublicInitApi = {
+    readonly options: {
+        set: (patch: ConfigPatch) => void;
+    };
+    readonly apps: {
+        install: (reference: AppPackageReference) => Promise<AppPlugin>;
+        /**
+         * Registers an application made available by init.mjs.
+         */
+        register: (id: string, appPlugin: AppPlugin) => void;
+        /**
+         * Optionally selects the app initially opened by the shell.
+         *
+         * If omitted, the runtime falls back to the most recently registered app.
+         */
+        initialAppId: (appId: string) => void;
+    };
+};
+/**
+ * Everything registered while init.mjs was evaluated.
+ *
+ * Config is shared tree-UI configuration. App selection is distinct from Config
+ * value. initialAppId is always the ID of one app in apps: either the app
+ * explicitly selected by init.mjs or the most recently registered app.
+ */
+export type Init = {
+    readonly config: Config;
+    readonly apps: readonly App[];
+    readonly initialAppId: string;
+};
+//# sourceMappingURL=init-runtime.d.ts.map

package/dist/domain/init-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-runtime.d.ts","sourceRoot":"","sources":["../../src/domain/init-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE;QAChB,GAAG,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;KACnC,CAAC;IAEF,QAAQ,CAAC,IAAI,EAAE;QACb,OAAO,EAAE,CAAC,SAAS,EAAE,mBAAmB,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;QAChE;;WAEG;QACH,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,KAAK,IAAI,CAAC;QACrD;;;;WAIG;QACH,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;KACvC,CAAC;CACH,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,IAAI,GAAG;IACjB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B,CAAC"}

package/dist/domain/init-runtime.js

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

package/dist/domain/initialization.d.ts

@@ -0,0 +1,20 @@
+import { Config } from './config.js';
+import { ExCommand } from './ex-command.js';
+import { AppPackageReference } from './app-pack-ref.js';
+/**
+ * Object set through initialization, i.e. evaluating init.mjs.
+ *
+ * Config is shared tree-UI configuration. App selection is distinct from Config
+ * value. Ex commands are executable startup registrations and are therefore
+ * stored separately from Config.
+ *
+ * initialAppId is always the ID of one app in apps: either the app explicitly
+ * selected by init.mjs or the most recently registered app.
+ */
+export type Initialization = {
+    readonly config: Readonly<Config>;
+    readonly initialAppId: string;
+    readonly registeredApps: ReadonlyMap<string, AppPackageReference>;
+    readonly exCommands: readonly ExCommand[];
+};
+//# sourceMappingURL=initialization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"initialization.d.ts","sourceRoot":"","sources":["../../src/domain/initialization.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAClE,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;CAC3C,CAAC"}

package/dist/domain/initialization.js

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

package/dist/domain/public-init-api.d.ts

@@ -0,0 +1,42 @@
+import { AppPackageReference } from './app-pack-ref.js';
+import { ConfigPatch } from './config.js';
+import { ShellApi } from './shell-api.js';
+/**
+ * The startup configuration API exposed to init.mjs as the global `dirvi`.
+ *
+ * This is intentionally a narrow facade. It is the public scripting boundary,
+ * rather than an escape hatch into UI state or infrastructure implementations.
+ */
+export type PublicInitApi = {
+    readonly options: {
+        set: (patch: ConfigPatch) => void;
+    };
+    readonly apps: {
+        /**
+         * Optionally selects the app initially opened by the shell.
+         *
+         * If omitted, the runtime falls back to the most recently registered app.
+         */
+        initialAppId: (appId: string) => void;
+        /**
+         * Registers an application made available by init.mjs.
+         */
+        register: (id: string, appReference: AppPackageReference) => void;
+    };
+    readonly ex: {
+        /**
+         * Registers an Ex command invoked as `:${name}`.
+         *
+         * The closure receives the live DirviApi when the user invokes the command,
+         * not while init.mjs is being evaluated. E.g.
+         *
+         * ```js
+         * dirvi.ex.register('hello', (api) => {
+         *     // Do something with api
+         * });
+         * ```
+         */
+        register: (name: string, execute: (shell: ShellApi) => void | Promise<void>) => void;
+    };
+};
+//# sourceMappingURL=public-init-api.d.ts.map

package/dist/domain/public-init-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public-init-api.d.ts","sourceRoot":"","sources":["../../src/domain/public-init-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE;QAChB,GAAG,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;KACnC,CAAC;IAEF,QAAQ,CAAC,IAAI,EAAE;QACb;;;;WAIG;QACH,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;QACtC;;WAEG;QACH,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,mBAAmB,KAAK,IAAI,CAAC;KACnE,CAAC;IAEF,QAAQ,CAAC,EAAE,EAAE;QACX;;;;;;;;;;;WAWG;QACH,QAAQ,EAAE,CACR,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAC/C,IAAI,CAAC;KACX,CAAC;CACH,CAAC"}

package/dist/domain/public-init-api.js

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

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

@@ -0,0 +1,5 @@
+import type { AppInput } from './app.js';
+export type ShellApi = {
+    readonly openApp: (appId: string, input: AppInput) => Promise<void>;
+};
+//# sourceMappingURL=shell-api.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shell-api.d.ts","sourceRoot":"","sources":["../../src/domain/shell-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACrE,CAAC"}

package/dist/domain/shell-api.js

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