@hypit/hypit 0.0.1 → 0.1.1

package/packages/film/src/manifest.ts

@@ -0,0 +1,152 @@
+import { temporalContextAttributeVocabulary } from "@hypit/temporal-markup";
+import { audioTrackSchema, compositionDependency, compositionTypes, visualTrackSchema } from "@hypit/composition";
+import { programSpaceDependency, programSpaceTypes } from "@hypit/program-space";
+import type { ModuleManifest, ProducerRef, TypeRef, ValueSchema } from "@hypit/protocol";
+import { semanticTrackDependency } from "@hypit/semantic-track";
+import { spatialDependency, spatialTypes } from "@hypit/spatial";
+import { svsManifest, svsModuleRef, svsRecipeType } from "@hypit/svs";
+
+export const filmModuleRef = { name: "@hypit/film", version: "1" } as const;
+export const filmTypes = {
+  program: { module: filmModuleRef, name: "FilmProgram" },
+  trackSet: { module: filmModuleRef, name: "FilmTrackSet" },
+} satisfies Record<string, TypeRef>;
+export const filmProducers = {
+  createTrackSet: { module: filmModuleRef, name: "create-track-set" },
+  appendVisualTrack: { module: filmModuleRef, name: "append-visual-track" },
+  appendAudioTrack: { module: filmModuleRef, name: "append-audio-track" },
+  compileComposition: { module: filmModuleRef, name: "compile-composition" },
+} satisfies Record<string, ProducerRef>;
+
+const string = { kind: "string", minLength: 1 } as const;
+const object = (fields: Readonly<Record<string, { readonly schema: ValueSchema; readonly optional?: boolean }>>): ValueSchema => ({
+  kind: "object",
+  fields,
+});
+
+export const filmProgramSchema: ValueSchema = object({
+
+  id: { schema: string },
+  clearColor: { schema: string },
+});
+
+export const filmTrackSetSchema: ValueSchema = object({
+
+  tracks: {
+    schema: {
+      kind: "array",
+      items: { kind: "oneOf", variants: [visualTrackSchema, audioTrackSchema] },
+    },
+  },
+});
+
+export const filmMarkupSurfaces = [{
+    name: "film",
+    tag: "Film",
+    mode: "structured",
+    outputs: [filmTypes.program],
+    vocabulary: {
+      summary:
+        "Assembles any number of peer VisualTrack and AudioTrack references into one Composition against a Canvas and a SemanticTrack.",
+      appearance:
+        "One flat fill of the entire Canvas, in the single hexadecimal color the Recipe's `background` carries, lying behind everything else in the Frame. It covers the full Canvas width and height, holds that one color from the first Frame to the last, and never moves, fades or changes. Wherever nothing is painted over it, that color is what the Frame shows; the Film puts no mark of its own on top of it.",
+      attributes: [
+        { name: "id", kind: "identifier", required: true,
+          summary: "Names the Film component and the Composition binding it publishes." },
+        { name: "canvas", kind: "reference", required: true,
+          accepts: [spatialTypes.canvas],
+          summary: "Selects the CanvasSpace that decides the Composition's dimensions." },
+        ...temporalContextAttributeVocabulary,
+        { name: "appearance", kind: "reference", required: true,
+          accepts: [svsRecipeType],
+          summary: "Selects the SVS Recipe that decides the clear color behind every Track.",
+          recipe: [
+            { name: "background", required: true,
+              summary: "Decides the color the Film clears to behind every Track, written as `#rrggbb` or `#rrggbbaa`." },
+          ] },
+      ],
+      children: [
+        { tag: "Track", cardinality: "many",
+          summary: "Adds one VisualTrack or AudioTrack to the assembly.",
+          attributes: [
+            { name: "source", kind: "reference", required: true,
+              accepts: [compositionTypes.visualTrack, compositionTypes.audioTrack],
+              summary: "Selects the Track this entry contributes to the Composition." },
+          ] },
+      ],
+      ports: [
+        { name: "composition", type: compositionTypes.composition,
+          summary: "The assembled Composition, addressed as `<id>.composition`." },
+      ],
+      example: [
+        '<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={captions.track}/>",
+        "</film:Film>",
+      ].join("\n"),
+      notes: [
+        "At least one `Track` is required.",
+        "The Recipe carries exactly one property, `background`, written as a hexadecimal color; any other property is rejected, and Canvas geometry and frame rate stay on their own edges.",
+        "Child order is organizational: Track identity, timing and absolute stacking stay in their own typed values.",
+      ],
+    },
+  }] as const;
+
+
+export const filmManifest: ModuleManifest = {
+  format: "hypit.module@1",
+  name: filmModuleRef.name,
+  version: filmModuleRef.version,
+  dependencies: [
+    programSpaceDependency,
+    semanticTrackDependency,
+    spatialDependency,
+    compositionDependency,
+    { module: svsModuleRef },
+  ],
+  types: [
+    { name: filmTypes.program.name },
+    { name: filmTypes.trackSet.name },
+  ],
+  capabilities: [],
+  producers: [
+    {
+      name: filmProducers.createTrackSet.name,
+      inputs: [],
+      outputs: [{ name: "set", type: filmTypes.trackSet }],
+      needs: [],
+    },
+    {
+      name: filmProducers.appendVisualTrack.name,
+      inputs: [
+        { name: "set", type: filmTypes.trackSet },
+        { name: "space", type: programSpaceTypes.programSpace },
+        { name: "track", type: compositionTypes.visualTrack },
+      ],
+      outputs: [{ name: "set", type: filmTypes.trackSet }],
+      needs: [],
+    },
+    {
+      name: filmProducers.appendAudioTrack.name,
+      inputs: [
+        { name: "set", type: filmTypes.trackSet },
+        { name: "space", type: programSpaceTypes.programSpace },
+        { name: "track", type: compositionTypes.audioTrack },
+      ],
+      outputs: [{ name: "set", type: filmTypes.trackSet }],
+      needs: [],
+    },
+    {
+      name: filmProducers.compileComposition.name,
+      inputs: [
+        { name: "program", type: filmTypes.program },
+        { name: "canvas", type: spatialTypes.canvas },
+        { name: "space", type: programSpaceTypes.programSpace },
+        { name: "set", type: filmTypes.trackSet },
+      ],
+      outputs: [{ name: "composition", type: compositionTypes.composition }],
+      needs: [],
+    },
+  ],
+};

