videobook 0.0.0-stage → 0.2.0

package/dist/dancing-workflow.js

@@ -0,0 +1,447 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { YtDlp } from "ytdlp-nodejs";
+import { ytdlpRunOptions } from "./ytdlp-binary.js";
+import { findVideoFile, resolveNotebookCellArtifactId, } from "videobook-engine";
+import { probeImage } from "./image.js";
+import { notebookCellFingerprint } from "./jobs/run-notebook.js";
+import { probeVideo, runFfmpeg } from "./ffmpeg.js";
+export const DANCING_FIXTURE_OWNER = "dancing-default";
+export const DANCING_FIXTURE_VERSION = 7;
+const DANCING_SOURCE_URL = "https://www.youtube.com/watch?v=8GwZveBYRJI";
+export const DANCING_MOTION_DURATION_SECONDS = 10;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DEFAULT_KITTEN_IMAGE_PATH = resolve(__dirname, "../../tests/fixtures/images/dancing-kittens-first-frame.png");
+const SOURCE_LABEL = "Dancing motion reference";
+const FIRST_FRAME_LABEL = "Dancing first frame";
+const KITTEN_IMAGE_LABEL = "Kittens freeway first frame";
+const IMAGE_PROMPT = "Replace the two dancers with two kittens standing in the same pose on the shoulder at the side of a freeway.";
+const MOTION_PROMPT = "Two kittens perform the same synchronized dance as the reference video while standing on the freeway shoulder.";
+const FIXTURE_ROLES = [
+    "download-video",
+    "extract-first-frame",
+    "kittens-freeway",
+    "kittens-freeway-output",
+    "kling-omni-transformation",
+    "kling-omni-transformation-output",
+];
+function roleOf(cell) {
+    return typeof cell.inputs?.workflowRole === "string"
+        ? cell.inputs.workflowRole
+        : null;
+}
+function fixtureRecord(document) {
+    const fixture = document.fixture;
+    return fixture && typeof fixture === "object" && !Array.isArray(fixture)
+        ? fixture
+        : null;
+}
+function fixtureCells(document) {
+    return document.cells.filter((cell) => cell.inputs?.fixtureOwner === DANCING_FIXTURE_OWNER);
+}
+function isCurrentFixture(document) {
+    const cells = fixtureCells(document);
+    const cellIds = new Set(cells.map((cell) => cell.id));
+    const roles = new Set(cells.map(roleOf));
+    const edges = document.edges.filter((edge) => cellIds.has(edge.source) && cellIds.has(edge.target));
+    return fixtureRecord(document)?.version === DANCING_FIXTURE_VERSION
+        && cells.length === FIXTURE_ROLES.length
+        && FIXTURE_ROLES.every((role) => roles.has(role))
+        && edges.length === 6
+        && cells.filter((cell) => cell.outputArtifactId).every((cell) => document.execution?.[cell.id]?.fingerprint
+            === notebookCellFingerprint(document, cell));
+}
+function requiredArtifact(artifacts, label) {
+    const artifact = artifacts.find((candidate) => candidate.label === label);
+    if (!artifact)
+        throw new Error(`Dancing fixture artifact is missing: ${label}`);
+    return artifact;
+}
+async function ensureArtifact(engine, kind, label) {
+    const existing = engine.artifacts.list().find((artifact) => artifact.label === label);
+    if (existing)
+        return existing;
+    const created = await engine.artifacts.create({ kind, label });
+    if (!created.ok)
+        throw new Error(created.error.message);
+    return created.value;
+}
+async function hasFile(engine, artifactId, filename) {
+    const manifest = await engine.files.manifest(artifactId);
+    return manifest.ok
+        && manifest.value.files.some((file) => file.name === filename);
+}
+async function downloadDancingVideo(destination) {
+    const ytdlp = new YtDlp(ytdlpRunOptions());
+    await ytdlp
+        .download(DANCING_SOURCE_URL)
+        .setOutputTemplate(destination)
+        .addArgs("--merge-output-format", "mp4")
+        .addArgs("--no-playlist")
+        .run();
+}
+async function ensureSourceVideo(engine, artifact, options) {
+    if (await hasFile(engine, artifact.artifactId, "original.mp4"))
+        return;
+    const workspace = await mkdtemp(join(tmpdir(), "videobook-dancing-source-"));
+    try {
+        const downloadedPath = join(workspace, "downloaded.mp4");
+        const sourcePath = options.sourceVideoPath ?? downloadedPath;
+        if (!options.sourceVideoPath)
+            await downloadDancingVideo(downloadedPath);
+        const clippedPath = join(workspace, "motion-reference.mp4");
+        await runFfmpeg([
+            "-y",
+            "-i", sourcePath,
+            "-t", String(DANCING_MOTION_DURATION_SECONDS),
+            "-map", "0:v:0",
+            "-map", "0:a:0?",
+            "-c:v", "libx264",
+            "-preset", "veryfast",
+            "-crf", "23",
+            "-pix_fmt", "yuv420p",
+            "-c:a", "aac",
+            "-b:a", "192k",
+            "-ac", "2",
+            "-movflags", "+faststart",
+            clippedPath,
+        ]);
+        const probe = await probeVideo(clippedPath);
+        if (probe.duration < 3 || probe.duration > 30) {
+            throw new Error(`Dancing motion reference must be 3-30 seconds, got ${probe.duration}`);
+        }
+        const written = await engine.files.writeFromPath(artifact.artifactId, "original.mp4", clippedPath);
+        if (!written.ok)
+            throw new Error(written.error.message);
+        const metadata = await engine.metadata.artifacts.write(artifact.artifactId, "original", {
+            origin: "download",
+            source_url: DANCING_SOURCE_URL,
+            title: "Dancing motion reference",
+            selected_range_seconds: [0, DANCING_MOTION_DURATION_SECONDS],
+            width: probe.width,
+            height: probe.height,
+            duration: probe.duration,
+            hasAudio: probe.hasAudio,
+            fixture: true,
+        });
+        if (!metadata.ok)
+            throw new Error(metadata.error.message);
+    }
+    finally {
+        await rm(workspace, { recursive: true, force: true });
+    }
+}
+async function ensureFirstFrame(engine, source, frame) {
+    if (await hasFile(engine, frame.artifactId, "original.jpg"))
+        return;
+    const sourceManifest = await engine.files.manifest(source.artifactId);
+    if (!sourceManifest.ok)
+        throw new Error(sourceManifest.error.message);
+    const video = findVideoFile(sourceManifest.value.files);
+    if (!video)
+        throw new Error("Dancing fixture source has no video file");
+    const workspace = await mkdtemp(join(tmpdir(), "videobook-dancing-frame-"));
+    try {
+        const framePath = join(workspace, "first-frame.jpg");
+        await runFfmpeg([
+            "-y",
+            "-ss", "0.1",
+            "-i", join(sourceManifest.value.path, video.name),
+            "-frames:v", "1",
+            "-q:v", "2",
+            framePath,
+        ]);
+        const written = await engine.files.writeFromPath(frame.artifactId, "original.jpg", framePath);
+        if (!written.ok)
+            throw new Error(written.error.message);
+        const image = await engine.files.read(frame.artifactId, "original.jpg");
+        if (!image.ok)
+            throw new Error(image.error.message);
+        const dimensions = await probeImage(image.value);
+        const metadata = await engine.metadata.artifacts.write(frame.artifactId, "original", {
+            origin: "first_frame",
+            source_asset: source.artifactId,
+            timestamp: 0.1,
+            ...dimensions,
+            fixture: true,
+        });
+        if (!metadata.ok)
+            throw new Error(metadata.error.message);
+    }
+    finally {
+        await rm(workspace, { recursive: true, force: true });
+    }
+}
+async function ensureKittenImage(engine, frame, kitten, options) {
+    if (await hasFile(engine, kitten.artifactId, "original.png"))
+        return;
+    const imagePath = options.kittenImagePath ?? DEFAULT_KITTEN_IMAGE_PATH;
+    const written = await engine.files.writeFromPath(kitten.artifactId, "original.png", imagePath);
+    if (!written.ok)
+        throw new Error(written.error.message);
+    const image = await engine.files.read(kitten.artifactId, "original.png");
+    if (!image.ok)
+        throw new Error(image.error.message);
+    const dimensions = await probeImage(image.value);
+    const metadata = await engine.metadata.artifacts.write(kitten.artifactId, "original", {
+        origin: "fixture_baseline",
+        source_asset: frame.artifactId,
+        prompt: IMAGE_PROMPT,
+        provider: "codex-imagegen",
+        ...dimensions,
+        fixture: true,
+    });
+    if (!metadata.ok)
+        throw new Error(metadata.error.message);
+}
+async function bootstrapDancingAssets(engine, options = {}) {
+    if (engine.book.get().name !== "dancing") {
+        throw new Error("The Dancing workflow can only seed the dancing book");
+    }
+    if (engine.notebooks.list().length === 0) {
+        const notebook = await engine.notebooks.create("Main");
+        if (!notebook.ok)
+            throw new Error(notebook.error.message);
+    }
+    const source = await ensureArtifact(engine, "video", SOURCE_LABEL);
+    const frame = await ensureArtifact(engine, "image", FIRST_FRAME_LABEL);
+    const kitten = await ensureArtifact(engine, "image", KITTEN_IMAGE_LABEL);
+    await ensureSourceVideo(engine, source, options);
+    await ensureFirstFrame(engine, source, frame);
+    await ensureKittenImage(engine, frame, kitten, options);
+}
+function completedExecution(document, preserved) {
+    const execution = { ...preserved };
+    const completedAt = new Date().toISOString();
+    for (const cell of fixtureCells(document)) {
+        const artifactId = resolveNotebookCellArtifactId(document, cell);
+        if (!artifactId)
+            continue;
+        execution[cell.id] = {
+            status: "completed",
+            fingerprint: notebookCellFingerprint(document, cell),
+            outputArtifactId: artifactId,
+            completedAt,
+            updatedAt: completedAt,
+            ...(cell.tool ? { tool: cell.tool } : {}),
+            fixtureBaseline: true,
+        };
+    }
+    return execution;
+}
+async function writeNotebook(engine, document) {
+    const written = await engine.notebooks.write(document);
+    if (!written.ok)
+        throw new Error(written.error.message);
+    const read = engine.notebooks.read(document.id);
+    if (!read.ok)
+        throw new Error(read.error.message);
+    return read.value;
+}
+export async function seedDancingWorkflow(engine, options = {}) {
+    if (engine.book.get().name !== "dancing") {
+        throw new Error("The Dancing workflow can only seed the dancing book");
+    }
+    await bootstrapDancingAssets(engine, options);
+    const notebook = engine.notebooks.list().find((candidate) => candidate.name.toLowerCase() === "dancing kittens")
+        ?? engine.notebooks.list()[0];
+    if (!notebook)
+        throw new Error("The Dancing book has no notebook");
+    if (isCurrentFixture(notebook))
+        return notebook;
+    const artifacts = engine.artifacts.list();
+    const sourceArtifact = requiredArtifact(artifacts, SOURCE_LABEL);
+    const frameArtifact = requiredArtifact(artifacts, FIRST_FRAME_LABEL);
+    const kittenArtifact = requiredArtifact(artifacts, KITTEN_IMAGE_LABEL);
+    const previousFixtureCells = fixtureCells(notebook);
+    const previousFixtureIds = new Set(previousFixtureCells.map((cell) => cell.id));
+    const preservedCells = notebook.cells.filter((cell) => !previousFixtureIds.has(cell.id));
+    const preservedEdges = notebook.edges.filter((edge) => !previousFixtureIds.has(edge.source) && !previousFixtureIds.has(edge.target));
+    const preservedExecution = Object.fromEntries(Object.entries(notebook.execution ?? {}).filter(([cellId]) => !previousFixtureIds.has(cellId)));
+    const ownedInputs = (workflowRole) => ({
+        fixtureOwner: DANCING_FIXTURE_OWNER,
+        workflowRole,
+    });
+    const source = engine.notebooks.createCell({
+        type: "video",
+        label: "Dancing reference video",
+        slot: { row: 0, column: 0 },
+        outputArtifactId: sourceArtifact.artifactId,
+        inputs: {
+            ...ownedInputs("download-video"),
+            sourceOperation: "download_video",
+            sourceUrl: DANCING_SOURCE_URL,
+            selectedRangeSeconds: [0, DANCING_MOTION_DURATION_SECONDS],
+            durationSeconds: DANCING_MOTION_DURATION_SECONDS,
+            state: "completed",
+        },
+    });
+    const extract = engine.notebooks.createCell({
+        type: "image",
+        label: "First frame",
+        slot: { row: 1, column: 0 },
+        outputArtifactId: frameArtifact.artifactId,
+        inputs: {
+            ...ownedInputs("extract-first-frame"),
+            mediaRole: "extract-frame-output",
+            sourceCellId: source.id,
+            atSeconds: 0.1,
+            frameMode: "first",
+            state: "completed",
+        },
+    });
+    const kittens = engine.notebooks.createCell({
+        type: "generate_image",
+        label: "Generate kittens freeway image",
+        slot: { row: 2, column: 1 },
+        prompt: IMAGE_PROMPT,
+        provider: "kie",
+        model: "kie:nano-banana-pro",
+        operation: "text_to_image",
+        tool: "generate_image",
+        inputs: {
+            ...ownedInputs("kittens-freeway"),
+            generationMode: "default",
+            generationSettings: { aspect_ratio: "9:16" },
+            fixtureBaseline: true,
+            requiresConfirmation: true,
+            state: "completed",
+        },
+    });
+    const kittenOutput = engine.notebooks.createCell({
+        type: "image",
+        label: "Kittens freeway image",
+        slot: { row: 3, column: 1 },
+        outputArtifactId: kittenArtifact.artifactId,
+        inputs: {
+            ...ownedInputs("kittens-freeway-output"),
+            mediaRole: "generate-image-output",
+            producerCellId: kittens.id,
+            fixtureBaseline: true,
+            state: "completed",
+        },
+    });
+    const motion = engine.notebooks.createCell({
+        type: "generate_video",
+        label: "Kittens dancing motion",
+        slot: { row: 3, column: 2 },
+        prompt: MOTION_PROMPT,
+        provider: "kie",
+        model: "kie:kling-3.0-omni/transformation",
+        operation: "edit_video",
+        tool: "generate_video",
+        inputs: {
+            ...ownedInputs("kling-omni-transformation"),
+            generationSettings: {
+                resolution: "720p",
+                aspect_ratio: "9:16",
+                duration: "10",
+            },
+            requiresConfirmation: true,
+            state: "pending",
+        },
+    });
+    const motionOutput = engine.notebooks.createCell({
+        type: "video",
+        label: "Kittens dancing video",
+        slot: { row: 4, column: 2 },
+        inputs: {
+            ...ownedInputs("kling-omni-transformation-output"),
+            mediaRole: "generate-video-output",
+            producerCellId: motion.id,
+            state: "pending",
+        },
+    });
+    const fixtureEdges = [
+        engine.notebooks.createEdge({
+            source: source.id,
+            target: extract.id,
+            targetInput: "segment",
+        }),
+        engine.notebooks.createEdge({
+            source: extract.id,
+            target: kittens.id,
+            targetInput: "input",
+        }),
+        engine.notebooks.createEdge({
+            source: kittens.id,
+            target: kittenOutput.id,
+            targetInput: "media",
+        }),
+        engine.notebooks.createEdge({
+            source: kittenOutput.id,
+            target: motion.id,
+            targetInput: "image",
+        }),
+        engine.notebooks.createEdge({
+            source: source.id,
+            target: motion.id,
+            targetInput: "video",
+        }),
+        engine.notebooks.createEdge({
+            source: motion.id,
+            target: motionOutput.id,
+            targetInput: "media",
+        }),
+    ];
+    const ensuredAt = new Date().toISOString();
+    const document = {
+        ...notebook,
+        name: "Dancing Kittens",
+        description: "Download a dance reference, extract its first frame, replace the dancers with kittens beside a freeway, then transfer the dance with Kling 3.0 Omni transformation.",
+        lifecycleState: "in-progress",
+        cells: [
+            ...preservedCells,
+            source,
+            extract,
+            kittens,
+            kittenOutput,
+            motion,
+            motionOutput,
+        ],
+        edges: [...preservedEdges, ...fixtureEdges],
+        generationPlans: [],
+        notebookRunPlans: [],
+        execution: preservedExecution,
+        fixture: {
+            version: DANCING_FIXTURE_VERSION,
+            owner: DANCING_FIXTURE_OWNER,
+            ensuredAt,
+            materializedAt: ensuredAt,
+            noPaidCalls: true,
+            sourceUrl: DANCING_SOURCE_URL,
+            motionDurationSeconds: DANCING_MOTION_DURATION_SECONDS,
+        },
+    };
+    document.execution = completedExecution(document, preservedExecution);
+    const persisted = await writeNotebook(engine, document);
+    persisted.execution = completedExecution(persisted, persisted.execution ?? preservedExecution);
+    return writeNotebook(engine, persisted);
+}
+export async function ensureDancingWorkflow(books, options = {}) {
+    await books.ready();
+    let selected = books.getByName("dancing");
+    let created = false;
+    if (!selected.ok) {
+        const createdBook = await books.create("dancing");
+        if (!createdBook.ok)
+            throw new Error(createdBook.error.message);
+        selected = books.getByName("dancing");
+        if (!selected.ok)
+            throw new Error(selected.error.message);
+        created = true;
+    }
+    const previousHead = selected.value.engine.head;
+    const notebook = await seedDancingWorkflow(selected.value.engine, options);
+    return {
+        status: created
+            ? "created"
+            : selected.value.engine.head === previousHead
+                ? "unchanged"
+                : "migrated",
+        notebookId: notebook.id,
+        revision: selected.value.engine.head,
+    };
+}

