@hypit/hypit 0.1.3 → 0.1.4

package/packages/estimate/README.md

@@ -14,9 +14,46 @@ hypit measure main.svml --segment opening --language en --pace normal
 hypit measure --text "Video editing begins with meaning." --language en --pace normal --rounding ceil
 ```
 
-The English pace presets are `slow = 4.2`, `normal = 4.6` and `fast = 5.0` syllables per second; a
-positive numeric `rate` replaces `pace`. `round` selects the nearest whole second, `ceil` a
-never-shorter one, `none` keeps the fraction.
+## Units and delivery
+
+English counts pronunciation syllables, not words or letters. Mandarin Chinese counts each Han
+character as one approximate syllable, with English syllables for embedded English words.
+Traditional and simplified Han use the same counting rule; punctuation separates words without
+adding units. This remains an approximation: connected English speech can reduce syllables,
+and Mandarin erhua can combine written characters into one syllable. An explicit `--language zh`
+keeps a Chinese passage with many English names under its intended delivery policy.
+
+Measure the spoken wording. `--segment` reads the Script's pronunciation side of Dual Text;
+`--text` reads literal speech, so spell numbers and letter names as they will be said. A count
+cannot resolve an unspecified pronunciation.
+
+| Language | slow | normal | fast | Unit |
+| --- | ---: | ---: | ---: | --- |
+| English (`en`) | 4.2 | 4.6 | 5.6 | syllables/s |
+| Mandarin Chinese (`zh`) | 4.2 | 5.25 | 6.5625 | approximate syllables/s |
+
+These are authoring starting points for whole-passage delivery, including ordinary speech pauses.
+`normal` suits conversational explanation; `fast` gives brisk, tightly delivered copy less time.
+The English fast preset is deliberately separated from normal so that choosing brisk delivery
+meaningfully changes the estimate. The Chinese normal preset is retained: available research
+does not establish that it is systematically too slow for whole passages. Neither table is a
+calibration of a particular video or voice model. For a specific delivery, a positive numeric
+`--rate` replaces the preset, including rates outside this table.
+
+```bash
+hypit measure main.svml --segment opening --language zh --pace fast --rounding round
+hypit measure main.svml --segment opening --language zh --rate 6 --rounding none
+```
+
+`seconds = pronunciation units / rate + padding`, followed by rounding. Add `--padding` for extra
+time deliberately reserved for a reaction, demonstration or held pause. Ordinary phrasing is
+already part of the chosen density; adding a generic pause allowance on top lengthens the passage
+again. `round` selects the nearest whole second, `ceil` rounds upward, and `none` keeps the fraction.
+The CLI shows the resolved rate and padding; JSON retains full numeric precision.
+
+For 60 Mandarin units, normal gives 11.43 seconds and fast gives 9.14 seconds before rounding.
+For 60 English syllables, normal gives 13.04 seconds and fast gives 10.71 seconds. Equal unit counts
+do not imply equal information, and 60 English words need not contain 60 syllables.
 
 The estimate reports the time the wording needs at that delivery. Use it to decide whether a passage
 needs merging, fuller wording, tightening, or splitting, then choose the request duration with the
@@ -30,3 +67,19 @@ performed media's semantic preparation.
 ```ts
 import { estimateSpeechDuration, sealSpeechEstimatePolicy, speechEstimatePolicyFromRecipe } from "@hypit/estimate";
 ```
+
+## Research basis and limits
+
+[Burchfield and Bradlow (2014)](https://doi.org/10.1121/1.4874357) measured Mandarin and English
+across clear reading, plain reading and spontaneous speech. Plain-reading means were 5.97 and
+5.39 canonical syllables/s respectively. Their articulation measure excludes errors, silence
+and non-speech, so those means cannot directly size an entire performance containing pauses.
+[Coupé et al. (2019)](https://doi.org/10.1126/sciadv.aaw2594) likewise counted canonical syllables
+and excluded pauses longer than 150 ms in their cross-language reading study. These studies
+support distinguishing language, pronunciation units and timing denominator; they do not
+establish one ideal pace for social video or validate these preset values.
+
+When an already understood reference passage provides useful timing, its spoken-unit count
+divided by its first-to-last-word span offers a starting density, including internal pauses.
+Choose how much of that rhythm belongs in the new performance. Requested clip length alone
+is not measured speaking time, and delivery density does not describe emphasis or expression.

package/packages/estimate/src/program.ts

@@ -14,9 +14,9 @@ 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.
+  // Authoring delivery densities, including ordinary pauses, not measured model
+  // guarantees or pause-free articulation rates. See README for units and rationale.
+  en: { slow: 4.2, normal: 4.6, fast: 5.6 },
   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 },
@@ -35,7 +35,7 @@ function looksSpanish(text: string): boolean {
 }
 
 export function detectSpeechEstimateLanguage(text: string): ResolvedSpeechEstimateLanguage {
-  const han = (text.match(/[\u3400-\u9fff]/gu) ?? []).length;
+  const han = (text.match(/\p{Script=Han}/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";
@@ -117,10 +117,9 @@ export function countSpeechEstimateUnits(
   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)
+    const characters = /[\p{Script=Han}\u3040-\u30ff]/gu;
+    const cjk = (text.match(characters) ?? []).length;
+    const latin = words(text.replace(characters, " "))
       .filter((word) => /[A-Za-z]/u.test(word));
     return cjk + latin.reduce((sum, word) => sum + englishSyllables(word), 0);
   }

package/packages/fonts-open/README.md

@@ -1,5 +1,10 @@
 # `@hypit/fonts-open`
 
+The optional `@hypit/fonts-open/studio` export supplies data-only catalog choices for Companions.
+`openFontStudioFields(owner)` returns the explicit nested font binding and Inspector fields for a
+Style reference such as `program` or `style`. It edits the referenced catalog face's family, keeping
+its authored weight, style and fallback faces. Ordinary font validation still applies.
+
 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.

package/packages/fonts-open/package.json

@@ -5,7 +5,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./studio": "./src/studio.ts"
   },
   "hypit": {
     "activation": "./src/activation.ts"
@@ -126,5 +127,8 @@
     "@hypit/package-loader-node": "workspace:*",
     "@hypit/protocol": "workspace:*",
     "@hypit/markup": "workspace:*"
+  },
+  "devDependencies": {
+    "@hypit/studio-adapter": "workspace:*"
   }
 }

package/packages/fonts-open/src/studio.ts

@@ -0,0 +1,21 @@
+import type { StudioInspectorFieldDeclaration, StudioSourceBindingDeclaration } from "@hypit/studio-adapter";
+import { openFontFamilies } from "./catalog.js";
+
+/** Optional Companion declarations for the primary catalog face reached through a Style's font. */
+export function openFontStudioFields(owner: string): {
+  readonly binding: StudioSourceBindingDeclaration;
+  readonly fields: readonly StudioInspectorFieldDeclaration[];
+} {
+  return {
+    binding: { name: "font", referenced: [{ name: "family", writable: true }] },
+    fields: [{
+      binding: `${owner}.font.family`, label: "Font Family", domain: "how",
+      page: { id: "font", label: "Font" }, section: { id: "face", label: "Primary Face" },
+      summary: "Changes the shared catalog face. Its authored weight and style must be available in the selected family.",
+      control: "select",
+      options: Object.entries(openFontFamilies).map(([value, family]) => ({
+        value, label: family.label, description: `${family.category} · ${family.intendedUse}`,
+      })),
+    }],
+  };
+}

package/packages/media-track-studio/src/index.ts

@@ -58,7 +58,7 @@ placeMedia([
 placeMedia(["stack-order"], "where", "Frame", "Stacking");
 placeMedia(["clip", "radius", "padding"], "where", "Frame", "Geometry");
 placeMedia(["opacity", "blur", "brightness", "contrast", "saturation"], "how", "Image", "Image");
-placeMedia(["playback", "trim-start", "trim-end"], "how", "Playback", "Playback");
+placeMedia(["playback", "trim-start", "trim-end"], "when", "Playback", "Playback");
 placeMedia(["border-width", "border-style", "border-color", "shadows", "frame-paint"], "how", "Frame", "Paint");
 placeMedia(["enter", "enter-frames", "enter-easing", "enter-direction", "enter-amount", "enter-origin"], "when", "Enter", "Enter");
 placeMedia(["sustain"], "when", "Sustain", "Sustain");
@@ -66,6 +66,8 @@ placeMedia(["exit", "exit-frames", "exit-easing", "exit-direction", "exit-amount
 
 const mediaColorProperties = new Set(["border-color"]);
 const mediaTextProperties = new Set(["padding", "shadows", "frame-paint", "sustain"]);
+const mediaPercentProperties = new Set(["frame-x", "frame-y", "content-x", "content-y", "opacity", "brightness", "contrast", "saturation"]);
+const mediaPixelProperties = new Set(["fit-offset-x", "fit-offset-y", "radius", "blur", "border-width"]);
 
 function mediaRecipe(name: "appearance" | "motion"): {
   readonly bindings: readonly { readonly name: string }[];
@@ -88,6 +90,9 @@ function mediaRecipe(name: "appearance" | "motion"): {
         ...placement,
         ...(property.summary === undefined ? {} : { summary: property.summary }),
         control,
+        ...(mediaPercentProperties.has(property.name) ? { unit: "%", number: { scale: 100, step: 1 } } : {}),
+        ...(mediaPixelProperties.has(property.name) ? { unit: "px", number: { step: 1 } } : {}),
+        ...(["enter-frames", "exit-frames", "trim-start", "trim-end"].includes(property.name) ? { unit: "f", number: { step: 1 } } : {}),
         ...(options === undefined ? {} : { options }),
       };
     }),
@@ -209,7 +214,7 @@ export const mediaTrackStudioTrackCompanions: readonly StudioTrackCompanion[] =
       ...frameParameters.filter(({ writable }) => writable === true).map(({ name }) => ({
         binding: `frame.${name}`, label: title(name), domain: "where" as const,
         page: { id: frameSizeParameters.has(name) ? "size" : "placement", label: frameSizeParameters.has(name) ? "Size" : "Placement" },
-        section: { id: "frame", label: "Frame" }, control: "text" as const,
+        section: { id: "frame", label: "Frame" }, control: "number" as const, number: { suffixes: ["%", "px"], step: 1 },
       })),
       ...extentParameters.map(({ name }) => ({
         binding: `extent.${name}`, label: title(name), domain: "where" as const,

package/packages/provider-whisperx-local/README.md

@@ -30,6 +30,41 @@ Provider; it is a different deployment package but must return the same
 The configured model, device, compute mode and batch size are checked through `/health` before use.
 This prevents a warm process with an incompatible inference configuration from accepting work.
 
+## Choose model and hardware
+
+The default `small` / `cpu` / `int8` is a modest-machine execution default, not a quality ranking.
+For multilingual transcription with quality as the priority and suitable hardware, consider
+`large-v3`. For example, an NVIDIA CUDA installation with sufficient memory can explicitly select:
+
+```json
+"whisperx.local": {
+  "use": "@hypit/provider-whisperx-local",
+  "config": {
+    "expectedModel": "large-v3",
+    "expectedDevice": "cuda",
+    "expectedCompute": "float16",
+    "expectedBatchSize": 4
+  }
+}
+```
+
+This is an example deployment, not a promise that every GPU has enough memory. Adjust batch size
+and compute mode for the actual device. On CPU, `int8` is the practical starting point; a larger
+model still takes more preparation and inference work. The packaged faster-whisper backend uses
+CTranslate2: Apple Silicon does not imply CUDA or support for a PyTorch `mps` setting here.
+An already ready smaller model can be useful for a short clear reference. Choose the local model
+or hosted service for the actual language, material and time available rather than installing
+successively larger models as a routine sequence.
+
+`expectedModel` selects speech recognition. WhisperX separately loads the language-specific
+alignment model when that language is first requested. A larger ASR model can improve the words
+fed into alignment, but does not select a larger aligner or guarantee better timing by itself.
+The health response identifies the loaded ASR configuration; it does not establish that every
+language's alignment weights are cached. See [WhisperX usage](https://github.com/m-bain/whisperX#usage-)
+and [faster-whisper deployment](https://github.com/SYSTRAN/faster-whisper#usage).
+
+## Preparation and downloads
+
 The Runtime installs and starts the packaged service in the machine Program Home when this Endpoint
 is selected. The environment is reused across projects and sessions. The current local package and
 service are trusted code; this is not a community-plugin sandbox.
@@ -42,3 +77,25 @@ its configuration through `/health`. Inspect an existing Profile's address and e
 when locating that service. A custom `serviceCommand` supplies its own installation and start command.
 `hypit programs status` checks the Programs selected by the supplied Profile; `programs up` prepares
 and starts them. The managed installation does not require a global `whisperx` shell command.
+
+Preparation and service processes inherit the environment of the command starting them. Set
+network and cache variables there before `programs up` or `runtime up`. A service already running
+retains its earlier environment. Inspect its reported log before deciding whether a selected
+Program needs restarting, and account for active work using it.
+
+Preparation commands write `install.log`; the running service writes `program.log`, with stderr in
+`program.err.log` on Windows. Inspect the stderr file for Python model-loading and download messages.
+The service health endpoint becomes available after ASR loading. A startup readiness wait expiring
+can leave that process still loading; check its reported PID and logs before starting another process.
+
+Python installation, Python packages, NLTK sentence data, ASR weights and language-alignment weights
+are separate downloads. `UV_PYTHON_INSTALL_MIRROR` configures a Python distribution mirror;
+`HF_ENDPOINT` and `HF_HOME` configure Hugging Face access/cache. Alignment models can also come
+from torchaudio's download hosts. These settings do not redirect NLTK's own downloader.
+
+Managed installation uses `uv sync --frozen` with the distributed lockfile, including its artifact
+URLs. `PIP_INDEX_URL` does not configure uv, and `UV_DEFAULT_INDEX` is an index-resolution setting,
+not a general rewrite of those frozen URLs. Inspect the actual transfer destination. For blocked
+locked downloads, use an appropriate network/proxy route or an already populated compatible cache;
+an operator-managed installation can instead provide `serviceCommand` with the expected service
+identity. Ordinary production keeps the distributed dependency selection intact.

package/packages/ranking/src/render.ts

@@ -183,6 +183,7 @@ function iconElement(input: {
 
 function present(input: {
   readonly id: string;
+  readonly subjectId: string;
   readonly start: number;
   readonly end: number;
   readonly stacking: number;
@@ -191,6 +192,7 @@ function present(input: {
 }): VisualPresent {
   return {
     id: input.id,
+    subjectId: input.subjectId,
     span: { startFrame: input.start, endFrameExclusive: input.end },
     stacking: { order: input.stacking, tieBreak: input.tieBreak },
     elements: input.elements,
@@ -307,7 +309,7 @@ export function renderTierBoard(space: ProgramSpace, program: TierBoardProgram):
     }));
   }
   presents.push(present({
-    id: `${program.id}:board`, start: schedule.outer.startFrame, end: schedule.outer.endFrameExclusive,
+    id: `${program.id}:board`, subjectId: program.id, start: schedule.outer.startFrame, end: schedule.outer.endFrameExclusive,
     stacking: style.boardStackingOrder, tieBreak: `${program.id}:0000:board`, elements: boardElements,
   }));
   const entries = new Map(schedule.entries.map((entry) => [entry.itemId, entry]));
@@ -351,7 +353,7 @@ export function renderTierBoard(space: ProgramSpace, program: TierBoardProgram):
         : (localFrame) => fromHighTierItemPose(
             localFrame, duration, stage, absoluteCell, style.motion.appearFrames, style.motion.moveFrames));
       presents.push(present({
-        id: `${program.id}:item:${item.id}:reveal`,
+        id: `${program.id}:item:${item.id}:reveal`, subjectId: item.id,
         start: entry.window.startFrame,
         end: entry.window.endFrameExclusive,
         stacking: item.stackingOrder ?? (item.entry === "drop" ? style.stageStackingOrder : style.itemStackingOrder),
@@ -360,7 +362,7 @@ export function renderTierBoard(space: ProgramSpace, program: TierBoardProgram):
       }));
     }
     if (entry.settled.endFrameExclusive > entry.settled.startFrame) presents.push(present({
-      id: `${program.id}:item:${item.id}:settled`,
+      id: `${program.id}:item:${item.id}:settled`, subjectId: item.id,
       start: entry.settled.startFrame,
       end: entry.settled.endFrameExclusive,
       stacking: item.stackingOrder ?? style.itemStackingOrder,
@@ -506,7 +508,7 @@ export function renderColumn(space: ProgramSpace, program: ColumnProgram): Visua
       ],
     }));
   }
-  presents.push(present({ id: `${program.id}:board`, start: schedule.outer.startFrame, end: schedule.outer.endFrameExclusive,
+  presents.push(present({ id: `${program.id}:board`, subjectId: program.id, start: schedule.outer.startFrame, end: schedule.outer.endFrameExclusive,
     stacking: style.boardStackingOrder, tieBreak: `${program.id}:0000:board`, elements: boardElements }));
   for (const [index, item] of program.items.entries()) {
     const entry = entries.get(item.id)!;
@@ -549,13 +551,13 @@ export function renderColumn(space: ProgramSpace, program: ColumnProgram): Visua
         stageSize: style.stageSizePx, finalSize: contentSize, easing: style.motion.easing,
       });
       presents.push(present({
-        id: `${program.id}:item:${item.id}:stage`, start: entry.window.startFrame, end: entry.window.endFrameExclusive,
+        id: `${program.id}:item:${item.id}:stage`, subjectId: item.id, start: entry.window.startFrame, end: entry.window.endFrameExclusive,
         stacking: item.stackingOrder ?? style.stageStackingOrder,
         tieBreak: `${program.id}:item:${String(item.rank).padStart(4, "0")}:${item.id}:stage`, elements: itemElements(rootAnimation),
       }));
     }
     if (entry.settled.endFrameExclusive > entry.settled.startFrame) presents.push(present({
-      id: `${program.id}:item:${item.id}:settled`, start: entry.settled.startFrame, end: entry.settled.endFrameExclusive,
+      id: `${program.id}:item:${item.id}:settled`, subjectId: item.id, start: entry.settled.startFrame, end: entry.settled.endFrameExclusive,
       stacking: item.stackingOrder ?? style.itemStackingOrder,
       tieBreak: `${program.id}:item:${String(item.rank).padStart(4, "0")}:${item.id}:settled`, elements: itemElements(),
     }));
@@ -599,7 +601,7 @@ export function renderTopThree(space: ProgramSpace, program: TopThreeProgram): V
     }));
   }
   const presents: VisualPresent[] = [present({
-    id: `${program.id}:slots`, start: schedule.outer.startFrame, end: schedule.outer.endFrameExclusive,
+    id: `${program.id}:slots`, subjectId: program.id, start: schedule.outer.startFrame, end: schedule.outer.endFrameExclusive,
     stacking: style.boardStackingOrder, tieBreak: `${program.id}:0000:slots`, elements: boardElements,
   })];
   for (const [index, item] of program.items.entries()) {
@@ -640,12 +642,12 @@ export function renderTopThree(space: ProgramSpace, program: TopThreeProgram): V
       return elements;
     };
     presents.push(present({
-      id: `${program.id}:item:${item.id}:stage`, start: entry.stage.startFrame, end: entry.stage.endFrameExclusive,
+      id: `${program.id}:item:${item.id}:stage`, subjectId: item.id, start: entry.stage.startFrame, end: entry.stage.endFrameExclusive,
       stacking: item.stackingOrder ?? style.itemStackingOrder,
       tieBreak: `${program.id}:item:${String(index).padStart(4, "0")}:${item.id}:stage`, elements: itemElements(true),
     }));
     if (entry.settled.endFrameExclusive > entry.settled.startFrame) presents.push(present({
-      id: `${program.id}:item:${item.id}:settled`, start: entry.settled.startFrame, end: entry.settled.endFrameExclusive,
+      id: `${program.id}:item:${item.id}:settled`, subjectId: item.id, start: entry.settled.startFrame, end: entry.settled.endFrameExclusive,
       stacking: item.stackingOrder ?? style.itemStackingOrder,
       tieBreak: `${program.id}:item:${String(index).padStart(4, "0")}:${item.id}:settled`, elements: itemElements(false),
     }));

package/packages/ranking-studio/README.md

@@ -1,3 +1,14 @@
 # `@hypit/ranking-studio`
 
 Hypit Studio Companion for the Ranking module's Column, Tier and Top Three surfaces.
+
+The root lane represents the board; `attachments` expose reveal or activation
+events on a detail lane. Both use Studio's ordinary item selection and overlap
+behavior. Their time ranges remain the authored event ranges.
+
+Ranking's renderer assigns `subjectId` to each item's rendered phases. The
+Companion associates those phases with the item's `renderIds`, so clicking an
+entering or settled icon selects the same detail entity. The board and preset
+items without a detail event remain associated with the root. Studio measures
+the visible parts at the current frame; the Companion does not duplicate motion
+geometry or infer identities from rendered ID strings.

package/packages/ranking-studio/package.json

@@ -4,11 +4,16 @@
   "license": "SEE LICENSE IN LICENSE",
   "private": true,
   "type": "module",
-  "exports": { ".": "./src/index.ts" },
-  "hypit": { "activation": "./src/activation.ts" },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "hypit": {
+    "activation": "./src/activation.ts"
+  },
   "dependencies": {
     "@hypit/ranking": "workspace:*",
     "@hypit/composition": "workspace:*",
-    "@hypit/studio-adapter": "workspace:*"
+    "@hypit/studio-adapter": "workspace:*",
+    "@hypit/fonts-open": "workspace:*"
   }
 }

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

@@ -1,9 +1,13 @@
+import { openFontStudioFields } from "@hypit/fonts-open/studio";
 import { rankingMarkupSurfaces, rankingModuleRef, rankingTypes } from "@hypit/ranking";
 import type { RankingProgram, RankingSchedule } from "@hypit/ranking";
 import { compositionTypes } from "@hypit/composition";
 import type { StudioTrackCompanion, StudioTrackCompanionContext, StudioEntityDraft, StudioInspectorFieldDeclaration, StudioSourceBindingDeclaration } from "@hypit/studio-adapter";
 import { artifactPreview, authoredChildFor, previewLayer, requiredSurfaceValue, temporalLineageFor, temporalSemanticSource } from "@hypit/studio-adapter";
 
+
+const fontInspector = openFontStudioFields("style");
+
 const frameParameters: readonly StudioSourceBindingDeclaration[] = [
   { name: "within" },
   ...["left", "top", "right", "bottom", "x", "y", "width", "height"].map((name) => ({ name, writable: true })),
@@ -76,7 +80,7 @@ const rankingInspectorPlacement = {
 } as const satisfies Readonly<Record<string, RankingInspectorPlacement>>;
 
 function rankingInspector(surface: "column-style" | "tier-style" | "top-three-style"): readonly StudioInspectorFieldDeclaration[] {
-  return rankingProperties(surface).map((property) => {
+  return [...fontInspector.fields, ...rankingProperties(surface).map((property) => {
     const placement = rankingInspectorPlacement[property.name as keyof typeof rankingInspectorPlacement];
     if (placement === undefined) throw new Error(`Ranking Studio has no explicit placement for ${property.name}.`);
     return {
@@ -85,12 +89,13 @@ function rankingInspector(surface: "column-style" | "tier-style" | "top-three-st
       ...placement,
       ...(property.summary === undefined ? {} : { summary: property.summary }),
     };
-  });
+  })];
 }
 
 function rankingStyle(surface: "column-style" | "tier-style" | "top-three-style"): StudioSourceBindingDeclaration {
   return {
     name: "style",
+    referenced: [fontInspector.binding],
     recipe: { through: ["recipe"], bindings: rankingProperties(surface).map(({ name, schema, fallback }) => ({
       name,
       schema,
@@ -133,6 +138,7 @@ function projectRanking(context: StudioTrackCompanionContext): readonly StudioEn
     return [{
       id: `${context.track.outputRef}:entity:${entry.itemId}`,
       authoredId: entry.itemId,
+      renderIds: context.spans.filter((span) => span.subjectId === entry.itemId).map((span) => span.id),
       ...(semanticSource?.id === undefined ? {} : { markerId: semanticSource.id }),
       display: {
         title: label,
@@ -147,7 +153,8 @@ function projectRanking(context: StudioTrackCompanionContext): readonly StudioEn
       ...(temporal === undefined ? {} : { temporal }),
     }];
   }).sort((left, right) => left.startFrame - right.startFrame || left.id.localeCompare(right.id));
-  return [group, ...reveals];
+  const childRenderIds = new Set(reveals.flatMap((entity) => entity.renderIds ?? []));
+  return [{ ...group, renderIds: group.renderIds!.filter((id) => !childRenderIds.has(id)) }, ...reveals];
 }
 
 const commonBindings: readonly StudioSourceBindingDeclaration[] = [
@@ -160,7 +167,7 @@ const frameInspector: readonly StudioInspectorFieldDeclaration[] = frameParamete
   .filter(({ writable }) => writable === true)
   .map(({ name }) => ({
     binding: `frame.${name}`, label: title(name), domain: "where",
-    page: { id: "frame", label: "Frame" }, section: { id: "frame", label: "Frame" }, control: "text",
+    page: { id: "frame", label: "Frame" }, section: { id: "frame", label: "Frame" }, control: "number", number: { suffixes: ["%", "px"], step: 1 },
   }));
 
 export const rankingStudioTrackCompanions: readonly StudioTrackCompanion[] = [

package/packages/runtime/src/catalog.ts

@@ -3,6 +3,8 @@ import type {
 } from "@hypit/protocol";
 
 export type BuildPublishedOutput = {
+  /** Author-provided display name; the Output identifier remains unchanged. */
+  readonly displayName?: string;
   readonly name: string;
   readonly ref: LogicalOutputRef;
 };

package/packages/runtime-host-node/src/index.ts

@@ -119,6 +119,7 @@ export type RuntimeHostExecution = RuntimeHostControl & RuntimeHostCredentialCon
       readonly repository: BuildResultRepositoryLocation;
       readonly title?: string;
       readonly forwards?: readonly BuildResultForward[];
+      readonly resourceReferences?: Readonly<Record<string, import("@hypit/build-result").BuildResultFileRef>>;
     };
   }, options?: {
     readonly follow?: boolean;

package/packages/runtime-local/README.md

@@ -3,6 +3,16 @@
 The default local Runtime for Hypit. It owns the Worker, scheduler and active SQLite execution
 worklist. Project-owned Build Results hold finished public Outputs.
 
+Managed Program preparation writes subprocess stdout and stderr directly to that Program's
+`install.log`, so dependency-download output is readable before installation finishes. Installation
+and startup progress expose `logPath`; failed installation reports retain it with a short error.
+The files belong to the Program's configured state directory. Service output uses `program.log`
+and, on Windows, a separate `program.err.log` for stderr. Keeping installation output separate
+preserves it when Windows opens fresh service logs at startup.
+The CLI retains Program failure reasons, PIDs and log paths in `programs` and `runtime up` reports.
+Human output stays compact for successful preparation; `programs status --verbose` also shows
+ready helpers, and JSON retains the reported details independently of verbosity.
+
 A Runtime Profile selects only the environmental parts that genuinely vary:
 
 ```json