package/packages/film/src/program.ts

@@ -0,0 +1,110 @@
+import { assertProgramSpaceIdentity } from "@hypit/program-space";
+import type { ProgramSpace } from "@hypit/program-space";
+import { assertCanvasSpace } from "@hypit/spatial";
+import type { CanvasSpace } from "@hypit/spatial";
+import { assertAudioTrackIdentity, assertCompositionIdentity, assertVisualTrackIdentity, sealComposition } from "@hypit/composition";
+import type { AudioTrack, Composition, Track, VisualTrack } from "@hypit/composition";
+
+import type { FilmProgram, FilmTrackSet } from "./types.js";
+
+function assertNonEmpty(value: string, label: string): void {
+  if (!value.trim()) throw new Error(`${label} must not be empty.`);
+}
+
+function trackKey(track: Track): string {
+  return `${track.kind}\u0000${track.id}`;
+}
+
+function filmProgramContent(value: FilmProgram): FilmProgram {
+  return {
+
+    id: value.id,
+    clearColor: value.clearColor,
+  };
+}
+
+function filmTrackSetContent(value: FilmTrackSet): FilmTrackSet {
+  return {
+
+    tracks: [...value.tracks]
+      .map((track) => structuredClone(track))
+      .sort((left, right) => trackKey(left).localeCompare(trackKey(right))),
+  };
+}
+
+export function sealFilmProgram(value: FilmProgram): FilmProgram {
+  return filmProgramContent(value);
+}
+
+export function assertFilmProgramIdentity(program: FilmProgram): void {
+  assertNonEmpty(program.id, "FilmProgram id");
+  if (!/^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/iu.test(program.clearColor)) {
+    throw new Error("FilmProgram clear color is invalid.");
+  }
+}
+
+function sealFilmTrackSet(value: FilmTrackSet): FilmTrackSet {
+  return filmTrackSetContent(value);
+}
+
+export function assertFilmTrackSetIdentity(set: FilmTrackSet): void {
+  const ids = new Set<string>();
+  for (const track of set.tracks) {
+    if (ids.has(track.id)) throw new Error(`FilmTrackSet contains duplicate Track id ${track.id}.`);
+    ids.add(track.id);
+    if (track.kind === "visual") assertVisualTrackIdentity(track);
+    else assertAudioTrackIdentity(track);
+  }
+}
+
+export function createFilmTrackSet(): FilmTrackSet {
+  return sealFilmTrackSet({
+
+    tracks: [],
+  });
+}
+
+function appendTrack(set: FilmTrackSet, programSpace: ProgramSpace, track: Track): FilmTrackSet {
+  assertFilmTrackSetIdentity(set);
+  assertProgramSpaceIdentity(programSpace);
+  if (track.kind === "visual") assertVisualTrackIdentity(track, programSpace);
+  else assertAudioTrackIdentity(track, programSpace);
+  if (set.tracks.some((existing) => existing.id === track.id)) {
+    throw new Error(`FilmTrackSet already contains Track id ${track.id}.`);
+  }
+  return sealFilmTrackSet({
+
+    tracks: [...set.tracks, track],
+  });
+}
+
+export function appendFilmVisualTrack(set: FilmTrackSet, programSpace: ProgramSpace, track: VisualTrack): FilmTrackSet {
+  return appendTrack(set, programSpace, track);
+}
+
+export function appendFilmAudioTrack(set: FilmTrackSet, programSpace: ProgramSpace, track: AudioTrack): FilmTrackSet {
+  return appendTrack(set, programSpace, track);
+}
+
+export function compileFilmComposition(
+  program: FilmProgram,
+  canvas: CanvasSpace,
+  programSpace: ProgramSpace,
+  set: FilmTrackSet,
+): Composition {
+  assertFilmProgramIdentity(program);
+  assertCanvasSpace(canvas);
+  assertProgramSpaceIdentity(programSpace);
+  assertFilmTrackSetIdentity(set);
+  const composition = sealComposition({
+    id: program.id,
+    canvas: {
+      width: canvas.widthPx,
+      height: canvas.heightPx,
+      clearColor: program.clearColor,
+    },
+    tracks: set.tracks,
+  });
+  assertCompositionIdentity(composition, programSpace);
+  return composition;
+}

