@rightkit/video-ui 0.0.0-stage → 0.1.1

package/dist/lib/media.js

@@ -0,0 +1,171 @@
+import { invoke } from "@tauri-apps/api/core";
+import { engineCall } from "./engine.js";
+export const projectsList = (roots) => engineCall("projects.list", {
+    roots,
+});
+export const sourceList = (dir) => engineCall("source.list", { dir });
+export const sourceVerify = (dir, tag) => engineCall("source.verify", { dir }, tag);
+export const sourceRelink = (dir, source, path) => engineCall("source.relink", { dir, source, path });
+export const transcribe = (dir, source, job, install, tag) => engineCall("transcribe", { dir, source, job, install: install ?? true }, tag);
+export const transcribeCancel = (job) => engineCall("transcribe.cancel", { job });
+export const transcriptShow = (dir, source) => engineCall("transcript.show", { dir, source });
+export const phraseSearch = (dir, query) => engineCall("phrase.search", { dir, query });
+export const autoeditAnalyze = (dir, preset, opts, tag) => engineCall("autoedit.analyze", {
+    dir,
+    preset,
+    ...(opts?.source ? { source: opts.source } : {}),
+    ...(opts?.sources ? { sources: opts.sources } : {}),
+}, tag);
+export const autoeditApply = (dir, preset, opts, tag) => engineCall("autoedit.apply", {
+    dir,
+    preset,
+    ...(opts?.source ? { source: opts.source } : {}),
+    ...(opts?.sources ? { sources: opts.sources } : {}),
+    ...(opts?.review ? { review: opts.review } : {}),
+}, tag);
+export const captionsExport = (dir, source, format) => engineCall("captions.export", {
+    dir,
+    source,
+    format,
+});
+export const shortsPropose = (dir, source, count = 5) => engineCall("shorts.propose", { dir, source, count });
+export const shortsAccept = (dir, source, proposal, opts, tag) => engineCall("shorts.accept", { dir, source, proposal, ...(opts ?? {}) }, tag);
+/** `clip.export` — render one source range through the full finish path (R7). */
+export const clipExport = (dir, params, tag) => engineCall("clip.export", { dir, ...params }, tag);
+export const rendersList = (dir) => engineCall("renders.list", { dir });
+export const qaRun = (dir, render, preset, tag) => engineCall("qa.run", { dir, render, preset }, tag);
+export const exportFcpxml = (dir, name) => engineCall("export.fcpxml", { dir, name });
+export const exportOtio = (dir, name) => engineCall("export.otio", { dir, name });
+export const variantsList = (dir) => engineCall("variants.list", {
+    dir,
+});
+export const variantsCreate = (dir, source) => engineCall("variants.create", { dir, source });
+export const variantsPromote = (dir, variant) => engineCall("variants.promote", { dir, variant });
+export const retentionImport = (dir, csv, render, name) => engineCall("retention.import", { dir, name, csv, render });
+export const retentionList = (dir) => engineCall("retention.list", { dir });
+export const retentionProposals = (dir, name) => engineCall("retention.proposals", { dir, name });
+export const retentionApply = (dir, name, drops, tag) => engineCall("retention.apply", { dir, name, ...(drops ? { drops } : {}) }, tag);
+export const framingApproval = (settings) => (settings.project.framing_approval ?? settings.app.framing_approval ?? "review") === "auto" ? "auto" : "review";
+export const framingLabel = (plan, auto) => plan?.approved
+    ? plan.approval?.approver === "policy:auto" ? "Approved automatically" : "Framing approved"
+    : auto ? "Framing: automatic" : "Needs framing approval";
+export const settingsGet = (dir) => engineCall("settings.get", dir ? { dir } : {});
+/** Fired on `window` after a finishing setting is saved. `detail.dir` is the project it was saved
+ *  to, or absent for an app-wide save, so a listener for one project can tell them apart. */
+export const SETTINGS_CHANGED = "cutright:settings-changed";
+const notifySettingsChanged = (dir) => window.dispatchEvent(new CustomEvent(SETTINGS_CHANGED, { detail: { dir } }));
+/** `expectedRevision` (the `revision` `settings.get` reported) makes the write a compare-and-set:
+ *  a file that changed since is refused with code `revision_conflict` and nothing is written. */
+export const settingsSet = (settings, dir, expectedRevision) => engineCall("settings.set", {
+    ...(dir ? { dir } : {}),
+    ...(expectedRevision !== undefined ? { expected_revision: expectedRevision } : {}),
+    settings,
+}).then((r) => {
+    notifySettingsChanged(dir);
+    return r;
+});
+/** Project grade plus per-source grades for the project at `dir`. */
+export const colourGet = (args) => engineCall("colour.get", { ...args });
+/** Omit `source` to write the project grade; `grade: null` clears a grade. */
+export const colourSet = (args) => engineCall("colour.set", {
+    dir: args.dir,
+    ...(args.source !== undefined ? { source: args.source } : {}),
+    grade: args.grade,
+}).then((r) => {
+    notifySettingsChanged(args.dir);
+    return r;
+});
+export const colourScopes = (args) => engineCall("colour.scopes", { ...args });
+export const storageStatus = (dir) => engineCall("storage.status", dir ? { dir } : {});
+export const storageClear = (dir) => engineCall("storage.clear", dir ? { dir } : {});
+export const modelsStatus = () => engineCall("models.status");
+/** `models.install` — install or repair one signed-pack model (progress: `model.progress` events on `tag`). */
+export const modelsInstall = (model, tag) => engineCall("models.install", { model }, tag);
+/** R2: plans are per (source × aspect); `aspect` is "9:16" or "1:1". */
+export const reframeAnalyze = (dir, source, aspect, tag) => engineCall("reframe.analyze", { dir, source, ...(aspect ? { aspect } : {}) }, tag);
+export const reframeShow = (dir, source, aspect) => engineCall("reframe.show", {
+    dir,
+    source,
+    ...(aspect ? { aspect } : {}),
+});
+export const reframeApprove = (dir, source, opts) => engineCall("reframe.approve", { dir, source, ...opts });
+export const reframeRender = (dir, source, aspect, tag) => engineCall("reframe.render", { dir, source, ...(aspect ? { aspect } : {}) }, tag);
+/** Caption looks the engine renders, with the labels the screens show. */
+export const CAPTION_STYLES = [
+    ["classic-box", "Classic box"],
+    ["clean-outline", "Clean outline"],
+    ["shorts-pop", "Shorts pop"],
+    ["karaoke-pop", "Karaoke pop"],
+    ["karaoke-fill", "Karaoke fill"],
+    ["card-classic", "Card classic"],
+    ["card-emphasis", "Card emphasis"],
+    ["minimal-lower", "Minimal lower"],
+];
+/** The caption look used when none is chosen; matches the engine default (`captions_cmd.rs`). */
+export const DEFAULT_CAPTION_STYLE = "classic-box";
+export const captionsPreview = (dir, opts = {}) => engineCall("captions.preview", { dir, ...opts });
+export const playbackOpen = (params) => invoke("playback_open", { params, toolsDir: null });
+/** Rebuilds the open timeline preview with freshly fetched colour chains and restores the
+ *  playhead. A grade change does not change the revision, so the revision-keyed reopen misses it.
+ *  Resolves null when no timeline preview is open. */
+/** Fired on `window` after the preview session was rebuilt; a paused player repaints on it. */
+export const PLAYBACK_REFRESHED = "cutright:playback-refreshed";
+export const playbackRefreshFinishing = (dir) => invoke("playback_refresh_finishing", { dir, toolsDir: null }).then((meta) => {
+    window.dispatchEvent(new Event(PLAYBACK_REFRESHED));
+    return meta;
+});
+export const playbackClose = () => invoke("playback_close");
+export const playbackStatus = () => invoke("playback_status");
+export const playbackControl = (cmd, value, value2) => invoke("playback_control", { cmd, value: value ?? 0, value2: value2 ?? 0 });
+/** Binary frame reply: `[u32 w][u32 h][u32 frame][u32 total][f64 pts]` + RGBA8. */
+export const playbackFrame = () => invoke("playback_frame");
+/** Runtime asset-protocol scope grant (project dirs, referenced media). */
+export const mediaScopeAllow = (paths, recursive) => invoke("media_scope_allow", { paths, recursive: recursive ?? null });
+/** Frames of a source (id or file name) or a render (file name in renders/).
+ *  Omit times for one representative frame (20% in). */
+export const thumbnails = (dir, target, opts = {}) => engineCall("media.thumbnail", { dir, ...target, ...opts });
+export const retentionShow = (dir, name) => engineCall("retention.show", { dir, name });
+export const rendersDelete = (dir, name) => engineCall("renders.delete", { dir, name });
+export const qaList = (dir) => engineCall("qa.list", { dir });
+/** `render` is a bare file name in renders/. A QA refusal arrives as an error starting `qa_failed:`. */
+export const packageBuild = (dir, params) => engineCall("package.build", { dir, ...params });
+export const sourceProbe = (dir, source) => engineCall("source.probe", { dir, source });
+export const recipeRun = (dir, opts, tag) => engineCall("recipe.run", { dir, ...opts }, tag);
+export const recipeCancel = (job) => engineCall("recipe.cancel", { job });
+export const recipeStatus = (dir) => engineCall("recipe.status", { dir });
+export const captionsShow = (dir, preset) => engineCall("captions.show", {
+    dir,
+    ...(preset ? { preset } : {}),
+});
+// Compatibility alias: editor lane imports `captionCues(dir)`.
+export const captionCues = captionsShow;
+export const editplanList = (dir) => engineCall("editplan.list", { dir });
+// Compatibility alias for consumers that imported the camelCase name.
+export const editPlanList = editplanList;
+// ---- Channel recipes (recipes.*: app-wide library, per-project ref) ----
+/** Engine id rule for library recipes: lowercase letters, digits and '-', 1..64 chars. */
+export const RECIPE_ID_RULE = /^[a-z0-9-]{1,64}$/;
+export const recipesList = () => engineCall("recipes.list", {});
+export const recipesGet = (id) => engineCall("recipes.get", { id });
+export const recipesSave = (args) => engineCall("recipes.save", { ...args });
+export const recipesDelete = (id) => engineCall("recipes.delete", { id });
+/** Saves this project's recipe settings to the library under `id`; a new version when `id` exists. */
+export const recipesSaveFromProject = (args) => engineCall("recipes.save_from_project", { ...args });
+/** Replaces this project's recipe settings with the library recipe `id`. */
+export const recipesApply = (dir, id) => engineCall("recipes.apply", { dir, id });
+export const recipesStatus = (dir) => engineCall("recipes.status", { dir });
+export const batchCreate = (dir, outputs, id) => 
+// The engine replies {status, created, id, batch}; callers want the batch document.
+engineCall("batch.create", { dir, outputs, ...(id ? { id } : {}) }).then((r) => r.batch);
+/**
+ * Long-running: pass `job` to cancel with `recipeCancel(job)`; progress arrives as `batch.output` on `tag`.
+ * `finishing: "current"` pins the batch to the project's current finishing settings and renders every output again.
+ */
+export const batchRun = (dir, id, job, tag, finishing) => engineCall("batch.run", { dir, id, ...(job ? { job } : {}), ...(finishing ? { finishing } : {}) }, tag);
+export const batchStatus = (dir, id) => engineCall("batch.status", { dir, id });
+export const batchList = (dir) => engineCall("batch.list", { dir });
+/** Sets the cover frame of one output; the reply carries the updated fields of that output row. */
+export const batchCover = (dir, id, key, at_ms) => engineCall("batch.cover", { dir, id, key, at_ms });
+/** `tag` routes the `bundle.progress` frames (`{completed, total}`, write stage) to this call. */
+export const bundleExport = (dir, params, tag) => engineCall("bundle.export", { dir, ...params }, tag);
+export const bundleImport = (params) => engineCall("bundle.import", params);

