@hypit/hypit 0.0.1 → 0.1.1

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

@@ -0,0 +1,109 @@
+import type {
+  FrameSpan,
+  VisualAnimation,
+  VisualColorPaint,
+  VisualTextDocument,
+  VisualTextFlow,
+  VisualTextPaintLayer,
+  VisualTextSequenceAnimation,
+  VisualTextTypography,
+} from "@hypit/composition";
+import type { SpatialFrame, SpatialPath, SpatialPoint } from "@hypit/spatial";
+
+export type TextDocument = VisualTextDocument;
+export type TextTypography = VisualTextTypography;
+export type TextPaint = VisualColorPaint;
+export type TextPaintLayer = VisualTextPaintLayer;
+
+export type TextAreaFlow = Omit<VisualTextFlow, "form">;
+
+export type TextStyle = {
+  readonly id: string;
+  readonly stackingOrder: number;
+  readonly typography: TextTypography;
+  readonly paints: readonly TextPaintLayer[];
+  readonly area: TextAreaFlow;
+  readonly point: {
+    readonly anchorInline: "start" | "center" | "end";
+    readonly anchorBlock: "start" | "center" | "end";
+  };
+  readonly path: {
+    readonly side: "left" | "right";
+    readonly orientation: "follow" | "upright";
+    readonly startMarginPx: number;
+    readonly endMarginPx: number;
+    readonly align: "start" | "center" | "end";
+    readonly reverse: boolean;
+    readonly overflow: "visible" | "clip";
+  };
+};
+
+export type TextMotion = {
+  readonly id: string;
+  readonly item?: VisualAnimation;
+  readonly sequences: readonly VisualTextSequenceAnimation[];
+  readonly pathMargin?: {
+    readonly keyframes: readonly {
+      readonly atFrame: number;
+      readonly startMarginPx: number;
+      readonly easing?: "linear" | "ease-in" | "ease-out" | "ease-in-out";
+    }[];
+  };
+};
+
+export type TextGeometry =
+  | { readonly kind: "point"; readonly point: SpatialPoint }
+  | { readonly kind: "area"; readonly frame: SpatialFrame }
+  | { readonly kind: "path"; readonly path: SpatialPath };
+
+export type TextPlacement = {
+  readonly geometry: TextGeometry;
+};
+
+export type TextItemSpec = {
+  readonly id: string;
+  readonly document: TextDocument;
+};
+
+/**
+ * Author/runtime-independent part of one plain-text item. The actual copy is
+ * supplied by an ordinary @hypit/text Text edge and materialized into a
+ * TextItemSpec before temporal projection.
+ */
+export type PlainTextItemSpec = {
+  readonly id: string;
+};
+
+export type TextItem = {
+  readonly id: string;
+  readonly span: FrameSpan;
+  readonly geometry: TextGeometry;
+  readonly document: TextDocument;
+  readonly style: TextStyle;
+  readonly motion: TextMotion;
+  readonly tieBreak: string;
+};
+
+export type TypographyTrackProgram = {
+  readonly id: string;
+  readonly items: readonly TextItem[];
+};
+
+/**
+ * Separate graph contract for revealing one explicitly supplied owned Surface
+ * through an already authored Text Program. It is not a TextStyle mode and it
+ * never samples another Track or the final composite.
+ */
+export type TextMaskSpec = {
+  readonly id: string;
+  readonly mode: "alpha" | "luminance";
+  readonly materialFit: "contain" | "cover" | "fill";
+};
+
+export type TypographyTrackHeader = {
+  readonly id: string;
+};
+
+export type TypographyTrackSet = {
+  readonly items: readonly TextItem[];
+};

package/packages/typography-track-studio/README.md

@@ -0,0 +1,3 @@
+# `@hypit/typography-track-studio`
+
+Hypit Studio Companion for `@hypit/typography-track`.

package/packages/typography-track-studio/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@hypit/typography-track-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/studio-adapter": "workspace:*",
+    "@hypit/typography-track": "workspace:*"
+  }
+}

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

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

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

