gooseworks 0.5.2 → 0.5.3

package/dist/kit/core/run.js

@@ -60,6 +60,7 @@ const errors_1 = require("./errors");
 const files_1 = require("./files");
 const paths_1 = require("./paths");
 const pieces_1 = require("./pieces");
+const plain_words_1 = require("./plain-words");
 const progress_1 = require("./progress");
 const progress_reporter_1 = require("./progress-reporter");
 const save_1 = require("./save");
@@ -81,11 +82,46 @@ const ASPECT_SIZE = {
     '4:5': { width: 1080, height: 1350 },
     '16:9': { width: 1920, height: 1080 },
 };
+const CHECK_FAILED = 'The video didn’t pass the final check.';
+/** For a failure that repeats on every run of the same plan. */
+const PLAN_CHANGE = 'This video can’t be made from this plan. Change the plan, then make it again.';
+/** The server's `failure.code` shape. */
+const FAILURE_CODE = /^[a-z][a-z0-9_]{0,39}$/;
+/** Codes the server keeps the video in Making for (gooseworks-app video-line/run-failure.ts RESUMABLE_CODES). */
+const RESUMABLE_CODES = new Set(['timeout', 'tool_failed', 'needs_missing']);
+/** A part that would not load, in plain words: which part and why go to the log. */
+function loadStop(error) {
+    const code = error instanceof loader_1.PartLoadError ? error.code : undefined;
+    switch (code) {
+        case 'kit_range':
+            return new errors_1.KitStop('This video needs a newer video kit. Nothing was spent.', 'update_kit', code);
+        case 'unreachable':
+            return new errors_1.KitStop('This video’s parts could not be downloaded right now. Run the same command again in a minute. Nothing was spent.', 'stop', code);
+        case 'bad_cache':
+            return new errors_1.KitStop('The video kit’s folder on this computer is busy or can’t be used. Run the same command again in a minute. Nothing was spent.', 'stop', code);
+        case 'withdrawn':
+            return new errors_1.KitStop(`A part this video uses was withdrawn. ${PLAN_CHANGE} Nothing was spent.`, 'change_request', code);
+        default:
+            return new errors_1.KitStop(`A part this video uses can’t run. ${PLAN_CHANGE} Nothing was spent.`, 'change_request', code);
+    }
+}
 function lineWords(error) {
     return [error.message, error.fix].filter(Boolean).join(' ');
 }