package/packages/film/src/recipe.ts

@@ -0,0 +1,24 @@
+import type { SvsRecipe } from "@hypit/svs";
+
+/**
+ * The Film Recipe owns Film appearance only. Canvas geometry and ProgramSpace
+ * remain separate graph inputs and cannot be smuggled into a stylesheet.
+ */
+
+export type FilmAppearance = { readonly clearColor: string };
+
+export function assertFilmRecipe(properties: SvsRecipe["properties"]): void {
+  const actual = Object.keys(properties).sort().join(" ");
+  if (actual !== "background") {
+    throw new Error("Film Recipe requires exactly background");
+  }
+}
+
+export function filmAppearanceFromRecipe(properties: SvsRecipe["properties"]): FilmAppearance {
+  assertFilmRecipe(properties);
+  const background = properties["background"];
+  if (typeof background !== "string" || !/^#[0-9a-f]{6}(?:[0-9a-f]{2})?$/iu.test(background)) {
+    throw new Error("Film Recipe background must be a hexadecimal color");
+  }
+  return { clearColor: background };
+}

package/packages/film/src/surface.ts

@@ -0,0 +1,146 @@
+import { createTemporalSpace, resolveTemporalContext } from "@hypit/temporal-markup";
+import { spatialTypes } from "@hypit/spatial";
+import { compositionTypes } from "@hypit/composition";
+import type { AudioTrack, Track, VisualTrack } from "@hypit/composition";
+import { svsRecipeType } from "@hypit/svs";
+import type { SvsRecipe } from "@hypit/svs";
+import type {
+  StructuredElement,
+  StructuredSurfaceHandler,
+  SurfaceResolvedReference,
+  MarkupAttributeValue,
+} from "@hypit/markup";
+
+import { createFilmAssemblyFragment } from "./fragment.js";
+import { filmTypes } from "./manifest.js";
+import { sealFilmProgram } from "./program.js";
+import { filmAppearanceFromRecipe } from "./recipe.js";
+
+function localName(value: string): string {
+  return value.includes(":") ? value.slice(value.lastIndexOf(":") + 1) : value;
+}
+
+function exactAttributes(element: StructuredElement, names: readonly string[]): void {
+  const actual = Object.keys(element.attributes).sort();
+  const expected = [...names].sort();
+  if (actual.join("\u0000") !== expected.join("\u0000")) {
+    throw new Error(`${element.name} requires exactly ${expected.join(", ")}`);
+  }
+}
+
+function stringAttribute(element: StructuredElement, name: string): string {
+  const value = element.attributes[name];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`${element.name}.${name} must be a non-empty string`);
+  }
+  return value;
+}
+
+function referenceAttribute(element: StructuredElement, name: string): string {
+  const value: MarkupAttributeValue | undefined = element.attributes[name];
+  if (typeof value !== "object" || value.kind !== "reference" || value.path.length === 0) {
+    throw new Error(`${element.name}.${name} must be a whole-value reference`);
+  }
+  return value.path;
+}
+
+function sameType(left: SurfaceResolvedReference["type"], right: SurfaceResolvedReference["type"]): boolean {
+  return left.module.name === right.module.name
+    && left.module.version === right.module.version
+    && left.name === right.name;
+}
+
+function requiredReference(
+  element: StructuredElement,
+  name: string,
+  resolve: (path: string) => SurfaceResolvedReference | undefined,
+): SurfaceResolvedReference {
+  const path = referenceAttribute(element, name);
+  const resolved = resolve(path);
+  if (resolved === undefined) throw new Error(`${element.name}.${name} cannot resolve ${path}`);
+  return resolved;
+}
+
+function recipe(reference: SurfaceResolvedReference, label: string): SvsRecipe {
+  if (!sameType(reference.type, svsRecipeType)) throw new Error(`${label} must reference an SVS Recipe`);
+  const value = reference.record?.value;
+  if (value?.kind !== "inline" || value.value === null || Array.isArray(value.value)
+    || typeof value.value !== "object") {
+    throw new Error(`${label} must reference an authored Recipe value`);
+  }
+  return value.value as SvsRecipe;
+}
+
+function trackChildren(element: StructuredElement): StructuredElement[] {
+  const tracks: StructuredElement[] = [];
+  for (const child of element.children) {
+    if (child.kind === "text") {
+      if (child.value.trim().length > 0) throw new Error(`${element.name} accepts only Track children`);
+      continue;
+    }
+    if (localName(child.name) !== "Track") throw new Error(`${element.name} accepts only Track children`);
+    exactAttributes(child, ["source"]);
+    tracks.push(child);
+  }
+  if (tracks.length === 0) throw new Error(`${element.name} requires at least one Track`);
+  return tracks;
+}
+
+function trackKind(reference: SurfaceResolvedReference): "visual" | "audio" {
+  if (sameType(reference.type, compositionTypes.visualTrack)) return "visual";
+  if (sameType(reference.type, compositionTypes.audioTrack)) return "audio";
+  throw new Error(`Film Track ${reference.path} must be a VisualTrack or AudioTrack`);
+}
+
+export const decodeFilmSurface: StructuredSurfaceHandler = ({ element, resolveReference }) => {
+  exactAttributes(element, ["id", "canvas", element.attributes.space === undefined ? "semantic" : "space", "appearance"]);
+  const id = stringAttribute(element, "id");
+  const canvas = requiredReference(element, "canvas", resolveReference);
+  if (!sameType(canvas.type, spatialTypes.canvas)) {
+    throw new Error(`${element.name}.canvas must reference CanvasSpace`);
+  }
+  const time = createTemporalSpace({ id, element, ...resolveTemporalContext({ element, resolveReference }) });
+  const appearanceReference = requiredReference(element, "appearance", resolveReference);
+  const appearance = filmAppearanceFromRecipe(
+    recipe(appearanceReference, `${element.name}.appearance`).properties,
+  );
+
+  const programId = `${id}.program`;
+  const program = sealFilmProgram({
+
+    id,
+    clearColor: appearance.clearColor,
+  });
+
+  const tracks = trackChildren(element).map((child, index) => {
+    const source = requiredReference(child, "source", resolveReference);
+    const name = `track-${index + 1}`;
+    return { name, kind: trackKind(source), source };
+  });
+  if (new Set(tracks.map((track) => track.name)).size !== tracks.length) {
+    throw new Error(`${element.name} cannot include the same Track more than once`);
+  }
+  const fragment = createFilmAssemblyFragment({ name: "@hypit/film/surface-assembly@1", tracks });
+
+  return {
+    records: [{
+      id: programId,
+      type: filmTypes.program,
+      value: { kind: "inline", value: program },
+      range: element.range,
+    }],
+    components: [...time.components, {
+      id,
+      fragment: fragment.id,
+      inputs: {
+        program: { kind: "record", id: programId },
+        canvas: canvas.ref,
+        space: time.space.ref,
+        ...Object.fromEntries(tracks.map((track) => [track.name, track.source.ref])),
+      },
+      outputs: { composition: `${id}.composition` },
+      range: element.range,
+    }],
+    fragments: [...time.fragments, fragment],
+  };
+};