package/dist/lib/mediaAdapters.d.ts

@@ -0,0 +1,18 @@
+import type { MediaAdapters } from "@rightkit/media-ui";
+/**
+ * the host app bindings for @rightkit/media-ui. Media the webview cannot decode is
+ * remuxed by `rightkit-playback` (`prepare_registered_media_playback`, registry shared with
+ * src-tauri/src/playback_host.rs); the player gets the derivative as an asset URL.
+ * The `id` is the registry-issued source id from `useMediaPlaybackId`, never a path.
+ */
+export declare const mediaAdapters: MediaAdapters;
+/** Registry-issued id; RightKit's authoriser checks the host's scope on every platform. */
+export declare const mediaSourceId: (path: string) => Promise<string>;
+/**
+ * The `playbackId` for `path`, once the host has registered it. Undefined until then, and
+ * stays undefined when the file is outside the media scope (no compatibility copy, as before).
+ * Call sites key the player on this value so a late id remounts it cleanly.
+ */
+export declare function useMediaPlaybackId(path: string | null | undefined): string | undefined;
+export declare const isPlayable: (path: string) => boolean;
+export declare const mediaKind: (path: string) => "audio" | "video";

package/dist/lib/mediaAdapters.js

@@ -0,0 +1,46 @@
+import { useEffect, useState } from "react";
+import { convertFileSrc, invoke } from "@tauri-apps/api/core";
+import { getCurrentWindow } from "@tauri-apps/api/window";
+import { defaultToastBus } from "@rightkit/react-shell";
+/**
+ * the host app bindings for @rightkit/media-ui. Media the webview cannot decode is
+ * remuxed by `rightkit-playback` (`prepare_registered_media_playback`, registry shared with
+ * src-tauri/src/playback_host.rs); the player gets the derivative as an asset URL.
+ * The `id` is the registry-issued source id from `useMediaPlaybackId`, never a path.
+ */
+export const mediaAdapters = {
+    resolveSrc: (source) => (/^[a-z][a-z0-9+.-]*:/i.test(source) ? source : convertFileSrc(source)),
+    preparePlayback: async ({ id, requestId }) => convertFileSrc(await invoke("prepare_registered_media_playback", { source: id, requestId })),
+    cancelPlayback: (requestId) => invoke("cancel_media_playback", { requestId }),
+    setFullscreen: (on) => getCurrentWindow().setFullscreen(on),
+    notify: (message, severity) => {
+        defaultToastBus.push(message, severity === "error" ? "error" : "info");
+    },
+};
+/** Registry-issued id; RightKit's authoriser checks the host's scope on every platform. */
+export const mediaSourceId = (path) => invoke("authorised_media_source_id", { path });
+/**
+ * The `playbackId` for `path`, once the host has registered it. Undefined until then, and
+ * stays undefined when the file is outside the media scope (no compatibility copy, as before).
+ * Call sites key the player on this value so a late id remounts it cleanly.
+ */
+export function useMediaPlaybackId(path) {
+    const [known, setKnown] = useState(null);
+    useEffect(() => {
+        if (!path)
+            return;
+        let live = true;
+        mediaSourceId(path).then((id) => {
+            if (live)
+                setKnown({ path, id });
+        }, () => undefined);
+        return () => {
+            live = false;
+        };
+    }, [path]);
+    return path && known?.path === path ? known.id : undefined;
+}
+const AUDIO_EXT = /\.(wav|mp3|m4a|flac|aac|ogg|opus)$/i;
+const MEDIA_EXT = /\.(mp4|mov|mkv|webm|m4v|wav|mp3|m4a|flac|aac|ogg|opus)$/i;
+export const isPlayable = (path) => MEDIA_EXT.test(path);
+export const mediaKind = (path) => (AUDIO_EXT.test(path) ? "audio" : "video");