@@ -0,0 +1,116 @@
+import { typographyTrackMarkupSurfaces, typographyTrackModuleRef, typographyTrackTypes } from "@hypit/typography-track";
+import type { TypographyTrackProgram } from "@hypit/typography-track";
+import { compositionTypes } from "@hypit/composition";
+import type { StudioTrackCompanion, StudioTrackCompanionContext, StudioEntityDraft, StudioInspectorFieldDeclaration } from "@hypit/studio-adapter";
+import { childEntities, requiredSurfaceValue, temporalLineageFor, temporalSemanticSource, textLayer } from "@hypit/studio-adapter";
+
+const typographyProperties = (typographyTrackMarkupSurfaces
+  .find((surface) => surface.name === "style")?.vocabulary.attributes
+  .find((attribute) => attribute.name === "recipe")?.recipe ?? []);
+
+function title(name: string): string {
+  return name.split("-").map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+
+function valuesFor(property: typeof typographyProperties[number]): readonly string[] | undefined {
+  return "values" in property ? property.values : undefined;
+}
+
+type TypographyPlacement = Pick<StudioInspectorFieldDeclaration, "domain" | "page" | "section">;
+
+function typographyPlace(domain: "where" | "how", page: string, section: string): TypographyPlacement {
+  const id = section.toLowerCase().replaceAll(" ", "-");
+  return { domain, page: { id: page.toLowerCase(), label: page }, section: { id, label: section } };
+}
+
+const typographyPlacement = new Map<string, TypographyPlacement>();
+function placeTypography(names: readonly string[], domain: "where" | "how", page: string, section: string): void {
+  for (const name of names) typographyPlacement.set(name, typographyPlace(domain, page, section));
+}
+
+placeTypography(["stack-order"], "where", "Layout", "Stacking");
+placeTypography([
+  "inline-size", "block-size", "padding", "align", "block-align", "wrap", "overflow", "max-lines",
+  "minimum-scale", "clip", "columns", "column-gap",
+], "where", "Layout", "Area");
+placeTypography(["point-anchor-inline", "point-anchor-block"], "where", "Layout", "Point");
+placeTypography([
+  "path-side", "path-orientation", "path-start-margin", "path-end-margin", "path-align", "path-reverse", "path-overflow",
+], "where", "Layout", "Path");
+placeTypography([
+  "size", "weight", "font-style", "line-height", "tracking", "word-spacing", "kerning", "synthesis", "language",
+  "direction", "writing-mode", "baseline-shift", "vertical-align", "tab-size", "indent", "paragraph-before",
+  "paragraph-after", "transform", "caps", "cjk-spacing", "punctuation-trim", "metric-edge",
+], "how", "Typography", "Typography");
+placeTypography(["fill"], "how", "Paint", "Fill");
+
+const typographyColorProperties = new Set(["fill"]);
+const typographyTextProperties = new Set(["language", "cjk-spacing", "punctuation-trim", "padding"]);
+
+const typographyInspector: readonly StudioInspectorFieldDeclaration[] = typographyProperties.map((property) => {
+  const placement = typographyPlacement.get(property.name);
+  if (placement === undefined) throw new Error(`Typography Studio has no explicit Inspector declaration for ${property.name}.`);
+  const options = valuesFor(property);
+  return {
+    binding: `style.${property.name}`, label: title(property.name), ...placement,
+    ...(property.summary === undefined ? {} : { summary: property.summary }),
+    control: options !== undefined ? "select" : typographyColorProperties.has(property.name) ? "color"
+      : typographyTextProperties.has(property.name) ? "text" : "number",
+    ...(options === undefined ? {} : { options }),
+  };
+});
+
+function textOf(item: TypographyTrackProgram["items"][number]): string {
+  return item.document.paragraphs.map((paragraph) => paragraph.inlines
+    .map((inline) => inline.kind === "text" ? inline.text : " ")
+    .join(""))
+    .join(" ")
+    .replace(/\s+/gu, " ")
+    .trim();
+}
+
+function projectTypography(context: StudioTrackCompanionContext): readonly StudioEntityDraft[] {
+  const program = requiredSurfaceValue(context, "program") as TypographyTrackProgram;
+  const items = program.items.map((item) => ({
+    id: item.id,
+    startFrame: item.span.startFrame,
+    endFrameExclusive: item.span.endFrameExclusive,
+    stackOrder: item.style.stackingOrder,
+    sourceTypes: [typographyTrackTypes.itemSpec, typographyTrackTypes.plainItemSpec],
+  }));
+  return childEntities(context, items, "typography-item", "standard").map((entity, index) => {
+    const item = program.items[index];
+    if (item === undefined) return entity;
+    const label = textOf(item);
+    const temporal = temporalLineageFor(context, item.id, "window");
+    const semanticSource = temporalSemanticSource(temporal);
+    return {
+      ...entity,
+      display: { ...entity.display, layers: label.length === 0 ? [] : [textLayer(label)] },
+      ...(semanticSource?.id === undefined
+        ? {}
+        : { markerId: semanticSource.id }),
+      ...(temporal === undefined ? {} : { temporal }),
+    };
+  });
+}
+
+export const typographyTrackStudioTrackCompanions: readonly StudioTrackCompanion[] = [
+  {
+    id: "track", role: "track",
+    output: { type: compositionTypes.visualTrack, surface: "track", modules: [typographyTrackModuleRef] },
+    family: "text", tone: "violet", icon: "text",
+    bindings: [
+      { name: "placement" },
+      { name: "content" },
+      {
+        name: "style",
+        recipe: { through: ["recipe"], bindings: typographyProperties.map(({ name }) => ({ name })) },
+      },
+      { name: "motion" },
+    ],
+    inspector: typographyInspector,
+    requiredValues: ["program"], project: projectTypography,
+    lane: { heightPx: 48 },
+  },
+];

package/packages/validation/README.md

@@ -0,0 +1,11 @@
+# `@hypit/validation`
+
+Host side semantic validation for package owned types.
+
+Core checks nominal type connections. A component package may additionally register one pure
+validator for an exact `TypeRef`. The compiler applies that validator to authored and provided
+values; `NodeDriver` applies it to component and endpoint results before offering them to Core.
+
+Validators only accept or reject. They cannot rewrite a value, create graph edges, select an
+endpoint, read credentials or add author intent. The registry executes trusted installed handlers
+in process.

package/packages/validation/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@hypit/validation",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "@hypit/component-kit": "workspace:*",
+    "@hypit/core": "workspace:*",
+    "@hypit/protocol": "workspace:*"
+  }
+}

