@allyhub/sdk 0.1.0-alpha.8 → 0.2.0-next.0

package/node_modules/@allyhub-next/protocol/dist/editor.d.ts

@@ -0,0 +1,405 @@
+import { z } from "zod";
+import { type ClientOf } from "./jsonrpc.js";
+export declare const ThemeSchema: z.ZodEnum<{
+    light: "light";
+    dark: "dark";
+}>;
+export declare const HostContextSchema: z.ZodObject<{
+    locale: z.ZodString;
+    theme: z.ZodEnum<{
+        light: "light";
+        dark: "dark";
+    }>;
+    agent: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>>;
+    project: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strict>;
+    item: z.ZodObject<{
+        kind: z.ZodEnum<{
+            video: "video";
+            slides: "slides";
+            doc: "doc";
+            sheet: "sheet";
+            scenery: "scenery";
+            website: "website";
+        }>;
+        dir: z.ZodString;
+        entry: z.ZodString;
+    }, z.core.$strict>;
+    editor: z.ZodEnum<{
+        video: "video";
+        slides: "slides";
+        doc: "doc";
+        sheet: "sheet";
+        scenery: "scenery";
+        website: "website";
+    }>;
+}, z.core.$strict>;
+export type HostContext = z.infer<typeof HostContextSchema>;
+/** What `items/open` shows: a file of the project, or a browser page (as Codex's `open_in_codex` names it). */
+export declare const OpenTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    path: z.ZodString;
+    line: z.ZodOptional<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"browser">;
+    url: z.ZodOptional<z.ZodURL>;
+    tabId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "type">;
+export type OpenTarget = z.infer<typeof OpenTargetSchema>;
+export declare const EDITOR_STATES: readonly ["saved", "saving", "unsaved", "error"];
+export declare const HOST_METHODS: {
+    readonly "host/context": import("./jsonrpc.js").MethodSpec<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+        locale: z.ZodString;
+        theme: z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>;
+        agent: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        project: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>;
+        item: z.ZodObject<{
+            kind: z.ZodEnum<{
+                video: "video";
+                slides: "slides";
+                doc: "doc";
+                sheet: "sheet";
+                scenery: "scenery";
+                website: "website";
+            }>;
+            dir: z.ZodString;
+            entry: z.ZodString;
+        }, z.core.$strict>;
+        editor: z.ZodEnum<{
+            video: "video";
+            slides: "slides";
+            doc: "doc";
+            sheet: "sheet";
+            scenery: "scenery";
+            website: "website";
+        }>;
+    }, z.core.$strict>>;
+    readonly "items/open": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            path: z.ZodString;
+            line: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"browser">;
+            url: z.ZodOptional<z.ZodURL>;
+            tabId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "storage/get": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnknown;
+    }, z.core.$strict>>;
+    readonly "storage/set": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "editor/state": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        state: z.ZodEnum<{
+            error: "error";
+            saved: "saved";
+            saving: "saving";
+            unsaved: "unsaved";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "editor/context": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        text: z.ZodString;
+        at: z.ZodOptional<z.ZodObject<{
+            t: z.ZodNumber;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        picture: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "tools/call": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        name: z.ZodString;
+        arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        result: z.ZodUnknown;
+    }, z.core.$strict>>;
+};
+export declare const HOST_NOTIFICATIONS: {
+    readonly "project/changed": import("./jsonrpc.js").NotificationSpec<z.ZodObject<{
+        revision: z.ZodInt;
+    }, z.core.$strict>>;
+    readonly "check/changed": import("./jsonrpc.js").NotificationSpec<z.ZodObject<{
+        status: z.ZodEnum<{
+            off: "off";
+            waiting: "waiting";
+            running: "running";
+            done: "done";
+            failed: "failed";
+        }>;
+        revision: z.ZodInt;
+        problems: z.ZodArray<z.ZodObject<{
+            code: z.ZodString;
+            level: z.ZodEnum<{
+                error: "error";
+                warn: "warn";
+            }>;
+            message: z.ZodString;
+            piece: z.ZodOptional<z.ZodString>;
+            part: z.ZodOptional<z.ZodString>;
+            t: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        facts: z.ZodArray<z.ZodObject<{
+            kind: z.ZodString;
+            data: z.ZodUnknown;
+        }, z.core.$loose>>;
+        versions: z.ZodOptional<z.ZodObject<{
+            total: z.ZodInt;
+            loaded: z.ZodInt;
+            reused: z.ZodInt;
+        }, z.core.$strict>>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "export/changed": import("./jsonrpc.js").NotificationSpec<z.ZodObject<{
+        job: z.ZodObject<{
+            id: z.ZodString;
+            item: z.ZodString;
+            versions: z.ZodArray<z.ZodString>;
+            types: z.ZodArray<z.ZodString>;
+            state: z.ZodEnum<{
+                running: "running";
+                done: "done";
+                failed: "failed";
+                queued: "queued";
+                cancelled: "cancelled";
+            }>;
+            progress: z.ZodNumber;
+            files: z.ZodArray<z.ZodString>;
+            error: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    readonly "index/changed": import("./jsonrpc.js").NotificationSpec<z.ZodObject<{
+        jobs: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            status: z.ZodEnum<{
+                running: "running";
+                done: "done";
+                failed: "failed";
+            }>;
+            message: z.ZodString;
+            share: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly "files/changed": import("./jsonrpc.js").NotificationSpec<z.ZodObject<{
+        watch: z.ZodString;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            version: z.ZodNullable<z.ZodString>;
+            by: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    person: "person";
+                    agent: "agent";
+                    tool: "tool";
+                }>;
+                name: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly "host/context-changed": import("./jsonrpc.js").NotificationSpec<z.ZodObject<{
+        locale: z.ZodString;
+        theme: z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>;
+        agent: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        project: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>;
+        item: z.ZodObject<{
+            kind: z.ZodEnum<{
+                video: "video";
+                slides: "slides";
+                doc: "doc";
+                sheet: "sheet";
+                scenery: "scenery";
+                website: "website";
+            }>;
+            dir: z.ZodString;
+            entry: z.ZodString;
+        }, z.core.$strict>;
+        editor: z.ZodEnum<{
+            video: "video";
+            slides: "slides";
+            doc: "doc";
+            sheet: "sheet";
+            scenery: "scenery";
+            website: "website";
+        }>;
+    }, z.core.$strict>>;
+};
+/** Every method an editor may call on its host. */
+export declare const EDITOR_HOST_METHODS: {
+    readonly "host/context": import("./jsonrpc.js").MethodSpec<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+        locale: z.ZodString;
+        theme: z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>;
+        agent: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>;
+        project: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>;
+        item: z.ZodObject<{
+            kind: z.ZodEnum<{
+                video: "video";
+                slides: "slides";
+                doc: "doc";
+                sheet: "sheet";
+                scenery: "scenery";
+                website: "website";
+            }>;
+            dir: z.ZodString;
+            entry: z.ZodString;
+        }, z.core.$strict>;
+        editor: z.ZodEnum<{
+            video: "video";
+            slides: "slides";
+            doc: "doc";
+            sheet: "sheet";
+            scenery: "scenery";
+            website: "website";
+        }>;
+    }, z.core.$strict>>;
+    readonly "items/open": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"file">;
+            path: z.ZodString;
+            line: z.ZodOptional<z.ZodInt>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"browser">;
+            url: z.ZodOptional<z.ZodURL>;
+            tabId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "type">;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "storage/get": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        key: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        value: z.ZodUnknown;
+    }, z.core.$strict>>;
+    readonly "storage/set": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodUnknown;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "editor/state": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        state: z.ZodEnum<{
+            error: "error";
+            saved: "saved";
+            saving: "saving";
+            unsaved: "unsaved";
+        }>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "editor/context": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        text: z.ZodString;
+        at: z.ZodOptional<z.ZodObject<{
+            t: z.ZodNumber;
+            version: z.ZodString;
+        }, z.core.$strict>>;
+        picture: z.ZodOptional<z.ZodObject<{
+            x: z.ZodNumber;
+            y: z.ZodNumber;
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+    readonly "tools/call": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        name: z.ZodString;
+        arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>, z.ZodObject<{
+        result: z.ZodUnknown;
+    }, z.core.$strict>>;
+    readonly "files/read": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        text: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/write": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+        text: z.ZodString;
+        over: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/upload": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        dir: z.ZodString;
+        name: z.ZodString;
+        data: z.ZodBase64;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/url": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/list": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        dir: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            size: z.ZodInt;
+            modified: z.ZodNumber;
+        }, z.core.$strict>>;
+        dirs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/move": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        rewritten: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/remove": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        trash: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/trash": import("./jsonrpc.js").MethodSpec<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            removed: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly "files/restore": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/watch": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        watch: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/unwatch": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        watch: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+};
+/** What an editor holds: its host, as typed calls. */
+export type EditorHost = ClientOf<typeof EDITOR_HOST_METHODS> & {
+    /** Tells `files/changed`, `host/context-changed` and the tools' notifications; answers how to stop. */
+    on<N extends keyof typeof HOST_NOTIFICATIONS>(name: N, listener: (params: z.output<(typeof HOST_NOTIFICATIONS)[N]["params"]>) => void): () => void;
+};
+//# sourceMappingURL=editor.d.ts.map

package/node_modules/@allyhub-next/protocol/dist/editor.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{z as t}from"zod";import{EDITORS as r,KINDS as s}from"@allyhub-next/formats";import{FILE_METHODS as n,FILE_NOTIFICATIONS as i,PathSchema as o}from"./files.js";import{method as e,notification as a}from"./jsonrpc.js";import{TOOL_NOTIFICATIONS as c}from"./tools.js";export const ThemeSchema=t.enum(["light","dark"]),HostContextSchema=t.strictObject({locale:t.string().min(2),theme:ThemeSchema,agent:t.strictObject({name:t.string().min(1)}).optional(),project:t.strictObject({name:t.string().min(1)}),item:t.strictObject({kind:t.enum(s),dir:o,entry:o}),editor:t.enum(r)}),OpenTargetSchema=t.discriminatedUnion("type",[t.strictObject({type:t.literal("file"),path:o,line:t.int().positive().optional()}),t.strictObject({type:t.literal("browser"),url:t.url({protocol:/^https?$/u}).optional(),tabId:t.string().min(1).optional()})]),EDITOR_STATES=["saved","saving","unsaved","error"],HOST_METHODS={"host/context":e(t.strictObject({}),HostContextSchema,"Where the editor runs."),"items/open":e(t.strictObject({target:OpenTargetSchema}),t.strictObject({}),"Shows another item, a file or a page, where the host shows things."),"storage/get":e(t.strictObject({key:t.string().min(1)}),t.strictObject({value:t.unknown()}),"What the editor kept for this person on this computer (a hand sort, what was last seen), or null."),"storage/set":e(t.strictObject({key:t.string().min(1),value:t.unknown()}),t.strictObject({}),"Keeps a value for this person on this computer; null removes it."),"editor/state":e(t.strictObject({state:t.enum(EDITOR_STATES),message:t.string().optional()}),t.strictObject({}),"Says whether what the person typed is saved."),"editor/context":e(t.strictObject({text:t.string(),at:t.strictObject({t:t.number().nonnegative(),version:t.string()}).optional(),picture:t.strictObject({x:t.number(),y:t.number(),width:t.number().positive(),height:t.number().positive()}).optional()}),t.strictObject({}),"Tells the host what the editor shows, as MCP Apps' ui/update-model-context does: what a note the person makes on it is about."),"tools/call":e(t.strictObject({name:t.string().min(1),arguments:t.record(t.string(),t.unknown()).default({})}),t.strictObject({result:t.unknown()}),"Runs one of the project server's tools (tools.ts's PROJECT_TOOLS), for an editor that needs more than files (a video's preview, a still).")},HOST_NOTIFICATIONS={"host/context-changed":a(HostContextSchema,"The language, theme or agent changed."),...i,...c},EDITOR_HOST_METHODS={...n,...HOST_METHODS};

package/node_modules/@allyhub-next/protocol/dist/files.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+/** A project path: forward slashes, inside the project, no `..`. */
+export declare const PathSchema: z.ZodString;
+/** The sha256 of a file's bytes, or null for a file that is not there. */
+export declare const VersionSchema: z.ZodNullable<z.ZodString>;
+/** Who changed a file, when the host knows. */
+export declare const WriterSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        person: "person";
+        agent: "agent";
+        tool: "tool";
+    }>;
+    name: z.ZodString;
+}, z.core.$strict>;
+export type Writer = z.infer<typeof WriterSchema>;
+export declare const FILE_METHODS: {
+    readonly "files/read": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        text: z.ZodString;
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/write": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+        text: z.ZodString;
+        over: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/upload": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        dir: z.ZodString;
+        name: z.ZodString;
+        data: z.ZodBase64;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/url": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/list": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        dir: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            size: z.ZodInt;
+            modified: z.ZodNumber;
+        }, z.core.$strict>>;
+        dirs: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/move": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        rewritten: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    readonly "files/remove": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        trash: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/trash": import("./jsonrpc.js").MethodSpec<z.ZodObject<{}, z.core.$strict>, z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            removed: z.ZodNumber;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    readonly "files/restore": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/watch": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        paths: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        watch: z.ZodString;
+    }, z.core.$strict>>;
+    readonly "files/unwatch": import("./jsonrpc.js").MethodSpec<z.ZodObject<{
+        watch: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{}, z.core.$strict>>;
+};
+export declare const FILE_NOTIFICATIONS: {
+    readonly "files/changed": import("./jsonrpc.js").NotificationSpec<z.ZodObject<{
+        watch: z.ZodString;
+        changes: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            version: z.ZodNullable<z.ZodString>;
+            by: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    person: "person";
+                    agent: "agent";
+                    tool: "tool";
+                }>;
+                name: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+};
+//# sourceMappingURL=files.d.ts.map

package/node_modules/@allyhub-next/protocol/dist/files.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{z as t}from"zod";import{method as e,notification as r}from"./jsonrpc.js";export const PathSchema=t.string().min(1).refine(i=>!i.startsWith("/")&&!i.split("/").includes(".."),{message:"A path is inside the project."}),VersionSchema=t.string().regex(/^[0-9a-f]{64}$/u).nullable(),WriterSchema=t.strictObject({kind:t.enum(["person","agent","tool"]),name:t.string().min(1)});const s=t.strictObject({path:PathSchema,size:t.int().nonnegative(),modified:t.number()});export const FILE_METHODS={"files/read":e(t.strictObject({path:PathSchema}),t.strictObject({text:t.string(),version:VersionSchema}),"A text file, with its version; a file that is not there reads as empty with version null."),"files/write":e(t.strictObject({path:PathSchema,text:t.string(),over:VersionSchema}),t.strictObject({version:VersionSchema}),"Writes a text file over the version read. Errors: conflict (data: { text, version }) when it changed; invalid (data: { problems }) when its format refuses it."),"files/upload":e(t.strictObject({dir:PathSchema,name:t.string().min(1),data:t.base64()}),t.strictObject({path:PathSchema}),"Keeps a file the person added, under a free name in the folder."),"files/url":e(t.strictObject({path:PathSchema}),t.strictObject({url:t.string()}),"An address a page can load the file from (a picture, a video)."),"files/list":e(t.strictObject({dir:t.string()}),t.strictObject({files:t.array(s),dirs:t.array(PathSchema)}),"A folder's files and folders, as on disk."),"files/move":e(t.strictObject({from:PathSchema,to:PathSchema}),t.strictObject({rewritten:t.array(PathSchema)}),"Moves a file or a folder, and rewrites the relative imports and links that pointed at it, as an editor does."),"files/remove":e(t.strictObject({path:PathSchema}),t.strictObject({trash:t.string()}),"Moves a file or folder to the recycle bin (nothing is deleted)."),"files/trash":e(t.strictObject({}),t.strictObject({entries:t.array(t.strictObject({id:t.string(),path:PathSchema,removed:t.number()}))}),"What the recycle bin holds."),"files/restore":e(t.strictObject({id:t.string()}),t.strictObject({path:PathSchema}),"Puts a removed thing back where it was; refused while something is there."),"files/watch":e(t.strictObject({paths:t.array(PathSchema).min(1)}),t.strictObject({watch:t.string()}),"Starts telling `files/changed` for these files or folders."),"files/unwatch":e(t.strictObject({watch:t.string()}),t.strictObject({}),"Stops a watch.")},FILE_NOTIFICATIONS={"files/changed":r(t.strictObject({watch:t.string(),changes:t.array(t.strictObject({path:PathSchema,version:VersionSchema,by:WriterSchema.optional()}))}),"Files under a watch changed, other than by this client's own writes.")};

package/node_modules/@allyhub-next/protocol/dist/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./jsonrpc.js";
+export * from "./files.js";
+export * from "./editor.js";
+export * from "./tools.js";
+export * from "./cli.js";
+export * from "./auth.js";
+export * from "./registry.js";
+export * from "./runtimes.js";
+export * from "./cloud.js";
+export * from "./teams.js";
+export * from "./app.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@allyhub-next/protocol/dist/index.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+export*from"./jsonrpc.js";export*from"./files.js";export*from"./editor.js";export*from"./tools.js";export*from"./cli.js";export*from"./auth.js";export*from"./registry.js";export*from"./runtimes.js";export*from"./cloud.js";export*from"./teams.js";export*from"./app.js";

package/node_modules/@allyhub-next/protocol/dist/jsonrpc.d.ts

@@ -0,0 +1,83 @@
+import { z } from "zod";
+export declare const JSONRPC: "2.0";
+export declare const RequestSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodInt]>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type Request = z.infer<typeof RequestSchema>;
+export declare const NotificationSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type Notification = z.infer<typeof NotificationSchema>;
+export declare const ErrorObjectSchema: z.ZodObject<{
+    code: z.ZodInt;
+    message: z.ZodString;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strict>;
+export type ErrorObject = z.infer<typeof ErrorObjectSchema>;
+export declare const ResponseSchema: z.ZodUnion<readonly [z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodInt]>;
+    result: z.ZodUnknown;
+}, z.core.$strict>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<readonly [z.ZodString, z.ZodInt, z.ZodNull]>;
+    error: z.ZodObject<{
+        code: z.ZodInt;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type Response = z.infer<typeof ResponseSchema>;
+/** JSON-RPC's own codes, and AllyHub's in the range it leaves for servers. */
+export declare const RPC_ERROR: {
+    readonly parse: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internal: -32603;
+    /** The file changed since the version it was written over: `data` says what it is now. */
+    readonly conflict: -32001;
+    readonly notFound: -32002;
+    /** The content is not what its format allows: `data.problems` says where. */
+    readonly invalid: -32003;
+    readonly forbidden: -32004;
+    /** It cannot run here or now; `message` says why. */
+    readonly unavailable: -32005;
+};
+export interface MethodSpec<P extends z.ZodType = z.ZodType, R extends z.ZodType = z.ZodType> {
+    params: P;
+    result: R;
+    /** What it does, for a reader of the protocol. */
+    about: string;
+}
+export interface NotificationSpec<P extends z.ZodType = z.ZodType> {
+    params: P;
+    about: string;
+}
+export declare const method: <P extends z.ZodType, R extends z.ZodType>(params: P, result: R, about: string) => MethodSpec<P, R>;
+export declare const notification: <P extends z.ZodType>(params: P, about: string) => NotificationSpec<P>;
+/** A typed client of a table of methods: what a caller holds. */
+export type ClientOf<M extends Record<string, MethodSpec>> = {
+    [K in keyof M]: (params: z.input<M[K]["params"]>) => Promise<z.output<M[K]["result"]>>;
+};
+/** A typed server of a table of methods: what an implementer writes. */
+export type HandlersOf<M extends Record<string, MethodSpec>> = {
+    [K in keyof M]: (params: z.output<M[K]["params"]>) => Promise<z.input<M[K]["result"]>>;
+};
+/** An error a handler throws to answer with a JSON-RPC error. */
+export declare class RpcError extends Error {
+    readonly code: number;
+    readonly data: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/**
+ * Answers one request from a table of handlers: params checked, result
+ * checked, errors as JSON-RPC errors. Transports wrap this.
+ */
+export declare function answer<M extends Record<string, MethodSpec>>(methods: M, handlers: HandlersOf<M>, request: Request): Promise<Response>;
+//# sourceMappingURL=jsonrpc.d.ts.map

package/node_modules/@allyhub-next/protocol/dist/jsonrpc.js

@@ -0,0 +1,2 @@
+/*! AllyHub. Copyright (c) 2026 AllyHub, Inc. All rights reserved. Use is subject to LICENSE.md. */
+import{z as r}from"zod";export const JSONRPC="2.0",RequestSchema=r.strictObject({jsonrpc:r.literal(JSONRPC),id:r.union([r.string(),r.int()]),method:r.string().min(1),params:r.unknown().optional()}),NotificationSchema=r.strictObject({jsonrpc:r.literal(JSONRPC),method:r.string().min(1),params:r.unknown().optional()}),ErrorObjectSchema=r.strictObject({code:r.int(),message:r.string(),data:r.unknown().optional()}),ResponseSchema=r.union([r.strictObject({jsonrpc:r.literal(JSONRPC),id:r.union([r.string(),r.int()]),result:r.unknown()}),r.strictObject({jsonrpc:r.literal(JSONRPC),id:r.union([r.string(),r.int(),r.null()]),error:ErrorObjectSchema})]),RPC_ERROR={parse:-32700,invalidRequest:-32600,methodNotFound:-32601,invalidParams:-32602,internal:-32603,conflict:-32001,notFound:-32002,invalid:-32003,forbidden:-32004,unavailable:-32005},method=(o,e,t)=>({params:o,result:e,about:t}),notification=(o,e)=>({params:o,about:e});export class RpcError extends Error{code;data;constructor(e,t,s){super(t),this.name="RpcError",this.code=e,this.data=s}}export async function answer(o,e,t){const{id:s}=t,a=Object.hasOwn(o,t.method)?o[t.method]:void 0;if(!a)return{jsonrpc:JSONRPC,id:s,error:{code:RPC_ERROR.methodNotFound,message:`There is no method "${t.method}".`}};const i=a.params.safeParse(t.params??{});if(!i.success)return{jsonrpc:JSONRPC,id:s,error:{code:RPC_ERROR.invalidParams,message:r.prettifyError(i.error)}};try{const n=e[t.method],c=await n(i.data);return{jsonrpc:JSONRPC,id:s,result:a.result.parse(c)}}catch(n){return n instanceof RpcError?{jsonrpc:JSONRPC,id:s,error:{code:n.code,message:n.message,...n.data===void 0?{}:{data:n.data}}}:{jsonrpc:JSONRPC,id:s,error:{code:RPC_ERROR.internal,message:n instanceof Error?n.message:String(n)}}}}