package/dist/lib/mic.d.ts

@@ -0,0 +1,38 @@
+/** `offset` is microphone source time minus camera source time, in ticks. */
+export type MicAlignment = {
+    offset: number;
+    offset_ms: number;
+    lag_samples: number;
+    sample_rate: number;
+    /** 0..1 normalised correlation score. */
+    confidence: number;
+    confidence_milli: number;
+    overlap_samples: number;
+};
+export type MicAttachment = {
+    camera: string;
+    microphone: string;
+    offset: number;
+    sample_rate: number;
+    lag_samples: number;
+    confidence_milli: number;
+};
+export type MicAlignResult = {
+    /** `attached` on a new mapping; `already_attached` when the same mapping exists. */
+    status: "attached" | "already_attached";
+    alignment: MicAlignment;
+    attachment: MicAttachment;
+    revision: unknown;
+};
+export type MicAlignOptions = {
+    /** Search window in milliseconds, 1..=180000 (engine default 30000). */
+    maxOffsetMs?: number;
+    /** Fail with a cursor mismatch unless the project is at this cursor. */
+    expectCursor?: number;
+};
+/**
+ * Aligns the external microphone source to the camera source and records the
+ * source-level mapping. `camera` and `microphone` are source BLAKE3 ids or
+ * unambiguous source names. Long-running: pass a `tag` to correlate progress.
+ */
+export declare function micAlign(dir: string, camera: string, microphone: string, options?: MicAlignOptions, tag?: string): Promise<MicAlignResult>;

