@volter/editor-core 0.5.57

package/dist/build/vite-plugin-shared-react.js

@@ -0,0 +1,25 @@
+import {
+  EDITOR_TREE_QUERY,
+  SHARED_REACT_ENTRIES,
+  SHARED_REACT_MANIFEST_FILE,
+  SHARED_REACT_SPECIFIERS,
+  installedExportNames,
+  readSharedReactManifest,
+  sharedReactBuildPlugin,
+  sharedReactEntryModule,
+  sharedReactPlugin,
+  sharedReactUrls
+} from "./chunk-JS4D4XZ3.js";
+export {
+  EDITOR_TREE_QUERY,
+  SHARED_REACT_ENTRIES,
+  SHARED_REACT_MANIFEST_FILE,
+  SHARED_REACT_SPECIFIERS,
+  installedExportNames,
+  readSharedReactManifest,
+  sharedReactBuildPlugin,
+  sharedReactEntryModule,
+  sharedReactPlugin,
+  sharedReactUrls
+};
+//# sourceMappingURL=vite-plugin-shared-react.js.map

package/dist/build/vite-plugin-shared-react.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

package/dist/build/vite-plugin-shared-three.js

@@ -0,0 +1,86 @@
+import {
+  installedExportNames,
+  sharedReactEntryModule
+} from "./chunk-JS4D4XZ3.js";
+
+// vite-plugin-shared-three.ts
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+var SHARED_THREE_SPECIFIER = "three";
+var SHARED_THREE_ENTRY_NAME = "vgai-shared-three";
+var SHARED_THREE_MANIFEST_FILE = "vgai-shared-three.json";
+var VIRTUAL_PREFIX = "\0vgai-shared-three:";
+function sharedThreeBuildPlugin(fromDir) {
+  let referenceId = null;
+  return {
+    name: "vgai-shared-three-build",
+    apply: "build",
+    buildStart() {
+      referenceId = this.emitFile({
+        type: "chunk",
+        id: `${VIRTUAL_PREFIX}${SHARED_THREE_SPECIFIER}`,
+        name: SHARED_THREE_ENTRY_NAME,
+        // Same reason as the shared-React entries: Vite's app build sets
+        // `preserveEntrySignatures: false`, which would mangle the entry's
+        // export names away — `strict` keeps `Mesh` spelled `Mesh`.
+        preserveSignature: "strict"
+      });
+    },
+    resolveId(id) {
+      return id.startsWith(VIRTUAL_PREFIX) ? id : void 0;
+    },
+    load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return void 0;
+      const specifier = id.slice(VIRTUAL_PREFIX.length);
+      return sharedReactEntryModule(specifier, installedExportNames(fromDir, specifier));
+    },
+    generateBundle() {
+      if (!referenceId) return;
+      this.emitFile({
+        type: "asset",
+        fileName: SHARED_THREE_MANIFEST_FILE,
+        source: `${JSON.stringify(
+          { file: this.getFileName(referenceId) },
+          null,
+          2
+        )}
+`
+      });
+    }
+  };
+}
+function readSharedThreeManifest(distPath) {
+  const manifestPath = path.join(distPath, SHARED_THREE_MANIFEST_FILE);
+  if (!existsSync(manifestPath)) return null;
+  try {
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    return manifest.file ? manifest : null;
+  } catch {
+    return null;
+  }
+}
+function sharedThreeUrl(manifest, base = "/") {
+  const prefix = base.endsWith("/") ? base : `${base}/`;
+  return `${prefix}${manifest.file}`;
+}
+function sharedThreePlugin(url) {
+  return {
+    name: "vgai-shared-three",
+    enforce: "pre",
+    resolveId(source, _importer, options) {
+      if (source !== SHARED_THREE_SPECIFIER) return void 0;
+      if (options?.scan) return void 0;
+      return url;
+    }
+  };
+}
+export {
+  SHARED_THREE_ENTRY_NAME,
+  SHARED_THREE_MANIFEST_FILE,
+  SHARED_THREE_SPECIFIER,
+  readSharedThreeManifest,
+  sharedThreeBuildPlugin,
+  sharedThreePlugin,
+  sharedThreeUrl
+};
+//# sourceMappingURL=vite-plugin-shared-three.js.map