package/packages/film/src/types.ts

@@ -0,0 +1,26 @@
+import type { Track } from "@hypit/composition";
+
+/** Package-owned authoring value. A future Film Surface may produce this record. */
+export type FilmProgram = {
+  readonly id: string;
+  readonly clearColor: string;
+};
+
+/**
+ * Immutable package-private fold value used to collect an arbitrary number of
+ * peer Tracks without adding variadic Operation ports to Core.
+ */
+export type FilmTrackSet = {
+  readonly tracks: readonly Track[];
+};
+
+export type FilmTrackInput = {
+  /** Fragment input name used by the author module lowering this Film instance. */
+  readonly name: string;
+  readonly kind: "visual" | "audio";
+};
+
+export type FilmAssemblyFragmentOptions = {
+  readonly name?: string;
+  readonly tracks: readonly FilmTrackInput[];
+};

package/packages/film-studio/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@hypit/film-studio",
+  "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/composition": "workspace:*",
+    "@hypit/film": "workspace:*",
+    "@hypit/semantic-track": "workspace:*",
+    "@hypit/studio-adapter": "workspace:*",
+    "@hypit/program-space": "workspace:*"
+  }
+}

package/packages/film-studio/src/activation.ts

@@ -0,0 +1,8 @@
+import { createStudioCompanionHostFacet } from "@hypit/studio-adapter";
+
+import { filmStudioCompanions } from "./index.js";
+
+export default {
+  format: "hypit.node-package@1" as const,
+  hostFacets: [createStudioCompanionHostFacet({ films: filmStudioCompanions })],
+};