+/**
+ * The code the line hears for a step's last failure. A provider failure a later run can get past
+ * (its piece has an attempt left, or no piece is named) is reported as `tool_failed`, which keeps
+ * the video in Making; the line ends the video on `provider_failed`.
+ */
+function reportedCode(error) {
+    if (error.code !== 'provider_failed')
+        return error.code;
+    return error instanceof pieces_1.PieceFailure && error.spent ? 'provider_failed' : 'tool_failed';
+}
 /** 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 && error.spent)
+        return pieces_1.FAILED_TWICE;
     if (error instanceof pieces_1.PieceFailure)
         return [error.line.error, error.line.fix].filter(Boolean).join(' ');
     switch (error.code) {
@@ -97,6 +133,9 @@ function failureWords(error) {
             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.';
+        case 'bad_input':
+        case 'output_invalid':
+            return PLAN_CHANGE;
         default:
             return 'Part of this video could not be made. Run the same command again; what was made so far is kept.';
     }
@@ -169,6 +208,9 @@ class Maker {
     parts = new Map();
     hosted = new Map();
     pieceLocks = new Map();
+    /** Where the run is, for the failure report: a step id or a stage before or after the steps. */
+    at = 'hand-over';
+    failureSent = false;
     constructor(videoId, deps) {
         this.videoId = videoId;
         this.deps = deps;
@@ -224,6 +266,11 @@ class Maker {
             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);
+            const replayed = await this.replayPending();
+            if (replayed)
+                return replayed;
+            if (this.fatal)
+                throw this.fatal;
             // Reports start now, so checking the style and parts never looks quiet.
             this.reporter.start();
             void this.reporter.send(true);
@@ -235,9 +282,71 @@ class Maker {
         finally {
             this.reporter?.stopTimer();
             await this.reporter?.flush().catch(() => undefined);
+            await this.keepPendingReport().catch((error) => deps.log.write('warn', 'the failure report could not be saved', { error: error instanceof Error ? error.message : String(error) }));
             await release();
         }
     }
+    reportKey() {
+        try {
+            return {
+                quote_id: this.handed.quote_id,
+                plan_sha256: (0, canonical_1.canonicalHash)((0, secrets_1.withoutSignedLinks)(this.handed.plan)),
+                lock_sha256: this.handed.parts_lock ? (0, canonical_1.canonicalHash)(this.handed.parts_lock) : '',
+                kit: version_1.KIT_VERSION,
+                toolchain: this.toolchain,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * An earlier run's failure report the line never took goes before anything else, when it still
+     * stands: the same plan, parts, kit and tools, and a code no new run gets past. Otherwise this
+     * run reports for itself.
+     */
+    async replayPending() {
+        const saved = await (0, save_1.readJson)(this.layout.pendingReport);
+        if (!saved)
+            return null;
+        const key = this.reportKey();
+        const stands = saved.report === 1 &&
+            !!saved.failure &&
+            typeof saved.failure.code === 'string' &&
+            typeof saved.failure.detail === 'string' &&
+            !RESUMABLE_CODES.has(saved.failure.code) &&
+            !!key &&
+            Object.keys(key).every((field) => saved[field] === key[field]);
+        if (!stands) {
+            this.deps.log.write('info', 'an earlier run’s failure report no longer stands', { code: saved.failure?.code ?? null });
+            await (0, promises_1.rm)(this.layout.pendingReport, { force: true });
+            return null;
+        }
+        const sent = await this.reporter.replay(saved.failure);
+        this.deps.log.write(sent === 'taken' ? 'info' : 'warn', 'an earlier run’s failure report', { sent, step: saved.failure.step, code: saved.failure.code });
+        if (sent === 'unsent')
+            return null;
+        await (0, promises_1.rm)(this.layout.pendingReport, { force: true });
+        if (sent === 'refused')
+            return null;
+        this.failureSent = true;
+        return { status: 'failed', message: saved.failure.detail };
+    }
+    /** Keeps a failure report the line never took for the next run; one taken, or a finished video, clears it. */
+    async keepPendingReport() {
+        if (!this.reporter || !this.layout)
+            return;
+        const unsent = this.reporter.undelivered;
+        const key = unsent ? this.reportKey() : null;
+        if (unsent && key) {
+            const pending = { report: 1, ...key, failure: unsent, saved_at: this.now().toISOString() };
+            await (0, save_1.writeJson)(this.layout.pendingReport, pending);
+            this.deps.log.write('warn', 'the failure report was not taken; the next run sends it', { step: unsent.step, code: unsent.code });
+        }
+        else if (this.failureSent || this.run?.status === 'done') {
+            await (0, promises_1.rm)(this.layout.pendingReport, { force: true });
+        }
+    }
     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;
@@ -254,13 +363,28 @@ class Maker {
             this.run.status = stop && stop.reason === 'stop' ? 'stopped' : 'failed';
             await this.saveRun().catch(() => undefined);
         }
+        if (stop && (stop.reason === 'failed' || stop.reason === 'change_request' || stop.reason === 'refused')) {
+            this.reportFailure(this.at, stop.code ?? 'change_request', stop.message);
+            await this.reporter?.flush().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.' };
+        this.deps.log.write('error', 'the run ended on an error', { step: this.at, error: error instanceof Error ? error.message : String(error) });
+        const message = 'This video could not be made right now. Run the same command again; what was made so far is kept.';
+        // Not a step's failure (a download or a disk write, say): a new run may get past it.
+        this.reportFailure(this.at, 'tool_failed', message);
+        await this.reporter?.flush().catch(() => undefined);
+        return { status: 'failed', message };
+    }
+    /** Tells the line once why the run gave up; the line's own refusals already ended it on its words. */
+    reportFailure(step, code, detail) {
+        if (!this.reporter || this.failureSent || this.reporter.refused)
+            return;
+        this.failureSent = true;
+        void this.reporter.fail({ step: step.slice(0, 60), code: FAILURE_CODE.test(code) ? code : 'change_request', detail: detail.trim().slice(0, 2000) });
     }
     async saveRun() {
         this.run.updated_at = this.now().toISOString();
@@ -269,6 +393,7 @@ class Maker {
     async makeHandedOver(dev) {
         const { deps, handed } = this;
         const plan = handed.plan;
+        this.at = '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');
         }
@@ -308,11 +433,14 @@ class Maker {
             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.at = 'style';
+        const note = (why, fields) => deps.log.write('error', why, fields);
         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 (0, style_1.readLocalStyle)(dev.styles, pin, note)
+            : 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), note });
         await this.loadParts(!!dev.parts);
         // The plan's files, checked against the hashes frozen at the yes.
+        this.at = 'plan-files';
         const planFiles = {
             dir: this.layout.inputs,
             download: (u, m) => deps.line.download(u, m, this.stop.signal),
@@ -361,51 +489,70 @@ class Maker {
             ...this.layersOn().map((slot) => ({ key: `layer-${slot}`, ref: layerRefs?.[slot], slot })),
         ];
         for (const { key, ref, slot } of wanted) {
+            this.at = key;
             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');
+                if (!entry || entry.version !== ref.version) {
+                    this.deps.log.write('error', 'part not in the parts list', { step: key, part: `${ref.id}@${ref.version}`, locked: entry?.version ?? null });
+                    throw new errors_1.KitStop(`A part this video uses is not in this video’s parts list, so it can’t run. ${PLAN_CHANGE} Nothing was spent.`, 'change_request', 'not_locked');
+                }
                 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');
+                if (tooOld) {
+                    this.deps.log.write('error', 'part needs another kit', { step: key, refusal: tooOld });
+                    throw new errors_1.KitStop('This video needs a newer video kit. Nothing was spent.', 'update_kit', 'kit_range');
+                }
             }
         }
         for (const { key, ref, slot } of wanted) {
+            this.at = key;
             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');
+                this.deps.log.write('error', 'part could not be loaded', {
+                    step: key,
+                    part: `${ref.id}@${ref.version}`,
+                    code: error instanceof loader_1.PartLoadError ? error.code : null,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw loadStop(error);
             }
             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 refused = (why, fields = {}) => this.deps.log.write('error', why, { step: key, part: `${ref.id}@${ref.version}`, ...fields });
+            if (m.id !== ref.id || m.version !== ref.version) {
+                refused('part loaded as another version', { loaded: `${m.id}@${m.version}` });
+                throw new errors_1.KitStop(`A part this video uses loaded as another version, so it can’t run. ${PLAN_CHANGE} Nothing was spent.`, 'change_request', 'manifest_mismatch');
+            }
             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');
+            if (refusal) {
+                refused('part needs another interface', { refusal });
+                throw new errors_1.KitStop('This video needs a newer video kit. Nothing was spent.', 'update_kit', 'interface');
+            }
+            if (slot && (m.layer !== slot || m.kind !== SLOT_KIND[slot])) {
+                refused('part can’t fill its layer', { slot, layer: m.layer ?? null, kind: m.kind });
+                throw new errors_1.KitStop(`A part this video uses can’t do the job its plan gives it. ${PLAN_CHANGE} Nothing was spent.`, 'change_request', 'wrong_layer');
+            }
             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');
+            if (paid && (!Array.isArray(lockModels) || lockModels.length === 0)) {
+                refused('paid part has no models in the parts list');
+                throw new errors_1.KitStop(`A part this video uses would order paid pieces its approved price doesn’t allow. ${PLAN_CHANGE} Nothing was spent.`, 'change_request', 'no_models');
+            }
             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');
+            if (missing) {
+                refused('part needs what this computer lacks', { missing });
+                throw new errors_1.KitStop(`This computer can’t make this video: ${missing}. Run the computer check, then make the video again. Nothing was spent.`, 'refused', 'needs_missing');
+            }
             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');
+                refused('part schema can’t be checked', { error: error.message });
+                throw new errors_1.KitStop('This video needs a newer video kit. Nothing was spent.', 'update_kit', 'schema');
             }
             this.parts.set(key, loaded);
         }
@@ -443,7 +590,7 @@ class Maker {
         };
         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 { inputs, round } = fixed(step.id, this.bind(step.id, step.inputs, scope));
             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')
@@ -469,8 +616,10 @@ class Maker {
                 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');
+            if (!(0, canonical_1.isFileRef)(video) || video.media !== 'video') {
+                this.deps.log.write('error', 'layer made no video', { step: id });
+                throw new errors_1.KitStop(`Finishing this video gave back no video. ${PLAN_CHANGE}`, 'change_request', 'output_invalid');
+            }
             cut = video;
             if (out.timeline && typeof out.timeline === 'object')
                 timeline = out.timeline;
@@ -485,6 +634,19 @@ class Maker {
             throw new errors_1.KitStop('The final check gave no verdict.', 'change_request');
         return { cut, captions, verdict, steps: hashes };
     }
+    /** A style step's inputs: a reference the kit can't resolve goes to the log, plain words to the person. */
+    bind(stepId, inputs, scope) {
+        this.at = stepId;
+        try {
+            return (0, bind_1.bindInputs)(inputs, scope, stepId);
+        }
+        catch (error) {
+            if (!(error instanceof errors_1.KitStop))
+                throw error;
+            this.deps.log.write('error', 'step inputs could not be bound', { step: stepId, error: error.message });
+            throw new errors_1.KitStop(`One step of this video can’t get what it needs, so the video stopped there. ${PLAN_CHANGE}`, 'change_request', 'bad_input');
+        }
+    }
     modelsOf(ref, loaded) {
         return this.lock ? (this.lock.parts[ref.id]?.models ?? []) : loaded.manifest.needs.models;
     }
@@ -502,10 +664,11 @@ class Maker {
     /** 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;
+        this.at = spec.id;
         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');
+            throw new errors_1.KitStop(`One step of this video was given something it can’t take, so the video stopped there. ${PLAN_CHANGE}`, 'change_request', 'bad_input');
         }
         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;
@@ -588,18 +751,20 @@ class Maker {
                 await this.saveRun();
                 if (stopped)
                     throw stopped;
-                this.deps.log.write('warn', 'step failed', { step: spec.id, attempt, code: failure.code });
+                this.deps.log.write('warn', 'step failed', { step: spec.id, attempt, code: failure.code, detail: record.error?.detail ?? null });
                 if (failure.retryable && attempt === 1 && manifest.retry?.transient !== 0)
                     continue;
+                const words = failureWords(failure);
+                const code = reportedCode(failure);
                 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);
+                this.reportFailure(spec.id, code, words);
+                throw new errors_1.KitStop(words, failure.code === 'over_quote' ? 'stop' : 'failed', code);
             }
             finally {
                 link.done();
             }
         }
-        throw new errors_1.KitStop(failureWords(new errors_1.PartError('tool_failed')), 'failed');
+        throw new errors_1.KitStop(failureWords(new errors_1.PartError('tool_failed')), 'failed', 'tool_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) {
@@ -705,11 +870,27 @@ class Maker {
         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);
+        // Check parts give each failed check words in `message`, beside the interface's fields; only plain ones reach the card.
+        const said = verdict.checks.find((c) => c.status === 'fail');
+        const message = typeof said?.message === 'string' ? said.message : '';
+        const detail = (0, plain_words_1.plainWords)(message, CHECK_FAILED, this.idNames());
+        this.deps.log.write('warn', 'the final check failed', { check: typeof said?.code === 'string' ? said.code : null, message, detail });
+        this.reportFailure('layer-check', 'check_failed', detail);
+        await this.reporter.flush();
         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.' };
     }
+    /** Part, step and layer ids, which the person never sees. */
+    idNames() {
+        const names = new Set();
+        for (const [key, loaded] of this.parts) {
+            names.add(key);
+            names.add(loaded.manifest.id);
+            names.add(`${loaded.manifest.id}@${loaded.manifest.version}`);
+        }
+        return [...names];
+    }
     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);
@@ -737,6 +918,7 @@ class Maker {
     /** Upload, our server's check, and one fix after a first failed check. */
     async upload(result) {
         let current = result;
+        this.at = 'upload';
         for (;;) {
             const final = (await this.writeFinal(current, current.verdict));
             const data = await (0, promises_1.readFile)(final);
@@ -745,13 +927,13 @@ class Maker {
             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');
+                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', 'tool_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');
+                    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', 'tool_failed');
                 }
                 if (captions.length > types_1.MAX_CAPTIONS_BYTES)
                     throw new errors_1.KitStop('The captions file is larger than the line takes.', 'failed');