package/dist/build/vite-plugin-shared-three.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../vite-plugin-shared-three.ts"],
+  "sourcesContent": ["/**\n * ONE three.js for the whole page \u2014 the editor shell's.\n *\n * ## The defect this closes (WORK.md P2, \"Packaged shell loads three.js twice\")\n *\n * Under the PACKAGED runtime (`server/packaged.ts`: a `@vgai/editor` npm\n * package with no monorepo checkout) the page runs two module graphs at once:\n *\n *  - the editor shell, a PREBUILT production bundle (`dist/assets/index-*.js`)\n *    with its own `three` inlined \u2014 the viewport renderer, the gizmos, the\n *    selection outline and ~100 other shell modules import it, so it evaluates\n *    at boot; and\n *  - the opened PROJECT's source, served fresh by a second, project-rooted\n *    Vite instance, whose bare `three` resolves \u2014 correctly, for its root \u2014 to\n *    the PROJECT's own `node_modules` (prebundled into `.vite/deps/three.js`).\n *\n * three's own module body runs `if (window.__THREE__) console.warn('WARNING:\n * Multiple instances of Three.js being imported.')` on evaluation, so the\n * SECOND graph's copy trips the guard. That warning is not cosmetic: it keeps\n * `vgai console` from reaching exit-0, a hard gate. `dev.ts` never sees it \u2014\n * one Vite instance, and the repo-root `vite.config.ts`'s\n * `resolve.dedupe: ['three', \u2026]` already collapses the project's copy onto the\n * editor's \u2014 so nothing in a checkout ever reproduced it.\n *\n * ## The mechanism: URL identity (the sibling of `vite-plugin-shared-react.ts`)\n *\n * The editor build emits one extra ENTRY chunk for `three`\n * ({@link sharedThreeBuildPlugin}) \u2014 the SHELL's own three. Because it is an\n * entry of the SAME build, rollup hoists the actual module into a chunk both it\n * and the shell import: it is not a copy of three, it is a doorway onto the\n * shell's instance. At serve time {@link sharedThreePlugin} resolves the bare\n * `three` specifier, for the whole PROJECT graph, to that built chunk's URL\n * (`/assets/vgai-shared-three-<hash>.js`) \u2014 the SAME absolute URL the shell's\n * own bundle imports, so the browser's module map hands both sides the one\n * instance and three's body evaluates exactly once.\n *\n * ## Why the scope is the WHOLE project graph \u2014 unlike shared-React\n *\n * `sharedReactPlugin` deliberately redirects react only for the EDITOR TREE and\n * leaves the GAME on the project's own (development) react, because React ships\n * distinct dev/prod builds and its prebundled DEVELOPMENT reconciler must not\n * run against the shell's PRODUCTION React (that broke Play mode, measured in\n * that plugin's header). three has NO such split \u2014 it is one build \u2014 and\n * `dev.ts`'s `resolve.dedupe` already proves the correct answer is ONE three\n * for editor AND game together (the R3F entry runtime already hands Fiber's\n * catalogue `host.three`, so a world's objects, Fiber's intrinsics and the\n * editor viewport that adopts them must all be the SAME three or `applyProps`\n * mis-types \u2014 see `r3f-entry-runtime.ts`). So this redirect is unscoped: every\n * project-graph `three` import becomes the shell's one instance.\n *\n * ## Ingest keeps its own three \u2014 for free, by construction\n *\n * An INGEST root's premise is a vendored game that brought its own three. Two\n * shapes, both preserved without a special case here:\n *\n *  - a SOURCE game (its modules served by this same project-rooted Vite) has\n *    its bare `three` DEDUPED to the editor's instance already under `dev.ts`\n *    (see `ingest/resolve-three.ts`'s header, and the `cov-bundled-dedupe`\n *    e2e). This redirect is the packaged analogue of that dedupe \u2014 the source\n *    game lands on the shell's three exactly as it lands on the editor's in a\n *    checkout, and the three-ingest doorway's `projectThree` (which goes\n *    through this same resolver) lands there too, so the capture trap and the\n *    game agree;\n *  - a PRE-BUILT BUNDLE game inlines its own three into a blob/`public/` URL\n *    that never passes through a bare-specifier resolve, so this plugin cannot\n *    and does not touch it \u2014 it keeps its own copy, the case the doorway\n *    header calls out as inherently un-shareable.\n *\n * For the redirect to reach `@react-three/fiber`'s OWN `import 'three'`,\n * `packaged.ts` also `optimizeDeps.exclude`s `three`: an excluded dep is\n * externalized out of every prebundled chunk and resolved at serve time, where\n * this plugin answers. Prebundling it instead would bake a second, un-\n * redirectable three chunk into `.vite/deps` \u2014 exactly the duplicate this\n * plugin removes.\n *\n * {@link sharedThreePlugin} is registered ONLY by `server/packaged.ts`.\n * `dev.ts` is untouched \u2014 it has one three already.\n */\nimport { existsSync, readFileSync } from 'node:fs';\nimport path from 'node:path';\nimport type { Plugin } from 'vite';\nimport { installedExportNames, sharedReactEntryModule } from './vite-plugin-shared-react.js';\n\n/** The bare specifier this plugin owns. three's `window.__THREE__` guard lives\n *  in its main entry (`three/build/three.core.js`, re-exported by `three`), so\n *  collapsing the main entry collapses the duplicate-instance warning; addons\n *  (`three/addons/*`, `three/examples/jsm/*`) import bare `three` internally and\n *  ride this same redirect. */\nexport const SHARED_THREE_SPECIFIER = 'three';\n\n/** The rollup chunk NAME the shell's three is emitted under. */\nexport const SHARED_THREE_ENTRY_NAME = 'vgai-shared-three';\n\n/**\n * The emitted map, written beside the built shell \u2014 the sibling of\n * `vgai-shared-react.json`, kept a SEPARATE file so an editor build that\n * predates one manifest but not the other degrades one lane at a time.\n */\nexport const SHARED_THREE_MANIFEST_FILE = 'vgai-shared-three.json';\n\nexport interface SharedThreeManifest {\n  /** outDir-relative built chunk file (`assets/\u2026js`) for `three`. */\n  file: string;\n}\n\nconst VIRTUAL_PREFIX = '\\0vgai-shared-three:';\n\n/**\n * BUILD side: emit the `three` entry chunk and the manifest naming it.\n *\n * `fromDir` is the directory whose `node_modules` the three being published\n * comes from \u2014 the repo root for this build, which is the same three the shell\n * itself bundles. The entry body is generated from the installed package's own\n * runtime key list ({@link sharedReactEntryModule} / {@link installedExportNames}\n * \u2014 generic over the specifier despite the React-shaped names), so it cannot\n * drift from the installed three and needs no hand-maintained export list.\n */\nexport function sharedThreeBuildPlugin(fromDir: string): Plugin {\n  let referenceId: string | null = null;\n  return {\n    name: 'vgai-shared-three-build',\n    apply: 'build',\n    buildStart() {\n      referenceId = this.emitFile({\n        type: 'chunk',\n        id: `${VIRTUAL_PREFIX}${SHARED_THREE_SPECIFIER}`,\n        name: SHARED_THREE_ENTRY_NAME,\n        // Same reason as the shared-React entries: Vite's app build sets\n        // `preserveEntrySignatures: false`, which would mangle the entry's\n        // export names away \u2014 `strict` keeps `Mesh` spelled `Mesh`.\n        preserveSignature: 'strict',\n      });\n    },\n    resolveId(id) {\n      return id.startsWith(VIRTUAL_PREFIX) ? id : undefined;\n    },\n    load(id) {\n      if (!id.startsWith(VIRTUAL_PREFIX)) return undefined;\n      const specifier = id.slice(VIRTUAL_PREFIX.length);\n      return sharedReactEntryModule(specifier, installedExportNames(fromDir, specifier));\n    },\n    generateBundle() {\n      if (!referenceId) return;\n      this.emitFile({\n        type: 'asset',\n        fileName: SHARED_THREE_MANIFEST_FILE,\n        source: `${JSON.stringify(\n          { file: this.getFileName(referenceId) } satisfies SharedThreeManifest,\n          null,\n          2,\n        )}\\n`,\n      });\n    },\n  };\n}\n\n/** The manifest a built `dist/` carries, or `null` when it predates this build\n *  step (an old tarball, or a checkout whose `dist/` was never rebuilt). */\nexport function readSharedThreeManifest(distPath: string): SharedThreeManifest | null {\n  const manifestPath = path.join(distPath, SHARED_THREE_MANIFEST_FILE);\n  if (!existsSync(manifestPath)) return null;\n  try {\n    const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as SharedThreeManifest;\n    return manifest.file ? manifest : null;\n  } catch {\n    return null;\n  }\n}\n\n/**\n * The `three` chunk URL, from a manifest. `base` is the built shell's own base\n * (`/` for the packaged build), so this URL is byte-identical to the one the\n * shell's bundle imports. That identity IS the fix: a differently-spelled URL\n * for the same file is a second three.\n */\nexport function sharedThreeUrl(manifest: SharedThreeManifest, base = '/'): string {\n  const prefix = base.endsWith('/') ? base : `${base}/`;\n  return `${prefix}${manifest.file}`;\n}\n\n/**\n * SERVE side: point every project-graph `three` import at the shell's built\n * chunk URL. Registered ONLY on the packaged runtime's project-rooted Vite.\n */\nexport function sharedThreePlugin(url: string): Plugin {\n  return {\n    name: 'vgai-shared-three',\n    enforce: 'pre',\n    resolveId(source, _importer, options) {\n      if (source !== SHARED_THREE_SPECIFIER) return undefined;\n      // Never during dependency SCANNING \u2014 the scanner records whatever an id\n      // resolves to as a file to prebundle, and handing it a `/assets/*` URL\n      // makes the boot optimizer die on ENOENT (the exact failure\n      // `sharedReactPlugin` documents). Returning undefined lets the scanner\n      // resolve `three` normally; because `packaged.ts` `exclude`s it from\n      // optimizeDeps, the scanner externalizes it rather than prebundling a\n      // second copy. `scan` is Vite's own flag on the resolve options, not part\n      // of rollup's published type \u2014 hence the cast.\n      if ((options as { scan?: boolean } | undefined)?.scan) return undefined;\n      return url;\n    },\n  };\n}\n"],
+  "mappings": ";;;;;;AA8EA,SAAS,YAAY,oBAAoB;AACzC,OAAO,UAAU;AASV,IAAM,yBAAyB;AAG/B,IAAM,0BAA0B;AAOhC,IAAM,6BAA6B;AAO1C,IAAM,iBAAiB;AAYhB,SAAS,uBAAuB,SAAyB;AAC9D,MAAI,cAA6B;AACjC,SAAO;AAAA,IACL,MAAM;AAAA,IACN,OAAO;AAAA,IACP,aAAa;AACX,oBAAc,KAAK,SAAS;AAAA,QAC1B,MAAM;AAAA,QACN,IAAI,GAAG,cAAc,GAAG,sBAAsB;AAAA,QAC9C,MAAM;AAAA;AAAA;AAAA;AAAA,QAIN,mBAAmB;AAAA,MACrB,CAAC;AAAA,IACH;AAAA,IACA,UAAU,IAAI;AACZ,aAAO,GAAG,WAAW,cAAc,IAAI,KAAK;AAAA,IAC9C;AAAA,IACA,KAAK,IAAI;AACP,UAAI,CAAC,GAAG,WAAW,cAAc,EAAG,QAAO;AAC3C,YAAM,YAAY,GAAG,MAAM,eAAe,MAAM;AAChD,aAAO,uBAAuB,WAAW,qBAAqB,SAAS,SAAS,CAAC;AAAA,IACnF;AAAA,IACA,iBAAiB;AACf,UAAI,CAAC,YAAa;AAClB,WAAK,SAAS;AAAA,QACZ,MAAM;AAAA,QACN,UAAU;AAAA,QACV,QAAQ,GAAG,KAAK;AAAA,UACd,EAAE,MAAM,KAAK,YAAY,WAAW,EAAE;AAAA,UACtC;AAAA,UACA;AAAA,QACF,CAAC;AAAA;AAAA,MACH,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAIO,SAAS,wBAAwB,UAA8C;AACpF,QAAM,eAAe,KAAK,KAAK,UAAU,0BAA0B;AACnE,MAAI,CAAC,WAAW,YAAY,EAAG,QAAO;AACtC,MAAI;AACF,UAAM,WAAW,KAAK,MAAM,aAAa,cAAc,MAAM,CAAC;AAC9D,WAAO,SAAS,OAAO,WAAW;AAAA,EACpC,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAQO,SAAS,eAAe,UAA+B,OAAO,KAAa;AAChF,QAAM,SAAS,KAAK,SAAS,GAAG,IAAI,OAAO,GAAG,IAAI;AAClD,SAAO,GAAG,MAAM,GAAG,SAAS,IAAI;AAClC;AAMO,SAAS,kBAAkB,KAAqB;AACrD,SAAO;AAAA,IACL,MAAM;AAAA,IACN,SAAS;AAAA,IACT,UAAU,QAAQ,WAAW,SAAS;AACpC,UAAI,WAAW,uBAAwB,QAAO;AAS9C,UAAK,SAA4C,KAAM,QAAO;AAC9D,aAAO;AAAA,IACT;AAAA,EACF;AACF;",
+  "names": []
+}

