@hypit/hypit 0.1.4 → 0.1.5

package/packages/{semantic-track → timeline}/src/location.ts

@@ -1,7 +1,7 @@
 import type { NarrativeExcerpt, NarrativeMomentRef, NarrativeSelectionRef } from "@hypit/narrative";
 
-import { assertSemanticTrackIdentity, semanticTrackFrameCount, semanticTrackSpans } from "./identity.js";
-import type { LocatedFrameSpan, SemanticTrack } from "./types.js";
+import { assertTimelineIdentity, timelineFrameCount, timelineSpans } from "./identity.js";
+import type { LocatedFrameSpan, Timeline } from "./types.js";
 
 export function assertNarrativeSelectionIdentity(selection: NarrativeSelectionRef): void {
   if (!selection.narrativeId || !selection.id || !selection.startAnchorId || !selection.endAnchorId) throw new Error("NarrativeSelection is invalid");
@@ -11,33 +11,33 @@ export function assertNarrativeMomentIdentity(moment: NarrativeMomentRef): void
   if (!moment.narrativeId || !moment.id || !moment.anchorId) throw new Error("NarrativeMoment is invalid");
 }
 
-function assertNarrativeOwner(track: SemanticTrack, narrativeId: string, label: string): void {
+function assertNarrativeOwner(track: Timeline, narrativeId: string, label: string): void {
   if (narrativeId !== track.narrativeId) {
-    throw new Error(`${label} belongs to Narrative ${narrativeId}, not SemanticTrack ${track.id}.`);
+    throw new Error(`${label} belongs to Narrative ${narrativeId}, not Timeline ${track.id}.`);
   }
 }
 
-export function semanticAnchorFrames(track: SemanticTrack): ReadonlyMap<string, number> {
-  assertSemanticTrackIdentity(track);
+export function semanticAnchorFrames(track: Timeline): ReadonlyMap<string, number> {
+  assertTimelineIdentity(track);
   return new Map([
     ["program:start", 0] as const,
-    ...semanticTrackSpans(track).flatMap(({ item, startFrame }) =>
+    ...timelineSpans(track).flatMap(({ item, startFrame }) =>
       item.take.anchors.map((anchor) => [anchor.identity, startFrame + anchor.frame] as const)),
-    ["program:end", semanticTrackFrameCount(track)] as const,
+    ["program:end", timelineFrameCount(track)] as const,
   ]);
 }
 
 function frameFor(frames: ReadonlyMap<string, number>, anchorId: string, owner: string): number {
   const frame = frames.get(anchorId);
-  if (frame === undefined) throw new Error(`${owner} names Anchor ${anchorId}, which this SemanticTrack does not contain.`);
+  if (frame === undefined) throw new Error(`${owner} names Anchor ${anchorId}, which this Timeline does not contain.`);
   return frame;
 }
 
 export function selectionFrameSpan(
-  track: SemanticTrack,
+  track: Timeline,
   selection: NarrativeSelectionRef,
 ): LocatedFrameSpan {
-  assertSemanticTrackIdentity(track);
+  assertTimelineIdentity(track);
   assertNarrativeSelectionIdentity(selection);
   assertNarrativeOwner(track, selection.narrativeId, `NarrativeSelection ${selection.id}`);
   const frames = semanticAnchorFrames(track);
@@ -47,19 +47,19 @@ export function selectionFrameSpan(
   };
 }
 
-export function segmentFrameSpan(track: SemanticTrack, segment: NarrativeExcerpt): LocatedFrameSpan {
-  assertSemanticTrackIdentity(track);
+export function segmentFrameSpan(track: Timeline, segment: NarrativeExcerpt): LocatedFrameSpan {
+  assertTimelineIdentity(track);
   if (segment.kind !== "segment" || !segment.id) throw new Error("Narrative Segment excerpt is invalid");
   assertNarrativeOwner(track, segment.narrativeId, `Narrative Segment ${segment.id}`);
-  const found = semanticTrackSpans(track).find(({ item }) => item.take.segment.segmentId === segment.id);
-  if (found === undefined) throw new Error(`SemanticTrack does not contain Segment ${segment.id}.`);
+  const found = timelineSpans(track).find(({ item }) => item.take.segment.segmentId === segment.id);
+  if (found === undefined) throw new Error(`Timeline does not contain Segment ${segment.id}.`);
   return { startFrame: found.startFrame, endFrameExclusive: found.endFrameExclusive };
 }
 
-export function tokenFrameSpan(track: SemanticTrack, tokenIds: readonly string[]): LocatedFrameSpan | undefined {
-  assertSemanticTrackIdentity(track);
+export function tokenFrameSpan(track: Timeline, tokenIds: readonly string[]): LocatedFrameSpan | undefined {
+  assertTimelineIdentity(track);
   if (tokenIds.length === 0) return undefined;
-  const timing = new Map(semanticTrackSpans(track).flatMap(({ item, startFrame }) =>
+  const timing = new Map(timelineSpans(track).flatMap(({ item, startFrame }) =>
     item.take.tokens.map((token) => [token.tokenId, {
       startFrame: startFrame + token.startFrame,
       endFrameExclusive: startFrame + token.endFrameExclusive,
@@ -72,8 +72,8 @@ export function tokenFrameSpan(track: SemanticTrack, tokenIds: readonly string[]
   };
 }
 
-export function momentFrame(track: SemanticTrack, moment: NarrativeMomentRef): number {
-  assertSemanticTrackIdentity(track);
+export function momentFrame(track: Timeline, moment: NarrativeMomentRef): number {
+  assertTimelineIdentity(track);
   assertNarrativeMomentIdentity(moment);
   assertNarrativeOwner(track, moment.narrativeId, `NarrativeMoment ${moment.id}`);
   const frames = semanticAnchorFrames(track);

package/packages/timeline/src/manifest.ts

@@ -0,0 +1,39 @@
+import { compositionDependency, compositionTypes } from "@hypit/composition";
+import { narrativeDependency } from "@hypit/narrative";
+import { programSpaceDependency, programSpaceSchema, programSpaceTypes } from "@hypit/program-space";
+import type { ModuleManifest, ProducerRef, TypeRef, ValueSchema } from "@hypit/protocol";
+import { semanticTakeSchema, speechDependency } from "@hypit/speech";
+
+export const timelineModuleRef = { name: "@hypit/timeline", version: "1" } as const;
+export const timelineTypes = {
+  track: { module: timelineModuleRef, name: "Timeline" },
+} satisfies Record<string, TypeRef>;
+export const timelineProducers = {
+  projectProgramSpace: { module: timelineModuleRef, name: "project-program-space" },
+  projectAudio: { module: timelineModuleRef, name: "project-audio-track" },
+} satisfies Record<string, ProducerRef>;
+
+const string = { kind: "string", minLength: 1 } as const;
+const object = (fields: Readonly<Record<string, { readonly schema: ValueSchema; readonly optional?: boolean }>>): ValueSchema => ({ kind: "object", fields });
+export const timelineSchema: ValueSchema = object({
+  ...(programSpaceSchema.kind === "object" ? programSpaceSchema.fields : {}),
+  narrativeId: { schema: string, optional: true },
+  items: { schema: { kind: "array", items: object({
+    startFrame: { schema: { kind: "number", integer: true, minimum: 0 } },
+    take: { schema: semanticTakeSchema },
+  }) } },
+});
+
+export const timelineManifest: ModuleManifest = {
+  format: "hypit.module@1",
+  name: timelineModuleRef.name,
+  version: timelineModuleRef.version,
+  dependencies: [speechDependency, narrativeDependency, programSpaceDependency, compositionDependency],
+  types: [{ name: timelineTypes.track.name }],
+  capabilities: [],
+  producers: [
+    { name: timelineProducers.projectProgramSpace.name, inputs: [{ name: "track", type: timelineTypes.track }], outputs: [{ name: "space", type: programSpaceTypes.programSpace }], needs: [] },
+    { name: timelineProducers.projectAudio.name, inputs: [{ name: "track", type: timelineTypes.track }], outputs: [{ name: "audio", type: compositionTypes.audioTrack }], needs: [] },
+  ],
+};
+export const timelineDependency = { module: timelineModuleRef } as const;

package/packages/{semantic-track → timeline}/src/projection.ts

@@ -7,18 +7,18 @@ import {
 } from "@hypit/program-space";
 import type { ProgramSpace } from "@hypit/program-space";
 
-import { assertSemanticTrackIdentity, semanticTrackFrameCount, semanticTrackSpans } from "./identity.js";
-import type { SemanticTrack } from "./types.js";
+import { assertTimelineIdentity, timelineFrameCount, timelineSpans } from "./identity.js";
+import type { Timeline } from "./types.js";
 
 /** Prepared material in an authored program interval, with its original source position retained. */
-export function projectSemanticMedia(track: SemanticTrack, window = {
-  startFrame: 0, endFrameExclusive: semanticTrackFrameCount(track),
+export function projectTimelineMedia(track: Timeline, window = {
+  startFrame: 0, endFrameExclusive: timelineFrameCount(track),
 }) {
-  assertSemanticTrackIdentity(track);
+  assertTimelineIdentity(track);
   if (!Number.isSafeInteger(window.startFrame) || !Number.isSafeInteger(window.endFrameExclusive)
     || window.startFrame < 0 || window.endFrameExclusive <= window.startFrame
-    || window.endFrameExclusive > semanticTrackFrameCount(track)) throw new Error("Semantic media window is outside the performance.");
-  return semanticTrackSpans(track).flatMap(({ item, startFrame, endFrameExclusive }) => {
+    || window.endFrameExclusive > timelineFrameCount(track)) throw new Error("Semantic media window is outside the performance.");
+  return timelineSpans(track).flatMap(({ item, startFrame, endFrameExclusive }) => {
     const start = Math.max(window.startFrame, startFrame);
     const end = Math.min(window.endFrameExclusive, endFrameExclusive);
     return end <= start ? [] : [{
@@ -30,19 +30,19 @@ export function projectSemanticMedia(track: SemanticTrack, window = {
   });
 }
 
-export function projectSemanticProgramSpace(track: SemanticTrack): ProgramSpace {
-  assertSemanticTrackIdentity(track);
-  const frameRate = track.items[0]!.take.media.timeline.frameRate;
+export function projectTimelineSpace(track: Timeline): ProgramSpace {
+  assertTimelineIdentity(track);
+  const frameRate = track.frameRate;
   return sealProgramSpace({
     id: track.id,
-    durationSec: semanticTrackFrameCount(track) * frameRate.denominator / frameRate.numerator,
+    durationSec: track.durationSec,
     frameRate,
   });
 }
 
-export function projectSemanticAudioTrack(track: SemanticTrack): AudioTrack {
-  const space = projectSemanticProgramSpace(track);
-  const clips = semanticTrackSpans(track).flatMap(({ item, startFrame, endFrameExclusive }) => {
+export function projectTimelineAudio(track: Timeline): AudioTrack {
+  const space = projectTimelineSpace(track);
+  const clips = timelineSpans(track).flatMap(({ item, startFrame, endFrameExclusive }) => {
     const audio = item.take.media.audio;
     if (audio === undefined) return [];
     const sourceSampleFrames = synchronizedMediaSampleFrames(item.take.media);

package/packages/timeline/src/types.ts

@@ -0,0 +1,24 @@
+import type { ProgramSpace } from "@hypit/program-space";
+import type { SemanticTake } from "@hypit/speech";
+
+export type TimelineItem = {
+  readonly take: SemanticTake;
+  readonly startFrame: number;
+};
+
+/** One complete film time range, with prepared material placed where it belongs. */
+export type Timeline = ProgramSpace & {
+  readonly narrativeId?: string;
+  readonly items: readonly TimelineItem[];
+};
+
+export type TimelineSpan = {
+  readonly item: TimelineItem;
+  readonly startFrame: number;
+  readonly endFrameExclusive: number;
+};
+
+export type LocatedFrameSpan = {
+  readonly startFrame: number;
+  readonly endFrameExclusive: number;
+};

package/packages/timeline-author/README.md

@@ -0,0 +1,68 @@
+# `@hypit/timeline-author`
+
+Declare one complete Timeline and place prepared Takes within it. Spoken work, mixed spoken/MG
+work and pure authored animation use the same declaration. The separate
+[Timeline value package](../timeline/README.md) owns the data and projections; this author package
+owns the markup and deterministic assembly.
+
+```svml
+<import as="time" from="@hypit/timeline-author@1"/>
+<time:Clock id="clock" frame-rate="30"/>
+<time:Timeline id="program" clock={clock} end="content.end+2s">
+  <time:Take source={opening.take} at="2s"/>
+  <time:Take source={explanation.take} at="previous.end+3s"/>
+  <time:Take source={closing.take} at="previous.end-12f"/>
+</time:Timeline>
+```
+
+The first Take begins at two seconds. The second starts three seconds after the preceding Take ends.
+The third overlaps its predecessor by twelve frames. The complete Timeline ends two seconds after
+all Takes have ended. Durations come from prepared material, so authoring these relations does not
+require knowing generated lengths beforehand or serializing generation.
+
+| Declaration | Meaning |
+| --- | --- |
+| `clock={clock}` | Required frame-rate input, also usable by upstream normalization. |
+| Take `source={clip.take}` | Complete normalized, semantically prepared local Take. A wordless Take is valid real media. |
+| First omitted `at` | `0f`. |
+| Later omitted `at` | `previous.end`. |
+| `at="20s"` | Absolute start. |
+| `at="previous.end+2s"` | Start relative to the preceding Take declaration's end. Negative offsets permit overlap. |
+| Omitted `end` | `content.end`, the maximum end across all placed Takes. |
+| `end="content.end+2s"` | Reserve a trailing interval after all Takes finish. |
+| `end="30s"` | Fixed complete extent, including every placed Take. |
+
+Positions and offsets accept seconds, milliseconds and frames, and must resolve to exact frame
+boundaries on the Clock. Negative placements, a missing predecessor, or a fixed end shorter than
+placed content produce an error. A positive predecessor offset does not promise globally empty
+time if another long Take remains active. Placement is translation at native speed; trimming or
+retiming material belongs before its semantic preparation.
+
+For ordinary sequential assembly, omit all Take `at` attributes and Timeline `end`. For wholly
+authored animation, supply the extent and no Takes:
+
+```svml
+<time:Timeline id="animation" clock={clock} end="30s"/>
+```
+
+This produces no blank video or fabricated Script. Empty content cannot supply an implicit positive
+extent. Program boundaries remain available for MG, media, titles and sound.
+
+| Output | Use |
+| --- | --- |
+| `.timeline` | Complete time range and placed material/evidence, consumed through `timeline={program.timeline}`. |
+
+[Performance](../performance/README.md) presents footage already
+held by the Timeline. It can show it full-frame, in an inset or as a cutout; project components can
+own coordinated video and graphics. Sampling a new presentation Window preserves each Take's source
+position. Overlap supplies multiple sources, not an automatic dissolve. Independent Media Items
+still receive their own assets and may coexist. Caption reads the authored words and placed timing.
+
+[Sound](../sound/README.md) presents existing Timeline audio through ordered Uses.
+[Audio Track](../audio-track/README.md) handles independent music and effects. Include the wanted
+presentation outputs explicitly in Film. Timeline itself exports only `.timeline`; holding material
+does not add a picture or sound contribution.
+
+Timeline placement is authored with `at` and `end`. Studio shows placed Takes and the complete range
+as reference information. Use-window and Script-marker controls edit presentation timing and semantic
+anchors respectively; they do not move Takes or change the Timeline extent.

package/packages/{speech-track → timeline-author}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@hypit/speech-track",
+  "name": "@hypit/timeline-author",
   "version": "0.0.0-dev",
   "license": "SEE LICENSE IN LICENSE",
   "private": true,
@@ -12,12 +12,14 @@
   },
   "dependencies": {
     "@hypit/component-kit": "workspace:*",
-    "@hypit/composition": "workspace:*",
     "@hypit/elaborator": "workspace:*",
     "@hypit/protocol": "workspace:*",
     "@hypit/speech": "workspace:*",
-    "@hypit/semantic-track": "workspace:*",
-    "@hypit/markup": "workspace:*"
+    "@hypit/timeline": "workspace:*",
+    "@hypit/markup": "workspace:*",
+    "@hypit/program-space": "workspace:*",
+    "@hypit/temporal": "workspace:*",
+    "@hypit/temporal-markup": "workspace:*"
   },
   "devDependencies": {
     "@hypit/core": "workspace:*",

package/packages/timeline-author/src/activation.ts

@@ -0,0 +1,22 @@
+import { decodeClockSurface } from "@hypit/program-space";
+import { createMarkupSurfaceHostFacet } from "@hypit/markup";
+import {
+  decodeTimelineAuthorSurface, timelineAuthorComponent, timelineAuthorManifest,
+  timelineAuthorModuleRef,
+  timelineAuthorMarkupSurfaces,
+} from "./index.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{
+    manifest: timelineAuthorManifest,
+  }],
+  components: [timelineAuthorComponent],
+  hostFacets: [createMarkupSurfaceHostFacet({
+    module: timelineAuthorModuleRef,
+    declaration: timelineAuthorMarkupSurfaces.find((item) => item.name === "timeline")!, handler: decodeTimelineAuthorSurface,
+  }), createMarkupSurfaceHostFacet({ module: timelineAuthorModuleRef,
+    declaration: timelineAuthorMarkupSurfaces.find(item => item.name === "clock")!, handler: decodeClockSurface,
+  })],
+};
+export default hypitPackage;

package/packages/{speech-track → timeline-author}/src/component.ts

@@ -1,42 +1,44 @@
+import type { ProgramClock } from "@hypit/program-space";
 import type { ComponentPackage } from "@hypit/component-kit";
 import type { StoredValue } from "@hypit/protocol";
 import { canonicalize } from "@hypit/protocol";
 import type { SemanticTake } from "@hypit/speech";
 
-import { speechTrackProducers } from "./manifest.js";
-import { appendSpeechTrackTake, assembleSpeechTrack, createSpeechTrackSet } from "./program.js";
-import type { SpeechTrackHeader, SpeechTrackSet } from "./types.js";
+import { timelineAuthorProducers } from "./manifest.js";
+import { appendTimelineAuthorTake, assembleTimelineAuthor, createTimelineAuthorSet } from "./program.js";
+import type { TimelineAuthorHeader, TimelineAuthorSet } from "./types.js";
 
 function inline<T>(value: StoredValue | undefined, subject: string): T {
   if (value?.kind !== "inline") throw new Error(`${subject} must be inline`);
   return value.value as unknown as T;
 }
 
-export const speechTrackComponent = {
+export const timelineAuthorComponent = {
   producers: [
     {
-      producer: speechTrackProducers.createSet,
+      producer: timelineAuthorProducers.createSet,
       handler: () => ({
-        outputs: { set: { kind: "inline", value: canonicalize(createSpeechTrackSet()) } },
+        outputs: { set: { kind: "inline", value: canonicalize(createTimelineAuthorSet()) } },
         needs: {},
       }),
     },
     {
-      producer: speechTrackProducers.appendTake,
+      producer: timelineAuthorProducers.appendTake,
       handler: ({ inputs }) => ({
-        outputs: { set: { kind: "inline", value: canonicalize(appendSpeechTrackTake(
-          inline<SpeechTrackSet>(inputs.set?.value, "SpeechTrackSet"),
+        outputs: { set: { kind: "inline", value: canonicalize(appendTimelineAuthorTake(
+          inline<TimelineAuthorSet>(inputs.set?.value, "TimelineAuthorSet"),
           inline<SemanticTake>(inputs.take?.value, "SemanticTake"),
         )) } },
         needs: {},
       }),
     },
     {
-      producer: speechTrackProducers.assembleTrack,
+      producer: timelineAuthorProducers.assembleTrack,
       handler: ({ inputs }) => ({
-        outputs: { track: { kind: "inline", value: canonicalize(assembleSpeechTrack(
-          inline<SpeechTrackHeader>(inputs.header?.value, "SpeechTrackHeader"),
-          inline<SpeechTrackSet>(inputs.set?.value, "SpeechTrackSet"),
+        outputs: { track: { kind: "inline", value: canonicalize(assembleTimelineAuthor(
+          inline<TimelineAuthorHeader>(inputs.header?.value, "TimelineAuthorHeader"),
+          inline<TimelineAuthorSet>(inputs.set?.value, "TimelineAuthorSet"),
+          inline<ProgramClock>(inputs.clock?.value, "ProgramClock"),
         )) } },
         needs: {},
       }),

package/packages/{speech-track → timeline-author}/src/fragment.ts

@@ -1,35 +1,35 @@
+import { programSpaceTypes } from "@hypit/program-space";
 import { speechTypes } from "@hypit/speech";
-import { compositionTypes } from "@hypit/composition";
 import { sealGraphFragment } from "@hypit/elaborator";
 import type { FragmentOperation } from "@hypit/elaborator";
-import { semanticTrackProducers, semanticTrackTypes } from "@hypit/semantic-track";
+import { timelineTypes } from "@hypit/timeline";
 import type { TypeRef } from "@hypit/protocol";
 
-import { speechTrackProducers, speechTrackTypes } from "./manifest.js";
-import type { SpeechTrackFragmentOptions } from "./types.js";
+import { timelineAuthorProducers, timelineAuthorTypes } from "./manifest.js";
+import type { TimelineAuthorFragmentOptions } from "./types.js";
 
 const input = (name: string) => ({ kind: "fragment-input" as const, name });
 const operation = (id: string) => ({ kind: "fragment-operation" as const, operation: id });
 
-export function createSpeechTrackFragment(options: SpeechTrackFragmentOptions) {
-  if (options.takes.length === 0) throw new Error("Speech Track requires at least one Take");
+export function createTimelineAuthorFragment(options: TimelineAuthorFragmentOptions) {
   const declaredInputs = new Map<string, TypeRef>();
   const addInput = (name: string, type: TypeRef): void => {
-    if (!name) throw new Error("Speech Track Fragment input names must not be empty");
+    if (!name) throw new Error("Timeline Fragment input names must not be empty");
     const previous = declaredInputs.get(name);
     if (previous !== undefined && (previous.module.name !== type.module.name
       || previous.module.version !== type.module.version || previous.name !== type.name)) {
-      throw new Error(`Speech Track Fragment input ${name} is reused with another Type`);
+      throw new Error(`Timeline Fragment input ${name} is reused with another Type`);
     }
     declaredInputs.set(name, type);
   };
-  addInput("header", speechTrackTypes.header);
+  addInput("header", timelineAuthorTypes.header);
+  addInput("clock", programSpaceTypes.clock);
   for (const take of options.takes) {
     addInput(take.takeName, speechTypes.semanticTake);
   }
   const operations: FragmentOperation[] = [{
     id: "track:set:empty",
-    producer: speechTrackProducers.createSet,
+    producer: timelineAuthorProducers.createSet,
     inputs: {},
     result: { kind: "output", name: "set" },
   }];
@@ -38,7 +38,7 @@ export function createSpeechTrackFragment(options: SpeechTrackFragmentOptions) {
     const id = `track:set:append:${String(index + 1).padStart(4, "0")}`;
     operations.push({
       id,
-      producer: speechTrackProducers.appendTake,
+      producer: timelineAuthorProducers.appendTake,
       inputs: {
         set: operation(current),
         take: input(take.takeName),
@@ -50,25 +50,16 @@ export function createSpeechTrackFragment(options: SpeechTrackFragmentOptions) {
   operations.push(
     {
       id: "track:semantic",
-      producer: speechTrackProducers.assembleTrack,
-      inputs: { header: input("header"), set: operation(current) },
+      producer: timelineAuthorProducers.assembleTrack,
+      inputs: { header: input("header"), set: operation(current), clock: input("clock") },
       result: { kind: "output", name: "track" },
     },
-    {
-      id: "track:audio-track",
-      producer: semanticTrackProducers.projectAudio,
-      inputs: { track: operation("track:semantic") },
-      result: { kind: "output", name: "audio" },
-    },
   );
   return sealGraphFragment({
     inputs: [...declaredInputs.entries()].map(([name, type]) => ({ name, type })),
     operations,
     exports: [
-      { name: "semantic", type: semanticTrackTypes.track, root: operation("track:semantic") },
-      {
-        name: "audio", type: compositionTypes.audioTrack, root: operation("track:audio-track"),
-      },
+      { name: "timeline", type: timelineTypes.track, root: operation("track:semantic") },
     ],
   });
 }

package/packages/timeline-author/src/index.ts

@@ -0,0 +1,7 @@
+/** Official Timeline authoring and deterministic Timeline assembly. */
+export { timelineAuthorComponent } from "./component.js";
+export { createTimelineAuthorFragment } from "./fragment.js";
+export { timelineAuthorManifest, timelineAuthorMarkupSurfaces, timelineAuthorModuleRef, timelineAuthorProducers, timelineAuthorTypes, timelineAuthorHeaderSchema, timelineAuthorSetSchema } from "./manifest.js";
+export { appendTimelineAuthorTake, assembleTimelineAuthor, assertTimelineAuthorHeader, assertTimelineAuthorSet, createTimelineAuthorSet, sealTimelineAuthorHeader } from "./program.js";
+export { decodeTimelineAuthorSurface } from "./surface.js";
+export type * from "./types.js";

package/packages/timeline-author/src/manifest.ts

@@ -0,0 +1,78 @@
+import { programSpaceDependency, programSpaceTypes, programSpaceMarkupSurfaces } from "@hypit/program-space";
+import { semanticTakeSchema, speechDependency, speechTypes } from "@hypit/speech";
+import { timelineDependency, timelineTypes } from "@hypit/timeline";
+import type { ModuleManifest, ValueSchema } from "@hypit/protocol";
+export const timelineAuthorModuleRef = { name: "@hypit/timeline-author", version: "1" } as const;
+export const timelineAuthorTypes = {
+  header: { module: timelineAuthorModuleRef, name: "TimelineAuthorHeader" },
+  trackSet: { module: timelineAuthorModuleRef, name: "TimelineAuthorSet" },
+} as const;
+export const timelineAuthorProducers = {
+  createSet: { module: timelineAuthorModuleRef, name: "create-track-set" },
+  appendTake: { module: timelineAuthorModuleRef, name: "append-track-take" },
+  assembleTrack: { module: timelineAuthorModuleRef, name: "assemble-timeline" },
+} as const;
+export const timelineAuthorHeaderSchema: ValueSchema = { kind: "object", fields: { id: { schema: { kind: "string", minLength: 1 } }, at: { optional: true, schema: { kind: "array", items: { kind: "string" } } }, end: { optional: true, schema: { kind: "string" } } } };
+export const timelineAuthorSetSchema: ValueSchema = { kind: "object", fields: { takes: { schema: { kind: "array", items: { kind: "object", fields: { semantic: { schema: semanticTakeSchema } } } } } } };
+export const timelineAuthorMarkupSurfaces = [{
+  name: "timeline", tag: "Timeline", mode: "structured",
+  outputs: [timelineAuthorTypes.header, timelineTypes.track],
+  vocabulary: {
+    summary: "Declares one complete Timeline, with zero or more prepared Takes placed within it.",
+    attributes: [
+      { name: "id", kind: "identifier", required: true, summary: "Names the Timeline output." },
+      { name: "clock", kind: "reference", required: true, accepts: [programSpaceTypes.clock], summary: "Frame rate, available before material generation." },
+      { name: "end", kind: "literal", required: false, summary: "Program end: fixed time or content.end with an optional offset; defaults to content.end." },
+    ],
+    children: [{ tag: "Take", cardinality: "many", summary: "A prepared SemanticTake in performance order.",
+      attributes: [{ name: "source", kind: "reference", required: true, accepts: [speechTypes.semanticTake], summary: "The normalized, aligned performance." },
+        { name: "at", kind: "literal", required: false, summary: "Absolute position or previous.end with an offset. Defaults to zero for the first Take and previous.end thereafter." }] }],
+    ports: [
+      { name: "timeline", type: timelineTypes.track, summary: "The complete time range, retaining placed material and any semantic evidence." },
+    ],
+    example: '<time:Clock id="clock" frame-rate="30"/><time:Timeline id="program" clock={clock} end="content.end+2s"><time:Take source={opening.take} at="2s"/><time:Take source={answer.take}/></time:Timeline>',
+    notes: ["Performance, Sound and Caption present existing pictures, audio and words independently. Include their contributions explicitly in Film."],
+  },
+}, programSpaceMarkupSurfaces[0]] as const;
+export const timelineAuthorManifest: ModuleManifest = {
+  format: "hypit.module@1",
+  name: timelineAuthorModuleRef.name,
+  version: timelineAuthorModuleRef.version,
+  dependencies: [
+    programSpaceDependency,
+    speechDependency,
+    timelineDependency,
+  ],
+  types: [
+    { name: timelineAuthorTypes.header.name },
+    { name: timelineAuthorTypes.trackSet.name },
+  ],
+  capabilities: [],
+  producers: [
+    {
+      name: timelineAuthorProducers.createSet.name,
+      inputs: [],
+      outputs: [{ name: "set", type: timelineAuthorTypes.trackSet }],
+      needs: [],
+    },
+    {
+      name: timelineAuthorProducers.appendTake.name,
+      inputs: [
+        { name: "set", type: timelineAuthorTypes.trackSet },
+        { name: "take", type: speechTypes.semanticTake },
+      ],
+      outputs: [{ name: "set", type: timelineAuthorTypes.trackSet }],
+      needs: [],
+    },
+    {
+      name: timelineAuthorProducers.assembleTrack.name,
+      inputs: [
+        { name: "header", type: timelineAuthorTypes.header },
+        { name: "clock", type: programSpaceTypes.clock },
+        { name: "set", type: timelineAuthorTypes.trackSet },
+      ],
+      outputs: [{ name: "track", type: timelineTypes.track }],
+      needs: [],
+    },
+  ],
+};