@hypit/hypit 0.0.1 → 0.1.1

package/packages/text/src/svs.ts

@@ -0,0 +1,189 @@
+import type { SvsRecipe } from "@hypit/svs";
+
+import { sealTextTemplate } from "./program.js";
+import type {
+  TextCondition,
+  TextExpression,
+  TextScalar,
+  TextTemplate,
+} from "./types.js";
+
+type Choice = {
+  readonly id: string;
+  readonly text: string;
+  readonly conditions: Readonly<Record<string, TextScalar>>;
+};
+
+type Block =
+  | { readonly kind: "fixed"; readonly id: string; readonly order: number; readonly text: string }
+  | { readonly kind: "axis"; readonly id: string; readonly order: number; readonly parameter: string; readonly choices: readonly Choice[] }
+  | { readonly kind: "variant"; readonly id: string; readonly order: number; readonly choices: readonly Choice[] }
+  | { readonly kind: "slot"; readonly id: string; readonly order: number; readonly slot: string; readonly optional: boolean; readonly label?: string };
+
+function text(recipe: SvsRecipe, name: string, fallback?: string): string {
+  const value = recipe.properties[name] ?? fallback;
+  if (typeof value !== "string" || value.length === 0) throw new Error(`${recipe.path}.${name} must be non-empty text`);
+  return value;
+}
+
+function integer(recipe: SvsRecipe, name: string): number {
+  const value = recipe.properties[name];
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${recipe.path}.${name} must be a non-negative integer`);
+  }
+  return value;
+}
+
+function boolean(recipe: SvsRecipe, name: string, fallback: boolean): boolean {
+  const value = recipe.properties[name] ?? fallback;
+  if (typeof value !== "boolean") throw new Error(`${recipe.path}.${name} must be boolean`);
+  return value;
+}
+
+function exactProperties(recipe: SvsRecipe, allowed: ReadonlySet<string>, prefixes: readonly string[] = []): void {
+  const unknown = Object.keys(recipe.properties).filter(
+    (name) => !allowed.has(name) && !prefixes.some((prefix) => name.startsWith(prefix)),
+  );
+  if (unknown.length > 0) throw new Error(`${recipe.path} contains unknown property ${unknown[0]}`);
+}
+
+function choice(recipe: SvsRecipe, id: string): Choice {
+  exactProperties(recipe, new Set(["text"]), ["when-param-", "when-select-"]);
+  const conditions: Record<string, TextScalar> = {};
+  for (const [name, value] of Object.entries(recipe.properties)) {
+    const prefix = name.startsWith("when-param-")
+      ? "when-param-"
+      : name.startsWith("when-select-") ? "when-select-" : undefined;
+    if (prefix === undefined) continue;
+    if (typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value))) {
+      throw new Error(`${recipe.path}.${name} must be a finite scalar`);
+    }
+    conditions[name.slice(prefix.length)] = value;
+  }
+  return { id, text: text(recipe, "text"), conditions };
+}
+
+function equalsConditions(values: Readonly<Record<string, TextScalar>>, subject: string): TextCondition {
+  const conditions = Object.entries(values).map(([binding, value]) => ({
+    kind: "equals" as const,
+    binding,
+    value,
+  }));
+  if (conditions.length === 0) throw new Error(`${subject} must declare at least one condition`);
+  return conditions.length === 1 ? conditions[0]! : { kind: "all", conditions };
+}
+
+function expression(block: Block): TextExpression {
+  if (block.kind === "fixed") return { kind: "literal", value: block.text };
+  if (block.kind === "axis") {
+    return {
+      kind: "choice",
+      cases: block.choices.map((item) => ({
+        when: { kind: "equals", binding: block.parameter, value: item.id },
+        value: { kind: "literal", value: item.text },
+      })),
+    };
+  }
+  if (block.kind === "variant") {
+    return {
+      kind: "choice",
+      cases: block.choices.map((item) => ({
+        when: equalsConditions(item.conditions, `Text Template variant ${block.id}.${item.id}`),
+        value: { kind: "literal", value: item.text },
+      })),
+    };
+  }
+  const value: TextExpression = block.label === undefined
+    ? { kind: "slot", binding: block.slot }
+    : {
+        kind: "sequence",
+        items: [
+          { kind: "literal", value: `${block.label}\n` },
+          { kind: "slot", binding: block.slot },
+        ],
+      };
+  return block.optional
+    ? { kind: "optional", when: { kind: "present", binding: block.slot }, value }
+    : value;
+}
+
+/**
+ * One optional textual convention for authoring a TextTemplate in flat SVS.
+ * SVS remains inert data; this Frontend only lowers fixed/axis/variant/slot
+ * recipes into the ordinary domain-neutral Text expression language.
+ */
+export function textTemplateFromSvsRecipes(
+  recipes: readonly SvsRecipe[],
+  templateId: string,
+): TextTemplate {
+  const prefix = `text-template.${templateId}`;
+  const meta = recipes.find((recipe) => recipe.path === prefix);
+  if (meta === undefined) throw new Error(`Missing root Recipe ${prefix}`);
+  exactProperties(meta, new Set(["separator"]), ["default-"]);
+  if (text(meta, "separator", "paragraph") !== "paragraph") throw new Error(`${prefix}.separator must be paragraph`);
+  const defaults: Record<string, TextScalar> = {};
+  for (const [name, value] of Object.entries(meta.properties)) {
+    if (!name.startsWith("default-")) continue;
+    if (typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value))) {
+      throw new Error(`${prefix}.${name} must be a finite scalar`);
+    }
+    defaults[name.slice("default-".length)] = value;
+  }
+  const blockPrefix = `${prefix}.block.`;
+  const choicePrefix = `${prefix}.choice.`;
+  const blocks: Block[] = recipes
+    .filter((recipe) => recipe.path.startsWith(blockPrefix))
+    .map((recipe): Block => {
+      const id = recipe.path.slice(blockPrefix.length);
+      if (id.includes(".")) throw new Error(`${recipe.path} block id cannot contain '.'`);
+      const kind = text(recipe, "kind");
+      const order = integer(recipe, "order");
+      if (kind === "fixed") {
+        exactProperties(recipe, new Set(["kind", "order", "text"]));
+        return { kind, id, order, text: text(recipe, "text") };
+      }
+      if (kind === "axis" || kind === "variant") {
+        exactProperties(recipe, new Set(["kind", "order", ...(kind === "axis" ? ["parameter"] : [])]));
+        const choices = recipes
+          .filter((item) => item.path.startsWith(`${choicePrefix}${id}.`))
+          .map((item) => choice(item, item.path.slice(`${choicePrefix}${id}.`.length)));
+        if (choices.length === 0) throw new Error(`${recipe.path} has no choices`);
+        return kind === "axis"
+          ? { kind, id, order, parameter: text(recipe, "parameter"), choices }
+          : { kind, id, order, choices };
+      }
+      if (kind === "slot") {
+        exactProperties(recipe, new Set(["kind", "order", "slot", "optional", "label"]));
+        const label = recipe.properties.label;
+        return {
+          kind,
+          id,
+          order,
+          slot: text(recipe, "slot"),
+          optional: boolean(recipe, "optional", false),
+          ...(label === undefined ? {} : { label: text(recipe, "label") }),
+        };
+      }
+      throw new Error(`${recipe.path}.kind ${kind} is unsupported`);
+    })
+    .sort((left, right) => left.order - right.order);
+  if (new Set(blocks.map((item) => item.id)).size !== blocks.length) throw new Error(`${prefix} repeats a block id`);
+  if (new Set(blocks.map((item) => item.order)).size !== blocks.length) throw new Error(`${prefix} repeats a block order`);
+  const consumed = new Set([
+    meta.path,
+    ...blocks.map((item) => `${blockPrefix}${item.id}`),
+    ...recipes.filter((recipe) => recipe.path.startsWith(choicePrefix)).map((recipe) => recipe.path),
+  ]);
+  const stray = recipes.find((recipe) => recipe.path.startsWith(`${prefix}.`) && !consumed.has(recipe.path));
+  if (stray !== undefined) throw new Error(`Unrecognized Text Template Recipe ${stray.path}`);
+  return sealTextTemplate({
+
+    defaults,
+    root: {
+      kind: "join",
+      separator: "\n\n",
+      omitEmpty: true,
+      items: blocks.map(expression),
+    },
+  });
+}

package/packages/text/src/types.ts

@@ -0,0 +1,82 @@
+export type Text = {
+  readonly value: string;
+};
+
+export type TextScalar = string | number | boolean;
+export type TextBindingValue = TextScalar | readonly TextScalar[];
+
+export type TextBindings = {
+  readonly values: Readonly<Record<string, TextBindingValue>>;
+};
+
+/** Instructions for attaching one graph Text edge to a named template input. */
+export type TextBinding = {
+  readonly name: string;
+  readonly mode: "set" | "append";
+};
+
+export type TextCondition =
+  | { readonly kind: "present"; readonly binding: string }
+  | { readonly kind: "equals"; readonly binding: string; readonly value: TextScalar }
+  | { readonly kind: "all"; readonly conditions: readonly TextCondition[] }
+  | { readonly kind: "any"; readonly conditions: readonly TextCondition[] }
+  | { readonly kind: "not"; readonly condition: TextCondition };
+
+export type TextTransform =
+  | { readonly kind: "trim" }
+  | { readonly kind: "trim-start" }
+  | { readonly kind: "trim-end" }
+  | { readonly kind: "uppercase" }
+  | { readonly kind: "lowercase" }
+  | { readonly kind: "collapse-whitespace" }
+  | { readonly kind: "normalize-newlines" }
+  | { readonly kind: "json-string" };
+
+export type TextExpression =
+  | { readonly kind: "literal"; readonly value: string }
+  | { readonly kind: "slot"; readonly binding: string }
+  | { readonly kind: "sequence"; readonly items: readonly TextExpression[] }
+  | {
+      readonly kind: "join";
+      readonly separator: string;
+      readonly omitEmpty?: boolean;
+      readonly items: readonly TextExpression[];
+    }
+  | {
+      readonly kind: "choice";
+      readonly cases: readonly { readonly when: TextCondition; readonly value: TextExpression }[];
+      readonly otherwise?: TextExpression;
+    }
+  | { readonly kind: "optional"; readonly when: TextCondition; readonly value: TextExpression }
+  | {
+      readonly kind: "each";
+      readonly binding: string;
+      readonly as: string;
+      readonly separator: string;
+      readonly value: TextExpression;
+    }
+  | {
+      readonly kind: "replace";
+      readonly input: TextExpression;
+      readonly replacements: readonly {
+        readonly from: string;
+        readonly to: string;
+        readonly mode: "first" | "all";
+      }[];
+    }
+  | {
+      readonly kind: "transform";
+      readonly input: TextExpression;
+      readonly transforms: readonly TextTransform[];
+    }
+  | { readonly kind: "call"; readonly template: string };
+
+/**
+ * A finite, data-only text program. Definitions share the caller's explicit
+ * bindings; `call` cannot pass hidden state or execute arbitrary code.
+ */
+export type TextTemplate = {
+  readonly root: TextExpression;
+  readonly defaults?: Readonly<Record<string, TextBindingValue>>;
+  readonly definitions?: Readonly<Record<string, TextExpression>>;
+};

package/packages/transport-aws-lambda/README.md

@@ -0,0 +1,20 @@
+# `@hypit/transport-aws-lambda`
+
+Low-level synchronous JSON invocation for Endpoint packages that execute work through AWS Lambda.
+It is deliberately not an Endpoint and declares no SVML capability.
+
+Endpoint-specific code owns:
+
+- the request/response schema;
+- whether one call completes work or returns a remote checkpoint;
+- conversion into `EndpointOutcome`;
+- artifact locations and intrinsic result validation;
+- the function name, version/alias and retry semantics included in Endpoint configuration identity.
+
+The transport always uses `RequestResponse`. Lambda `Event` invocation has its own at-least-once
+queue and no immediate result/checkpoint, so treating it as an asynchronous Hypit Endpoint would be
+misleading. An Endpoint may invoke a coordinator Lambda synchronously; that coordinator can submit
+long work and return a checkpoint which the Endpoint later polls through another synchronous call.
+
+AWS authentication uses the SDK credential chain or an injected trusted client. Large media belongs
+in ResourceStore; JSON payloads are bounded by Lambda's synchronous payload limit.

package/packages/transport-aws-lambda/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@hypit/transport-aws-lambda",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@aws-sdk/client-lambda": "3.1103.0",
+    "@hypit/protocol": "workspace:*"
+  }
+}

package/packages/transport-aws-lambda/src/index.ts

@@ -0,0 +1,131 @@
+import {
+  InvokeCommand,
+  LambdaClient,
+} from "@aws-sdk/client-lambda";
+import type {
+  LambdaClientConfig,
+} from "@aws-sdk/client-lambda";
+import { canonicalize } from "@hypit/protocol";
+import type { CanonicalValue } from "@hypit/protocol";
+
+/** One canonical JSON exchange; callers may inject any structurally compatible transport. */
+export interface JsonInvoker {
+  invoke(request: CanonicalValue, options?: { readonly signal?: AbortSignal }): Promise<CanonicalValue>;
+}
+
+export type LambdaInvocationInput = {
+  readonly functionName: string;
+  readonly payload: Uint8Array;
+  readonly qualifier?: string;
+  readonly tenantId?: string;
+};
+
+export type LambdaInvocationOutput = {
+  readonly statusCode?: number;
+  readonly functionError?: string;
+  readonly payload?: Uint8Array;
+};
+
+export type LambdaInvocationClient = {
+  invoke(input: LambdaInvocationInput, signal?: AbortSignal): Promise<LambdaInvocationOutput>;
+};
+
+export type AwsLambdaJsonInvokerOptions = {
+  readonly functionName: string;
+  readonly qualifier?: string;
+  readonly tenantId?: string;
+  readonly region?: string;
+  readonly endpoint?: string;
+  readonly maxPayloadBytes?: number;
+  /** Injection point for tests and specially configured trusted AWS clients. */
+  readonly client?: LambdaInvocationClient;
+};
+
+function assert(condition: unknown, message: string): asserts condition {
+  if (!condition) throw new Error(message);
+}
+
+function positiveInteger(value: number, subject: string): number {
+  assert(Number.isSafeInteger(value) && value > 0, `${subject} must be a positive safe integer`);
+  return value;
+}
+
+function decode(bytes: Uint8Array): string {
+  return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}
+
+class AwsSdkLambdaInvocationClient implements LambdaInvocationClient {
+  readonly #client: LambdaClient;
+
+  constructor(config: LambdaClientConfig = {}) {
+    this.#client = new LambdaClient(config);
+  }
+
+  async invoke(input: LambdaInvocationInput, signal?: AbortSignal): Promise<LambdaInvocationOutput> {
+    const response = await this.#client.send(new InvokeCommand({
+      FunctionName: input.functionName,
+      InvocationType: "RequestResponse",
+      Payload: input.payload,
+      ...(input.qualifier === undefined ? {} : { Qualifier: input.qualifier }),
+      ...(input.tenantId === undefined ? {} : { TenantId: input.tenantId }),
+    }), signal === undefined ? {} : { abortSignal: signal });
+    return {
+      ...(response.StatusCode === undefined ? {} : { statusCode: response.StatusCode }),
+      ...(response.FunctionError === undefined ? {} : { functionError: response.FunctionError }),
+      ...(response.Payload === undefined ? {} : { payload: Uint8Array.from(response.Payload) }),
+    };
+  }
+}
+
+/**
+ * Synchronous JSON transport. Endpoint packages still own request shape and outcomes.
+ */
+export class AwsLambdaJsonInvoker implements JsonInvoker {
+  readonly #client: LambdaInvocationClient;
+  readonly #functionName: string;
+  readonly #qualifier: string | undefined;
+  readonly #tenantId: string | undefined;
+  readonly #maxPayloadBytes: number;
+
+  constructor(options: AwsLambdaJsonInvokerOptions) {
+    assert(options.functionName.trim().length > 0, "Lambda functionName must not be empty");
+    if (options.qualifier !== undefined) assert(options.qualifier.trim().length > 0, "Lambda qualifier must not be empty");
+    if (options.tenantId !== undefined) assert(options.tenantId.trim().length > 0, "Lambda tenantId must not be empty");
+    this.#functionName = options.functionName;
+    this.#qualifier = options.qualifier;
+    this.#tenantId = options.tenantId;
+    this.#maxPayloadBytes = positiveInteger(options.maxPayloadBytes ?? 6 * 1024 * 1024, "maxPayloadBytes");
+    this.#client = options.client ?? new AwsSdkLambdaInvocationClient({
+      ...(options.region === undefined ? {} : { region: options.region }),
+      ...(options.endpoint === undefined ? {} : { endpoint: options.endpoint }),
+    });
+  }
+
+  async invoke(
+    request: CanonicalValue,
+    options: { readonly signal?: AbortSignal } = {},
+  ): Promise<CanonicalValue> {
+    const payload = new TextEncoder().encode(JSON.stringify(canonicalize(request)));
+    assert(payload.byteLength <= this.#maxPayloadBytes,
+      `Lambda JSON request is ${payload.byteLength} bytes, over limit ${this.#maxPayloadBytes}`);
+    const response = await this.#client.invoke({
+      functionName: this.#functionName,
+      payload,
+      ...(this.#qualifier === undefined ? {} : { qualifier: this.#qualifier }),
+      ...(this.#tenantId === undefined ? {} : { tenantId: this.#tenantId }),
+    }, options.signal);
+    if (response.statusCode !== 200) {
+      throw new Error(`Lambda ${this.#functionName} returned invocation status ${response.statusCode ?? "unknown"}`);
+    }
+    const responsePayload = response.payload ?? new Uint8Array();
+    assert(responsePayload.byteLength <= this.#maxPayloadBytes,
+      `Lambda JSON response is ${responsePayload.byteLength} bytes, over limit ${this.#maxPayloadBytes}`);
+    const text = decode(responsePayload);
+    if (response.functionError !== undefined) {
+      // Function payloads may contain deployment secrets; do not copy them into framework errors.
+      throw new Error(`Lambda ${this.#functionName} failed (${response.functionError})`);
+    }
+    assert(text.length > 0, `Lambda ${this.#functionName} returned an empty JSON response`);
+    return canonicalize(JSON.parse(text));
+  }
+}