package/dist/server/chunk-KMJC7AGO.js

@@ -0,0 +1,98 @@
+// server/worktree-identity.ts
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { basename, isAbsolute, relative, resolve } from "node:path";
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+function worktreeIdForRoot(repositoryId, worktreeRoot) {
+  return `worktree-${hash(`${repositoryId}\0${canonical(worktreeRoot)}`)}`;
+}
+function canonical(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return resolve(path);
+  }
+}
+function git(cwd, args) {
+  try {
+    const output = execFileSync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return output === "" ? null : output;
+  } catch {
+    return null;
+  }
+}
+function resolveGitPath(worktreeRoot, rawPath) {
+  if (!rawPath) return null;
+  return canonical(isAbsolute(rawPath) ? rawPath : resolve(worktreeRoot, rawPath));
+}
+function defaultBaseCommit(worktreeRoot, headCommit) {
+  if (!headCommit) return null;
+  const originHead = git(worktreeRoot, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+  const candidates = [
+    originHead,
+    "refs/remotes/origin/main",
+    "refs/heads/main",
+    "refs/heads/master"
+  ];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const base = git(worktreeRoot, ["merge-base", "HEAD", candidate]);
+    if (base) return base;
+  }
+  return headCommit;
+}
+function resolveWorktreeIdentity(projectRoot) {
+  const project = canonical(projectRoot);
+  const discoveredRoot = git(project, ["rev-parse", "--show-toplevel"]);
+  if (!discoveredRoot) {
+    const repositoryId2 = `local-${hash(project)}`;
+    return {
+      repositoryId: repositoryId2,
+      worktreeId: `worktree-${hash(`${repositoryId2}\0${project}`)}`,
+      worktreeRoot: project,
+      projectRelativePath: ".",
+      branch: null,
+      headCommit: null,
+      baseCommit: null
+    };
+  }
+  const worktreeRoot = canonical(discoveredRoot);
+  const commonDir = resolveGitPath(
+    worktreeRoot,
+    git(worktreeRoot, ["rev-parse", "--git-common-dir"])
+  );
+  const remote = git(worktreeRoot, ["config", "--get", "remote.origin.url"]);
+  const repositoryKey = remote ?? commonDir ?? worktreeRoot;
+  const repositoryId = `repository-${hash(repositoryKey)}`;
+  const branch = git(worktreeRoot, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+  const headCommit = git(worktreeRoot, ["rev-parse", "--verify", "HEAD"]);
+  const projectRelativePath = relative(worktreeRoot, project) || ".";
+  if (projectRelativePath === ".." || projectRelativePath.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
+    throw new Error(`Project ${project} is outside its reported Git worktree ${worktreeRoot}.`);
+  }
+  return {
+    repositoryId,
+    worktreeId: worktreeIdForRoot(repositoryId, worktreeRoot),
+    worktreeRoot,
+    projectRelativePath,
+    branch,
+    headCommit,
+    baseCommit: defaultBaseCommit(worktreeRoot, headCommit)
+  };
+}
+function worktreeName(identity) {
+  return identity.branch ?? (basename(identity.worktreeRoot) || "detached");
+}
+
+export {
+  worktreeIdForRoot,
+  resolveWorktreeIdentity,
+  worktreeName
+};
+//# sourceMappingURL=chunk-KMJC7AGO.js.map

package/dist/server/chunk-KMJC7AGO.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../server/worktree-identity.ts"],
+  "sourcesContent": ["import { execFileSync } from 'node:child_process';\nimport { createHash } from 'node:crypto';\nimport { realpathSync } from 'node:fs';\nimport { basename, isAbsolute, relative, resolve } from 'node:path';\n\nexport interface WorktreeIdentity {\n  repositoryId: string;\n  worktreeId: string;\n  worktreeRoot: string;\n  projectRelativePath: string;\n  branch: string | null;\n  headCommit: string | null;\n  baseCommit: string | null;\n}\n\nfunction hash(value: string): string {\n  return createHash('sha256').update(value).digest('hex').slice(0, 24);\n}\n\nexport function worktreeIdForRoot(repositoryId: string, worktreeRoot: string): string {\n  return `worktree-${hash(`${repositoryId}\\0${canonical(worktreeRoot)}`)}`;\n}\n\nfunction canonical(path: string): string {\n  try {\n    return realpathSync(path);\n  } catch {\n    return resolve(path);\n  }\n}\n\nfunction git(cwd: string, args: readonly string[]): string | null {\n  try {\n    const output = execFileSync('git', ['-C', cwd, ...args], {\n      encoding: 'utf8',\n      stdio: ['ignore', 'pipe', 'ignore'],\n    }).trim();\n    return output === '' ? null : output;\n  } catch {\n    return null;\n  }\n}\n\nfunction resolveGitPath(worktreeRoot: string, rawPath: string | null): string | null {\n  if (!rawPath) return null;\n  return canonical(isAbsolute(rawPath) ? rawPath : resolve(worktreeRoot, rawPath));\n}\n\nfunction defaultBaseCommit(worktreeRoot: string, headCommit: string | null): string | null {\n  if (!headCommit) return null;\n  const originHead = git(worktreeRoot, ['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD']);\n  const candidates = [\n    originHead,\n    'refs/remotes/origin/main',\n    'refs/heads/main',\n    'refs/heads/master',\n  ];\n  for (const candidate of candidates) {\n    if (!candidate) continue;\n    const base = git(worktreeRoot, ['merge-base', 'HEAD', candidate]);\n    if (base) return base;\n  }\n  return headCommit;\n}\n\n/**\n * Resolve the Git/materialization identity for a project. A project outside\n * Git still gets an honest local repository/worktree identity rooted at the\n * project, but carries no branch or commits.\n */\nexport function resolveWorktreeIdentity(projectRoot: string): WorktreeIdentity {\n  const project = canonical(projectRoot);\n  const discoveredRoot = git(project, ['rev-parse', '--show-toplevel']);\n  if (!discoveredRoot) {\n    const repositoryId = `local-${hash(project)}`;\n    return {\n      repositoryId,\n      worktreeId: `worktree-${hash(`${repositoryId}\\0${project}`)}`,\n      worktreeRoot: project,\n      projectRelativePath: '.',\n      branch: null,\n      headCommit: null,\n      baseCommit: null,\n    };\n  }\n\n  const worktreeRoot = canonical(discoveredRoot);\n  const commonDir = resolveGitPath(\n    worktreeRoot,\n    git(worktreeRoot, ['rev-parse', '--git-common-dir']),\n  );\n  const remote = git(worktreeRoot, ['config', '--get', 'remote.origin.url']);\n  const repositoryKey = remote ?? commonDir ?? worktreeRoot;\n  const repositoryId = `repository-${hash(repositoryKey)}`;\n  const branch = git(worktreeRoot, ['symbolic-ref', '--quiet', '--short', 'HEAD']);\n  const headCommit = git(worktreeRoot, ['rev-parse', '--verify', 'HEAD']);\n  const projectRelativePath = relative(worktreeRoot, project) || '.';\n\n  if (\n    projectRelativePath === '..' ||\n    projectRelativePath.startsWith(`..${process.platform === 'win32' ? '\\\\' : '/'}`)\n  ) {\n    throw new Error(`Project ${project} is outside its reported Git worktree ${worktreeRoot}.`);\n  }\n\n  return {\n    repositoryId,\n    worktreeId: worktreeIdForRoot(repositoryId, worktreeRoot),\n    worktreeRoot,\n    projectRelativePath,\n    branch,\n    headCommit,\n    baseCommit: defaultBaseCommit(worktreeRoot, headCommit),\n  };\n}\n\n/** Git's main-worktree `--git-dir` is `<root>/.git`; linked worktrees use a\n * common-dir child. Kept exported for focused identity tests. */\nexport function worktreeName(identity: WorktreeIdentity): string {\n  return identity.branch ?? (basename(identity.worktreeRoot) || 'detached');\n}\n"],
+  "mappings": "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",
+  "names": ["repositoryId"]
+}

