@dailies-studio/shot-editor 0.1.0 → 0.2.0

package/src/state/renderEvents.ts

@@ -15,17 +15,41 @@
 // "the document moved underneath me", and only one of them would have that
 // refusal in it.
 //
-// EventSource reconnects on its own, and a missed frame costs a stale progress
-// number until the next one. For the document that is safe too: `doc-changed`
-// is a NOTIFICATION and `adoptExternalChange` re-reads from the server, so a
-// dropped frame costs a stale view until the next write, which the baseRev 409
-// protocol already makes safe.
+// EventSource reconnects on its own. For the document a dropped frame is safe:
+// `doc-changed` is a NOTIFICATION and `adoptExternalChange` re-reads from the
+// server, so it costs a stale view until the next write, which the baseRev 409
+// protocol already makes safe. For a render it was NOT: a dropped "done" or
+// "failed" left the export lock held and the dialog on "Rendering" forever, and
+// a server restart dropped the job itself. So every `hello` (the first frame of
+// every connection, reconnects included) re-reads the render state; see
+// `reconcileRender`.
+import { renderState } from "../api.js";
+import type { RenderJob, RenderState } from "../api.js";
+import type { StageHealthRequest } from "@dailies-studio/shot/doc";
+import { dailiesHost } from "../hostApi.js";
+import { CLIENT_ID, CLIENT_ID_HEADER } from "./clientId.js";
+import { setRuntimeErrorRevision } from "./runtimeErrors.js";
+import { awaitStageHealth } from "./stageHealth.js";
 import type { ShotEditorStore } from "./store.js";
-import type { RenderJob } from "../api.js";
+import { buffersOpen } from "./types.js";
+import { parseAgentActivity } from "./agentActivity.js";
 
 /** The SSE event names; `docEvents.ts` is the other half of this contract. */
 const EVENT = "shot-render";
 const DOC_EVENT = "doc-changed";
