@nuvio/shared 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Nuvio contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# `@nuvio/shared`
+
+Wire protocol (Zod schemas), shared TypeScript types, and Node path helpers (`secure-path` export) used by `@nuvio/vite-plugin` and `@nuvio/overlay`.
+
+See the [Nuvio README](../../README.md) and [CHANGELOG](../../CHANGELOG.md).

package/dist/index.d.ts

@@ -0,0 +1,877 @@
+import { z } from 'zod';
+
+/** WebSocket path on the Vite dev server (must match `configureServer` upgrade handler). */
+declare const NUVIO_WS_PATH: "/__nuvio/ws";
+
+/** Bump when wire payloads change incompatibly. */
+declare const PROTOCOL_VERSION: 4;
+declare const indexEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    file: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    file: string;
+    line: number;
+    column: number;
+}, {
+    id: string;
+    file: string;
+    line: number;
+    column: number;
+}>;
+type IndexWireEntry = z.infer<typeof indexEntrySchema>;
+declare const duplicateIdOccurrenceSchema: z.ZodObject<{
+    file: z.ZodString;
+    line: z.ZodNumber;
+    column: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    file: string;
+    line: number;
+    column: number;
+}, {
+    file: string;
+    line: number;
+    column: number;
+}>;
+declare const duplicateIdErrorSchema: z.ZodObject<{
+    id: z.ZodString;
+    occurrences: z.ZodArray<z.ZodObject<{
+        file: z.ZodString;
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        file: string;
+        line: number;
+        column: number;
+    }, {
+        file: string;
+        line: number;
+        column: number;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    occurrences: {
+        file: string;
+        line: number;
+        column: number;
+    }[];
+}, {
+    id: string;
+    occurrences: {
+        file: string;
+        line: number;
+        column: number;
+    }[];
+}>;
+type DuplicateIdError = z.infer<typeof duplicateIdErrorSchema>;
+declare const clientPingSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "ping";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    type: "ping";
+    protocolVersion: number;
+    requestId: string;
+}>;
+type ClientPing = z.infer<typeof clientPingSchema>;
+declare const clientSelectSchema: z.ZodObject<{
+    type: z.ZodLiteral<"select">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "select";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    id: string;
+    type: "select";
+    protocolVersion: number;
+    requestId: string;
+}>;
+type ClientSelect = z.infer<typeof clientSelectSchema>;
+declare const patchOpSetTextSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"setText">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "setText";
+    text: string;
+}, {
+    kind: "setText";
+    text: string;
+}>;
+declare const patchOpMergeTailwindSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"mergeTailwindClassName">;
+    classNameFragment: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "mergeTailwindClassName";
+    classNameFragment: string;
+}, {
+    kind: "mergeTailwindClassName";
+    classNameFragment: string;
+}>;
+/** Reorder host among JSX element siblings under a flex/grid parent (Phase 4). */
+declare const patchOpMoveSiblingSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"moveSibling">;
+    direction: z.ZodEnum<["up", "down"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "moveSibling";
+    direction: "up" | "down";
+}, {
+    kind: "moveSibling";
+    direction: "up" | "down";
+}>;
+/** Toggle `hidden` on a string-literal className (Phase 4 toolbar). */
+declare const patchOpSetHiddenSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"setHidden">;
+    hidden: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    kind: "setHidden";
+    hidden: boolean;
+}, {
+    kind: "setHidden";
+    hidden: boolean;
+}>;
+/** Clone the host JSX element with a new unique `data-nuvio-id` (Phase 4 toolbar). */
+declare const patchOpDuplicateHostSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"duplicateHost">;
+}, "strip", z.ZodTypeAny, {
+    kind: "duplicateHost";
+}, {
+    kind: "duplicateHost";
+}>;
+declare const patchOpSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"setText">;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "setText";
+    text: string;
+}, {
+    kind: "setText";
+    text: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"mergeTailwindClassName">;
+    classNameFragment: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    kind: "mergeTailwindClassName";
+    classNameFragment: string;
+}, {
+    kind: "mergeTailwindClassName";
+    classNameFragment: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"moveSibling">;
+    direction: z.ZodEnum<["up", "down"]>;
+}, "strip", z.ZodTypeAny, {
+    kind: "moveSibling";
+    direction: "up" | "down";
+}, {
+    kind: "moveSibling";
+    direction: "up" | "down";
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"setHidden">;
+    hidden: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    kind: "setHidden";
+    hidden: boolean;
+}, {
+    kind: "setHidden";
+    hidden: boolean;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"duplicateHost">;
+}, "strip", z.ZodTypeAny, {
+    kind: "duplicateHost";
+}, {
+    kind: "duplicateHost";
+}>]>;
+type PatchOp = z.infer<typeof patchOpSchema>;
+declare const clientPatchApplySchema: z.ZodObject<{
+    type: z.ZodLiteral<"patchApply">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+    ops: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"setText">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "setText";
+        text: string;
+    }, {
+        kind: "setText";
+        text: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"mergeTailwindClassName">;
+        classNameFragment: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    }, {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"moveSibling">;
+        direction: z.ZodEnum<["up", "down"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    }, {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"setHidden">;
+        hidden: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        kind: "setHidden";
+        hidden: boolean;
+    }, {
+        kind: "setHidden";
+        hidden: boolean;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"duplicateHost">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "duplicateHost";
+    }, {
+        kind: "duplicateHost";
+    }>]>, "many">;
+    /** When true, server validates and returns `patchAck` with `diffSummary` but does not write disk or push undo. */
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "patchApply";
+    protocolVersion: number;
+    requestId: string;
+    ops: ({
+        kind: "setText";
+        text: string;
+    } | {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    } | {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    } | {
+        kind: "setHidden";
+        hidden: boolean;
+    } | {
+        kind: "duplicateHost";
+    })[];
+    dryRun?: boolean | undefined;
+}, {
+    id: string;
+    type: "patchApply";
+    protocolVersion: number;
+    requestId: string;
+    ops: ({
+        kind: "setText";
+        text: string;
+    } | {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    } | {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    } | {
+        kind: "setHidden";
+        hidden: boolean;
+    } | {
+        kind: "duplicateHost";
+    })[];
+    dryRun?: boolean | undefined;
+}>;
+type ClientPatchApply = z.infer<typeof clientPatchApplySchema>;
+declare const clientPatchUndoSchema: z.ZodObject<{
+    type: z.ZodLiteral<"patchUndo">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "patchUndo";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    type: "patchUndo";
+    protocolVersion: number;
+    requestId: string;
+}>;
+type ClientPatchUndo = z.infer<typeof clientPatchUndoSchema>;
+declare const clientMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "ping";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    type: "ping";
+    protocolVersion: number;
+    requestId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"select">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "select";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    id: string;
+    type: "select";
+    protocolVersion: number;
+    requestId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"patchApply">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+    ops: z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+        kind: z.ZodLiteral<"setText">;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "setText";
+        text: string;
+    }, {
+        kind: "setText";
+        text: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"mergeTailwindClassName">;
+        classNameFragment: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    }, {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"moveSibling">;
+        direction: z.ZodEnum<["up", "down"]>;
+    }, "strip", z.ZodTypeAny, {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    }, {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"setHidden">;
+        hidden: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        kind: "setHidden";
+        hidden: boolean;
+    }, {
+        kind: "setHidden";
+        hidden: boolean;
+    }>, z.ZodObject<{
+        kind: z.ZodLiteral<"duplicateHost">;
+    }, "strip", z.ZodTypeAny, {
+        kind: "duplicateHost";
+    }, {
+        kind: "duplicateHost";
+    }>]>, "many">;
+    /** When true, server validates and returns `patchAck` with `diffSummary` but does not write disk or push undo. */
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "patchApply";
+    protocolVersion: number;
+    requestId: string;
+    ops: ({
+        kind: "setText";
+        text: string;
+    } | {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    } | {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    } | {
+        kind: "setHidden";
+        hidden: boolean;
+    } | {
+        kind: "duplicateHost";
+    })[];
+    dryRun?: boolean | undefined;
+}, {
+    id: string;
+    type: "patchApply";
+    protocolVersion: number;
+    requestId: string;
+    ops: ({
+        kind: "setText";
+        text: string;
+    } | {
+        kind: "mergeTailwindClassName";
+        classNameFragment: string;
+    } | {
+        kind: "moveSibling";
+        direction: "up" | "down";
+    } | {
+        kind: "setHidden";
+        hidden: boolean;
+    } | {
+        kind: "duplicateHost";
+    })[];
+    dryRun?: boolean | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"patchUndo">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "patchUndo";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    type: "patchUndo";
+    protocolVersion: number;
+    requestId: string;
+}>]>;
+type ClientMessage = z.infer<typeof clientMessageSchema>;
+declare const serverPongSchema: z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pong";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    type: "pong";
+    protocolVersion: number;
+    requestId: string;
+}>;
+declare const serverErrorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    code: z.ZodString;
+    message: z.ZodString;
+    requestId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    type: "error";
+    requestId?: string | undefined;
+}, {
+    code: string;
+    message: string;
+    type: "error";
+    requestId?: string | undefined;
+}>;
+declare const serverIndexReadySchema: z.ZodObject<{
+    type: z.ZodLiteral<"indexReady">;
+    protocolVersion: z.ZodNumber;
+    indexVersion: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        file: z.ZodString;
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }, {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }>, "many">;
+    duplicateErrors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        occurrences: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            line: number;
+            column: number;
+        }, {
+            file: string;
+            line: number;
+            column: number;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }, {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "indexReady";
+    entries: {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }[];
+    protocolVersion: number;
+    indexVersion: number;
+    duplicateErrors: {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }[];
+}, {
+    type: "indexReady";
+    entries: {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }[];
+    protocolVersion: number;
+    indexVersion: number;
+    duplicateErrors: {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }[];
+}>;
+type ServerIndexReady = z.infer<typeof serverIndexReadySchema>;
+declare const serverSelectAckSchema: z.ZodObject<{
+    type: z.ZodLiteral<"selectAck">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+    ok: z.ZodBoolean;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+    errorCode: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "selectAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    line?: number | undefined;
+    column?: number | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+}, {
+    id: string;
+    type: "selectAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    line?: number | undefined;
+    column?: number | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+}>;
+type ServerSelectAck = z.infer<typeof serverSelectAckSchema>;
+declare const serverPatchAckSchema: z.ZodObject<{
+    type: z.ZodLiteral<"patchAck">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+    ok: z.ZodBoolean;
+    diffSummary: z.ZodOptional<z.ZodString>;
+    /** Present when this ack is for a `patchApply` with `dryRun: true`. */
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    /** Absolute path written on successful non-dry apply (for touched-file log). */
+    writtenFile: z.ZodOptional<z.ZodString>;
+    /** Server undo stack size after this apply (non-dry success only). */
+    undoStackDepth: z.ZodOptional<z.ZodNumber>;
+    errorCode: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "patchAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    dryRun?: boolean | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    diffSummary?: string | undefined;
+    writtenFile?: string | undefined;
+    undoStackDepth?: number | undefined;
+}, {
+    id: string;
+    type: "patchAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    dryRun?: boolean | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    diffSummary?: string | undefined;
+    writtenFile?: string | undefined;
+    undoStackDepth?: number | undefined;
+}>;
+type ServerPatchAck = z.infer<typeof serverPatchAckSchema>;
+declare const serverPatchUndoAckSchema: z.ZodObject<{
+    type: z.ZodLiteral<"patchUndoAck">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    ok: z.ZodBoolean;
+    file: z.ZodOptional<z.ZodString>;
+    /** Remaining in-memory undo snapshots after this undo (success only). */
+    undoStackDepth: z.ZodOptional<z.ZodNumber>;
+    errorCode: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "patchUndoAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    undoStackDepth?: number | undefined;
+}, {
+    type: "patchUndoAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    undoStackDepth?: number | undefined;
+}>;
+type ServerPatchUndoAck = z.infer<typeof serverPatchUndoAckSchema>;
+declare const serverMessageSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"pong">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "pong";
+    protocolVersion: number;
+    requestId: string;
+}, {
+    type: "pong";
+    protocolVersion: number;
+    requestId: string;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    code: z.ZodString;
+    message: z.ZodString;
+    requestId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    type: "error";
+    requestId?: string | undefined;
+}, {
+    code: string;
+    message: string;
+    type: "error";
+    requestId?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"indexReady">;
+    protocolVersion: z.ZodNumber;
+    indexVersion: z.ZodNumber;
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        file: z.ZodString;
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }, {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }>, "many">;
+    duplicateErrors: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        occurrences: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            line: number;
+            column: number;
+        }, {
+            file: string;
+            line: number;
+            column: number;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }, {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "indexReady";
+    entries: {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }[];
+    protocolVersion: number;
+    indexVersion: number;
+    duplicateErrors: {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }[];
+}, {
+    type: "indexReady";
+    entries: {
+        id: string;
+        file: string;
+        line: number;
+        column: number;
+    }[];
+    protocolVersion: number;
+    indexVersion: number;
+    duplicateErrors: {
+        id: string;
+        occurrences: {
+            file: string;
+            line: number;
+            column: number;
+        }[];
+    }[];
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"selectAck">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+    ok: z.ZodBoolean;
+    file: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    column: z.ZodOptional<z.ZodNumber>;
+    errorCode: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "selectAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    line?: number | undefined;
+    column?: number | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+}, {
+    id: string;
+    type: "selectAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    line?: number | undefined;
+    column?: number | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"patchAck">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    id: z.ZodString;
+    ok: z.ZodBoolean;
+    diffSummary: z.ZodOptional<z.ZodString>;
+    /** Present when this ack is for a `patchApply` with `dryRun: true`. */
+    dryRun: z.ZodOptional<z.ZodBoolean>;
+    /** Absolute path written on successful non-dry apply (for touched-file log). */
+    writtenFile: z.ZodOptional<z.ZodString>;
+    /** Server undo stack size after this apply (non-dry success only). */
+    undoStackDepth: z.ZodOptional<z.ZodNumber>;
+    errorCode: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    type: "patchAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    dryRun?: boolean | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    diffSummary?: string | undefined;
+    writtenFile?: string | undefined;
+    undoStackDepth?: number | undefined;
+}, {
+    id: string;
+    type: "patchAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    dryRun?: boolean | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    diffSummary?: string | undefined;
+    writtenFile?: string | undefined;
+    undoStackDepth?: number | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"patchUndoAck">;
+    protocolVersion: z.ZodNumber;
+    requestId: z.ZodString;
+    ok: z.ZodBoolean;
+    file: z.ZodOptional<z.ZodString>;
+    /** Remaining in-memory undo snapshots after this undo (success only). */
+    undoStackDepth: z.ZodOptional<z.ZodNumber>;
+    errorCode: z.ZodOptional<z.ZodString>;
+    errorMessage: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    type: "patchUndoAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    undoStackDepth?: number | undefined;
+}, {
+    type: "patchUndoAck";
+    protocolVersion: number;
+    requestId: string;
+    ok: boolean;
+    file?: string | undefined;
+    errorCode?: string | undefined;
+    errorMessage?: string | undefined;
+    undoStackDepth?: number | undefined;
+}>]>;
+type ServerMessage = z.infer<typeof serverMessageSchema>;
+declare function parseClientMessage(raw: string): ClientMessage | null;
+declare function parseServerMessage(raw: string): ServerMessage | null;
+declare function serializeServerMessage(msg: ServerMessage): string;
+
+export { type ClientMessage, type ClientPatchApply, type ClientPatchUndo, type ClientPing, type ClientSelect, type DuplicateIdError, type IndexWireEntry, NUVIO_WS_PATH, PROTOCOL_VERSION, type PatchOp, type ServerIndexReady, type ServerMessage, type ServerPatchAck, type ServerPatchUndoAck, type ServerSelectAck, clientMessageSchema, clientPatchApplySchema, clientPatchUndoSchema, clientPingSchema, clientSelectSchema, duplicateIdErrorSchema, duplicateIdOccurrenceSchema, indexEntrySchema, parseClientMessage, parseServerMessage, patchOpDuplicateHostSchema, patchOpMergeTailwindSchema, patchOpMoveSiblingSchema, patchOpSchema, patchOpSetHiddenSchema, patchOpSetTextSchema, serializeServerMessage, serverErrorSchema, serverIndexReadySchema, serverMessageSchema, serverPatchAckSchema, serverPatchUndoAckSchema, serverPongSchema, serverSelectAckSchema };