package/dist/lib/mic.js

@@ -0,0 +1,14 @@
+import { engineCall } from "./engine.js";
+/**
+ * Aligns the external microphone source to the camera source and records the
+ * source-level mapping. `camera` and `microphone` are source BLAKE3 ids or
+ * unambiguous source names. Long-running: pass a `tag` to correlate progress.
+ */
+export function micAlign(dir, camera, microphone, options = {}, tag) {
+    const params = { dir, camera, microphone };
+    if (options.maxOffsetMs !== undefined)
+        params.max_offset_ms = options.maxOffsetMs;
+    if (options.expectCursor !== undefined)
+        params.expect_cursor = options.expectCursor;
+    return engineCall("mic.align", params, tag);
+}

package/dist/lib/models.d.ts

@@ -0,0 +1,53 @@
+export type ModelKind = "image" | "video" | "voice" | "avatar";
+/** Every the host app media kind a catalog row can carry (the eight generate kinds). */
+export type CatalogKind = ModelKind | "music" | "sfx" | "upscale" | "lipsync";
+export type ModelRow = {
+    provider: string;
+    model: string;
+    kind: string;
+    label: string;
+    estUsd: number | null;
+    /** A closed set of allowed durations (seconds). */
+    durationsS?: number[];
+    minDurationS?: number;
+    maxDurationS?: number;
+    defaultDurationS?: number;
+};
+export type ModelCatalog = {
+    models: ModelRow[];
+    structuredDurations: boolean;
+};
+export declare function parseCatalog(result: unknown): ModelCatalog;
+export declare const ofKind: (c: ModelCatalog, kind: CatalogKind) => ModelRow[];
+export declare const providersOf: (c: ModelCatalog, kind: CatalogKind) => string[];
+export declare const findModel: (c: ModelCatalog | null, provider: string, model: string) => ModelRow | undefined;
+export type DurationControl = {
+    type: "set";
+    options: number[];
+    initial: number;
+} | {
+    type: "range";
+    min: number;
+    max: number;
+    initial: number;
+} | {
+    type: "free";
+    initial: number;
+};
+/** What the duration control offers for `m`; the model's default is preselected. */
+export declare function durationControl(m: ModelRow | undefined, fallback?: number): DurationControl;
+/** Preferred model of a kind: the wanted one when listed, else the cheapest priced, else the first. */
+export declare function pickModel(c: ModelCatalog, kind: CatalogKind, want?: {
+    provider: string;
+    model: string;
+}): ModelRow | undefined;
+export type SpendLine = {
+    label: string;
+    estUsd: number | null;
+};
+/** Sum of the known per-item estimates; `unpriced` counts items the host app has no estimate for. */
+export declare function spendTotal(lines: SpendLine[]): {
+    total: number;
+    unpriced: number;
+};
+export declare const formatUsd: (n: number) => string;