package/dist/server/chunk-PSILUMGS.js

@@ -0,0 +1,46 @@
+// server/spawn-opener.ts
+import { spawn } from "node:child_process";
+var OPENER_STDERR_CAP_BYTES = 2048;
+var OPENER_EXIT_WATCH_TIMEOUT_MS = 2e4;
+function spawnOpener(cmd, cmdArgs, fallback) {
+  let child;
+  try {
+    child = spawn(cmd, cmdArgs, { stdio: ["ignore", "ignore", "pipe"], detached: true });
+  } catch (err) {
+    console.error(`vgai: auto-open via ${cmd} failed: ${err.message}`);
+    fallback?.();
+    return;
+  }
+  const stderrChunks = [];
+  let stderrBytes = 0;
+  child.stderr?.on("data", (chunk) => {
+    if (stderrBytes >= OPENER_STDERR_CAP_BYTES) return;
+    const remaining = OPENER_STDERR_CAP_BYTES - stderrBytes;
+    const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;
+    stderrChunks.push(slice);
+    stderrBytes += slice.length;
+  });
+  child.on("error", (err) => {
+    console.error(`vgai: auto-open via ${cmd} failed to launch: ${err.message}`);
+    fallback?.();
+  });
+  child.on("exit", (code) => {
+    if (code !== null && code !== 0) {
+      const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+      console.error(`vgai: auto-open via ${cmd} exited ${code}: ${stderr}`);
+      fallback?.();
+    }
+  });
+  child.unref();
+  const pipeTimeout = setTimeout(() => {
+    child.stderr?.destroy();
+  }, OPENER_EXIT_WATCH_TIMEOUT_MS);
+  pipeTimeout.unref();
+}
+
+export {
+  OPENER_STDERR_CAP_BYTES,
+  OPENER_EXIT_WATCH_TIMEOUT_MS,
+  spawnOpener
+};
+//# sourceMappingURL=chunk-PSILUMGS.js.map

