@dailies-studio/shot-editor 0.1.0 → 0.2.0

package/src/channels.ts

@@ -1,40 +1,25 @@
-// The eight channels the block system writes, each with its label and its
-// resolved-value formatter.
+// The five transform paths a layer's channel row reads live, each with its
+// label and its resolved-value formatter.
 //
-// This list IS resolve.ts's combinator table, in the order the composition is
-// written there — and it is the chrome's ONE copy. The inspector's Resolved
-// section and the dock's channel rows both read it, so an eighth channel added
-// in resolve.ts without a row here is a value the author has no way to see in
-// either place, which is how a delta model becomes folklore.
+// This table IS `LayerState`, in the order resolve.ts writes it, and it is the
+// chrome's ONE copy. The dock's channel rows read it: a tracked transform path
+// lists first, in this order, with the value the stage draws beside its label.
+// Every other tracked path is a row without a readout.
 import { formatValue } from "@dailies-studio/ui";
-import type { LayerDelta, LayerState } from "@dailies-studio/shot/doc";
-
-/** The channel names, exactly as `LayerDelta` declares them. */
-export type Channel = keyof Required<LayerDelta>;
+import type { LayerState } from "@dailies-studio/shot/doc";
 
 export interface ChannelSpec {
-  key: Channel;
   label: string;
-  /** The channel's value as the author sees it — from `resolveLayerAt`'s
-   *  output, never a second fold. */
+  /** The value as the author sees it, from `resolveLayerAt`'s output, never a
+   *  second fold. */
   read(state: LayerState): string;
 }
 
-export const CHANNELS: readonly ChannelSpec[] = [
-  { key: "opacity", label: "Opacity", read: (s) => formatValue(s.opacity, 0.01) },
-  // Position, size, tilt and roll read the layer's own value WITH the delta
-  // folded in, because that is the number on screen.
-  { key: "offset", label: "Position", read: (s) => s.position.map((v) => formatValue(v, 0.1)).join(", ") },
-  { key: "scale", label: "Size", read: (s) => `${formatValue(s.size[0], 0.1)} × ${formatValue(s.size[1], 0.1)}` },
-  { key: "tilt", label: "Tilt", read: (s) => `${formatValue(s.tilt[0], 0.1)}°, ${formatValue(s.tilt[1], 0.1)}°` },
-  { key: "roll", label: "Roll", read: (s) => `${formatValue(s.rollDeg, 0.1)}°` },
-  // Blur, reveal and stagger have no base at all: they exist only as block
-  // output, so the resolved value IS the fold.
-  { key: "blurPx", label: "Blur", read: (s) => `${formatValue(s.blurPx, 0.1)} px` },
-  { key: "reveal", label: "Reveal", read: (s) => `${formatValue(s.reveal * 100, 1)}%` },
-  { key: "textPhase", label: "Stagger", read: (s) => `${formatValue(s.textPhase * 100, 1)}%` },
-];
-
-export const CHANNEL_BY_KEY: ReadonlyMap<Channel, ChannelSpec> = new Map(
-  CHANNELS.map((c) => [c.key, c]),
-);
+/** Keyed by track path. A `Map`, so the iteration order is the row order. */
+export const TRANSFORM_CHANNELS: ReadonlyMap<string, ChannelSpec> = new Map<string, ChannelSpec>([
+  ["transform.opacity", { label: "Opacity", read: (s) => formatValue(s.opacity, 0.01) }],
+  ["transform.position", { label: "Position", read: (s) => s.position.map((v) => formatValue(v, 0.1)).join(", ") }],
+  ["transform.size", { label: "Size", read: (s) => `${formatValue(s.size[0], 0.1)} × ${formatValue(s.size[1], 0.1)}` }],
+  ["transform.tilt", { label: "Tilt", read: (s) => `${formatValue(s.tilt[0], 0.1)}°, ${formatValue(s.tilt[1], 0.1)}°` }],
+  ["transform.rollDeg", { label: "Roll", read: (s) => `${formatValue(s.rollDeg, 0.1)}°` }],
+]);

package/src/fonts/googleFonts.ts

@@ -0,0 +1,4 @@
+// Moved to @dailies-studio/shot (`googleFonts.ts`), which the MCP `set_font`
+// op plans from too. Re-exported here for the chrome importers that predate
+// the move.
+export * from "@dailies-studio/shot/googleFonts";

package/src/hostApi.ts

