flowviant 0.124.0 → 0.124.1

package/bin/lib/workLiveMessages.mjs

@@ -0,0 +1,129 @@
+/** One live conversation's input relay, shared by tabs, capture chats and
+ * card agents. The server owns queue/holder checks; the CLI echo owns receipt.
+ * Durable receipts plus native transcript UUIDs cover a restart before POST.
+ * No model call, new process, or re-send of an unacknowledged write here. */
+import { readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { fleetRequest } from './fleetPost.mjs';
+import { fleetEndpoint, isConsideredRefusal } from './fleetWire.mjs';
+import { DAEMON_INSTANCE, FLEET_URL } from './config.mjs';
+import { messageIdsForSession } from './claudeSessions.mjs';
+
+export function createLiveMessages({ scope, turnId, attempt, cwd, sessionMetaPath, format, interrupted = () => false,
+  request = fleetRequest, nativeIds = messageIdsForSession, setTimer = setInterval, clearTimer = clearInterval, finalFlushMs = 1_000 }) {
+  const identity = { scope, turnId, instance: DAEMON_INSTANCE, ...(attempt !== undefined ? { attempt } : {}) };
+  const file = sessionMetaPath(cwd, 'flowviant-live-messages', turnId);
+  let sessionId = null;
+  let timer = null;
+  let stopped = false;
+  let send = null;
+  let flight = null;
+  let posting = null;
+  const sent = new Set();
+  const initialIds = new Set();
+  let initialId = turnId;
+  const taken = new Set();
+  const confirmed = new Set();
+  const outstanding = () => [...taken].filter((id) => !confirmed.has(id));
+  try {
+    const saved = JSON.parse(readFileSync(file, 'utf8'));
+    sessionId = saved.sessionId;
+    for (const id of saved.ids ?? []) if (typeof id === 'string') taken.add(id);
+  } catch { /* no measured receipts yet */ }
+  const save = () => {
+    if (!file) return;
+    // Keep only ids and the CLI's conversation id, never the person's words.
+    const temporary = `${file}.tmp-${process.pid}`;
+    try {
+      writeFileSync(temporary, JSON.stringify({ sessionId, ids: outstanding() }), { mode: 0o600, flag: 'wx' });
+      renameSync(temporary, file); // a crash leaves the previous complete receipt
+    } catch { /* the native transcript remains the recovery evidence */ }
+    finally { try { rmSync(temporary, { force: true }); } catch { /* best effort */ } }
+  };
+  const flush = () => {
+    if (posting) return posting;
+    if (!outstanding().length) return Promise.resolve(true);
+    posting = (async () => {
+      for (const id of outstanding()) {
+        const result = await request(fleetEndpoint('live-turn-messages-taken', FLEET_URL), { body: { ...identity, ids: [id] }, timeoutMs: 15_000 });
+        if (!result.ok || result.json?.data?.taken !== true) return false;
+        confirmed.add(id);
+        save();
+      }
+      return true;
+    })().catch(() => false).finally(() => { posting = null; });
+    return posting;
+  };
+  const onTaken = (id) => {
+    if (initialIds.has(id) || taken.has(id)) return;
+    taken.add(id);
+    save(); // synchronous before the report or final settlement
+    void flush();
+  };
+  const tick = () => {
+    if (flight || stopped || interrupted() || !send) return flight ?? Promise.resolve();
+    flight = (async () => {
+      await flush();
+      if (stopped || interrupted()) return;
+      const result = await request(fleetEndpoint('live-turn-messages', FLEET_URL), { body: identity, timeoutMs: 15_000 });
+      if (!result.ok) {
+        if (isConsideredRefusal(result.status)) { if (timer) clearTimer(timer); timer = null; }
+        return;
+      }
+      if (!result.json?.data?.active) return;
+      const seen = sessionId ? nativeIds(cwd, sessionId) : null;
+      for (const message of result.json.data.messages ?? []) {
+        if (stopped || interrupted()) break;
+        if (taken.has(message.id) || seen?.has(message.id)) { onTaken(message.id); continue; }
+        if (sent.has(message.id)) continue;
+        const prompt = await format(message);
+        if (!stopped && !interrupted() && send(message.id, prompt)) sent.add(message.id);
+      }
+    })().catch(() => {}).finally(() => { flight = null; });
+    return flight;
+  };
+  return {
+    turnId, onTaken, tick,
+    connected: () => Boolean(send) && !stopped,
+    get initialId() { return initialId; },
+    initialPrompt(prompt, resumeId, resume = Boolean(resumeId), continuation = false) {
+      initialId = turnId;
+      sessionId = resume || resumeId ? resumeId || sessionId : null;
+      // A daemon-authored correction continues the same conversation with
+      // new instructions. Restart recovery alone replaces the old prompt.
+      if (continuation) {
+        initialId = randomUUID();
+        initialIds.add(initialId);
+        return prompt;
+      }
+      if ((resume || resumeId) && sessionId && nativeIds(cwd, sessionId)?.has(turnId)) {
+        onTaken(turnId); // the native transcript proves the original prompt was read
+        initialId = randomUUID(); // continuation, never a second copy of the user's UUID
+        initialIds.add(initialId);
+        return 'Continue the request already in this conversation after the process stopped. Inspect the work in flight before repeating a command, and finish under the same operating contract.';
+      }
+      return prompt;
+    },
+    onInit(id) { sessionId = id; save(); },
+    connect(writer) {
+      sent.clear(); // a new child can retry writes the previous child never echoed
+      stopped = false;
+      send = writer;
+      timer = setTimer(() => void tick(), 1_000);
+      timer?.unref?.();
+      void tick();
+    },
+    receipts: () => ({ ...identity, ids: outstanding() }),
+    async stop() {
+      stopped = true;
+      if (timer) clearTimer(timer);
+      timer = null;
+      // A completed CLI never waits on a queue read or attachment download.
+      // Give receipts one bounded chance; the final report carries the rest.
+      let cap;
+      try { await Promise.race([flush(), new Promise(resolve => { cap = setTimeout(resolve, finalFlushMs); })]); }
+      finally { clearTimeout(cap); }
+      if (!outstanding().length && file) try { rmSync(file, { force: true }); } catch { /* best effort */ }
+    },
+  };
+}

package/bin/lib/workPlaceReports.mjs

@@ -23,6 +23,7 @@ import { fleetEndpoint } from './fleetWire.mjs';
 import { isValidPlace } from './workPlaces.mjs';
 
 export function createWorkPlaceReports({
+  repositoryPlaces,
   repoRoot,
   baseRef,
   placeOf,
@@ -101,6 +102,10 @@ export function createWorkPlaceReports({
     const wt = placeDir(sessionId);
     const d = worktreeDiff(wt, baseRef());
     if (!d) return null;
+    const siblings = repositoryPlaces?.entries(place).filter((r) => r.writable) ?? [];
+    if (siblings.length) {
+      d.commits = siblings.flatMap((r) => (worktreeDiff(r.wt, r.baseRef)?.commits ?? []).map((commit) => ({ ...commit, repo: r.id }))).slice(0, 50);
+    }
     // WHAT IS LISTENING in this worktree, attributed by the CWD of the process
     // holding the socket. It rides the sweep the daemon already makes rather
     // than taking a beat of its own, exactly as the commit trailers do — and

package/bin/lib/workPlaces.mjs

@@ -12,6 +12,7 @@
  * the session lane's turn intake both go through it (audit 2026-10-10, F141),
  * so a lane that learns a place cannot store one unvalidated.
  */
+import { readRepositoryPlace } from './repositoryPlaces.mjs';
 import { existsSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { git, isSafePathSegment, hasCommits, gitFailure, sessionBranch } from './git.mjs';
@@ -51,7 +52,11 @@ export function isValidPlace(place) {
  * that does not exist rather than becoming the operator's checkout.
  */
 export function worktreePath(baseDir, place) {
-  return isSafePathSegment(place) ? join(baseDir, 'sessions', place) : null;
+  if (!isSafePathSegment(place)) return null;
+  const home = join(baseDir, 'sessions', place);
+  const state = readRepositoryPlace(home);
+  const primary = state?.repositories.find((r) => r.id === state.primary && r.writable);
+  return primary ? join(home, primary.folder) : home;
 }
 
 /**

package/bin/lib/workRetire.mjs

@@ -14,6 +14,7 @@ import { git, isSafePathSegment } from './git.mjs';
 import { PERSON_PLACE_PREFIX } from './workPlaces.mjs';
 
 export function createWorkRetire({
+  repositoryPlaces,
   repoRoot,
   baseDir,
   baseRef,
@@ -113,6 +114,10 @@ export function createWorkRetire({
         // Uncommitted work is the human's — a resource sweep does not outrank
         // it, closed tab or not. (The non-force remove would refuse anyway;
         // the explicit check keeps the intent legible.)
+        if (repositoryPlaces?.stateFor(id)) {
+          if (repositoryPlaces.remove(id)) { workTokens.delete(id); removed++; }
+          continue;
+        }
         if (git(['status', '--porcelain'], wt) !== '') continue;
         git(['worktree', 'remove', wt], repoRoot); // non-force
         workTokens.delete(id);

package/bin/lib/workSessionTurns.mjs

@@ -32,6 +32,8 @@ import { isAgyConversationLive } from './agySessions.mjs';
 import { adoptFence } from './localSessions.mjs';
 import { resumeRetriesFresh } from './resumeLost.mjs';
 import { turnLockedByLivePid } from './turnLock.mjs';
+import { createDeliveryReporter } from './workDelivery.mjs';
+import { createLiveMessages } from './workLiveMessages.mjs';
 import { killGroup } from './processGroup.mjs';
 import { printable } from './printable.mjs';
 import { brainFor } from './workBrain.mjs';
@@ -84,6 +86,8 @@ export function createWorkSessionTurns({
   runTurn = defaultRunTurn,
   // The clock `settledHere` ages by; injectable only for its bound's test.
   now = Date.now,
+  makeLiveMessages = createLiveMessages,
+  reportDelivery = createDeliveryReporter(),
 }) {
   const workAnswering = new Set(); // turn ids currently queued/running here
   const MAX_WORK_TRIES = 3;
@@ -144,12 +148,14 @@ export function createWorkSessionTurns({
     settledHere.delete(turnId); // re-inserted at the end: the map stays in time order
     settledHere.set(turnId, at);
     forgetStale(at);
-    return settleWorkTurn(turnId, payload);
+    const liveMessages = runs.get(turnId)?.live?.receipts();
+    return settleWorkTurn(turnId, { ...payload, ...(liveMessages?.ids.length ? { liveMessages } : {}) });
   };
 
   /**
-   * A PLACE A TURN OF THIS PROCESS IS STARTING IN (2026-09-29) — the turn
-   * lock's in-process half, keyed by the lock's own path.
+   * A TAB A TURN OF THIS PROCESS IS STARTING IN (2026-09-29; per tab since
+   * 2026-10-14) — the turn lock's in-process half, keyed by the lock's own
+   * path.
    *
    * `flowviant-turn.lock` is written at SPAWN, several awaits after it is
    * read (a credential mint, the attachment fetch), so two turns of one
@@ -159,7 +165,8 @@ export function createWorkSessionTurns({
    * check, so the second turn waits for a later poll like any locked one,
    * and it is released in the turn's outer `finally`, after its settle.
    */
-  const startingIn = new Set();
+  const startingIn = new Map(); // lock path -> the holding tab's measured name
+
   // A roster can contain a turn read before its stop was requested. Never
   // start that stale job after acknowledging the same roster's interrupt.
   let rosterInterrupts = new Set();
@@ -168,13 +175,23 @@ export function createWorkSessionTurns({
     for (const job of jobs ?? []) {
       if (!job || typeof job.id !== 'string' || !job.body || !job.sessionId) continue;
       if (rosterInterrupts.has(job.id)) continue;
-      if (workAnswering.has(job.id)) continue;
+      if (workAnswering.has(job.id)) {
+        const reason = runs.get(job.id)?.waitingReason;
+        if (reason) reportDelivery('session', job, 'queued', reason);
+        continue;
+      }
       // Settled by this lane already: a roster read from before the settle
       // landed. See `settledHere`.
       if (settledRecently(job.id)) continue;
       // The turn already RAN and its answer sits in the delivery queue — never
       // run it again while the report is merely undelivered.
       if (pendingWorkReports.has(job.id)) continue;
+      // This conversation already has a streaming Claude. Its input relay
+      // reads the durable queue; a second process must never read these words.
+      if ([...runs.values()].some((r) => r.sessionId === job.sessionId && r.live?.connected() && !r.interrupted)) {
+        reportDelivery('session', job, 'queued', 'waiting for this turn to take in the message');
+        continue;
+      }
       /**
        * THE BOX IS ABOUT TO FALL OVER, OR THIS MACHINE IS ALREADY AT ITS
        * CEILING. Defer: return without settling and without consuming an
@@ -195,12 +212,13 @@ export function createWorkSessionTurns({
       const hold = admit('interactive');
       if (hold) {
         sayTurnDeferred(job.sessionId, job.id, hold.reason);
+        reportDelivery('session', job, 'queued', hold.reason);
         continue;
       }
       const releaseSlot = admit.reserve();
       lastDeferSaid.delete(job.sessionId);
       workAnswering.add(job.id);
-      const run = { interrupted: false, spawned: [] };
+      const run = { interrupted: false, spawned: [], sessionId: job.sessionId, live: null };
       runs.set(job.id, run);
       /** The execution generation the server handed, echoed on every settle
        *  so the server can tell this execution's answer from an older one's. */
@@ -236,6 +254,7 @@ export function createWorkSessionTurns({
       }
       // A READER: other turns in this place run alongside it. See `inPlace`.
       inPlace(place, false, async () => {
+        run.waitingReason = null;
         /** This turn's artifact snapshot — set once the place is resolved and
          *  a CLI is about to spawn there; read in the `finally`. Null on every
          *  path that never ran a CLI, which is exactly when nothing is new. */
@@ -404,23 +423,37 @@ export function createWorkSessionTurns({
             });
             return;
           }
-          // A live CLI is ALREADY in this worktree — this daemon's previous
-          // life, most likely; the lock outlives a restart. Leave the job
-          // pending and look again next poll; spawning a second CLI would put
-          // two Claudes in one held context. Costs no attempt: nothing ran.
+          // A live CLI is ALREADY in this tab's conversation — this daemon's
+          // previous life, most likely; the lock outlives a restart. Leave the
+          // job pending and look again next poll; spawning a second CLI would
+          // put two Claudes in one held context. Costs no attempt: nothing ran.
           // …AND ONE OF OURS MAY BE ABOUT TO: `startingIn`, checked and
           // claimed with no await between, because the file is only written
-          // at spawn. Keyed by the lock's path (the directory, when the git
-          // dir cannot be named) — the file lock's own scope.
-          const lockPath = sessionMetaPath(dir.wt, 'flowviant-turn.lock');
-          const startKey = lockPath || dir.wt;
+          // at spawn. Keyed by the lock's path (the directory and the tab,
+          // when the git dir cannot be named) — the file lock's own scope.
+          // PER TAB (2026-10-14, turnLock.mjs): other tabs in this directory
+          // run beside it. The unscoped file is an older daemon's CLI, whose
+          // tab is unknown, so it holds every tab here until it exits.
+          const lockPath = sessionMetaPath(dir.wt, 'flowviant-turn.lock', job.sessionId);
+          const legacyLock = sessionMetaPath(dir.wt, 'flowviant-turn.lock');
+          const startKey = lockPath || `${dir.wt}\0${job.sessionId}`;
+          const tabId = printable(job.sessionId);
+          const tabLabel = `tab "${printable(job.sessionName) || tabId}" (${tabId})`;
+          if (turnLockedByLivePid(legacyLock)) {
+            reportDelivery('session', job, 'queued', 'waiting for another tab’s turn to finish (legacy lock; tab unknown)');
+            warn(
+              `a turn from an earlier flowviant holds the place; tab unknown (legacy lock) — ${tabLabel} waits for it to finish`
+            );
+            return;
+          }
           if (startingIn.has(startKey) || turnLockedByLivePid(lockPath)) {
+            reportDelivery('session', job, 'queued', 'waiting for this turn to finish');
             warn(
-              `a turn is already running in "${printable(job.sessionName) || job.sessionId}" — waiting for it to finish`
+              `${startingIn.get(startKey) || tabLabel} holds the turn lock — waiting for it to finish`
             );
             return;
           }
-          startingIn.add(startKey);
+          startingIn.set(startKey, tabLabel);
           startClaim = startKey;
           // WHICH BRAIN the roster says this tab speaks (null/absent = Claude,
           // which is what every tab ran on until now) — honored by
@@ -683,6 +716,17 @@ export function createWorkSessionTurns({
               .filter(Boolean)
               .join('\n\n');
             const turnArgs = {
+              ...(rt.id === 'claude' ? { liveMessages: (run.live = makeLiveMessages({
+                scope: 'session', turnId: job.id, attempt: job.attempt, cwd: dir.wt, sessionMetaPath,
+                interrupted: () => run.interrupted,
+                format: async (followup) => {
+                  const paths = await fetchAttachments(dir.wt, followup.attachments);
+                  const note = paths.length ? `[FILES THE HUMAN ATTACHED TO THIS MESSAGE — already on disk in this worktree]\n${paths.map((f) => `- ${f}`).join('\n')}` : '';
+                  const words = shape.capture ? (followup.libraryPrompt ?? '') + followup.body : followup.body + (followup.libraryPrompt ?? '');
+                  return sessionTurnKickoff(shape, { sessionId: job.sessionId, sessionName: job.sessionName,
+                    askedByName: followup.askedByName, message: [words, note].filter(Boolean).join('\n\n') });
+                },
+              })) } : {}),
               // The kickoff under the turn's contract: a plain tab (or a plan
               // turn) has no tools to name and no session id to pass, and asks
               // for one complete report instead of a stream; a capture chat
@@ -767,13 +811,15 @@ export function createWorkSessionTurns({
               // a tab's build turn is the machine's measurement; its fenced
               // capture chat is not.
               onInit: (i) => {
-                // The conversation this turn is actually speaking under. Held
-                // and persisted after the turn ends, so the NEXT one resumes
-                // this exact thread rather than whatever the directory saw
-                // last. Last write wins on purpose: a resume that fell back to
-                // fresh reports the fresh id, healing the marker.
-                if (typeof i.sessionId === 'string' && i.sessionId.trim())
+                // Pin at init so a restart during a long tool can resume the
+                // same conversation and recover its native message UUIDs.
+                if (typeof i.sessionId === 'string' && i.sessionId.trim()) {
                   seenClaudeSession = i.sessionId.trim();
+                  if (CLAUDE_SESSION_RE.test(seenClaudeSession)) {
+                    const marker = sessionMetaPath(dir.wt, RESUME_MARKERS.claude, job.sessionId);
+                    if (marker) try { writeFileSync(marker, seenClaudeSession); } catch { /* best effort */ }
+                  }
+                }
               },
               cwd: dir.wt,
               mcpArgs: mcp.args,
@@ -792,6 +838,7 @@ export function createWorkSessionTurns({
               },
               onSpawn: (ch) => {
                 if (!ch) return;
+                if (rt.id !== 'claude') reportDelivery('session', job, 'taken');
                 spawned.push(ch);
                 run.spawned.push(ch);
                 // Asked to stop between the check and the spawn.
@@ -883,24 +930,6 @@ export function createWorkSessionTurns({
           // before it ever touches disk — it later rides in argv as
           // `resume <id>` — and best-effort, like the runtime pin: an
           // unwritable marker just means the tab runs fresh next turn.
-          // The conversation THIS TAB just spoke under, pinned so the next
-          // turn resumes it by id rather than asking the directory. Written
-          // after the turn for the same reason codex's is: an id learned
-          // mid-turn is only true once the turn that learned it finished.
-          if (
-            rt.id === 'claude' &&
-            seenClaudeSession &&
-            CLAUDE_SESSION_RE.test(seenClaudeSession)
-          ) {
-            const convMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.claude, job.sessionId);
-            if (convMarker) {
-              try {
-                writeFileSync(convMarker, seenClaudeSession);
-              } catch {
-                /* best-effort — the next turn re-learns it */
-              }
-            }
-          }
           if (rt.id === 'codex' && seenThreadId && CODEX_THREAD_RE.test(seenThreadId)) {
             const threadMarker = sessionMetaPath(dir.wt, RESUME_MARKERS.codex, job.sessionId);
             if (threadMarker) {
@@ -1069,6 +1098,9 @@ export function createWorkSessionTurns({
               .catch(() => {});
           }
         }
+      }, () => {
+        run.waitingReason = 'waiting for a ship to finish';
+        reportDelivery('session', job, 'queued', run.waitingReason);
       });
     }
   };

package/bin/lib/workShip.mjs

@@ -7,7 +7,7 @@ import { gitMergeIn } from './gitMergeIdentity.mjs';
 import { c, note, ok, warn } from './ui.mjs';
 import { scrub as envScrub } from './uplinkScrub.mjs';
 import { REPO_PLACE } from './workPlaces.mjs';
-import { turnLockedByLivePid } from './turnLock.mjs';
+import { placeTurnLockHolder } from './turnLock.mjs';
 import { printable } from './printable.mjs';
 
 export function createWorkShipper({
@@ -227,11 +227,24 @@ export function createWorkShipper({
             ok(`${c.cyan('ship')} ${c.dim('— already on main; nothing new to merge')}`);
             return;
           }
+          // Any tab's orphaned CLI holds this shared HEAD across a restart.
+          // This also applies when the SHIPPING tab is closed: another tab
+          // can still be editing its place. Query the directory without
+          // re-cutting a retired worktree, after the idempotent receipt path.
+          const holder = placeTurnLockHolder(sessionMetaPath(wt, 'flowviant-turn.lock'));
+          if (holder) {
+            const holderTab = holder.sessionId === null ? 'tab unknown (legacy lock)' : `tab "${printable(holder.sessionId)}"`;
+            warn(
+              `${holderTab} holds the turn lock — ship of "${sessionName || job.sessionId}" waits for it`
+            );
+            deferred = true;
+            return;
+          }
           const ended = liveIds ? !liveIds.has(job.sessionId) : false;
           if (ended) {
-            // The tab is closed: no turn can commit, discard, or resolve
-            // anything in the directory, so a dirty worktree must not strand
-            // the branch's committed work in review forever. Ship the TIP.
+            // The tab is closed: it cannot commit, discard, or resolve, so
+            // a dirty worktree must not strand its committed work in review
+            // forever. With every other tab's CLI quiet, ship the TIP.
             if (!branchExists) {
               await done({
                 ok: false,
@@ -284,18 +297,6 @@ export function createWorkShipper({
             });
             return;
           }
-          // A live CLI is in this worktree — a restarted daemon's orphan
-          // mid-turn (in-process the chain serializes, but the lock is the
-          // only guarantee that survives a crash). Folding under it would
-          // rewrite HEAD inside a held conversation; defer like the turn
-          // path, and the job re-offers next poll.
-          if (turnLockedByLivePid(sessionMetaPath(dir.wt, 'flowviant-turn.lock'))) {
-            warn(
-              `a turn is still running in "${sessionName || job.sessionId}" — ship waits for it`
-            );
-            deferred = true;
-            return;
-          }
           if (git(['status', '--porcelain'], dir.wt) !== '') {
             await done({
               ok: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flowviant",
-  "version": "0.124.0",
+  "version": "0.124.1",
   "description": "Run your own coding CLIs as build agents for Flowviant — Claude Code, Codex or Antigravity, on your own credentials. Holds your sessions, keeps a worktree per tab, and ships branches on your word.",
   "type": "module",
   "bin": {

package/npm-shrinkwrap.json

@@ -1,69 +0,0 @@
-{
-  "name": "flowviant",
-  "version": "0.124.0",
-  "lockfileVersion": 3,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "flowviant",
-      "version": "0.124.0",
-      "license": "MIT",
-      "dependencies": {
-        "libsodium-wrappers-sumo": "^0.8.4",
-        "ws": "^8.18.0"
-      },
-      "bin": {
-        "flowviant": "bin/cli.mjs"
-      },
-      "devDependencies": {
-        "three": "0.180.0"
-      },
-      "engines": {
-        "node": ">=20"
-      }
-    },
-    "node_modules/libsodium-sumo": {
-      "version": "0.8.4",
-      "resolved": "https://registry.npmjs.org/libsodium-sumo/-/libsodium-sumo-0.8.4.tgz",
-      "integrity": "sha512-TMtHShQfVVsaxDygyapvUC3o7YsPgXa/hRWeIgzyFz6w5k/1hirGptCxp1U7XwW3rCskaTTYKgV10v86UiGgNw==",
-      "license": "ISC"
-    },
-    "node_modules/libsodium-wrappers-sumo": {
-      "version": "0.8.4",
-      "resolved": "https://registry.npmjs.org/libsodium-wrappers-sumo/-/libsodium-wrappers-sumo-0.8.4.tgz",
-      "integrity": "sha512-ql7hcgulKZ3ekfa2DGAogcCKsWU0diA/0nArz1CFzh93WQdb46/Kj18ka/Hifq6uA3Ush34Pc6vU/6HXeRwUkg==",
-      "license": "ISC",
-      "dependencies": {
-        "libsodium-sumo": "^0.8.0"
-      }
-    },
-    "node_modules/three": {
-      "version": "0.180.0",
-      "resolved": "https://registry.npmjs.org/three/-/three-0.180.0.tgz",
-      "integrity": "sha512-o+qycAMZrh+TsE01GqWUxUIKR1AL0S8pq7zDkYOQw8GqfX8b8VoCKYUoHbhiX5j+7hr8XsuHDVU6+gkQJQKg9w==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/ws": {
-      "version": "8.21.1",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.1.tgz",
-      "integrity": "sha512-+0NTnW77fFN/DjQi6k/Sq/Yvk4Sgajw7urW8V+asjXnRgDs9gyGkdb7EzgfhA4goXsRIZKE28fzIXBHEzhuiWw==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=10.0.0"
-      },
-      "peerDependencies": {
-        "bufferutil": "^4.0.1",
-        "utf-8-validate": ">=5.0.2"
-      },
-      "peerDependenciesMeta": {
-        "bufferutil": {
-          "optional": true
-        },
-        "utf-8-validate": {
-          "optional": true
-        }
-      }
-    }
-  }
-}