package/dist/lib/models.js

@@ -0,0 +1,72 @@
+// `genright.models` as the engine returns it (crates/cutright-engine/src/genright_cmd.rs `models`):
+//   {models:[{provider, model, kind, label, est_usd, durations_s?, min_duration_s?, max_duration_s?,
+//             default_duration_s?}], structured_durations}
+// `est_usd` is the host app own per-job price estimate (null when unknown).
+const isObj = (v) => typeof v === "object" && v !== null;
+const str = (v) => (typeof v === "string" ? v : undefined);
+const num = (v) => (typeof v === "number" && Number.isFinite(v) ? v : undefined);
+export function parseCatalog(result) {
+    const r = isObj(result) ? result : {};
+    const rows = Array.isArray(r.models) ? r.models : [];
+    const models = [];
+    for (const raw of rows) {
+        if (!isObj(raw))
+            continue;
+        const provider = str(raw.provider);
+        const model = str(raw.model);
+        if (!provider || !model)
+            continue;
+        const set = Array.isArray(raw.durations_s)
+            ? raw.durations_s.map(num).filter((n) => n !== undefined)
+            : [];
+        models.push({
+            provider,
+            model,
+            kind: str(raw.kind) ?? "",
+            label: str(raw.label) ?? model,
+            estUsd: num(raw.est_usd) ?? null,
+            durationsS: set.length > 0 ? [...set].sort((a, b) => a - b) : undefined,
+            minDurationS: num(raw.min_duration_s),
+            maxDurationS: num(raw.max_duration_s),
+            defaultDurationS: num(raw.default_duration_s),
+        });
+    }
+    return { models, structuredDurations: r.structured_durations === true };
+}
+export const ofKind = (c, kind) => c.models.filter((m) => m.kind === kind);
+export const providersOf = (c, kind) => [...new Set(ofKind(c, kind).map((m) => m.provider))];
+export const findModel = (c, provider, model) => c?.models.find((m) => m.provider === provider && m.model === model);
+/** What the duration control offers for `m`; the model's default is preselected. */
+export function durationControl(m, fallback = 4) {
+    if (m?.durationsS) {
+        const d = m.defaultDurationS;
+        return { type: "set", options: m.durationsS, initial: d !== undefined && m.durationsS.includes(d) ? d : m.durationsS[0] };
+    }
+    if (m?.minDurationS !== undefined && m.maxDurationS !== undefined) {
+        const d = m.defaultDurationS ?? m.minDurationS;
+        return { type: "range", min: m.minDurationS, max: m.maxDurationS, initial: Math.min(m.maxDurationS, Math.max(m.minDurationS, d)) };
+    }
+    return { type: "free", initial: m?.defaultDurationS ?? fallback };
+}
+/** Preferred model of a kind: the wanted one when listed, else the cheapest priced, else the first. */
+export function pickModel(c, kind, want) {
+    const rows = ofKind(c, kind);
+    const exact = want && rows.find((m) => m.provider === want.provider && m.model === want.model);
+    if (exact)
+        return exact;
+    const priced = rows.filter((m) => m.estUsd !== null).sort((a, b) => (a.estUsd ?? 0) - (b.estUsd ?? 0));
+    return priced[0] ?? rows[0];
+}
+/** Sum of the known per-item estimates; `unpriced` counts items the host app has no estimate for. */
+export function spendTotal(lines) {
+    let total = 0;
+    let unpriced = 0;
+    for (const l of lines) {
+        if (l.estUsd === null)
+            unpriced += 1;
+        else
+            total += l.estUsd;
+    }
+    return { total, unpriced };
+}
+export const formatUsd = (n) => `$${n.toFixed(n < 1 ? 3 : 2)}`;