package/dist/server/chunk-PSILUMGS.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../server/spawn-opener.ts"],
+  "sourcesContent": ["/**\n * Best-effort launch of an OS \"open a URL\" command (`open`, `cmd /c start`,\n * `powershell.exe Start-Process`, `xdg-open`, \u2026), extracted from\n * `index.ts`'s `openBrowser` into its own module so it's unit-testable\n * against a REAL spawned child (see `spawn-opener.test.ts`) without pulling\n * in the whole CLI entry point.\n */\n\nimport { type ChildProcess, spawn } from 'node:child_process';\n\n/** Cap on how much of a failed opener's stderr we buffer before printing \u2014\n *  enough for a real error message, small enough to never matter for a\n *  detached fire-and-forget child. */\nexport const OPENER_STDERR_CAP_BYTES = 2048;\n\n/** An unref'd child's piped stderr only stays readable for as long as THIS\n *  process's event loop keeps ticking \u2014 normally guaranteed by the caller's\n *  verified-open poll (>=15s, see waitForVerifiedEditorOpen). Belt-and-\n *  suspenders bound so a genuinely long-lived/never-exiting opener can't\n *  hold the pipe (and this process) open indefinitely if the parent exits\n *  on its own first. */\nexport const OPENER_EXIT_WATCH_TIMEOUT_MS = 20_000;\n\n/** Fire one open attempt, NAMING the failure instead of swallowing it.\n *  Two failure modes, both silent before this fix:\n *  - meteor-dodge dry-run friction #1: the powershell.exe hand-off died\n *    silently in a background shell \u2014 spawn launch failures arrive on the\n *    child's 'error' event, which nothing listened to.\n *  - run-3 dogfood friction #3: a child that LAUNCHES but exits nonzero\n *    (e.g. Start-Process itself failing inside powershell) was silent too \u2014\n *    stdio was fully 'ignore'd and nothing checked the exit code.\n *  Still best-effort: a failure logs one line (stderr captured, capped, and\n *  included when available) and runs `fallback`, if given \u2014 never throws,\n *  never blocks. */\nexport function spawnOpener(cmd: string, cmdArgs: string[], fallback?: () => void): void {\n  let child: ChildProcess;\n  try {\n    child = spawn(cmd, cmdArgs, { stdio: ['ignore', 'ignore', 'pipe'], detached: true });\n  } catch (err) {\n    console.error(`vgai: auto-open via ${cmd} failed: ${(err as Error).message}`);\n    fallback?.();\n    return;\n  }\n\n  const stderrChunks: Buffer[] = [];\n  let stderrBytes = 0;\n  child.stderr?.on('data', (chunk: Buffer) => {\n    if (stderrBytes >= OPENER_STDERR_CAP_BYTES) return;\n    const remaining = OPENER_STDERR_CAP_BYTES - stderrBytes;\n    const slice = chunk.length > remaining ? chunk.subarray(0, remaining) : chunk;\n    stderrChunks.push(slice);\n    stderrBytes += slice.length;\n  });\n\n  child.on('error', (err) => {\n    console.error(`vgai: auto-open via ${cmd} failed to launch: ${err.message}`);\n    fallback?.();\n  });\n\n  child.on('exit', (code) => {\n    if (code !== null && code !== 0) {\n      const stderr = Buffer.concat(stderrChunks).toString('utf8').trim();\n      console.error(`vgai: auto-open via ${cmd} exited ${code}: ${stderr}`);\n      fallback?.();\n    }\n  });\n\n  child.unref();\n\n  const pipeTimeout = setTimeout(() => {\n    child.stderr?.destroy();\n  }, OPENER_EXIT_WATCH_TIMEOUT_MS);\n  pipeTimeout.unref();\n}\n"],
+  "mappings": ";AAQA,SAA4B,aAAa;AAKlC,IAAM,0BAA0B;AAQhC,IAAM,+BAA+B;AAarC,SAAS,YAAY,KAAa,SAAmB,UAA6B;AACvF,MAAI;AACJ,MAAI;AACF,YAAQ,MAAM,KAAK,SAAS,EAAE,OAAO,CAAC,UAAU,UAAU,MAAM,GAAG,UAAU,KAAK,CAAC;AAAA,EACrF,SAAS,KAAK;AACZ,YAAQ,MAAM,uBAAuB,GAAG,YAAa,IAAc,OAAO,EAAE;AAC5E,eAAW;AACX;AAAA,EACF;AAEA,QAAM,eAAyB,CAAC;AAChC,MAAI,cAAc;AAClB,QAAM,QAAQ,GAAG,QAAQ,CAAC,UAAkB;AAC1C,QAAI,eAAe,wBAAyB;AAC5C,UAAM,YAAY,0BAA0B;AAC5C,UAAM,QAAQ,MAAM,SAAS,YAAY,MAAM,SAAS,GAAG,SAAS,IAAI;AACxE,iBAAa,KAAK,KAAK;AACvB,mBAAe,MAAM;AAAA,EACvB,CAAC;AAED,QAAM,GAAG,SAAS,CAAC,QAAQ;AACzB,YAAQ,MAAM,uBAAuB,GAAG,sBAAsB,IAAI,OAAO,EAAE;AAC3E,eAAW;AAAA,EACb,CAAC;AAED,QAAM,GAAG,QAAQ,CAAC,SAAS;AACzB,QAAI,SAAS,QAAQ,SAAS,GAAG;AAC/B,YAAM,SAAS,OAAO,OAAO,YAAY,EAAE,SAAS,MAAM,EAAE,KAAK;AACjE,cAAQ,MAAM,uBAAuB,GAAG,WAAW,IAAI,KAAK,MAAM,EAAE;AACpE,iBAAW;AAAA,IACb;AAAA,EACF,CAAC;AAED,QAAM,MAAM;AAEZ,QAAM,cAAc,WAAW,MAAM;AACnC,UAAM,QAAQ,QAAQ;AAAA,EACxB,GAAG,4BAA4B;AAC/B,cAAY,MAAM;AACpB;",
+  "names": []
+}