@@ -94,6 +104,15 @@ through the same adapter registry as an explicit `@hypit/build-result-s3` select
 filesystem Repository shortcut.
 Runtime working Resources remain internal and Build-local; there is no ResourceStore selector. After
 a Result has an outcome, history is read from the selected repository, not Runtime SQLite.
+The submission passes known Resource references to the Result writer, separately from the execution
+graph. Staging bytes for a running Build does not make them new Result files: external and reused
+resources keep their addresses even when a Producer embeds them inside a new Composite value.
+
+While execution advances, Result synchronization publishes newly accepted public Outputs. The
+repository leaves its files or objects untouched when no new public Output is available; internal
+execution progress remains in SQLite. Once execution has a final decision, all accepted public Outputs
+and the outcome are saved before active state and working Resources are removed. This order applies
+to completed, failed and cancelled Builds alike.
 
 Saving a finished Result is a separate, idempotent storage action. If that write is interrupted, the
 Build keeps its already-decided outcome and reports exact operator attention. `hypit result finish

package/packages/runtime-local/src/programs.ts

@@ -36,6 +36,7 @@ export type ManagedProgramReport = {
 export type ManagedProgramProgress = {
   readonly id: string;
   readonly phase: "checking" | "installing" | "starting" | "waiting" | "ready";
+  readonly logPath?: string;
 };
 
 export type ManagedProgramOptions = LoadRuntimeConfigOptions & {
@@ -97,24 +98,31 @@ async function readPid(root: string, program: ManagedProgram): Promise<number |
   }
 }
 
-function run(root: string, command: ManagedProgramCommand): Promise<{ ok: boolean; detail: string }> {
-  return new Promise((resolve) => {
-    const child = spawn(command.command, [...command.args], {
-      cwd: command.cwd ?? root,
-      env: { ...process.env, ...command.env },
-      shell: false,
-      windowsHide: true,
-      stdio: ["ignore", "pipe", "pipe"],
+async function run(root: string, command: ManagedProgramCommand, logPath: string): Promise<{ ok: boolean; detail: string }> {
+  const log = await open(logPath, "a+");
+  try {
+    const offset = (await log.stat()).size;
+    const exit = await new Promise<{ code: number | null; error?: string }>((resolve) => {
+      const child = spawn(command.command, [...command.args], {
+        cwd: command.cwd ?? root,
+        env: { ...process.env, ...command.env },
+        shell: false,
+        windowsHide: true,
+        stdio: ["ignore", log.fd, log.fd],
+      });
+      child.on("error", (error) => resolve({ code: null, error: error.message }));
+      child.on("close", (code) => resolve({ code }));
     });
-    let output = "";
-    child.stdout.on("data", (chunk: Buffer) => { output += chunk.toString(); });
-    child.stderr.on("data", (chunk: Buffer) => { output += chunk.toString(); });
-    child.on("error", (error) => resolve({ ok: false, detail: error.message }));
-    child.on("close", (code) => resolve({
-      ok: code === 0,
-      detail: code === 0 ? "" : (output.trim().split("\n").at(-1) ?? `exited ${code}`),
-    }));
-  });
+    if (exit.code === 0) return { ok: true, detail: "" };
+    const end = (await log.stat()).size;
+    const start = Math.max(offset, end - 8192);
+    const tail = Buffer.alloc(end - start);
+    const { bytesRead } = await log.read(tail, 0, tail.length, start);
+    const line = tail.subarray(0, bytesRead).toString().trim().split(/\r?\n/u).at(-1);
+    return { ok: false, detail: exit.error ?? (line || `exited ${exit.code}`) };
+  } finally {
+    await log.close();
+  }
 }
 
 /**
@@ -254,20 +262,23 @@ async function bringUp(
   }
 
   let installed = false;
+  const logPath = join(directory(root, program), "program.log");
+  const installLogPath = join(directory(root, program), "install.log");
   if (program.installation !== undefined) {
     const installation = await program.installation.probe();
     if (installation.state !== "ready") {
-      onProgress?.({ id: program.id, phase: "installing" });
       await mkdir(directory(root, program), { recursive: true });
+      await rotateLog(installLogPath);
+      onProgress?.({ id: program.id, phase: "installing", logPath: installLogPath });
       for (const command of program.installation.commands) {
-        const result = await run(root, command);
+        const result = await run(root, command, installLogPath);
         if (!result.ok) {
-          return { ...base, action: "unchanged", state: initial, detail: `${command.command} failed: ${result.detail}` };
+          return { ...base, action: "unchanged", state: initial, logPath: installLogPath, detail: `${command.command} failed: ${result.detail}` };
         }
       }
       const after = await program.installation.probe();
       if (after.state !== "ready") {
-        return { ...base, action: "unchanged", state: initial, detail: `installation is ${after.state}: ${after.detail}` };
+        return { ...base, action: "unchanged", state: initial, logPath: installLogPath, detail: `installation is ${after.state}: ${after.detail}` };
       }
       installed = true;
     }
@@ -276,12 +287,16 @@ async function bringUp(
     // Nothing to keep running: installation was the whole job.
     const state = await program.probe();
     if (state.state === "ready") onProgress?.({ id: program.id, phase: "ready" });
-    return { ...base, action: state.state === "ready" && installed ? "installed" : "unchanged", state };
+    return {
+      ...base,
+      action: state.state === "ready" && installed ? "installed" : "unchanged",
+      state,
+      ...(installed ? { logPath: installLogPath } : {}),
+    };
   }
 
-  onProgress?.({ id: program.id, phase: "starting" });
+  onProgress?.({ id: program.id, phase: "starting", logPath });
   await mkdir(directory(root, program), { recursive: true });
-  const logPath = join(directory(root, program), "program.log");
   await rotateLog(logPath);
   const log = await open(logPath, "a");
   try {

package/packages/runtime-local/src/runtime.ts

@@ -268,6 +268,7 @@ export async function createLocalRuntime(
       try {
         const publishedOutputs = request.catalog.publishedOutputs.map((published) => ({
           name: published.name,
+          ...(published.displayName === undefined ? {} : { displayName: published.displayName }),
           output: published.ref.id,
         }));
         const names = new Map<string, string>();
@@ -291,6 +292,7 @@ export async function createLocalRuntime(
           targets,
           publishedOutputs,
           ...(resultRequest.forwards === undefined ? {} : { forwards: resultRequest.forwards }),
+          ...(resultRequest.resourceReferences === undefined ? {} : { resourceReferences: resultRequest.resourceReferences }),
         });
       } finally {
         await opened.close?.();