package/dist/index.js

@@ -0,0 +1,194 @@
+// src/constants.ts
+var NUVIO_WS_PATH = "/__nuvio/ws";
+
+// src/protocol.ts
+import { z } from "zod";
+var PROTOCOL_VERSION = 4;
+var indexEntrySchema = z.object({
+  id: z.string(),
+  file: z.string(),
+  line: z.number().int(),
+  column: z.number().int()
+});
+var duplicateIdOccurrenceSchema = z.object({
+  file: z.string(),
+  line: z.number().int(),
+  column: z.number().int()
+});
+var duplicateIdErrorSchema = z.object({
+  id: z.string(),
+  occurrences: z.array(duplicateIdOccurrenceSchema)
+});
+var clientPingSchema = z.object({
+  type: z.literal("ping"),
+  protocolVersion: z.number().int(),
+  requestId: z.string().min(1)
+});
+var clientSelectSchema = z.object({
+  type: z.literal("select"),
+  protocolVersion: z.number().int(),
+  requestId: z.string().min(1),
+  id: z.string().min(1)
+});
+var patchOpSetTextSchema = z.object({
+  kind: z.literal("setText"),
+  text: z.string()
+});
+var patchOpMergeTailwindSchema = z.object({
+  kind: z.literal("mergeTailwindClassName"),
+  classNameFragment: z.string()
+});
+var patchOpMoveSiblingSchema = z.object({
+  kind: z.literal("moveSibling"),
+  direction: z.enum(["up", "down"])
+});
+var patchOpSetHiddenSchema = z.object({
+  kind: z.literal("setHidden"),
+  hidden: z.boolean()
+});
+var patchOpDuplicateHostSchema = z.object({
+  kind: z.literal("duplicateHost")
+});
+var patchOpSchema = z.discriminatedUnion("kind", [
+  patchOpSetTextSchema,
+  patchOpMergeTailwindSchema,
+  patchOpMoveSiblingSchema,
+  patchOpSetHiddenSchema,
+  patchOpDuplicateHostSchema
+]);
+var clientPatchApplySchema = z.object({
+  type: z.literal("patchApply"),
+  protocolVersion: z.number().int(),
+  requestId: z.string().min(1),
+  id: z.string().min(1),
+  ops: z.array(patchOpSchema).min(1),
+  /** When true, server validates and returns `patchAck` with `diffSummary` but does not write disk or push undo. */
+  dryRun: z.boolean().optional()
+});
+var clientPatchUndoSchema = z.object({
+  type: z.literal("patchUndo"),
+  protocolVersion: z.number().int(),
+  requestId: z.string().min(1)
+});
+var clientMessageSchema = z.discriminatedUnion("type", [
+  clientPingSchema,
+  clientSelectSchema,
+  clientPatchApplySchema,
+  clientPatchUndoSchema
+]);
+var serverPongSchema = z.object({
+  type: z.literal("pong"),
+  protocolVersion: z.number().int(),
+  requestId: z.string()
+});
+var serverErrorSchema = z.object({
+  type: z.literal("error"),
+  code: z.string(),
+  message: z.string(),
+  requestId: z.string().optional()
+});
+var serverIndexReadySchema = z.object({
+  type: z.literal("indexReady"),
+  protocolVersion: z.number().int(),
+  indexVersion: z.number().int(),
+  entries: z.array(indexEntrySchema),
+  duplicateErrors: z.array(duplicateIdErrorSchema)
+});
+var serverSelectAckSchema = z.object({
+  type: z.literal("selectAck"),
+  protocolVersion: z.number().int(),
+  requestId: z.string(),
+  id: z.string(),
+  ok: z.boolean(),
+  file: z.string().optional(),
+  line: z.number().int().optional(),
+  column: z.number().int().optional(),
+  errorCode: z.string().optional(),
+  errorMessage: z.string().optional()
+});
+var serverPatchAckSchema = z.object({
+  type: z.literal("patchAck"),
+  protocolVersion: z.number().int(),
+  requestId: z.string(),
+  id: z.string(),
+  ok: z.boolean(),
+  diffSummary: z.string().optional(),
+  /** Present when this ack is for a `patchApply` with `dryRun: true`. */
+  dryRun: z.boolean().optional(),
+  /** Absolute path written on successful non-dry apply (for touched-file log). */
+  writtenFile: z.string().optional(),
+  /** Server undo stack size after this apply (non-dry success only). */
+  undoStackDepth: z.number().int().optional(),
+  errorCode: z.string().optional(),
+  errorMessage: z.string().optional()
+});
+var serverPatchUndoAckSchema = z.object({
+  type: z.literal("patchUndoAck"),
+  protocolVersion: z.number().int(),
+  requestId: z.string(),
+  ok: z.boolean(),
+  file: z.string().optional(),
+  /** Remaining in-memory undo snapshots after this undo (success only). */
+  undoStackDepth: z.number().int().optional(),
+  errorCode: z.string().optional(),
+  errorMessage: z.string().optional()
+});
+var serverMessageSchema = z.discriminatedUnion("type", [
+  serverPongSchema,
+  serverErrorSchema,
+  serverIndexReadySchema,
+  serverSelectAckSchema,
+  serverPatchAckSchema,
+  serverPatchUndoAckSchema
+]);
+function parseClientMessage(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const r = clientMessageSchema.safeParse(json);
+  return r.success ? r.data : null;
+}
+function parseServerMessage(raw) {
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const r = serverMessageSchema.safeParse(json);
+  return r.success ? r.data : null;
+}
+function serializeServerMessage(msg) {
+  return JSON.stringify(msg);
+}
+export {
+  NUVIO_WS_PATH,
+  PROTOCOL_VERSION,
+  clientMessageSchema,
+  clientPatchApplySchema,
+  clientPatchUndoSchema,
+  clientPingSchema,
+  clientSelectSchema,
+  duplicateIdErrorSchema,
+  duplicateIdOccurrenceSchema,
+  indexEntrySchema,
+  parseClientMessage,
+  parseServerMessage,
+  patchOpDuplicateHostSchema,
+  patchOpMergeTailwindSchema,
+  patchOpMoveSiblingSchema,
+  patchOpSchema,
+  patchOpSetHiddenSchema,
+  patchOpSetTextSchema,
+  serializeServerMessage,
+  serverErrorSchema,
+  serverIndexReadySchema,
+  serverMessageSchema,
+  serverPatchAckSchema,
+  serverPatchUndoAckSchema,
+  serverPongSchema,
+  serverSelectAckSchema
+};

