gooseworks 0.5.0-dev.9.d3e7757f → 0.5.0

package/dist/kit/core/run.js

@@ -0,0 +1,850 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYER_ORDER = void 0;
+exports.makeVideo = makeVideo;
+// `gooseworks video make <id>`, in order (part-interface.md section 8):
+//  1. the hand-over (token, frozen plan, parts lock, style package);
+//  2. a kit that is too old stops here and updates itself;
+//  3. the run folder and its lock; the style package, checked;
+//  4. every locked part loaded and checked: nothing is spent before this;
+//  5. the plan's files downloaded and checked;
+//  6. the style's timeline in order, saving after every piece;
+//  7. the layers that are on, in the fixed order brand, captions, sound, check;
+//  8. one local fix when the check fails;
+//  9. the upload and our server's check, with one fix after a first fail;
+// 10. done. The run folder stays, so the same command resumes at any time.
+//
+// The core knows the style file's grammar, the part interface, the four layer
+// slots, the line and the save layout. It knows nothing about any one style.
+const promises_1 = require("fs/promises");
+const path = __importStar(require("path"));
+const client_1 = require("../line/client");
+const types_1 = require("../line/types");
+const bind_1 = require("./bind");
+const canonical_1 = require("./canonical");
+const device_1 = require("./device");
+const errors_1 = require("./errors");
+const files_1 = require("./files");
+const paths_1 = require("./paths");
+const pieces_1 = require("./pieces");
+const progress_1 = require("./progress");
+const progress_reporter_1 = require("./progress-reporter");
+const save_1 = require("./save");
+const schema_1 = require("./schema");
+const secrets_1 = require("./secrets");
+const style_1 = require("./style");
+const toolchain_1 = require("./toolchain");
+const loader_1 = require("../parts/loader");
+const env_1 = require("../env");
+const version_1 = require("./version");
+exports.LAYER_ORDER = ['brand', 'captions', 'sound', 'check'];
+const SLOT_KIND = { brand: 'compose', captions: 'caption', sound: 'mix', check: 'check' };
+/** The server's checks a layer can redo. */
+const SERVER_CHECK_SLOT = { sound: 'sound', captions: 'captions' };
+/** Pixel size of each aspect the plan may pick (short side 1080). */
+const ASPECT_SIZE = {
+    '9:16': { width: 1080, height: 1920 },
+    '1:1': { width: 1080, height: 1080 },
+    '4:5': { width: 1080, height: 1350 },
+    '16:9': { width: 1920, height: 1080 },
+};
+function lineWords(error) {
+    return [error.message, error.fix].filter(Boolean).join(' ');
+}
+/** Plain words for a part's failure: the line's own words when it said them, never a part's detail. */
+function failureWords(error) {
+    if (error instanceof pieces_1.PieceFailure)
+        return [error.line.error, error.line.fix].filter(Boolean).join(' ');
+    switch (error.code) {
+        case 'provider_rejected':
+            return 'One part of this video was refused by the maker. Change that scene in the plan, then make it again.';
+        case 'over_quote':
+            return 'This video reached its approved price, so it stopped. Nothing past the price was charged.';
+        case 'needs_missing':
+            return 'This computer is missing something this video needs. Run the computer check, then make it again.';
+        case 'timeout':
+            return 'Part of this video took too long. Run the same command again; what was made so far is kept.';
+        default:
+            return 'Part of this video could not be made. Run the same command again; what was made so far is kept.';
+    }
+}
+function checkLock(raw, videoId, plan) {
+    const lock = raw;
+    if (!lock || lock.lock !== 1 || lock.video_id !== videoId || !lock.parts || !lock.layers || !lock.style) {
+        throw new errors_1.KitStop('This video’s parts list can’t be read. Nothing was spent.', 'change_request');
+    }
+    if (lock.style.id !== plan.style_id || lock.style.version !== plan.style_version)
+        throw new errors_1.KitStop('This video’s parts list is for another style. Nothing was spent.', 'change_request');
+    return lock;
+}
+function expectationOf(style, plan) {
+    const aspect = String(plan.body.aspect ?? style.aspects?.[0] ?? '');
+    const size = ASPECT_SIZE[aspect];
+    if (!size)
+        throw new errors_1.KitStop('This video’s shape can’t be made by the kit.', 'change_request');
+    const scenes = Array.isArray(plan.body.scenes) ? plan.body.scenes : [];
+    const script = scenes.map((s) => s?.line).filter((l) => typeof l === 'string' && l.length > 0);
+    return {
+        aspect: aspect,
+        ...size,
+        duration_s: { min: style.duration.min_seconds, max: style.duration.max_seconds },
+        speech: (style.traits?.speech ?? 'none'),
+        captions: style.traits?.captions === true,
+        end_card: style.traits?.end_card === true,
+        qc_flags: Array.isArray(style.traits?.qc_flags) ? style.traits.qc_flags : [],
+        ...(script.length ? { script } : {}),
+    };
+}
+function brandKit(materialized) {
+    const out = {};
+    for (const [k, v] of Object.entries((materialized ?? {})))
+        if (v !== null && v !== undefined)
+            out[k] = v;
+    return out;
+}
+function fileRefsIn(value, into = []) {
+    if ((0, canonical_1.isFileRef)(value))
+        into.push(value);
+    else if (Array.isArray(value))
+        value.forEach((v) => fileRefsIn(v, into));
+    else if (value && typeof value === 'object')
+        Object.values(value).forEach((v) => fileRefsIn(v, into));
+    return into;
+}
+/** One make of one video. */
+class Maker {
+    videoId;
+    deps;
+    sleep;
+    now;
+    stop = new AbortController();
+    fatal = null;
+    book = new progress_1.ProgressBook();
+    reporter;
+    store;
+    layout;
+    run;
+    cache;
+    tools;
+    toolchain = '';
+    browserReady = false;
+    handed;
+    lock = null;
+    style;
+    planScope;
+    brand;
+    parts = new Map();
+    hosted = new Map();
+    pieceLocks = new Map();
+    constructor(videoId, deps) {
+        this.videoId = videoId;
+        this.deps = deps;
+        this.sleep = deps.sleep ?? client_1.sleep;
+        this.now = deps.now ?? (() => new Date());
+        deps.signal?.addEventListener('abort', () => this.halt(new errors_1.KitStop('Stopped on this computer. Run the same command to carry on.', 'stop')), { once: true });
+    }
+    halt(stop) {
+        this.fatal ??= stop;
+        if (!this.stop.signal.aborted)
+            this.stop.abort(stop);
+    }
+    say(line) {
+        this.deps.log.say(line);
+    }
+    async make() {
+        const { deps } = this;
+        let dev;
+        try {
+            dev = this.devFolders();
+        }
+        catch (error) {
+            return this.ended(error);
+        }
+        this.tools = deps.tools ?? (await (0, toolchain_1.inspectFfmpeg)({ home: deps.home, env: deps.env, setup: true, download: (u, m) => deps.line.download(u, m), say: (l) => this.say(l) }));
+        const browser = await deps.host.browser.check({ home: deps.home, setup: true, env: deps.env, say: (l) => this.say(l) });
+        this.browserReady = browser.ok;
+        this.toolchain = (0, toolchain_1.toolchainId)(this.tools, browser.ok ? browser.version : null);
+        const report = await (0, device_1.deviceReport)({ home: deps.home, worker: deps.line.isWorker, tools: this.tools, browser });
+        let answer;
+        try {
+            answer = await deps.line.handOver(this.videoId, report);
+        }
+        catch (error) {
+            if (error instanceof client_1.LineError) {
+                if (error.next === 'update_kit')
+                    return { status: 'update_kit', message: lineWords(error) };
+                return { status: 'stopped', message: lineWords(error) };
+            }
+            throw error;
+        }
+        if (!answer.kit.ok)
+            return { status: 'update_kit', message: 'This video kit is too old for this video.', min_version: answer.kit.min_version };
+        if (!answer.line)
+            return { status: 'stopped', message: 'This video can’t be made on this computer right now.' };
+        this.handed = answer.line;
+        this.layout = (0, paths_1.runLayout)(deps.home, this.videoId);
+        const release = await (0, save_1.takeRunLock)(this.layout, this.now());
+        // From here on the lock is always given back, whatever fails.
+        try {
+            deps.log.attach(this.layout.log);
+            deps.log.write('info', 'video handed over', { quote_id: this.handed.quote_id, stage: this.handed.stage, kit: version_1.KIT_VERSION });
+            this.store = new save_1.RunStore(this.layout);
+            this.cache = new pieces_1.PieceCache(this.layout.pieces);
+            this.reporter = new progress_reporter_1.ProgressReporter(deps.line, this.videoId, this.book, deps.log, (message, reason, code) => this.halt(new errors_1.KitStop(message, reason, code)), deps.heartbeatMs, this.stop.signal);
+            // Reports start now, so checking the style and parts never looks quiet.
+            this.reporter.start();
+            void this.reporter.send(true);
+            return await this.makeHandedOver(dev);
+        }
+        catch (error) {
+            return await this.ended(error);
+        }
+        finally {
+            this.reporter?.stopTimer();
+            await this.reporter?.flush().catch(() => undefined);
+            await release();
+        }
+    }
+    devFolders() {
+        const parts = this.deps.env[env_1.KIT_DEV_ENV.partsDir] || null;
+        const styles = this.deps.env[env_1.KIT_DEV_ENV.stylesDir] || null;
+        if ((parts || styles) && this.deps.environment === 'production') {
+            throw new errors_1.KitStop('The dev parts and styles folders work only against staging or a local server.', 'refused');
+        }
+        return { parts, styles };
+    }
+    async ended(error) {
+        const stop = this.fatal ?? (error instanceof errors_1.KitStop ? error : null);
+        if (stop)
+            this.deps.log.write('warn', 'the run stopped', { reason: stop.reason, code: stop.code ?? null, message: stop.message });
+        if (this.run) {
+            this.run.status = stop && stop.reason === 'stop' ? 'stopped' : 'failed';
+            await this.saveRun().catch(() => undefined);
+        }
+        if (stop) {
+            if (stop.reason === 'update_kit')
+                return { status: 'update_kit', message: stop.message };
+            return { status: stop.reason === 'stop' ? 'stopped' : 'failed', message: stop.message };
+        }
+        this.deps.log.write('error', 'the run ended on an error', { error: error instanceof Error ? error.message : String(error) });
+        return { status: 'failed', message: 'This video could not be made right now. Run the same command again; what was made so far is kept.' };
+    }
+    async saveRun() {
+        this.run.updated_at = this.now().toISOString();
+        await this.store.writeRun(this.run);
+    }
+    async makeHandedOver(dev) {
+        const { deps, handed } = this;
+        const plan = handed.plan;
+        if (!plan || plan.project_id !== this.videoId || plan.style_id !== handed.style_package?.style_id || plan.style_version !== handed.style_package?.version) {
+            throw new errors_1.KitStop('The plan handed over is not this video’s. Nothing was spent.', 'change_request');
+        }
+        if (handed.parts_lock)
+            this.lock = checkLock(handed.parts_lock, this.videoId, plan);
+        else if (!dev.parts)
+            throw new errors_1.KitStop('This video’s parts are not ready yet. Run the same command again in a few minutes. Nothing was spent.', 'stop');
+        const planCopy = (0, secrets_1.withoutSignedLinks)(plan);
+        await (0, promises_1.mkdir)(this.layout.root, { recursive: true, mode: 0o700 });
+        await (0, save_1.writeJson)(this.layout.plan, planCopy);
+        if (this.lock)
+            await (0, save_1.writeJson)(this.layout.partsLock, this.lock);
+        const previous = (await this.store.readRun());
+        const started = this.now().toISOString();
+        this.run = {
+            record: 1,
+            video_id: this.videoId,
+            quote_id: handed.quote_id,
+            plan_revision: plan.revision,
+            style: { id: plan.style_id, version: plan.style_version },
+            plan_sha256: (0, canonical_1.canonicalHash)(planCopy),
+            lock_sha256: this.lock ? (0, canonical_1.canonicalHash)(this.lock) : '',
+            device_id: await (0, device_1.deviceId)(deps.home),
+            kit: { version: version_1.KIT_VERSION, toolchain: this.toolchain, parts_source: dev.parts ? 'dev' : 'published' },
+            status: 'running',
+            steps: previous?.steps ?? {},
+            local_fix_used: previous?.quote_id === handed.quote_id ? previous.local_fix_used : false,
+            fixes: previous?.quote_id === handed.quote_id ? (previous.fixes ?? []) : [],
+            upload_attempt: previous?.quote_id === handed.quote_id ? previous.upload_attempt : 0,
+            started_at: previous?.started_at ?? started,
+            updated_at: started,
+        };
+        await this.saveRun();
+        // The style, then every part: all checked before anything is spent.
+        // The style must be exactly the one approved: the package's hash and the plan's must agree.
+        if (!plan.style_hash || handed.style_package.style_hash !== plan.style_hash) {
+            throw new errors_1.KitStop('The style handed over is not the one approved for this video. Nothing was spent.', 'change_request');
+        }
+        const pin = { id: plan.style_id, version: plan.style_version, hash: plan.style_hash };
+        this.style = dev.styles
+            ? await (0, style_1.readLocalStyle)(dev.styles, pin)
+            : await (0, style_1.fetchStyle)({ ref: handed.style_package, projectId: this.videoId, dir: this.layout.style, download: (u, m) => deps.line.download(u, m, this.stop.signal) });
+        await this.loadParts(!!dev.parts);
+        // The plan's files, checked against the hashes frozen at the yes.
+        const planFiles = {
+            dir: this.layout.inputs,
+            download: (u, m) => deps.line.download(u, m, this.stop.signal),
+            hostedLink: (fileId) => deps.line.hostedFileLink(this.videoId, fileId, this.stop.signal).catch((error) => {
+                if (error instanceof client_1.LineError)
+                    throw new errors_1.KitStop(`${lineWords(error)} Nothing was spent.`, error.next === 'update_kit' ? 'update_kit' : error.next === 'change_request' ? 'change_request' : 'stop', error.code);
+                throw error;
+            }),
+            // A hosted plan file goes into a payload as the line already knows it.
+            onHosted: (sha256, ref) => this.hosted.set(sha256, ref),
+        };
+        this.planScope = await (0, files_1.materialize)(plan.body, planFiles);
+        this.brand = brandKit(await (0, files_1.materialize)(plan.brand, planFiles));
+        this.book.note = 'Making your video';
+        this.book.plan([
+            ...this.style.style.timeline.map((s) => ({ id: s.id, kind: this.parts.get(s.id).manifest.kind, typical_s: this.parts.get(s.id).manifest.timing.typical_s })),
+            ...this.layersOn().map((slot) => ({ id: `layer-${slot}`, kind: SLOT_KIND[slot], typical_s: this.parts.get(`layer-${slot}`).manifest.timing.typical_s })),
+        ]);
+        void this.reporter.send(true);
+        // The fixes already in force (after a restart) apply from the start.
+        let result = await this.pipeline();
+        if (!result.verdict.pass) {
+            const fix = this.run.local_fix_used ? null : this.fixFrom(result.verdict, [], 'local');
+            if (!fix)
+                return this.checkFailed(result.verdict);
+            this.run.local_fix_used = true;
+            this.run.fixes = [...(this.run.fixes ?? []), fix];
+            await this.saveRun();
+            this.say('The final check found something to fix. Fixing it once…');
+            result = await this.pipeline();
+            if (!result.verdict.pass)
+                return this.checkFailed(result.verdict);
+        }
+        return this.upload(result);
+    }
+    layersOn() {
+        const layers = this.style.style.layers;
+        return exports.LAYER_ORDER.filter((slot) => slot === 'check' || layers[slot] === true);
+    }
+    /** Every part this video runs, from the lock, checked before anything is spent. */
+    async loadParts(dev) {
+        const lock = this.lock;
+        const layerRefs = lock?.layers ?? this.handed.plan.layers;
+        const wanted = [
+            ...this.style.style.timeline.map((s) => ({ key: s.id, ref: s.part })),
+            ...this.layersOn().map((slot) => ({ key: `layer-${slot}`, ref: layerRefs?.[slot], slot })),
+        ];
+        for (const { key, ref, slot } of wanted) {
+            if (!ref || typeof ref.id !== 'string' || typeof ref.version !== 'string')
+                throw new errors_1.KitStop('This video names a part it has no version for. Nothing was spent.', 'change_request');
+            if (lock) {
+                const entry = lock.parts[ref.id];
+                if (!entry || entry.version !== ref.version)
+                    throw new errors_1.KitStop(`Part ${ref.id} ${ref.version} is not in this video’s parts list, so it can’t run. Nothing was spent.`, 'change_request');
+                const tooOld = (0, version_1.kitRangeRefusal)({ id: ref.id, version: ref.version, kit: entry.kit });
+                if (tooOld)
+                    throw new errors_1.KitStop(`${tooOld} Nothing was spent.`, 'update_kit');
+            }
+        }
+        for (const { key, ref, slot } of wanted) {
+            let loaded;
+            try {
+                loaded = await this.deps.host.loader.load({ ref, lock, dev, home: this.deps.home, env: this.deps.env, signal: this.stop.signal });
+            }
+            catch (error) {
+                const words = `${error instanceof Error ? error.message : 'A part could not be loaded.'} Nothing was spent.`;
+                if (error instanceof loader_1.PartLoadError && error.code === 'kit_range')
+                    throw new errors_1.KitStop(words, 'update_kit');
+                if (error instanceof loader_1.PartLoadError && error.code === 'unreachable')
+                    throw new errors_1.KitStop(`${words} Run the same command again in a minute.`, 'stop');
+                throw new errors_1.KitStop(words, 'change_request');
+            }
+            const m = loaded.manifest;
+            if (m.id !== ref.id || m.version !== ref.version)
+                throw new errors_1.KitStop(`Part ${ref.id} ${ref.version} loaded as another version. Nothing was spent.`, 'change_request');
+            const refusal = (0, version_1.interfaceRefusal)(m);
+            if (refusal)
+                throw new errors_1.KitStop(`${refusal} Nothing was spent.`, 'update_kit');
+            if (slot && (m.layer !== slot || m.kind !== SLOT_KIND[slot]))
+                throw new errors_1.KitStop(`Part ${ref.id} can’t fill the ${slot} layer. Nothing was spent.`, 'change_request');
+            const lockModels = lock ? lock.parts[ref.id].models : m.needs.models;
+            const paid = m.needs.network || m.needs.models.length > 0 || m.kind.startsWith('generate_');
+            if (paid && (!Array.isArray(lockModels) || lockModels.length === 0))
+                throw new errors_1.KitStop(`Part ${ref.id} orders paid pieces but this video’s parts list allows it none. Nothing was spent.`, 'change_request');
+            const missing = this.missingNeeds(m.needs);
+            if (missing)
+                throw new errors_1.KitStop(`This computer can’t run part ${ref.id}: ${missing}. Run the computer check, then make the video again. Nothing was spent.`, 'refused');
+            try {
+                (0, schema_1.assertCheckable)(m.inputs);
+                (0, schema_1.assertCheckable)(m.outputs);
+            }
+            catch (error) {
+                throw new errors_1.KitStop(`Part ${ref.id} can’t be checked by this kit (${error.message}). Nothing was spent.`, 'update_kit');
+            }
+            this.parts.set(key, loaded);
+        }
+    }
+    missingNeeds(needs) {
+        if (needs.ffmpeg) {
+            if (!this.tools.ffmpeg.path || !this.tools.ffprobe.path)
+                return 'the video tools are missing';
+            if (typeof needs.ffmpeg === 'object') {
+                const lacking = [
+                    ...(needs.ffmpeg.filters ?? []).filter((f) => !(this.tools.ffmpeg.filters ?? []).includes(f)),
+                    ...(needs.ffmpeg.encoders ?? []).filter((e) => !(this.tools.ffmpeg.encoders ?? []).includes(e)),
+                ];
+                if (lacking.length)
+                    return 'the video tools here lack something it needs';
+            }
+        }
+        if (needs.browser && !this.browserReady)
+            return 'the video browser is missing';
+        return null;
+    }
+    /** The timeline, then the layers that are on. Saved steps with the same hash are reused. */
+    async pipeline() {
+        const outputs = new Map();
+        const scope = { plan: this.planScope, brand: this.brand, steps: outputs, assets: this.style.assets };
+        const hashes = {};
+        let timeline = null;
+        const fixes = this.run.fixes ?? [];
+        const fixed = (id, inputs) => {
+            const mine = fixes.filter((f) => f.target === id);
+            return {
+                inputs: mine.reduce((acc, f) => ({ ...acc, ...f.inputs }), inputs),
+                round: mine.length ? Math.max(...mine.map((f) => f.round)) : undefined,
+            };
+        };
+        for (const step of this.style.style.timeline) {
+            const loaded = this.parts.get(step.id);
+            const { inputs, round } = fixed(step.id, (0, bind_1.bindInputs)(step.inputs, scope, step.id));
+            const out = await this.runStep({ id: step.id, ref: step.part, loaded, inputs, models: this.modelsOf(step.part, loaded), fix: round }, hashes);
+            outputs.set(step.id, out);
+            if (out.timeline && typeof out.timeline === 'object')
+                timeline = out.timeline;
+        }
+        const last = this.style.style.timeline[this.style.style.timeline.length - 1];
+        const made = outputs.get(last.id)?.video;
+        if (!(0, canonical_1.isFileRef)(made) || made.media !== 'video')
+            throw new errors_1.KitStop('The style’s last step made no video.', 'change_request');
+        let cut = made;
+        timeline ??= await this.bareTimeline(cut);
+        let words;
+        let captions;
+        let verdict = null;
+        for (const slot of this.layersOn()) {
+            const id = `layer-${slot}`;
+            const loaded = this.parts.get(id);
+            const ref = { id: loaded.manifest.id, version: loaded.manifest.version };
+            const { inputs, round } = fixed(id, { video: cut, timeline, brand: this.brand, expect: expectationOf(this.style.style, this.handed.plan), ...(words ? { words } : {}) });
+            const out = await this.runStep({ id, ref, loaded, inputs, models: this.modelsOf(ref, loaded), fix: round }, hashes);
+            if (slot === 'check') {
+                verdict = out.verdict;
+                continue;
+            }
+            const video = out.video;
+            if (!(0, canonical_1.isFileRef)(video) || video.media !== 'video')
+                throw new errors_1.KitStop(`The ${slot} layer made no video.`, 'change_request');
+            cut = video;
+            if (out.timeline && typeof out.timeline === 'object')
+                timeline = out.timeline;
+            if (slot === 'captions') {
+                if ((0, canonical_1.isFileRef)(out.words))
+                    words = out.words;
+                if ((0, canonical_1.isFileRef)(out.captions))
+                    captions = out.captions;
+            }
+        }
+        if (!verdict || typeof verdict.pass !== 'boolean' || !Array.isArray(verdict.checks))
+            throw new errors_1.KitStop('The final check gave no verdict.', 'change_request');
+        return { cut, captions, verdict, steps: hashes };
+    }
+    modelsOf(ref, loaded) {
+        return this.lock ? (this.lock.parts[ref.id]?.models ?? []) : loaded.manifest.needs.models;
+    }
+    async bareTimeline(cut) {
+        const probe = (0, toolchain_1.kitTools)({ ffmpeg: this.tools.ffmpeg.path ?? 'ffmpeg', ffprobe: this.tools.ffprobe.path ?? 'ffprobe', toolchain: this.toolchain }, this.stop.signal).probe;
+        const info = await probe(cut.path).catch(() => null);
+        const duration_s = info?.duration_s ?? cut.duration_s;
+        const width = info?.width ?? cut.width;
+        const height = info?.height ?? cut.height;
+        const fps = info?.fps ?? cut.fps;
+        if (!duration_s || !width || !height || !fps)
+            throw new errors_1.KitStop('The video’s length and size could not be read.', 'failed');
+        return { duration_s, width, height, fps, scenes: [], speech: [] };
+    }
+    /** One step: reused when its saved record has the same hash and intact files, else run (and retried once). */
+    async runStep(spec, hashes) {
+        const { manifest } = spec.loaded;
+        const inputErrors = (0, schema_1.schemaErrors)(manifest.inputs, spec.inputs, `${spec.id} inputs`);
+        if (inputErrors.length) {
+            this.deps.log.write('error', 'step inputs refused', { step: spec.id, errors: inputErrors });
+            throw new errors_1.KitStop(`The style gave its ${spec.id} step something its part can’t take, so the video stopped before that step.`, 'change_request');
+        }
+        const hash = (0, canonical_1.stepHash)({ interface: manifest.interface, part: spec.ref, toolchain: this.toolchain, inputs: spec.inputs, fix: spec.fix });
+        hashes[spec.id] = hash;
+        const saved = await this.store.readStep(spec.id);
+        if (saved && saved.status === 'done' && saved.step_hash === hash && saved.outputs && this.run.steps[spec.id]?.status === 'done') {
+            const files = fileRefsIn(saved.outputs);
+            if ((await Promise.all(files.map(files_1.intact))).every(Boolean)) {
+                this.book.finish(spec.id);
+                return saved.outputs;
+            }
+        }
+        const dir = this.store.stepDir(spec.id);
+        const workDir = path.join(dir, 'out');
+        // Scratch space sits inside the step's own folder, so a part can register a scratch file too.
+        const tmpDir = path.join(workDir, '.tmp');
+        for (const attempt of [1, 2]) {
+            if (this.stop.signal.aborted)
+                throw this.fatal ?? new errors_1.KitStop('This video was stopped.', 'stop');
+            await (0, promises_1.rm)(workDir, { recursive: true, force: true });
+            await (0, promises_1.rm)(tmpDir, { recursive: true, force: true });
+            await (0, promises_1.mkdir)(workDir, { recursive: true, mode: 0o700 });
+            await (0, promises_1.mkdir)(tmpDir, { recursive: true, mode: 0o700 });
+            const record = {
+                record: 1,
+                step: spec.id,
+                part: spec.ref,
+                step_hash: hash,
+                status: 'running',
+                inputs: (0, secrets_1.withoutSignedLinks)(spec.inputs),
+                pieces: [],
+                started_at: this.now().toISOString(),
+            };
+            await this.store.writeStep(record);
+            this.run.steps[spec.id] = { status: 'running', step_hash: hash };
+            await this.saveRun();
+            this.book.start(spec.id);
+            this.deps.log.write('info', 'step started', { step: spec.id, part: `${spec.ref.id}@${spec.ref.version}`, attempt });
+            void this.reporter.send();
+            const timeoutMs = manifest.timing.timeout_s * 1000;
+            const link = (0, client_1.linkedSignal)([this.stop.signal], timeoutMs);
+            try {
+                const ctx = this.context(spec, attempt, workDir, tmpDir, link.signal, record);
+                const outputs = await new Promise((resolve, reject) => {
+                    const ended = () => reject(this.stop.signal.aborted ? new errors_1.PartError('stopped') : new errors_1.PartError('timeout', `${spec.id} ran past ${manifest.timing.timeout_s} s`));
+                    // Stopped while the step was being saved: the part never starts.
+                    if (link.signal.aborted)
+                        return ended();
+                    link.signal.addEventListener('abort', ended, { once: true });
+                    spec.loaded.run(spec.inputs, ctx).then((o) => resolve(o), reject);
+                });
+                if (this.fatal)
+                    throw this.fatal;
+                const outputErrors = outputs && typeof outputs === 'object' ? (0, schema_1.schemaErrors)(manifest.outputs, outputs, `${spec.id} outputs`) : ['outputs are not an object'];
+                if (outputErrors.length) {
+                    this.deps.log.write('error', 'step outputs refused', { step: spec.id, errors: outputErrors });
+                    throw new errors_1.PartError('output_invalid', outputErrors.join('; '));
+                }
+                await this.checkOutputFiles(outputs, spec.loaded.dir, tmpDir);
+                record.status = 'done';
+                record.outputs = outputs;
+                record.finished_at = this.now().toISOString();
+                await this.store.writeStep({ ...record, outputs: outputs });
+                this.run.steps[spec.id] = { status: 'done', step_hash: hash, finished_at: record.finished_at };
+                await this.saveRun();
+                await (0, promises_1.rm)(tmpDir, { recursive: true, force: true });
+                this.book.finish(spec.id);
+                this.deps.log.write('info', 'step done', { step: spec.id, pieces: record.pieces.length });
+                void this.reporter.send(true);
+                return outputs;
+            }
+            catch (error) {
+                const stopped = this.fatal ?? (error instanceof errors_1.KitStop ? error : null);
+                const failure = stopped ? null : (0, errors_1.asPartError)(error);
+                record.status = stopped ? 'stopped' : 'failed';
+                if (failure)
+                    record.error = { code: failure.code, ...(failure.detail ? { detail: this.deps.log.clean(failure.detail).slice(0, 2000) } : {}) };
+                record.finished_at = this.now().toISOString();
+                await this.store.writeStep(record);
+                this.run.steps[spec.id] = { status: record.status, step_hash: hash };
+                await this.saveRun();
+                if (stopped)
+                    throw stopped;
+                this.deps.log.write('warn', 'step failed', { step: spec.id, attempt, code: failure.code });
+                if (failure.retryable && attempt === 1 && manifest.retry?.transient !== 0)
+                    continue;
+                this.book.finish(spec.id, 'failed');
+                void this.reporter.send(true);
+                throw new errors_1.KitStop(failureWords(failure), failure.code === 'over_quote' ? 'stop' : 'failed', failure.code);
+            }
+            finally {
+                link.done();
+            }
+        }
+        throw new errors_1.KitStop(failureWords(new errors_1.PartError('tool_failed')), 'failed');
+    }
+    /** A part's output files must be in this video's folder (or the part's own) and unchanged. */
+    async checkOutputFiles(outputs, partDir, tmpDir) {
+        for (const ref of fileRefsIn(outputs)) {
+            if (!(0, paths_1.isInside)(this.layout.root, ref.path) && !(0, paths_1.isInside)(partDir, ref.path))
+                throw new errors_1.PartError('output_invalid', 'an output file is outside this video’s folder');
+            if ((0, paths_1.isInside)(tmpDir, ref.path))
+                throw new errors_1.PartError('output_invalid', 'an output file is in the step’s scratch folder, which is cleared after the step');
+            // Every output is hashed again once the part returns, even one it registered.
+            const actual = await (0, files_1.hashFile)(ref.path).catch(() => null);
+            if (!actual || actual.sha256 !== ref.sha256 || actual.bytes !== ref.bytes)
+                throw new errors_1.PartError('output_invalid', 'an output file does not match its hash');
+        }
+    }
+    context(spec, attempt, workDir, tmpDir, signal, record) {
+        const { manifest } = spec.loaded;
+        const tools = (0, toolchain_1.kitTools)({ ffmpeg: this.tools.ffmpeg.path ?? '', ffprobe: this.tools.ffprobe.path ?? '', toolchain: this.toolchain }, signal);
+        const seedInput = spec.inputs.seed ?? null;
+        const order = manifest.needs.network
+            ? (0, pieces_1.pieceOrderer)({
+                line: this.deps.line,
+                videoId: this.videoId,
+                stepId: spec.id,
+                part: spec.ref,
+                models: spec.models,
+                workDir,
+                runRoot: this.layout.root,
+                cache: this.cache,
+                signal,
+                sleep: this.sleep,
+                probe: tools.probe,
+                hosted: this.hosted,
+                locks: this.pieceLocks,
+                onWait: () => void this.reporter.send(),
+                onPiece: async (piece) => {
+                    record.pieces.push(piece);
+                    await this.store.writeStep(record);
+                    this.book.count(spec.id, { done: record.pieces.length });
+                    void this.reporter.send(true);
+                },
+            })
+            : null;
+        const style = { id: this.style.style.id, version: this.style.style.version };
+        const ctx = {
+            interface: 1,
+            video: { id: this.videoId, style, env: this.deps.environment },
+            step: { id: spec.id, attempt },
+            part: { id: spec.ref.id, version: spec.ref.version, dir: spec.loaded.dir },
+            workDir,
+            tmpDir,
+            seed: (piece) => (0, canonical_1.pieceSeed)({ step: spec.id, part: spec.ref.id, piece, seed: seedInput }),
+            ...(order
+                ? {
+                    line: {
+                        order: async (request) => {
+                            try {
+                                return await order(request);
+                            }
+                            catch (error) {
+                                if (error instanceof errors_1.KitStop)
+                                    this.halt(error);
+                                throw error;
+                            }
+                        },
+                    },
+                }
+                : {}),
+            tools,
+            ...(manifest.needs.browser ? { browser: this.deps.host.browser.provider({ allowDirs: [spec.loaded.dir, this.layout.root], signal }) } : {}),
+            log: this.deps.log.forStep(spec.id),
+            progress: (update) => {
+                this.book.count(spec.id, update ?? {});
+                void this.reporter.send();
+            },
+            file: async (relativePath, media) => {
+                const target = path.resolve(workDir, relativePath);
+                if (!(0, paths_1.isInside)(workDir, target))
+                    throw new errors_1.PartError('bad_input', 'a part may register only files in its own folder');
+                return (0, files_1.fileRef)(target, media, tools.probe);
+            },
+            error: (code, detail) => new errors_1.PartError(code, detail),
+            signal,
+        };
+        return ctx;
+    }
+    /** The one fix: the check's own hint, or the server's check mapped to the layer that can redo it. */
+    fixFrom(verdict, serverChecks, from) {
+        const round = (this.run.fixes?.length ?? 0) + 1;
+        const failed = verdict.checks.filter((c) => c.status === 'fail' && (serverChecks.length === 0 || serverChecks.includes(c.code)));
+        const hinted = failed.find((c) => c.fix)?.fix;
+        if (hinted?.slot && this.parts.has(`layer-${hinted.slot}`))
+            return { target: `layer-${hinted.slot}`, inputs: hinted.inputs ?? {}, round, from };
+        if (hinted?.step && this.parts.has(hinted.step))
+            return { target: hinted.step, inputs: hinted.inputs ?? {}, round, from };
+        for (const check of serverChecks) {
+            const slot = SERVER_CHECK_SLOT[check];
+            if (slot && this.parts.has(`layer-${slot}`))
+                return { target: `layer-${slot}`, inputs: {}, round, from };
+        }
+        return null;
+    }
+    async checkFailed(verdict) {
+        await this.writeFinal(null, verdict);
+        this.book.finish('layer-check', 'failed');
+        this.book.note = 'The final check found a problem';
+        await this.reporter.send(true);
+        this.run.status = 'failed';
+        await this.saveRun();
+        return { status: 'failed', message: 'The video didn’t pass the final check, so it wasn’t sent. Nothing more will be charged for it.' };
+    }
+    async writeFinal(result, verdict) {
+        await (0, promises_1.mkdir)(this.layout.final, { recursive: true, mode: 0o700 });
+        await (0, save_1.writeJson)(path.join(this.layout.final, 'check.json'), verdict);
+        if (!result)
+            return null;
+        const final = path.join(this.layout.final, 'final.mp4');
+        await (0, promises_1.copyFile)(result.cut.path, final);
+        if (result.captions)
+            await (0, promises_1.copyFile)(result.captions.path, path.join(this.layout.final, 'captions.vtt'));
+        return final;
+    }
+    manifestFor(steps) {
+        const parts = {};
+        for (const loaded of this.parts.values())
+            parts[loaded.manifest.id] = loaded.manifest.version;
+        return {
+            style: { id: this.style.style.id, version: this.style.style.version },
+            lock_sha256: this.run.lock_sha256 || null,
+            parts,
+            steps,
+            kit: { version: version_1.KIT_VERSION, toolchain: this.toolchain },
+            parts_source: this.run.kit.parts_source,
+        };
+    }
+    /** Upload, our server's check, and one fix after a first failed check. */
+    async upload(result) {
+        let current = result;
+        for (;;) {
+            const final = (await this.writeFinal(current, current.verdict));
+            const data = await (0, promises_1.readFile)(final);
+            if (data.length > types_1.MAX_UPLOAD_BYTES)
+                throw new errors_1.KitStop('The finished video is larger than the line takes.', 'failed');
+            const sha256 = (0, canonical_1.sha256Hex)(data);
+            // Only the exact bytes the final check passed are sent.
+            if (sha256 !== current.cut.sha256 || data.length !== current.cut.bytes) {
+                throw new errors_1.KitStop('The finished video changed after its final check, so it wasn’t sent. Run the same command again to make it again.', 'failed');
+            }
+            let captions_vtt;
+            if (current.captions) {
+                const captions = await (0, promises_1.readFile)(current.captions.path);
+                if ((0, canonical_1.sha256Hex)(captions) !== current.captions.sha256 || captions.length !== current.captions.bytes) {
+                    throw new errors_1.KitStop('The captions changed after the final check, so the video wasn’t sent. Run the same command again to make it again.', 'failed');
+                }
+                if (captions.length > types_1.MAX_CAPTIONS_BYTES)
+                    throw new errors_1.KitStop('The captions file is larger than the line takes.', 'failed');
+                captions_vtt = captions.toString('utf8');
+            }
+            this.book.note = 'Sending your video for its final check';
+            this.run.status = 'uploading';
+            await this.saveRun();
+            void this.reporter.send(true);
+            let check;
+            try {
+                check = await this.sendUpload(sha256, data, captions_vtt, this.manifestFor(current.steps));
+            }
+            catch (error) {
+                if (error instanceof client_1.LineError)
+                    throw new errors_1.KitStop(lineWords(error), error.next === 'update_kit' ? 'update_kit' : error.next === 'change_request' ? 'change_request' : 'stop', error.code);
+                throw error;
+            }
+            this.run.upload_attempt = check.attempt;
+            if (check.result === 'pass') {
+                this.run.status = 'done';
+                await this.saveRun();
+                await this.cleanTmp();
+                return { status: 'done', message: `Your video is ready. It passed the final check. Saved here: ${final}` };
+            }
+            const reasons = check.reasons.map((r) => r.message).filter(Boolean).join(' ');
+            const serverFixUsed = (this.run.fixes ?? []).some((f) => f.from === 'server');
+            const fix = check.fixes_left > 0 && !serverFixUsed ? this.fixFrom(current.verdict, check.reasons.map((r) => r.check), 'server') : null;
+            if (!fix) {
+                this.run.status = 'failed';
+                await this.saveRun();
+                return { status: 'failed', message: `The video didn’t pass our check. ${reasons}`.trim() };
+            }
+            this.run.fixes = [...(this.run.fixes ?? []), fix];
+            this.run.status = 'running';
+            await this.saveRun();
+            this.reporter.resume();
+            this.say('Our check found something to fix. Fixing it once…');
+            current = await this.pipeline();
+            if (!current.verdict.pass)
+                return this.checkFailed(current.verdict);
+            // A fix that changed nothing is not sent again: the same bytes get the same answer.
+        }
+    }
+    /**
+     * The slot, the PUT and done, saved stage by stage. These same bytes already
+     * put (or already checked) are never sent again: done is asked again for
+     * that upload, which gives the same answer.
+     */
+    async sendUpload(sha256, data, captions_vtt, manifest) {
+        const { line } = this.deps;
+        const saved = (await this.store.readUpload()) ?? { uploads: [] };
+        const finish = async (stage) => {
+            this.book.note = 'Checking your video';
+            this.run.status = 'checking';
+            await this.saveRun();
+            await this.reporter.flush();
+            this.reporter.pause();
+            const check = await line.finishUpload(this.videoId, stage.upload_id, this.stop.signal);
+            stage.stage = 'done';
+            stage.result = check.result;
+            await this.store.writeUpload(saved);
+            return check;
+        };
+        // Bytes sent before (or maybe sent: a crash can land between the PUT and
+        // the journal) are asked about first; they are sent again only when the
+        // line says the slot holds no such file.
+        const sent = [...saved.uploads].reverse().find((u) => u.sha256 === sha256 && u.quote_id === this.handed.quote_id);
+        if (sent) {
+            try {
+                return await finish(sent);
+            }
+            catch (error) {
+                if (!(sent.stage === 'requested' && error instanceof client_1.LineError && error.code === 'file_mismatch'))
+                    throw error;
+                this.reporter.resume();
+            }
+        }
+        const slot = await line.openUpload(this.videoId, { sha256, bytes: data.length, content_type: 'video/mp4', ...(captions_vtt ? { captions_vtt } : {}), manifest }, this.stop.signal);
+        const stage = { upload_id: slot.upload_id, attempt: slot.attempt, sha256, quote_id: this.handed.quote_id, stage: 'requested' };
+        saved.uploads.push(stage);
+        await this.store.writeUpload(saved);
+        await line.put(slot.put, data, this.stop.signal);
+        stage.stage = 'put';
+        await this.store.writeUpload(saved);
+        return finish(stage);
+    }
+    async cleanTmp() {
+        for (const key of this.parts.keys())
+            await (0, promises_1.rm)(path.join(this.store.stepDir(key), 'out', '.tmp'), { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+async function makeVideo(videoId, deps) {
+    return new Maker(videoId, deps).make();
+}
+//# sourceMappingURL=run.js.map