@hypit/hypit 0.1.4 → 0.1.6

package/dist/public/sound.d.ts

@@ -0,0 +1,822 @@
+/** Opaque identity for one admitted byte resource. Equal bytes may have different identities. */
+type ResourceId = `res_${string}`;
+type RecordId = string;
+type LogicalOutputId = string;
+type NeedId = 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 ResolvedModule = {
+    readonly manifest: ModuleManifest;
+};
+type ResolvedModuleClosure = {
+    readonly format: "hypit.closure@1";
+    readonly modules: readonly ResolvedModule[];
+};
+
+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 Need = {
+    readonly id: NeedId;
+    readonly capability: CapabilityRef;
+    readonly returns: TypeRef;
+    readonly constraints: CanonicalValue;
+    readonly result: RecordId;
+};
+type NeedBinding = {
+    readonly id: NeedId;
+    readonly result: RecordId;
+};
+type BuildTarget = {
+    readonly output: LogicalOutputId;
+};
+type BuildOutputBinding = {
+    readonly output: LogicalOutputId;
+    readonly record: RecordId;
+    readonly type: TypeRef;
+};
+type ProducerStep = {
+    readonly id: StepId;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, RecordId>>;
+    readonly outputs: Readonly<Record<string, RecordId>>;
+    readonly needs: Readonly<Record<string, NeedBinding>>;
+};
+type BuildGoal = {
+    readonly record: RecordId;
+    readonly type: TypeRef;
+};
+type BuildPlan = {
+    readonly format: "hypit.plan@1";
+    readonly steps: readonly ProducerStep[];
+    readonly goals: readonly BuildGoal[];
+    /** Every Logical Output reached by the selected execution, independent of how it was supplied. */
+    readonly outputBindings: readonly BuildOutputBinding[];
+};
+type LinkedProgram = {
+    readonly closure: ResolvedModuleClosure;
+    readonly records: readonly TypedRecord[];
+};
+type StepState = {
+    readonly id: StepId;
+    readonly status: "pending" | "complete";
+};
+type InvokeProducerCommand = {
+    readonly kind: "invoke-producer";
+    readonly id: CommandId;
+    readonly step: StepId;
+    readonly producer: ProducerRef;
+    readonly inputs: Readonly<Record<string, RecordId>>;
+};
+type FulfillNeedCommand = {
+    readonly kind: "fulfill-need";
+    readonly id: CommandId;
+    readonly need: Need;
+};
+type CoreCommand = InvokeProducerCommand | FulfillNeedCommand;
+type BuildDiagnostic = {
+    readonly code: string;
+    readonly message: string;
+    readonly subject?: string;
+};
+/** Materialized read/execution view. Durable Stores persist Definition + Facts, never this object. */
+type BuildState = {
+    readonly format: "hypit.build@1";
+    readonly program: LinkedProgram;
+    readonly plan: BuildPlan;
+    readonly targets: readonly BuildTarget[];
+    readonly status: "active" | "complete" | "failed";
+    readonly records: readonly TypedRecord[];
+    readonly steps: readonly StepState[];
+    readonly needs: readonly Need[];
+    readonly outstanding: readonly CoreCommand[];
+    readonly diagnostics: readonly BuildDiagnostic[];
+};
+
+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$1<T> = T | Promise<T>;
+
+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$1<ResolvedAuthorSourceAsset>;
+};
+type SurfaceResolvedReference = {
+    readonly path: string;
+    readonly ref: AuthorValueRef;
+    readonly type: TypeRef;
+    readonly record?: TypedRecord;
+};
+type StructuredSurfaceHandler = (input: StructuredSurfaceInput) => Awaitable$1<SurfaceDecodeOutput>;
+type SurfaceAttributeKind = "identifier" | "literal" | "reference" | "expression";
+type SurfaceRecipePropertyVocabulary = {
+    readonly name: string;
+    readonly required: boolean;
+    readonly summary: string;
+    /** The author value's public structure; it contains no editor presentation. */
+    readonly schema?: ValueSchema;
+    readonly values?: readonly string[];
+    /** Decoded author default; when a schema is present this value conforms to that public structure. */
+    readonly fallback?: CanonicalValue;
+};
+type SurfaceAttributeVocabulary = {
+    readonly name: string;
+    readonly kind: SurfaceAttributeKind;
+    readonly required: boolean;
+    readonly summary: string;
+    readonly values?: readonly string[];
+    readonly accepts?: readonly TypeRef[];
+    readonly recipe?: readonly SurfaceRecipePropertyVocabulary[];
+};
+
+/** Author-time closure: bound references become ordinary graph edges at each Use. */
+type SoundStyle = {
+    readonly fragment: GraphFragment;
+    readonly bindings: Readonly<Record<string, {
+        readonly type: SurfaceResolvedReference["type"];
+        readonly ref: SurfaceResolvedReference["ref"];
+    }>>;
+};
+declare function soundStyle(fragment: GraphFragment, bindings?: SoundStyle["bindings"]): SoundStyle;
+
+type Awaitable<T> = T | Promise<T>;
+type TypeValidatorContext = {
+    readonly type: TypeRef;
+    readonly value: StoredValue;
+};
+type TypeValidatorHandler = (context: TypeValidatorContext) => void | Promise<void>;
+type ProducerHandlerResult = {
+    readonly outputs: Readonly<Record<string, StoredValue>>;
+    readonly needs: Readonly<Record<string, CanonicalValue>>;
+};
+/**
+ * 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 ProducerHandler = (context: ProducerHandlerContext) => Awaitable<ProducerHandlerResult>;
+/** Enumerable deterministic Producer handler owned by its package. */
+type ProducerFacet = {
+    readonly producer: ProducerRef;
+    readonly handler: ProducerHandler;
+};
+/** One input whose value will exist only after an upstream Build step has run. */
+type PlannedNeedInput = {
+    readonly input: string;
+    readonly record: string;
+    readonly sourceStep?: string;
+    /** Capability-owned semantic role when the value represents media, such as image or audio. */
+    readonly role?: string;
+};
+/**
+ * The complete support-relevant request known before external work starts. Values produced later
+ * are represented by input slots; their eventual StoredValues are execution bindings, not missing
+ * author intent. A slot may be a Resource or a structured value.
+ */
+type PlannedNeedSpecification = {
+    readonly constraints: CanonicalValue;
+    readonly pendingInputs: readonly PlannedNeedInput[];
+};
+/** Package-owned, presentation-neutral reading of one request. */
+type PlannedNeedPresentation = {
+    readonly fields: Readonly<Record<string, readonly CanonicalValue[]>>;
+    readonly references: Readonly<Record<string, number>>;
+};
+type PlannedNeedFacet = {
+    readonly producer: ProducerRef;
+    readonly port: string;
+    readonly capability: CapabilityRef;
+    plan(input: {
+        readonly state: BuildState;
+        readonly step: string;
+        readonly port: string;
+    }): PlannedNeedSpecification | undefined;
+    present?(specification: PlannedNeedSpecification): PlannedNeedPresentation;
+};
+/** Package-owned semantic validator. */
+type TypeValidatorFacet = {
+    readonly type: TypeRef;
+    readonly handler: TypeValidatorHandler;
+};
+/** Trusted deterministic implementation package; it selects no Provider or Runtime infrastructure. */
+type ComponentPackage = {
+    readonly producers?: readonly ProducerFacet[];
+    readonly validators?: readonly TypeValidatorFacet[];
+    /** Planning knowledge owned by the package that declares the external request. */
+    readonly plannedNeeds?: readonly PlannedNeedFacet[];
+};
+
+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;
+    };
+};
+
+type ProgramSpace = {
+    /** Author-visible identity of this film time axis. */
+    readonly id: string;
+    readonly durationSec: number;
+    readonly frameRate: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+};
+
+/** Gain and audibility are measured on the complete 48 kHz program clock. */
+type AudioSampleSpan = {
+    readonly startSample: number;
+    readonly endSampleExclusive: number;
+};
+type AudioGainPoint = {
+    readonly sample: number;
+    readonly gain: number;
+};
+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[];
+};
+
+type AudioClip = AudioPresentation & {
+    readonly id: string;
+    /** Optional domain entity implemented by this renderer Clip. */
+    readonly subjectId?: string;
+    /** Bytes only. Exact duration belongs to source.sampleFrames, not duplicated floating metadata. */
+    readonly artifact: BlobRef;
+    /** Exact audible placement in the canonical 48 kHz ProgramSpace sample domain. */
+    readonly target: {
+        readonly startSample: number;
+        readonly endSampleExclusive: number;
+    };
+    /** Exact sampling interval in one canonical 48 kHz stereo WAV Artifact. */
+    readonly source: {
+        readonly sampleFrames: number;
+        readonly startSample: number;
+        readonly endSampleExclusive: number;
+        readonly loop: boolean;
+        /** Offset inside the effective source interval used only when looping. */
+        readonly phaseSample: number;
+    };
+    readonly playbackRate: number;
+    readonly pitch: "preserve";
+    readonly gain: number;
+    readonly fadeInSamples: number;
+    readonly fadeOutSamples: number;
+};
+type AudioTrack = {
+    readonly kind: "audio";
+    /** ProgramSpace identity this terminal placement was rendered against. */
+    readonly programSpaceId: string;
+    readonly id: string;
+    readonly clips: readonly AudioClip[];
+};
+
+/**
+ * One author-selected contiguous excerpt. Script is one possible producer;
+ * generation and speech packages consume this shared value without importing
+ * Script's parser or source representation.
+ */
+type NarrativeExcerpt = {
+    readonly kind: "segment";
+    /** Author-visible `<script id>` that owns this Segment. */
+    readonly narrativeId: string;
+    readonly id: string;
+    readonly tokenStart: number;
+    readonly tokenEndExclusive: number;
+};
+
+/** 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 TimelineItem = {
+    readonly take: SemanticTake;
+    readonly startFrame: number;
+};
+/** One complete film time range, with prepared material placed where it belongs. */
+type Timeline = ProgramSpace & {
+    readonly narrativeId?: string;
+    readonly items: readonly TimelineItem[];
+};
+
+/** Exact author duration. Decimal source spelling is reduced before reaching this value. */
+type TemporalDuration = {
+    readonly unit: "frames";
+    readonly value: number;
+} | {
+    readonly unit: "milliseconds";
+    readonly value: number;
+} | {
+    readonly unit: "seconds";
+    readonly numerator: number;
+    readonly denominator: number;
+};
+/** A single projected boundary before it is resolved into ProgramSpace. */
+type TemporalInstantExpression = {
+    readonly ref: "program.start";
+    readonly offset?: TemporalDuration;
+} | {
+    readonly ref: "program.end";
+    readonly offset?: TemporalDuration;
+} | {
+    readonly ref: "selection.start";
+    readonly offset?: TemporalDuration;
+} | {
+    readonly ref: "selection.end";
+    readonly offset?: TemporalDuration;
+} | {
+    readonly ref: "segment.start";
+    readonly offset?: TemporalDuration;
+} | {
+    readonly ref: "segment.end";
+    readonly offset?: TemporalDuration;
+} | {
+    readonly ref: "moment.cue";
+    readonly offset?: TemporalDuration;
+} | {
+    readonly ref: "absolute";
+    readonly at: TemporalDuration;
+    readonly offset?: TemporalDuration;
+};
+/** Runtime dependency used to resolve an Instant. This is not its authoring authority. */
+type TemporalSource = {
+    readonly spaceId: string;
+    /** Present when the boundary originates in a Script. */
+    readonly narrativeId?: string;
+    readonly kind: "program" | "selection" | "segment" | "moment";
+    readonly id: string;
+};
+/**
+ * The author-owned inverse of one projected Instant. Runtime dependencies and
+ * author authority are deliberately separate: an expression may read an
+ * anchor while remaining writable only at its author parameter.
+ */
+type TemporalInstantAuthority = {
+    readonly kind: "semantic";
+    readonly boundary: "start" | "end" | "cue";
+} | {
+    readonly kind: "parameter";
+    readonly binding: string;
+    readonly relation: "direct" | "after-start" | "before-end";
+} | {
+    readonly kind: "fixed";
+};
+type FrameSpan = {
+    readonly startFrame: number;
+    readonly endFrameExclusive: number;
+};
+type ProjectedInstant = {
+    readonly id: string;
+    readonly subjectId: string;
+    readonly source: TemporalSource;
+    readonly projection: TemporalInstantExpression;
+    readonly authority: TemporalInstantAuthority;
+    readonly frame: number;
+};
+type ProjectedWindow = {
+    readonly id: string;
+    readonly subjectId: string;
+    readonly start: ProjectedInstant;
+    readonly end: ProjectedInstant;
+    readonly span: FrameSpan;
+};
+/** Public projection protocol composed from two independently traced Instants. */
+type TemporalWindow = ProjectedWindow;
+
+type SoundUse = {
+    readonly window: TemporalWindow;
+    readonly audio: AudioTrack;
+};
+type SoundSet = {
+    readonly uses: readonly SoundUse[];
+};
+type SoundGain = {
+    readonly gain: number;
+    readonly endGain: number;
+};
+declare function soundWindow(timeline: Timeline, window: TemporalWindow): AudioSampleSpan;
+declare function intersectAudioSpans(left: readonly AudioSampleSpan[], right: readonly AudioSampleSpan[]): AudioSampleSpan[];
+/** Default source choice is declaration order, independently of the order of Use rules. */
+declare function ordinarySound(timeline: Timeline, window: TemporalWindow, gain?: SoundGain): AudioTrack;
+/** Explicit source selection for project Styles, with its original placement/sampling retained. */
+declare function sourceSound(timeline: Timeline, window: TemporalWindow, segment: NarrativeExcerpt, gain?: SoundGain): AudioTrack;
+declare function appendSoundUse(set: SoundSet, window: TemporalWindow, audio: AudioTrack): SoundSet;
+/** Resolve presentation coverage without changing original targets, source clocks or envelopes. */
+declare function resolveSound(timeline: Timeline, id: string, set: SoundSet): AudioTrack;
+
+declare const soundComponent: ComponentPackage;
+
+declare const decodeSoundTrackSurface: StructuredSurfaceHandler;
+declare const ordinarySoundFragment: GraphFragment;
+declare const decodeSoundStyleSurface: StructuredSurfaceHandler;
+
+declare const soundModuleRef: {
+    readonly name: "@hypit/sound";
+    readonly version: "1";
+};
+declare const soundTypes: Record<"style" | "set" | "header" | "gain", TypeRef>;
+declare const soundProducers: Record<"create" | "append" | "resolve" | "ordinary", ProducerRef>;
+declare const ordinaryInputs: {
+    name: string;
+    type: TypeRef;
+}[];
+declare const soundManifest: ModuleManifest;
+declare const soundMarkupSurfaces: readonly [{
+    readonly name: "style";
+    readonly tag: "Style";
+    readonly mode: "structured";
+    readonly outputs: readonly [TypeRef, TypeRef];
+    readonly vocabulary: {
+        readonly summary: "Presents existing Timeline sound, choosing the last declared active audio source. Gain may change linearly across each Use.";
+        readonly example: "<sound:Style id=\"fade-in\" gain=\"0\" end-gain=\"1\"/>";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Style name.";
+        }, {
+            readonly name: "gain";
+            readonly kind: "literal";
+            readonly required: false;
+            readonly summary: "Linear gain at the beginning of a Use; defaults to 1. Zero silences the presentation.";
+        }, {
+            readonly name: "end-gain";
+            readonly kind: "literal";
+            readonly required: false;
+            readonly summary: "Linear gain at the end of a Use; defaults to gain. The original Use interval owns the ramp.";
+        }];
+    };
+}, {
+    readonly name: "track";
+    readonly tag: "Track";
+    readonly mode: "structured";
+    readonly outputs: readonly [{
+        module: {
+            readonly name: "@hypit/composition";
+            readonly version: "1";
+        };
+        name: string;
+    }, TypeRef, TypeRef, {
+        module: {
+            readonly name: "@hypit/temporal";
+            readonly version: "1";
+        };
+        name: string;
+    }, {
+        module: {
+            readonly name: "@hypit/temporal";
+            readonly version: "1";
+        };
+        name: string;
+    }, {
+        module: {
+            readonly name: "@hypit/temporal";
+            readonly version: "1";
+        };
+        name: string;
+    }, {
+        module: {
+            readonly name: "@hypit/temporal";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Presents Timeline sound through ordered Uses. Later Uses replace earlier presentation locally without restarting source playback or gain curves.";
+        readonly example: "<sound:Track id=\"voice\" timeline={program.timeline}><sound:Use style={normal}/><sound:Use at=\"0f\" for=\"2s\" style={fade-in}/></sound:Track>";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Sound presentation name.";
+        }, {
+            readonly name: "timeline";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/timeline";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "Complete film time and placed sources.";
+        }];
+        readonly children: readonly [{
+            readonly tag: "Use";
+            readonly cardinality: "many";
+            readonly summary: "Last matching Use wins, including silence. No time selector covers the complete Timeline.";
+            readonly attributes: readonly [{
+                readonly name: "id";
+                readonly kind: "identifier";
+                readonly required: false;
+                readonly summary: "Optional occurrence identity.";
+            }, {
+                readonly name: "style";
+                readonly kind: "reference";
+                readonly required: true;
+                readonly accepts: readonly [TypeRef];
+                readonly summary: "Ordinary or project-authored sound Style. Explicit source bindings belong to the Style.";
+            }, ...SurfaceAttributeVocabulary[]];
+        }];
+    };
+}];
+
+export { appendSoundUse, decodeSoundStyleSurface, decodeSoundTrackSurface, intersectAudioSpans, ordinaryInputs, ordinarySound, ordinarySoundFragment, resolveSound, soundComponent, soundManifest, soundMarkupSurfaces, soundModuleRef, soundProducers, soundStyle, soundTypes, soundWindow, sourceSound };
+export type { SoundGain, SoundSet, SoundStyle, SoundUse };