@rightkit/video-ui 0.0.0-stage → 0.1.1

package/dist/lib/engine.js

@@ -0,0 +1,51 @@
+import { invoke } from "@tauri-apps/api/core";
+import { shell } from "./shell.js";
+export const engineStatus = async () => {
+    // Typed lifecycle snapshot from @rightkit/tauri-shell 0.1.2 (`rk_shell_engine_status`).
+    const status = (await shell.engine.status());
+    if (!status)
+        return { state: "failed", hello: null, restarts: 0, last_error: "no engine configured" };
+    return {
+        state: status.state === "error" ? "failed" : status.state,
+        hello: (status.hello ?? null),
+        restarts: status.restarts ?? 0,
+        last_error: status.last_error ?? status.message ?? null,
+    };
+};
+export const engineDoctor = () => engineCall("doctor");
+/** Allowlisted passthrough (see `ALLOWED_METHODS` in the supervisor). */
+let activeCalls = 0;
+export const engineBusy = () => activeCalls > 0;
+export async function engineCall(method, params = {}, tag) {
+    activeCalls += 1;
+    try {
+        // Tagged call from @rightkit/tauri-shell 0.1.2: events echo the tag, failures reject typed.
+        return await shell.engine.callTagged(method, params, tag);
+    }
+    finally {
+        activeCalls -= 1;
+    }
+}
+export const revealPath = (path) => invoke("reveal_path", { path });
+/** Every engine event payload (`{call, id, tag, event}`), lifecycle frames included. */
+export const onEngineRaw = (handler) => shell.engine.onEvent(handler);
+/** Frames are `{id: engine request id, tag: the caller's tag for that call, event}`. */
+export function onEngineEvent(handler) {
+    return shell.engine.onEvent((frame) => {
+        if (frame.call === "$lifecycle" || frame.id === undefined)
+            return;
+        handler({ id: frame.id, tag: frame.tag ?? null, event: frame.event });
+    });
+}
+export function errorCode(error) {
+    if (error && typeof error === "object" && "code" in error) {
+        return String(error.code);
+    }
+    return undefined;
+}
+export function errorMessage(error) {
+    if (error && typeof error === "object" && "message" in error) {
+        return String(error.message);
+    }
+    return String(error);
+}

package/dist/lib/genright.d.ts

@@ -0,0 +1,90 @@
+export type HostState = "checking" | "ready" | "missing" | "outdated" | "unavailable";
+export type HostInfo = {
+    state: HostState;
+    /** Engine error message, as reported. */
+    detail?: string;
+    enginePath?: string;
+    appVersion?: string;
+    /** Contract version the installed the host app reports (ready) or was found at (outdated). */
+    found?: number;
+    /** Contract version the host app requires (outdated, parsed from the engine message). */
+    required?: number;
+    /** What the user should do: install or update the host app. */
+    action?: "install" | "update";
+};
+export declare function interpretHost(result: unknown): HostInfo;
+/** Status used when the call itself failed (engine down, timeout). */
+export declare function genRightCallFailed(message: string): HostInfo;
+export type HostJobState = "queued" | "running" | "ready" | "failed" | "cancelled" | "done" | "unknown" | "import_failed";
+export type HostJob = {
+    requestId: string;
+    kind: string;
+    provider: string;
+    model: string;
+    prompt: string;
+    jobId: string | null;
+    /** Normalized: queued | running | ready | failed | cancelled | done. */
+    state: HostJobState;
+    /** the host app own status word when a live `job status` was fetched. */
+    engineStatus: string | null;
+    error: {
+        code?: string;
+        message?: string;
+    } | null;
+    imported: boolean;
+    estUsd: number | null;
+    actualUsd: number | null;
+};
+export declare function interpretJobRow(raw: unknown): HostJob | null;
+export declare function interpretJobs(result: unknown): HostJob[];
+/** One entry of `genright.recover`'s `recovered` array. */
+export type RecoveredRequest = {
+    requestId: string;
+    state: HostJobState;
+    jobId?: string;
+    imported?: number;
+    error: {
+        code?: string;
+        message?: string;
+    } | null;
+};
+export declare function interpretRecover(result: unknown): RecoveredRequest[];
+export type GeneratedAsset = {
+    assetId: string;
+    jobId: string;
+    requestId: string | null;
+    kind: string | null;
+    path: string;
+    mime: string;
+    bytes: number;
+    blake3: string;
+    provider: string;
+    model: string;
+    prompt: string | null;
+    estUsd: number | null;
+    actualUsd: number | null;
+    importedAt: number;
+    /** true when the project copy is still on disk. */
+    exists: boolean;
+    /** ready | missing */
+    state: string;
+    /** relink | regenerate | null — what to offer for a missing file. */
+    recovery: string | null;
+    /** Timeline source id once registered (BLAKE3), else null. */
+    sourceId: string | null;
+};
+export declare function interpretAsset(raw: unknown): GeneratedAsset | null;
+export type AssetLibrary = {
+    assets: GeneratedAsset[];
+    openRequests: HostJob[];
+};
+export declare function interpretAssetLibrary(result: unknown): AssetLibrary;
+/** `assets.place` placement modes (PlaceMode on the engine). */
+export type PlaceMode = "append" | "broll" | "narration" | "music";
+/**
+ * Which place modes an asset kind supports. Mirrors the engine's
+ * `RequestedKind::default_place_mode` (crates/cutright-engine/src/genright_cmd.rs):
+ * sfx and music land as a music bed, voice as narration or bed, and visual or
+ * transform kinds append or cover B-roll.
+ */
+export declare function placeModesFor(kind: string | null): PlaceMode[];

