@gentbajko/slopify 0.8.4 → 1.0.0

package/dist/kernel/audio-preview.js

@@ -39,12 +39,16 @@ export function createAudioPreviewStore(limits = {}) {
     const expiry = setInterval(prune, Math.min(keepMs, 30_000));
     expiry.unref();
     const store = {
-        begin(projectId, key, label) {
+        begin(projectId, key, label, origin) {
             if (closed)
                 return inactive;
             prune();
             for (const entry of entries.values()) {
-                if (entry.projectId === projectId && entry.key === key)
+                if (entry.projectId === projectId &&
+                    entry.key === key &&
+                    entry.origin?.revisionId === origin?.revisionId &&
+                    entry.origin?.workId === origin?.workId &&
+                    entry.origin?.workPieceId === origin?.workPieceId)
                     remove(entry);
             }
             // At capacity, completed previews yield to current generation. Otherwise
@@ -57,6 +61,7 @@ export function createAudioPreviewStore(limits = {}) {
             if (entries.size >= maxEntries)
                 return inactive;
             const entry = {
+                origin,
                 id: randomUUID(),
                 projectId,
                 key,
@@ -103,7 +108,7 @@ export function createAudioPreviewStore(limits = {}) {
             prune();
             return [...entries.values()]
                 .filter((entry) => entry.projectId === projectId)
-                .map(({ id, label, state, bytes }) => ({ id, label, state, bytes }));
+                .map(({ id, label, state, bytes, origin }) => ({ id, label, state, bytes, ...origin }));
         },
         stream(projectId, id, signal) {
             prune();
@@ -115,9 +120,10 @@ export function createAudioPreviewStore(limits = {}) {
                 return undefined;
             return follow(entry, signal);
         },
-        clear(projectId) {
+        clear(projectId, workId) {
             for (const entry of entries.values())
-                if (entry.projectId === projectId)
+                if (entry.projectId === projectId &&
+                    (workId === undefined || entry.origin?.workId === workId))
                     remove(entry);
         },
         close() {

package/dist/kernel/db/migrations/0004-project-revisions.sql

@@ -0,0 +1,91 @@
+CREATE TABLE project_revisions (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  parent_id TEXT,
+  restored_from_id TEXT,
+  config TEXT NOT NULL CHECK(json_valid(config)),
+  content TEXT NOT NULL CHECK(json_valid(content)),
+  fingerprints TEXT NOT NULL CHECK(json_valid(fingerprints)),
+  created_at TEXT NOT NULL,
+  UNIQUE(project_id, id),
+  FOREIGN KEY(project_id, parent_id)
+    REFERENCES project_revisions(project_id, id),
+  FOREIGN KEY(project_id, restored_from_id)
+    REFERENCES project_revisions(project_id, id)
+);
+CREATE INDEX project_revisions_project ON project_revisions(project_id, created_at, id);
+CREATE TABLE project_heads (
+  project_id TEXT PRIMARY KEY REFERENCES projects(id) ON DELETE CASCADE,
+  revision_id TEXT NOT NULL,
+  FOREIGN KEY(project_id, revision_id)
+    REFERENCES project_revisions(project_id, id) ON DELETE CASCADE
+);
+CREATE TABLE project_assets (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  path TEXT NOT NULL CHECK(length(path) > 0),
+  bytes INTEGER CHECK(bytes IS NULL OR bytes >= 0),
+  created_at TEXT NOT NULL,
+  UNIQUE(project_id, id),
+  UNIQUE(project_id, path)
+);
+CREATE TABLE revision_outputs (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  revision_id TEXT NOT NULL,
+  slot TEXT NOT NULL,
+  work_key TEXT NOT NULL,
+  asset_id TEXT NOT NULL,
+  fingerprint TEXT NOT NULL,
+  state TEXT NOT NULL CHECK(state IN ('ready','outdated','review')),
+  descriptor TEXT NOT NULL CHECK(json_valid(descriptor)),
+  publication_id TEXT,
+  selected INTEGER NOT NULL CHECK(selected IN (0,1)),
+  created_at TEXT NOT NULL,
+  FOREIGN KEY(project_id, revision_id)
+    REFERENCES project_revisions(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY(project_id, asset_id)
+    REFERENCES project_assets(project_id, id) ON DELETE CASCADE
+);
+CREATE UNIQUE INDEX revision_outputs_selected ON revision_outputs(revision_id, slot)
+  WHERE selected = 1;
+CREATE INDEX revision_outputs_revision ON revision_outputs(revision_id, created_at, id);
+CREATE UNIQUE INDEX revision_outputs_publication ON revision_outputs(revision_id, publication_id, slot)
+  WHERE publication_id IS NOT NULL;
+CREATE TABLE revision_pieces (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  revision_id TEXT NOT NULL,
+  piece_key TEXT NOT NULL,
+  stage_kind TEXT NOT NULL CHECK(stage_kind IN
+    ('research','article','audio','images','thumbnail','video')),
+  asset_id TEXT,
+  fingerprint TEXT NOT NULL,
+  descriptor TEXT NOT NULL CHECK(json_valid(descriptor)),
+  publication_id TEXT,
+  selected INTEGER NOT NULL CHECK(selected IN (0,1)),
+  created_at TEXT NOT NULL,
+  FOREIGN KEY(project_id, revision_id)
+    REFERENCES project_revisions(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY(project_id, asset_id)
+    REFERENCES project_assets(project_id, id) ON DELETE CASCADE
+);
+CREATE UNIQUE INDEX revision_pieces_selected ON revision_pieces(revision_id, piece_key)
+  WHERE selected = 1;
+CREATE INDEX revision_pieces_revision ON revision_pieces(revision_id, created_at, id);
+CREATE UNIQUE INDEX revision_pieces_publication ON revision_pieces(revision_id, publication_id, piece_key)
+  WHERE publication_id IS NOT NULL;
+CREATE TABLE revision_mutations (
+  project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+  idempotency_key TEXT NOT NULL,
+  operation TEXT NOT NULL CHECK(operation IN ('save','restore')),
+  request_hash TEXT NOT NULL,
+  base_revision_id TEXT NOT NULL,
+  result_revision_id TEXT NOT NULL,
+  created_at TEXT NOT NULL,
+  PRIMARY KEY(project_id, idempotency_key),
+  FOREIGN KEY(project_id, base_revision_id)
+    REFERENCES project_revisions(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY(project_id, result_revision_id)
+    REFERENCES project_revisions(project_id, id) ON DELETE CASCADE
+);

package/dist/kernel/db/migrations/0005-revision-work.sql

@@ -0,0 +1,103 @@
+CREATE UNIQUE INDEX stages_project_identity ON stages(project_id,id,kind);
+CREATE TABLE revision_work (
+ id TEXT PRIMARY KEY,
+ project_id TEXT NOT NULL,
+ revision_id TEXT NOT NULL,
+ stage_id TEXT NOT NULL,
+ kind TEXT NOT NULL,
+ fingerprint TEXT NOT NULL,
+ admission_id TEXT,
+ recipe_context TEXT CHECK(recipe_context IS NULL OR json_valid(recipe_context)),
+ progress_current REAL,
+ progress_total REAL,
+ state TEXT NOT NULL CHECK(state IN ('pending','running','done','failed','canceled')),
+ dispatch_state TEXT NOT NULL CHECK(dispatch_state IN ('held','allowed','draining')),
+ failure_reason TEXT,
+ created_at TEXT NOT NULL,
+ UNIQUE(project_id,id),
+ FOREIGN KEY(project_id,revision_id) REFERENCES project_revisions(project_id,id) ON DELETE CASCADE,
+ FOREIGN KEY(project_id,stage_id,kind) REFERENCES stages(project_id,id,kind) ON DELETE CASCADE
+);
+CREATE INDEX revision_work_stage ON revision_work(revision_id,stage_id);
+CREATE INDEX revision_work_dispatch ON revision_work(project_id,dispatch_state,state);
+CREATE TABLE revision_work_pieces (
+ id TEXT PRIMARY KEY,
+ work_id TEXT NOT NULL REFERENCES revision_work(id) ON DELETE CASCADE,
+ work_key TEXT NOT NULL,
+ request_fingerprint TEXT NOT NULL,
+ fingerprint TEXT NOT NULL,
+ input_json TEXT NOT NULL CHECK(json_valid(input_json)),
+ logical_fingerprint TEXT,
+ result_json TEXT CHECK(result_json IS NULL OR json_valid(result_json)),
+ continuation TEXT,
+ generation_token TEXT,
+ state TEXT NOT NULL CHECK(state IN ('pending','running','done','failed','held')),
+ dispatch_state TEXT NOT NULL CHECK(dispatch_state IN ('held','allowed','draining')),
+ submitted_at TEXT,
+ UNIQUE(work_id,id),
+ UNIQUE(work_id,work_key)
+);
+CREATE INDEX revision_piece_dispatch ON revision_work_pieces(work_id,dispatch_state,state);
+CREATE TABLE revision_work_reservations (
+ project_id TEXT NOT NULL,
+ revision_id TEXT NOT NULL,
+ work_key TEXT NOT NULL,
+ work_id TEXT NOT NULL,
+ piece_id TEXT,
+ fingerprint TEXT NOT NULL,
+ logical_key TEXT,
+ desired_fingerprint TEXT,
+ CHECK((logical_key IS NULL) = (desired_fingerprint IS NULL)),
+ PRIMARY KEY(revision_id,work_key),
+ FOREIGN KEY(project_id,revision_id) REFERENCES project_revisions(project_id,id) ON DELETE CASCADE,
+ FOREIGN KEY(project_id,work_id) REFERENCES revision_work(project_id,id) ON DELETE CASCADE,
+ FOREIGN KEY(work_id,piece_id) REFERENCES revision_work_pieces(work_id,id) ON DELETE CASCADE
+);
+CREATE TABLE rebuild_previews (
+ id TEXT PRIMARY KEY,
+ project_id TEXT NOT NULL,
+ revision_id TEXT NOT NULL,
+ plan_fingerprint TEXT NOT NULL,
+ body_json TEXT NOT NULL CHECK(json_valid(body_json)),
+ execution_json TEXT CHECK(execution_json IS NULL OR json_valid(execution_json)),
+ created_at TEXT NOT NULL,
+ UNIQUE(project_id,revision_id,id),
+ FOREIGN KEY(project_id,revision_id) REFERENCES project_revisions(project_id,id) ON DELETE CASCADE
+);
+CREATE TABLE rebuild_admissions (
+ id TEXT PRIMARY KEY,
+ project_id TEXT NOT NULL,
+ revision_id TEXT NOT NULL,
+ idempotency_key TEXT NOT NULL,
+ request_hash TEXT NOT NULL,
+ preview_id TEXT NOT NULL,
+ response_json TEXT NOT NULL CHECK(json_valid(response_json)),
+ created_at TEXT NOT NULL,
+ UNIQUE(project_id,idempotency_key),
+ FOREIGN KEY(project_id,revision_id) REFERENCES project_revisions(project_id,id) ON DELETE CASCADE,
+ FOREIGN KEY(project_id,revision_id,preview_id) REFERENCES rebuild_previews(project_id,revision_id,id)
+);
+ALTER TABLE attempts ADD COLUMN revision_id TEXT REFERENCES project_revisions(id) ON DELETE SET NULL;
+ALTER TABLE attempts ADD COLUMN work_id TEXT REFERENCES revision_work(id) ON DELETE SET NULL;
+ALTER TABLE attempts ADD COLUMN work_piece_id TEXT REFERENCES revision_work_pieces(id) ON DELETE SET NULL;
+
+CREATE TABLE project_control_receipts (
+ project_id TEXT NOT NULL,
+ idempotency_key TEXT NOT NULL,
+ operation TEXT NOT NULL CHECK(operation IN ('pause','cancel')),
+ request_hash TEXT NOT NULL,
+ base_revision_id TEXT NOT NULL,
+ response_json TEXT NOT NULL CHECK(json_valid(response_json)),
+ created_at TEXT NOT NULL,
+ PRIMARY KEY(project_id,idempotency_key),
+ FOREIGN KEY(project_id,base_revision_id) REFERENCES project_revisions(project_id,id) ON DELETE CASCADE
+);
+CREATE TABLE revision_provided_reviews (
+ project_id TEXT NOT NULL,
+ revision_id TEXT NOT NULL,
+ work_key TEXT NOT NULL,
+ dependency_fingerprint TEXT NOT NULL,
+ admission_id TEXT NOT NULL REFERENCES rebuild_admissions(id) ON DELETE CASCADE,
+ PRIMARY KEY(revision_id,work_key),
+ FOREIGN KEY(project_id,revision_id) REFERENCES project_revisions(project_id,id) ON DELETE CASCADE
+);

package/dist/kernel/db/migrations/0006-play-drafts.sql

@@ -0,0 +1,38 @@
+CREATE TABLE play_drafts (
+ id TEXT PRIMARY KEY,
+ schema_version INTEGER NOT NULL,
+ version INTEGER NOT NULL CHECK(version >= 1),
+ title TEXT NOT NULL,
+ document_json TEXT NOT NULL CHECK(json_valid(document_json)),
+ creation_hash TEXT NOT NULL,
+ save_mutation_id TEXT,
+ save_request_hash TEXT,
+ created_at TEXT NOT NULL,
+ updated_at TEXT NOT NULL,
+ state TEXT NOT NULL CHECK(state IN ('active','starting','started')),
+ review_id TEXT UNIQUE,
+ review_json TEXT CHECK(review_json IS NULL OR json_valid(review_json)),
+ review_fingerprint TEXT,
+ start_id TEXT
+);
+CREATE TABLE play_draft_attachments (
+ id TEXT PRIMARY KEY,
+ draft_id TEXT NOT NULL REFERENCES play_drafts(id) ON DELETE CASCADE,
+ staged_file_id TEXT REFERENCES staged_files(id) ON DELETE SET NULL,
+ kind TEXT NOT NULL CHECK(kind IN ('audio','images','thumbnail')),
+ original_filename TEXT NOT NULL,
+ status TEXT NOT NULL CHECK(status IN ('pending','ready','reattach')),
+ error TEXT
+);
+CREATE INDEX play_draft_attachment_file ON play_draft_attachments(staged_file_id);
+CREATE INDEX play_draft_attachment_owner ON play_draft_attachments(draft_id);
+CREATE TABLE play_start_receipts (
+ id TEXT PRIMARY KEY,
+ draft_id TEXT NOT NULL,
+ draft_version INTEGER NOT NULL,
+ request_hash TEXT NOT NULL,
+ result_json TEXT NOT NULL CHECK(json_valid(result_json)),
+ created_at TEXT NOT NULL,
+ UNIQUE(draft_id,draft_version)
+);
+CREATE INDEX play_start_receipt_draft ON play_start_receipts(draft_id);

package/dist/kernel/db/migrations/0007-review-checkpoints.sql

@@ -0,0 +1,28 @@
+CREATE UNIQUE INDEX revision_work_revision_identity ON revision_work(project_id,revision_id,id);
+CREATE TABLE review_checkpoints (
+ project_id TEXT NOT NULL,
+ revision_id TEXT NOT NULL,
+ checkpoint_id TEXT NOT NULL,
+ stage TEXT NOT NULL CHECK(stage IN ('audio','images','video')),
+ work_id TEXT NOT NULL,
+ fingerprint TEXT NOT NULL CHECK(length(fingerprint)=64),
+ state TEXT NOT NULL CHECK(state IN ('configured','pending-review','held','released','satisfied','invalidated','canceled')),
+ created_at TEXT NOT NULL,
+ approved_at TEXT,
+ PRIMARY KEY(project_id,revision_id,checkpoint_id),
+ UNIQUE(project_id,revision_id,stage),
+ FOREIGN KEY(project_id,revision_id) REFERENCES project_revisions(project_id,id) ON DELETE CASCADE,
+ FOREIGN KEY(project_id,revision_id,work_id) REFERENCES revision_work(project_id,revision_id,id) ON DELETE CASCADE
+);
+CREATE INDEX review_checkpoint_work ON review_checkpoints(work_id);
+CREATE TABLE review_checkpoint_approvals (
+ project_id TEXT NOT NULL,
+ idempotency_key TEXT NOT NULL,
+ revision_id TEXT NOT NULL,
+ checkpoint_id TEXT NOT NULL,
+ fingerprint TEXT NOT NULL CHECK(length(fingerprint)=64),
+ approved_at TEXT NOT NULL,
+ PRIMARY KEY(project_id,idempotency_key),
+ UNIQUE(project_id,revision_id,checkpoint_id),
+ FOREIGN KEY(project_id,revision_id,checkpoint_id) REFERENCES review_checkpoints(project_id,revision_id,checkpoint_id) ON DELETE CASCADE
+);

package/dist/kernel/db/migrations/0008-project-templates.sql

@@ -0,0 +1,21 @@
+CREATE TABLE project_templates (
+ id TEXT PRIMARY KEY,
+ head_version INTEGER NOT NULL CHECK(head_version >= 1),
+ creation_hash TEXT NOT NULL,
+ created_at TEXT NOT NULL,
+ mutation_id TEXT,
+ mutation_hash TEXT
+);
+CREATE TABLE project_template_revisions (
+ template_id TEXT NOT NULL REFERENCES project_templates(id) ON DELETE CASCADE,
+ version INTEGER NOT NULL CHECK(version >= 1),
+ name TEXT NOT NULL CHECK(length(trim(name)) BETWEEN 1 AND 200),
+ document_json TEXT NOT NULL CHECK(json_valid(document_json)),
+ created_at TEXT NOT NULL,
+ PRIMARY KEY(template_id,version)
+);
+CREATE TABLE project_template_instantiations (
+ draft_id TEXT PRIMARY KEY REFERENCES play_drafts(id) ON DELETE CASCADE,
+ template_id TEXT NOT NULL,
+ template_version INTEGER NOT NULL CHECK(template_version >= 1)
+);

package/dist/kernel/db/migrations/0009-scheduled-jobs.sql

@@ -0,0 +1,37 @@
+CREATE TABLE schedules (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL CHECK(length(trim(name)) BETWEEN 1 AND 200),
+  template_id TEXT NOT NULL,
+  template_version INTEGER NOT NULL CHECK(template_version >= 1),
+  cadence_json TEXT NOT NULL CHECK(json_valid(cadence_json)),
+  timezone TEXT NOT NULL,
+  missed_policy TEXT NOT NULL CHECK(missed_policy IN ('skip','run-once')),
+  overlap_policy TEXT NOT NULL CHECK(overlap_policy IN ('skip')),
+  spend_limit_cents INTEGER CHECK(spend_limit_cents IS NULL OR spend_limit_cents >= 0),
+  items_json TEXT NOT NULL CHECK(json_valid(items_json)),
+  status TEXT NOT NULL CHECK(status IN ('active','paused','completed','canceled')),
+  version INTEGER NOT NULL CHECK(version >= 1),
+  creation_hash TEXT NOT NULL,
+  next_run_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  mutation_id TEXT,
+  mutation_hash TEXT,
+  FOREIGN KEY(template_id) REFERENCES project_templates(id)
+);
+CREATE INDEX schedules_due ON schedules(status, next_run_at);
+CREATE TABLE schedule_runs (
+  id TEXT PRIMARY KEY,
+  schedule_id TEXT NOT NULL REFERENCES schedules(id) ON DELETE CASCADE,
+  scheduled_for TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('running','succeeded','failed','skipped')),
+  request_id TEXT,
+  project_ids_json TEXT NOT NULL CHECK(json_valid(project_ids_json)),
+  estimate_json TEXT CHECK(estimate_json IS NULL OR json_valid(estimate_json)),
+  started_at TEXT NOT NULL,
+  ended_at TEXT,
+  error TEXT,
+  UNIQUE(schedule_id, scheduled_for),
+  UNIQUE(request_id)
+);
+CREATE INDEX schedule_runs_schedule ON schedule_runs(schedule_id, started_at DESC);

package/dist/kernel/db/migrations/0010-retain-schedule-history.sql

@@ -0,0 +1,62 @@
+CREATE TABLE retained_schedule_runs (
+  id TEXT PRIMARY KEY,
+  schedule_id TEXT NOT NULL,
+  scheduled_for TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('running','succeeded','failed','skipped')),
+  request_id TEXT,
+  project_ids_json TEXT NOT NULL CHECK(json_valid(project_ids_json)),
+  estimate_json TEXT CHECK(estimate_json IS NULL OR json_valid(estimate_json)),
+  started_at TEXT NOT NULL,
+  ended_at TEXT,
+  projects_settled_at TEXT,
+  error TEXT,
+  UNIQUE(schedule_id, scheduled_for),
+  UNIQUE(request_id)
+);
+INSERT INTO retained_schedule_runs (
+  id,schedule_id,scheduled_for,status,request_id,project_ids_json,estimate_json,started_at,
+  ended_at,projects_settled_at,error
+)
+SELECT
+  id,schedule_id,scheduled_for,status,request_id,project_ids_json,estimate_json,started_at,
+  ended_at,NULL,error
+FROM schedule_runs;
+DROP TABLE schedule_runs;
+ALTER TABLE retained_schedule_runs RENAME TO schedule_runs;
+CREATE INDEX schedule_runs_schedule ON schedule_runs(schedule_id, started_at DESC);
+
+CREATE TABLE retained_schedules (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL CHECK(length(trim(name)) BETWEEN 1 AND 200),
+  template_id TEXT NOT NULL,
+  template_version INTEGER NOT NULL CHECK(template_version >= 1),
+  cadence_json TEXT NOT NULL CHECK(json_valid(cadence_json)),
+  timezone TEXT NOT NULL,
+  missed_policy TEXT NOT NULL CHECK(missed_policy IN ('skip','run-once')),
+  overlap_policy TEXT NOT NULL CHECK(overlap_policy IN ('skip')),
+  spend_limit_cents INTEGER CHECK(spend_limit_cents IS NULL OR spend_limit_cents >= 0),
+  items_json TEXT NOT NULL CHECK(json_valid(items_json)),
+  status TEXT NOT NULL CHECK(status IN ('active','paused','completed','canceled')),
+  version INTEGER NOT NULL CHECK(version >= 1),
+  creation_hash TEXT NOT NULL,
+  next_run_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL,
+  mutation_id TEXT,
+  mutation_hash TEXT,
+  deleted_at TEXT,
+  CHECK(deleted_at IS NULL OR (status IN ('completed','canceled') AND next_run_at IS NULL))
+);
+INSERT INTO retained_schedules (
+  id,name,template_id,template_version,cadence_json,timezone,missed_policy,overlap_policy,
+  spend_limit_cents,items_json,status,version,creation_hash,next_run_at,created_at,updated_at,
+  mutation_id,mutation_hash,deleted_at
+)
+SELECT
+  id,name,template_id,template_version,cadence_json,timezone,missed_policy,overlap_policy,
+  spend_limit_cents,items_json,status,version,creation_hash,next_run_at,created_at,updated_at,
+  mutation_id,mutation_hash,NULL
+FROM schedules;
+DROP TABLE schedules;
+ALTER TABLE retained_schedules RENAME TO schedules;
+CREATE INDEX schedules_due ON schedules(status, next_run_at) WHERE deleted_at IS NULL;

package/dist/kernel/ports/model.js

@@ -1,6 +1,11 @@
 // The vocabulary that crosses the provider seam. Domain types only: a vendor's payload
 // shape never leaves its adapter.
 export const providerFamilies = ["llm", "tts", "image"];
+export function readinessIsUsable(readiness) {
+    return readiness.kind === "keyed"
+        ? readiness.hasKey
+        : readiness.installed && readiness.issue === undefined;
+}
 export const providerErrorKinds = [
     "auth",
     // Distinct from `auth`, a key the provider rejected: a bad key runs the whole retry

package/dist/kernel/runner/attempt-repo.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { providerErrorKinds } from "../ports/model.js";
+import { readWorkContinuation, startWorkAttempt, writeWorkContinuation } from "./work-attempt.js";
 // One row per provider call attempt. The project page reads the last error text off these rows
 // and Usage counts them, so an attempt is written when it opens rather than when it ends: a
 // process that dies mid-call leaves the evidence behind.
@@ -13,10 +14,20 @@ const attemptRow = z.object({
     ended_at: z.string().nullable(),
     outcome: z.enum(attemptOutcomes).nullable(),
     error_text: z.string().nullable(),
+    revision_id: z.string().nullable(),
+    work_id: z.string().nullable(),
+    work_piece_id: z.string().nullable(),
 });
 export function sqliteAttempts(db, ids) {
     return {
+        readContinuation: (work, pieceId) => readWorkContinuation(db, work, pieceId) ?? undefined,
+        writeContinuation: (work, pieceId, token) => {
+            if (!writeWorkContinuation(db, work, pieceId, token))
+                throw new Error("Could not persist the submitted narration job");
+        },
         start: (attempt) => {
+            if (attempt.work !== undefined)
+                return startWorkAttempt(db, ids, attempt, attempt.work, attempt.workPieceId ?? null, attempt.operation);
             const id = ids.next();
             db.prepare("INSERT INTO attempts (id, stage_id, piece_id, n, started_at) VALUES (?, ?, ?, ?, ?)").run(id, attempt.stageId, attempt.pieceId, attempt.n, attempt.startedAt);
             // The stage shows the attempt count beside the error. A stage with pieces (twenty images)
@@ -38,6 +49,9 @@ export function attemptsOf(db, stageId) {
 function toAttempt(row) {
     return {
         id: row.id,
+        revisionId: row.revision_id,
+        workId: row.work_id,
+        workPieceId: row.work_piece_id,
         stageId: row.stage_id,
         pieceId: row.piece_id,
         n: row.n,
@@ -47,3 +61,4 @@ function toAttempt(row) {
         errorText: row.error_text,
     };
 }
+export { readWorkContinuation, startWorkAttempt, writeWorkContinuation };

package/dist/kernel/runner/attempt.js

@@ -20,12 +20,24 @@ export async function attempt(ctx, call, opts) {
     ctx.signal.throwIfAborted();
     const limit = timeoutMs[opts.kind];
     for (let n = 1;; n += 1) {
-        const id = ctx.attempts.start({
+        ctx.signal.throwIfAborted();
+        const retrieving = ctx.continuation?.read() !== undefined;
+        if (!retrieving && !ctx.maySubmit())
+            return { ok: false, reason: "held" };
+        const started = ctx.attempts.start({
             stageId: ctx.stageId,
+            revisionId: ctx.work.revisionId,
+            workId: ctx.work.workId,
+            workPieceId: ctx.workPieceId ?? null,
+            work: ctx.work,
+            operation: retrieving ? "retrieve" : "submit",
             pieceId: ctx.pieceId ?? null,
             n,
             startedAt: ctx.clock.now().toISOString(),
         });
+        if (typeof started !== "string" && !started.ok)
+            return started;
+        const id = typeof started === "string" ? started : started.value;
         const window = deadline(ctx.clock, ctx.signal, limit, opts.streaming === true);
         let result;
         try {
@@ -42,7 +54,7 @@ export async function attempt(ctx, call, opts) {
                 endedAt: ctx.clock.now().toISOString(),
                 errorText: null,
             });
-            return result.value;
+            return { ok: true, value: result.value };
         }
         if (ctx.signal.aborted) {
             // An aborted call counts nothing. The row is closed so the page is

package/dist/kernel/runner/checkpoint-authority.js

@@ -0,0 +1,23 @@
+export function createCheckpointAuthority(deps) {
+    return {
+        beforeClaim: deps.decide,
+        release: (projectId, checkpointId, identity) => {
+            // A nested savepoint cannot authorize dispatch before its caller commits.
+            if (deps.inTransaction())
+                return { ok: false, reason: "conflict" };
+            const result = deps.approve(projectId, checkpointId, identity);
+            if (result.ok) {
+                try {
+                    deps.wake(projectId);
+                }
+                catch (error) {
+                    deps.log.write("error", "checkpoint.wake", {
+                        projectId,
+                        detail: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
+            return result;
+        },
+    };
+}

package/dist/kernel/runner/index.js

@@ -16,6 +16,8 @@ export function createRunner(deps) {
     const emitStage = (stage, state, reason) => {
         deps.emit(stage.projectId, {
             type: "stage.state",
+            revisionId: stage.work.revisionId,
+            workId: stage.work.workId,
             projectId: stage.projectId,
             stage: stage.kind,
             state,
@@ -35,7 +37,7 @@ export function createRunner(deps) {
         }
     };
     const announce = (projectId) => {
-        const state = derive(deps.stages.stagesOf(projectId), deps.stages.paused?.(projectId));
+        const state = derive(deps.stages.standingsOf?.(projectId) ?? deps.stages.stagesOf(projectId), deps.stages.paused?.(projectId));
         if (announced.get(projectId) === state) {
             return;
         }
@@ -44,7 +46,7 @@ export function createRunner(deps) {
     };
     const conclude = (stage, state, reason) => {
         try {
-            deps.stages.finish(stage.id, state, reason);
+            deps.stages.finish(stage.work, state, reason);
         }
         catch (error) {
             // The row stays `running` when the write fails. The event still goes out, and the
@@ -63,14 +65,25 @@ export function createRunner(deps) {
             if (run === undefined) {
                 throw new Error(`no implementation is registered for the ${stage.kind} stage`);
             }
-            await run({
+            const result = await run({
                 stage,
+                work: stage.work,
+                maySubmit: (pieceId) => !shuttingDown &&
+                    !stopped.has(stage.projectId) &&
+                    !deps.stages.paused?.(stage.projectId) &&
+                    (deps.checkpoints === undefined ||
+                        deps.checkpoints.beforeClaim(stage.work).kind === "eligible") &&
+                    deps.stages.maySubmit(stage.work, pieceId),
                 signal: controller.signal,
                 emit: (event) => {
-                    deps.emit(stage.projectId, event);
+                    deps.emit(stage.projectId, {
+                        ...event,
+                        revisionId: stage.work.revisionId,
+                        workId: stage.work.workId,
+                    });
                 },
             });
-            conclude(stage, "done", null);
+            conclude(stage, result === "held" ? "pending" : "done", null);
         }
         catch (error) {
             if (controller.signal.aborted) {
@@ -92,6 +105,7 @@ export function createRunner(deps) {
         const controller = new AbortController();
         let release = () => { };
         const entry = {
+            work: stage.work,
             projectId: stage.projectId,
             controller,
             settled: new Promise((resolve) => {
@@ -99,12 +113,12 @@ export function createRunner(deps) {
             }),
         };
         // Registered before the body runs: a tick arriving mid-start has to see it in flight.
-        inflight.set(stage.id, entry);
+        inflight.set(stage.work.workId, entry);
         retally();
         emitStage(stage, "running", null);
         void execute(stage, controller)
             .finally(() => {
-            inflight.delete(stage.id);
+            inflight.delete(stage.work.workId);
             release();
             try {
                 // Claim the next stage before reading the tally, so a hand-over never reports
@@ -136,17 +150,26 @@ export function createRunner(deps) {
     }
     function startEligible(projectId) {
         const stages = deps.stages.stagesOf(projectId);
-        const stateOf = (kind) => stages.find((stage) => stage.kind === kind)?.state ?? "pending";
+        const satisfiedKind = (kind) => {
+            const matches = stages.filter((stage) => stage.kind === kind);
+            return matches.length > 0 && matches.every((stage) => satisfied(stage.state));
+        };
         for (const stage of stages) {
-            if (stage.state !== "pending" || inflight.has(stage.id)) {
+            if (stage.state !== "pending" || inflight.has(stage.work.workId)) {
                 continue;
             }
             const dependencies = deps.stages.dependenciesOf?.(projectId, stage.kind) ?? graph[stage.kind];
-            if (!dependencies.every((kind) => satisfied(stateOf(kind)))) {
+            if (deps.stages.ready === undefined
+                ? !dependencies.every(satisfiedKind)
+                : !deps.stages.ready(stage.work)) {
                 continue;
             }
+            if (deps.stages.paused?.(projectId))
+                return;
+            if (deps.checkpoints && deps.checkpoints.beforeClaim(stage.work).kind !== "eligible")
+                continue;
             // Nothing is awaited here: the fan-out starts audio, images and thumbnail together.
-            if (deps.stages.claim(stage.id)) {
+            if (deps.stages.claim(stage.work)) {
                 start({ ...stage, state: "running" });
             }
         }
@@ -166,6 +189,7 @@ export function createRunner(deps) {
         }
     }
     return {
+        ...(deps.checkpoints === undefined ? {} : { checkpoints: deps.checkpoints }),
         tick,
         settled,
         hasInflight: (projectId) => [...inflight.values()].some((entry) => entry.projectId === projectId),