package/packages/validation/src/index.ts

@@ -0,0 +1,100 @@
+import {
+  resolveType,
+  verifyRecordStructure,
+} from "@hypit/core";
+import type {
+  TypeValidatorHandler,
+  TypeValidatorRegistrar,
+} from "@hypit/component-kit";
+import type { ResolvedModuleClosure, StoredValue, TypeRef, TypedRecord } from "@hypit/protocol";
+
+function typeKey(type: TypeRef): string {
+  return `${type.module.name}@${type.module.version}#${type.name}`;
+}
+
+export type { TypeValidatorContext, TypeValidatorHandler, TypeValidatorRegistrar } from "@hypit/component-kit";
+
+export type TypeValidatorRegistration = {
+  readonly handler: TypeValidatorHandler;
+};
+
+export interface TypeValidatorRegistryLike {
+  resolve(type: TypeRef): TypeValidatorRegistration | undefined;
+}
+
+export class TypeValidationError extends Error {
+  readonly code: string;
+  readonly subject: string | undefined;
+
+  constructor(code: string, message: string, subject?: string) {
+    super(message);
+    this.name = "TypeValidationError";
+    this.code = code;
+    this.subject = subject;
+  }
+}
+
+export class TypeValidatorRegistry implements TypeValidatorRegistryLike, TypeValidatorRegistrar {
+  readonly #validators = new Map<string, TypeValidatorRegistration>();
+
+  register(
+    type: TypeRef,
+    handler: TypeValidatorHandler,
+  ): void {
+    const key = typeKey(type);
+    if (this.#validators.has(key)) {
+      throw new TypeValidationError("DUPLICATE_TYPE_VALIDATOR", `${key} validator is already registered`, key);
+    }
+    this.#validators.set(key, { handler });
+  }
+
+  resolve(type: TypeRef): TypeValidatorRegistration | undefined {
+    return this.#validators.get(typeKey(type));
+  }
+}
+
+async function refineValue(
+  type: TypeRef,
+  value: StoredValue,
+  registry: TypeValidatorRegistryLike,
+): Promise<void> {
+  const registration = registry.resolve(type);
+  if (registration === undefined) return;
+  try {
+    await registration.handler({ type: structuredClone(type), value: structuredClone(value) });
+  } catch (error) {
+    throw new TypeValidationError(
+      "TYPE_REFINEMENT_REJECTED",
+      `${typeKey(type)} rejected the value: ${error instanceof Error ? error.message : String(error)}`,
+      typeKey(type),
+    );
+  }
+}
+
+export async function validateValue(
+  closure: ResolvedModuleClosure,
+  type: TypeRef,
+  value: StoredValue,
+  registry: TypeValidatorRegistryLike,
+): Promise<void> {
+  resolveType(closure, type);
+  await refineValue(type, value, registry);
+}
+
+export async function admitRecord(
+  closure: ResolvedModuleClosure,
+  record: TypedRecord,
+  registry: TypeValidatorRegistryLike,
+): Promise<TypedRecord> {
+  verifyRecordStructure(closure, record);
+  await refineValue(record.type, record.value, registry);
+  return record;
+}
+
+export function createRecordAdmitter(
+  registry: TypeValidatorRegistryLike,
+): (closure: ResolvedModuleClosure, record: TypedRecord) => Promise<void> {
+  return async (closure, record) => {
+    await admitRecord(closure, record, registry);
+  };
+}