package/dist/lib/genright.js

@@ -0,0 +1,160 @@
+// `genright.status` as the engine returns it (crates/cutright-engine/src/genright_cmd.rs `status`):
+//   ready:    {installed:true, ready:true, action:null, engine_path, app_version, contract_version, error:null}
+//   missing:  {installed:false, ready:false, action:"install", error:{code:"genright_not_installed"|"genright_unavailable", message}}
+//             (installed but without an engine also comes back installed:false, action:"update")
+//   other:    {installed:true, ready:false, action:"update"|"install", engine_path, error:{code, message}}
+//             code "genright_outdated" carries `contract version <found> is not supported (need <required>)`
+//             or `lacks capability <name> v<n>` in its message; anything else means the engine failed to run.
+import { hostAppName } from "../appName.js";
+const isObj = (v) => typeof v === "object" && v !== null;
+const str = (v) => (typeof v === "string" ? v : undefined);
+const num = (v) => (typeof v === "number" ? v : undefined);
+export function interpretHost(result) {
+    const r = isObj(result) ? result : {};
+    const err = isObj(r.error) ? r.error : undefined;
+    const code = str(err?.code);
+    const detail = str(err?.message);
+    const enginePath = str(r.engine_path);
+    const action = r.action === "install" || r.action === "update" ? r.action : undefined;
+    if (r.ready === true) {
+        return {
+            state: "ready",
+            enginePath,
+            appVersion: str(r.app_version),
+            found: num(r.contract_version),
+        };
+    }
+    if (r.installed === false || code === "genright_not_installed") {
+        return { state: "missing", detail, action: action ?? "install" };
+    }
+    if (code === "genright_outdated") {
+        const m = /contract version (\d+) is not supported \(need (\d+)\)/.exec(detail ?? "");
+        return {
+            state: "outdated",
+            detail,
+            enginePath,
+            found: m ? Number(m[1]) : undefined,
+            required: m ? Number(m[2]) : undefined,
+            action: "update",
+        };
+    }
+    if (r.ready === false) {
+        return { state: "unavailable", detail, enginePath, action: action ?? "update" };
+    }
+    return { state: "unavailable", detail: detail ?? `${hostAppName()} did not report ready.`, enginePath };
+}
+/** Status used when the call itself failed (engine down, timeout). */
+export function genRightCallFailed(message) {
+    return { state: "unavailable", detail: message };
+}
+const optStr = (v) => (typeof v === "string" && v.length > 0 ? v : null);
+export function interpretJobRow(raw) {
+    if (!isObj(raw))
+        return null;
+    const requestId = str(raw.request_id);
+    if (!requestId)
+        return null;
+    const err = isObj(raw.error) ? raw.error : null;
+    const state = str(raw.state);
+    return {
+        requestId,
+        kind: str(raw.kind) ?? "",
+        provider: str(raw.provider) ?? "",
+        model: str(raw.model) ?? "",
+        prompt: str(raw.prompt) ?? "",
+        jobId: optStr(raw.job_id),
+        state: state ?? "unknown",
+        engineStatus: optStr(raw.engine_status),
+        error: err ? { code: str(err.code), message: str(err.message) } : null,
+        imported: raw.imported === true,
+        estUsd: num(raw.est_usd) ?? null,
+        actualUsd: num(raw.actual_usd) ?? null,
+    };
+}
+export function interpretJobs(result) {
+    const rows = isObj(result) && Array.isArray(result.jobs) ? result.jobs : [];
+    return rows.map(interpretJobRow).filter((j) => j !== null);
+}
+export function interpretRecover(result) {
+    const rows = isObj(result) && Array.isArray(result.recovered) ? result.recovered : [];
+    const out = [];
+    for (const raw of rows) {
+        if (!isObj(raw))
+            continue;
+        const requestId = str(raw.request_id);
+        if (!requestId)
+            continue;
+        const err = isObj(raw.error) ? raw.error : null;
+        out.push({
+            requestId,
+            state: str(raw.state) ?? "unknown",
+            jobId: optStr(raw.job_id) ?? undefined,
+            imported: num(raw.imported),
+            error: err ? { code: str(err.code), message: str(err.message) } : null,
+        });
+    }
+    return out;
+}
+export function interpretAsset(raw) {
+    if (!isObj(raw))
+        return null;
+    const assetId = str(raw.asset_id);
+    const path = str(raw.path);
+    if (!assetId || !path)
+        return null;
+    return {
+        assetId,
+        jobId: str(raw.job_id) ?? "",
+        requestId: optStr(raw.request_id),
+        kind: optStr(raw.kind),
+        path,
+        mime: str(raw.mime) ?? "",
+        bytes: num(raw.bytes) ?? 0,
+        blake3: str(raw.blake3) ?? "",
+        provider: str(raw.provider) ?? "",
+        model: str(raw.model) ?? "",
+        prompt: optStr(raw.prompt),
+        estUsd: num(raw.est_usd) ?? null,
+        actualUsd: num(raw.actual_usd) ?? null,
+        importedAt: num(raw.imported_at) ?? 0,
+        exists: raw.exists === true,
+        state: str(raw.state) ?? "ready",
+        recovery: optStr(raw.recovery),
+        sourceId: optStr(raw.source_id),
+    };
+}
+export function interpretAssetLibrary(result) {
+    const r = isObj(result) ? result : {};
+    const assets = (Array.isArray(r.assets) ? r.assets : [])
+        .map(interpretAsset)
+        .filter((a) => a !== null);
+    const openRequests = (Array.isArray(r.open_requests) ? r.open_requests : [])
+        .map(interpretJobRow)
+        .filter((j) => j !== null);
+    return { assets, openRequests };
+}
+/**
+ * Which place modes an asset kind supports. Mirrors the engine's
+ * `RequestedKind::default_place_mode` (crates/cutright-engine/src/genright_cmd.rs):
+ * sfx and music land as a music bed, voice as narration or bed, and visual or
+ * transform kinds append or cover B-roll.
+ */
+export function placeModesFor(kind) {
+    switch (kind) {
+        case "voice":
+        case "narration":
+            return ["narration", "music"];
+        case "music":
+        case "sfx":
+            return ["music"];
+        case "image":
+        case "video":
+        case "broll":
+        case "avatar":
+        case "upscale":
+        case "lipsync":
+            return ["append", "broll"];
+        default:
+            return ["append", "broll", "narration", "music"];
+    }
+}