@hypit/hypit 0.1.3 → 0.1.5

package/packages/studio/src/server.ts

@@ -15,12 +15,13 @@ import type { ServedFile } from "./compile.js";
 import type { StudioDomain } from "./domain.js";
 import type { StudioCompanionRegistry } from "./studio-registry.js";
 import { loadStudioRun } from "./run.js";
-import { serializeParameterValue, validateParameterValue } from "./parameter-values.js";
+import { parameterAuthorValue, parameterOption, serializeParameterValue, serializeAttributeGroup, validateParameterValue } from "./parameter-values.js";
 import { readStudioSession } from "./session.js";
-import type { Range, StudioFailure, StudioLibraryView, StudioMutation, StudioSnapshot } from "./shared.js";
+import type { Range, StudioFailure, StudioLibraryRequest, StudioLibraryView, StudioMutation, StudioSnapshot } from "./shared.js";
 import { createStudioStoryboard } from "./storyboard.js";
 import type { StudioStoryboard } from "./storyboard.js";
 import { findSurfacePreview } from "./surface-preview.js";
+import { formatTemporalPointEdit, semanticGestureSpan } from "./temporal-edit.js";
 import { replaceSourceFiles } from "./source-transaction.js";
 
 export type StudioPluginOptions = {
@@ -93,8 +94,9 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
   const watchedFiles = new Set<string>();
   const storyboards = new Map<string, Promise<StudioStoryboard>>();
 
-  const readLibrary = async (before?: string): Promise<StudioLibraryView> => {
-    return await options.buildLibrary?.library(before) ?? {
+  const readLibrary = async (request: StudioLibraryRequest): Promise<StudioLibraryView> => {
+    return await options.buildLibrary?.library(request) ?? {
+      section: request.section,
       environment: options.workspaceRoot,
       tasks: [],
       artifacts: [],
@@ -271,7 +273,7 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
       throw new Error("A timeline target must use valid whole frames.");
     }
     if (temporal.kind === "window") {
-      if (mutation.gesture === "move"
+      if (mutation.gesture === "move" && handle.semantic?.kind !== "selection"
         && endFrameExclusive - startFrame !== clip.endFrameExclusive - clip.startFrame) {
         throw new Error("Move must preserve the Window duration.");
       }
@@ -287,6 +289,7 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
 
     const patches: Patch[] = [];
     const semanticTarget = mutation.target.semantic;
+    if (handle.semantic !== undefined && semanticTarget === undefined) throw new Error("A semantic edit requires explicit target anchors.");
     if (semanticTarget !== undefined) {
       if (handle.semantic?.kind !== semanticTarget.kind) {
         throw new Error(`Entity ${mutation.entityId} is not bound to a writable ${semanticTarget.kind}.`);
@@ -298,15 +301,9 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
         || script.narrativeId !== current.semantic.narrativeId) {
         throw new Error("The timeline entity and writable Script do not belong to the selected Narrative.");
       }
-      if (semanticTarget.kind === "selection") {
-        const startIndex = current.semantic.anchors.findIndex((anchor) => anchor.id === semanticTarget.startAnchorId);
-        const endIndex = current.semantic.anchors.findIndex((anchor) => anchor.id === semanticTarget.endAnchorId);
-        if (startIndex < 0 || endIndex < 0 || startIndex >= endIndex
-          || current.semantic.anchors[startIndex]!.frame >= current.semantic.anchors[endIndex]!.frame) {
-          throw new Error("A Selection must span two ordered semantic Anchors with positive time.");
-        }
-      } else if (!current.semantic.anchors.some((anchor) => anchor.id === semanticTarget.anchorId)) {
-        throw new Error(`Moment Anchor ${semanticTarget.anchorId} does not exist in the current semantic Candidate.`);
+      const projected = semanticGestureSpan(current.semantic.anchors, handle, semanticTarget);
+      if (projected === undefined || projected.startFrame !== startFrame || projected.endFrameExclusive !== endFrameExclusive) {
+        throw new Error("The semantic edit does not produce the requested timeline projection.");
       }
       const absolute = resolve(options.workspaceRoot, script.sourcePath);
       const source = await readFile(absolute, "utf8");
@@ -366,20 +363,15 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
       }
       return snapshot?.semantic?.moments.find((candidate) => candidate.id === id)?.frame;
     };
-    const projectedPointValue = (endpoint: StudioTemporalInstantProjection, desired: number): string => {
-      if (endpoint.reference === "absolute") return frame(desired);
-      const base = projectionBaseFrame(endpoint);
-      if (base === undefined) throw new Error(`The ${endpoint.reference} projection base is unavailable.`);
-      const offset = desired - base;
-      return offset === 0 ? endpoint.reference : `${endpoint.reference}${offset > 0 ? "+" : ""}${offset}f`;
-    };
+    const projectedPointValue = (endpoint: StudioTemporalInstantProjection, desired: number): string =>
+      formatTemporalPointEdit(endpoint.reference, desired, projectionBaseFrame(endpoint));
     const writeEndpoint = (
       endpoint: StudioTemporalInstantProjection,
       desired: number,
       role: "start" | "end",
     ): void => {
       if (desired === endpoint.frame) return;
-      if (endpoint.authority.kind === "fixed") throw new Error(`The ${role} endpoint is structurally fixed.`);
+      if (endpoint.authority.kind === "fixed") throw new Error(`The ${role} endpoint has no timeline write target.`);
       if (endpoint.authority.kind === "semantic") {
         if (semanticFrame(endpoint) !== desired) throw new Error(`The ${role} endpoint does not match its semantic Anchor.`);
         return;
@@ -410,26 +402,32 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
     if (mutation.type === "timeline.adjust") return timelinePatches(mutation);
     const clip = currentClip(mutation.entityId);
     const parameter = clip.inspector.find((candidate) => candidate.id === mutation.parameterId);
-    if (parameter === undefined) {
+    if (parameter?.edit === undefined) {
       throw new Error(`Entity ${mutation.entityId} has no writable parameter ${mutation.parameterId}.`);
     }
+    const authorValue = parameterAuthorValue(parameter, mutation.value);
     if (parameter.schema !== undefined) {
-      validateParameterValue(mutation.value, parameter.schema, parameter.label);
+      validateParameterValue(authorValue, parameter.schema, parameter.label);
     } else if (parameter.control === "boolean" && typeof mutation.value !== "boolean") {
       throw new Error(`${parameter.label} expects true or false.`);
     } else if (parameter.control === "number" && (typeof mutation.value !== "number" || !Number.isFinite(mutation.value))) {
       throw new Error(`${parameter.label} expects a number.`);
-    } else if ((parameter.control === "text" || parameter.control === "color" || parameter.control === "select")
+    } else if ((parameter.control === "text" || parameter.control === "color")
       && typeof mutation.value !== "string") {
       throw new Error(`${parameter.label} expects text.`);
     }
-    if (parameter.options !== undefined && (typeof mutation.value !== "string" || !parameter.options.includes(mutation.value))) {
+    if (parameter.options !== undefined && !parameter.options.some(option => parameterOption(option).value === authorValue)) {
       throw new Error(`${parameter.label} does not accept ${mutation.value}.`);
     }
-    const encoded = serializeParameterValue(mutation.value, parameter.language);
-    const replacement = `${parameter.source.prefix ?? ""}${encoded}${parameter.source.suffix ?? ""}`;
-    return replacement === parameter.source.preimage ? [] : [{
-      ...parameter.source,
+    if (parameter.control === "color") validateParameterValue(authorValue, { kind: "string", format: "color" }, parameter.label);
+    if (parameter.edit.attributes) {
+      const replacement = serializeAttributeGroup(parameter, authorValue);
+      return replacement === parameter.edit.source.preimage ? [] : [{ ...parameter.edit.source, replacement }];
+    }
+    const encoded = serializeParameterValue(authorValue, parameter.edit.language);
+    const replacement = `${parameter.edit.source.prefix ?? ""}${encoded}${parameter.edit.source.suffix ?? ""}`;
+    return replacement === parameter.edit.source.preimage ? [] : [{
+      ...parameter.edit.source,
       replacement,
     }];
   };
@@ -525,6 +523,28 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
           })();
           return;
         }
+        if (request.method === "PUT" && url.pathname === "/__studio/artifact-name") {
+          void (async () => {
+            try {
+              const chunks: Buffer[] = [];
+              for await (const chunk of request) chunks.push(Buffer.from(chunk));
+              const body = JSON.parse(Buffer.concat(chunks).toString("utf8")) as {
+                build?: unknown; output?: unknown; displayName?: unknown;
+              };
+              if (typeof body.build !== "string" || typeof body.output !== "string"
+                || (typeof body.displayName !== "string" && body.displayName !== null)) {
+                json(response, 400, { error: "Expected Build, Output and displayName" });
+                return;
+              }
+              if (options.buildLibrary === undefined) throw new Error("Result Repository is unavailable");
+              const displayName = await options.buildLibrary.renameArtifact(body.build, body.output, body.displayName);
+              json(response, 200, { displayName: displayName ?? null });
+            } catch (error) {
+              json(response, 422, { error: error instanceof Error ? error.message : String(error) });
+            }
+          })();
+          return;
+        }
         if (request.method === "POST" && url.pathname === "/__studio/mutation") {
           void (async () => {
             try {
@@ -577,8 +597,21 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
           return;
         }
         if (url.pathname === "/__studio/library") {
+          const section = url.searchParams.get("section");
+          if (section !== "tasks" && section !== "artifacts") {
+            json(response, 400, { error: "Choose tasks or artifacts with the section parameter" });
+            return;
+          }
+          const media = url.searchParams.get("media") ?? undefined;
+          if (media !== undefined && media !== "image" && media !== "video" && media !== "audio") {
+            json(response, 400, { error: "Choose image, video or audio with the media parameter" });
+            return;
+          }
           const before = url.searchParams.get("before") ?? undefined;
-          void readLibrary(before).then(
+          const run = url.searchParams.get("run") ?? undefined;
+          const build = url.searchParams.get("build") ?? undefined;
+          void readLibrary({ section, ...(media === undefined ? {} : { media }), ...(before === undefined ? {} : { before }),
+            ...(run === undefined ? {} : { run }), ...(build === undefined ? {} : { build }) }).then(
             (view) => json(response, 200, view),
             (error) => json(response, 500, { error: error instanceof Error ? error.message : String(error) }),
           );
@@ -662,13 +695,12 @@ export function studioPlugin(options: StudioPluginOptions): Plugin {
           void (async () => {
             const build = url.searchParams.get("build");
             const output = url.searchParams.get("output");
-            const valuePath = url.searchParams.get("path");
-            if (build === null || output === null || valuePath === null || options.buildLibrary === undefined) {
+            if (build === null || output === null || options.buildLibrary === undefined) {
               response.statusCode = 404;
               response.end();
               return;
             }
-            const artifact = await options.buildLibrary.openArtifact(build, output, valuePath);
+            const artifact = await options.buildLibrary.openArtifact(build, output);
             if (artifact === undefined) {
               response.statusCode = 404;
               response.end();

package/packages/studio/src/shared.ts

@@ -9,6 +9,7 @@ import type {
   StudioIcon,
   StudioEditHandle,
   StudioLaneDescription,
+  StudioTrackBand,
   StudioMaterialPreview,
   StudioInspectorField,
   StudioInspectorDomain,
@@ -63,6 +64,7 @@ export type StudioTrackBinding = {
   readonly companion: string;
   /** Studio-local partition key for an attached projection. */
   readonly attachmentId?: string;
+  readonly bands?: readonly Omit<StudioTrackBand, "bindings" | "inspector">[];
   readonly lane: StudioLaneDescription;
   readonly authoredTag?: string;
   readonly references: readonly { readonly name: string; readonly type: string }[];
@@ -95,6 +97,8 @@ export type Clip = {
   readonly presentId?: string;
   /** The authored id this Present is named after, when it names one. */
   readonly authoredId: string;
+  readonly selectionGroup?: string;
+  readonly band?: string;
   /** The Script marker that placed it, when something said put it there. */
   readonly markerId?: string;
   readonly display: StudioEntityDisplay;
@@ -190,12 +194,14 @@ export type StudioTaskView = {
   readonly note?: string;
   readonly highlightedOutputs?: readonly string[];
   readonly createdAt: number;
-  readonly status: "queued" | "running" | "waiting" | "complete" | "failed" | "cancelled" | "active" | "blocked" | "unknown";
+  readonly finishedAt?: number;
+  readonly ongoing: boolean;
+  readonly status: "queued" | "running" | "waiting" | "complete" | "failed" | "cancelled" | "saving-result" | "attention";
+  readonly detail?: string;
+  readonly requests?: { readonly total: number; readonly completed: number };
   readonly source: string;
   readonly run?: string;
   readonly targets: readonly string[];
-  readonly acceptedRecords: number;
-  readonly outstandingCommands: number;
   readonly operations: readonly {
     readonly status: "pending" | "completed" | "failed" | "cancelled";
     readonly phase?: string;
@@ -206,7 +212,10 @@ export type StudioTaskView = {
 };
 
 export type StudioArtifactView = {
-  /** Build-qualified identity derived from the public Output and its value path. */
+  readonly nameEditable?: boolean;
+  /** Author-provided display name; the Output identifier remains unchanged. */
+  readonly displayName?: string;
+  /** File-owner identity; references to the same file share one card. */
   readonly id: string;
   readonly build: string;
   readonly createdAt: number;
@@ -214,18 +223,27 @@ export type StudioArtifactView = {
   readonly highlighted: boolean;
   readonly buildTitle?: string;
   readonly buildNote?: string;
-  readonly valuePath: string;
-  readonly ownerBuild: string;
+  readonly ownerBuild?: string;
   readonly ownerOutput: string;
   readonly filePath: string;
   readonly size: number;
   readonly mediaType: string;
   readonly source: string;
   readonly run?: string;
+  readonly origins: readonly { readonly build: string; readonly output: string; readonly run?: string; readonly source: string }[];
+};
+
+export type StudioLibraryRequest = {
+  readonly media?: "image" | "video" | "audio";
+  readonly section: "tasks" | "artifacts";
+  readonly before?: string;
+  readonly run?: string;
+  readonly build?: string;
 };
 
 /** Read-only view of the Runtime context selected for this Studio environment. */
 export type StudioLibraryView = {
+  readonly section: StudioLibraryRequest["section"];
   readonly environment: string;
   readonly runtime?: string;
   /** Cursor for the next older page of immutable Build Results. */
@@ -267,8 +285,6 @@ export type StudioSnapshot = {
   /** The Tracks, compiled into the document the renderer photographs. */
   readonly preview: { readonly kind: "hyperframes"; readonly srcdoc: string };
   readonly provenance: {
-    /** Where the timeline came from. The frame domain always shares its source. */
-    readonly timing: "measured" | "authored";
     readonly picture: "resolved";
     /** What the badges above are standing for, in one sentence. */
     readonly note: string;

package/packages/studio/src/snapshot.ts

@@ -1,16 +1,15 @@
+import { composeParameterDeclarations } from "./parameters.js";
 /**
  * Turn a built programme into what the panels read.
  *
- * A timeline is the Presents of every Track, and a Present carries a span, an
- * identity and a stacking order - the whole contract, for every package. So the
- * timeline is assembled without knowing what made any of it, and a package that
- * grows a new Track shows up without this file changing.
+ * The Timeline owns the work range. Companions project selectable entities onto
+ * that range without extending it or requiring component-specific editor code.
  */
 import { relative } from "node:path";
 
 import type { MarkupSurfaceRegistryLike } from "@hypit/markup";
 import { compositionTypes } from "@hypit/composition";
-import { narrativeTypes } from "@hypit/narrative";
+import { programSpaceFrameCount } from "@hypit/program-space";
 import { sameModule, sameType } from "@hypit/protocol";
 
 import type {
@@ -138,43 +137,10 @@ function scriptMap(
   };
 }
 
-type NarrativeValue = {
-  readonly id?: string;
-  readonly segments?: readonly {
-    readonly id: string;
-    readonly startAnchorId: string;
-    readonly endAnchorId: string;
-  }[];
-  readonly tokens?: readonly {
-    readonly id: string;
-    readonly segmentId: string;
-    readonly startAnchorId: string;
-    readonly endAnchorId: string;
-    readonly text: string;
-  }[];
-  readonly selections?: readonly {
-    readonly id: string;
-    readonly startAnchorId: string;
-    readonly endAnchorId: string;
-  }[];
-  readonly moments?: readonly {
-    readonly id: string;
-    readonly anchorId: string;
-  }[];
-  readonly semanticIndex?: {
-    readonly anchors?: readonly {
-      readonly id: string;
-      readonly kind: "program-start" | "segment-start" | "segment-end" | "token-start" | "token-end" | "program-end";
-      readonly segmentId?: string;
-      readonly tokenId?: string;
-    }[];
-  };
-};
-
 /**
  * Project the compiled Narrative into the frame domain that the preview is
  * already using. No frontend timing is invented here: if an anchor is absent
- * from the built SemanticTrack, the corresponding item is simply not drawable yet.
+ * from the built Timeline, the corresponding item is simply not drawable yet.
  */
 function semanticTimeline(
   registry: StudioCompanionRegistry,
@@ -182,77 +148,13 @@ function semanticTimeline(
   script: ScriptMap | undefined,
 ): SemanticTimeline | undefined {
   if (built.narrativeId === undefined) return undefined;
-  const records = built.source.compiled.program.records.filter((item) =>
-    sameType(item.type, narrativeTypes.narrative)
-    && item.value.kind === "inline"
-    && (item.value.value as NarrativeValue).id === built.narrativeId);
-  if (records.length > 1) {
-    throw new Error(`Studio Narrative id ${built.narrativeId} resolves to more than one authored value.`);
-  }
-  const record = records[0];
-  const narrative = record?.value.kind === "inline"
-    ? record.value.value as NarrativeValue
-    : undefined;
-  if (narrative === undefined) throw new Error("Studio Narrative is not an inline authored value.");
-
-  const segmentRanges = new Map((script?.segments ?? []).map((item) => [item.id, item.range]));
-  const tokenRanges = new Map((script?.tokens ?? []).map((item) => [item.id, item.range]));
-  const frame = (id: string): number | undefined => built.anchors.get(id);
-
-  const segments = (narrative.segments ?? []).flatMap((segment) => {
-    const startFrame = frame(segment.startAnchorId);
-    const endFrame = frame(segment.endAnchorId);
-    if (startFrame === undefined || endFrame === undefined) return [];
-    return [{
-      id: segment.id,
-      startFrame,
-      endFrameExclusive: Math.max(startFrame + 1, endFrame),
-      ...(segmentRanges.has(segment.id) ? { range: segmentRanges.get(segment.id)! } : {}),
-    }];
+  if (script === undefined) throw new Error("Timeline's Script has no Studio source mapping.");
+  const projected = registry.projectScript({ source: script, anchors: built.anchors,
+    values: built.source.compiled.program.records.flatMap(record => record.value.kind === "inline"
+      ? [{ id: record.id, type: record.type, value: record.value.value }] : []),
   });
-  const tokens = (narrative.tokens ?? []).flatMap((token) => {
-    const startFrame = frame(token.startAnchorId);
-    const endFrame = frame(token.endAnchorId);
-    if (startFrame === undefined || endFrame === undefined) return [];
-    return [{
-      id: token.id,
-      segmentId: token.segmentId,
-      text: token.text,
-      startFrame,
-      endFrameExclusive: Math.max(startFrame + 1, endFrame),
-      ...(tokenRanges.has(token.id) ? { range: tokenRanges.get(token.id)! } : {}),
-    }];
-  });
-  const anchors = (narrative.semanticIndex?.anchors ?? []).flatMap((anchor) => {
-    const at = frame(anchor.id);
-    if (at === undefined) return [];
-    return [{
-      id: anchor.id,
-      kind: anchor.kind,
-      frame: at,
-      ...(anchor.segmentId === undefined ? {} : { segmentId: anchor.segmentId }),
-      ...(anchor.tokenId === undefined ? {} : { tokenId: anchor.tokenId }),
-    }];
-  });
-  const selections = (narrative.selections ?? []).flatMap((selection) => {
-    const startFrame = frame(selection.startAnchorId);
-    const endFrameExclusive = frame(selection.endAnchorId);
-    if (startFrame === undefined || endFrameExclusive === undefined || endFrameExclusive <= startFrame) return [];
-    return [{
-      id: selection.id,
-      startAnchorId: selection.startAnchorId,
-      endAnchorId: selection.endAnchorId,
-      startFrame,
-      endFrameExclusive,
-    }];
-  });
-  const moments = (narrative.moments ?? []).flatMap((moment) => {
-    const at = frame(moment.anchorId);
-    return at === undefined ? [] : [{ id: moment.id, anchorId: moment.anchorId, frame: at }];
-  });
-  if (segments.length === 0) throw new Error("Studio SemanticTrack resolves no authored Segment anchors.");
   const provenance: CandidateProvenance = {
-    output: built.timingOutput?.name ?? "SemanticTrack",
+    output: built.timingOutput?.name ?? "Timeline",
     ...(built.timingOutput?.ref === undefined ? {} : { outputRef: built.timingOutput.ref }),
     ...(built.timingCandidateId === undefined ? {} : { candidateId: built.timingCandidateId }),
     origin: built.timingCandidateOrigin,
@@ -262,17 +164,10 @@ function semanticTimeline(
   return {
     spaceId: built.space.id,
     narrativeId: built.narrativeId,
-    // Semantic is a Studio lane with its own registered meaning. Do not copy
-    // the authored Speech Track id into this label: it is the timebase, not a
-    // second Speech output.
+    // The generic ruler presentation is independent of the authored Timeline id.
     presentation: registry.semanticTimelinePresentation(),
-    // Narrative order is the semantic ruler. Frame ties are common and must
-    // not erase the discrete 2M+2N+2 anchor ordering used by writeback.
-    anchors,
-    segments: segments.sort((left, right) => left.startFrame - right.startFrame || left.id.localeCompare(right.id)),
-    tokens: tokens.sort((left, right) => left.startFrame - right.startFrame || left.id.localeCompare(right.id)),
-    selections: selections.sort((left, right) => left.startFrame - right.startFrame || left.id.localeCompare(right.id)),
-    moments: moments.sort((left, right) => left.frame - right.frame || left.id.localeCompare(right.id)),
+    // Preserve the Companion's ordered anchors, including coincident boundaries.
+    ...projected,
     provenance,
   };
 }
@@ -338,13 +233,18 @@ export function snapshot(registry: StudioCompanionRegistry, built: Preview, inpu
       semantic,
       generic,
     }).map((draft) => {
+      const declarations = composeParameterDeclarations({
+        placement, draft, placements: built.source.observations.placements, registry,
+        bindings: registry.bindingDeclarations(item, placement, draft.lane, draft.band),
+        inspector: registry.inspectorDeclarations(item, placement, draft.lane, draft.band),
+      });
       const bindings = sourceBindingsForDraft({
         root: input.workspaceRoot,
         files: input.sourceFiles,
         placement,
         draft,
         declarations: [
-          ...registry.bindingDeclarations(item, placement, draft.lane),
+          ...declarations.bindings,
           ...temporalBindingDeclarations(draft.temporal),
         ],
         placements: built.source.observations.placements,
@@ -352,7 +252,7 @@ export function snapshot(registry: StudioCompanionRegistry, built: Preview, inpu
       const inspector = inspectorFieldsForBindings(
         draft,
         bindings,
-        registry.inspectorDeclarations(item, placement, draft.lane),
+        declarations.inspector,
       );
       const editHandles = resolveTimelineEditHandles(
         bindings,
@@ -404,17 +304,7 @@ export function snapshot(registry: StudioCompanionRegistry, built: Preview, inpu
   // root that produced them in this list.
   const rows = tracks.map((track, row) => ({ ...track, row }));
 
-  const declared = (built.space as { durationSec?: number; frameRate?: { numerator: number; denominator: number } })
-    ?.durationSec;
-  const frameCount = Math.max(
-    1,
-    declared === undefined
-      ? 0
-      : Math.round(declared * input.frameRate.numerator / input.frameRate.denominator),
-    ...rows.flatMap((track) => track.clips.map((clip) => clip.endFrameExclusive)),
-    ...(semantic?.segments ?? []).map((segment) => segment.endFrameExclusive),
-    ...(semantic?.tokens ?? []).map((token) => token.endFrameExclusive),
-  );
+  const frameCount = programSpaceFrameCount(built.space);
   return {
     revision: input.revision,
     source: {
@@ -442,7 +332,6 @@ export function snapshot(registry: StudioCompanionRegistry, built: Preview, inpu
     ...(semantic === undefined ? {} : { semantic }),
     preview: input.preview,
     provenance: {
-      timing: built.timing,
       picture: "resolved",
       note: note(built),
     },

package/packages/studio/src/studio-preflight.ts

@@ -1,7 +1,7 @@
 import type { Candidate } from "@hypit/protocol";
 import { sameType } from "@hypit/protocol";
 import type { StudioFilmCompanion } from "@hypit/studio-adapter";
-import { semanticTrackTypes } from "@hypit/semantic-track";
+import { timelineTypes } from "@hypit/timeline";
 
 import type { CompiledSource } from "./compile.js";
 import type { Placement } from "./observe.js";
@@ -137,7 +137,7 @@ export function inspectStudioRun(
   });
   const timeOutput = times[0];
   if (times.length !== 1) issues.push("Film requires one traceable time source.");
-  const semanticOutput = timeOutput !== undefined && sameType(timeOutput.typeRef, semanticTrackTypes.track) ? timeOutput : undefined;
+  const semanticOutput = timeOutput !== undefined && sameType(timeOutput.typeRef, timelineTypes.track) ? timeOutput : undefined;
   let companionValueRefs: readonly string[] = [];
   try {
     companionValueRefs = unique(filmTrackRefs.flatMap((ref) =>
@@ -149,7 +149,7 @@ export function inspectStudioRun(
 
   const projectionRefs = unique([
     ...filmTrackRefs,
-    ...(semanticOutput !== undefined && sameType(semanticOutput.typeRef, semanticTrackTypes.track) ? [semanticOutput.ref] : []),
+    ...(semanticOutput !== undefined && sameType(semanticOutput.typeRef, timelineTypes.track) ? [semanticOutput.ref] : []),
     ...companionValueRefs,
   ]);
   const projections: StudioViewRequirement[] = [];