@@ -0,0 +1,174 @@
+// The hosted editor's code host, as the chrome and the stage see it.
+//
+// Hosted, no Vite serves the project's modules. The boot script
+// (packages/browser-host/src/boot.ts, served as /host/boot.js and stamped into
+// /scene ahead of the chrome) compiles user code in a worker, publishes it to
+// Cache Storage, and a Service Worker answers the stage's module requests from
+// there. It installs `window.__dailiesHost` synchronously, before the chrome's
+// own module runs. Locally there is no boot script, `__dailiesHost` is absent,
+// and nothing here changes what the chrome does.
+//
+// Pure data and types, no value imports: the boot script bundles the two
+// constants, and it must stay free of React and three.
+import type { Doc3D, GlyphFaceRequest, MediaProbe, StageHealthReport, StageHealthRequest } from "@dailies-studio/shot/doc";
+import type { StillCaptureOptions } from "./state/stillStage.js";
+
+/** The BroadcastChannel a new module epoch travels on (stage/moduleEpoch.ts
+ *  listens; the boot script posts). Not the bridge: the epoch is a
+ *  same-origin fact about the served modules, not chrome-stage protocol. */
+export const MODULE_EPOCH_CHANNEL = "dailies-module-epoch";
+
+/** The epoch message shape's version. A message of any other version is
+ *  ignored. */
+export const MODULE_EPOCH_MESSAGE_VERSION = 1;
+
+/** What the boot script posts on {@link MODULE_EPOCH_CHANNEL}: the stage
+ *  imports its instance modules under `?v=<epoch>`. Epochs only grow. */
+export interface ModuleEpochMessage {
+  readonly epoch: number;
+  readonly version: typeof MODULE_EPOCH_MESSAGE_VERSION;
+}
+
+/** One TypeScript diagnostic, as `POST /api/diagnostics` answers it (the
+ *  extractor's FileDiagnostic; api.ts CodeDiagnostic is the same wire shape). */
+export interface HostFileDiagnostic {
+  readonly category: "error" | "warning" | "suggestion" | "message";
+  readonly code: number;
+  readonly message: string;
+  readonly start: number;
+  readonly length: number;
+  readonly line: number;
+  readonly character: number;
+  readonly endLine: number;
+  readonly endCharacter: number;
+}
+
+/** Whether one contract key's default can be persisted into source. */
+export type HostDefaultsKeyMeta = { readonly editable: true } | { readonly editable: false; readonly reason: string };
+
+/** The edit a contract default makes, which the chrome writes through
+ *  `PUT /api/files/:rel` with `baseHash`: what `POST
+ *  /api/components/:id/defaults` does on the dev server, split at the write. */
+export interface HostDefaultsEdit {
+  /** Project-relative path of the file the edit lands in. */
+  readonly file: string;
+  /** The sha256 of the text the edit was made over. */
+  readonly baseHash: string;
+  /** The file's text with the edit made. */
+  readonly content: string;
+  /** How many keys it splices; 0 writes nothing. */
+  readonly edits: number;
+  readonly results: Readonly<Record<string, { readonly status: "written" } | { readonly status: "refused"; readonly reason: string }>>;
+  /** The contract the edit was checked against. */
+  readonly contractHash: string;
+}
+
+/** A host call the dev server's route would refuse carries its status and
+ *  body, so the chrome surfaces it as that route's error. */
+export interface HostRefusalError extends Error {
+  readonly status?: number;
+  readonly body?: Readonly<Record<string, unknown>>;
+}
+
+export interface DailiesHost {
+  /** Settles once the stage may load: the Service Worker is active and the
+   *  project's first compile is published. Rejects with the reason the host
+   *  could not start; the chrome then loads the stage anyway, and each
+   *  instance layer reports its own failure. The host keeps trying, and its
+   *  first publish after that posts an epoch the stage re-imports under. */
+  readonly ready: Promise<void>;
+  /** The last published epoch, or null before the first publish. */
+  compileVersion(): ModuleEpochMessage | null;
+  /** After a sync (which compiles what changed): path -> why that module's
+   *  current source does not build. A failing module keeps serving its last
+   *  good build, so the stage alone never shows it. Optional: an older host
+   *  has no such report. */
+  buildErrors?(): Promise<Readonly<Record<string, string>>>;
+  /** Calls `listener` after each new epoch; returns the unsubscribe. */
+  subscribe(listener: () => void): () => void;
+  /** The chrome calls this on every load of the stage iframe, before it
+   *  connects the bridge. The host posts the current epoch again (the channel
+   *  does not replay, and a fresh stage document has missed every earlier
+   *  post) and checks that the Service Worker controls the stage document.
+   *  False means the host is reloading the stage once to get it controlled:
+   *  skip this load, the next one follows. */
+  stageLoaded(stage: Window): boolean;
+  /** `POST /api/diagnostics`, answered by the compile worker's extractor over
+   *  the project it compiled, with `content` in place of the file's text when
+   *  given (an unsaved buffer). Rejects with a HostRefusalError. */
+  diagnostics(path: string, content?: string): Promise<{ path: string; diagnostics: HostFileDiagnostic[] }>;
+  /** The edit `POST /api/components/:id/defaults` makes, computed after a
+   *  sync so it is checked against the current contract and bytes. Rejects
+   *  with a HostRefusalError where the route refuses (unknown id, builtin,
+   *  bad body, contract drift). */
+  applyDefaults(
+    componentId: string,
+    body: { readonly contractHash: string; readonly values: Readonly<Record<string, unknown>> },
+  ): Promise<HostDefaultsEdit>;
+  /** After a sync (which extracts what changed): the component's contract
+   *  hash and which keys take a default, or null when the registry no longer
+   *  holds it. */
+  componentDefaults(
+    componentId: string,
+  ): Promise<{ readonly contractHash: string; readonly editableKeys: Readonly<Record<string, HostDefaultsKeyMeta>> } | null>;
+  /** Media the page itself canonicalises, measures and derives (plan B5). */
+  readonly media: DailiesHostMedia;
+  /** The client id the code host's change feed names (plan C5). The chrome
+   *  takes it as its own (state/clientId.ts), so the tab an agent session is
+   *  asked from is the tab whose code host answers the session's relayed
+   *  browser tools. */
+  readonly clientId: string;
+  /** The chrome hands the host how it answers "what does your stage show,
+   *  and is it broken" (state/stageHealth.ts), which the host's relayed
+   *  `stage` call asks for an agent (browser-host relay.ts). */
+  provideStageHealth(answer: (request: StageHealthRequest) => Promise<StageHealthReport>): void;
+  /** One still of `doc` at master `frame`, drawn on the code host's own
+   *  offscreen stage (state/stillStage.ts), the one agent stills are drawn
+   *  on. It never calls `stageLoaded` and never touches the author's stage. */
+  captureStill(doc: Doc3D, frame: number, width: number, height: number, options?: StillCaptureOptions): Promise<Blob>;
+}
+
+/**
+ * The hosted media host (browser-host media/host.ts).
+ *
+ * Locally the CLI's upload route transcodes audio with ffmpeg, measures video
+ * and derives every sidecar on disk. Hosted, the Worker stores bytes as they
+ * arrive and refuses audio that is not already the canonical WAV, so the page
+ * does that work in a media worker before and after the upload, and sends the
+ * sidecars to the Worker's derived lane.
+ */
+export interface DailiesHostMedia {
+  /** The file the hosted store accepts for this pick: audio decoded to the
+   *  canonical 48 kHz stereo 16-bit WAV, named `<stem>.wav` (the CLI's own
+   *  renaming); any other file unchanged. Rejects with the refusal, by name,
+   *  for audio this browser cannot decode, that passes the asset ceiling, or
+   *  that has more than two channels. */
+  prepareUpload(file: File): Promise<File>;
+  /** Call once the store accepted `file` as `stored`. A video's measurement
+   *  (null for any other kind, or a container it cannot measure); the video's
+   *  or the audio's sidecars are derived and sent in the background. */
+  uploaded(stored: string, file: File): Promise<MediaProbe | null>;
+  /** The open Project's stored asset paths, on open and after a save that
+   *  registered new ones: every sidecar the derived lane lacks is derived and
+   *  sent, in the background, once per page. */
+  backfill(paths: readonly string[]): void;
+  /** The open Project's glyph faces (`glyphFaceRequests`), on open and after
+   *  every save, as the CLI bakes them after a save: each the derived lane
+   *  lacks is baked and sent, in the background, once per page. */
+  faces(requests: readonly Pick<GlyphFaceRequest, "assetPath" | "weight">[]): void;
+  /** A stored recording's own sound as a canonical WAV file, `<stem>.audio.wav`
+   *  as the CLI names it, to upload as an ordinary asset: hosted, it counts
+   *  toward the Project's media quota (the plan's "Hosted vs local" row). */
+  extractSoundtrack(stored: string): Promise<File>;
+}
+
+declare global {
+  interface Window {
+    __dailiesHost?: DailiesHost;
+  }
+}
+
+/** The host, when this chrome runs hosted. */
+export function dailiesHost(): DailiesHost | undefined {
+  return typeof window === "undefined" ? undefined : window.__dailiesHost;
+}