@hypit/hypit 0.0.1 → 0.1.0

package/dist/public/caption.d.ts

@@ -0,0 +1,751 @@
+declare class CaptionTimingError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+
+/** Opaque identity for one admitted byte resource. Equal bytes may have different identities. */
+type ResourceId = `res_${string}`;
+type RecordId = string;
+type StepId = string;
+type CommandId = string;
+type ModuleRef = {
+    readonly name: string;
+    readonly version: string;
+};
+/**
+ * A Type is its owning Module and its name, and nothing else is compared. Two Types whose values
+ * carry identical shapes are distinct, so one is refused where the other is declared — there is no
+ * structural fallback to fall back to.
+ */
+type TypeRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+type ProducerRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+type CapabilityRef = {
+    readonly module: ModuleRef;
+    readonly name: string;
+};
+
+type CanonicalValue = null | boolean | number | string | readonly CanonicalValue[] | {
+    readonly [key: string]: CanonicalValue;
+};
+type BlobRef = {
+    readonly kind: "blob";
+    /** One admitted resource instance. Equal bytes admitted twice keep distinct identities. */
+    readonly resource: ResourceId;
+    readonly size: number;
+    readonly mediaType: string;
+};
+type StoredValue = {
+    readonly kind: "inline";
+    readonly value: CanonicalValue;
+} | BlobRef;
+type ValueSchema = {
+    readonly kind: "null";
+} | {
+    readonly kind: "boolean";
+} | {
+    readonly kind: "number";
+    readonly integer?: boolean;
+    readonly minimum?: number;
+    readonly maximum?: number;
+} | {
+    readonly kind: "string";
+    readonly enum?: readonly string[];
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    /** UI-neutral semantic format shared by authoring, validation and tools. */
+    readonly format?: "color";
+} | {
+    readonly kind: "literal";
+    readonly value: CanonicalValue;
+} | {
+    readonly kind: "array";
+    readonly items: ValueSchema;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+} | {
+    readonly kind: "object";
+    readonly fields: Readonly<Record<string, ObjectFieldSchema>>;
+    readonly allowUnknown?: boolean;
+} | {
+    readonly kind: "oneOf";
+    readonly variants: readonly ValueSchema[];
+} | {
+    readonly kind: "blob";
+    readonly mediaTypes?: readonly string[];
+    readonly maxBytes?: number;
+};
+type ObjectFieldSchema = {
+    readonly schema: ValueSchema;
+    readonly optional?: boolean;
+};
+
+type ModuleDependency = {
+    readonly module: ModuleRef;
+};
+type TypeDeclaration = {
+    readonly name: string;
+};
+type PortDeclaration = {
+    readonly name: string;
+    readonly type: TypeRef;
+};
+type NeedPortDeclaration = {
+    readonly name: string;
+    readonly capability: CapabilityRef;
+    readonly returns: TypeRef;
+};
+type CapabilityDeclaration = {
+    readonly name: string;
+    readonly returns: TypeRef;
+};
+type ProducerDeclaration = {
+    readonly name: string;
+    readonly inputs: readonly PortDeclaration[];
+    readonly outputs: readonly PortDeclaration[];
+    readonly needs: readonly NeedPortDeclaration[];
+};
+type ModuleManifest = {
+    readonly format: "hypit.module@1";
+    readonly name: string;
+    readonly version: string;
+    readonly dependencies: readonly ModuleDependency[];
+    readonly types: readonly TypeDeclaration[];
+    readonly capabilities: readonly CapabilityDeclaration[];
+    readonly producers: readonly ProducerDeclaration[];
+};
+
+type SourceRange = {
+    readonly start: number;
+    readonly end: number;
+};
+/** One typed value in the graph; semantic validation happens at the Host admission boundary. */
+type TypedRecord = {
+    readonly id: RecordId;
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+};
+type InvokeProducerCommand = {
+    readonly kind: "invoke-producer";
+    readonly id: CommandId;
+    readonly step: StepId;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, RecordId>>;
+};
+
+type TypeValidatorContext = {
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+};
+/**
+ * Pure compute context. Artifact bytes, credentials, network and stores are deliberately absent;
+ * those effects must cross an explicit Need into a Provider.
+ */
+type ProducerHandlerContext = {
+    readonly command: InvokeProducerCommand;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, TypedRecord>>;
+};
+
+type NarrativeSegment = {
+    readonly id: string;
+    readonly startAnchorId: string;
+    readonly endAnchorId: string;
+    readonly tokenStart: number;
+    readonly tokenEndExclusive: number;
+};
+type NarrativeToken = {
+    readonly id: string;
+    readonly segmentId: string;
+    readonly startAnchorId: string;
+    readonly endAnchorId: string;
+    readonly text: string;
+    readonly normalized: string;
+};
+type NarrativeTurn = {
+    readonly id: string;
+    readonly segmentId: string;
+    readonly role?: string;
+    readonly tokenStart: number;
+    readonly tokenEndExclusive: number;
+};
+type NarrativeSelection = {
+    readonly id: string;
+    /** The exact semantic anchors chosen by the author Surface's affinity syntax. */
+    readonly startAnchorId: string;
+    readonly endAnchorId: string;
+};
+type NarrativeMoment = {
+    readonly id: string;
+    /** The exact semantic anchor chosen by the author Surface's affinity syntax. */
+    readonly anchorId: string;
+};
+/** One author-visible word surface. Punctuation owned by the surface is preserved. */
+type CaptionDisplayWord = {
+    readonly id: string;
+    readonly unitId: string;
+    readonly segmentId: string;
+    readonly turnId: string;
+    readonly role?: string;
+    readonly text: string;
+    /** Reserved for Script-native word attributes; empty until an inline Mark is authored. */
+    readonly attributes: readonly CaptionWordAttribute[];
+};
+type CaptionWordAttributeValue = string | number | boolean;
+type CaptionWordAttribute = {
+    readonly name: string;
+    readonly value: CaptionWordAttributeValue;
+};
+/** The smallest author-declared N:M display-to-speech correspondence unit. */
+type CaptionAlignmentUnit = {
+    readonly id: string;
+    readonly segmentId: string;
+    readonly turnId: string;
+    readonly role?: string;
+    readonly wordIds: readonly string[];
+    /** Speech tokens are retained here so Caption can project a Narrative Selection without frames. */
+    readonly sourceTokenIds: readonly string[];
+};
+type CaptionCueBreak = {
+    /** The Cue boundary is after this complete Alignment Unit. */
+    readonly afterUnitId: string;
+};
+/** Complete Script-owned Caption truth. It contains no frame or measured timing facts. */
+type CaptionDocument = {
+    /** Author-visible `<script id>` that owns this caption projection. */
+    readonly narrativeId: string;
+    readonly id: string;
+    readonly units: readonly CaptionAlignmentUnit[];
+    readonly words: readonly CaptionDisplayWord[];
+    readonly cueBreaks: readonly CaptionCueBreak[];
+};
+type SemanticAnchor = {
+    readonly id: "program:start";
+    readonly kind: "program-start";
+    readonly segmentId?: never;
+    readonly tokenId?: never;
+} | {
+    readonly id: "program:end";
+    readonly kind: "program-end";
+    readonly segmentId?: never;
+    readonly tokenId?: never;
+} | {
+    readonly id: string;
+    readonly kind: "segment-start" | "token-start" | "token-end" | "segment-end";
+    readonly segmentId: string;
+    readonly tokenId?: string;
+};
+type Narrative = {
+    /** Author-visible `<script id>`; every exported semantic view retains it. */
+    readonly id: string;
+    readonly segments: readonly NarrativeSegment[];
+    readonly tokens: readonly NarrativeToken[];
+    readonly turns: readonly NarrativeTurn[];
+    readonly selections: readonly NarrativeSelection[];
+    readonly moments: readonly NarrativeMoment[];
+    readonly semanticIndex: {
+        readonly anchors: readonly SemanticAnchor[];
+    };
+};
+
+declare function assertCaptionDocument(value: CaptionDocument): void;
+type CaptionUnitSubset = {
+    readonly documentId: string;
+    readonly unitIds: readonly string[];
+};
+/** Project a semantic Selection to complete authored N:M Caption units. */
+declare function captionUnitsForSelection(document: CaptionDocument, narrative: Narrative, selection: NarrativeSelection): CaptionUnitSubset;
+declare function captionUnitsForRole(document: CaptionDocument, role: string): CaptionUnitSubset;
+declare function captionWordsForAttribute(document: CaptionDocument, attribute: string): readonly string[];
+declare function assertCaptionUnitSubset(value: CaptionUnitSubset, document: CaptionDocument): void;
+
+declare const captionComponent: {
+    producers: {
+        producer: {
+            module: {
+                readonly name: "@hypit/caption";
+                readonly version: "1";
+            };
+            name: string;
+        };
+        handler: ({ inputs }: ProducerHandlerContext) => {
+            outputs: {
+                caption: {
+                    kind: "inline";
+                    value: CanonicalValue;
+                };
+            };
+            needs: {};
+        };
+    }[];
+    validators: {
+        type: {
+            module: {
+                readonly name: "@hypit/caption";
+                readonly version: "1";
+            };
+            name: string;
+        };
+        handler: ({ value }: TypeValidatorContext) => void;
+    }[];
+};
+
+type FragmentInputRef = {
+    readonly kind: "fragment-input";
+    readonly name: string;
+};
+type FragmentOperationRef = {
+    readonly kind: "fragment-operation";
+    readonly operation: string;
+};
+type FragmentValueRef = FragmentInputRef | FragmentOperationRef;
+type FragmentOperationResult = {
+    readonly kind: "output";
+    readonly name: string;
+} | {
+    readonly kind: "need";
+    readonly name: string;
+};
+type FragmentOperation = {
+    readonly id: string;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, FragmentValueRef>>;
+    readonly result: FragmentOperationResult;
+};
+type FragmentExport = {
+    readonly name: string;
+    readonly type: TypeRef;
+    readonly root: FragmentOperationRef;
+};
+type GraphFragment = {
+    readonly format: "hypit.fragment@1";
+    readonly id: string;
+    readonly inputs: readonly {
+        readonly name: string;
+        readonly type: TypeRef;
+    }[];
+    readonly operations: readonly FragmentOperation[];
+    readonly exports: readonly FragmentExport[];
+};
+
+/** A reference to an authored fact that already exists in the Linked Program. */
+type AuthorRecordRef = {
+    readonly kind: "record";
+    readonly id: string;
+};
+/** A symbolic reference to one public export of another component instance. */
+type AuthorComponentOutputRef = {
+    readonly kind: "component-output";
+    readonly component: string;
+    readonly output: string;
+};
+type AuthorValueRef = AuthorRecordRef | AuthorComponentOutputRef;
+/**
+ * One author-visible component call. `outputs` binds every public Fragment export to a Logical Output.
+ */
+type AuthorComponent = {
+    readonly id: string;
+    readonly fragment: string;
+    readonly inputs: Readonly<Record<string, AuthorValueRef>>;
+    readonly outputs: Readonly<Record<string, string>>;
+};
+
+type SourceAssetRequest = {
+    readonly from: string;
+    readonly mediaType: string;
+    /** Package-owned bytes admitted by the compiler before a Workspace is consulted. */
+    readonly bytes?: Uint8Array;
+    readonly range?: SourceRange;
+};
+type ResolvedSourceAsset = {
+    readonly artifact: BlobRef;
+};
+
+/** A semantic source dependency requested by a Frontend or package-owned Surface. */
+type AuthorSourceAssetRequest = SourceAssetRequest;
+type ResolvedAuthorSourceAsset = ResolvedSourceAsset;
+/**
+ * One author-visible identity whose uniqueness is part of a domain's public
+ * contract. The Frontend only carries the declaration; the owning Surface
+ * chooses the Type namespace and the Source closure enforces it generically.
+ */
+type AuthorSourceIdentity = {
+    readonly namespace: TypeRef;
+    readonly id: string;
+};
+type Awaitable<T> = T | Promise<T>;
+
+declare const captionTimingFragment: GraphFragment;
+/** Kept as the fragment's public name for callers that only know the old export. */
+declare const plannedCaptionTimingFragment: GraphFragment;
+
+declare const captionModuleRef: {
+    readonly name: "@hypit/caption";
+    readonly version: "1";
+};
+declare const captionProducers: {
+    temporalizeDocument: {
+        module: {
+            readonly name: "@hypit/caption";
+            readonly version: "1";
+        };
+        name: string;
+    };
+};
+declare const captionTypes: {
+    style: {
+        module: {
+            readonly name: "@hypit/caption";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    program: {
+        module: {
+            readonly name: "@hypit/caption";
+            readonly version: "1";
+        };
+        name: string;
+    };
+    timedProjection: {
+        module: {
+            readonly name: "@hypit/caption";
+            readonly version: "1";
+        };
+        name: string;
+    };
+};
+declare const captionStyleSchema: ValueSchema;
+declare const captionProgramSchema: ValueSchema;
+declare const timedCaptionProjectionSchema: ValueSchema;
+declare const captionMarkupSurfaces: readonly [{
+    readonly name: "program";
+    readonly tag: "Program";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/caption";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Assigns rendering Styles to the Script-owned CaptionDocument using authored semantic selections.";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Names the CaptionProgram.";
+        }, {
+            readonly name: "document";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/narrative";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "The complete Script-owned CaptionDocument.";
+        }, {
+            readonly name: "narrative";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/narrative";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "The semantic anchor universe used to project selections.";
+        }, {
+            readonly name: "default";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/caption";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "The default Style.";
+        }];
+        readonly children: readonly [{
+            readonly tag: "Use";
+            readonly cardinality: "many";
+            readonly summary: "Applies a complete Style by Role or semantic Selection, or supplies a word-attribute Style for a supporting family.";
+            readonly attributes: readonly [{
+                readonly name: "style";
+                readonly kind: "reference";
+                readonly required: true;
+                readonly accepts: readonly [{
+                    module: {
+                        readonly name: "@hypit/caption";
+                        readonly version: "1";
+                    };
+                    name: string;
+                }];
+                readonly summary: "The Style to apply.";
+            }, {
+                readonly name: "role";
+                readonly kind: "literal";
+                readonly required: false;
+                readonly summary: "Selects all Caption units authored for this Role.";
+            }, {
+                readonly name: "selection";
+                readonly kind: "reference";
+                readonly required: false;
+                readonly accepts: readonly [{
+                    module: {
+                        readonly name: "@hypit/narrative";
+                        readonly version: "1";
+                    };
+                    name: string;
+                }];
+                readonly summary: "Selects complete Caption units contained by a semantic Selection.";
+            }, {
+                readonly name: "attribute";
+                readonly kind: "literal";
+                readonly required: false;
+                readonly summary: "Selects display words carrying this Script-native attribute.";
+            }];
+        }, {
+            readonly tag: "Mute";
+            readonly cardinality: "many";
+            readonly summary: "Hides selected complete Caption units.";
+            readonly attributes: readonly [{
+                readonly name: "role";
+                readonly kind: "literal";
+                readonly required: false;
+                readonly summary: "Selects all Caption units authored for this Role.";
+            }, {
+                readonly name: "selection";
+                readonly kind: "reference";
+                readonly required: false;
+                readonly accepts: readonly [{
+                    module: {
+                        readonly name: "@hypit/narrative";
+                        readonly version: "1";
+                    };
+                    name: string;
+                }];
+                readonly summary: "Selects complete Caption units contained by a semantic Selection.";
+            }];
+        }];
+        readonly example: "<caption:Program id=\"captions\" document={story.caption} narrative={story} default={plain}>\n  <caption:Use role=\"GUEST\" style={guest}/>\n  <caption:Use selection={story.selection.answer} style={answer}/>\n  <caption:Mute selection={story.selection.demonstration}/>\n</caption:Program>";
+        readonly notes: readonly ["Use selects exactly one of role, selection or attribute; Mute selects exactly one of role or selection.", "For Role and Selection applications, the last matching Use in Source order selects the complete Style; properties are not merged.", "Selections may cover a phrase, a whole Segment, several Segments or the program, preserving complete display/pronunciation units.", "All Mute selections hide their words independently of Style order. They do not mute audio; the family still controls neighboring Cue lead and tail.", "Word-attribute runs are separate from Role/Selection overrides and require a family that implements them; Fine does not. Conflicting Styles on one attributed word are rejected."];
+    };
+}];
+declare const captionManifest: ModuleManifest;
+
+type MarkupReference = {
+    readonly kind: "reference";
+    readonly path: string;
+};
+type MarkupAttributeValue = string | MarkupReference;
+type StructuredText = {
+    readonly kind: "text";
+    readonly value: string;
+    readonly range: SourceRange;
+};
+type StructuredElement = {
+    readonly kind: "element";
+    readonly name: string;
+    readonly attributes: Readonly<Record<string, MarkupAttributeValue>>;
+    /** Exact ranges of literal/reference values in the opening tag. */
+    readonly attributeValueRanges?: Readonly<Record<string, SourceRange>>;
+    readonly children: readonly StructuredNode[];
+    readonly range: SourceRange;
+};
+type StructuredNode = StructuredText | StructuredElement;
+type SurfaceRecordDraft = {
+    readonly id: string;
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+    readonly range: SourceRange;
+};
+/** Source-local diagnostics are removed before the component enters semantic elaboration. */
+type SurfaceComponentDraft = AuthorComponent & {
+    readonly range: SourceRange;
+};
+type SurfaceDecodeOutput = {
+    readonly records: readonly SurfaceRecordDraft[];
+    readonly components: readonly SurfaceComponentDraft[];
+    readonly fragments: readonly GraphFragment[];
+    /** Domain-owned public identities that must be unique in the Source closure. */
+    readonly identities?: readonly AuthorSourceIdentity[];
+    /**
+     * Public source bindings contributed by this Surface invocation. Omit to
+     * publish every generated binding; use an explicit list to keep plumbing
+     * addressable inside the source without exposing it from the source.
+     */
+    readonly exports?: readonly string[];
+};
+type StructuredSurfaceInput = {
+    readonly sourceName: string;
+    readonly element: StructuredElement;
+    /**
+     * Resolve an explicitly written author reference. Imported record values are
+     * available because their source has already been compiled and admitted.
+     * A component output has a ref and Type but no compile-time Record value.
+     */
+    readonly resolveReference: (path: string) => SurfaceResolvedReference | undefined;
+    readonly resolveAsset: (request: AuthorSourceAssetRequest) => Awaitable<ResolvedAuthorSourceAsset>;
+};
+type SurfaceResolvedReference = {
+    readonly path: string;
+    readonly ref: AuthorValueRef;
+    readonly type: TypeRef;
+    readonly record?: TypedRecord;
+};
+type StructuredSurfaceHandler = (input: StructuredSurfaceInput) => Awaitable<SurfaceDecodeOutput>;
+
+declare const decodeCaptionProgramSurface: StructuredSurfaceHandler;
+
+type CaptionStyleIntent = {
+    readonly id: string;
+    readonly rendering: {
+        readonly family: string;
+        readonly parameters: CanonicalValue;
+    };
+};
+type CaptionStyleApplication = {
+    readonly id: string;
+    readonly unitIds: readonly string[];
+    readonly style: CaptionStyleIntent;
+};
+type CaptionWordStyleApplication = {
+    readonly id: string;
+    readonly attribute: string;
+    readonly wordIds: readonly string[];
+    readonly style: CaptionStyleIntent;
+};
+type CaptionMuteApplication = {
+    readonly id: string;
+    readonly unitIds: readonly string[];
+};
+type CaptionProgramRun = {
+    readonly id: string;
+    readonly styleId: string;
+    readonly unitIds: readonly string[];
+};
+type CaptionProgramWordRun = {
+    readonly id: string;
+    readonly styleId: string;
+    readonly wordIds: readonly string[];
+};
+type CaptionProgram = {
+    readonly id: string;
+    readonly documentId: string;
+    readonly styles: readonly CaptionStyleIntent[];
+    readonly runs: readonly CaptionProgramRun[];
+    /** Optional local word styles resolved from Script-native word attributes. */
+    readonly wordRuns: readonly CaptionProgramWordRun[];
+    readonly mutedUnitIds: readonly string[];
+};
+type TimedCaptionUnit = {
+    readonly unitId: string;
+    readonly startFrame: number;
+    readonly endFrameExclusive: number;
+};
+type TimedCaptionCue = {
+    readonly id: string;
+    readonly styleId: string;
+    readonly startFrame: number;
+    readonly endFrameExclusive: number;
+    readonly units: readonly TimedCaptionUnit[];
+};
+type TimedCaptionProjection = {
+    /** Semantic ProgramSpace from which every unit frame was measured. */
+    readonly spaceId: string;
+    readonly narrativeId: string;
+    readonly documentId: string;
+    readonly cues: readonly TimedCaptionCue[];
+};
+
+declare function sealCaptionStyle(value: CaptionStyleIntent): CaptionStyleIntent;
+declare function assertCaptionStyle(value: CaptionStyleIntent): void;
+declare function sealCaptionProgram(value: CaptionProgram): CaptionProgram;
+declare function assertCaptionProgram(value: CaptionProgram): void;
+declare function assertCaptionProgramForDocument(value: CaptionProgram, document: CaptionDocument): void;
+declare function resolveCaptionProgram(document: CaptionDocument, narrative: Narrative, id: string, defaultStyle: CaptionStyleIntent, applications: readonly CaptionStyleApplication[], mutes?: readonly CaptionMuteApplication[], wordApplications?: readonly CaptionWordStyleApplication[]): CaptionProgram;
+
+type MediaRational = {
+    readonly numerator: number;
+    readonly denominator: number;
+};
+type SynchronizedMedia = {
+    readonly timeline: {
+        readonly frameRate: MediaRational;
+        readonly frameCount: number;
+    };
+    readonly visual?: {
+        readonly artifact: BlobRef;
+        readonly width: number;
+        readonly height: number;
+    };
+    readonly audio?: {
+        readonly artifact: BlobRef;
+    };
+};
+
+/** One authored Script token located in one normalized Take's local frame domain. */
+type SemanticTakeToken = {
+    readonly tokenId: string;
+    readonly segmentId: string;
+    readonly text: string;
+    readonly startAnchorId: string;
+    readonly endAnchorId: string;
+    readonly startFrame: number;
+    readonly endFrameExclusive: number;
+};
+/**
+ * A self-contained semantic media product. Media bytes remain ordinary BlobRefs
+ * inside SynchronizedMedia; the authored word surface and its local frame
+ * coordinates travel with this Take instead of requiring a second Script edge.
+ */
+type SemanticTake = {
+    /** Author-visible Script identity carried through every semantic projection. */
+    readonly narrativeId: string;
+    readonly media: SynchronizedMedia;
+    readonly segment: {
+        readonly segmentId: string;
+        readonly startAnchorId: string;
+        readonly endAnchorId: string;
+        readonly startFrame: number;
+        readonly endFrameExclusive: number;
+    };
+    readonly tokens: readonly SemanticTakeToken[];
+    readonly anchors: readonly {
+        readonly identity: string;
+        readonly frame: number;
+    }[];
+};
+
+type SemanticTrackItem = {
+    readonly take: SemanticTake;
+};
+/**
+ * The continuous program skeleton. Every item is a real SemanticTake and the
+ * global frame domain is exactly their prefix sum: no gap or empty item exists.
+ */
+type SemanticTrack = {
+    readonly id: string;
+    readonly narrativeId: string;
+    readonly items: readonly SemanticTrackItem[];
+};
+
+declare function temporalizeCaptionDocument(document: CaptionDocument, semantic: SemanticTrack, program: CaptionProgram): TimedCaptionProjection;
+declare function applyCaptionMute(projection: TimedCaptionProjection, program: CaptionProgram, document: CaptionDocument): TimedCaptionProjection;
+declare function assertTimedCaptionProjection(projection: TimedCaptionProjection): void;
+
+export { CaptionTimingError, applyCaptionMute, assertCaptionDocument, assertCaptionProgram, assertCaptionProgramForDocument, assertCaptionStyle, assertCaptionUnitSubset, assertTimedCaptionProjection, captionComponent, captionManifest, captionMarkupSurfaces, captionModuleRef, captionProducers, captionProgramSchema, captionStyleSchema, captionTimingFragment, captionTypes, captionUnitsForRole, captionUnitsForSelection, captionWordsForAttribute, decodeCaptionProgramSurface, plannedCaptionTimingFragment, resolveCaptionProgram, sealCaptionProgram, sealCaptionStyle, temporalizeCaptionDocument, timedCaptionProjectionSchema };
+export type { CaptionMuteApplication, CaptionProgram, CaptionProgramRun, CaptionProgramWordRun, CaptionStyleApplication, CaptionStyleIntent, CaptionUnitSubset, CaptionWordStyleApplication, TimedCaptionCue, TimedCaptionProjection, TimedCaptionUnit };