@hypit/hypit 0.1.4 → 0.1.6

package/packages/comment-sticker/src/surface.ts

@@ -1,4 +1,4 @@
-import { createTemporalSpace, resolveTemporalContext } from "@hypit/temporal-markup";
+import { resolveTemporalContext } from "@hypit/temporal-markup";
 import { artifactTypes } from "@hypit/artifact";
 import { mediaTypes } from "@hypit/media";
 import type { FontStackRef } from "@hypit/media";
@@ -88,11 +88,10 @@ export const decodeCommentStickerStyleSurface: StructuredSurfaceHandler = ({ ele
 };
 
 export const decodeCommentStickerTrackSurface: StructuredSurfaceHandler = ({ element, resolveReference }) => {
-  allowed(element, ["id", "canvas", "semantic"], ["id", "canvas", "semantic"]);
+  allowed(element, ["id", "canvas", "timeline"], ["id", "canvas", "timeline"]);
   const id = text(element, "id");
   const canvas = reference(element.attributes.canvas, `${element.name}.canvas`, spatialTypes.canvas, resolveReference);
   const context = resolveTemporalContext({ element, resolveReference });
-  const time = createTemporalSpace({ id: id, element, ...context });
   const headerId = `${id}.__header`;
   const records: SurfaceRecordDraft[] = [{
     id: headerId,
@@ -100,9 +99,9 @@ export const decodeCommentStickerTrackSurface: StructuredSurfaceHandler = ({ ele
     value: { kind: "inline", value: sealCommentStickerHeader({ id }) },
     range: element.range,
   }];
-  const temporalComponents: SurfaceComponentDraft[] = [...time.components];
-  const temporalFragments: ReturnType<typeof createTemporalWindowProjection>["fragments"][number][] = [...time.fragments];
-  const inputs: Record<string, typeof canvas.ref> = { canvas: canvas.ref, header: { kind: "record", id: headerId }, space: time.space.ref };
+  const temporalComponents: SurfaceComponentDraft[] = [];
+  const temporalFragments: ReturnType<typeof createTemporalWindowProjection>["fragments"][number][] = [];
+  const inputs: Record<string, typeof canvas.ref> = { canvas: canvas.ref, header: { kind: "record", id: headerId }, timeline: context.timeline.ref };
   const items: Parameters<typeof createCommentStickerFragment>[0][number][] = [];
   for (const child of element.children) {
     if (child.kind === "text") {
@@ -113,7 +112,7 @@ export const decodeCommentStickerTrackSurface: StructuredSurfaceHandler = ({ ele
     if (child.children.some((node) => node.kind === "element")) throw new Error(`${child.name} accepts plain comment text only.`);
     allowed(child, ["id", "comment", "frame", "style", "avatar", "author", "header", "meta", ...TIMING], ["id", "frame", "style"]);
     const itemId = text(child, "id");
-    const temporal = createTemporalWindowProjection({ id: itemId, element: child, ...context, space: time.space, resolveReference });
+    const temporal = createTemporalWindowProjection({ id: itemId, element: child, ...context, resolveReference });
     records.push(...temporal.records); temporalComponents.push(...temporal.components); temporalFragments.push(...temporal.fragments);
     const suffix = String(items.length + 1).padStart(4, "0");
     const frame = reference(child.attributes.frame, `${child.name}.frame`, spatialTypes.frame, resolveReference);

package/packages/composition/README.md

@@ -51,3 +51,24 @@ A Composition carries its id, Canvas with clear color, and peer Tracks. The Trac
 ProgramSpace identity; assembly and rendering receive the corresponding time domain separately.
 `@hypit/film` is one author-facing way to assemble it;
 `@hypit/render-hyperframes` consumes it to produce a video.
+
+### Visibility without a new playback origin
+
+A VisualPresent may supply `visibility`, an ordered list of non-overlapping subranges in program
+frames, all inside its `span`. Omission means the full span; an empty list means never visible.
+`span` continues to define local animation and media-sampling time. This permits rule overrides or
+other partial visibility without cutting a program into restarted copies. HyperFrames applies the
+visibility independently when seeking; custom HTML and typed media keep their original clocks.
+
+## Audio presentation on the program clock
+
+AudioClip optionally carries `gainEnvelope: { sample, gain }[]` and
+`audibility: { startSample, endSampleExclusive }[]`. Both use absolute 48 kHz program samples.
+Envelope points have strictly increasing sample positions and interpolate linearly, holding the
+outer endpoint gains. They multiply the existing Clip gain and fades. Audible subranges are ordered,
+disjoint and inside the original target; omission means the whole target, an empty list means silence.
+`audioEnvelopeGainAt` evaluates the envelope; `assertAudioPresentation` checks these values.
+
+Original target and source sampling remain intact when presentation is partially hidden. Range
+rendering applies envelopes and masks before cropping. These fields express generic sound behavior;
+source selection and Style/Use precedence belong to author components such as Sound.

package/packages/composition/src/audio-presentation.ts

@@ -0,0 +1,44 @@
+/** Gain and audibility are measured on the complete 48 kHz program clock. */
+export type AudioSampleSpan = { readonly startSample: number; readonly endSampleExclusive: number };
+export type AudioGainPoint = { readonly sample: number; readonly gain: number };
+export type AudioPresentation = {
+  /** Linear interpolation; hold the first/last gain outside the supplied points. */
+  readonly gainEnvelope?: readonly AudioGainPoint[];
+  /** Half-open audible regions; omission means the complete target, [] means silence. */
+  readonly audibility?: readonly AudioSampleSpan[];
+};
+
+export function assertAudioPresentation(value: AudioPresentation, target: AudioSampleSpan,
+  totalSamples = Number.MAX_SAFE_INTEGER): void {
+  if (value.gainEnvelope !== undefined) {
+    if (!Array.isArray(value.gainEnvelope) || value.gainEnvelope.length === 0) throw new Error("Audio gain envelope needs points.");
+    let previous = -1;
+    for (const point of value.gainEnvelope) {
+      if (!Number.isSafeInteger(point.sample) || point.sample <= previous || point.sample > totalSamples
+        || !Number.isFinite(point.gain) || point.gain < 0 || point.gain > 64) throw new Error("Audio gain envelope point is invalid.");
+      previous = point.sample;
+    }
+  }
+  if (value.audibility !== undefined) {
+    if (!Array.isArray(value.audibility)) throw new Error("Audio audibility must be sample intervals.");
+    let previous = target.startSample;
+    for (const span of value.audibility) {
+      if (!Number.isSafeInteger(span.startSample) || span.startSample < previous
+        || !Number.isSafeInteger(span.endSampleExclusive) || span.endSampleExclusive <= span.startSample
+        || span.endSampleExclusive > target.endSampleExclusive) throw new Error("Audio audibility is outside its target or overlaps.");
+      previous = span.endSampleExclusive;
+    }
+  }
+}
+
+export function audioEnvelopeGainAt(points: readonly AudioGainPoint[] | undefined, sample: number): number {
+  if (points === undefined) return 1;
+  const first = points[0];
+  if (first === undefined) throw new Error("Audio gain envelope needs points.");
+  if (sample <= first.sample) return first.gain;
+  for (let index = 1; index < points.length; index++) {
+    const left = points[index - 1]!, right = points[index]!;
+    if (sample <= right.sample) return left.gain + (right.gain - left.gain) * (sample - left.sample) / (right.sample - left.sample);
+  }
+  return points.at(-1)!.gain;
+}

package/packages/composition/src/index.ts

@@ -16,3 +16,6 @@ export {
 export { assertAudioTrackIdentity, assertCompositionIdentity, assertVisualTrackIdentity, sealAudioTrack, sealComposition, sealVisualTrack } from "./track.js";
 export { animatableLocalStyles } from "./track.js";
 export type * from "./track.js";
+
+export * from "./audio-presentation.js";
+export { audioSampleSpanSchema, audioGainEnvelopeSchema } from "./schema.js";

package/packages/composition/src/schema.ts

@@ -170,13 +170,16 @@ export const visualSurfaceSchema: ValueSchema = object({ ...base, kind: { schema
 export const visualProgramSchema: ValueSchema = object({ ...base, kind: { schema: { kind: "literal", value: "program" } }, program: { schema: object({ format: { schema: string }, payload: { schema: object({}, true) }, artifacts: { schema: { kind: "array", items: mediaBlobRef } } }) } });
 export const visualElementSchema: ValueSchema = { kind: "oneOf", variants: [visualBoxSchema, visualMaskSchema, visualTextSchema, textFlowElement, pathTextElement, visualImageSchema, visualVideoSchema, visualSurfaceSchema, visualProgramSchema] };
 const span = object({ startFrame: { schema: integer }, endFrameExclusive: { schema: integer } });
-const present = object({ id: { schema: string }, span: { schema: span }, stacking: { schema: object({ order: { schema: signedInteger }, tieBreak: { schema: string } }) }, elements: { schema: { kind: "array", minItems: 1, items: visualElementSchema } } });
+const present = object({ id: { schema: string }, subjectId: { schema: string, optional: true }, span: { schema: span }, visibility: { schema: { kind: "array", items: span }, optional: true }, stacking: { schema: object({ order: { schema: signedInteger }, tieBreak: { schema: string } }) }, elements: { schema: { kind: "array", minItems: 1, items: visualElementSchema } } });
 export const visualTrackSchema: ValueSchema = object({ kind: { schema: { kind: "literal", value: "visual" } }, programSpaceId: { schema: string }, visualIr: { schema: { kind: "literal", value: VISUAL_IR_V1 } }, id: { schema: string }, presents: { schema: { kind: "array", items: present } } });
-const audioSampleSpan = object({ startSample: { schema: integer }, endSampleExclusive: { schema: { kind: "number", integer: true, minimum: 1 } } });
+export const audioSampleSpanSchema = object({ startSample: { schema: integer }, endSampleExclusive: { schema: { kind: "number", integer: true, minimum: 1 } } });
+export const audioGainEnvelopeSchema: ValueSchema = { kind: "array", minItems: 1, items: object({
+  sample: { schema: integer }, gain: { schema: { kind: "number", minimum: 0, maximum: 64 } },
+}) };
 const audioClip = object({
   id: { schema: string },
   artifact: { schema: audioBlobRef },
-  target: { schema: audioSampleSpan },
+  target: { schema: audioSampleSpanSchema },
   source: { schema: object({
     sampleFrames: { schema: { kind: "number", integer: true, minimum: 1 } },
     startSample: { schema: integer },
@@ -189,6 +192,8 @@ const audioClip = object({
   gain: { schema: { kind: "number", minimum: 0, maximum: 64 } },
   fadeInSamples: { schema: integer },
   fadeOutSamples: { schema: integer },
+  gainEnvelope: { schema: audioGainEnvelopeSchema, optional: true },
+  audibility: { schema: { kind: "array", items: audioSampleSpanSchema }, optional: true },
 });
 export const audioTrackSchema: ValueSchema = object({ kind: { schema: { kind: "literal", value: "audio" } }, programSpaceId: { schema: string }, id: { schema: string }, clips: { schema: { kind: "array", items: audioClip } } });
 export const compositionSchema: ValueSchema = object({ id: { schema: string }, canvas: { schema: object({ width: { schema: integer }, height: { schema: integer }, clearColor: { schema: string } }) }, tracks: { schema: { kind: "array", items: { kind: "oneOf", variants: [visualTrackSchema, audioTrackSchema] } } } });

package/packages/composition/src/track.ts

@@ -1,3 +1,5 @@
+import { assertAudioPresentation } from "./audio-presentation.js";
+import type { AudioPresentation } from "./audio-presentation.js";
 import { canonicalStringify, isResourceId } from "@hypit/protocol";
 import type { BlobRef, CanonicalValue } from "@hypit/protocol";
 
@@ -361,6 +363,8 @@ export type VisualPresent = {
   /** Optional domain entity implemented by this renderer Present. */
   readonly subjectId?: string;
   readonly span: FrameSpan;
+  /** Optional visible subranges in program frames; span remains the animation and sampling origin. */
+  readonly visibility?: readonly FrameSpan[];
   /** Absolute paint position for this Present, not for its authoring Track. */
   readonly stacking: {
     readonly order: number;
@@ -380,7 +384,7 @@ export type VisualTrack = {
   readonly presents: readonly VisualPresent[];
 };
 
-export type AudioClip = {
+export type AudioClip = AudioPresentation & {
   readonly id: string;
   /** Optional domain entity implemented by this renderer Clip. */
   readonly subjectId?: string;
@@ -935,6 +939,12 @@ function assertPresent(present: VisualPresent, programSpace: ProgramSpace | unde
   assertNonEmpty(present.id, `${trackId} Present id`);
   if (present.subjectId !== undefined) assertNonEmpty(present.subjectId, `${trackId}.${present.id} subjectId`);
   assertFrameSpan(present.span, totalFrames, `${trackId}.${present.id}.span`);
+  let previousEnd = present.span.startFrame;
+  for (const span of present.visibility ?? []) {
+    assertFrameSpan(span, present.span.endFrameExclusive, `${trackId}.${present.id}.visibility`);
+    if (span.startFrame < previousEnd) throw new Error(`${trackId}.${present.id} visibility must be ordered within its span.`);
+    previousEnd = span.endFrameExclusive;
+  }
   assertNonEmpty(present.stacking.tieBreak, `${trackId}.${present.id} stacking tieBreak`);
   if (!Number.isSafeInteger(present.stacking.order)) {
     throw new Error(`${trackId}.${present.id} has invalid stacking order.`);
@@ -1236,6 +1246,7 @@ function visualTrackContent(value: Omit<VisualTrack, "kind">): VisualTrack {
         id: present.id,
         ...(present.subjectId === undefined ? {} : { subjectId: present.subjectId }),
         span: { ...present.span },
+        ...(present.visibility === undefined ? {} : { visibility: present.visibility.map(span => ({ ...span })) }),
         stacking: { ...present.stacking },
         elements: [...present.elements].map(normalizeElement).sort((a, b) => a.order - b.order || a.id.localeCompare(b.id)),
       }))
@@ -1263,6 +1274,8 @@ function audioTrackContent(value: Omit<AudioTrack, "kind">): AudioTrack {
         gain: clip.gain,
         fadeInSamples: clip.fadeInSamples,
         fadeOutSamples: clip.fadeOutSamples,
+        ...(clip.gainEnvelope === undefined ? {} : { gainEnvelope: clip.gainEnvelope.map(point => ({ ...point })) }),
+        ...(clip.audibility === undefined ? {} : { audibility: clip.audibility.map(span => ({ ...span })) }),
       }))
       .sort((a, b) => a.target.startSample - b.target.startSample || a.id.localeCompare(b.id)),
   };
@@ -1337,6 +1350,7 @@ export function assertAudioTrackIdentity(track: AudioTrack, programSpace?: Progr
     if (!Number.isFinite(clip.gain) || clip.gain < 0 || clip.gain > 64) {
       throw new Error(`${track.id}.${clip.id} gain is invalid.`);
     }
+    assertAudioPresentation(clip, clip.target, totalSamples);
     const targetLength = clip.target.endSampleExclusive - clip.target.startSample;
     if (!Number.isSafeInteger(clip.fadeInSamples) || clip.fadeInSamples < 0 || clip.fadeInSamples > targetLength
       || !Number.isSafeInteger(clip.fadeOutSamples) || clip.fadeOutSamples < 0

package/packages/credential-store-env/README.md

@@ -3,7 +3,7 @@
 Read-only `CredentialStore` backed by explicitly named environment variables.
 
 ```ts
-credentialRef("env", "KIE_API_KEY")
+credentialRef("env", "IMAGE_API_KEY")
 ```
 
 It resolves only the requested key when an Endpoint needs it. It never enumerates or serializes the

package/packages/deck-track/README.md

@@ -1,7 +1,7 @@
 # `@hypit/deck-track`
 
-The Track Surface accepts `semantic={speech.semantic}` or `space={animation}`. Semantic context
-resolves Script Selections and Moments; authored space supports clock-based animation. Shared `at`
+The Track Surface accepts `timeline={program.timeline}`. The same Timeline supports authored
+positions and, where prepared Takes supply evidence, Script Selections and Moments. Shared `at`
 inputs accept a Moment or a time such as `2s`; `at` with `for` produces a Window where required.
 
 The official, deliberately narrow depth-stack Deck author package.
@@ -19,7 +19,7 @@ Media layer lowerer, but Deck is not a Media mode and exports only an ordinary p
 
 <deck:DepthStack
   id="proof-stack"
-  semantic={speech.semantic}
+  timeline={speech.timeline}
   canvas={vertical}
   frame={layout.proof-stack}
   until={story.selection.proof}

package/packages/deck-track/package.json

@@ -20,7 +20,7 @@
     "@hypit/narrative": "workspace:*",
     "@hypit/program-space": "workspace:*",
     "@hypit/protocol": "workspace:*",
-    "@hypit/semantic-track": "workspace:*",
+    "@hypit/timeline": "workspace:*",
     "@hypit/spatial": "workspace:*",
     "@hypit/svs": "workspace:*",
     "@hypit/temporal": "workspace:*",

package/packages/deck-track/src/component.ts

@@ -1,7 +1,7 @@
+import type { Timeline } from "@hypit/timeline";
 import type { ComponentPackage, ProducerHandlerContext } from "@hypit/component-kit";
 import { canonicalize } from "@hypit/protocol";
 import type { StoredValue } from "@hypit/protocol";
-import type { ProgramSpace } from "@hypit/program-space";
 import type { CanvasSpace, SpatialFrame } from "@hypit/spatial";
 import type { TemporalInstant } from "@hypit/temporal";
 import type { MediaLayerSet } from "@hypit/media-track";
@@ -32,7 +32,7 @@ function finalizeInputs(inputs: ProducerHandlerContext["inputs"]) {
     header: inline<DepthStackHeader>(inputs.header?.value, "DepthStackHeader"),
     frame: inline<SpatialFrame>(inputs.frame?.value, "SpatialFrame"),
     spec: inline<DepthStackSpec>(inputs.spec?.value, "DepthStackSpec"),
-    space: inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+    timeline: inline<Timeline>(inputs.timeline?.value, "Timeline"),
   };
 }
 
@@ -53,7 +53,7 @@ export const depthStackComponent = {
       producer: depthStackProducers.appendCard,
       handler: ({ inputs }) => ({ outputs: { set: output(appendDepthStackCard(
         inline<DepthStackCardSet>(inputs.set?.value, "DepthStackCardSet"),
-        inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+        inline<Timeline>(inputs.timeline?.value, "Timeline"),
         inline<MediaLayerSet>(inputs.material?.value, "MediaLayerSet"),
         inline<DepthStackCardLabel>(inputs.label?.value, "DepthStackCardLabel"),
         inline<DepthStackCardSpec>(inputs.spec?.value, "DepthStackCardSpec"),
@@ -66,7 +66,7 @@ export const depthStackComponent = {
         const value = finalizeInputs(inputs);
         return { outputs: { program: output(finalizeDepthStack(
           value.set, value.header, value.frame, value.spec,
-          inline<TemporalInstant>(inputs.terminal?.value, "TemporalInstant"), value.space,
+          inline<TemporalInstant>(inputs.terminal?.value, "TemporalInstant"), value.timeline,
         )) }, needs: {} };
       },
     },
@@ -74,7 +74,7 @@ export const depthStackComponent = {
       producer: depthStackProducers.render,
       handler: ({ inputs }) => ({ outputs: { track: output(renderDepthStack(
         inline<CanvasSpace>(inputs.canvas?.value, "CanvasSpace"),
-        inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+        inline<Timeline>(inputs.timeline?.value, "Timeline"),
         inline<DepthStackProgram>(inputs.program?.value, "DepthStackProgram"),
       )) }, needs: {} }),
     },

package/packages/deck-track/src/fragment.ts

@@ -1,4 +1,5 @@
-import { programSpaceTypes } from "@hypit/program-space";
+import { timelineTypes } from "@hypit/timeline";
+
 import { artifactTypes } from "@hypit/artifact";
 import { compositionTypes } from "@hypit/composition";
 import { sealGraphFragment } from "@hypit/elaborator";
@@ -42,7 +43,7 @@ export function createDepthStackFragment(
     { name: "canvas", type: spatialTypes.canvas },
     { name: "frame", type: spatialTypes.frame },
     { name: "header", type: depthStackTypes.header },
-    { name: "space", type: programSpaceTypes.programSpace },
+    { name: "timeline", type: timelineTypes.track },
     { name: "spec", type: depthStackTypes.spec },
   ];
   const operations: FragmentOperation[] = [
@@ -107,7 +108,7 @@ export function createDepthStackFragment(
       producer: depthStackProducers.appendCard,
       inputs: {
         set: cardSet,
-        space: input("space"),
+        timeline: input("timeline"),
         material: operation(sampleId),
         label: input(card.labelName),
         spec: input(card.cardSpecName),
@@ -126,7 +127,7 @@ export function createDepthStackFragment(
       header: input("header"),
       frame: input("frame"),
       spec: input("spec"),
-      space: input("space"),
+      timeline: input("timeline"),
       terminal: input(terminalName),
     },
     result: { kind: "output", name: "program" },
@@ -134,7 +135,7 @@ export function createDepthStackFragment(
   operations.push({
     id: "track",
     producer: depthStackProducers.render,
-    inputs: { canvas: input("canvas"), space: input("space"), program: operation("program") },
+    inputs: { canvas: input("canvas"), timeline: input("timeline"), program: operation("program") },
     result: { kind: "output", name: "track" },
   });
   return sealGraphFragment({

package/packages/deck-track/src/lower.ts

@@ -1,3 +1,4 @@
+import type { Timeline } from "@hypit/timeline";
 import {
   assertVisualTrackIdentity,
   sealVisualTrack,
@@ -20,7 +21,6 @@ import type {
   MediaSampleLayerProgram,
   MediaVisualTrim,
 } from "@hypit/media-track";
-import type { ProgramSpace } from "@hypit/program-space";
 import { assertCanvasSpace } from "@hypit/spatial";
 import type { CanvasSpace, SpatialFrame } from "@hypit/spatial";
 
@@ -170,17 +170,17 @@ function samplingFor(input: {
   readonly relation: number;
   readonly stageStart: number;
   readonly stageDuration: number;
-  readonly space: ProgramSpace;
+  readonly timeline: Timeline;
 }): VisualTimedSampling | undefined {
   const timing = sourceTiming(input.layer);
   if (timing === undefined) return undefined;
-  assert(timing.frameRate.numerator === input.space.frameRate.numerator
-    && timing.frameRate.denominator === input.space.frameRate.denominator,
-  `DepthStack Card ${input.card.id} timed material must be normalized to ProgramSpace.`);
+  assert(timing.frameRate.numerator === input.timeline.frameRate.numerator
+    && timing.frameRate.denominator === input.timeline.frameRate.denominator,
+  `DepthStack Card ${input.card.id} timed material must be normalized to Timeline.`);
   const trim = trimFor(input.layer, timing.frameCount);
   if (input.relation === 0) {
     return resolveVisualSampling({
-      space: input.space,
+      timeline: input.timeline,
       sourceFrameRate: timing.frameRate,
       sourceFrameCount: timing.frameCount,
       targetFrameCount: input.stageDuration,
@@ -282,10 +282,10 @@ function labelElement(card: DepthStackCard, parent: string, order: number): Visu
 
 export function renderDepthStack(
   canvas: CanvasSpace,
-  space: ProgramSpace,
+  timeline: Timeline,
   program: DepthStackProgram,
 ): VisualTrack {
-  assertDepthStackProgramIdentity(program, space);
+  assertDepthStackProgramIdentity(program, timeline);
   assertCanvasSpace(canvas);
   const presents: VisualTrack["presents"][number][] = [];
   for (let stageIndex = 0; stageIndex < program.cards.length; stageIndex += 1) {
@@ -322,7 +322,7 @@ export function renderDepthStack(
       const samplingAnimationOverrides: Record<string, VisualAnimation | null> = {};
       for (const layer of card.material.layers) {
         if (layer.kind !== "sample") continue;
-        const sampling = samplingFor({ program, card, layer, relation, stageStart, stageDuration, space });
+        const sampling = samplingFor({ program, card, layer, relation, stageStart, stageDuration, timeline });
         if (sampling !== undefined) samplingOverrides[layer.id] = sampling;
         if (relation !== 0 && layer.samplingMotion !== undefined) samplingAnimationOverrides[layer.id] = null;
       }
@@ -337,7 +337,7 @@ export function renderDepthStack(
         stacking: { order: 0, tieBreak: card.id },
         sounds: [],
       };
-      const material = [...lowerMediaItemElements(mediaItem, space, {
+      const material = [...lowerMediaItemElements(mediaItem, timeline, {
         placementParent: group.poseParent,
         lifecycleAnimationOverride: null,
         samplingOverrides,
@@ -360,11 +360,11 @@ export function renderDepthStack(
     }
   }
   const track = sealVisualTrack({
-    programSpaceId: space.id,
+    programSpaceId: timeline.id,
     visualIr: "hypit.visual-ir@1",
     id: program.id,
     presents,
   });
-  assertVisualTrackIdentity(track, space);
+  assertVisualTrackIdentity(track, timeline);
   return track;
 }

package/packages/deck-track/src/manifest.ts

@@ -1,3 +1,4 @@
+import { timelineTypes } from "@hypit/timeline";
 import { temporalContextAttributeVocabulary } from "@hypit/temporal-markup";
 import { readFile } from "node:fs/promises";
 
@@ -19,9 +20,9 @@ import {
   mediaTrackTypes,
 } from "@hypit/media-track";
 import { narrativeDependency, narrativeTypes } from "@hypit/narrative";
-import { programSpaceDependency, programSpaceTypes } from "@hypit/program-space";
+
 import type { ModuleManifest, ProducerRef, TypeRef, ValueSchema } from "@hypit/protocol";
-import { semanticTrackDependency } from "@hypit/semantic-track";
+import { timelineDependency } from "@hypit/timeline";
 import { spatialDependency, spatialFrameSchema, spatialTypes } from "@hypit/spatial";
 import { svsRecipeType } from "@hypit/svs";
 import { temporalDependency, temporalTypes } from "@hypit/temporal";
@@ -118,7 +119,7 @@ export const depthStackProgramSchema: ValueSchema = object({
 const finalizeInputs = [
   { name: "set", type: depthStackTypes.cardSet }, { name: "header", type: depthStackTypes.header },
   { name: "frame", type: spatialTypes.frame }, { name: "spec", type: depthStackTypes.spec },
-  { name: "space", type: programSpaceTypes.programSpace },
+  { name: "timeline", type: timelineTypes.track },
 ] as const;
 
 export const depthStackMarkupSurfaces = [
@@ -386,7 +387,7 @@ export const depthStackMarkupSurfaces = [
         ],
         example: `<deck:DepthStack
   id="proof-stack"
-  semantic={speech.semantic}
+  timeline={speech.timeline}
   canvas={vertical}
   frame={layout.proof-stack}
   until={story.selection.proof}
@@ -408,7 +409,7 @@ export const depthStackMarkupSurfaces = [
 
 export const depthStackManifest: ModuleManifest = {
   format: "hypit.module@1", name: depthStackModuleRef.name, version: depthStackModuleRef.version,
-  dependencies: [narrativeDependency, programSpaceDependency, semanticTrackDependency, spatialDependency, temporalDependency, mediaDependency, mediaTrackDependency, compositionDependency, textDependency],
+  dependencies: [narrativeDependency, timelineDependency, spatialDependency, temporalDependency, mediaDependency, mediaTrackDependency, compositionDependency, textDependency],
   types: [
     { name: depthStackTypes.header.name },
     { name: depthStackTypes.spec.name },
@@ -422,7 +423,7 @@ export const depthStackManifest: ModuleManifest = {
     { name: depthStackProducers.bindLabelText.name, inputs: [{ name: "style", type: depthStackTypes.cardLabelStyle }, { name: "content", type: textTypes.text }], outputs: [{ name: "label", type: depthStackTypes.cardLabel }], needs: [] },
     { name: depthStackProducers.createCards.name, inputs: [], outputs: [{ name: "set", type: depthStackTypes.cardSet }], needs: [] },
     { name: depthStackProducers.appendCard.name, inputs: [
-      { name: "set", type: depthStackTypes.cardSet }, { name: "space", type: programSpaceTypes.programSpace }, { name: "material", type: mediaTrackTypes.layerSet },
+      { name: "set", type: depthStackTypes.cardSet }, { name: "timeline", type: timelineTypes.track }, { name: "material", type: mediaTrackTypes.layerSet },
       { name: "label", type: depthStackTypes.cardLabel }, { name: "spec", type: depthStackTypes.cardSpec },
       { name: "activation", type: temporalTypes.instant },
     ], outputs: [{ name: "set", type: depthStackTypes.cardSet }], needs: [] },
@@ -430,7 +431,7 @@ export const depthStackManifest: ModuleManifest = {
       inputs: [...finalizeInputs, { name: "terminal", type: temporalTypes.instant }],
       outputs: [{ name: "program", type: depthStackTypes.program }], needs: [] },
     { name: depthStackProducers.render.name, inputs: [
-      { name: "canvas", type: spatialTypes.canvas }, { name: "space", type: programSpaceTypes.programSpace },
+      { name: "canvas", type: spatialTypes.canvas }, { name: "timeline", type: timelineTypes.track },
       { name: "program", type: depthStackTypes.program },
     ], outputs: [{ name: "track", type: compositionTypes.visualTrack }], needs: [] },
   ],

package/packages/deck-track/src/program.ts

@@ -1,3 +1,4 @@
+import type { Timeline } from "@hypit/timeline";
 import {
   assertFontArtifactRef,
 } from "@hypit/media";
@@ -6,11 +7,7 @@ import {
   assertMediaLayerSet,
   assertMediaLifecycleMotion,
 } from "@hypit/media-track";
-import {
-  assertProgramSpaceIdentity,
-  programSpaceFrameCount,
-} from "@hypit/program-space";
-import type { ProgramSpace } from "@hypit/program-space";
+import { assertProgramSpaceIdentity, programSpaceFrameCount } from "@hypit/program-space";
 import { canonicalize } from "@hypit/protocol";
 import { verifyText } from "@hypit/text";
 import type { Text } from "@hypit/text";
@@ -229,13 +226,13 @@ function appendDepthStackCardAtFrame(
 
 export function appendDepthStackCard(
   set: DepthStackCardSet,
-  space: ProgramSpace,
+  timeline: Timeline,
   material: DepthStackCardSet["cards"][number]["material"],
   label: DepthStackCardLabel,
   spec: DepthStackCardSpec,
   activation: TemporalInstant,
 ): DepthStackCardSet {
-  assertTemporalInstantFor(activation, { subjectId: spec.id, space });
+  assertTemporalInstantFor(activation, { subjectId: spec.id, space: timeline });
   return appendDepthStackCardAtFrame(set, material, label, spec, activation.frame);
 }
 
@@ -245,13 +242,13 @@ function finalizeDepthStackAtFrame(
   frame: SpatialFrame,
   spec: DepthStackSpec,
   terminalFrame: number,
-  space: ProgramSpace,
+  timeline: Timeline,
 ): DepthStackProgram {
   assertDepthStackCardSet(set);
   assertDepthStackHeader(header);
   assertSpatialFrame(frame);
   assertDepthStackSpec(spec);
-  assertProgramSpaceIdentity(space);
+  assertProgramSpaceIdentity(timeline);
   assert(set.cards.length > 0, "DepthStack requires at least one Card.");
   const first = set.cards[0]!;
   const program: DepthStackProgram = {
@@ -263,7 +260,7 @@ function finalizeDepthStackAtFrame(
     spec: structuredClone(spec),
     cards: structuredClone(set.cards),
   };
-  assertDepthStackProgramIdentity(program, space);
+  assertDepthStackProgramIdentity(program, timeline);
   return canonicalize(program) as unknown as DepthStackProgram;
 }
 
@@ -273,10 +270,10 @@ export function finalizeDepthStack(
   frame: SpatialFrame,
   spec: DepthStackSpec,
   terminal: TemporalInstant,
-  space: ProgramSpace,
+  timeline: Timeline,
 ): DepthStackProgram {
-  assertTemporalInstantFor(terminal, { subjectId: header.id, space });
-  return finalizeDepthStackAtFrame(set, header, frame, spec, terminal.frame, space);
+  assertTemporalInstantFor(terminal, { subjectId: header.id, space: timeline });
+  return finalizeDepthStackAtFrame(set, header, frame, spec, terminal.frame, timeline);
 }
 
 export function assertDepthStackProgram(program: DepthStackProgram): void {
@@ -307,10 +304,10 @@ export function assertDepthStackProgram(program: DepthStackProgram): void {
   }
 }
 
-export function assertDepthStackProgramIdentity(program: DepthStackProgram, space: ProgramSpace): void {
-  assertProgramSpaceIdentity(space);
+export function assertDepthStackProgramIdentity(program: DepthStackProgram, timeline: Timeline): void {
+  assertProgramSpaceIdentity(timeline);
   assertDepthStackProgram(program);
-  assert(program.terminalFrame <= programSpaceFrameCount(space), "DepthStack terminal is outside ProgramSpace.");
+  assert(program.terminalFrame <= programSpaceFrameCount(timeline), "DepthStack terminal is outside Timeline.");
 }
 
 function modulo(value: number, size: number): number {

package/packages/deck-track/src/surface.ts

@@ -1,4 +1,4 @@
-import { createTemporalSpace, resolveTemporalContext } from "@hypit/temporal-markup";
+import { resolveTemporalContext } from "@hypit/temporal-markup";
 import { artifactTypes } from "@hypit/artifact";
 import { mediaTypes } from "@hypit/media";
 import type { FontStackRef } from "@hypit/media";
@@ -181,28 +181,27 @@ export const decodeDepthStackLabelSurface: StructuredSurfaceHandler = ({ element
 };
 
 export const decodeDepthStackSurface: StructuredSurfaceHandler = ({ element, resolveReference }) => {
-  allowed(element, ["id", "semantic", "space", "canvas", "frame", "appearance", "until", "until-boundary"]);
+  allowed(element, ["id", "timeline", "canvas", "frame", "appearance", "until", "until-boundary"]);
   const id = text(element, "id");
   const context = resolveTemporalContext({ element, resolveReference });
-  const time = createTemporalSpace({ id: id, element, ...context });
   const canvas = reference(element.attributes.canvas, `${element.name}.canvas`, spatialTypes.canvas, resolveReference);
   const frame = reference(element.attributes.frame, `${element.name}.frame`, spatialTypes.frame, resolveReference);
   const appearance = recipe(element.attributes.appearance, `${element.name}.appearance`, resolveReference);
   const terminal = createTemporalInstantProjection({
-    id: `${id}.terminal`, subjectId: id, element, ...context, space: time.space, resolveReference,
+    id: `${id}.terminal`, subjectId: id, element, ...context, resolveReference,
     semanticAttribute: "until", boundaryAttribute: "until-boundary", boundaryFallback: "end", projectedAttribute: false,
   });
   const records: SurfaceRecordDraft[] = [...terminal.records];
-  const temporalComponents: SurfaceComponentDraft[] = [...time.components, ...terminal.components];
-  const temporalFragments = [...time.fragments, ...terminal.fragments];
+  const temporalComponents: SurfaceComponentDraft[] = [...terminal.components];
+  const temporalFragments = [...terminal.fragments];
   const headerId = `${id}.header`;
   const specId = `${id}.spec`;
   records.push(
     { id: headerId, type: depthStackTypes.header, value: { kind: "inline", value: sealDepthStackHeader({ id }) }, range: element.range },
     { id: specId, type: depthStackTypes.spec, value: { kind: "inline", value: decodeDepthStackSpec(appearance) }, range: element.range },
   );
-  const inputs: Record<string, typeof time.space.ref> = {
-    canvas: canvas.ref, frame: frame.ref, header: { kind: "record", id: headerId }, space: time.space.ref,
+  const inputs: Record<string, typeof context.timeline.ref> = {
+    canvas: canvas.ref, frame: frame.ref, header: { kind: "record", id: headerId }, timeline: context.timeline.ref,
     spec: { kind: "record", id: specId }, terminal: terminal.ref,
   };
   const cards: DepthStackFragmentCard[] = [];
@@ -225,7 +224,7 @@ export const decodeDepthStackSurface: StructuredSurfaceHandler = ({ element, res
       : reference(child.attributes.extent, `${child.name}.extent`, spatialTypes.extent, resolveReference);
     if (sourceKind === "still" && extent === undefined) throw new Error(`${child.name}.extent is required for a still image.`);
     if (sourceKind !== "still" && extent !== undefined) throw new Error(`${child.name}.extent belongs only to a still image.`);
-    const activation = createTemporalInstantProjection({ id: `${id}.${cardId}`, subjectId: cardId, element: child, ...context, space: time.space, resolveReference });
+    const activation = createTemporalInstantProjection({ id: `${id}.${cardId}`, subjectId: cardId, element: child, ...context, resolveReference });
     records.push(...activation.records); temporalComponents.push(...activation.components); temporalFragments.push(...activation.fragments);
     const cardAppearance = child.attributes.appearance === undefined
       ? appearance : recipe(child.attributes.appearance, `${child.name}.appearance`, resolveReference);
@@ -249,7 +248,7 @@ export const decodeDepthStackSurface: StructuredSurfaceHandler = ({ element, res
     inputs[sampleSpecName] = { kind: "record", id: sampleId };
     inputs[cardSpecName] = { kind: "record", id: cardSpecId };
     inputs[activationName] = activation.ref;
-    let labelRef: typeof time.space.ref;
+    let labelRef: typeof context.timeline.ref;
     if (child.attributes.label === undefined) {
       const labelId = `${id}.card.${suffix}.label-none`;
       records.push({ id: labelId, type: depthStackTypes.cardLabel, value: { kind: "inline", value: noDepthStackCardLabel() }, range: child.range });