package/dist/secure-path.d.ts

@@ -0,0 +1,13 @@
+declare class PathEscapeError extends Error {
+    readonly root: string;
+    readonly candidate: string;
+    readonly name = "PathEscapeError";
+    constructor(root: string, candidate: string);
+}
+/**
+ * Ensures `candidateAbs` is the root directory itself or a path inside `rootAbs`.
+ * Use before any dev-server file write (Phase 1+).
+ */
+declare function assertPathWithinRoot(rootAbs: string, candidateAbs: string): void;
+
+export { PathEscapeError, assertPathWithinRoot };

package/dist/secure-path.js

@@ -0,0 +1,27 @@
+// src/secure-path.ts
+import path from "path";
+var PathEscapeError = class extends Error {
+  constructor(root, candidate) {
+    super(`Path escapes project root: ${candidate} (root ${root})`);
+    this.root = root;
+    this.candidate = candidate;
+  }
+  root;
+  candidate;
+  name = "PathEscapeError";
+};
+function assertPathWithinRoot(rootAbs, candidateAbs) {
+  const root = path.resolve(rootAbs);
+  const candidate = path.resolve(candidateAbs);
+  if (candidate === root) {
+    return;
+  }
+  const relative = path.relative(root, candidate);
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+    throw new PathEscapeError(root, candidate);
+  }
+}
+export {
+  PathEscapeError,
+  assertPathWithinRoot
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@nuvio/shared",
+  "version": "0.1.0",
+  "description": "Nuvio wire protocol (Zod), shared types, and path helpers for dev tooling.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ehah/Nuvio.git",
+    "directory": "packages/shared"
+  },
+  "keywords": [
+    "nuvio",
+    "vite",
+    "devtools",
+    "protocol"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./secure-path": {
+      "types": "./dist/secure-path.d.ts",
+      "import": "./dist/secure-path.js"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.5",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.6"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/secure-path.ts --format esm --dts --clean",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}