package/dist/lib/modelsBackend.d.ts

@@ -0,0 +1,3 @@
+import type { ModelsBackend } from "@rightkit/settings-ui";
+/** RightKit models port over the engine's signed-pack store (`models.status` / `models.install`). */
+export declare function createModelsBackend(): ModelsBackend;

package/dist/lib/modelsBackend.js

@@ -0,0 +1,68 @@
+import { errorMessage } from "./engine.js";
+import { modelsInstall, modelsStatus } from "./media.js";
+const LABELS = {
+    speech: { label: "Speech model", description: "Transcribes talking-head footage for cuts and captions." },
+    face: { label: "Face model", description: "Tracks faces for vertical and square framing." },
+};
+function entry(id, row, installing) {
+    const state = installing || row?.in_progress
+        ? "downloading"
+        : row?.ready || row?.state === "ready"
+            ? "installed"
+            : row?.error && row.state !== "missing"
+                ? "error"
+                : "missing";
+    return {
+        id,
+        ...LABELS[id],
+        sizeBytes: row?.size_hint_bytes,
+        state,
+        // Signed packs live in the shared Orthic store and other apps use them.
+        shared: true,
+        error: state === "error" && row?.error ? { code: row.state ?? "error", message: row.error } : undefined,
+    };
+}
+/** RightKit models port over the engine's signed-pack store (`models.status` / `models.install`). */
+export function createModelsBackend() {
+    const installing = new Set();
+    const listeners = new Set();
+    // The engine rejects with a {code, message} object; the kits show `Error.message`.
+    const asError = (e) => {
+        throw e instanceof Error ? e : new Error(errorMessage(e));
+    };
+    const list = async () => {
+        const s = await modelsStatus().catch(asError);
+        return Object.keys(LABELS).map((k) => entry(k, s[k], installing.has(k)));
+    };
+    const push = async () => {
+        const all = await list().catch(() => []);
+        for (const e of all)
+            for (const l of listeners)
+                l(e);
+    };
+    return {
+        list,
+        async install(id) {
+            const k = id;
+            installing.add(k);
+            void push();
+            try {
+                await modelsInstall(k).catch(asError);
+            }
+            finally {
+                installing.delete(k);
+                void push();
+            }
+        },
+        // The engine install is not resumable mid-file; cancel is a no-op the UI tolerates.
+        async cancel() { },
+        // settings-ui never offers Remove for shared entries; the port still requires the method.
+        async remove() {
+            throw new Error("Removing a signed model pack is not supported; it is shared with other Orthic Labs apps.");
+        },
+        async subscribe(handler) {
+            listeners.add(handler);
+            return () => listeners.delete(handler);
+        },
+    };
+}