package/dist/server/frame-proxy.js

@@ -0,0 +1,255 @@
+// server/frame-proxy.ts
+import {
+  createServer,
+  request as httpRequest
+} from "node:http";
+import { connect as netConnect } from "node:net";
+import { basename } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createBrotliCompress, createGzip, constants as zlibConstants } from "node:zlib";
+var VSCODE_PATH_BASE = "^\\/$|^\\/(static|favicon|manifest\\.json|code-192|code-512|callback|oauth|out|extensions|builtin|remote|vscode-remote|_static|web-extension|version|delay-shutdown)";
+var COMPRESSIBLE = /^(?:text\/|application\/(?:javascript|json|wasm|manifest\+json)|image\/svg\+xml)/;
+var decodeAttr = (value) => value.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+var encodeAttr = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+function negotiateEncoding(header) {
+  const accepted = (Array.isArray(header) ? header.join(",") : header ?? "").toLowerCase();
+  if (accepted.includes("br")) return "br";
+  if (accepted.includes("gzip")) return "gzip";
+  return null;
+}
+function compressor(encoding) {
+  return encoding === "br" ? createBrotliCompress({ params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 5 } }) : createGzip({ level: 6 });
+}
+async function startFrameProxy(options) {
+  const { port, upstreamPort, sessionPort, projectRoot, colorTheme, log } = options;
+  const upstream = { host: "127.0.0.1", port: upstreamPort };
+  const session = { host: "127.0.0.1", port: sessionPort };
+  const upstreamOrigin = `http://${upstream.host}:${upstream.port}`;
+  const selfOrigin = `http://127.0.0.1:${port}`;
+  const webviewOriginTemplate = `http://{{uuid}}.localhost:${port}`;
+  const webviewOriginPattern = `http://*.localhost:${port}`;
+  const projectId = basename(projectRoot);
+  const isolation = {
+    "Cross-Origin-Opener-Policy": "same-origin",
+    "Cross-Origin-Embedder-Policy": "credentialless",
+    "Cross-Origin-Resource-Policy": "cross-origin"
+  };
+  let vscodePath = new RegExp(VSCODE_PATH_BASE);
+  const colorSchemeMeta = (html) => colorTheme === null ? html : html.replace("<head>", `<head>
+		<meta name="color-scheme" content="${colorTheme}">`);
+  const patchWorkbenchConfig = (html) => {
+    const webBaseUrl = html.match(/id="vscode-workbench-web-base-url" data-settings="([^"]*)"/)?.[1] ?? "/static";
+    return html.replace(
+      /(id="vscode-workbench-web-configuration" data-settings=")([^"]*)(")/,
+      (_all, head, value, tail) => {
+        const config = JSON.parse(decodeAttr(value));
+        config["webviewEndpoint"] = `${webviewOriginTemplate}${decodeAttr(webBaseUrl)}/out/vs/workbench/contrib/webview/browser/pre/`;
+        if (colorTheme !== null) config["initialColorTheme"] = { themeType: colorTheme };
+        return head + encodeAttr(JSON.stringify(config)) + tail;
+      }
+    );
+  };
+  const sendText = (res, status, body, type) => {
+    res.writeHead(status, { ...isolation, "content-type": type, "cache-control": "no-store" });
+    res.end(body);
+  };
+  const refuseProject = (res, id) => {
+    sendText(
+      res,
+      404,
+      `<!doctype html><meta charset="utf-8"><title>no such project</title><body style="font:14px system-ui;padding:2rem"><h1>No project "${encodeAttr(id)}" is open here.</h1><p>This workbench is the session for <code>${encodeAttr(projectRoot)}</code>, whose id is <code>${encodeAttr(projectId)}</code>.</p>`,
+      "text/html; charset=utf-8"
+    );
+  };
+  const handleRequest = (req, res) => {
+    const url = new URL(req.url ?? "/", selfOrigin);
+    const pathname = url.pathname;
+    if (pathname === "/") {
+      const id = url.searchParams.get("project");
+      if (id && !url.searchParams.has("folder") && !url.searchParams.has("workspace")) {
+        if (id !== projectId) {
+          refuseProject(res, id);
+          return;
+        }
+        const next = new URL(url);
+        next.searchParams.delete("project");
+        next.searchParams.set("folder", projectRoot);
+        res.writeHead(302, {
+          ...isolation,
+          location: `${next.pathname}${next.search}`,
+          "cache-control": "no-store"
+        });
+        res.end();
+        return;
+      }
+    }
+    const target = vscodePath.test(pathname) ? upstream : session;
+    const encoding = negotiateEncoding(req.headers["accept-encoding"]);
+    const forward = httpRequest(
+      { ...target, method: req.method, path: req.url, headers: req.headers },
+      (answer) => {
+        const headers = {};
+        for (const [key, value] of Object.entries(answer.headers)) {
+          if (value !== void 0) headers[key] = value;
+        }
+        delete headers["cross-origin-opener-policy"];
+        delete headers["cross-origin-embedder-policy"];
+        delete headers["cross-origin-resource-policy"];
+        const csp = headers["content-security-policy"];
+        if (typeof csp === "string" && csp.includes("frame-src")) {
+          headers["content-security-policy"] = csp.replace(/frame-src([^;]*)/, `frame-src$1 ${webviewOriginPattern}`).replace(/connect-src([^;]*)/, "connect-src$1 blob:").replace(/media-src([^;]*)/, "media-src$1 blob:");
+        }
+        const type = String(headers["content-type"] ?? "");
+        const alreadyEncoded = headers["content-encoding"] !== void 0;
+        if (/text\/html|javascript|json/.test(type) && !alreadyEncoded) {
+          const chunks = [];
+          answer.on("data", (chunk) => chunks.push(chunk));
+          answer.on("end", () => {
+            let body = Buffer.concat(chunks).toString("utf8").replaceAll(upstreamOrigin, selfOrigin);
+            if (pathname === "/" && target === upstream && /text\/html/.test(type)) {
+              body = colorSchemeMeta(patchWorkbenchConfig(body));
+            }
+            delete headers["content-length"];
+            const raw = Buffer.from(body, "utf8");
+            if (encoding === null) {
+              res.writeHead(answer.statusCode ?? 502, {
+                ...headers,
+                ...isolation,
+                "content-length": raw.byteLength
+              });
+              res.end(raw);
+              return;
+            }
+            res.writeHead(answer.statusCode ?? 502, {
+              ...headers,
+              ...isolation,
+              "content-encoding": encoding,
+              vary: "accept-encoding"
+            });
+            const stream = compressor(encoding);
+            stream.pipe(res);
+            stream.end(raw);
+          });
+          return;
+        }
+        if (encoding !== null && !alreadyEncoded && COMPRESSIBLE.test(type)) {
+          delete headers["content-length"];
+          res.writeHead(answer.statusCode ?? 502, {
+            ...headers,
+            ...isolation,
+            "content-encoding": encoding,
+            vary: "accept-encoding"
+          });
+          void pipeline(answer, compressor(encoding), res).catch(() => res.destroy());
+          return;
+        }
+        res.writeHead(answer.statusCode ?? 502, { ...headers, ...isolation });
+        answer.pipe(res);
+      }
+    );
+    forward.on("error", (error) => {
+      if (!res.headersSent) {
+        sendText(
+          res,
+          502,
+          `upstream ${target.port}: ${error.message}`,
+          "text/plain; charset=utf-8"
+        );
+      } else res.destroy();
+    });
+    res.on("close", () => forward.destroy());
+    req.pipe(forward);
+  };
+  const handleUpgrade = (req, socket, head) => {
+    const target = vscodePath.test(new URL(req.url ?? "/", selfOrigin).pathname) ? upstream : session;
+    const proxied = netConnect(target.port, target.host, () => {
+      proxied.write(
+        `${req.method} ${req.url} HTTP/${req.httpVersion}\r
+` + Object.entries(req.headers).map(([key, value]) => `${key}: ${Array.isArray(value) ? value.join(", ") : value}`).join("\r\n") + "\r\n\r\n"
+      );
+      if (head.length) proxied.write(head);
+      socket.pipe(proxied).pipe(socket);
+    });
+    proxied.on("error", () => socket.destroy());
+    socket.on("error", () => proxied.destroy());
+  };
+  const discoverUpstream = () => new Promise((done) => {
+    const probe = httpRequest({ ...upstream, path: "/" }, (answer) => {
+      const chunks = [];
+      answer.on("data", (chunk) => chunks.push(chunk));
+      answer.on("end", () => {
+        const html = Buffer.concat(chunks).toString("utf8");
+        const base = html.match(
+          /id="vscode-workbench-web-base-url" data-settings="([^"]*)"/
+        )?.[1];
+        done(answer.statusCode === 200 && base ? decodeAttr(base).replace(/\/static\/?$/, "") : null);
+      });
+    });
+    probe.on("error", () => done(null));
+    probe.setTimeout(3e3, () => {
+      probe.destroy();
+      done(null);
+    });
+    probe.end();
+  });
+  const discoveryDeadline = Date.now() + 3e4;
+  let segment = null;
+  do {
+    segment = await discoverUpstream();
+    if (segment !== null) break;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  } while (Date.now() < discoveryDeadline);
+  if (segment === null) throw new Error(
+    `Code-OSS on port ${upstream.port} did not report its workbench asset base within 30s; refusing to start an incorrectly routed proxy.`
+  );
+  if (segment) {
+    vscodePath = new RegExp(
+      `${VSCODE_PATH_BASE}|^${segment.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(\\/|$)`
+    );
+    log(`frame: workbench product segment ${segment}`);
+  }
+  const servers = [];
+  await new Promise((ready, failed) => {
+    let settled = false;
+    for (const host of ["127.0.0.1", "::1"]) {
+      const one = createServer(handleRequest);
+      one.on("upgrade", handleUpgrade);
+      one.on("error", (error) => {
+        if (host === "::1") {
+          log(
+            `frame: no IPv6 loopback listener (${error.message}); webviews need one if the browser resolves *.localhost to ::1`
+          );
+          return;
+        }
+        if (!settled) {
+          settled = true;
+          failed(error);
+        }
+      });
+      servers.push(one);
+      one.listen(port, host, () => {
+        if (!settled) {
+          settled = true;
+          ready();
+        }
+      });
+    }
+  });
+  return {
+    url: `${selfOrigin}/?project=${encodeURIComponent(projectId)}`,
+    close: async () => {
+      await Promise.all(
+        servers.map(
+          (one) => new Promise((done) => {
+            one.close(() => done());
+            one.closeAllConnections?.();
+          })
+        )
+      );
+    }
+  };
+}
+export {
+  startFrameProxy
+};
+//# sourceMappingURL=frame-proxy.js.map