package/packages/typography-track/README.md

@@ -0,0 +1,50 @@
+# `@hypit/typography-track`
+
+The Track Surface accepts `semantic={speech.semantic}` or `space={animation}`. Semantic context
+resolves Script Selections and Moments; authored space supports clock-based animation. Shared `at`
+inputs accept a Moment or a time such as `2s`; `at` with `for` produces a Window where required.
+
+Place independently authored titles, labels, verdicts and other text in the video. Their lifetime
+can follow a Script Selection or Moment even when their wording differs from the speech. For words
+displayed as they are spoken, use a [Caption family](../caption-fine/README.md).
+
+The Track takes `semantic` or `space` to supply ProgramSpace. Items use explicit Point, Frame or Path
+placement, exact fonts and Styles. Timing can follow a Segment, Selection, Moment with duration, the
+whole program or explicit clock expressions. `.program` describes the text presentation; `.track`
+is the VisualTrack to include in Film. Each item has its own lifetime and stacking order.
+
+The text program supports rich documents, font stacks, Paint, wrapping, overflow and motion at item,
+word or grapheme level. Placement and time are separate from the Style Recipe. `typo:Mask` is a
+separate component for an authored Text Program and an owned still surface; read its vocabulary for
+the supported mask forms.
+
+Content has two explicit author forms:
+
+```svml
+<import as="copy" from="@hypit/text@1"/>
+<import as="typo" from="@hypit/typography-track@1"/>
+
+<copy:Value id="headline-copy">A useful idea, clearly shown.</copy:Value>
+
+<typo:Track id="titles" semantic={speech.semantic}>
+  <typo:Area id="headline" content={headline-copy}
+    placement={layout.headline} style={title-style} during="program"/>
+
+  <typo:Area id="editorial" placement={layout.editorial}
+    style={body-style} during="program">
+    <typo:P>Rich <typo:Span style={accent}>authored</typo:Span> typography.</typo:P>
+  </typo:Area>
+</typo:Track>
+```
+
+`content={...}` consumes an ordinary graph `Text` and is exclusive with body content. It becomes
+one plain document run; the Track still owns placement, timing, appearance and motion. Inline body
+content owns a bounded rich `VisualTextDocument`. Dynamic rich text is intentionally not smuggled
+through generic `Text`; it would require a separate explicit rich-document contract.
+
+`<typo:P>`, `<typo:Span>` and `<typo:Break>` are declared children of every item, so they are
+discoverable from the Surface vocabulary rather than from prose. A `style` on a `<typo:P>` or a
+`<typo:Span>` replaces the whole typography record, not only the paints: that paragraph or run is
+shaped with the referenced Style's own exact font at its own size, weight and slant, so one document
+can mix typefaces. The Style's area, point, path and stacking-order properties are ignored there;
+those stay with the item.

