@hypit/hypit 0.1.3 → 0.1.5

package/dist/public/performance.d.ts

@@ -0,0 +1,1590 @@
+/** 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 PerformanceStyle = {
+    readonly fragment: GraphFragment;
+    readonly bindings: Readonly<Record<string, {
+        readonly type: SurfaceResolvedReference["type"];
+        readonly ref: SurfaceResolvedReference["ref"];
+    }>>;
+};
+declare function performanceStyle(fragment: GraphFragment, bindings?: PerformanceStyle["bindings"]): PerformanceStyle;
+
+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 FontArtifactRef = {
+    /** One logical face may be split into independently addressed Unicode-range sources. */
+    readonly sources: readonly {
+        readonly artifact: BlobRef;
+        readonly unicodeRange?: string;
+    }[];
+    readonly weight: number;
+    readonly style: "normal" | "italic" | "oblique";
+};
+type CompositableSurfaceRef = {
+    readonly artifact: BlobRef;
+    readonly width: number;
+    readonly height: number;
+    readonly colorSpace: "srgb";
+    readonly alphaMode: "opaque" | "straight";
+    readonly timing: {
+        readonly kind: "still";
+    } | {
+        readonly kind: "frames";
+        readonly frameRate: {
+            readonly numerator: number;
+            readonly denominator: number;
+        };
+        readonly frameCount: number;
+    };
+};
+
+type ProgramSpace = {
+    /** Author-visible identity of this film time axis. */
+    readonly id: string;
+    readonly durationSec: number;
+    readonly frameRate: {
+        readonly numerator: number;
+        readonly denominator: number;
+    };
+};
+
+/** Structural style vocabulary. Renderer programs own their richer layout and code formats. */
+declare const VISUAL_IR_V1: "hypit.visual-ir@1";
+
+type FrameSpan$1 = {
+    readonly startFrame: number;
+    readonly endFrameExclusive: number;
+};
+/** One inline style declaration inside a Present-owned element tree. */
+type VisualStyleDeclaration = {
+    readonly name: string;
+    readonly value: string | number;
+};
+type VisualAttribute = {
+    readonly name: string;
+    readonly value: string;
+};
+type VisualEasing = "linear" | "ease-in" | "ease-out" | "ease-in-out";
+/**
+ * A frame-exact, code-free animation owned by one element. Keyframe offsets
+ * are relative to the containing Present and therefore remain deterministic
+ * under local and hosted rendering.
+ */
+type VisualKeyframe = {
+    readonly atFrame: number;
+    readonly easing?: VisualEasing;
+    readonly style: readonly VisualStyleDeclaration[];
+};
+type VisualAnimation = {
+    readonly keyframes: readonly VisualKeyframe[];
+};
+type VisualElementBase = {
+    readonly id: string;
+    readonly parent?: string;
+    readonly order: number;
+    readonly style: readonly VisualStyleDeclaration[];
+    readonly attributes?: readonly VisualAttribute[];
+    readonly animation?: VisualAnimation;
+};
+type VisualBoxElement = VisualElementBase & {
+    readonly kind: "box";
+};
+/** A renderer-interpreted local program. Its format and payload belong to its rendering package. */
+type VisualProgramElement = VisualElementBase & {
+    readonly kind: "program";
+    readonly program: {
+        readonly format: string;
+        readonly payload: {
+            readonly [key: string]: CanonicalValue;
+        };
+        readonly artifacts: readonly BlobRef[];
+    };
+};
+/** A strictly local two-input mask. Both roots are direct owned children in the same Present. */
+type VisualMaskElement = VisualElementBase & {
+    readonly kind: "mask";
+    readonly mode: "alpha" | "luminance";
+    readonly maskElement: string;
+    readonly contentElement: string;
+};
+type VisualTextElement = VisualElementBase & {
+    readonly kind: "text";
+    readonly text: string;
+    /** Exact ordered fallback faces. Terminal Visual IR never depends on environment fonts. */
+    readonly fonts: readonly FontArtifactRef[];
+    /**
+     * Ordered glyph Paint, in the same vocabulary Text Flow uses.
+     *
+     * Style alone can only say `-webkit-text-stroke`, which centres an outline on the glyph edge and
+     * therefore spends half its width inside the letter. An outline that is asked to sit outside the
+     * letter cannot be expressed that way at all. Declaring the Paint instead lets the renderer build
+     * the placement that was asked for, and `stroke` before `fill` orders them.
+     */
+    readonly paints?: readonly VisualTextPaintLayer[];
+};
+type VisualTextDirection = "auto" | "ltr" | "rtl";
+type VisualTextWritingMode = "horizontal-tb" | "vertical-rl" | "vertical-lr";
+type VisualTextTypography = {
+    /** Exact ordered faces. Author-package prototype families must resolve before this boundary. */
+    readonly fonts: readonly FontArtifactRef[];
+    readonly sizePx: number;
+    readonly weight: number;
+    readonly style: "normal" | "italic" | "oblique";
+    readonly axes: readonly {
+        readonly tag: string;
+        readonly value: number;
+    }[];
+    readonly features: readonly {
+        readonly tag: string;
+        readonly enabled: boolean;
+    }[];
+    readonly synthesis: "none" | "weight" | "style" | "weight-style";
+    readonly kerning: "auto" | "normal" | "none";
+    readonly trackingPx: number;
+    readonly wordSpacingPx: number;
+    readonly lineHeight: number;
+    readonly language?: string;
+    readonly direction: VisualTextDirection;
+    readonly writingMode: VisualTextWritingMode;
+    readonly baselineShiftPx: number;
+    readonly tabSize: number;
+    readonly indentationPx: number;
+    readonly paragraphBeforePx: number;
+    readonly paragraphAfterPx: number;
+    readonly transform: "none" | "uppercase" | "lowercase" | "capitalize";
+    readonly variantCaps: "normal" | "small-caps" | "all-small-caps";
+    readonly verticalAlign: "baseline" | "super" | "sub";
+    readonly decorations: readonly VisualTextDecoration[];
+    readonly cjk: {
+        readonly textSpacing: "normal" | "none";
+        readonly punctuationTrim: "none" | "start" | "end" | "adjacent" | "all";
+    };
+};
+/** Explicit run override. Omitted properties inherit; authored text never changes. */
+type VisualTextRunStyle = {
+    readonly typography?: Partial<VisualTextTypography>;
+    readonly paints?: readonly VisualTextPaintLayer[];
+};
+type VisualTextInline = {
+    readonly kind: "text";
+    readonly id: string;
+    readonly text: string;
+    readonly style?: VisualTextRunStyle;
+    readonly language?: string;
+    readonly direction?: VisualTextDirection;
+} | {
+    readonly kind: "break";
+    readonly id: string;
+};
+type VisualTextDocument = {
+    readonly paragraphs: readonly {
+        readonly id: string;
+        readonly inlines: readonly VisualTextInline[];
+        readonly style?: VisualTextRunStyle;
+    }[];
+};
+type VisualColorPaint = {
+    readonly kind: "solid";
+    readonly color: string;
+} | {
+    readonly kind: "linear-gradient";
+    readonly angleDeg: number;
+    readonly stops: readonly {
+        readonly offset: number;
+        readonly color: string;
+        readonly opacity: number;
+    }[];
+} | {
+    readonly kind: "radial-gradient";
+    readonly center: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly stops: readonly {
+        readonly offset: number;
+        readonly color: string;
+        readonly opacity: number;
+    }[];
+};
+type VisualTextDecoration = {
+    readonly line: "underline" | "overline" | "line-through";
+    readonly paint: VisualColorPaint;
+    readonly style: "solid" | "double" | "dotted" | "dashed" | "wavy";
+    readonly thicknessPx?: number;
+    readonly offsetPx?: number;
+    readonly skipInk: boolean;
+};
+type VisualTextBoxDecoration = {
+    readonly fill?: VisualColorPaint;
+    readonly border?: {
+        readonly paint: VisualColorPaint;
+        readonly widthsPx: {
+            readonly top: number;
+            readonly right: number;
+            readonly bottom: number;
+            readonly left: number;
+        };
+        readonly style: "solid" | "dashed" | "dotted";
+    };
+    readonly paddingPx: {
+        readonly top: number;
+        readonly right: number;
+        readonly bottom: number;
+        readonly left: number;
+    };
+    readonly radiiPx: {
+        readonly topLeft: number;
+        readonly topRight: number;
+        readonly bottomRight: number;
+        readonly bottomLeft: number;
+    };
+    readonly shadows: readonly {
+        readonly paint: VisualColorPaint;
+        readonly offsetX: number;
+        readonly offsetY: number;
+        readonly blurPx: number;
+        readonly spreadPx: number;
+    }[];
+    readonly tail?: {
+        readonly side: "top" | "right" | "bottom" | "left";
+        readonly offset: number;
+        readonly widthPx: number;
+        readonly heightPx: number;
+        readonly paint: VisualColorPaint;
+    };
+};
+type VisualTextPaintTarget = "frame" | "content" | "paragraph" | "line" | "run" | "word" | "grapheme";
+/** Ordered renderer-neutral text Paint. Repetition and array order are semantic. */
+type VisualTextPaintLayer = {
+    readonly kind: "fill";
+    readonly paint: VisualColorPaint;
+} | {
+    readonly kind: "stroke";
+    readonly paint: VisualColorPaint;
+    readonly widthPx: number;
+    readonly placement: "inside" | "center" | "outside";
+} | {
+    readonly kind: "shadow";
+    readonly paint: VisualColorPaint;
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly blurPx: number;
+    readonly spreadPx: number;
+} | {
+    readonly kind: "glow";
+    readonly paint: VisualColorPaint;
+    readonly blurPx: number;
+    readonly spreadPx: number;
+} | {
+    readonly kind: "box";
+    readonly target: VisualTextPaintTarget;
+    readonly continuity: "isolated" | "joined";
+    readonly decoration: VisualTextBoxDecoration;
+};
+type VisualTextFlow = {
+    readonly form: {
+        readonly kind: "point";
+        readonly anchorInline: "start" | "center" | "end";
+        readonly anchorBlock: "start" | "center" | "end";
+    } | {
+        readonly kind: "area";
+    };
+    readonly inlineSize: "hug" | "fixed";
+    readonly blockSize: "hug" | "fixed";
+    readonly paddingPx: {
+        readonly inlineStart: number;
+        readonly inlineEnd: number;
+        readonly blockStart: number;
+        readonly blockEnd: number;
+    };
+    readonly inlineAlign: "start" | "center" | "end" | "justify";
+    readonly blockAlign: "start" | "center" | "end";
+    readonly wrap: "none" | "word" | "grapheme";
+    readonly overflow: "visible" | "clip" | "ellipsis" | "shrink";
+    readonly maxLines?: number;
+    readonly minimumScale?: number;
+    readonly clipToFrame: boolean;
+    readonly columns: number;
+    readonly columnGapPx: number;
+    readonly metricEdge: "line-box" | "cap-height" | "ink";
+};
+type VisualTextSequenceAnimation = {
+    readonly id: string;
+    readonly unit: "paragraph" | "line" | "run" | "word" | "grapheme";
+    readonly range: {
+        readonly start: number;
+        readonly endExclusive: number;
+    };
+    readonly order: "forward" | "reverse" | "random";
+    readonly startFrame: number;
+    readonly unitDurationFrames: number;
+    readonly staggerFrames: number;
+    readonly cycles: number;
+    readonly seed?: number;
+    readonly keyframes: readonly {
+        readonly atProgress: number;
+        readonly easing?: VisualEasing;
+        readonly style: readonly VisualStyleDeclaration[];
+    }[];
+};
+/** Exact terminal text flow. It contains no author Style/Recipe reference or renderer callback. */
+type VisualTextFlowElement = VisualElementBase & {
+    readonly kind: "text-flow";
+    readonly document: VisualTextDocument;
+    readonly typography: VisualTextTypography;
+    readonly paints: readonly VisualTextPaintLayer[];
+    readonly flow: VisualTextFlow;
+    readonly sequences: readonly VisualTextSequenceAnimation[];
+};
+type VisualVectorPathCommand = {
+    readonly kind: "move" | "line";
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly kind: "quadratic";
+    readonly controlX: number;
+    readonly controlY: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly kind: "cubic";
+    readonly control1X: number;
+    readonly control1Y: number;
+    readonly control2X: number;
+    readonly control2Y: number;
+    readonly x: number;
+    readonly y: number;
+} | {
+    readonly kind: "close";
+};
+type VisualPathTextElement = VisualElementBase & {
+    readonly kind: "path-text";
+    readonly document: VisualTextDocument;
+    readonly typography: VisualTextTypography;
+    readonly paints: readonly VisualTextPaintLayer[];
+    readonly path: readonly VisualVectorPathCommand[];
+    readonly side: "left" | "right";
+    readonly orientation: "follow" | "upright";
+    readonly startMarginPx: number;
+    readonly endMarginPx: number;
+    readonly align: "start" | "center" | "end";
+    readonly reverse: boolean;
+    readonly overflow: "visible" | "clip";
+    readonly sequences: readonly VisualTextSequenceAnimation[];
+    readonly marginAnimation?: {
+        readonly keyframes: readonly {
+            readonly atFrame: number;
+            readonly startMarginPx: number;
+            readonly easing?: VisualEasing;
+        }[];
+    };
+};
+type VisualSamplingRational = {
+    readonly numerator: number;
+    readonly denominator: number;
+};
+/**
+ * One exact piece of a timed visual's source-time function. Target frames are
+ * relative to the containing Present. A gap means the material is invisible.
+ */
+type VisualSamplingSegment = {
+    readonly target: FrameSpan$1;
+    /** Absolute source-frame position at target.startFrame. */
+    readonly sourceFrame: VisualSamplingRational;
+    /** Source frames advanced per Program frame; zero is an exact held frame. */
+    readonly rate: VisualSamplingRational;
+    readonly loop?: FrameSpan$1;
+};
+type VisualTimedSampling = {
+    readonly sourceFrameRate: VisualSamplingRational;
+    readonly sourceFrameCount: number;
+    readonly segments: readonly VisualSamplingSegment[];
+};
+type VisualMediaElement = VisualElementBase & {
+    readonly kind: "image" | "video";
+    readonly artifact: BlobRef;
+    /** Exact frame-domain mapping for timed media. */
+    readonly sampling?: VisualTimedSampling;
+    readonly muted?: boolean;
+};
+/** A package-materialized visual surface with content-bound compositing metadata, not an untyped media guess. */
+type VisualSurfaceElement = VisualElementBase & {
+    readonly kind: "surface";
+    readonly surface: CompositableSurfaceRef;
+    readonly sampling?: VisualTimedSampling;
+};
+/**
+ * Structural elements and explicit renderer programs compose in one owned tree.
+ *
+ * A Present holds exactly one root; everything else names a `parent`, which can be a box,
+ * mask or program. **Position is measured from that parent, not from the Canvas.** A component that computes
+ * its layout in Canvas pixels and then nests its elements has to subtract the parent's own origin,
+ * or every child lands offset by it — which draws without complaint and is wrong by exactly the
+ * distance the parent sits from the corner.
+ */
+type VisualElement = VisualBoxElement | VisualProgramElement | VisualMaskElement | VisualTextElement | VisualTextFlowElement | VisualPathTextElement | VisualMediaElement | VisualSurfaceElement;
+type VisualPresent = {
+    readonly id: string;
+    /** Optional domain entity implemented by this renderer Present. */
+    readonly subjectId?: string;
+    readonly span: FrameSpan$1;
+    /** Optional visible subranges in program frames; span remains the animation and sampling origin. */
+    readonly visibility?: readonly FrameSpan$1[];
+    /** Absolute paint position for this Present, not for its authoring Track. */
+    readonly stacking: {
+        readonly order: number;
+        readonly tieBreak: string;
+    };
+    readonly elements: readonly VisualElement[];
+};
+type VisualTrack = {
+    readonly kind: "visual";
+    /** ProgramSpace identity this terminal placement was rendered against. */
+    readonly programSpaceId: string;
+    /** The one terminal visual language shared by official video components. */
+    readonly visualIr: typeof VISUAL_IR_V1;
+    readonly id: string;
+    /** Author-owned contributions that Composition may interleave by absolute z. */
+    readonly presents: readonly VisualPresent[];
+};
+
+/** 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 PerformanceUse = {
+    readonly window: TemporalWindow;
+    readonly visual: VisualTrack;
+};
+type PerformanceSet = {
+    readonly uses: readonly PerformanceUse[];
+};
+declare function appendPerformanceUse(set: PerformanceSet, window: TemporalWindow, visual: VisualTrack): PerformanceSet;
+declare function intersectVisibility(left: readonly FrameSpan$1[], right: readonly FrameSpan$1[]): FrameSpan$1[];
+declare function performancePresentId(useId: string, presentId: string): string;
+/** Keep original animation/sample origins. Only the visibility mask changes. */
+declare function resolvePerformance(timeline: Timeline, id: string, set: PerformanceSet): VisualTrack;
+
+type CanvasSpace = {
+    readonly widthPx: number;
+    readonly heightPx: number;
+    readonly origin: "top-left";
+    readonly xDirection: "right";
+    readonly yDirection: "down";
+    readonly pixelAspect: "square";
+};
+type SpatialFrame = {
+    readonly xPx: number;
+    readonly yPx: number;
+    readonly widthPx: number;
+    readonly heightPx: number;
+};
+type SpatialPathCommand = {
+    readonly kind: "move";
+    readonly xPx: number;
+    readonly yPx: number;
+} | {
+    readonly kind: "line";
+    readonly xPx: number;
+    readonly yPx: number;
+} | {
+    readonly kind: "quadratic";
+    readonly controlX: number;
+    readonly controlY: number;
+    readonly xPx: number;
+    readonly yPx: number;
+} | {
+    readonly kind: "cubic";
+    readonly control1X: number;
+    readonly control1Y: number;
+    readonly control2X: number;
+    readonly control2Y: number;
+    readonly xPx: number;
+    readonly yPx: number;
+} | {
+    readonly kind: "close";
+};
+type SpatialPath = {
+    readonly commands: readonly SpatialPathCommand[];
+};
+type IntrinsicExtent = {
+    readonly widthPx: number;
+    readonly heightPx: number;
+};
+type NormalizedPoint = {
+    readonly x: number;
+    readonly y: number;
+};
+type ContentFit = {
+    readonly sizing: "contain" | "cover" | "fit-width" | "fit-height" | "native" | "scale-down" | "stretch";
+    readonly framePoint: NormalizedPoint;
+    readonly contentPoint: NormalizedPoint;
+    readonly offsetPx: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly constraint: "bounded" | "free";
+};
+
+/** Intrinsic visual truth resolved before Media authoring; never a Provider or lineage envelope. */
+type MediaVisualSource = {
+    readonly kind: "still";
+    readonly artifact: BlobRef;
+    readonly extent: IntrinsicExtent;
+} | {
+    readonly kind: "timed";
+    readonly artifact: BlobRef;
+    readonly extent: IntrinsicExtent;
+    readonly frameRate: MediaRational;
+    readonly frameCount: number;
+    readonly audio?: {
+        readonly artifact: BlobRef;
+        readonly sampleFrames: number;
+    };
+} | {
+    readonly kind: "surface";
+    readonly surface: CompositableSurfaceRef;
+    readonly extent: IntrinsicExtent;
+};
+type MediaVisualTrim = {
+    readonly startFrame: number;
+    readonly endFrameExclusive: number;
+};
+type MediaVisualOccupancy = {
+    readonly mode: "once";
+    readonly align: "start" | "end";
+} | {
+    readonly mode: "hold";
+    readonly align: "start" | "end";
+} | {
+    readonly mode: "loop";
+    readonly align: "start" | "end";
+} | {
+    readonly mode: "stretch";
+};
+type MediaGradientStop = {
+    readonly offset: number;
+    readonly color: string;
+};
+type MediaPaint = {
+    readonly kind: "solid";
+    readonly color: string;
+} | {
+    readonly kind: "linear-gradient";
+    readonly angleDeg: number;
+    readonly stops: readonly MediaGradientStop[];
+} | {
+    readonly kind: "radial-gradient";
+    readonly center: {
+        readonly x: number;
+        readonly y: number;
+    };
+    readonly stops: readonly MediaGradientStop[];
+};
+type MediaSampleAppearance = {
+    readonly opacity: number;
+    readonly filter: {
+        readonly blurPx: number;
+        readonly brightness: number;
+        readonly contrast: number;
+        readonly saturation: number;
+    };
+};
+type MediaSamplingKeyframe = {
+    /** Normalized position inside the resolved Item/member envelope. */
+    readonly atProgress: number;
+    readonly zoom: number;
+    readonly offsetX: number;
+    readonly offsetY: number;
+    readonly rotationDeg: number;
+    readonly easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+};
+type MediaSamplingMotion = {
+    readonly keyframes: readonly MediaSamplingKeyframe[];
+};
+type MediaPaintLayerProgram = {
+    readonly id: string;
+    readonly kind: "paint";
+    readonly paint: MediaPaint;
+    readonly opacity: number;
+};
+type MediaSampleLayerProgram = {
+    readonly id: string;
+    readonly kind: "sample";
+    readonly sampling?: VisualTimedSampling;
+    readonly source: MediaVisualSource;
+    readonly fit: ContentFit;
+    readonly trim?: MediaVisualTrim;
+    readonly occupancy?: MediaVisualOccupancy;
+    readonly appearance: MediaSampleAppearance;
+    readonly samplingMotion?: MediaSamplingMotion;
+};
+type MediaLayerProgram = MediaPaintLayerProgram | MediaSampleLayerProgram;
+type MediaSampleLayerSpec = {
+    readonly id: string;
+    readonly trim?: MediaVisualTrim;
+    readonly occupancy?: MediaVisualOccupancy;
+    readonly appearance: MediaSampleAppearance;
+    readonly samplingMotion?: MediaSamplingMotion;
+};
+type MediaLayerSet = {
+    readonly layers: readonly MediaLayerProgram[];
+};
+type MediaPadding = {
+    readonly topPx: number;
+    readonly rightPx: number;
+    readonly bottomPx: number;
+    readonly leftPx: number;
+};
+type MediaFrameClip = {
+    readonly kind: "none";
+} | {
+    readonly kind: "frame";
+} | {
+    readonly kind: "rounded";
+    readonly radiusPx: number;
+} | {
+    readonly kind: "path";
+    readonly path: SpatialPath;
+};
+type MediaFramePresentation = {
+    readonly clip: MediaFrameClip;
+    readonly padding: MediaPadding;
+    readonly border?: {
+        readonly widthPx: number;
+        readonly style: "solid" | "dashed" | "dotted";
+        readonly color: string;
+    };
+    readonly shadows: readonly {
+        readonly offsetX: number;
+        readonly offsetY: number;
+        readonly blurPx: number;
+        readonly spreadPx: number;
+        readonly color: string;
+    }[];
+};
+type MediaMotionDirection = "left" | "right" | "up" | "down";
+type MediaEdgeMotion = {
+    readonly operator: "fade" | "slide" | "scale" | "pop" | "bounce" | "blur-reveal" | "wipe" | "flip" | "spin";
+    readonly durationFrames: number;
+    readonly easing: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+    readonly direction?: MediaMotionDirection;
+    readonly amount?: number;
+    readonly origin?: "outside-canvas";
+};
+type MediaSustainMotion = {
+    readonly operator: "float" | "breathe" | "pulse" | "wobble" | "shake" | "drift";
+    readonly amount: number;
+    readonly cycles: number;
+    readonly direction?: MediaMotionDirection;
+};
+type MediaLifecycleMotion = {
+    readonly enter?: MediaEdgeMotion;
+    readonly sustain: readonly MediaSustainMotion[];
+    readonly exit?: MediaEdgeMotion;
+};
+type MediaSourceAudioProjection = {
+    readonly fromLayer: string;
+    readonly gain: number;
+};
+type MediaSoundSource = {
+    readonly artifact: BlobRef;
+    readonly sampleFrames: number;
+};
+type MediaSoundTrigger = {
+    readonly kind: "enter";
+} | {
+    readonly kind: "exit";
+} | {
+    readonly kind: "handoff";
+    readonly handoffId: string;
+};
+type MediaSoundSpec = {
+    readonly id: string;
+    readonly trigger: MediaSoundTrigger;
+    readonly gain: number;
+};
+type MediaSoundEvent = MediaSoundSpec & {
+    readonly source: MediaSoundSource;
+};
+type MediaSoundSet = {
+    readonly sounds: readonly MediaSoundEvent[];
+};
+type MediaAbsoluteStacking = {
+    readonly order: number;
+    readonly tieBreak: string;
+};
+type MediaItemSpec = {
+    readonly id: string;
+    readonly presentation: MediaFramePresentation;
+    readonly motion: MediaLifecycleMotion;
+    readonly stackingOrder: number;
+    readonly sourceAudio?: MediaSourceAudioProjection;
+};
+type MediaItemProgram = {
+    readonly id: string;
+    /** Author-owned Item realized by this externally projected window. */
+    readonly subjectId: string;
+    readonly span: FrameSpan$1;
+    readonly frame: SpatialFrame;
+    readonly presentation: MediaFramePresentation;
+    readonly layers: readonly MediaLayerProgram[];
+    readonly motion: MediaLifecycleMotion;
+    readonly stacking: MediaAbsoluteStacking;
+    readonly sourceAudio?: MediaSourceAudioProjection;
+    readonly sounds: readonly MediaSoundEvent[];
+};
+type MediaHandoffOperator = "cut" | "crossfade" | "push" | "wipe" | "cover" | "page-turn";
+type MediaHandoffProgram = {
+    readonly id: string;
+    readonly fromMemberId: string;
+    readonly toMemberId: string;
+    readonly operator: MediaHandoffOperator;
+    readonly durationFrames: number;
+    readonly boundaryRatio: number;
+    readonly span: FrameSpan$1;
+    readonly direction?: MediaMotionDirection;
+    readonly audio: "cut" | "crossfade";
+};
+type MediaSequenceMemberProgram = {
+    readonly id: string;
+    readonly activationFrame: number;
+    readonly logicalSpan: FrameSpan$1;
+    readonly visualSpan: FrameSpan$1;
+    readonly layers: readonly MediaLayerProgram[];
+    readonly sourceAudio?: MediaSourceAudioProjection;
+};
+type MediaSequenceProgram = {
+    readonly id: string;
+    readonly span: FrameSpan$1;
+    readonly terminalFrame: number;
+    readonly frame: SpatialFrame;
+    readonly presentation: MediaFramePresentation;
+    readonly members: readonly MediaSequenceMemberProgram[];
+    readonly handoffs: readonly MediaHandoffProgram[];
+    readonly motion: MediaLifecycleMotion;
+    readonly stacking: MediaAbsoluteStacking;
+    readonly sounds: readonly MediaSoundEvent[];
+};
+type MediaTrackHeader = {
+    readonly id: string;
+};
+type MediaTrackSet = {
+    readonly items: readonly MediaItemProgram[];
+    readonly sequences: readonly MediaSequenceProgram[];
+};
+
+/** Component entry point: timing has already been projected by @hypit/temporal. */
+declare function appendMediaItem(set: MediaTrackSet, header: MediaTrackHeader, timeline: Timeline, canvas: CanvasSpace, layers: MediaLayerSet, frame: MediaItemProgram["frame"], spec: MediaItemSpec, sounds: MediaSoundSet, window: ProjectedWindow): MediaTrackSet;
+
+declare function ordinaryPerformance(input: {
+    timeline: Timeline;
+    canvas: CanvasSpace;
+    window: TemporalWindow;
+    frame: SpatialFrame;
+    fit: ContentFit;
+    sample: MediaSampleLayerSpec;
+    spec: MediaItemSpec;
+}): VisualTrack;
+declare const performanceComponent: ComponentPackage;
+
+declare const ordinaryPerformanceFragment: GraphFragment;
+declare const decodePerformanceStyleSurface: StructuredSurfaceHandler;
+declare const decodePerformanceTrackSurface: StructuredSurfaceHandler;
+
+declare const performanceModuleRef: {
+    readonly name: "@hypit/performance";
+    readonly version: "1";
+};
+declare const performanceTypes: Record<"style" | "set" | "header", TypeRef>;
+declare const performanceProducers: Record<"create" | "append" | "resolve" | "ordinary", ProducerRef>;
+declare const ordinaryInputs: ({
+    name: string;
+    type: {
+        module: {
+            readonly name: "@hypit/timeline";
+            readonly version: "1";
+        };
+        name: string;
+    };
+} | {
+    name: string;
+    type: {
+        module: {
+            readonly name: "@hypit/spatial";
+            readonly version: "1";
+        };
+        name: string;
+    };
+} | {
+    name: string;
+    type: {
+        module: {
+            readonly name: "@hypit/temporal";
+            readonly version: "1";
+        };
+        name: string;
+    };
+} | {
+    name: string;
+    type: {
+        module: {
+            readonly name: "@hypit/media-track";
+            readonly version: "1";
+        };
+        name: string;
+    };
+})[];
+declare const performanceManifest: ModuleManifest;
+declare const performanceMarkupSurfaces: readonly [{
+    readonly name: "style";
+    readonly tag: "Style";
+    readonly mode: "structured";
+    readonly outputs: readonly [TypeRef, {
+        module: {
+            readonly name: "@hypit/spatial";
+            readonly version: "1";
+        };
+        name: string;
+    }, {
+        module: {
+            readonly name: "@hypit/media-track";
+            readonly version: "1";
+        };
+        name: string;
+    }, {
+        module: {
+            readonly name: "@hypit/media-track";
+            readonly version: "1";
+        };
+        name: string;
+    }];
+    readonly vocabulary: {
+        readonly summary: "Defines ordinary A-roll framing using Media appearance properties.";
+        readonly example: "<performance:Style id=\"full\" frame={layout.full} appearance={recipes.media.presenter}/>";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "Style name.";
+        }, {
+            readonly name: "frame";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/spatial";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "Destination Frame.";
+        }, {
+            readonly name: "appearance";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/svs";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "Media appearance Recipe: fitting, clipping, border and color.";
+        }];
+    };
+}, {
+    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 footage through ordered Use rules, retaining source playback time.";
+        readonly example: "<performance:Track id=\"presenter\" timeline={program.timeline} canvas={canvas}><performance:Use style={full}/></performance:Track>";
+        readonly attributes: readonly [{
+            readonly name: "id";
+            readonly kind: "identifier";
+            readonly required: true;
+            readonly summary: "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: "Placed material and film time.";
+        }, {
+            readonly name: "canvas";
+            readonly kind: "reference";
+            readonly required: true;
+            readonly accepts: readonly [{
+                module: {
+                    readonly name: "@hypit/spatial";
+                    readonly version: "1";
+                };
+                name: string;
+            }];
+            readonly summary: "Composition Canvas.";
+        }];
+        readonly children: readonly [{
+            readonly tag: "Use";
+            readonly cardinality: "many";
+            readonly summary: "Last matching Use wins. No time selector means the whole 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 presentation Style.";
+            }, ...SurfaceAttributeVocabulary[]];
+        }];
+    };
+}];
+
+type ItemArguments = Parameters<typeof appendMediaItem>;
+type PerformanceInput = {
+    set: ItemArguments[0];
+    header: ItemArguments[1];
+    timeline: ItemArguments[2];
+    canvas: ItemArguments[3];
+    layers: ItemArguments[4];
+    frame: ItemArguments[5];
+    spec: ItemArguments[6];
+    sounds: ItemArguments[7];
+    window: ItemArguments[8];
+};
+/** One framed unit and lifecycle containing all selected performance spans. */
+declare function appendMediaPerformance(input: PerformanceInput, fit: ContentFit, sample: MediaSampleLayerSpec): MediaTrackSet;
+
+export { appendMediaPerformance, appendPerformanceUse, decodePerformanceStyleSurface, decodePerformanceTrackSurface, intersectVisibility, ordinaryInputs, ordinaryPerformance, ordinaryPerformanceFragment, performanceComponent, performanceManifest, performanceMarkupSurfaces, performanceModuleRef, performancePresentId, performanceProducers, performanceStyle, performanceTypes, resolvePerformance };
+export type { PerformanceSet, PerformanceStyle, PerformanceUse };