+const CONTRACT_EVENT = "contract-changed";
+const FILES_EVENT = "files-changed";
+const RELAY_EVENT = "relay-request";
+/** Comment events (plan C4): `{v:1, projectId, threadId, stillId}` and
+ *  `{v:1}`. Signals only: the comments store refetches. */
+const COMMENTS_EVENT = "comments-changed";
+const INBOX_EVENT = "inbox-changed";
+/** An MCP agent's tool call started or ended (store mcpActivity.ts). */
+const AGENT_EVENT = "agent-activity";
+/** An agent's question to the person moved: `{v:1, project, id, status}`. */
+const QUESTION_EVENT = "agent-question";
+/** A project file's bytes changed: `{v:1, path, hash}`. */
+const SOURCE_EVENT = "source-changed";
 
 /**
  * Subscribe until the returned function is called.
@@ -35,47 +59,303 @@ const DOC_EVENT = "doc-changed";
  * chrome from booting.
  */
 export function subscribeStudioEvents(store: ShotEditorStore): () => void {
+  // ── WHAT THE STAGE MADE OF A WRITE, FOR AN AGENT ─────────────────────
+  //
+  // An MCP write waits for an editor tab's stage to draw it and reports what
+  // the stage holds (state/stageHealth.ts). Hosted, the code host answers the
+  // workspace's relayed question and asks this chrome through the host seam.
+  // Locally there is no code host: this chrome's feed names it and asks for
+  // the dev server's one relayed question, `stage`, which it answers itself.
+  const host = dailiesHost();
+  setRuntimeErrorRevision(() => {
+    const now = store.getState();
+    return now.dirty ? null : now.rev;
+  });
+  host?.provideStageHealth((request) => awaitStageHealth(store, request));
+  // ── COMMENTS COME BACK ON FOCUS ─────────────────────────────────────────
+  //
+  // A hidden tab's EventSource may be throttled or dropped, and an access
+  // change made in the dashboard tab (Share and mention) sends no comment
+  // event. So a tab that comes back to the front re-reads both.
+  const refetchComments = (): void => {
+    if (typeof document !== "undefined" && document.visibilityState === "hidden") return;
+    void store.comments.refresh();
+    void store.comments.loadInbox();
+  };
+  const win = typeof window === "undefined" ? undefined : window;
+  win?.addEventListener("focus", refetchComments);
+  win?.document.addEventListener("visibilitychange", refetchComments);
+  const unlistenFocus = (): void => {
+    win?.removeEventListener("focus", refetchComments);
+    win?.document.removeEventListener("visibilitychange", refetchComments);
+  };
   const Source = (globalThis as { EventSource?: typeof EventSource }).EventSource;
-  if (Source === undefined) return () => {};
-  const source = new Source("/api/events");
+  if (Source === undefined) return unlistenFocus;
+  const source = new Source(host === undefined ? `/api/events?client=${encodeURIComponent(CLIENT_ID)}&relay=1` : "/api/events");
   const onMessage = (e: MessageEvent<string>): void => {
     const job = parseJob(e.data);
     // Only THIS document's renders. The bus is project-wide and a second chrome
     // may be exporting something else; showing its progress here would be a
-    // progress bar for a file this window is not making.
-    if (job !== null && job.name === store.getState().name) store.setRenderJob(job);
+    // progress bar for a file this window is not making. The job this window
+    // already holds is followed to its end even after it opened another shot:
+    // that job holds the export lock, and dropping its "done" held it for good.
+    if (job === null) return;
+    const now = store.getState();
+    if (job.name === now.name || job.id === now.renderJob?.id) store.setRenderJob(job);
   };
   const onDoc = (e: MessageEvent<string>): void => {
     const payload = parseDocChange(e.data);
-    // The SHOT lane only. The bus carries motion, canvas and scene writes too,
-    // and handing one of those to a shot store would ask it to reload a
-    // document that is not in its store at all.
-    if (payload !== null && payload.lane === "shot") store.adoptExternalChange(payload);
+    if (payload === null) return;
+    // The SHOT lane only. The bus carries other lanes' writes too, and handing
+    // one of those to a shot store would ask it to reload a document that is
+    // not in its store at all.
+    if (payload.lane === "shot") store.adoptExternalChange(payload);
+  };
+  // ── A COMPONENT'S SOURCE CHANGED ON DISK ────────────────────────────────
+  //
+  // The watcher re-extracts the contract and tells Vite, which reloads the
+  // stage. That covers the PICTURE. It never covered the chrome: the drift
+  // badge, the props panel and the open source buffer all stayed on what they
+  // had, so an edit made from outside this window — a second editor, or an
+  // agent through MCP — was invisible here until something happened to refetch.
+  const onContract = (e: MessageEvent<string>): void => {
+    const componentId = parseContractChange(e.data);
+    if (componentId === null) return;
+    store.adoptContractChange(componentId);
+  };
+  // ── A FILE APPEARED OR VANISHED ─────────────────────────────────────────
+  //
+  // The payload names nothing on purpose, so there is nothing to parse and
+  // nothing to get wrong: re-list and take the server's answer. Only while code
+  // buffers are open (Code Studio): a chrome editing a
+  // shot has no reason to fetch a file listing every time a build writes.
+  const onFiles = (): void => {
+    if (buffersOpen(store.getState())) void store.refreshProjectFiles();
+  };
+  const onComments = (e: MessageEvent<string>): void => {
+    store.comments.changed(parseJson(e.data) ?? {});
+  };
+  const onInbox = (): void => {
+    void store.comments.loadInbox();
+  };
+  const onAgent = (e: MessageEvent<string>): void => {
+    const event = parseAgentActivity(e.data);
+    if (event !== null) store.agentActivity.receive(event);
+  };
+  // The open Project's question only: re-read it, which opens the dialog for
+  // a new one and closes it for one answered elsewhere.
+  const onQuestion = (e: MessageEvent<string>): void => {
+    const name = store.getState().name;
+    if (name !== null && parseJson(e.data)?.["project"] === name) void store.agentQuestion.load(name);
+  };
+  // ── FOLLOWING AN AGENT'S WRITES ─────────────────────────────────────────
+  //
+  // `contract-changed` fires only when a contract moves, so a body-only write
+  // left an open buffer on the old text until its save 409'd. Each write now
+  // reaches the buffer holding that file, which is what Code Studio's follow
+  // mode shows.
+  const onSource = (e: MessageEvent<string>): void => {
+    const change = parseJson(e.data);
+    const path = change?.["path"];
+    const hash = change?.["hash"];
+    if (typeof path !== "string" || (hash !== null && typeof hash !== "string")) return;
+    void store.adoptSourceChange(path, hash);
+  };
+  const onHello = (): void => {
+    // A reconnect may have dropped comment events: read both again.
+    refetchComments();
+    const name = store.getState().name;
+    if (name === null) return;
+    // And the question: an ask sent while the feed was down is still open.
+    void store.agentQuestion.load(name);
+    const asked = store.getState().renderJob;
+    void renderState(name)
+      .then((state) => reconcileRender(store, name, state, asked))
+      .catch(() => {
+        // A server without the render lane, or one mid-restart: the next
+        // hello asks again.
+      });
+  };
+  const onRelay = (e: MessageEvent<string>): void => {
+    const ask = parseStageAsk(e.data);
+    if (ask === null) return;
+    const answer = (outcome: { ok: true; result: unknown } | { ok: false; error: string }): void => {
+      void fetch(`/api/relay/${encodeURIComponent(ask.id)}/result`, {
+        method: "POST",
+        headers: { "content-type": "application/json", [CLIENT_ID_HEADER]: CLIENT_ID },
+        body: JSON.stringify(outcome),
+      }).catch(() => {
+        // The dev server times the question out and says so.
+      });
+    };
+    if (ask.tool !== "stage") {
+      answer({ ok: false, error: `this editor answers "stage", not ${JSON.stringify(ask.tool)}: reload it, which picks up the newer build` });
+      return;
+    }
+    void awaitStageHealth(store, ask.input).then(
+      (report) => answer({ ok: true, result: report }),
+      (error: unknown) => answer({ ok: false, error: error instanceof Error ? error.message : String(error) }),
+    );
   };
+  source.addEventListener("hello", onHello);
   source.addEventListener(EVENT, onMessage as EventListener);
   source.addEventListener(DOC_EVENT, onDoc as EventListener);
+  source.addEventListener(CONTRACT_EVENT, onContract as EventListener);
+  source.addEventListener(FILES_EVENT, onFiles);
+  if (host === undefined) source.addEventListener(RELAY_EVENT, onRelay as EventListener);
+  source.addEventListener(COMMENTS_EVENT, onComments as EventListener);
+  source.addEventListener(INBOX_EVENT, onInbox);
+  source.addEventListener(AGENT_EVENT, onAgent as EventListener);
+  source.addEventListener(SOURCE_EVENT, onSource as EventListener);
+  source.addEventListener(QUESTION_EVENT, onQuestion as EventListener);
   return () => {
+    source.removeEventListener(QUESTION_EVENT, onQuestion as EventListener);
+    source.removeEventListener(AGENT_EVENT, onAgent as EventListener);
+    source.removeEventListener(SOURCE_EVENT, onSource as EventListener);
+    unlistenFocus();
+    source.removeEventListener(COMMENTS_EVENT, onComments as EventListener);
+    source.removeEventListener(INBOX_EVENT, onInbox);
+    source.removeEventListener("hello", onHello);
     source.removeEventListener(EVENT, onMessage as EventListener);
     source.removeEventListener(DOC_EVENT, onDoc as EventListener);
+    source.removeEventListener(CONTRACT_EVENT, onContract as EventListener);
+    source.removeEventListener(FILES_EVENT, onFiles);
+    source.removeEventListener(RELAY_EVENT, onRelay as EventListener);
     source.close();
   };
 }
 