package/packages/film-studio/src/index.ts

@@ -0,0 +1,17 @@
+import { programSpaceTypes } from "@hypit/program-space";
+import type { StudioFilmCompanion } from "@hypit/studio-adapter";
+import { compositionTypes } from "@hypit/composition";
+import { filmModuleRef } from "@hypit/film";
+import { semanticTrackTypes } from "@hypit/semantic-track";
+
+/** Film owns the author vocabulary that selects its time source and peer Tracks. */
+export const filmStudioCompanions: readonly StudioFilmCompanion[] = [{
+  id: "film",
+  match: { module: filmModuleRef, surface: "film", outputType: compositionTypes.composition },
+  timeSources: [{ attribute: "semantic", type: semanticTrackTypes.track }, { attribute: "space", type: programSpaceTypes.programSpace }],
+  tracks: {
+    childSurface: "Track",
+    sourceAttribute: "source",
+    types: [compositionTypes.visualTrack, compositionTypes.audioTrack],
+  },
+}];

package/packages/fonts-open/README.md

@@ -0,0 +1,77 @@
+# `@hypit/fonts-open`
+
+Workspace package exposing 109 redistributable open font families as exact,
+Resource-backed `FontArtifactRef` values. The installed packages carry their font bytes and license
+files. Author compilation and rendering never download fonts or inspect system font directories.
+
+A developer who pulls this repository gets the catalog with the ordinary `pnpm install`; importing
+`@hypit/fonts-open@1` selects it. Nothing is installed globally and this package has not been
+published to npm.
+
+## One exact face
+
+```svml
+<import as="fonts" from="@hypit/fonts-open@1"/>
+
+<fonts:Face id="headline" family="archivo-black" weight="400" style="normal"/>
+```
+
+`family` is a finite catalog identifier. Weight and style must exist in that family; the package
+never snaps to a nearby weight and never silently substitutes an italic face.
+
+## A convenient multilingual and Emoji stack
+
+Emoji is normally a fallback of the chosen text face, not a separate style. `Stack` packages that
+intent into one reusable Author Graph value:
+
+```svml
+<fonts:Stack id="caption-fonts"
+  family="inter" weight="700" style="normal" emoji="color">
+  <fonts:Fallback family="noto-sans-sc" weight="700" style="normal"/>
+</fonts:Stack>
+
+<caption-fine:Style id="caption" recipe={recipes.caption.primary}
+  font={caption-fonts}/>
+```
+
+The resulting order is Inter, Noto Sans SC, then Noto Color Emoji. `emoji="color"` selects the
+pinned COLRv1 face verified in HyperFrames' Chromium renderer; `emoji="mono"` selects the
+weight-400 monochrome Noto Emoji face. Emoji stays explicit—omitting `emoji` adds no bytes. Extra
+`Fallback` children can select Arabic, Hebrew, Devanagari, Thai, Japanese, Korean or any other
+catalog family with their own honest weight/style.
+
+The package does not rewrite author text to force presentation. For characters that have both text
+and Emoji forms, write the real Unicode Emoji sequence (normally the character followed by VS16,
+for example `☎️`) when color presentation is intended. Ordinary pictographic Emoji such as `🌐`
+already have Emoji presentation. This preserves the author's exact display text while avoiding
+platform-font guesses.
+
+`Stack` is only authoring convenience. Its output is the generic `FontStackRef` media contract, so
+other packages may produce or consume the same ordered exact-face value. Caption Fine does not know
+about Fontsource, Noto or COLRv1.
+
+## Catalog
+
+The exported `openFontFamilies` map includes `label`, `category`, `intendedUse`, exact availability
+and license metadata; `openFontFamiliesByCategory` is suitable for a frontend picker.
+
+| Category | Count | Families |
+|---|---:|---|
+| Handwriting | 11 | `architects-daughter`, `caveat`, `coming-soon`, `handlee`, `kalam`, `patrick-hand`, `permanent-marker`, `playpen-sans`, `shadows-into-light`, `shantell-sans`, `short-stack` |
+| Script | 3 | `pacifico`, `pinyon-script`, `satisfy` |
+| Display | 16 | `abril-fatface`, `alfa-slab-one`, `anton`, `archivo-black`, `bangers`, `bebas-neue`, `black-ops-one`, `bungee`, `dm-serif-display`, `fredoka`, `league-spartan`, `lilita-one`, `luckiest-guy`, `oswald`, `righteous`, `unbounded` |
+| Sans | 35 | `archivo`, `barlow`, `barlow-condensed`, `cabin`, `dm-sans`, `figtree`, `fira-sans-condensed`, `geist`, `instrument-sans`, `inter`, `josefin-sans`, `jost`, `kanit`, `lato`, `lexend`, `manrope`, `montserrat`, `mulish`, `noto-sans`, `nunito-sans`, `onest`, `open-sans`, `outfit`, `plus-jakarta-sans`, `poppins`, `quicksand`, `raleway`, `rethink-sans`, `roboto`, `roboto-condensed`, `rubik`, `sora`, `space-grotesk`, `urbanist`, `work-sans` |
+| Serif | 16 | `bodoni-moda`, `cinzel`, `cormorant-garamond`, `crimson-pro`, `eb-garamond`, `fraunces`, `gloock`, `instrument-serif`, `libre-baskerville`, `lora`, `merriweather`, `newsreader`, `playfair-display`, `roboto-slab`, `source-serif-4`, `vollkorn` |
+| Monospace | 6 | `fira-code`, `geist-mono`, `ibm-plex-mono`, `jetbrains-mono`, `roboto-mono`, `space-mono` |
+| CJK | 15 | `liu-jian-mao-cao`, `long-cang`, `ma-shan-zheng`, `noto-sans-hk`, `noto-sans-jp`, `noto-sans-kr`, `noto-sans-sc`, `noto-sans-tc`, `noto-serif-jp`, `noto-serif-kr`, `noto-serif-sc`, `noto-serif-tc`, `zcool-kuaile`, `zcool-qingke-huangyou`, `zcool-xiaowei` |
+| World scripts | 5 | `noto-naskh-arabic`, `noto-sans-arabic`, `noto-sans-devanagari`, `noto-sans-hebrew`, `noto-sans-thai` |
+| Emoji | 2 | `noto-color-emoji`, `noto-emoji` |
+
+Latin variable faces intentionally load the compact Latin subset. CJK, world-script and Emoji
+families preserve every Unicode-range shard from their installed CSS as one logical face. Only
+faces referenced by the Author Graph enter a Build transfer bundle and ResourceStore.
+
+Every catalog entry is either SIL OFL 1.1 or Apache 2.0. Tests compare the declared license against
+the installed package's own metadata. Private local fonts are not bundled: public redistribution
+requires an independently verified license, and brand fonts remain
+explicit `<media:Font>` author assets.