package/packages/typography-track/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@hypit/typography-track",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "hypit": {
+    "activation": "./src/activation.ts"
+  },
+  "dependencies": {
+    "@hypit/component-kit": "workspace:*",
+    "@hypit/composition": "workspace:*",
+    "@hypit/elaborator": "workspace:*",
+    "@hypit/media": "workspace:*",
+    "@hypit/narrative": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/program-space": "workspace:*",
+    "@hypit/semantic-track": "workspace:*",
+    "@hypit/spatial": "workspace:*",
+    "@hypit/svs": "workspace:*",
+    "@hypit/temporal": "workspace:*",
+    "@hypit/temporal-markup": "workspace:*",
+    "@hypit/text": "workspace:*",
+    "@hypit/visual-ir": "workspace:*",
+    "@hypit/markup": "workspace:*"
+  },
+  "devDependencies": {
+    "@hypit/core": "workspace:*",
+    "@hypit/validation": "workspace:*"
+  }
+}

package/packages/typography-track/src/activation.ts

@@ -0,0 +1,36 @@
+import { createMarkupSurfaceHostFacet } from "@hypit/markup";
+import {
+  decodeTypographyMotionSurface,
+  decodeTypographyMaskSurface,
+  decodeTypographyStyleSurface,
+  decodeTypographyTrackSurface,
+  typographyTrackComponent,
+  typographyTrackManifest,
+  typographyTrackModuleRef,
+  typographyTrackMarkupSurfaces,
+} from "./index.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{ manifest: typographyTrackManifest }],
+  components: [typographyTrackComponent],
+  hostFacets: [
+    createMarkupSurfaceHostFacet({
+      module: typographyTrackModuleRef,
+    declaration: typographyTrackMarkupSurfaces.find((item) => item.name === "style")!, handler: decodeTypographyStyleSurface,
+    }),
+    createMarkupSurfaceHostFacet({
+      module: typographyTrackModuleRef,
+    declaration: typographyTrackMarkupSurfaces.find((item) => item.name === "motion")!, handler: decodeTypographyMotionSurface,
+    }),
+    createMarkupSurfaceHostFacet({
+      module: typographyTrackModuleRef,
+    declaration: typographyTrackMarkupSurfaces.find((item) => item.name === "track")!, handler: decodeTypographyTrackSurface,
+    }),
+    createMarkupSurfaceHostFacet({
+      module: typographyTrackModuleRef,
+    declaration: typographyTrackMarkupSurfaces.find((item) => item.name === "mask")!, handler: decodeTypographyMaskSurface,
+    }),
+  ],
+};
+export default hypitPackage;

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

