@nuvio/vite-plugin 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,7 @@
+# `@nuvio/vite-plugin`
+
+Vite plugin: dev WebSocket channel, **dev-time source index**, secure file writes for Nuvio patches.
+
+**Peer:** `vite` ^5.4 or ^6.
+
+See the [Nuvio README](../../README.md) and [CHANGELOG](../../CHANGELOG.md).

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { Plugin } from 'vite';
+
+interface NuvioPluginOptions {
+    /** Glob patterns relative to Vite config root (see DEFAULT_GLOBS). */
+    scanGlobs?: string[];
+    /** Log client ops (no source file contents). */
+    verbose?: boolean;
+}
+/**
+ * Nuvio Vite plugin — Phase 1: WebSocket protocol + dev-time source index + selection ack.
+ */
+declare function nuvio(options?: NuvioPluginOptions): Plugin;
+
+export { type NuvioPluginOptions, nuvio };

package/dist/index.js

@@ -0,0 +1,644 @@
+// src/index.ts
+import fs2 from "fs";
+import path2 from "path";
+import { WebSocket } from "ws";
+import { WebSocketServer } from "ws";
+import { applyPatchToSource } from "@nuvio/ast-engine";
+import {
+  NUVIO_WS_PATH,
+  PROTOCOL_VERSION,
+  parseClientMessage,
+  serializeServerMessage
+} from "@nuvio/shared";
+import { assertPathWithinRoot } from "@nuvio/shared/secure-path";
+
+// src/upgrade-url.ts
+function pathnameFromUpgradeUrl(url) {
+  if (!url) {
+    return "";
+  }
+  try {
+    return new URL(url, "http://localhost").pathname;
+  } catch {
+    return "";
+  }
+}
+
+// src/source-index.ts
+import * as fs from "fs";
+import * as path from "path";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import fg from "fast-glob";
+function getTraverseFn() {
+  if (typeof traverseImport === "function") {
+    return traverseImport;
+  }
+  const d = traverseImport.default;
+  if (typeof d === "function") {
+    return d;
+  }
+  throw new Error("[Nuvio] @babel/traverse did not resolve to a callable export");
+}
+var WRAPPER_TAGS = /* @__PURE__ */ new Set(["EditableText", "EditableContainer"]);
+function extractIdsFromSource(fileAbs, code) {
+  const acc = [];
+  let ast;
+  try {
+    ast = parse(code, {
+      sourceType: "module",
+      plugins: ["typescript", "jsx"],
+      sourceFilename: fileAbs
+    });
+  } catch {
+    return acc;
+  }
+  const traverseFn = getTraverseFn();
+  traverseFn(ast, {
+    JSXOpeningElement(p) {
+      const opening = p.node;
+      let tagName = "";
+      if (opening.name.type === "JSXIdentifier") {
+        tagName = opening.name.name;
+      } else {
+        return;
+      }
+      for (const attr of opening.attributes) {
+        if (attr.type !== "JSXAttribute") {
+          continue;
+        }
+        if (attr.name.type !== "JSXIdentifier") {
+          continue;
+        }
+        const prop = attr.name.name;
+        const loc = attr.loc?.start ?? opening.loc?.start;
+        const line = loc?.line ?? 1;
+        const column = loc?.column ?? 0;
+        if (prop === "data-nuvio-id" && attr.value?.type === "StringLiteral") {
+          const id = attr.value.value.trim();
+          if (id) {
+            acc.push({ id, file: path.resolve(fileAbs), line, column });
+          }
+          continue;
+        }
+        if (WRAPPER_TAGS.has(tagName) && prop === "id" && attr.value?.type === "StringLiteral") {
+          const id = attr.value.value.trim();
+          if (id) {
+            acc.push({ id, file: path.resolve(fileAbs), line, column });
+          }
+        }
+      }
+    }
+  });
+  return acc;
+}
+function buildSourceIndex(rootAbs, globPatterns) {
+  const root = path.resolve(rootAbs);
+  const parseErrors = [];
+  const normalizedPatterns = globPatterns.map((g) => {
+    const resolved = path.isAbsolute(g) ? path.resolve(g) : path.resolve(root, g);
+    return resolved.replace(/\\/g, "/");
+  });
+  const matched = fg.sync(normalizedPatterns, {
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**"],
+    onlyFiles: true
+  });
+  const files = [...new Set(matched)];
+  const byId = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    let code;
+    try {
+      code = fs.readFileSync(file, "utf8");
+    } catch (e) {
+      parseErrors.push({ file, message: String(e) });
+      continue;
+    }
+    let occurrences;
+    try {
+      occurrences = extractIdsFromSource(file, code);
+    } catch (e) {
+      parseErrors.push({ file, message: String(e) });
+      continue;
+    }
+    for (const occ of occurrences) {
+      const list = byId.get(occ.id) ?? [];
+      list.push(occ);
+      byId.set(occ.id, list);
+    }
+  }
+  const duplicateErrors = [];
+  const entries = [];
+  for (const [id, list] of byId) {
+    if (list.length > 1) {
+      duplicateErrors.push({
+        id,
+        occurrences: list.map((o) => ({
+          file: o.file,
+          line: o.line,
+          column: o.column
+        }))
+      });
+    } else if (list.length === 1) {
+      entries.push(list[0]);
+    }
+  }
+  entries.sort((a, b) => {
+    const fa = a.file.localeCompare(b.file);
+    if (fa !== 0) {
+      return fa;
+    }
+    if (a.line !== b.line) {
+      return a.line - b.line;
+    }
+    return a.column - b.column;
+  });
+  duplicateErrors.sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    entries,
+    duplicateErrors,
+    parseErrors,
+    scannedFileCount: files.length
+  };
+}
+function indexQuality(b) {
+  return [b.entries.length, -b.duplicateErrors.length, b.scannedFileCount];
+}
+function isBetterIndex(candidate, current) {
+  const c = indexQuality(candidate);
+  const b = indexQuality(current);
+  for (let i = 0; i < 3; i++) {
+    if (c[i] !== b[i]) {
+      return c[i] > b[i];
+    }
+  }
+  return false;
+}
+function pickBestSourceIndex(rootCandidates, globPatterns) {
+  const roots = [...new Set(rootCandidates.map((r) => path.resolve(r)).filter((r) => r.length > 0))];
+  if (roots.length === 0) {
+    return {
+      entries: [],
+      duplicateErrors: [],
+      parseErrors: [],
+      scannedFileCount: 0
+    };
+  }
+  let best = buildSourceIndex(roots[0], globPatterns);
+  for (let i = 1; i < roots.length; i++) {
+    const built = buildSourceIndex(roots[i], globPatterns);
+    if (isBetterIndex(built, best)) {
+      best = built;
+    }
+  }
+  return best;
+}
+
+// src/index.ts
+var APP_ENTRY_CANDIDATES = ["src/App.tsx", "src/app.tsx", "App.tsx"];
+function nuvioWsMessageToText(data) {
+  if (typeof data === "string") {
+    return data;
+  }
+  if (Buffer.isBuffer(data)) {
+    return data.toString("utf8");
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString("utf8");
+  }
+  if (ArrayBuffer.isView(data)) {
+    const v = data;
+    return Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("utf8");
+  }
+  return String(data);
+}
+function supplementIndexFromAppTsx(serverRoot, built, emitWarn = console.warn) {
+  if (built.entries.length > 0) {
+    return built;
+  }
+  for (const rel of APP_ENTRY_CANDIDATES) {
+    const appTsx = path2.resolve(serverRoot, rel);
+    if (!fs2.existsSync(appTsx)) {
+      continue;
+    }
+    try {
+      const code = fs2.readFileSync(appTsx, "utf8");
+      const hits = extractIdsFromSource(appTsx, code);
+      if (hits.length === 0) {
+        continue;
+      }
+      emitWarn(
+        `[Nuvio] Source index had 0 ids; supplemented from ${appTsx} (${hits.length} id(s)). Fix scan roots if this is unexpected.`
+      );
+      return {
+        ...built,
+        entries: hits,
+        scannedFileCount: Math.max(built.scannedFileCount, 1)
+      };
+    } catch {
+    }
+  }
+  return built;
+}
+var DEFAULT_GLOBS = [
+  "src/**/*.{tsx,jsx}",
+  "apps/**/src/**/*.{tsx,jsx}",
+  "packages/**/src/**/*.{tsx,jsx}"
+];
+function isAllowedOrigin(origin) {
+  if (origin === void 0 || origin === "") {
+    return true;
+  }
+  try {
+    const u = new URL(origin);
+    return (u.hostname === "localhost" || u.hostname === "127.0.0.1") && (u.protocol === "http:" || u.protocol === "https:");
+  } catch {
+    return false;
+  }
+}
+function nuvio(options) {
+  const scanGlobs = options?.scanGlobs ?? DEFAULT_GLOBS;
+  const verbose = options?.verbose ?? false;
+  let indexVersion = 0;
+  let cachedIndexPayload = null;
+  const idToEntry = /* @__PURE__ */ new Map();
+  return {
+    name: "nuvio",
+    apply: "serve",
+    configureServer(server) {
+      const log = server.config.logger;
+      const fromConfigFile = typeof server.config.configFile === "string" ? path2.dirname(server.config.configFile) : "";
+      const serverRoot = path2.resolve(server.config.root);
+      const rootCandidates = [
+        path2.resolve(fromConfigFile || serverRoot),
+        serverRoot,
+        process.cwd()
+      ];
+      const rootsLabel = [...new Set(rootCandidates)].join(" | ");
+      const wss = new WebSocketServer({ noServer: true });
+      const undoStack = [];
+      const UNDO_MAX = 32;
+      const pushUndoSnapshot = (file, contents) => {
+        undoStack.push({ file, contents });
+        while (undoStack.length > UNDO_MAX) {
+          undoStack.shift();
+        }
+      };
+      const rebuildIndex = () => {
+        let built = pickBestSourceIndex(rootCandidates, scanGlobs);
+        built = supplementIndexFromAppTsx(serverRoot, built, log.warn);
+        if (built.entries.length === 0) {
+          const fallback = buildSourceIndex(serverRoot, ["src/**/*.{tsx,jsx}"]);
+          if (fallback.entries.length > 0) {
+            log.warn(
+              `[Nuvio] Multi-root scan yielded 0 ids; using serverRoot-only index (${fallback.entries.length} id(s)) from ${serverRoot}.`
+            );
+            built = fallback;
+          }
+        }
+        indexVersion += 1;
+        idToEntry.clear();
+        for (const e of built.entries) {
+          idToEntry.set(e.id, e);
+        }
+        cachedIndexPayload = serializeServerMessage({
+          type: "indexReady",
+          protocolVersion: PROTOCOL_VERSION,
+          indexVersion,
+          entries: built.entries,
+          duplicateErrors: built.duplicateErrors
+        });
+        if (verbose) {
+          if (built.parseErrors.length > 0) {
+            log.warn(`[Nuvio] index parse issues: ${built.parseErrors.length} file(s)`);
+          }
+          if (built.duplicateErrors.length > 0) {
+            log.warn(
+              `[Nuvio] duplicate ids: ${built.duplicateErrors.map((d) => d.id).join(", ")}`
+            );
+          }
+          log.info(
+            `[Nuvio] index roots=${rootsLabel} matchedFiles=${built.scannedFileCount} uniqueIds=${built.entries.length}`
+          );
+        } else {
+          log.info(
+            `[Nuvio] index v${indexVersion} \u2014 ${built.entries.length} id(s), ${built.scannedFileCount} file(s)`
+          );
+        }
+        if (built.scannedFileCount === 0) {
+          log.warn(
+            `[Nuvio] Source index matched 0 files for globs [${scanGlobs.join(", ")}] under roots ${rootsLabel}. Dev server cwd does not affect this if Vite root is correct; ensure \`data-nuvio-id\` lives under that root.`
+          );
+        } else if (built.entries.length === 0 && built.parseErrors.length > 0) {
+          const e0 = built.parseErrors[0];
+          log.warn(
+            `[Nuvio] Source index has 0 ids after ${built.scannedFileCount} file(s); first error: ${e0.file} \u2014 ${e0.message}`
+          );
+        } else if (built.entries.length === 0 && built.duplicateErrors.length > 0) {
+          log.warn(
+            `[Nuvio] Source index: all contract ids appear duplicated \u2014 ${built.duplicateErrors.map((d) => d.id).join(", ")}`
+          );
+        } else if (built.entries.length === 0 && built.duplicateErrors.length === 0 && built.parseErrors.length === 0) {
+          log.warn(
+            `[Nuvio] Source index scanned ${built.scannedFileCount} file(s) under roots ${rootsLabel} but extracted 0 ids (no \`data-nuvio-id\` / wrapper hits).`
+          );
+        }
+        if (cachedIndexPayload && wss.clients.size > 0) {
+          for (const client of wss.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+              client.send(cachedIndexPayload);
+            }
+          }
+        }
+      };
+      const debouncedRebuild = /* @__PURE__ */ (() => {
+        let t;
+        return () => {
+          if (t) {
+            clearTimeout(t);
+          }
+          t = setTimeout(() => {
+            rebuildIndex();
+            t = void 0;
+          }, 120);
+        };
+      })();
+      server.watcher.on("change", (file) => {
+        if (!/\.(tsx|jsx)$/.test(file)) {
+          return;
+        }
+        debouncedRebuild();
+      });
+      wss.on("connection", (ws) => {
+        if (cachedIndexPayload && ws.readyState === WebSocket.OPEN) {
+          ws.send(cachedIndexPayload);
+        }
+        ws.on("message", async (data) => {
+          const text = nuvioWsMessageToText(data);
+          const msg = parseClientMessage(text);
+          if (!msg) {
+            ws.send(
+              serializeServerMessage({
+                type: "error",
+                code: "bad_message",
+                message: "Invalid client message"
+              })
+            );
+            return;
+          }
+          if (msg.protocolVersion !== PROTOCOL_VERSION) {
+            ws.send(
+              serializeServerMessage({
+                type: "error",
+                code: "bad_version",
+                message: `Expected protocolVersion ${PROTOCOL_VERSION}`,
+                requestId: "requestId" in msg ? msg.requestId : void 0
+              })
+            );
+            return;
+          }
+          if (msg.type === "ping") {
+            if (verbose) {
+              log.info(`[Nuvio] ping ${msg.requestId}`);
+            }
+            ws.send(
+              serializeServerMessage({
+                type: "pong",
+                protocolVersion: PROTOCOL_VERSION,
+                requestId: msg.requestId
+              })
+            );
+            if (cachedIndexPayload) {
+              ws.send(cachedIndexPayload);
+            }
+            return;
+          }
+          if (msg.type === "select") {
+            if (verbose) {
+              log.info(`[Nuvio] select ${msg.id}`);
+            }
+            const entry = idToEntry.get(msg.id);
+            if (!entry) {
+              log.warn(`[Nuvio] select unknown_id: ${msg.id} (index has ${idToEntry.size} id(s))`);
+              ws.send(
+                serializeServerMessage({
+                  type: "selectAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  id: msg.id,
+                  ok: false,
+                  errorCode: "unknown_id",
+                  errorMessage: "Id not found in dev source index"
+                })
+              );
+              return;
+            }
+            ws.send(
+              serializeServerMessage({
+                type: "selectAck",
+                protocolVersion: PROTOCOL_VERSION,
+                requestId: msg.requestId,
+                id: msg.id,
+                ok: true,
+                file: entry.file,
+                line: entry.line,
+                column: entry.column
+              })
+            );
+            return;
+          }
+          if (msg.type === "patchUndo") {
+            const writeGuardRoot = path2.resolve(fromConfigFile || serverRoot);
+            const last = undoStack.pop();
+            if (!last) {
+              ws.send(
+                serializeServerMessage({
+                  type: "patchUndoAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  ok: false,
+                  errorCode: "empty_stack",
+                  errorMessage: "Nothing to undo"
+                })
+              );
+              return;
+            }
+            try {
+              assertPathWithinRoot(writeGuardRoot, last.file);
+              fs2.writeFileSync(last.file, last.contents, "utf8");
+            } catch (e) {
+              undoStack.push(last);
+              ws.send(
+                serializeServerMessage({
+                  type: "patchUndoAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  ok: false,
+                  errorCode: "undo_write_error",
+                  errorMessage: String(e)
+                })
+              );
+              return;
+            }
+            log.info(`[Nuvio] undo restored ${last.file}`);
+            ws.send(
+              serializeServerMessage({
+                type: "patchUndoAck",
+                protocolVersion: PROTOCOL_VERSION,
+                requestId: msg.requestId,
+                ok: true,
+                file: last.file,
+                undoStackDepth: undoStack.length
+              })
+            );
+            return;
+          }
+          if (msg.type === "patchApply") {
+            const entry = idToEntry.get(msg.id);
+            const writeGuardRoot = path2.resolve(fromConfigFile || serverRoot);
+            const dryRun = msg.dryRun === true;
+            const patchAckExtras = dryRun ? { dryRun: true } : {};
+            if (!entry) {
+              log.warn(`[Nuvio] patch unknown_id: ${msg.id} (index has ${idToEntry.size} id(s))`);
+              ws.send(
+                serializeServerMessage({
+                  type: "patchAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  id: msg.id,
+                  ok: false,
+                  errorCode: "unknown_id",
+                  errorMessage: "Id not found in dev source index",
+                  ...patchAckExtras
+                })
+              );
+              return;
+            }
+            try {
+              assertPathWithinRoot(writeGuardRoot, entry.file);
+            } catch (e) {
+              ws.send(
+                serializeServerMessage({
+                  type: "patchAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  id: msg.id,
+                  ok: false,
+                  errorCode: "path_escape",
+                  errorMessage: String(e),
+                  ...patchAckExtras
+                })
+              );
+              return;
+            }
+            let source;
+            try {
+              source = fs2.readFileSync(entry.file, "utf8");
+            } catch (e) {
+              ws.send(
+                serializeServerMessage({
+                  type: "patchAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  id: msg.id,
+                  ok: false,
+                  errorCode: "read_error",
+                  errorMessage: String(e),
+                  ...patchAckExtras
+                })
+              );
+              return;
+            }
+            const result = await applyPatchToSource(source, entry.file, msg.id, msg.ops);
+            if (!result.ok) {
+              ws.send(
+                serializeServerMessage({
+                  type: "patchAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  id: msg.id,
+                  ok: false,
+                  errorCode: result.code,
+                  errorMessage: result.message,
+                  ...patchAckExtras
+                })
+              );
+              return;
+            }
+            if (dryRun) {
+              ws.send(
+                serializeServerMessage({
+                  type: "patchAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  id: msg.id,
+                  ok: true,
+                  diffSummary: result.diffSummary,
+                  dryRun: true
+                })
+              );
+              if (verbose) {
+                log.info(`[Nuvio] patchPreview ${msg.id} ${msg.ops.map((o) => o.kind).join(",")}`);
+              }
+              return;
+            }
+            try {
+              fs2.writeFileSync(entry.file, result.source, "utf8");
+            } catch (e) {
+              ws.send(
+                serializeServerMessage({
+                  type: "patchAck",
+                  protocolVersion: PROTOCOL_VERSION,
+                  requestId: msg.requestId,
+                  id: msg.id,
+                  ok: false,
+                  errorCode: "write_error",
+                  errorMessage: String(e)
+                })
+              );
+              return;
+            }
+            pushUndoSnapshot(entry.file, source);
+            log.info(`[Nuvio] touched ${entry.file}`);
+            ws.send(
+              serializeServerMessage({
+                type: "patchAck",
+                protocolVersion: PROTOCOL_VERSION,
+                requestId: msg.requestId,
+                id: msg.id,
+                ok: true,
+                diffSummary: result.diffSummary,
+                writtenFile: entry.file,
+                undoStackDepth: undoStack.length
+              })
+            );
+            if (verbose) {
+              log.info(`[Nuvio] patchApply ${msg.id} ${msg.ops.map((o) => o.kind).join(",")}`);
+            }
+            return;
+          }
+        });
+      });
+      server.httpServer?.on(
+        "upgrade",
+        (request, socket, head) => {
+          const pathname = pathnameFromUpgradeUrl(request.url);
+          if (pathname !== NUVIO_WS_PATH) {
+            return;
+          }
+          if (!isAllowedOrigin(request.headers.origin)) {
+            socket.destroy();
+            return;
+          }
+          wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit("connection", ws, request);
+          });
+        }
+      );
+      rebuildIndex();
+    }
+  };
+}
+export {
+  nuvio
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@nuvio/vite-plugin",
+  "version": "0.1.0",
+  "description": "Nuvio Vite plugin: dev WebSocket, source index for data-nuvio-id, secure patch writes.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ehah/Nuvio.git",
+    "directory": "packages/vite-plugin"
+  },
+  "keywords": [
+    "nuvio",
+    "vite",
+    "vite-plugin",
+    "devtools",
+    "react"
+  ],
+  "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"
+    }
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "peerDependencies": {
+    "vite": "^5.4.0 || ^6.0.0"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.26.9",
+    "@babel/traverse": "^7.26.9",
+    "fast-glob": "^3.3.3",
+    "ws": "^8.18.0",
+    "@nuvio/ast-engine": "0.1.0",
+    "@nuvio/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "@babel/types": "^7.26.9",
+    "@types/babel__traverse": "^7.20.7",
+    "@types/node": "^22.13.5",
+    "@types/ws": "^8.5.14",
+    "tsup": "^8.4.0",
+    "typescript": "^5.7.3",
+    "vite": "^6.1.0",
+    "vitest": "^3.0.6"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --external vite --external @nuvio/shared --external @nuvio/ast-engine",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run"
+  }
+}