@hypit/hypit 0.0.1 → 0.1.1

package/packages/estimate/src/index.ts

@@ -0,0 +1,16 @@
+export { estimateManifest, estimateModuleRef, estimateTypes, speechEstimatePolicySchema } from "./manifest.js";
+export {
+  speechEstimatePolicyFromAttributes,
+  speechEstimatePolicyFromRecipe,
+  speechEstimatePolicyProperties,
+} from "./policy.js";
+export {
+  assertSpeechEstimatePolicy,
+  countSpeechEstimateUnits,
+  detectSpeechEstimateLanguage,
+  estimateSpeechDuration,
+  resolveSpeechEstimateLanguage,
+  resolveSpeechEstimateRate,
+  sealSpeechEstimatePolicy,
+} from "./program.js";
+export type * from "./types.js";

package/packages/estimate/src/manifest.ts

@@ -0,0 +1,34 @@
+import type { ModuleManifest, TypeRef, ValueSchema } from "@hypit/protocol";
+
+export const estimateModuleRef = { name: "@hypit/estimate", version: "1" } as const;
+
+/**
+ * The one graph value this package still declares: the delivery policy an estimated SemanticTake
+ * weights its Tokens with. Durations themselves are author literals; measuring a script happens at
+ * creation time with `hypit measure`, never inside a Build.
+ */
+export const estimateTypes = {
+  speechPolicy: { module: estimateModuleRef, name: "SpeechEstimatePolicy" },
+} satisfies Record<string, TypeRef>;
+
+const number = { kind: "number" } as const satisfies ValueSchema;
+export const speechEstimatePolicySchema: ValueSchema = {
+  kind: "object",
+  fields: {
+    language: { schema: { kind: "string", enum: ["auto", "en", "zh", "ja", "es"] } },
+    pace: { schema: { kind: "string", enum: ["slow", "normal", "fast"] }, optional: true },
+    rate: { schema: { kind: "number", minimum: 0.000001 }, optional: true },
+    rounding: { schema: { kind: "string", enum: ["none", "round", "ceil"] } },
+    paddingSec: { schema: number, optional: true },
+  },
+};
+
+export const estimateManifest: ModuleManifest = {
+  format: "hypit.module@1",
+  name: estimateModuleRef.name,
+  version: estimateModuleRef.version,
+  dependencies: [],
+  types: [{ name: estimateTypes.speechPolicy.name }],
+  capabilities: [],
+  producers: [],
+};

package/packages/estimate/src/policy.ts

@@ -0,0 +1,70 @@
+import type { SvsRecipe } from "@hypit/svs";
+
+import { sealSpeechEstimatePolicy } from "./program.js";
+import type {
+  SpeechEstimateLanguage,
+  SpeechEstimatePace,
+  SpeechEstimatePolicy,
+  SpeechEstimateRounding,
+} from "./types.js";
+
+const POLICY_PROPERTIES = ["language", "pace", "rate", "rounding", "padding"] as const;
+
+/** The property names an estimate policy is written with, in an SVS Recipe or as element attributes. */
+export const speechEstimatePolicyProperties: readonly string[] = POLICY_PROPERTIES;
+
+function policyFrom(
+  properties: Readonly<Record<string, unknown>>,
+  subject: string,
+): SpeechEstimatePolicy {
+  const allowed = new Set<string>(POLICY_PROPERTIES);
+  const unknown = Object.keys(properties).filter((name) => !allowed.has(name));
+  if (unknown.length > 0) throw new Error(`${subject} contains unknown property ${unknown[0]}`);
+  const missing = ["language", "rounding"].filter((name) => properties[name] === undefined);
+  if (missing.length > 0) throw new Error(`${subject} requires ${missing.join(", ")}`);
+  const string = (name: string): string => {
+    const value = properties[name];
+    if (typeof value !== "string" || value.trim().length === 0) {
+      throw new Error(`${subject}.${name} must be a non-empty string`);
+    }
+    return value.trim();
+  };
+  const finite = (name: string): number => {
+    const raw = properties[name];
+    const value = typeof raw === "string" ? Number(raw) : raw;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw new Error(`${subject}.${name} must be a finite number`);
+    }
+    return value;
+  };
+  const pace = properties.pace;
+  const rate = properties.rate;
+  if ((pace !== undefined) === (rate !== undefined)) {
+    throw new Error(`${subject} requires exactly one of pace or rate`);
+  }
+  const common = {
+    language: string("language") as SpeechEstimateLanguage,
+    rounding: string("rounding") as SpeechEstimateRounding,
+    ...(properties.padding !== undefined ? { paddingSec: finite("padding") } : {}),
+  } as const;
+  return rate === undefined
+    ? sealSpeechEstimatePolicy({ ...common, pace: string("pace") as SpeechEstimatePace })
+    : sealSpeechEstimatePolicy({ ...common, rate: finite("rate") });
+}
+
+/** One reusable estimate policy written as an SVS Recipe; it configures a measurement, nothing executable. */
+export function speechEstimatePolicyFromRecipe(
+  recipe: SvsRecipe,
+  subject = `SVS Recipe ${recipe.path}`,
+): SpeechEstimatePolicy {
+  return policyFrom(recipe.properties, subject);
+}
+
+/** The same policy written inline as attributes or options: strings are read as the values they name. */
+export function speechEstimatePolicyFromAttributes(
+  attributes: Readonly<Record<string, unknown>>,
+  subject: string,
+): SpeechEstimatePolicy {
+  const present = Object.fromEntries(Object.entries(attributes).filter(([, value]) => value !== undefined));
+  return policyFrom(present, subject);
+}