package/dist/lib/progress.d.ts

@@ -0,0 +1,77 @@
+export type EngineEvent = {
+    event?: string;
+} & Record<string, unknown>;
+export type EngineFrame = {
+    id: number | null;
+    tag: string | null;
+    event: EngineEvent;
+};
+export type JobView = {
+    /** request id (stable across retries). */
+    id: string;
+    label: string;
+    jobId?: string;
+    /** journaled | submitted */
+    request?: string;
+    status?: string;
+    stage?: string;
+    message?: string;
+    imported: boolean;
+};
+export type ProgressState = {
+    /** Correlation: frames are accepted only for this tag (then this engine frame id). */
+    tag: string | null;
+    frameId: number | null;
+    assembleId: string | null;
+    running: boolean;
+    resumed: boolean;
+    stages: string[];
+    jobs: Record<string, JobView>;
+    imports: number;
+    render: {
+        job?: string;
+        frame?: number;
+        out_time_ms?: number;
+        total_ms?: number;
+    } | null;
+    timeline: {
+        video_clips?: number;
+        titles?: number;
+        total_frames?: number;
+    } | null;
+    error: {
+        code?: string;
+        message: string;
+    } | null;
+    cancelled: boolean;
+    output: string | null;
+    done: boolean;
+    log: EngineEvent[];
+};
+export declare const initialProgress: ProgressState;
+export declare const assembleRenderJob: (assembleId: string) => string;
+/** Starts tracking one engine call. */
+export declare function beginProgress(tag: string, assembleId: string | null): ProgressState;
+export declare function reduceFrame(state: ProgressState, frame: EngineFrame): ProgressState;
+/** Rebuilds what is known from an `assemble.status` result (after an app restart). */
+export declare function seedFromStatus(state: ProgressState, status: {
+    assemble_id: string;
+    status: string;
+    stage: string;
+    error: {
+        code?: string;
+        message?: string;
+    } | null;
+    timeline_built: boolean;
+    render: {
+        output?: string;
+    } | null;
+    render_exists?: boolean;
+    requests: {
+        item: string;
+        request_id: string;
+        state: string | null;
+        job_id: string | null;
+        imported: boolean;
+    }[];
+}): ProgressState;