@@ -0,0 +1,93 @@
+import type { ComponentPackage } from "@hypit/component-kit";
+import type { ProgramSpace } from "@hypit/program-space";
+import type { CompositableSurfaceRef } from "@hypit/media";
+import type { SpatialFrame, SpatialPath, SpatialPoint } from "@hypit/spatial";
+import type { StoredValue } from "@hypit/protocol";
+import type { Text } from "@hypit/text";
+import { canonicalize } from "@hypit/protocol";
+
+import { typographyTrackProducers } from "./manifest.js";
+import { appendProjectedTextItem, bindAreaTextPlacement, bindPathTextPlacement, bindPointTextPlacement, createTypographyTrackSet, finalizeTypographyTrack, renderTypographyTrack, renderTextMaskTrack, materializePlainTextItem } from "./program.js";
+import type {
+  TextItemSpec,
+  PlainTextItemSpec,
+  TextPlacement,
+  TextMotion,
+  TextMaskSpec,
+  TextStyle,
+  TypographyTrackHeader,
+  TypographyTrackProgram,
+  TypographyTrackSet,
+} from "./types.js";
+import type { TemporalWindow } from "@hypit/temporal";
+
+function inline<T>(value: StoredValue | undefined, subject: string): T {
+  if (value?.kind !== "inline") throw new Error(`${subject} must be inline.`);
+  return value.value as unknown as T;
+}
+
+const output = (value: unknown) => ({ kind: "inline" as const, value: canonicalize(value) });
+
+export const typographyTrackComponent = {
+  producers: [
+    {
+      producer: typographyTrackProducers.materializePlainItem,
+      handler: ({ inputs }) => ({ outputs: { spec: output(materializePlainTextItem(
+        inline<PlainTextItemSpec>(inputs.spec?.value, "PlainTextItemSpec"),
+        inline<Text>(inputs.content?.value, "Text"),
+      )) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.bindPoint,
+      handler: ({ inputs }) => ({ outputs: { placement: output(bindPointTextPlacement(inline<SpatialPoint>(inputs.point?.value, "SpatialPoint"))) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.bindArea,
+      handler: ({ inputs }) => ({ outputs: { placement: output(bindAreaTextPlacement(inline<SpatialFrame>(inputs.frame?.value, "SpatialFrame"))) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.bindPath,
+      handler: ({ inputs }) => ({ outputs: { placement: output(bindPathTextPlacement(inline<SpatialPath>(inputs.path?.value, "SpatialPath"))) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.createSet,
+      handler: () => ({ outputs: { set: output(createTypographyTrackSet()) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.appendItem,
+      handler: ({ inputs }) => ({ outputs: { set: output(appendProjectedTextItem(
+        inline<TypographyTrackSet>(inputs.set?.value, "TypographyTrackSet"),
+        inline<TypographyTrackHeader>(inputs.header?.value, "TypographyTrackHeader"),
+        inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+        inline<TextPlacement>(inputs.placement?.value, "TextPlacement"),
+        inline<TextItemSpec>(inputs.spec?.value, "TextItemSpec"),
+        inline<TextStyle>(inputs.style?.value, "TextStyle"),
+        inline<TextMotion>(inputs.motion?.value, "TextMotion"),
+        inline<TemporalWindow>(inputs.window?.value, "TemporalWindow"),
+      )) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.finalize,
+      handler: ({ inputs }) => ({ outputs: { program: output(finalizeTypographyTrack(
+        inline<TypographyTrackHeader>(inputs.header?.value, "TypographyTrackHeader"),
+        inline<TypographyTrackSet>(inputs.set?.value, "TypographyTrackSet"),
+      )) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.render,
+      handler: ({ inputs }) => ({ outputs: { track: output(renderTypographyTrack(
+        inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+        inline<TypographyTrackProgram>(inputs.program?.value, "TypographyTrackProgram"),
+      )) }, needs: {} }),
+    },
+    {
+      producer: typographyTrackProducers.renderMask,
+      handler: ({ inputs }) => ({ outputs: { track: output(renderTextMaskTrack(
+        inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+        inline<TypographyTrackProgram>(inputs.program?.value, "TypographyTrackProgram"),
+        inline<CompositableSurfaceRef>(inputs.material?.value, "CompositableSurfaceRef"),
+        inline<TextMaskSpec>(inputs.spec?.value, "TextMaskSpec"),
+      )) }, needs: {} }),
+    },
+  ],
+} satisfies ComponentPackage;