package/dist/data-home.js

@@ -0,0 +1,44 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const WORKSPACE_PACKAGE_NAME = "videobook-workspace";
+function packageName(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return typeof parsed.name === "string" ? parsed.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function sourceCheckoutRoot(moduleUrl = import.meta.url) {
+    const root = resolve(dirname(fileURLToPath(moduleUrl)), "../..");
+    return packageName(join(root, "package.json")) === WORKSPACE_PACKAGE_NAME ? root : null;
+}
+function homeLayout(root) {
+    return {
+        kind: "home",
+        root,
+        libraryDir: join(root, "books"),
+        appStatePath: join(root, "app-state.json"),
+        envPath: join(root, ".env"),
+    };
+}
+function checkoutLayout(root) {
+    return {
+        kind: "checkout",
+        root,
+        libraryDir: join(root, "books"),
+        appStatePath: join(root, "runtime", "app-state.json"),
+        envPath: join(root, ".env"),
+    };
+}
+export function dataLayout(env = process.env, cwd = process.cwd(), checkoutRoot = sourceCheckoutRoot()) {
+    const home = env.VIDEOBOOK_HOME?.trim();
+    if (home)
+        return homeLayout(resolve(cwd, home));
+    if (checkoutRoot)
+        return checkoutLayout(checkoutRoot);
+    return homeLayout(join(homedir(), ".videobook"));
+}

package/dist/diagnostics.js

@@ -0,0 +1,109 @@
+import { ENGINE_ERROR_CODES } from "videobook-engine";
+const EVENTS = [
+    "mcp", "server-listening", "shutdown-complete", "shutdown-failed", "startup-failed",
+    "book-open", "book-open-slow", "book-catalog-gc", "provider-poll-failed",
+    "ace-server-exited", "scheduled-post-failed", "scheduled-post-rearm-failed",
+    "generation-record-failed", "generation-update-failed", "generation-list-failed",
+    "provider-task-record-failed",
+    "prompt-record-failed",
+    "waveform-empty", "waveform-failed", "heartbeat-failed", "subtitle-cache-failed",
+    "subtitle-translation-failed", "overlay-skipped", "kie-upload-fallback",
+    "kie-upload-unconfigured", "fal-upload-fallback", "fal-upload-unconfigured",
+    "alibaba-upload-fallback", "alibaba-upload-unconfigured", "suggest-cuts-dropped",
+    "suggest-sfx-dropped", "transcribe-soft-fail", "post-record-failed", "post-cell-failed",
+    "process-video-enqueue-failed", "waveform-write-failed", "timeline-reencode",
+    "pad-video-started", "video-analysis-failed", "description-truncated",
+    "description-cache-failed", "watermark-placement-fallback", "waveform-enqueue-failed",
+    "poster-enqueue-failed",
+    "watermark-probe-fallback", "generation-error-clear-failed", "timeline-orientation-failed",
+    "generation-cost-estimate", "job-error", "semantic-index-deferred",
+    "tag-asset-failed", "voice-session-closed", "alive-captions-regions-failed",
+];
+const events = new Set(EVENTS);
+const errorCodes = new Set([
+    ...ENGINE_ERROR_CODES, "UNKNOWN", "ENOENT", "EACCES", "EPERM", "ENOSPC",
+    "EIO", "EMFILE", "ENFILE", "ENOMEM", "ECONNREFUSED", "ECONNRESET",
+    "ETIMEDOUT", "EPIPE", "ENOTFOUND", "EADDRINUSE", "EADDRNOTAVAIL", "ABORT_ERR",
+]);
+const names = { tool: new Set(), jobType: new Set() };
+export function registerDiagnosticName(kind, name) {
+    if (typeof name === "string" && name.trim() === name && /^[a-z][a-z0-9_]{0,95}$/.test(name))
+        names[kind].add(name);
+}
+function ownValue(value, key) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    try {
+        return Object.getOwnPropertyDescriptor(value, key)?.value;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function diagnosticErrorCode(error) {
+    for (const value of [ownValue(error, "code"), ownValue(ownValue(error, "error"), "code")]) {
+        if (typeof value === "string" && errorCodes.has(value))
+            return value;
+    }
+    return "UNKNOWN";
+}
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UUID_FIELDS = ["bookId", "assetId", "artifactId", "notebookId", "cellId", "outputCellId",
+    "generationId", "scheduleId", "operationId", "runId"];
+const NUMBER_FIELDS = ["durationMs", "bytesBefore", "bytesAfter", "count", "limit", "warningCount", "targetFps", "inputTokens", "outputTokens"];
+const ENUM_FIELDS = {
+    voiceModel: ["gpt-realtime-2.1-mini", "gpt-realtime-2.1", "gpt-realtime-mini", "gpt-realtime", "grok-voice-think-fast-2.0", "grok-voice-latest"],
+    status: ["ok", "error"],
+    modality: ["visual", "audio", "metadata"],
+    reason: ["unbounded", "zero", "missing-adapter", "missing-rates", "missing-selector", "estimator-threw", "estimate-error"],
+    provider: ["kie", "fal", "alibaba", "elevenlabs", "openai", "kimicoding", "xai", "acestep"],
+    stage: ["submit-kie", "submit-queued-kie", "submit-veo", "index-progressive"],
+    signal: ["SIGTERM", "SIGKILL", "SIGINT", "SIGABRT", "SIGSEGV", "SIGBUS", "SIGILL", "SIGFPE", "SIGHUP"],
+};
+export function diagnosticRecord(event, fields = {}) {
+    const result = { event: events.has(event) ? event : "unknown-event" };
+    for (const key of UUID_FIELDS) {
+        const value = ownValue(fields, key);
+        if (typeof value === "string" && value.length === 36 && UUID.test(value))
+            result[key] = value;
+    }
+    for (const key of NUMBER_FIELDS) {
+        const value = ownValue(fields, key);
+        if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+            result[key] = value;
+    }
+    for (const key of ["available", "detached", "rolledBack"]) {
+        const value = ownValue(fields, key);
+        if (typeof value === "boolean")
+            result[key] = value;
+    }
+    for (const key of Object.keys(ENUM_FIELDS)) {
+        const value = ownValue(fields, key);
+        if (typeof value === "string" && ENUM_FIELDS[key].includes(value))
+            result[key] = value;
+    }
+    for (const key of ["tool", "jobType"]) {
+        const value = ownValue(fields, key);
+        if (typeof value === "string" && names[key].has(value))
+            result[key] = value;
+    }
+    const jobId = ownValue(fields, "jobId");
+    if ((typeof jobId === "number" && Number.isSafeInteger(jobId) && jobId >= 0)
+        || (typeof jobId === "string" && jobId.length === 36 && UUID.test(jobId)))
+        result.jobId = jobId;
+    for (const [key, min, max] of [["exitCode", -255, 255], ["port", 1, 65535]]) {
+        const value = ownValue(fields, key);
+        if (typeof value === "number" && Number.isInteger(value) && value >= min && value <= max)
+            result[key] = value;
+    }
+    const error = ownValue(fields, "error");
+    const code = ownValue(fields, "errorCode");
+    if (error !== undefined || code !== undefined) {
+        result.errorCode = typeof code === "string" && errorCodes.has(code) ? code : diagnosticErrorCode(error);
+    }
+    return result;
+}
+export async function appendDiagnostic(engine, event, fields) {
+    const record = diagnosticRecord(event, fields);
+    await engine.logs.append(String(record.event), record);
+}

package/dist/dialog-quality.js

@@ -0,0 +1,34 @@
+export function assessDialogQuality(data) {
+    const raw = data.text ?? "";
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+        return { hasDialog: false, reason: "empty", text: trimmed, wordCount: 0 };
+    }
+    const stripped = trimmed.replace(/\[[^\]]*\]/g, "").trim();
+    if (stripped.length === 0) {
+        return { hasDialog: false, reason: "noise_only", text: trimmed, wordCount: 0 };
+    }
+    const words = stripped.split(/\s+/);
+    const wordCount = words.length;
+    if (wordCount < 3) {
+        return { hasDialog: false, reason: "too_short", text: trimmed, wordCount };
+    }
+    const uniqueWords = new Set(words.map((w) => w.toLowerCase()));
+    if (uniqueWords.size / wordCount < 0.3) {
+        return { hasDialog: false, reason: "nonsensical", text: trimmed, wordCount };
+    }
+    return { hasDialog: true, reason: "real_dialog", text: trimmed, wordCount };
+}
+export async function readAndAssessDialog(engine, assetId) {
+    const result = await engine.files.read(assetId, ".analysis.gpt4otrans.json");
+    if (!result.ok) {
+        return { hasDialog: false, reason: "no_transcription", text: "", wordCount: 0 };
+    }
+    try {
+        const data = JSON.parse(result.value.toString());
+        return assessDialogQuality(data);
+    }
+    catch {
+        return { hasDialog: false, reason: "no_transcription", text: "", wordCount: 0 };
+    }
+}