@earendil-works/chord 1.5.0 → 1.5.1

package/dist/jobs/records.js

@@ -0,0 +1,871 @@
+// A job's records on its object (§15, slice 6a §1.2, slice 6b §4): its runs by id and by key, the active count, the
+// run state documents, `running` and the runs waiting for a live attempt, across the object's attempts. Records and
+// state documents change only in transactions on the object's line (staged changes adopted in the commit step); a
+// persisted job's also in its object's store, in the same commits, loaded once per object, and written back stopped by
+// the close writer when a clean stop cuts its runs off. Across a reload (slice 7b §8) the records take the new
+// declaration's definition and every run keeps its version: an older one is mapped forwards through `accepts`, one
+// without an adapter (or newer, or of a job the code no longer declares) is blocked `version` until a reload brings
+// matching code.
+import { withoutAbortSignal } from "../context/index.js";
+import { ChordError } from "../data/index.js";
+import { check, validatorFor } from "../data/internal.js";
+import { Persistence } from "../documents/internal.js";
+import { uuidv7 } from "../host/internal.js";
+import { carrierOf } from "../telemetry.js";
+import { PersistedRuns } from "./persisted.js";
+import { JobRun } from "./run.js";
+import { RunStates } from "./run-states.js";
+import { Running } from "./running.js";
+import { outcomeOf, storedRun } from "./stored.js";
+const RESTART = { kind: "failed", error: { kind: "aborted", reason: "restart" } };
+const RELOAD = { kind: "failed", error: { kind: "aborted", reason: "reload" } };
+const ABORTED = { kind: "failed", error: { kind: "aborted", reason: "abort" } };
+/** A persisted run cut off this many times in a row ends `restart_limit` (D6, Durable's limit). */
+const RESTART_LIMIT = 5;
+/**
+ * The records of one job name on one object. The live attempt's `Job` invokes and finishes its runs; between live
+ * attempts, committed runs not yet invoked and runs whose outcome is recorded wait for the next one.
+ */
+export class JobRecords {
+    /** The latest declaration's definition: a reload's new attempt redefines it; each run keeps its own version. */
+    definition;
+    running;
+    #owner;
+    #states;
+    /** The store side of a persisted job's state documents; `undefined` in memory. */
+    #statePersistence;
+    /** The store side of a persisted job's runs; `undefined` in memory. */
+    #persisted;
+    #runs = new Map();
+    #keys = new Map();
+    /** Running and finishing runs: concurrency and keep-alive count them. */
+    #active = 0;
+    /** The live attempt's job; `undefined` between live attempts. */
+    #job;
+    /** Runs waiting for a live attempt: to be invoked (`invocation` pending) or finished (phase `finishing`). */
+    #waiting = new Set();
+    /** Runs a clean stop cut off whose record the close writer has not written `stopped` yet. */
+    #stopped = new Set();
+    /** Whether a persisted job's records were loaded (once per object). */
+    #loaded = false;
+    /** The object's end error, once it ended. */
+    #ended;
+    /** Whether the latest live attempt declares the job: its runs are blocked `version` while it does not. */
+    #declared = true;
+    constructor(definition, owner) {
+        this.definition = definition;
+        this.#owner = owner;
+        const { state, persist, name } = definition;
+        const store = persist === undefined ? undefined : owner.store;
+        const persistence = store === undefined ? undefined : new Persistence(store.store, store.owner, "chord.job-states", name);
+        this.#statePersistence = persistence;
+        this.#states = state === undefined ? undefined : this.#runStates(state);
+        this.#persisted =
+            store === undefined
+                ? undefined
+                : new PersistedRuns(new Persistence(store.store, store.owner, "chord.jobs", name), persistence);
+        this.running = new Running(owner.documents.batch, this.name);
+    }
+    /** The run state documents of `state`, reporting their changes to `running` and their held deadlines. */
+    #runStates(state) {
+        const owner = this.#owner;
+        const states = {
+            documents: owner.documents,
+            changed: (id, ops) => this.#stateChanged(id, ops),
+            held: (deadline) => owner.held(deadline),
+        };
+        return new RunStates(state, states, this.#statePersistence);
+    }
+    /**
+     * Refuses a declaration of this job that its records cannot take (slice 7b §8): the same version with another
+     * fingerprint (its args, result or state schema changed without a version bump), or a state document definition
+     * the run documents refuse (`SlotDefinition.check`). A reload's staging checks it too.
+     */
+    check(definition) {
+        const current = this.definition;
+        if (definition.version === current.version && definition.fingerprint !== current.fingerprint) {
+            throw new Error(`${this.name}: its schema changed without a version bump (version ${definition.version})`);
+        }
+        const { state } = definition;
+        const states = this.#states;
+        if (state !== undefined && states !== undefined && state !== states.definition.current) {
+            states.definition.check(state);
+        }
+    }
+    /**
+     * Takes a new attempt's declaration `definition` (another version after a reload, `ChordObject.checkJob` refused
+     * the same version with another fingerprint): new runs are of its version; the runs of others keep theirs, their
+     * `running` entries show their args mapped forwards (or blocked); their state documents keep their version until
+     * their run settles or moves to the new code.
+     */
+    redefine(definition) {
+        this.#declared = true;
+        if (definition === this.definition)
+            return;
+        this.definition = definition;
+        const { state } = definition;
+        if (state !== undefined) {
+            if (this.#states === undefined)
+                this.#states = this.#runStates(state);
+            else
+                this.#states.redefine(state);
+        }
+        if (this.#runs.size === 0)
+            return;
+        this.#owner.documents.batch.within(() => {
+            for (const run of this.#runs.values())
+                if (run.entry !== undefined)
+                    this.#replaceEntry(run);
+        }, this.#owner.context);
+    }
+    /**
+     * The latest live attempt does not declare the job (slice 7b §8): its runs not invoked and its finishing runs are
+     * blocked `version` (kept, not invoked) until a reload declares it again or they are aborted; a running
+     * invocation finishes and is blocked then.
+     */
+    undeclare() {
+        if (!this.#declared || this.#ended !== undefined)
+            return;
+        this.#declared = false;
+        this.#job = undefined;
+        const waiting = [...this.#waiting];
+        this.#waiting.clear();
+        for (const run of waiting)
+            void this.record(run, { kind: "block", run, reason: "version" });
+    }
+    /**
+     * A reload brought new code (its attempt is live): blocked runs are retried, once: a `finish_failed` one finishes
+     * again, a `version` one whose version the code now takes (its own, or an older one with an adapter) is invoked or
+     * finished; the others stay blocked. A persisted run blocked at its load has its state document read first.
+     */
+    async retryBlocked(context) {
+        if (!this.#declared || this.#ended !== undefined)
+            return;
+        const retried = [...this.#runs.values()].filter((run) => run.phase === "blocked" && (run.blocked === "finish_failed" || this.#takes(run)));
+        if (retried.length === 0)
+            return;
+        try {
+            for (const run of retried)
+                if (run.blockedPhase !== undefined)
+                    await this.#readBlockedState(run, context);
+        }
+        catch {
+            // Its state document cannot be read: it stays blocked (the next reload tries again).
+            return;
+        }
+        const { documents } = this.#owner;
+        try {
+            await documents.tx((tx) => {
+                for (const run of retried) {
+                    if (this.#runs.get(run.id) !== run || run.phase !== "blocked")
+                        continue;
+                    const phase = run.outcome !== undefined ? "finishing" : this.#persisted === undefined ? "running" : "pending";
+                    this.change(tx, { kind: "unblock", run, phase });
+                }
+            }, documents.own, this.#owner.context);
+        }
+        catch {
+            // The object ended.
+        }
+    }
+    /** Reads and decodes the state document of a persisted run blocked at its load, now that the code takes it. */
+    async #readBlockedState(run, context) {
+        const states = this.#states;
+        this.#persisted.forgetBlockedState(run.id);
+        if (states === undefined)
+            return;
+        const document = await states.persistence.read(run.id, context);
+        if (document === undefined)
+            return;
+        const { value, stored } = states.persistence.decode(document, states.definition.current, context);
+        states.create(run.id, value, stored);
+        if (run.outcome !== undefined)
+            run.outcome = { ...run.outcome, state: value };
+    }
+    /**
+     * Whether the current code takes `run`: of its version and fingerprint, or of an older version its `accepts` maps
+     * forwards; a newer one (a rollback) or an older one without an adapter is not (`blocked { version }`).
+     */
+    #takes(run) {
+        const { definition } = this;
+        if (run.version === definition.version)
+            return run.fingerprint === definition.fingerprint;
+        return run.version < definition.version && definition.accepts[run.version] !== undefined;
+    }
+    /**
+     * `run`'s args as the code of `definition` takes them (the current code's, or an invoking attempt's own): mapped
+     * forwards once per run and version when older.
+     */
+    argsOf(run, definition) {
+        if (run.version === definition.version)
+            return run.args;
+        const mapped = run.mapped;
+        if (mapped !== undefined && mapped.version === definition.version)
+            return mapped.args;
+        // `#takes` found the adapter; its result is the current args (the provider's mapping, not validated).
+        const args = definition.accepts[run.version].args(run.args);
+        run.mapped = { version: definition.version, args };
+        return args;
+    }
+    /**
+     * `run`'s outcome as the current code's `finish` gets it: an older run's args and result mapped forwards (once per
+     * run), its state document migrated to the current state definition.
+     */
+    outcomeOf(run, context) {
+        const outcome = run.outcome;
+        const { definition } = this;
+        if (run.version === definition.version)
+            return outcome;
+        const args = this.argsOf(run, definition);
+        const mapped = run.mapped;
+        if (mapped.outcome !== undefined)
+            return mapped.outcome;
+        const result = outcome.kind === "done"
+            ? { kind: "done", result: definition.accepts[run.version].result(outcome.result) }
+            : { kind: "failed", error: outcome.error };
+        const state = this.#states?.migrated(run.id, context) ?? outcome.state;
+        mapped.outcome = { id: outcome.id, args, state, ...result };
+        return mapped.outcome;
+    }
+    /** The job in errors: its object and its name. */
+    get name() {
+        return `${this.#owner.label} job ${this.definition.name}`;
+    }
+    /** Waits for the outcome of the unsettled run `id`; a settled or unknown id rejects `gone`. */
+    outcome(id, context) {
+        const run = this.#runs.get(id);
+        if (run === undefined) {
+            return Promise.reject(new ChordError({ code: "gone", message: `${this.name}: no unsettled run ${id}` }));
+        }
+        return run.handle.outcome(context);
+    }
+    /**
+     * Aborts run `id` (D7, Durable's `abortTask`): a blocked run is dropped; a finishing one is only marked; any other
+     * is marked (stored for a persisted job) in a transaction, its signal fired after the commit, outside the batch and
+     * the line, and the abort joins its invocation. `"marked"`, or `"terminal"` when no unsettled run has that id.
+     */
+    async abort(id, context) {
+        const run = this.#runs.get(id);
+        if (run === undefined || this.#ended !== undefined)
+            return "terminal";
+        if (run.phase === "blocked") {
+            await this.record(run, { kind: "drop", run });
+            return "marked";
+        }
+        if (!run.abortMarked)
+            await this.record(run, { kind: "update", run, fields: { abortMarked: true } });
+        // A finishing run's outcome stays: it is only marked.
+        if (run.phase === "finishing")
+            return "marked";
+        run.invocation?.abort.abort(new ChordError({ code: "aborted", message: `${this.name}: run ${id} aborted` }));
+        await run.over(context);
+        return "marked";
+    }
+    /** See `Job.stage`: the checks and the staged creation, against the object's runs. */
+    stage(tx, args, context, options) {
+        const definition = this.definition;
+        // Plugin code, not type-checked: the args are checked as a method's are (R7).
+        check(validatorFor(definition.args, context), args, "args", context);
+        const staged = tx.staged(this);
+        const { key } = options;
+        if (key !== undefined) {
+            const known = staged?.started.find((run) => run.key === key) ?? this.#keys.get(key);
+            if (known !== undefined && known !== staged?.finishing)
+                return known.handle;
+        }
+        const { concurrency } = definition;
+        const active = this.#active + (staged?.started.length ?? 0) - (staged?.finishing === undefined ? 0 : 1);
+        if (concurrency !== undefined && active >= concurrency) {
+            const message = `${this.name}: at its concurrency limit (${concurrency})`;
+            throw new ChordError({ code: "unavailable", reason: "busy", message });
+        }
+        const persisted = this.#persisted !== undefined;
+        // Its starter's carrier: its later phases are children of it (a persisted run stores it, for a later process).
+        const trace = carrierOf(context.telemetry);
+        // Checked above: the args are JSON (the definition refuses bytes).
+        const run = new JobRun(uuidv7(), definition.version, definition.fingerprint, key, args, persisted ? "pending" : "running", trace);
+        const staging = this.staging(tx);
+        staging.started.push(run);
+        this.change(tx, { kind: "create", run });
+        const state = definition.state?.initial(context);
+        if (state !== undefined)
+            staging.adopts.push(this.#states.stageCreate(run.id, state, () => this.#store(tx)));
+        return run.handle;
+    }
+    /**
+     * Stages `change` in `tx`: in the job's staging, adopted in the commit step, and for a persisted job the run's record
+     * written with it (rule 8: serialized now), and for a settled run its state document retired.
+     */
+    change(tx, change) {
+        const staging = this.staging(tx);
+        staging.changes.push(change);
+        const { run } = change;
+        const states = this.#states;
+        const retires = change.kind === "delete" || change.kind === "drop";
+        if (retires && states?.current(run.id) !== undefined)
+            tx.retireSlot(states, run.id);
+        const persisted = this.#persisted;
+        if (persisted === undefined)
+            return;
+        const writes = this.#store(tx);
+        if (retires) {
+            staging.adopts.push(persisted.stageRetire(run.id, writes));
+            return;
+        }
+        const fields = recordFields(change);
+        staging.adopts.push(persisted.stage(run.id, storedRun(run, fields), writes));
+    }
+    /** This job's changes in `tx`, made on the first. */
+    staging(tx) {
+        return tx.stage(this, () => {
+            const changes = [];
+            const adopts = [];
+            return {
+                started: [],
+                changes,
+                adopts,
+                finishing: undefined,
+                adopt: () => {
+                    // A step admitted before the object ended adopts after it: the records are not changed any more.
+                    if (this.#ended !== undefined)
+                        return;
+                    // What is stored first: a new run's state document exists when its `running` entry is made.
+                    runAll(adopts);
+                    for (const change of changes)
+                        this.#adopt(change);
+                },
+                committed: () => {
+                    const ended = this.#ended;
+                    if (ended === undefined) {
+                        for (const change of changes)
+                            this.#committed(change);
+                        return;
+                    }
+                    // Its runs end as the object's other runs did.
+                    for (const change of changes)
+                        if (change.kind === "create")
+                            change.run.reject(ended);
+                },
+                discarded: () => {
+                    for (const change of changes)
+                        if (change.kind === "create")
+                            change.run.reject(this.#discarded());
+                },
+            };
+        });
+    }
+    /**
+     * A persisted job's runs, loaded once per object at its first activation (slice 6b §4.2), again only after a load
+     * failed (design §9): each record read; a record of another version or fingerprint blocked (`version`) as stored,
+     * its state document left undecoded; the others' state documents read and decoded, a run cut off while `running`
+     * counted (`restarts + 1`; at the limit it ends `restart_limit`, reported `job_interrupted`), `stopped` and
+     * `pending` ones made `pending` again. The runs and their activation changes are adopted in one commit, all before
+     * anything runs; a failure leaves nothing loaded.
+     */
+    async load(context) {
+        const persisted = this.#persisted;
+        if (persisted === undefined || this.#loaded)
+            return;
+        const restored = [];
+        try {
+            for (const loaded of await persisted.load(context))
+                restored.push(await this.#restored(loaded, context));
+            if (restored.length > 0) {
+                const { documents } = this.#owner;
+                await documents.tx((tx) => this.#restoreAll(tx, restored), documents.own, context);
+            }
+        }
+        catch (error) {
+            persisted.drop();
+            for (const { run } of restored)
+                this.#states?.retire(run.id);
+            throw error;
+        }
+        this.#loaded = true;
+        for (const { run, change } of restored) {
+            if (change?.kind === "outcome" &&
+                change.outcome.kind === "failed" &&
+                change.outcome.error.kind === "restart_limit") {
+                this.report({ kind: "job_interrupted", id: run.id, restarts: change.outcome.error.restarts });
+            }
+        }
+        for (const { run } of restored)
+            this.#need(run);
+    }
+    /** Stages the loaded runs in `tx`: each restored, then the activation changes (adopted after every restore). */
+    #restoreAll(tx, restored) {
+        const staging = this.staging(tx);
+        for (const { run } of restored)
+            staging.changes.push({ kind: "restore", run });
+        for (const { change } of restored)
+            if (change !== undefined)
+                this.change(tx, change);
+    }
+    /** `job`, of the attempt that went live, invokes and finishes the runs from now on; the waiting ones first. */
+    attach(job) {
+        if (this.#ended !== undefined)
+            return;
+        this.#job = job;
+        const waiting = [...this.#waiting];
+        this.#waiting.clear();
+        for (const run of waiting)
+            this.#dispatch(run, job);
+    }
+    /**
+     * `job`'s attempt was sealed: its running invocations are cut off (`cut`), the runs it was finishing wait for the
+     * next live attempt.
+     */
+    detach(job, finishing) {
+        if (this.#job === job)
+            this.#job = undefined;
+        for (const run of finishing)
+            this.#need(run);
+    }
+    /**
+     * A run whose reservation its sealed attempt never committed waits for the next live attempt (dispatched now when one
+     * is attached already: the sealed attempt was detached at its seal).
+     */
+    requeue(run) {
+        this.#need(run);
+    }
+    /** Records `run` running before its `run` is invoked (a persisted run's reservation: a crash after it counts). */
+    reserve(tx, run) {
+        this.change(tx, { kind: "update", run, fields: { phase: "running" } });
+    }
+    /** A state change of a run with restarts counted resets them in its commit (progress, D6). */
+    progressed(tx, run) {
+        if (run.restarts !== 0)
+            this.change(tx, { kind: "update", run, fields: { restarts: 0 } });
+    }
+    /**
+     * A run's invocation settled: its outcome is recorded (phase `finishing`) in a transaction of the object behind the
+     * state changes admitted before, so `outcome.state` has them; then it is finished on the live attempt.
+     */
+    settled(run, ended) {
+        void this.#recordOutcome(run, ended);
+    }
+    /**
+     * A running run whose attempt was sealed: its signal fires with `error`, its invocation is fenced (later state
+     * changes refused, the open one discarded, its settling ignored). In memory it ends `failed { aborted }` with
+     * `reason` (`reload` for a native restart, slice 7b §8), finished on the next live attempt; persisted it is stopped (R3), written back by the close writer and
+     * resumed by the next live attempt as after a clean close.
+     */
+    cut(run, error, reason) {
+        // Only an invoked run is cut: its current invocation is the one the seal stops.
+        const invocation = run.invocation;
+        invocation.settle();
+        this.#owner.documents.fence(invocation.token);
+        invocation.abort.abort(error);
+        if (this.#persisted !== undefined) {
+            run.phase = "stopped";
+            // Resumed per the job's `resume` (an `abandon` job's run ends `failed { aborted, restart }`).
+            run.resuming = true;
+            this.#stopped.add(run);
+            if (this.#ended === undefined)
+                this.#need(run);
+            return;
+        }
+        if (this.#ended === undefined)
+            void this.#recordOutcome(run, reason === "reload" ? RELOAD : RESTART);
+    }
+    /**
+     * Records `change` (a run's finish failure, its block, its drop) in a transaction of the object, if `run` is still
+     * one of its runs there. The object's end ends it.
+     */
+    async record(run, change) {
+        const { documents, context } = this.#owner;
+        try {
+            await documents.tx((tx) => {
+                if (this.#runs.get(run.id) === run)
+                    this.change(tx, change);
+            }, documents.own, context);
+        }
+        catch {
+            // The object ended: its runs went with it.
+        }
+    }
+    /**
+     * The close writer (slice 6b §4.2, Durable's `writeAtClose`): one commit past the seal writing the runs a clean stop
+     * cut off `stopped` and every held state change, straight to the store (the object's transactions are refused by
+     * now). Its failure is the store's; the records stay as they were (a crash counts them).
+     */
+    async writeAtClose(context) {
+        const persisted = this.#persisted;
+        if (persisted === undefined)
+            return;
+        const writes = [];
+        const adopts = [];
+        for (const run of this.#stopped) {
+            adopts.push(persisted.stage(run.id, storedRun(run), writes));
+        }
+        this.#stopped.clear();
+        for (const id of this.#states?.heldIds ?? []) {
+            const adopt = this.#states.stageHeld(id, writes);
+            if (adopt !== undefined)
+                adopts.push(adopt);
+        }
+        if (writes.length === 0)
+            return;
+        const fence = { admit: () => true, adopt: () => runAll(adopts) };
+        try {
+            await this.#owner.store.store.commit(writes, fence, withoutAbortSignal(context));
+        }
+        catch {
+            // The store failed or refused it (reported as the store's): a crash loses as much.
+        }
+    }
+    /** Stores every held state change whose deadline passed (`now`), in one transaction of the object (D8). */
+    async flushHeld(now) {
+        const states = this.#states;
+        if (states === undefined || states.heldIds.length === 0)
+            return;
+        const { documents, context } = this.#owner;
+        try {
+            await documents.tx((tx) => {
+                const staging = this.staging(tx);
+                for (const id of states.heldIds) {
+                    if (states.deadline(id) > now)
+                        continue;
+                    const adopt = states.stageHeld(id, this.#store(tx));
+                    if (adopt !== undefined)
+                        staging.adopts.push(adopt);
+                }
+            }, documents.own, context);
+        }
+        catch {
+            // The object is ending: its close writer stores what is held.
+        }
+    }
+    /** The earliest deadline of a held state change (`Infinity`: none). */
+    nextDeadline() {
+        const states = this.#states;
+        if (states === undefined)
+            return Number.POSITIVE_INFINITY;
+        return Math.min(Number.POSITIVE_INFINITY, ...states.heldIds.map((id) => states.deadline(id)));
+    }
+    /** The value of run `id`'s state document, `undefined` without one or once retired. */
+    stateOf(id) {
+        return this.#states?.value(id);
+    }
+    /** The run state documents, for `ctx.state.change`; `undefined` without a state definition. */
+    get states() {
+        return this.#states;
+    }
+    /** Whether the job persists its runs. */
+    get persisted() {
+        return this.#persisted !== undefined;
+    }
+    /**
+     * The object ends: running runs' signals fire, every waiter rejects with `error`; blocked in-memory runs are
+     * dropped (reported), persisted ones keep their records; nothing finishes. The records stay readable until `drop`.
+     */
+    end(error) {
+        if (this.#ended !== undefined)
+            return;
+        this.#ended = error;
+        this.#job = undefined;
+        this.#waiting.clear();
+        for (const run of this.#runs.values()) {
+            if (run.phase === "blocked" && this.#persisted === undefined)
+                this.report({ kind: "job_dropped", id: run.id });
+            const { invocation } = run;
+            invocation?.abort.abort(error);
+            run.reject(error);
+            if (invocation?.state !== "running")
+                invocation?.ended();
+        }
+        if (this.#active > 0)
+            this.#owner.countRuns(-this.#active);
+    }
+    /** Its object's documents are dropped: the runs, their state documents and `running`'s watches go. */
+    drop() {
+        this.#runs.clear();
+        this.#keys.clear();
+        this.#states?.drop();
+        this.#persisted?.drop();
+        this.running.end();
+    }
+    /** Reports a run's failure, drop or interruption to the host. */
+    report(error) {
+        this.#owner.host.report({ ...error, object: this.#owner.label, job: this.definition.name });
+    }
+    /** The store writes of `tx` (Chord's own documents of a persisted job). */
+    #store(tx) {
+        return tx.stageStore(this.#owner.store.store);
+    }
+    /**
+     * The run a loaded record stands for and the change its activation writes (D6): a record of another version or
+     * fingerprint blocked as stored (its state document only found, never decoded: slice 7 maps it); otherwise its state
+     * document read and decoded (migrated), pinned while it is unsettled, a crash counted, at the limit its outcome,
+     * marked resuming unless blocked or finishing.
+     */
+    async #restored(loaded, context) {
+        const { id, record } = loaded;
+        const { definition } = this;
+        const run = new JobRun(id, record.version, record.fingerprint, record.key, record.args, record.phase, record.trace);
+        run.restarts = record.restarts;
+        run.finishFailures = record.finishFailures;
+        run.abortMarked = record.abort === true;
+        const states = this.#states;
+        if (record.version !== definition.version || record.fingerprint !== definition.fingerprint) {
+            run.phase = "blocked";
+            run.blocked = "version";
+            // What the record says, for the reload that brings its version (`retryBlocked`).
+            run.blockedPhase = record.phase;
+            if (record.outcome !== undefined)
+                run.outcome = outcomeOf(record.outcome, id, record.args, undefined);
+            // What is stored of its state (also when this version declares none), so an abort drops it with the record.
+            await this.#persisted.findBlockedState(id, context);
+            return { run, change: undefined };
+        }
+        const document = await states?.persistence.read(id, context);
+        if (document !== undefined) {
+            const { value, stored } = states.persistence.decode(document, states.definition.current, context);
+            states.create(id, value, stored);
+        }
+        if (record.outcome !== undefined)
+            run.outcome = outcomeOf(record.outcome, id, record.args, this.stateOf(id));
+        run.blocked = record.blocked;
+        switch (record.phase) {
+            case "running": {
+                const restarts = record.restarts + 1;
+                run.resuming = true;
+                if (restarts < RESTART_LIMIT) {
+                    return { run, change: { kind: "update", run, fields: { phase: "pending", restarts } } };
+                }
+                run.restarts = restarts;
+                const outcome = this.#outcome(run, { kind: "failed", error: { kind: "restart_limit", restarts } });
+                return { run, change: { kind: "outcome", run, outcome } };
+            }
+            case "stopped":
+                run.resuming = true;
+                return { run, change: { kind: "update", run, fields: { phase: "pending" } } };
+            case "pending":
+                run.resuming = true;
+                return { run, change: undefined };
+            default:
+                return { run, change: undefined };
+        }
+    }
+    /** Records the outcome of `run` (with what its state holds, D8), then has it finished on the live attempt. */
+    async #recordOutcome(run, ended) {
+        const { documents, context } = this.#owner;
+        try {
+            await documents.tx((tx) => {
+                const outcome = this.#outcome(run, ended);
+                this.change(tx, { kind: "outcome", run, outcome });
+                // What its state holds is stored before the outcome is recorded (D8).
+                const adopt = this.#persisted === undefined ? undefined : this.#states?.stageHeld(run.id, this.#store(tx));
+                if (adopt !== undefined)
+                    this.staging(tx).adopts.push(adopt);
+            }, documents.own, context);
+        }
+        catch {
+            // The object ended: nothing finishes.
+            return;
+        }
+        finally {
+            // A run ending without an invocation (marked aborted, abandoned, cut off in memory) has none to wait for.
+            run.invocation?.ended();
+        }
+        this.#need(run);
+    }
+    /** `run`'s outcome for `ended`, with its args and its state as it is now. */
+    #outcome(run, ended) {
+        return { id: run.id, args: run.args, state: this.stateOf(run.id), ...ended };
+    }
+    /** `run` needs a live attempt (to be invoked or finished): now, or once one attaches. */
+    #need(run) {
+        if (this.#ended !== undefined || this.#runs.get(run.id) !== run)
+            return;
+        // A job the code no longer declares: blocked `version`, kept (slice 7b §8).
+        if (!this.#declared) {
+            if (run.phase !== "blocked")
+                void this.record(run, { kind: "block", run, reason: "version" });
+            return;
+        }
+        const job = this.#job;
+        if (job === undefined)
+            this.#waiting.add(run);
+        else
+            this.#dispatch(run, job);
+    }
+    /**
+     * Invokes or finishes `run` on `job`, as its record stands: a finishing run is finished; a run not invoked yet is
+     * invoked, unless it is marked aborted (it ends `aborted` without `run`) or resumes abandoned (`failed { aborted,
+     * reason: "restart" }`).
+     */
+    #dispatch(run, job) {
+        if (this.#runs.get(run.id) !== run || run.phase === "blocked")
+            return;
+        // Not of a version the code takes: blocked `version` until a reload brings matching code.
+        if (!this.#takes(run)) {
+            void this.record(run, { kind: "block", run, reason: "version" });
+            return;
+        }
+        if (run.phase === "finishing") {
+            job.finish(run);
+            return;
+        }
+        if (run.invoked)
+            return;
+        if (run.abortMarked) {
+            void this.#recordOutcome(run, ABORTED);
+            return;
+        }
+        if (run.resuming && this.definition.persist?.resume === "abandon") {
+            void this.#recordOutcome(run, RESTART);
+            return;
+        }
+        run.resuming = false;
+        job.invoke(run);
+    }
+    /**
+     * Adopts one record change, inside the commit step: the maps, the active count, `running`. A new run is counted for
+     * its object here, before the commit's publication (a link closing while it sends may release the object's last
+     * reference) and before any run of the same commit settles in `#committed`.
+     */
+    #adopt(change) {
+        const { run } = change;
+        switch (change.kind) {
+            case "create":
+            case "restore":
+                this.#runs.set(run.id, run);
+                if (run.key !== undefined)
+                    this.#keys.set(run.key, run);
+                if (run.phase !== "blocked") {
+                    this.#active++;
+                    this.#owner.countRuns(1);
+                }
+                run.entry = this.#entryOf(run);
+                this.running.add(run.entry);
+                return;
+            case "update":
+                Object.assign(run, change.fields);
+                this.#replaceEntry(run);
+                return;
+            case "outcome":
+                run.outcome = change.outcome;
+                run.phase = "finishing";
+                this.#replaceEntry(run);
+                return;
+            case "block":
+                run.phase = "blocked";
+                run.blocked = change.reason;
+                this.#active--;
+                this.#replaceEntry(run);
+                return;
+            case "unblock":
+                run.phase = change.phase;
+                run.blocked = undefined;
+                run.blockedPhase = undefined;
+                run.finishFailures = 0;
+                // A persisted run to be invoked again resumes per its job's `resume`, as after a stop.
+                if (change.phase === "pending")
+                    run.resuming = true;
+                this.#active++;
+                this.#owner.countRuns(1);
+                this.#replaceEntry(run);
+                return;
+            case "delete":
+            case "drop":
+                this.#runs.delete(run.id);
+                // The finishing run's key may name its successor already, started in the same commit.
+                if (run.key !== undefined && this.#keys.get(run.key) === run)
+                    this.#keys.delete(run.key);
+                if (change.kind === "delete")
+                    this.#active--;
+                this.running.remove(run.entry);
+                run.entry = undefined;
+                return;
+        }
+    }
+    /** The actions after a record change committed. */
+    #committed(change) {
+        const { run } = change;
+        switch (change.kind) {
+            case "create":
+                // After the commit, outside the batch, once the transaction settled; on the live attempt, or the next.
+                queueMicrotask(() => this.#need(run));
+                return;
+            case "restore":
+            case "update":
+            case "outcome":
+                return;
+            case "delete":
+                this.#owner.countRuns(-1);
+                run.resolve(run.outcome);
+                return;
+            case "block":
+                this.#owner.countRuns(-1);
+                return;
+            case "unblock":
+                this.#need(run);
+                return;
+            case "drop":
+                this.report({ kind: "job_dropped", id: run.id });
+                run.reject(new ChordError({ code: "aborted", message: `${this.name}: run ${run.id} dropped` }));
+                return;
+        }
+    }
+    /** A run's state document changed by `ops`, inside the commit step: its entry is replaced. */
+    #stateChanged(id, ops) {
+        const run = this.#runs.get(id);
+        // Its record may not be adopted yet (a start creates both in one commit; its entry takes the state then).
+        if (run?.entry === undefined)
+            return;
+        const before = run.entry;
+        run.entry = this.#entryOf(run);
+        this.running.stateChanged(before, run.entry, ops);
+    }
+    /** A run's record changed, inside the commit step: its entry is replaced. */
+    #replaceEntry(run) {
+        const before = run.entry;
+        run.entry = this.#entryOf(run);
+        this.running.replace(before, run.entry);
+    }
+    /**
+     * `run`'s `running` entry: blocked, or with its state and its args as the current code takes them (an older run's
+     * mapped; one the code does not take, or whose mapping throws, shows its own).
+     */
+    #entryOf(run) {
+        let args = run.args;
+        if (run.phase !== "blocked" && run.version !== this.definition.version && this.#takes(run)) {
+            try {
+                args = this.argsOf(run, this.definition);
+            }
+            catch {
+                // The provider's mapping threw: its own args (its finish meets the same throw and is retried).
+            }
+        }
+        return run.entryFor(this.stateOf(run.id), args);
+    }
+    #discarded() {
+        return new ChordError({
+            code: "released",
+            reason: "discarded",
+            message: `${this.name}: the start's transaction was discarded`,
+        });
+    }
+}
+/** Runs every adoption of `adopts`. */
+function runAll(adopts) {
+    for (const adopt of adopts)
+        adopt();
+}
+/** The record fields a change writes, its phase transitions included. */
+function recordFields(change) {
+    switch (change.kind) {
+        case "create":
+            return {};
+        case "update":
+            return change.fields;
+        case "outcome":
+            return { phase: "finishing", outcome: change.outcome };
+        case "block":
+            return { phase: "blocked", blocked: change.reason };
+        case "unblock":
+            return { phase: change.phase, blocked: undefined, finishFailures: 0 };
+    }
+}
+//# sourceMappingURL=records.js.map