@dailies-studio/shot-editor 0.1.0

package/dist/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Dailies shot</title>
+    <script type="module" crossorigin src="/shot/assets/index-BBE6Ta9L.js"></script>
+    <link rel="stylesheet" crossorigin href="/shot/assets/index-B7notge7.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@dailies-studio/shot-editor",
+  "version": "0.1.0",
+  "description": "The shot editor chrome: a prebuilt React app served static at /shot by the merged studio server, so user tooling can never break it. The 3D stage lives in src/stage and is served ONLY through the project's Vite (pinned three stack, project assets) via /shot-stage.html — never bundled into dist.",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    "./stage": {
+      "types": "./src/stage/main.tsx",
+      "default": "./src/stage/main.tsx"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "@dailies-studio/contract": "0.1.0",
+    "@dailies-studio/engine": "0.1.0",
+    "@dailies-studio/shot": "0.1.0",
+    "@dailies-studio/runtime": "0.1.0"
+  },
+  "devDependencies": {
+    "@react-three/fiber": "^9.6.1",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@types/three": "^0.185.1",
+    "@vitejs/plugin-react": "^4.5.0",
+    "jsdom": "^26.1.0",
+    "three": "^0.185.1",
+    "vite": "^6.3.5",
+    "@dailies-studio/agent-client": "0.1.0",
+    "@dailies-studio/transitions": "0.1.0",
+    "@dailies-studio/timeline": "0.1.0",
+    "@dailies-studio/ui": "0.1.0"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/api.ts

@@ -0,0 +1,289 @@
+// The chrome's HTTP surface: /api/shots, plus the render verb.
+//
+// Every write carries the client id header, so the server's change event comes
+// back labelled and this chrome can tell its own echo from someone else's write
+// (see state/clientId.ts). Every write also carries `baseRev`, so a lost race
+// is a 409 the author sees rather than a silent clobber.
+import type { Doc3D, ExportFormat, ExportQualityId, RenderStats } from "@dailies-studio/shot/doc";
+import type { Contract } from "@dailies-studio/contract";
+import { createAgentClient } from "@dailies-studio/agent-client";
+import type { AgentClient, AgentTransport } from "@dailies-studio/agent-client";
+import { CLIENT_ID, CLIENT_ID_HEADER } from "./state/clientId.js";
+
+export interface ShotListing {
+  name: string;
+  mtimeMs: number;
+}
+
+export interface LoadedShot {
+  name: string;
+  doc: Doc3D;
+  rev: string;
+}
+
+export interface SaveResult {
+  saved: true;
+  rev: string;
+  generated: string | null;
+  warning?: string;
+}
+
+/** A refused write, carrying enough for the chrome to say WHY. `conflict` is
+ *  the 409 case specifically, because that one has a recovery ("reload and
+ *  re-apply") the others do not. */
+export class ApiError extends Error {
+  constructor(
+    readonly status: number,
+    message: string,
+    readonly reason?: string,
+  ) {
+    super(message);
+    this.name = "ApiError";
+  }
+  get conflict(): boolean {
+    return this.status === 409;
+  }
+}
+
+async function request<T>(path: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(path, {
+    ...init,
+    headers: {
+      ...(init?.body !== undefined ? { "content-type": "application/json" } : {}),
+      [CLIENT_ID_HEADER]: CLIENT_ID,
+      ...init?.headers,
+    },
+  });
+  const text = await res.text();
+  let body: unknown = null;
+  if (text.length > 0) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      // A non-JSON body from a route that owes JSON is itself the error.
+      throw new ApiError(res.status, text.slice(0, 400));
+    }
+  }
+  if (!res.ok) {
+    const b = body as { error?: unknown; reason?: unknown } | null;
+    throw new ApiError(
+      res.status,
+      typeof b?.error === "string" ? b.error : `${init?.method ?? "GET"} ${path} failed (${res.status})`,
+      typeof b?.reason === "string" ? b.reason : undefined,
+    );
+  }
+  return body as T;
+}
+
+export function listShots(): Promise<{ shots: ShotListing[] }> {
+  return request("/api/shots");
+}
+
+export function loadShot(name: string): Promise<LoadedShot> {
+  return request(`/api/shots/${encodeURIComponent(name)}`);
+}
+
+/** `baseRev` is REQUIRED at this seam even though the route allows it to be
+ *  absent: an editor that omits it is an editor that can silently overwrite
+ *  another surface's work, and `null` already means "I am claiming a create". */
+export function saveShot(name: string, doc: Doc3D, baseRev: string | null): Promise<SaveResult> {
+  return request(`/api/shots/${encodeURIComponent(name)}`, {
+    method: "PUT",
+    body: JSON.stringify({ doc, baseRev }),
+  });
+}
+
+export function deleteShot(name: string): Promise<{ deleted: true }> {
+  return request(`/api/shots/${encodeURIComponent(name)}`, { method: "DELETE" });
+}
+
+export function renameShot(name: string, to: string): Promise<{ renamed: true; generated: string | null }> {
+  return request(`/api/shots/${encodeURIComponent(name)}/rename`, {
+    method: "POST",
+    body: JSON.stringify({ to }),
+  });
+}
+
+export function duplicateShot(name: string, to: string): Promise<{ duplicated: true }> {
+  return request(`/api/shots/${encodeURIComponent(name)}/duplicate`, {
+    method: "POST",
+    body: JSON.stringify({ to }),
+  });
+}
+
+// ---- the component registry (instance layers) --------------------------------
+
+/**
+ * One row of `GET /api/components` — the live registry the ADD menu lists and
+ * the instance inspector judges an instance against.
+ *
+ * Declared here rather than imported from another chrome: only these fields are
+ * load-bearing for this lane, and the shot chrome depends on no other chrome.
+ *
+ * `host` is the instance gate (only "three" components can be instanced — a
+ * "dom" one under the three reconciler is a hard crash, and the SERVER's
+ * `classifyHost` is what decided the value). `contractHash` is the drift
+ * baseline recorded on the layer. `contractAvailability` is the server's own
+ * verdict on whether generated code can STATICALLY IMPORT the contract or
+ * whether the document must carry a snapshot — consumed verbatim, never
+ * re-derived, because re-deriving it chrome-side got builtins wrong in the 2D
+ * lane and emitted imports that cannot resolve.
+ */
+export interface ComponentRow {
+  id: string;
+  name: string;
+  rel: string;
+  exportName: string;
+  contractHash: string;
+  contractSource: "declared" | "inferred";
+  contractAvailability?: "sibling" | "colocated" | "inferred";
+  host: "dom" | "three" | "dom-embedded-gl";
+  builtin?: boolean;
+  /**
+   * Present only on catalog EFFECTS, which is what makes it the filter for the
+   * material picker: a TSL generator is exactly a builtin that carries this.
+   *
+   * `thumb` is a pre-rendered PNG path under the server's own thumbs route —
+   * the reason the picker can show real renders without a single line of three
+   * in the chrome. `softwareRaster` badges a generator measured NOT to finish
+   * under `--gl swangle`, so an author learns before they pick rather than
+   * after a render has stalled.
+   */
+  effect?: {
+    category: string;
+    tags: string[];
+    thumb?: string;
+    softwareRaster?: "unfinished";
+  };
+}
+
+export interface ComponentDetail extends ComponentRow {
+  contract: Contract;
+}
+
+/** A bare ARRAY, not an envelope — the shape that route has always answered. */
+export function listComponents(): Promise<ComponentRow[]> {
+  return request("/api/components");
+}
+
+export function componentDetail(id: string): Promise<ComponentDetail> {
+  return request(`/api/components/${encodeURIComponent(id)}`);
+}
+
+// ---- the asset store ---------------------------------------------------------
+
+/** What `POST /api/assets` answers with. `path` is the BARE content-addressed
+ *  filename; identical bytes always land on it, so a re-import is idempotent. */
+export interface UploadedAsset {
+  path: string;
+  hash: string;
+  /** Absent for an extension the store does not recognise. */
+  kind?: string;
+}
+
+/**
+ * Upload one file into the shared asset store (the F2-C route every chrome
+ * uses; the shot lane is served by the same server, so it is the same route).
+ *
+ * The filename rides a URI-ENCODED header because HTTP headers are latin-1 and
+ * user filenames are not, and the BODY is the raw bytes — this is the one write
+ * in this module that is not JSON, so it overrides `request`'s content-type
+ * rather than letting it claim the bytes are JSON.
+ */
+export function uploadAsset(file: File): Promise<UploadedAsset> {
+  return request("/api/assets", {
+    method: "POST",
+    body: file,
+    headers: {
+      "content-type": "application/octet-stream",
+      "x-studio-filename": encodeURIComponent(file.name),
+    },
+  });
+}
+
+/**
+ * The stored bytes of an asset.
+ *
+ * Raw, and deliberately not through `request` (which owes JSON). The audio lane
+ * reads the STORED WAV rather than the upload: the server transcodes every
+ * audio import to canonical 48 kHz PCM, so the original container's duration
+ * and the stored one's can differ by a partial frame, and the clip has to be
+ * timed against what will actually be mixed.
+ */
+export async function fetchAssetBytes(path: string): Promise<ArrayBuffer> {
+  const url = `/studio/assets/${encodeURIComponent(path)}`;
+  const res = await fetch(url);
+  if (!res.ok) throw new ApiError(res.status, `GET ${url} -> ${res.status}`);
+  return res.arrayBuffer();
+}
+
+// ---- the export button -------------------------------------------------------
+
+export interface RenderJob {
+  id: string;
+  name: string;
+  phase: "running" | "done" | "failed" | "cancelled";
+  done: number;
+  total: number;
+  out?: string;
+  error?: string;
+  elapsedMs: number;
+}
+
+export interface RenderRequest {
+  format: ExportFormat;
+  quality: ExportQualityId;
+  /** Absent = the whole timeline. */
+  sceneId?: string;
+  /** `false` renders a SILENT file even though the document has clips. Absent
+   *  = the server's default, which is to mux whatever `doc.audio` carries. */
+  audio?: boolean;
+}
+
+export interface RenderState {
+  job: RenderJob | null;
+  recent: RenderJob[];
+  stats: RenderStats;
+}
+
+/**
+ * Start a render. Resolves as soon as the job EXISTS, not when it finishes —
+ * progress arrives on the SSE bus.
+ *
+ * A 409 means one is already running, and its `job` rides the error rather than
+ * being thrown away, so the dialog can show that instead of an error the author
+ * cannot act on.
+ */
+export async function startRender(name: string, spec: RenderRequest): Promise<RenderJob> {
+  const body = await request<{ job: RenderJob }>(`/api/shots/${encodeURIComponent(name)}/render`, {
+    method: "POST",
+    body: JSON.stringify(spec),
+  });
+  return body.job;
+}
+
+export function renderState(name: string): Promise<RenderState> {
+  return request(`/api/shots/${encodeURIComponent(name)}/render`);
+}
+
+export function cancelRender(name: string): Promise<{ cancelled: boolean }> {
+  return request(`/api/shots/${encodeURIComponent(name)}/render`, { method: "DELETE" });
+}
+
+// ---- the agent lane ----------------------------------------------------------
+
+/**
+ * The agent transport, shared with every other chrome.
+ *
+ * The shot chrome is ALWAYS served by the server it calls (there is no
+ * standalone shot lane and no hosted pairing), so this is plain same-origin
+ * fetch over this module's own error discipline. `createAgentClient` owns the
+ * routes, the SSE drain and the event vocabulary, so the four chromes cannot
+ * interpret one stream four different ways.
+ */
+const agentTransport: AgentTransport = {
+  json: (path, init) => request(path, init),
+  raw: (path) => fetch(path),
+};
+
+export const agent: AgentClient = createAgentClient(agentTransport);