+/** The render reason a job the server no longer knows gets. */
+export const RENDER_LOST =
+  "the studio server lost track of this render (it restarted, or its progress stopped reaching " +
+  "this window); check the output folder, or export again";
+
+/**
+ * Adopt what the server says about THIS shot's render after a (re)connect.
+ *
+ * The live job wins, then the newest finished one, so a chrome that reloaded
+ * still shows the last result. A job this window thinks is running that the
+ * server has never heard of ended with the old server, and it is closed as
+ * failed rather than holding the export lock forever.
+ *
+ * `asked` is the job this window held when the read was sent. If that changed
+ * while the read was in flight (an Export click, a bus frame), the answer is
+ * older than what the window knows and is dropped: applying it could close a
+ * render that had just started.
+ */
+export function reconcileRender(
+  store: ShotEditorStore,
+  name: string,
+  state: RenderState,
+  asked: RenderJob | null,
+): void {
+  const now = store.getState();
+  if (now.name !== name || now.renderJob !== asked) return;
+  const newest = state.job ?? state.recent.at(-1) ?? null;
+  if (newest !== null) {
+    store.setRenderJob(newest);
+    return;
+  }
+  // A job of ANOTHER shot (the author switched, renamed or duplicated while
+  // it ran). The route reports only this shot's renders, so its silence says
+  // nothing about that job: it is dropped from this window, never declared
+  // lost while the server may still be rendering it.
+  if (asked !== null && asked.name !== name) {
+    store.setRenderJob(null);
+    return;
+  }
+  if (asked !== null && asked.phase === "running") {
+    store.setRenderJob({ ...asked, phase: "failed", error: RENDER_LOST });
+  }
+}
+
+/** A relayed question the dev server asks this chrome (`relay-request`,
+ *  `{v, id, tool, input}`): only `stage` is asked locally. */
+function parseStageAsk(raw: string): { id: string; tool: string; input: StageHealthRequest } | null {
+  try {
+    const data: unknown = JSON.parse(raw);
+    if (data === null || typeof data !== "object") return null;
+    const p = data as { id?: unknown; tool?: unknown; input?: unknown };
+    if (typeof p.id !== "string" || typeof p.tool !== "string") return null;
+    const i = (typeof p.input === "object" && p.input !== null ? p.input : {}) as Record<string, unknown>;
+    const code = (typeof i["code"] === "object" && i["code"] !== null ? i["code"] : null) as Record<string, unknown> | null;
+    return {
+      id: p.id,
+      tool: p.tool,
+      input: {
+        ...(typeof i["name"] === "string" ? { name: i["name"] } : {}),
+        ...(typeof i["rev"] === "string" ? { rev: i["rev"] } : {}),
+        ...(code === null
+          ? {}
+          : {
+              code: {
+                ...(typeof code["epoch"] === "number" ? { epoch: code["epoch"] } : {}),
+                ...(typeof code["since"] === "number" ? { since: code["since"] } : {}),
+              },
+            }),
+        waitMs: typeof i["waitMs"] === "number" && Number.isFinite(i["waitMs"]) ? Math.max(0, i["waitMs"]) : 0,
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** The one field this chrome acts on. `ContractChangedPayload` also carries the
+ *  hashes, which are what the REFETCH is for. */
+/** A comment frame's fields, or null for a malformed one. */
+function parseJson(raw: string): Record<string, unknown> | null {
+  try {
+    const data: unknown = JSON.parse(raw);
+    return data !== null && typeof data === "object" ? (data as Record<string, unknown>) : null;
+  } catch {
+    return null;
+  }
+}
+
+function parseContractChange(raw: string): string | null {
+  try {
+    const data: unknown = JSON.parse(raw);
+    if (data === null || typeof data !== "object") return null;
+    const p = data as { componentId?: unknown };
+    return typeof p.componentId === "string" && p.componentId.length > 0 ? p.componentId : null;
+  } catch {
+    return null;
+  }
+}
+
 /** The subset of `DocChangedPayload` this chrome acts on. A malformed frame is
  *  dropped for the same reason a malformed job frame is. */
-function parseDocChange(
-  raw: string,
-): { lane: string; name?: string; origin?: string; clientId?: string } | null {
+function parseDocChange(raw: string): {
+  lane: string;
+  name?: string;
+  origin?: string;
+  clientId?: string;
+  deleted?: true;
+  renamedFrom?: string;
+  renamedTo?: string;
+} | null {
   try {
     const data: unknown = JSON.parse(raw);
     if (data === null || typeof data !== "object") return null;
-    const p = data as { lane?: unknown; name?: unknown; origin?: unknown; clientId?: unknown };
+    const p = data as {
+      lane?: unknown;
+      name?: unknown;
+      origin?: unknown;
+      clientId?: unknown;
+      deleted?: unknown;
+      renamedFrom?: unknown;
+      renamedTo?: unknown;
+    };
     if (typeof p.lane !== "string") return null;
     return {
       lane: p.lane,
       ...(typeof p.name === "string" ? { name: p.name } : {}),
       ...(typeof p.origin === "string" ? { origin: p.origin } : {}),
       ...(typeof p.clientId === "string" ? { clientId: p.clientId } : {}),
+      ...(p.deleted === true ? { deleted: true as const } : {}),
+      ...(typeof p.renamedFrom === "string" ? { renamedFrom: p.renamedFrom } : {}),
+      ...(typeof p.renamedTo === "string" ? { renamedTo: p.renamedTo } : {}),
     };
   } catch {
     return null;

package/src/state/runtimeErrors.ts

@@ -0,0 +1,46 @@
+// The chrome realm's errors that no panel owns: a worklet processor that
+// throws (the level meters' ran `process()` into a ReferenceError on every
+// render quantum in the shipped chrome, and said so only in the console).
+// Kept, deduplicated, for the stage health an agent asks for
+// (state/stageHealth.ts), stamped with the saved revision on screen when each
+// was last seen, so a write's check counts only what happened at the
+// revision it wrote. One log per page, like the chrome's one store.
+import { recordStageError, settleStageErrors } from "@dailies-studio/shot/doc";
+import type { StageErrorSource, StageRuntimeError } from "@dailies-studio/shot/doc";
+
+let errors: StageRuntimeError[] = [];
+let revision: () => string | null = () => null;
+const listeners = new Set<() => void>();
+
+/** How the log reads the saved revision on screen (the store registers it). */
+export function setRuntimeErrorRevision(read: () => string | null): void {
+  revision = read;
+}
+
+/** `standing`: the realm that threw is dead until it restarts (see
+ *  `runtimeRealmRestarted`), so the error counts at every revision. */
+export function recordRuntimeError(source: StageErrorSource, message: string, standing = false): void {
+  errors = recordStageError(errors, source, message, revision(), Date.now(), standing);
+  for (const listener of [...listeners]) listener();
+}
+
+/** `source`'s realm runs again (every dead processor was torn down): its
+ *  errors are history. */
+export function runtimeRealmRestarted(source: StageErrorSource): void {
+  errors = settleStageErrors(errors, source);
+  for (const listener of [...listeners]) listener();
+}
+
+export function runtimeErrors(): readonly StageRuntimeError[] {
+  return errors;
+}
+
+export function subscribeRuntimeErrors(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+
+/** Test seam: an empty log. */
+export function clearRuntimeErrors(): void {
+  errors = [];
+}

package/src/state/selection.ts

@@ -0,0 +1,12 @@
+/** Selection membership is read by every visible outline row. Store selection
+ * arrays are immutable, so their identity is the exact invalidation key for a
+ * single shared Set rather than one linear `includes` scan per row. */
+const MEMBERSHIP = new WeakMap<readonly string[], ReadonlySet<string>>();
+
+export function selectionMembership(selection: readonly string[]): ReadonlySet<string> {
+  const found = MEMBERSHIP.get(selection);
+  if (found !== undefined) return found;
+  const next = new Set(selection);
+  MEMBERSHIP.set(selection, next);
+  return next;
+}