@kvman/sdk 0.1.0

package/dist/kernel-api.d.ts

@@ -0,0 +1,550 @@
+import { z } from 'zod';
+/** Accepts a JSON Schema, as the kernel lists schemas for forms (plan 02 §2.12). */
+export declare const jsonSchemaDocumentSchema: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+/** Accepts a command or query as `kernel.extensions.list` describes it. */
+export declare const registrationInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    public: z.ZodBoolean;
+    input: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+    output: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+}, z.core.$strict>;
+/** Accepts a command or query as `kernel.registrations.list` lists it: with its owner, and without its schemas. */
+export declare const registrationRowSchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        command: "command";
+        query: "query";
+    }>;
+    extension: z.ZodString;
+    public: z.ZodBoolean;
+    description: z.ZodString;
+}, z.core.$strict>;
+/** Accepts an extension as `kernel.extensions.list` describes it. */
+export declare const extensionInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    source: z.ZodUnion<readonly [z.ZodLiteral<"bundled">, z.ZodTemplateLiteral<`npm:${string}`>, z.ZodTemplateLiteral<`path:${string}`>]>;
+    revision: z.ZodNumber;
+    namespace: z.ZodString;
+    commands: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        public: z.ZodBoolean;
+        input: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+        output: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+    }, z.core.$strict>>;
+    queries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        public: z.ZodBoolean;
+        input: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+        output: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+    }, z.core.$strict>>;
+    settings: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        description: z.ZodString;
+        scopes: z.ZodArray<z.ZodEnum<{
+            global: "global";
+            workspace: "workspace";
+        }>>;
+    }, z.core.$strict>>;
+    handlers: z.ZodArray<z.ZodObject<{
+        point: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Accepts a setting as `kernel.settings.list` describes it: its JSON Schema, its scopes, and where its value comes from. */
+export declare const settingInfoSchema: z.ZodObject<{
+    key: z.ZodString;
+    description: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+    scopes: z.ZodArray<z.ZodEnum<{
+        global: "global";
+        workspace: "workspace";
+    }>>;
+    value: z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>;
+    source: z.ZodEnum<{
+        default: "default";
+        global: "global";
+        workspace: "workspace";
+        preset: "preset";
+    }>;
+}, z.core.$strict>;
+/** Accepts a running long-lived process as `kernel.processes.list` describes it. */
+export declare const processRowSchema: z.ZodObject<{
+    extension: z.ZodString;
+    workspaceId: z.ZodString;
+    name: z.ZodString;
+    pid: z.ZodNumber;
+    startedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+/** Accepts the sub-folders of a folder as `kernel.folder.list` answers (plan 02 §2.12). */
+export declare const folderListSchema: z.ZodObject<{
+    path: z.ZodString;
+    parent: z.ZodNullable<z.ZodString>;
+    folders: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    truncated: z.ZodBoolean;
+}, z.core.$strict>;
+/** Accepts the answer of `kernel.health.get`; `rolledBack` is the Problem of the start that was undone before this one (ADR 0024, 5). */
+export declare const healthSchema: z.ZodObject<{
+    version: z.ZodString;
+    preset: z.ZodString;
+    mode: z.ZodLiteral<"web">;
+    workers: z.ZodNumber;
+    uptimeMs: z.ZodNumber;
+    languages: z.ZodArray<z.ZodString>;
+    rolledBack: z.ZodExactOptional<z.ZodObject<{
+        code: z.ZodUnion<readonly [z.ZodEnum<{
+            VALIDATION_FAILED: "VALIDATION_FAILED";
+            NOT_FOUND: "NOT_FOUND";
+            NOT_PUBLIC: "NOT_PUBLIC";
+            NOT_A_COMMAND: "NOT_A_COMMAND";
+            READ_ONLY: "READ_ONLY";
+            NO_JOB: "NO_JOB";
+            TOO_LARGE: "TOO_LARGE";
+            TOO_DEEP: "TOO_DEEP";
+            TIMEOUT: "TIMEOUT";
+            CANCELLED: "CANCELLED";
+            WORKER_CRASHED: "WORKER_CRASHED";
+            INTERRUPTED: "INTERRUPTED";
+            HANDLER_FAILED: "HANDLER_FAILED";
+            FORBIDDEN_ORIGIN: "FORBIDDEN_ORIGIN";
+            PROCESS_RUNNING: "PROCESS_RUNNING";
+            PORT_IN_USE: "PORT_IN_USE";
+            EXTENSION_INVALID: "EXTENSION_INVALID";
+            KVMAN_RUNNING: "KVMAN_RUNNING";
+        }>, z.ZodString]>;
+        message: z.ZodString;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** The input and output schemas of the kernel's own commands (plan 02 §2.12). */
+export declare const kernelCommandSchemas: {
+    readonly 'kernel.workspace.open': {
+        readonly input: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.workspace.close': {
+        readonly input: z.ZodObject<{
+            workspaceId: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{}, z.core.$strict>;
+    };
+    readonly 'kernel.folder.create': {
+        readonly input: z.ZodObject<{
+            path: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.settings.set': {
+        readonly input: z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>;
+            scope: z.ZodEnum<{
+                global: "global";
+                workspace: "workspace";
+            }>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{}, z.core.$strict>;
+    };
+    readonly 'kernel.settings.reset': {
+        readonly input: z.ZodObject<{
+            key: z.ZodString;
+            scope: z.ZodEnum<{
+                global: "global";
+                workspace: "workspace";
+            }>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{}, z.core.$strict>;
+    };
+    readonly 'kernel.secrets.set': {
+        readonly input: z.ZodObject<{
+            extension: z.ZodString;
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{}, z.core.$strict>;
+    };
+    readonly 'kernel.secrets.delete': {
+        readonly input: z.ZodObject<{
+            extension: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{}, z.core.$strict>;
+    };
+    readonly 'kernel.files.unlink': {
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{}, z.core.$strict>;
+    };
+    readonly 'kernel.extensions.install': {
+        readonly input: z.ZodObject<{
+            source: z.ZodUnion<readonly [z.ZodTemplateLiteral<`bundled:${string}`>, z.ZodTemplateLiteral<`npm:${string}@${string}`>, z.ZodTemplateLiteral<`path:${string}`>]>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            file: z.ZodString;
+            restartRequired: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.extensions.uninstall': {
+        readonly input: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            file: z.ZodString;
+            restartRequired: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.restart': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            restarting: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+    };
+};
+/** The input and output schemas of the kernel's own queries (plan 02 §2.12). */
+export declare const kernelQuerySchemas: {
+    readonly 'kernel.workspace.list': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            path: z.ZodString;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.folder.list': {
+        readonly input: z.ZodObject<{
+            path: z.ZodExactOptional<z.ZodString>;
+            hidden: z.ZodExactOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            path: z.ZodString;
+            parent: z.ZodNullable<z.ZodString>;
+            folders: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$strict>>;
+            truncated: z.ZodBoolean;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.settings.list': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            description: z.ZodString;
+            schema: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+            scopes: z.ZodArray<z.ZodEnum<{
+                global: "global";
+                workspace: "workspace";
+            }>>;
+            value: z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>;
+            source: z.ZodEnum<{
+                default: "default";
+                global: "global";
+                workspace: "workspace";
+                preset: "preset";
+            }>;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.secrets.list': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            extension: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.jobs.get': {
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            id: z.ZodUUID;
+            name: z.ZodString;
+            input: z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>;
+            workspaceId: z.ZodString;
+            caller: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"user">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"extension">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"kernel">;
+            }, z.core.$strict>], "kind">;
+            status: z.ZodEnum<{
+                queued: "queued";
+                running: "running";
+                succeeded: "succeeded";
+                failed: "failed";
+                cancelled: "cancelled";
+            }>;
+            attempts: z.ZodNumber;
+            retries: z.ZodNumber;
+            output: z.ZodOptional<z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+            problem: z.ZodOptional<z.ZodObject<{
+                code: z.ZodUnion<readonly [z.ZodEnum<{
+                    VALIDATION_FAILED: "VALIDATION_FAILED";
+                    NOT_FOUND: "NOT_FOUND";
+                    NOT_PUBLIC: "NOT_PUBLIC";
+                    NOT_A_COMMAND: "NOT_A_COMMAND";
+                    READ_ONLY: "READ_ONLY";
+                    NO_JOB: "NO_JOB";
+                    TOO_LARGE: "TOO_LARGE";
+                    TOO_DEEP: "TOO_DEEP";
+                    TIMEOUT: "TIMEOUT";
+                    CANCELLED: "CANCELLED";
+                    WORKER_CRASHED: "WORKER_CRASHED";
+                    INTERRUPTED: "INTERRUPTED";
+                    HANDLER_FAILED: "HANDLER_FAILED";
+                    FORBIDDEN_ORIGIN: "FORBIDDEN_ORIGIN";
+                    PROCESS_RUNNING: "PROCESS_RUNNING";
+                    PORT_IN_USE: "PORT_IN_USE";
+                    EXTENSION_INVALID: "EXTENSION_INVALID";
+                    KVMAN_RUNNING: "KVMAN_RUNNING";
+                }>, z.ZodString]>;
+                message: z.ZodString;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodISODateTime;
+            startedAt: z.ZodOptional<z.ZodISODateTime>;
+            endedAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.jobs.list': {
+        readonly input: z.ZodObject<{
+            status: z.ZodOptional<z.ZodEnum<{
+                queued: "queued";
+                running: "running";
+                succeeded: "succeeded";
+                failed: "failed";
+                cancelled: "cancelled";
+            }>>;
+            limit: z.ZodNumber;
+        }, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            name: z.ZodString;
+            input: z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>;
+            workspaceId: z.ZodString;
+            caller: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"user">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"extension">;
+                name: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"kernel">;
+            }, z.core.$strict>], "kind">;
+            status: z.ZodEnum<{
+                queued: "queued";
+                running: "running";
+                succeeded: "succeeded";
+                failed: "failed";
+                cancelled: "cancelled";
+            }>;
+            attempts: z.ZodNumber;
+            retries: z.ZodNumber;
+            output: z.ZodOptional<z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+            problem: z.ZodOptional<z.ZodObject<{
+                code: z.ZodUnion<readonly [z.ZodEnum<{
+                    VALIDATION_FAILED: "VALIDATION_FAILED";
+                    NOT_FOUND: "NOT_FOUND";
+                    NOT_PUBLIC: "NOT_PUBLIC";
+                    NOT_A_COMMAND: "NOT_A_COMMAND";
+                    READ_ONLY: "READ_ONLY";
+                    NO_JOB: "NO_JOB";
+                    TOO_LARGE: "TOO_LARGE";
+                    TOO_DEEP: "TOO_DEEP";
+                    TIMEOUT: "TIMEOUT";
+                    CANCELLED: "CANCELLED";
+                    WORKER_CRASHED: "WORKER_CRASHED";
+                    INTERRUPTED: "INTERRUPTED";
+                    HANDLER_FAILED: "HANDLER_FAILED";
+                    FORBIDDEN_ORIGIN: "FORBIDDEN_ORIGIN";
+                    PROCESS_RUNNING: "PROCESS_RUNNING";
+                    PORT_IN_USE: "PORT_IN_USE";
+                    EXTENSION_INVALID: "EXTENSION_INVALID";
+                    KVMAN_RUNNING: "KVMAN_RUNNING";
+                }>, z.ZodString]>;
+                message: z.ZodString;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>>;
+            }, z.core.$strict>>;
+            createdAt: z.ZodISODateTime;
+            startedAt: z.ZodOptional<z.ZodISODateTime>;
+            endedAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.files.get': {
+        readonly input: z.ZodObject<{
+            id: z.ZodString;
+        }, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            id: z.ZodUUID;
+            name: z.ZodString;
+            type: z.ZodString;
+            size: z.ZodNumber;
+            owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"user">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"extension">;
+                name: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            workspaceId: z.ZodString;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.files.list': {
+        readonly input: z.ZodObject<{
+            limit: z.ZodNumber;
+        }, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            name: z.ZodString;
+            type: z.ZodString;
+            size: z.ZodNumber;
+            owner: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"user">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"extension">;
+                name: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            workspaceId: z.ZodString;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.extensions.list': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+            source: z.ZodUnion<readonly [z.ZodLiteral<"bundled">, z.ZodTemplateLiteral<`npm:${string}`>, z.ZodTemplateLiteral<`path:${string}`>]>;
+            revision: z.ZodNumber;
+            namespace: z.ZodString;
+            commands: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                public: z.ZodBoolean;
+                input: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+                output: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+            }, z.core.$strict>>;
+            queries: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+                public: z.ZodBoolean;
+                input: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+                output: z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>;
+            }, z.core.$strict>>;
+            settings: z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                description: z.ZodString;
+                scopes: z.ZodArray<z.ZodEnum<{
+                    global: "global";
+                    workspace: "workspace";
+                }>>;
+            }, z.core.$strict>>;
+            handlers: z.ZodArray<z.ZodObject<{
+                point: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.registrations.list': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodEnum<{
+                command: "command";
+                query: "query";
+            }>;
+            extension: z.ZodString;
+            public: z.ZodBoolean;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.preset.get': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            name: z.ZodString;
+            extensions: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"bundled">, z.ZodTemplateLiteral<`npm:${string}`>, z.ZodTemplateLiteral<`path:${string}`>]>>;
+            settings: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>>;
+            origin: z.ZodEnum<{
+                file: "file";
+                bundled: "bundled";
+                home: "home";
+            }>;
+            file: z.ZodExactOptional<z.ZodString>;
+        }, z.core.$strict>;
+    };
+    readonly 'kernel.processes.list': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodArray<z.ZodObject<{
+            extension: z.ZodString;
+            workspaceId: z.ZodString;
+            name: z.ZodString;
+            pid: z.ZodNumber;
+            startedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    };
+    readonly 'kernel.health.get': {
+        readonly input: z.ZodObject<{}, z.core.$strict>;
+        readonly output: z.ZodObject<{
+            version: z.ZodString;
+            preset: z.ZodString;
+            mode: z.ZodLiteral<"web">;
+            workers: z.ZodNumber;
+            uptimeMs: z.ZodNumber;
+            languages: z.ZodArray<z.ZodString>;
+            rolledBack: z.ZodExactOptional<z.ZodObject<{
+                code: z.ZodUnion<readonly [z.ZodEnum<{
+                    VALIDATION_FAILED: "VALIDATION_FAILED";
+                    NOT_FOUND: "NOT_FOUND";
+                    NOT_PUBLIC: "NOT_PUBLIC";
+                    NOT_A_COMMAND: "NOT_A_COMMAND";
+                    READ_ONLY: "READ_ONLY";
+                    NO_JOB: "NO_JOB";
+                    TOO_LARGE: "TOO_LARGE";
+                    TOO_DEEP: "TOO_DEEP";
+                    TIMEOUT: "TIMEOUT";
+                    CANCELLED: "CANCELLED";
+                    WORKER_CRASHED: "WORKER_CRASHED";
+                    INTERRUPTED: "INTERRUPTED";
+                    HANDLER_FAILED: "HANDLER_FAILED";
+                    FORBIDDEN_ORIGIN: "FORBIDDEN_ORIGIN";
+                    PROCESS_RUNNING: "PROCESS_RUNNING";
+                    PORT_IN_USE: "PORT_IN_USE";
+                    EXTENSION_INVALID: "EXTENSION_INVALID";
+                    KVMAN_RUNNING: "KVMAN_RUNNING";
+                }>, z.ZodString]>;
+                message: z.ZodString;
+                params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("./json.ts").Json, unknown, z.core.$ZodTypeInternals<import("./json.ts").Json, unknown>>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    };
+};
+type Typed<Schemas extends Record<string, {
+    input: z.ZodType;
+    output: z.ZodType;
+}>> = {
+    [Name in keyof Schemas]: {
+        input: z.input<Schemas[Name]['input']>;
+        output: z.output<Schemas[Name]['output']>;
+    };
+};
+/** The kernel's commands by name, each `{ input; output }`; `Commands` includes them. */
+export type KernelCommands = Typed<typeof kernelCommandSchemas>;
+/** The kernel's queries by name, each `{ input; output }`; `Queries` includes them. */
+export type KernelQueries = Typed<typeof kernelQuerySchemas>;
+export {};
+//# sourceMappingURL=kernel-api.d.ts.map

package/dist/kernel-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kernel-api.d.ts","sourceRoot":"","sources":["../src/kernel-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,oFAAoF;AACpF,eAAO,MAAM,wBAAwB,qIAAmC,CAAC;AAEzE,2EAA2E;AAC3E,eAAO,MAAM,sBAAsB;;;;;;kBAMjC,CAAC;AAEH,mHAAmH;AACnH,eAAO,MAAM,qBAAqB;;;;;;;;;kBAMhC,CAAC;AAEH,qEAAqE;AACrE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAU9B,CAAC;AAEH,6HAA6H;AAC7H,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;kBAO5B,CAAC;AAEH,oFAAoF;AACpF,eAAO,MAAM,gBAAgB;;;;;;kBAM3B,CAAC;AAEH,2FAA2F;AAC3F,eAAO,MAAM,gBAAgB;;;;;;;;kBAK3B,CAAC;AAEH,yIAAyI;AACzI,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAQvB,CAAC;AAEH,iFAAiF;AACjF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBvB,CAAC;AAEX,gFAAgF;AAChF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAcrB,CAAC;AAEX,KAAK,KAAK,CAAC,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE;IAAE,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC;IAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAA;CAAE,CAAC,IAAI;KACnF,IAAI,IAAI,MAAM,OAAO,GAAG;QAAE,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;QAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAA;KAAE;CAC/G,CAAC;AAEF,yFAAyF;AACzF,MAAM,MAAM,cAAc,GAAG,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEhE,uFAAuF;AACvF,MAAM,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/dist/kernel-api.js

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { jsonSchema } from "./json.js";
+import { packageNameSchema } from "./manifest.js";
+import { extensionSourceSchema, installSourceSchema, presetStateSchema } from "./preset.js";
+import { problemSchema } from "./problem.js";
+import { fileSchema, isoTimeSchema, jobSchema, jobStatusSchema, workspaceSchema } from "./rows.js";
+const emptySchema = z.strictObject({});
+const scopeSchema = z.enum(['global', 'workspace']);
+const listLimitSchema = z.number().int().positive().max(1000);
+/** Accepts a JSON Schema, as the kernel lists schemas for forms (plan 02 §2.12). */
+export const jsonSchemaDocumentSchema = z.record(z.string(), jsonSchema);
+/** Accepts a command or query as `kernel.extensions.list` describes it. */
+export const registrationInfoSchema = z.strictObject({
+    name: z.string(),
+    description: z.string(),
+    public: z.boolean(),
+    input: jsonSchemaDocumentSchema,
+    output: jsonSchemaDocumentSchema,
+});
+/** Accepts a command or query as `kernel.registrations.list` lists it: with its owner, and without its schemas. */
+export const registrationRowSchema = z.strictObject({
+    name: z.string(),
+    kind: z.enum(['command', 'query']),
+    extension: z.string(),
+    public: z.boolean(),
+    description: z.string(),
+});
+/** Accepts an extension as `kernel.extensions.list` describes it. */
+export const extensionInfoSchema = z.strictObject({
+    name: z.string(),
+    version: z.string(),
+    source: extensionSourceSchema,
+    revision: z.number().int().nonnegative(),
+    namespace: z.string(),
+    commands: z.array(registrationInfoSchema),
+    queries: z.array(registrationInfoSchema),
+    settings: z.array(z.strictObject({ key: z.string(), description: z.string(), scopes: z.array(scopeSchema) })),
+    handlers: z.array(z.strictObject({ point: z.string(), description: z.string() })),
+});
+/** Accepts a setting as `kernel.settings.list` describes it: its JSON Schema, its scopes, and where its value comes from. */
+export const settingInfoSchema = z.strictObject({
+    key: z.string(),
+    description: z.string(),
+    schema: jsonSchemaDocumentSchema,
+    scopes: z.array(scopeSchema),
+    value: jsonSchema,
+    source: z.enum(['workspace', 'global', 'preset', 'default']),
+});
+/** Accepts a running long-lived process as `kernel.processes.list` describes it. */
+export const processRowSchema = z.strictObject({
+    extension: z.string(),
+    workspaceId: z.string(),
+    name: z.string(),
+    pid: z.number().int(),
+    startedAt: isoTimeSchema,
+});
+/** Accepts the sub-folders of a folder as `kernel.folder.list` answers (plan 02 §2.12). */
+export const folderListSchema = z.strictObject({
+    path: z.string(),
+    parent: z.string().nullable(),
+    folders: z.array(z.strictObject({ name: z.string(), path: z.string() })),
+    truncated: z.boolean(),
+});
+/** Accepts the answer of `kernel.health.get`; `rolledBack` is the Problem of the start that was undone before this one (ADR 0024, 5). */
+export const healthSchema = z.strictObject({
+    version: z.string(),
+    preset: z.string(),
+    mode: z.literal('web'),
+    workers: z.number().int().positive(),
+    uptimeMs: z.number().nonnegative(),
+    languages: z.array(z.string()),
+    rolledBack: problemSchema.exactOptional(),
+});
+/** The input and output schemas of the kernel's own commands (plan 02 §2.12). */
+export const kernelCommandSchemas = {
+    'kernel.workspace.open': { input: z.strictObject({ path: z.string().min(1) }), output: workspaceSchema },
+    'kernel.workspace.close': { input: z.strictObject({ workspaceId: z.string().min(1) }), output: emptySchema },
+    'kernel.folder.create': { input: z.strictObject({ path: z.string().min(1), name: z.string() }), output: z.strictObject({ path: z.string() }) },
+    'kernel.settings.set': { input: z.strictObject({ key: z.string().min(1), value: jsonSchema, scope: scopeSchema }), output: emptySchema },
+    'kernel.settings.reset': { input: z.strictObject({ key: z.string().min(1), scope: scopeSchema }), output: emptySchema },
+    'kernel.secrets.set': { input: z.strictObject({ extension: z.string().min(1), name: z.string().min(1), value: z.string() }), output: emptySchema },
+    'kernel.secrets.delete': { input: z.strictObject({ extension: z.string().min(1), name: z.string().min(1) }), output: emptySchema },
+    'kernel.files.unlink': { input: z.strictObject({ id: z.string().min(1) }), output: emptySchema },
+    'kernel.extensions.install': {
+        input: z.strictObject({ source: installSourceSchema }),
+        output: z.strictObject({ file: z.string(), restartRequired: z.literal(true) }),
+    },
+    'kernel.extensions.uninstall': {
+        input: z.strictObject({ name: packageNameSchema }),
+        output: z.strictObject({ file: z.string(), restartRequired: z.literal(true) }),
+    },
+    'kernel.restart': { input: emptySchema, output: z.strictObject({ restarting: z.literal(true) }) },
+};
+/** The input and output schemas of the kernel's own queries (plan 02 §2.12). */
+export const kernelQuerySchemas = {
+    'kernel.workspace.list': { input: emptySchema, output: z.array(workspaceSchema) },
+    'kernel.folder.list': { input: z.strictObject({ path: z.string().min(1).exactOptional(), hidden: z.boolean().exactOptional() }), output: folderListSchema },
+    'kernel.settings.list': { input: emptySchema, output: z.array(settingInfoSchema) },
+    'kernel.secrets.list': { input: emptySchema, output: z.array(z.strictObject({ extension: z.string(), name: z.string() })) },
+    'kernel.jobs.get': { input: z.strictObject({ id: z.string().min(1) }), output: jobSchema },
+    'kernel.jobs.list': { input: z.strictObject({ status: jobStatusSchema.optional(), limit: listLimitSchema }), output: z.array(jobSchema) },
+    'kernel.files.get': { input: z.strictObject({ id: z.string().min(1) }), output: fileSchema },
+    'kernel.files.list': { input: z.strictObject({ limit: listLimitSchema }), output: z.array(fileSchema) },
+    'kernel.extensions.list': { input: emptySchema, output: z.array(extensionInfoSchema) },
+    'kernel.registrations.list': { input: emptySchema, output: z.array(registrationRowSchema) },
+    'kernel.preset.get': { input: emptySchema, output: presetStateSchema },
+    'kernel.processes.list': { input: emptySchema, output: z.array(processRowSchema) },
+    'kernel.health.get': { input: emptySchema, output: healthSchema },
+};
+//# sourceMappingURL=kernel-api.js.map