package/packages/estimate/src/program.ts

@@ -0,0 +1,196 @@
+import type { Text } from "@hypit/text";
+import { assertSpeechDurationIdentity, sealSpeechDuration } from "@hypit/speech";
+import type { SpeechDuration } from "@hypit/speech";
+import { dictionary as cmuPronouncingDictionary } from "cmu-pronouncing-dictionary";
+
+import type {
+  ResolvedSpeechEstimateLanguage,
+  SpeechEstimateLanguage,
+  SpeechEstimatePace,
+  SpeechEstimatePolicy,
+} from "./types.js";
+
+const PACE_RATE: Readonly<Record<
+  ResolvedSpeechEstimateLanguage,
+  Readonly<Record<SpeechEstimatePace, number>>
+>> = {
+  // English is calibrated as delivery density, not pause-free articulation rate.
+  en: { slow: 4.2, normal: 4.6, fast: 5 },
+  // Preserve the existing non-English behavior until those languages are audited.
+  zh: { slow: 4.2, normal: 5.25, fast: 6.5625 },
+  ja: { slow: 6, normal: 7.5, fast: 9.375 },
+  es: { slow: 4.72, normal: 5.9, fast: 7.375 },
+};
+
+function words(text: string): string[] {
+  return text.match(/[\p{L}\p{N}]+(?:['’\-‐‑–][\p{L}\p{N}]+)*/gu) ?? [];
+}
+
+function looksSpanish(text: string): boolean {
+  if (/[ñáéíóúü¿¡]/iu.test(text)) return true;
+  const tokens = words(text).map((word) => word.toLowerCase());
+  if (tokens.length === 0) return false;
+  const hits = tokens.filter((word) => /^(?:que|de|la|el|los|las|un|una|para|por|con|sin|pero|porque|como|más|muy|este|esta|eso|soy|eres|es|son|estoy|está|tengo|quiero|puedo|ahora|cuando|todo|nada|aquí|así)$/u.test(word)).length;
+  return hits >= Math.max(2, Math.ceil(tokens.length * 0.18));
+}
+
+export function detectSpeechEstimateLanguage(text: string): ResolvedSpeechEstimateLanguage {
+  const han = (text.match(/[\u3400-\u9fff]/gu) ?? []).length;
+  const kana = (text.match(/[\u3040-\u30ff]/gu) ?? []).length;
+  const ascii = (text.match(/[A-Za-z]/gu) ?? []).length;
+  if (kana > Math.max(han, ascii / 4)) return "ja";
+  if (han > ascii / 4) return "zh";
+  if (looksSpanish(text)) return "es";
+  return "en";
+}
+
+function normalizedEnglishWord(word: string): string {
+  return word
+    .toLowerCase()
+    .replace(/’/gu, "'")
+    .replace(/[‐‑–]/gu, "-")
+    .replace(/[^a-z'-]/gu, "");
+}
+
+function dictionarySyllables(word: string): number | undefined {
+  const pronunciation = cmuPronouncingDictionary[word];
+  if (pronunciation === undefined) return undefined;
+  const syllables = pronunciation.split(" ").filter((phoneme) => /\d$/u.test(phoneme)).length;
+  return syllables > 0 ? syllables : undefined;
+}
+
+function heuristicEnglishSyllables(word: string): number {
+  const normalized = word.replace(/[^a-z]/gu, "");
+  if (!normalized) return 0;
+  if (normalized.length <= 3) return 1;
+  const stripped = normalized
+    .replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/u, "")
+    .replace(/^y/u, "");
+  return Math.max(1, stripped.match(/[aeiouy]{1,2}/gu)?.length ?? 1);
+}
+
+function englishSyllables(word: string): number {
+  const normalized = normalizedEnglishWord(word);
+  if (!normalized) return 0;
+  const direct = dictionarySyllables(normalized);
+  if (direct !== undefined) return direct;
+  if (normalized.includes("-")) {
+    return normalized
+      .split("-")
+      .filter(Boolean)
+      .reduce((sum, part) => sum + (dictionarySyllables(part) ?? heuristicEnglishSyllables(part)), 0);
+  }
+  return heuristicEnglishSyllables(normalized);
+}
+
+function spanishVowelNuclei(run: string): number {
+  let nuclei = 0;
+  let pending = "";
+  const flush = () => {
+    if (!pending) return;
+    nuclei += Math.max(1, pending.match(/[aeoáéó]/gu)?.length ?? 0);
+    pending = "";
+  };
+  for (const character of run) {
+    if (character === "í" || character === "ú") {
+      flush();
+      nuclei += 1;
+    } else {
+      pending += character;
+    }
+  }
+  flush();
+  return nuclei;
+}
+
+function spanishSyllables(word: string): number {
+  let normalized = word.toLowerCase().normalize("NFC").replace(/[^a-záéíóúüñ]/gu, "");
+  if (!normalized) return 0;
+  if (normalized === "y") normalized = "i";
+  else normalized = normalized.replace(/y$/u, "i");
+  const runs = normalized.match(/[aeiouáéíóúü]+/gu) ?? [];
+  return Math.max(1, runs.reduce((sum, run) => sum + spanishVowelNuclei(run), 0));
+}
+
+export function countSpeechEstimateUnits(
+  text: string,
+  language: ResolvedSpeechEstimateLanguage,
+): number {
+  if (language === "zh" || language === "ja") {
+    const cjk = (text.match(/[\u3400-\u9fff\u3040-\u30ff]/gu) ?? []).length;
+    const latin = text
+      .replace(/[\u3400-\u9fff\u3040-\u30ff]/gu, " ")
+      .split(/\s+/u)
+      .filter((word) => /[A-Za-z]/u.test(word));
+    return cjk + latin.reduce((sum, word) => sum + englishSyllables(word), 0);
+  }
+  if (language === "es") return words(text).reduce((sum, word) => sum + spanishSyllables(word), 0);
+  return words(text).reduce((sum, word) => sum + englishSyllables(word), 0);
+}
+
+export function sealSpeechEstimatePolicy(value: SpeechEstimatePolicy): SpeechEstimatePolicy {
+  const policy = structuredClone(value);
+  assertSpeechEstimatePolicy(policy);
+  return policy;
+}
+
+export function assertSpeechEstimatePolicy(value: SpeechEstimatePolicy): void {
+  const hasPace = value.pace !== undefined;
+  const hasRate = value.rate !== undefined;
+  if (
+    !(["auto", "en", "zh", "ja", "es"] as const).includes(value.language)
+    || hasPace === hasRate
+    || (hasPace && !(["slow", "normal", "fast"] as const).includes(value.pace))
+    || (hasRate && (!Number.isFinite(value.rate) || value.rate <= 0))
+    || !(["none", "round", "ceil"] as const).includes(value.rounding)
+    || (value.paddingSec !== undefined && (!Number.isFinite(value.paddingSec) || value.paddingSec < 0))
+  ) {
+    throw new Error("SpeechEstimatePolicy is invalid");
+  }
+}
+
+export function resolveSpeechEstimateRate(
+  policy: SpeechEstimatePolicy,
+  language: ResolvedSpeechEstimateLanguage,
+): number {
+  assertSpeechEstimatePolicy(policy);
+  return policy.rate ?? PACE_RATE[language][policy.pace];
+}
+
+function assertSpeechText(value: Text): void {
+  if (
+    value.value.trim().length === 0
+  ) {
+    throw new Error("Speech Text is invalid");
+  }
+}
+
+function rounded(value: number, mode: SpeechEstimatePolicy["rounding"]): number {
+  if (mode === "ceil") return Math.ceil(value);
+  if (mode === "round") return Math.round(value);
+  return value;
+}
+
+export function estimateSpeechDuration(
+  text: Text,
+  policy: SpeechEstimatePolicy,
+): SpeechDuration {
+  assertSpeechText(text);
+  assertSpeechEstimatePolicy(policy);
+  const language = policy.language === "auto" ? detectSpeechEstimateLanguage(text.value) : policy.language;
+  const units = countSpeechEstimateUnits(text.value, language);
+  if (units < 1) throw new Error("Speech Text contains no countable speech units");
+  const raw = units / resolveSpeechEstimateRate(policy, language) + (policy.paddingSec ?? 0);
+  const durationSec = rounded(raw, policy.rounding);
+  if (durationSec === 0) throw new Error("Speech estimate rounds to zero seconds; use rounding none or ceil.");
+  const duration = sealSpeechDuration(durationSec);
+  assertSpeechDurationIdentity(duration);
+  return duration;
+}
+
+export function resolveSpeechEstimateLanguage(
+  text: string,
+  requested: SpeechEstimateLanguage,
+): ResolvedSpeechEstimateLanguage {
+  return requested === "auto" ? detectSpeechEstimateLanguage(text) : requested;
+}

package/packages/estimate/src/types.ts

@@ -0,0 +1,15 @@
+export type SpeechEstimateLanguage = "auto" | "en" | "zh" | "ja" | "es";
+export type ResolvedSpeechEstimateLanguage = Exclude<SpeechEstimateLanguage, "auto">;
+export type SpeechEstimatePace = "slow" | "normal" | "fast";
+export type SpeechEstimateRounding = "none" | "round" | "ceil";
+
+type SpeechEstimatePolicyBase = {
+  readonly language: SpeechEstimateLanguage;
+  readonly rounding: SpeechEstimateRounding;
+  readonly paddingSec?: number;
+};
+
+export type SpeechEstimatePolicy = SpeechEstimatePolicyBase & (
+  | { readonly pace: SpeechEstimatePace; readonly rate?: never }
+  | { readonly pace?: never; readonly rate: number }
+);

package/packages/film/README.md

@@ -0,0 +1,49 @@
+# `@hypit/film`
+
+The Surface accepts `semantic={speech.semantic}` for performance time or `space={animation}` for an
+authored ProgramSpace. Its Fragment receives `space` directly; rendering does not require Script
+or prepared performance media. Both time sources use the same frame and audio pipeline.
+
+Official package-owned assembly layer between peer Tracks and the generic Composition waist.
+Film is an ordinary author component and an optional Target, not a Core root or a privileged video
+type.
+
+The package lowers one concrete Film declaration into a finite `FilmTrackSet` fold, then compiles
+that set into `Composition`. This supports any number and mix
+of VisualTrack and AudioTrack inputs while every Core Operation retains a fixed manifest-declared
+port list and one atomic result.
+
+`FilmTrackSet` is an immutable lowering value, not an author-facing workflow collection. Each append
+receives the previous set and newly added Track through explicit graph edges. The domain value copies
+no lineage metadata. Final Composition
+remains order-independent because the public contract canonicalizes Tracks and visual ordering
+belongs to each Present's absolute stacking key.
+
+The official Structured Surface validates an imported generic SVS Recipe into a nominal
+`FilmProgram`, receives CanvasSpace and the selected time source through separate explicit edges,
+projects ProgramSpace when that source is a SemanticTrack, type-checks
+each `<film:Track source={...}/>` reference and generates the finite fold. CanvasSpace is the only
+dimension truth, ProgramSpace is the only frame-rate truth, and FilmProgram owns only assembly
+identity and clear color.
+Child order is organizational: Track and Present identity, timing and absolute stacking remain in
+their own typed values. Final rendering is a separate author package and capability.
+
+For example, after the named inputs are declared:
+
+```svml
+<film:Film id="main" canvas={vertical} semantic={speech.semantic}
+  appearance={recipes.film.vertical}>
+  <film:Track source={performance.visual}/>
+  <film:Track source={speech.audio}/>
+  <film:Track source={coverage.visual}/>
+  <film:Track source={captions.track}/>
+  <film:Track source={music.track}/>
+</film:Film>
+```
+
+The public output is `main.composition`. Including a visual output does not automatically include
+its sibling audio output. An opaque upper layer can cover a performance while its audio continues;
+reordering these children is not how an author changes that visual stacking.
+
+The `appearance` Recipe uses `background`, for example `film.vertical { background: #18212A; }`.
+The compiled FilmProgram's field is `clearColor`; it is not a Recipe key named `clear-color`.

package/packages/film/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@hypit/film",
+  "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/program-space": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/semantic-track": "workspace:*",
+    "@hypit/spatial": "workspace:*",
+    "@hypit/svs": "workspace:*",
+    "@hypit/markup": "workspace:*",
+    "@hypit/temporal-markup": "workspace:*"
+  },
+  "devDependencies": {
+    "@hypit/core": "workspace:*",
+    "@hypit/driver-node": "workspace:*",
+    "@hypit/hyperframes": "workspace:*",
+    "@hypit/media": "workspace:*",
+    "@hypit/text": "workspace:*",
+    "@hypit/typography-track": "workspace:*",
+    "@hypit/validation": "workspace:*"
+  }
+}

package/packages/film/src/activation.ts

@@ -0,0 +1,16 @@
+import { createMarkupSurfaceHostFacet } from "@hypit/markup";
+import {
+  decodeFilmSurface, filmComponent, filmManifest, filmModuleRef,
+  filmMarkupSurfaces,
+} from "./index.js";
+
+export const hypitPackage = {
+  format: "hypit.node-package@1" as const,
+  modules: [{ manifest: filmManifest }],
+  components: [filmComponent],
+  hostFacets: [createMarkupSurfaceHostFacet({
+    module: filmModuleRef,
+    declaration: filmMarkupSurfaces.find((item) => item.name === "film")!, handler: decodeFilmSurface,
+  })],
+};
+export default hypitPackage;

package/packages/film/src/component.ts

@@ -0,0 +1,61 @@
+import type { ComponentPackage } from "@hypit/component-kit";
+import type { ProgramSpace } from "@hypit/program-space";
+import type { CanvasSpace } from "@hypit/spatial";
+import type { AudioTrack, VisualTrack } from "@hypit/composition";
+import type { StoredValue } from "@hypit/protocol";
+import { canonicalize } from "@hypit/protocol";
+
+import { filmProducers } from "./manifest.js";
+import { appendFilmAudioTrack, appendFilmVisualTrack, compileFilmComposition, createFilmTrackSet } from "./program.js";
+import type { FilmProgram, FilmTrackSet } from "./types.js";
+
+function inline<T>(value: StoredValue | undefined, subject: string): T {
+  if (value?.kind !== "inline") throw new Error(`${subject} must be inline`);
+  return value.value as unknown as T;
+}
+
+export const filmComponent = {
+  producers: [
+    {
+      producer: filmProducers.createTrackSet,
+      handler: () => ({
+        outputs: { set: { kind: "inline", value: canonicalize(createFilmTrackSet()) } },
+        needs: {},
+      }),
+    },
+    {
+      producer: filmProducers.appendVisualTrack,
+      handler: ({ inputs }) => ({
+        outputs: { set: { kind: "inline", value: canonicalize(appendFilmVisualTrack(
+          inline<FilmTrackSet>(inputs.set?.value, "FilmTrackSet"),
+          inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+          inline<VisualTrack>(inputs.track?.value, "VisualTrack"),
+        )) } },
+        needs: {},
+      }),
+    },
+    {
+      producer: filmProducers.appendAudioTrack,
+      handler: ({ inputs }) => ({
+        outputs: { set: { kind: "inline", value: canonicalize(appendFilmAudioTrack(
+          inline<FilmTrackSet>(inputs.set?.value, "FilmTrackSet"),
+          inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+          inline<AudioTrack>(inputs.track?.value, "AudioTrack"),
+        )) } },
+        needs: {},
+      }),
+    },
+    {
+      producer: filmProducers.compileComposition,
+      handler: ({ inputs }) => ({
+        outputs: { composition: { kind: "inline", value: canonicalize(compileFilmComposition(
+          inline<FilmProgram>(inputs.program?.value, "FilmProgram"),
+          inline<CanvasSpace>(inputs.canvas?.value, "CanvasSpace"),
+          inline<ProgramSpace>(inputs.space?.value, "ProgramSpace"),
+          inline<FilmTrackSet>(inputs.set?.value, "FilmTrackSet"),
+        )) } },
+        needs: {},
+      }),
+    },
+  ],
+} satisfies ComponentPackage;

package/packages/film/src/fragment.ts

@@ -0,0 +1,83 @@
+import { programSpaceTypes } from "@hypit/program-space";
+import { spatialTypes } from "@hypit/spatial";
+import { compositionTypes } from "@hypit/composition";
+import type { Track } from "@hypit/composition";
+import { sealGraphFragment } from "@hypit/elaborator";
+import type { FragmentOperation } from "@hypit/elaborator";
+
+import { filmProducers, filmTypes } from "./manifest.js";
+import type { FilmAssemblyFragmentOptions, FilmTrackInput } from "./types.js";
+
+const input = (name: string) => ({ kind: "fragment-input" as const, name });
+const operation = (id: string) => ({ kind: "fragment-operation" as const, operation: id });
+
+function assertTrackInputs(tracks: readonly FilmTrackInput[]): FilmTrackInput[] {
+  const names = new Set(["program", "canvas", "space"]);
+  return [...tracks]
+    .map((track) => ({ name: track.name.trim(), kind: track.kind }))
+    .sort((left, right) => left.name.localeCompare(right.name))
+    .map((track) => {
+      if (!track.name) throw new Error("Film Track input name must not be empty.");
+      if (names.has(track.name)) throw new Error(`Film Track input name ${track.name} is reserved or duplicated.`);
+      names.add(track.name);
+      return track;
+    });
+}
+
+/**
+ * Create one hygienic, finite Fragment for a concrete Film declaration. The
+ * author module decides how many Track references it has; Core still receives
+ * ordinary fixed-port Operations after this lowering.
+ */
+export function createFilmAssemblyFragment(options: FilmAssemblyFragmentOptions) {
+  const tracks = assertTrackInputs(options.tracks);
+  const operations: FragmentOperation[] = [
+    {
+      id: "track-set:empty",
+      producer: filmProducers.createTrackSet,
+      inputs: {},
+      result: { kind: "output" as const, name: "set" },
+    },
+  ];
+  let current = "track-set:empty";
+  tracks.forEach((track, index) => {
+    const id = `track-set:append:${String(index).padStart(4, "0")}`;
+    operations.push({
+      id,
+      producer: track.kind === "visual" ? filmProducers.appendVisualTrack : filmProducers.appendAudioTrack,
+      inputs: { set: operation(current), space: input("space"), track: input(track.name) },
+      result: { kind: "output" as const, name: "set" },
+    });
+    current = id;
+  });
+  operations.push({
+    id: "film:composition",
+    producer: filmProducers.compileComposition,
+    inputs: {
+      program: input("program"),
+      canvas: input("canvas"),
+      space: input("space"),
+      set: operation(current),
+    },
+    result: { kind: "output" as const, name: "composition" },
+  });
+  return sealGraphFragment({
+    inputs: [
+      { name: "program", type: filmTypes.program },
+      { name: "canvas", type: spatialTypes.canvas },
+      { name: "space", type: programSpaceTypes.programSpace },
+      ...tracks.map((track) => ({
+        name: track.name,
+        type: track.kind === "visual" ? compositionTypes.visualTrack : compositionTypes.audioTrack,
+      })),
+    ],
+    operations,
+    exports: [
+      {
+        name: "composition",
+        type: compositionTypes.composition,
+        root: operation("film:composition"),
+      },
+    ],
+  });
+}

package/packages/film/src/index.ts

@@ -0,0 +1,11 @@
+export { createFilmAssemblyFragment } from "./fragment.js";
+export { filmComponent } from "./component.js";
+export { filmManifest, filmMarkupSurfaces, filmModuleRef, filmProgramSchema, filmProducers, filmTrackSetSchema, filmTypes } from "./manifest.js";
+export { appendFilmAudioTrack, appendFilmVisualTrack, assertFilmProgramIdentity, assertFilmTrackSetIdentity, compileFilmComposition, createFilmTrackSet, sealFilmProgram } from "./program.js";
+export {
+  assertFilmRecipe,
+  filmAppearanceFromRecipe,
+} from "./recipe.js";
+export type { FilmAppearance } from "./recipe.js";
+export { decodeFilmSurface } from "./surface.js";
+export type * from "./types.js";