package/packages/video-cli/README.md

@@ -0,0 +1,181 @@
+# `@hypit/video-cli`
+
+Official video command application. It selects the Markup compiler Host and supplies one editable
+starter Runtime Profile. The CLI still imports no Provider or Store implementation; installed packages
+are activated only by explicit Source imports or Profile `use` entries.
+
+Every Frontend, Surface, deterministic Producer and Validator is activated from Source imports.
+Installing a new author package therefore does not require a video CLI or Core release. Source
+imports never grant network, credential or process authority. A data-only package can also export a
+reusable Source directly, for example
+`<import as="ugc" source="@hypit/gpt-image-kits/phone-ugc-v1"/>`; resolving that Source does not
+activate package code.
+
+From any project:
+
+```bash
+cd path/to/project
+hypit runtime init
+hypit auth login hypihub.default
+hypit doctor
+hypit runtime up
+hypit check main.svml
+hypit plan build.svrun
+hypit build build.svrun --follow
+hypit status <build-id> --watch
+hypit activity
+hypit builds
+hypit history <source-output-name> [--source ./main.svml]
+hypit inspect <build-id> [--output <source-output-name>]
+hypit get <build-id> --output final.video --to ./final.mp4
+hypit cancel <build-id>
+hypit doctor
+```
+
+`transcribe` runs one immediate request through the selected Runtime Profile, with no Build,
+Result or state. It names the Endpoint and its price page before it runs, and writes the transcript
+to the chosen file. `measure` estimates a passage locally:
+
+```bash
+hypit transcribe reference.mp4 --to notes/reference.transcript.json [--language en|zh|es]
+hypit measure main.svml --segment hook --language en --pace normal --rounding round
+```
+
+`transcribe` uses the Profile's `whisperx-alignment` Endpoint (after
+extracting 16 kHz mono speech audio with ffmpeg). `measure` counts a Segment's pronunciation units at a
+delivery policy and prints the seconds to write as the literal `duration`; it opens no Profile and
+spends nothing. `--runtime <profile>` names the Profile; otherwise the project's `hypit runtime use`
+selection is read. Anything the Author Graph declares as an output is a Build, however quickly it
+comes back: pictures, clips and accepted voice references (`@hypit/mimo-speech`) carry the identity of the Source
+that produced them, so they are declared in the Source and go through `plan` and `build`. To hear a
+voice or learn a passage's real length before authoring the rest, build a Run whose target is that
+speech output and reuse it as a Candidate.
+
+Two more families are local, stateless and spend nothing. `hypit media` exposes the source at chosen
+times and scales, and `hypit vocabulary`
+prints what a Source may write:
+
+```bash
+hypit media probe reference.mp4
+hypit media cut reference.mp4 --start 12 --end 19.5 --label-time --to notes/hook.mp4
+hypit media frames reference.mp4 --at 12.4,13.1 --label-time --to notes/hook-frames
+hypit media tile reference.mp4 --start 12 --end 19.5 --to notes/hook-grid.jpg
+hypit media tile reference.mp4 --at 12.4,13.1,14.8 --columns 3 --to notes/exact-grid.jpg
+hypit media tile reference.mp4 --start 12 --end 14 --every 0.1 --transcript notes/reference.transcript.json --to notes/detail.jpg
+hypit media tiles reference.mp4 --around "your next idea" --transcript notes/reference.transcript.json --every 0.1 --columns 3 --rows 2 --to notes/phrase
+hypit media tiles reference.mp4 --ranges notes/ranges.json --to notes/grids
+hypit media boundaries reference.mp4
+hypit media fetch https://… --to reference/source.mp4
+hypit vocabulary
+hypit vocabulary @hypit/media-pipeline --tag StillVideo
+hypit vocabulary --visual text
+```
+
+`cut` isolates the requested interval and can visibly overlay source time on the evidence copy.
+`frames` writes one JPEG per requested time, selecting the first decoded frame at or after it.
+Visible frame labels use that frame's actual timestamp, as do the labels below each `tile` cell.
+Sampling is shared by `frames`, `tile` and `tiles`:
+
+- `--at` names exact sample times; `--start` and `--end` choose a range in seconds.
+- `--every` samples from the start at that interval, excluding the end. Times use millisecond precision.
+- Grids can instead use `--frames` evenly spaced bin midpoints. Without a sampling option they provide
+  a compact overview; choose the interval explicitly when inspecting fast motion.
+- `--transcript` reads `hypit.transcript@1` from `hypit transcribe`. The transcript and input media must
+  share the same clock. Labels show source time, active words with their start/end, and nearby words.
+  Active spans use `[start, end)`; overlapping words are all shown. Missing times stay missing, and a
+  frame without a timed word is identified without inferring silence. Text is rendered below the
+  source picture using Sharp/Pango and the machine's fonts, including font fallback for multilingual text.
+- `--around "a phrase"` with `--transcript` selects that phrase's word boundaries plus `--padding`
+  seconds on either side (0.3 by default), clipped to the input duration. Matching uses whole consecutive
+  words, ignoring case, whitespace and punctuation. Repeated matches list their times and require an
+  explicit `--occurrence` (one-based), or a numeric range. This locates evidence; it does not interpret it.
+- `tiles` accepts the same selection as `tile`, or `--ranges` with a JSON array of
+  `{ start, end, id?, frames?, every? }`. A range's sampling choice overrides the command default.
+  It paginates into `--columns` × `--rows` cells (3 × 3 by default); the final page may have fewer cells.
+  `--cell` chooses picture width. `tile` keeps all requested samples in one image.
+
+`--json` reports each frame's `requestedAt` and actual `at`, plus its active/context words when supplied.
+Grid `samples` retain the requested times; `frames` contain the actual extracted-frame information.
+It also reports every page path for `tiles`. The media layer reads existing timed text; transcription
+and its Endpoint remain separate. `boundaries` reports adjacent-frame
+change candidates and their measured scores; it does not suppress short changes or call them shots.
+`fetch` turns a link into a file with the pinned yt-dlp; [the downloader package](../yt-dlp/README.md)
+owns its dependencies, download choices and file handling. Commands that create evidence write only
+what `--to` names and refuse to overwrite. `vocabulary` reads the installed
+manifests: every package with its tags and models, or one package's Surfaces with their attributes,
+children and example, or the value shapes a drawing Producer must emit.
+
+Install the `@hypit/hypit` Distribution globally once. It resolves its own TypeScript loader and CLI, so it
+neither invokes npm per command nor requires a project to contain Hypit's `package.json`.
+
+`hypit capture screenshot <url-or-file> --to <image>` saves browser material, and
+`hypit capture run <script.mjs> [-- arguments]` runs ordinary project interactions with a prepared
+Puppeteer page and screenshot/recording helpers. `hypit capture --help` lists viewport, region,
+readiness and browser options. `hypit capture install-browser` prepares the package's tested browser
+revision; an already installed compatible browser can be selected explicitly. The independently maintained `@hypit/browser-capture` package owns
+browser lifecycle and capture; Video CLI owns command presentation. This preparation tool outputs
+ordinary project files and opens no Runtime Profile or Build. The package README owns the script API.
+
+`--workspace` is only the Source Workspace containment boundary. `--asset-root` may additionally admit
+explicit asset bytes without widening Source imports. `--package-root` is only the Host
+override used to resolve installed packages. By default, a project with
+`package.json` owns package resolution; a plain creative folder falls back to this Distribution's
+installation. Keeping that separate from Source containment lets a video project live outside the
+Distribution without weakening canonical-path source and asset boundaries. Runtime Profiles do not
+contain either Workspace or package-installation overrides.
+
+`check` is usable for an Author Source or a complete Run Source. `plan` and `build` require a Run
+Source because an Author Graph without execution intent is not a Build. The live example executes
+the Script-owned deterministic CaptionDocument alongside real local/remote Endpoints; the CLI never
+fabricates a Target, Candidate or missing fact.
+
+`build` compiles one immutable Build Definition and submits it to the configured Local Runtime with a
+fresh, automatically assigned Build id. The id begins with its UTC creation time, so repository order is both
+stable and visible; its random suffix prevents same-millisecond collisions and says nothing about content.
+Source or Plan identity never reclaims an earlier Build; reuse
+across Builds exists only through explicit Run Source Candidates. JSON Profiles resolve only adapters in their separately
+selected `use` fields and contain no executable callback. The CLI imports no Provider. A TypeScript config
+module remains trusted deployment code with normal Node authority. Neither form is discovered from
+a source import.
+
+Without `--follow`, `build` returns after durable submission and the detached Worker continues.
+With `--follow`, the CLI observes Build activity and Operation facts until a Result outcome or
+`--max-wait-ms`; Ctrl-C only detaches that observer. `status` reads durable verified state, and
+`status --watch` reattaches the same kind of observer to an existing Build. The CLI
+controls Builds, not individual Operations. Cancelling a Build atomically withdraws it before claim,
+or marks running work for one best-effort Provider cancellation call after claim. It never selects
+another Candidate. None of these commands creates or stores a ready-Command queue.
+
+The Result saves every public Author Output completed on the demanded route, including structured
+values such as semantic takes. Each Logical Output has exactly one public name in `publishedOutputs`;
+there are no Record, Artifact or alias selectors. `inspect` shows those Outputs. `get` requires one
+exact `--output` name and one explicit `--to` destination: a Scalar becomes a JSON file, a Resource
+streams to one file, and a Composite becomes a self-contained directory with `value.json` plus every
+referenced Resource. The destination must not already exist. This is Host egress only and never
+changes Build identity or retention; large media does not need to be loaded into CLI memory.
+
+`builds` and `history` browse project-owned Result manifests newest first. `--before <build-id>` moves
+the cursor to older Results without a central history table. Presentation titles, notes and highlights
+live in the Result manifest and may be edited without changing the Build id or the saved Outputs.
+`history` always asks for one exact Output name; it never chooses a Result or writes reuse markup.
+Use the returned Build id and Output name explicitly in a Run Source when reusing that value.
+
+Human output is compact and organized around author-facing names. `--json` returns a stable, bounded
+command view rather than Repository manifests or Runtime persistence objects. `--verbose` adds bounded
+operational detail; physical state locations remain the job of `paths`, while `get --to` and
+`runtime logs --verbose` expose the paths those commands explicitly operate on.
+
+Historical Records, fixed files and generated previews are declared as ordinary Candidates in the
+Run Source and selected by explicit Satisfaction edges. The Host verifies a referenced prior Build
+only to extract the declared typed Record; it does not prove a semantic relationship with the current
+output. Upstream work behind the selected Candidate is pruned by reverse reachability, while every
+unbound reachable output follows the ordinary graph. This is a new Build identity and never resumes
+or copies the prior Build's outstanding Commands.
+
+`@hypit/package-loader-node` loads explicitly selected installed implementation packages and checks
+their Module, Host-facet, Producer and Validator contributions. Frontends are ordinary
+`hypit.source-frontend@1` Host facets, so the Loader does not
+select a syntax; each Source Header selects among installed Frontends. Run Fragment libraries enter
+only through the `hypit.run-fragment-host@1` facet. Source cannot
+install a package or activate Provider/Runtime authority. Arbitrary untrusted community execution
+remains absent until an isolated Worker and real permission boundary exist.

package/packages/video-cli/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@hypit/video-cli",
+  "version": "0.0.0-dev",
+  "license": "SEE LICENSE IN LICENSE",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./cli": "./src/cli.ts"
+  },
+  "dependencies": {
+    "@hypit/browser-capture": "workspace:*",
+    "@hypit/cli": "workspace:*",
+    "@hypit/compiler-markup-node": "workspace:*",
+    "@hypit/composition": "workspace:*",
+    "@hypit/credential-store-os": "workspace:*",
+    "@hypit/driver-node": "workspace:*",
+    "@hypit/estimate": "workspace:*",
+    "@hypit/generation": "workspace:*",
+    "@hypit/markup": "workspace:*",
+    "@hypit/model-kit": "workspace:*",
+    "@hypit/package-loader-node": "workspace:*",
+    "@hypit/protocol": "workspace:*",
+    "@hypit/provider-hypihub": "workspace:*",
+    "@hypit/runtime": "workspace:*",
+    "@hypit/runtime-host-node": "workspace:*",
+    "@hypit/runtime-local": "workspace:*",
+    "@hypit/speech": "workspace:*",
+    "@hypit/speech-evidence": "workspace:*",
+    "@hypit/text": "workspace:*",
+    "@hypit/visual-ir": "workspace:*",
+    "@hypit/whisperx": "workspace:*",
+    "@hypit/workspace-fs-node": "workspace:*",
+    "@hypit/yt-dlp": "workspace:*",
+    "sharp": "0.35.3"
+  }
+}