@software-dlc/cli 0.157.2

package/dist/local/app-contract-readers.d.ts

@@ -0,0 +1,229 @@
+import { type TaskModel } from './app-tasks-read.js';
+/**
+ * The local half of the shared pages' domain contracts (docs/specs/app-ui-contracts.md): sdlc
+ * viewer's tasks, issues and Releases reads under api/app/, answered in the shapes the hosted
+ * session routes answer (the shell's own reads are app-shell-readers.ts's). Every read
+ * goes through a reader that already exists, and nothing here writes or moves a store:
+ *
+ * - tasks: the Tasks board rows (core.js snapshotHeadless, run in its own process by the caller)
+ *   and one task's page (task-page-read.js, task_page.py);
+ * - issues: the local issue command (`issue list --all`, `issue show`);
+ * - releases: release_history.py, the Releases view's read of every Release and the candidate.
+ *
+ * A store a writer holds locked, or one that kept changing during the read, answers 503 with
+ * retry: the page may read again in a moment. Any other failure is said on the viewer's terminal and
+ * answered 500 with no detail, as the viewer's other routes do. Answers are kept briefly, and one
+ * read of each kind runs at a time; a failed read is not kept.
+ */
+/** One request under api/app/: its path segments after it, decoded and checked, and its query. */
+export type AppContractRoute = {
+    segments: string[];
+    query: URLSearchParams;
+};
+/** The answer: a status and the JSON body (the contract's data, or {error, retry?}). */
+export type AppContractAnswer = {
+    status: number;
+    body: unknown;
+};
+/** One engine command: its stdout, even when it exits non-zero with a JSON answer, or a rejection. */
+export type EngineRun = (script: string, args: string[]) => Promise<string>;
+/** task-page-read.js's answer for one task. */
+export type TaskPageAnswer = {
+    value?: Record<string, unknown>;
+    unknown?: string;
+    error?: string;
+    absent?: boolean;
+};
+export type AppContractReaderInput = {
+    /** The engine root whose commands run (the view code's own; checkout.ts engineLayout). */
+    engine: string;
+    /** The repository the engine reads. */
+    repo: string;
+    /**
+     * The Tasks board read (app-tasks-read.ts TaskBoardRead, or an older child's rows alone); it
+     * must not block this process.
+     */
+    boardRows: () => Promise<unknown>;
+    /** One task's page (task-page-read.js readTaskPage without links). */
+    taskPage: (id: string) => Promise<TaskPageAnswer>;
+    /** The viewer offers Done (POST api/task-done), so rows and holds the user's word closes say so. */
+    done?: boolean;
+    /** model.js's task search and row parts; absent, the model.js beside the engine's view code. */
+    model?: TaskModel;
+    run?: EngineRun;
+    now?: () => number;
+};
+/** The reader, and what drops its kept Tasks reads after a write (a Done) changed them. */
+export type AppContractReader = ((route: AppContractRoute) => Promise<AppContractAnswer>) & {
+    invalidate: () => void;
+};
+/** One workspace, one list and one workflow whose statuses are the board's groups, then Cancelled. */
+export declare function localTaskConfiguration(model: Pick<TaskModel, 'TASK_GROUPS'>): {
+    state: "active";
+    organization_id: string;
+    authorization_generation: null;
+    workspaces: {
+        id: string;
+        name: string;
+        is_default: boolean;
+        revision: number;
+        hierarchy_revision: number;
+        permission: "read";
+        lists: {
+            id: string;
+            name: string;
+            revision: number;
+            order_revision: number;
+            workflow_id: string;
+            default_status_id: string;
+            permission: "read";
+            offers: {
+                search: boolean;
+                archived: boolean;
+                assigned_to_me: boolean;
+                activity: boolean;
+                refresh_ms: number;
+            };
+        }[];
+        workflows: {
+            id: string;
+            name: string;
+            statuses: {
+                position: number;
+                revision: number;
+                id: string;
+                name: string;
+                category: "backlog" | "planned" | "in_progress" | "completed" | "canceled";
+            }[];
+        }[];
+        priorities: never[];
+    }[];
+};
+/** task_page.py's answer as the task's detail: its acceptance criteria are its checklist. */
+export declare function localTaskDetail(page: Record<string, unknown>): {
+    permission: "read";
+    task: {
+        id: string;
+        list_id: string;
+        workflow_id: string;
+        status_id: string;
+        priority_id: null;
+        title: string;
+        description: string | null;
+        primary_user_id: string | null;
+        parent_task_id: null;
+        revision: number;
+        created_at: string;
+        created_by: string;
+        archived_at: null;
+    };
+    contributors: never[];
+    checklist: {
+        id: string;
+        label: string;
+        position: number;
+        is_complete: boolean;
+        revision: number;
+    }[];
+    holds: never[];
+    claim: null;
+    acceptance: string[];
+    estimate: {
+        low: number;
+        high: number;
+    } | null;
+    release: string | null;
+    thread: string | null;
+};
+/** One local issue (a list row, or `issue show`'s whole issue) in the Maintain issue's shape. */
+export declare function localIssue(row: Record<string, unknown>): {
+    seen: string | null;
+    placement: string | null;
+    occurrences?: number | undefined;
+    id: string;
+    project_id: string;
+    title: string;
+    description: string;
+    external_reference: string | null;
+    status: string;
+    resolution_reason: string | null;
+    priority: null;
+    assignee_id: null;
+    assignee_username: string | null;
+    assignee_can_act: null;
+    created_by: string | null;
+    created_by_username: string | null;
+    revision: number;
+    created_at: string;
+    updated_at: string;
+    resolved_at: string | null;
+    closed_at: null;
+};
+/** A local issue's history as the Maintain issue's events. */
+export declare function localIssueEvents(history: unknown[]): {
+    id: number;
+    kind: string;
+    fields: never[];
+    from_status: null;
+    to_status: string | null;
+    resolution_reason: string | null;
+    priority: null;
+    assignee_id: null;
+    assignee_username: null;
+    actor_id: null;
+    actor_username: string | null;
+    created_at: string;
+    note: string;
+}[];
+/**
+ * One of release_history.py's Releases in the hosted Release's shape. Its version is its label (the
+ * app version, or its batch when it has no app section, so two Releases never share one); the
+ * previous Release is the next older one listed, given by the caller.
+ */
+export declare function localRelease(entry: Record<string, unknown>, previous: Record<string, unknown> | undefined): {
+    landings?: number | undefined;
+    id: string;
+    version: string;
+    computed_bump: string | null;
+    bump: string | null;
+    declared_reason: string | null;
+    declared_by_name: string | null;
+    source_judged: boolean;
+    marks_approximate: boolean;
+    written_by_name: null;
+    written_at: string;
+    previous_release_id: string | null;
+    breaking: boolean;
+    commit: string | null;
+};
+/**
+ * release_history.py's candidate as the hosted candidate. Its previous Release is the newest one
+ * listed, given by the caller and named by its label as the list names it (the candidate's own
+ * `previous` is that Release's app version, which a Release with no app section shares).
+ */
+export declare function localCandidate(entry: Record<string, unknown>, newest: Record<string, unknown> | undefined): {
+    head_commit_id: string;
+    previous_release: {
+        id: string;
+        version: string;
+    } | null;
+    next_version: string;
+    version: string;
+    commits_since: number | null;
+    classification: {
+        bump: "patch" | "minor" | "major";
+        marks_approximate: boolean;
+    } | null;
+    changes: {
+        node_id: string;
+        node_type: string;
+        label: string;
+        change: string;
+        bump: null;
+        why: string | null;
+        modeling_only: boolean;
+    }[];
+};
+/** The read behind sdlc viewer's api/app/ routes. */
+export declare function appContractReader(input: AppContractReaderInput): AppContractReader;
+//# sourceMappingURL=app-contract-readers.d.ts.map

package/dist/local/app-contract-readers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-contract-readers.d.ts","sourceRoot":"","sources":["../../src/local/app-contract-readers.ts"],"names":[],"mappings":"AAKA,OAAO,EASL,KAAK,SAAS,EACf,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;;;;;GAeG;AAEH,kGAAkG;AAClG,MAAM,MAAM,gBAAgB,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,KAAK,EAAE,eAAe,CAAA;CAAE,CAAC;AAE9E,wFAAwF;AACxF,MAAM,MAAM,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAElE,sGAAsG;AACtG,MAAM,MAAM,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAE5E,+CAA+C;AAC/C,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,0FAA0F;IAC1F,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,SAAS,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAClC,sEAAsE;IACtE,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC;IAClD,oGAAoG;IACpG,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,gGAAgG;IAChG,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB,GAAG,CAAC,EAAE,SAAS,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB,CAAC;AAEF,2FAA2F;AAC3F,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC,iBAAiB,CAAC,CAAC,GAAG;IAAE,UAAU,EAAE,MAAM,IAAI,CAAA;CAAE,CAAC;AAiEvH,sGAAsG;AACtG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,aAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B3E;AAiBD,6FAA6F;AAC7F,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2D5D;AAID,iGAAiG;AACjG,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;EAmCtD;AAED,8DAA8D;AAC9D,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE;;;;;;;;;;;;;;IAsBlD;AAmBD;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;;;;;;;;;;;;;;;EAmBzG;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;;;;;;;;;;cAWlF,OAAO,GAAG,OAAO,GAAG,OAAO;;;;;;;;;;;;EAIlD;AAID,qDAAqD;AACrD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,sBAAsB,GAAG,iBAAiB,CAuJlF"}

package/dist/local/app-contract-readers.js

@@ -0,0 +1,450 @@
+import { execFile } from 'node:child_process';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { engineLayout } from '../checkout.js';
+import { LIST_ID, LOCAL_TASK_OFFERS, localTaskMembers, localTaskPage, localTaskStatuses, localWaitingOnYou, taskBoardRead } from './app-tasks-read.js';
+const ENGINE_TIMEOUT_MS = 120_000;
+/** How long an answer serves later requests, by what it reads. */
+const KEEP_MS = { board: 15_000, issues: 10_000, issue: 10_000, releases: 30_000, task: 10_000 };
+const ISSUE_ID = /^iss-\d+$/;
+// A store a writer holds: SQLite's own words, and core.js's when its snapshot could not settle.
+const BUSY = /database is (locked|busy)|SQLITE_BUSY|stayed locked or kept changing/;
+const LOCAL = 'local';
+const TRUE = new Set(['true', '1']);
+const ISSUE_STATUSES = new Set(['open', 'triaged', 'escalated', 'waiting_on_fix', 'resolved', 'closed']);
+const RESOLUTIONS = new Set(['fixed', 'works_as_intended', 'planned', 'duplicate', 'wont_fix', 'cannot_reproduce']);
+const BUMPS = new Set(['patch', 'minor', 'major']);
+class Refusal extends Error {
+    status;
+    reason;
+    constructor(status, message, reason) {
+        super(message);
+        this.status = status;
+        this.reason = reason;
+    }
+}
+const notFound = () => new Refusal(404, 'Not found.');
+function runEngine(repo) {
+    return (script, args) => new Promise((resolve, reject) => {
+        execFile('python3', [script, ...args], { cwd: repo, encoding: 'utf8', timeout: ENGINE_TIMEOUT_MS, maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+            // The engine prints {ok: false, error} and exits 1 for an answer it refuses.
+            if (!error || String(stdout).trim())
+                resolve(String(stdout));
+            else
+                reject(new Error(String(stderr).trim() || error.message));
+        });
+    });
+}
+const iso = (seconds) => typeof seconds === 'number' && Number.isFinite(seconds) ? new Date(seconds * 1000).toISOString() : null;
+const text = (value) => (typeof value === 'string' && value ? value : null);
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+const list = (value) => (Array.isArray(value) ? value : []);
+/** The engine's {ok, result} answer's result, or a throw with its error. */
+function result(stdout, what) {
+    let parsed;
+    try {
+        parsed = JSON.parse(stdout);
+    }
+    catch {
+        throw new Error(`${what} printed no JSON`);
+    }
+    const answer = record(parsed);
+    if (answer.ok !== true)
+        throw new Error(`${what}: ${String(answer.error ?? 'it did not answer')}`);
+    return record(answer.result);
+}
+// ---- Tasks -------------------------------------------------------------------------------------
+/** One workspace, one list and one workflow whose statuses are the board's groups, then Cancelled. */
+export function localTaskConfiguration(model) {
+    return {
+        state: 'active',
+        organization_id: LOCAL,
+        authorization_generation: null,
+        workspaces: [
+            {
+                id: LOCAL,
+                name: 'Local',
+                is_default: true,
+                revision: 0,
+                hierarchy_revision: 0,
+                permission: 'read',
+                lists: [
+                    {
+                        id: LIST_ID,
+                        name: 'Tasks',
+                        revision: 0,
+                        order_revision: 0,
+                        workflow_id: LOCAL,
+                        default_status_id: 'proposed',
+                        permission: 'read',
+                        offers: LOCAL_TASK_OFFERS
+                    }
+                ],
+                workflows: [{ id: LOCAL, name: 'Local', statuses: localTaskStatuses(model) }],
+                priorities: []
+            }
+        ]
+    };
+}
+/** The list's query: the local filters, refusing the hosted ones this host does not offer. */
+function taskQuery(query, model) {
+    if (query.get('state') === 'archived')
+        throw new Refusal(400, 'This checkout keeps no archived tasks.');
+    if (TRUE.has(query.get('assigned_to_me') ?? ''))
+        throw new Refusal(400, 'This checkout has no reader to assign tasks to.');
+    const group = query.get('group') || undefined;
+    if (group !== undefined && !model.TASK_GROUPS.some(([key]) => key === group))
+        throw new Refusal(400, 'Unknown group.');
+    return {
+        ...(query.get('search') ? { search: query.get('search') } : {}),
+        ...(query.has('owner') ? { owner: query.get('owner') } : {}),
+        ...(group ? { group } : {}),
+        urgent: TRUE.has(query.get('urgent') ?? ''),
+        over_estimate: TRUE.has(query.get('over_estimate') ?? '')
+    };
+}
+/** task_page.py's answer as the task's detail: its acceptance criteria are its checklist. */
+export function localTaskDetail(page) {
+    const id = String(page.task);
+    const held = record(page.record);
+    const registry = record(page.registry);
+    const execution = record(page.execution);
+    const lifecycle = text(held.lifecycle_state);
+    const outcome = text(held.outcome);
+    const status = lifecycle === 'finished'
+        ? outcome === 'cancelled'
+            ? 'canceled'
+            : 'completed'
+        : lifecycle === 'active'
+            ? 'in_progress'
+            : lifecycle === 'planned'
+                ? 'planned'
+                : registry.state === 'done'
+                    ? 'completed'
+                    : 'backlog';
+    const acceptance = list(held.acceptance).filter((a) => typeof a === 'string');
+    const met = lifecycle === 'finished' && outcome === 'complete';
+    const estimate = record(held.estimate);
+    const thread = text(execution.thread);
+    return {
+        permission: 'read',
+        task: {
+            id,
+            list_id: LIST_ID,
+            workflow_id: LOCAL,
+            status_id: status,
+            priority_id: null,
+            title: text(held.original_objective) ?? text(registry.description) ?? id,
+            description: text(held.evidence),
+            primary_user_id: thread,
+            parent_task_id: null,
+            revision: 0,
+            // A task the registry lists with no record has no time it was made.
+            created_at: iso(held.created_at) ?? '',
+            created_by: thread ?? LOCAL,
+            archived_at: null
+        },
+        contributors: [],
+        checklist: acceptance.map((label, position) => ({
+            id: `acceptance-${position + 1}`,
+            label,
+            position,
+            is_complete: met,
+            revision: 0
+        })),
+        holds: [],
+        claim: null,
+        acceptance,
+        estimate: typeof estimate.low === 'number' && typeof estimate.high === 'number'
+            ? { low: estimate.low, high: estimate.high }
+            : null,
+        release: text(held.release),
+        thread
+    };
+}
+// ---- Issues ------------------------------------------------------------------------------------
+/** One local issue (a list row, or `issue show`'s whole issue) in the Maintain issue's shape. */
+export function localIssue(row) {
+    const status = String(row.status ?? 'open');
+    const resolution = text(row.resolution);
+    const description = [text(row.actual), text(row.expected) && `Expected: ${text(row.expected)}`]
+        .filter(Boolean)
+        .join('\n\n');
+    const created = iso(row.created) ?? '';
+    return {
+        id: String(row.issue),
+        project_id: LOCAL,
+        title: String(row.title ?? ''),
+        description,
+        external_reference: text(row.key),
+        status: ISSUE_STATUSES.has(status) ? status : 'open',
+        resolution_reason: resolution && RESOLUTIONS.has(resolution) ? resolution : null,
+        priority: null,
+        assignee_id: null,
+        assignee_username: text(row.owner),
+        assignee_can_act: null,
+        created_by: text(row.reported_by) ?? text(row.reporter),
+        created_by_username: text(row.reporter),
+        revision: list(row.history).length,
+        created_at: created,
+        // The latest of its last sighting, its resolution and its history (a reopen, a merge, a triage):
+        // each is a change, not a sighting. A listed row carries no history, so it reads sightings only.
+        updated_at: [iso(row.last_seen), iso(row.resolved_at), ...list(row.history).map((entry) => iso(record(entry).at))].reduce((latest, at) => (at && at > latest ? at : latest), created),
+        resolved_at: iso(row.resolved_at),
+        closed_at: null,
+        ...(typeof row.occurrences === 'number' ? { occurrences: row.occurrences } : {}),
+        seen: text(row.seen),
+        placement: text(row.placement)
+    };
+}
+/** A local issue's history as the Maintain issue's events. */
+export function localIssueEvents(history) {
+    return history.map(record).map((entry, index) => {
+        const [key, value] = Object.entries(entry).find(([k]) => k !== 'at' && k !== 'actor') ?? ['changed', null];
+        const resolved = key === 'resolved';
+        const reopened = key === 'reopened';
+        const reason = resolved && typeof value === 'string' && RESOLUTIONS.has(value) ? value : null;
+        return {
+            id: index + 1,
+            kind: key === 'filed' ? 'created' : resolved || reopened ? 'transitioned' : 'updated',
+            fields: [],
+            from_status: null,
+            to_status: resolved ? 'resolved' : reopened ? 'open' : null,
+            resolution_reason: reason,
+            priority: null,
+            assignee_id: null,
+            assignee_username: null,
+            actor_id: null,
+            actor_username: text(entry.actor),
+            created_at: iso(entry.at) ?? '',
+            note: `${key.replace(/_/g, ' ')}${typeof value === 'string' ? `: ${value}` : ''}`
+        };
+    });
+}
+// ---- Releases ----------------------------------------------------------------------------------
+/** A Release's or the candidate's bump reasons as its change lines. */
+function releaseChanges(entry) {
+    return list(entry.reason_lines)
+        .map(record)
+        .map((line) => ({
+        node_id: String(line.node ?? ''),
+        node_type: String(line.type ?? ''),
+        label: String(line.label ?? ''),
+        change: String(line.change ?? ''),
+        bump: null,
+        why: text(line.why),
+        modeling_only: false
+    }));
+}
+/**
+ * One of release_history.py's Releases in the hosted Release's shape. Its version is its label (the
+ * app version, or its batch when it has no app section, so two Releases never share one); the
+ * previous Release is the next older one listed, given by the caller.
+ */
+export function localRelease(entry, previous) {
+    const override = record(entry.override);
+    const version = String(entry.version ?? entry.id);
+    return {
+        id: String(entry.id ?? version),
+        version,
+        computed_bump: text(entry.computed),
+        bump: text(entry.bump),
+        declared_reason: text(override.reason),
+        declared_by_name: text(override.by),
+        source_judged: entry.unjudged === 0,
+        marks_approximate: entry.lower_bound === true,
+        written_by_name: null,
+        written_at: iso(entry.released_at) ?? '',
+        previous_release_id: previous ? String(previous.id ?? previous.version) : null,
+        breaking: entry.bump === 'major',
+        commit: text(entry.commit),
+        ...(typeof entry.landings === 'number' ? { landings: entry.landings } : {})
+    };
+}
+/**
+ * release_history.py's candidate as the hosted candidate. Its previous Release is the newest one
+ * listed, given by the caller and named by its label as the list names it (the candidate's own
+ * `previous` is that Release's app version, which a Release with no app section shares).
+ */
+export function localCandidate(entry, newest) {
+    const bump = String(entry.bump ?? '');
+    const previous = newest ? localRelease(newest, undefined) : null;
+    const version = text(entry.app_version) ?? text(entry.version) ?? text(entry.previous) ?? '';
+    return {
+        head_commit_id: String(entry.commit ?? ''),
+        previous_release: previous ? { id: previous.id, version: previous.version } : null,
+        next_version: version,
+        version,
+        commits_since: typeof entry.commits === 'number' ? entry.commits : null,
+        classification: BUMPS.has(bump)
+            ? { bump: bump, marks_approximate: entry.lower_bound === true }
+            : null,
+        changes: releaseChanges(entry)
+    };
+}
+// ---- The reader --------------------------------------------------------------------------------
+/** The read behind sdlc viewer's api/app/ routes. */
+export function appContractReader(input) {
+    const run = input.run ?? runEngine(input.repo);
+    const now = input.now ?? Date.now;
+    const layout = engineLayout(input.engine);
+    const script = (name) => path.join(layout.scripts, name);
+    let loaded = input.model;
+    const model = () => (loaded ??= createRequire(import.meta.url)(path.join(layout.view, 'model.js')));
+    // One read per key at a time; an answer serves later requests for its time, a failure is not kept.
+    // A key forgotten while its read runs keeps that read's answer only for the requests already waiting.
+    const kept = new Map();
+    const reading = new Map();
+    let generation = 0;
+    const keep = (key, ms, read) => {
+        const held = kept.get(key);
+        if (held && held.until > now())
+            return Promise.resolve(held.value);
+        const running = reading.get(key);
+        if (running)
+            return running;
+        const started = now();
+        const born = generation;
+        const next = read()
+            .then((value) => {
+            if (born === generation)
+                kept.set(key, { until: started + ms, value });
+            return value;
+        })
+            .finally(() => {
+            if (reading.get(key) === next)
+                reading.delete(key);
+        });
+        reading.set(key, next);
+        return next;
+    };
+    const forget = () => {
+        generation += 1;
+        for (const key of [...kept.keys(), ...reading.keys()])
+            if (key === 'board' || key.startsWith('task:')) {
+                kept.delete(key);
+                reading.delete(key);
+            }
+    };
+    const board = async () => taskBoardRead(await keep('board', KEEP_MS.board, input.boardRows));
+    const done = input.done === true;
+    const engine = async (file, args) => result(await run(script(file), ['--repo', input.repo, ...args]), file);
+    const issues = () => keep('issues', KEEP_MS.issues, async () => list((await engine('issue', ['list', '--all'])).issues).map(record));
+    const history = () => keep('releases', KEEP_MS.releases, () => engine('release_history.py', []));
+    const releases = async () => list((await history()).releases)
+        .map(record)
+        .filter((entry) => !('error' in entry));
+    const answer = async (segments, query) => {
+        const [domain, ...rest] = segments;
+        const route = rest.join('/');
+        if (domain === 'tasks') {
+            if (route === 'configuration')
+                return localTaskConfiguration(model());
+            if (rest.length === 3 && rest[0] === 'lists' && rest[2] === 'tasks') {
+                if (rest[1] !== LIST_ID)
+                    throw notFound();
+                const asked = taskQuery(query, model());
+                return localTaskPage(await board(), asked, model(), { done, now: now() });
+            }
+            if (route === 'waiting-on-you') {
+                const waiting = localWaitingOnYou(await board(), { done, now: now() });
+                // The board read is from before cli-view printed the user's queue.
+                if (!waiting)
+                    throw new Refusal(409, 'This viewer reads no Waiting on you; restart sdlc viewer.', 'view_outdated');
+                return waiting;
+            }
+            if (route === 'members')
+                return localTaskMembers(await board());
+            if (rest.length === 2 && rest[0] === 'tasks') {
+                const id = rest[1];
+                const page = await keep(`task:${id}`, KEEP_MS.task, async () => {
+                    const read = await input.taskPage(id);
+                    if (read.error)
+                        throw new Error(read.error);
+                    return read;
+                });
+                if (!page.value)
+                    throw notFound();
+                return localTaskDetail(page.value);
+            }
+        }
+        if (domain === 'issues') {
+            if (!route) {
+                const status = query.get('status');
+                if (status !== null && !ISSUE_STATUSES.has(status))
+                    throw new Refusal(400, 'Unknown status.');
+                const limit = Math.min(Math.max(Number(query.get('limit') ?? 100) || 100, 1), 500);
+                const offset = Math.max(Number(query.get('offset') ?? 0) || 0, 0);
+                const rows = (await issues())
+                    .map(localIssue)
+                    .filter((issue) => status === null || issue.status === status)
+                    .sort((a, b) => b.created_at.localeCompare(a.created_at));
+                return { issues: rows.slice(offset, offset + limit), total: rows.length };
+            }
+            if (rest.length === 1) {
+                const id = rest[0];
+                if (!ISSUE_ID.test(id))
+                    throw notFound();
+                const shown = await keep(`issue:${id}`, KEEP_MS.issue, async () => {
+                    try {
+                        return await engine('issue', ['show', id]);
+                    }
+                    catch (error) {
+                        if (/unknown issue/.test(String(error.message)))
+                            throw notFound();
+                        throw error;
+                    }
+                });
+                return { issue: localIssue(shown), events: localIssueEvents(list(shown.history)) };
+            }
+        }
+        if (domain === 'releases') {
+            if (!route) {
+                return {
+                    release_branch: null,
+                    releases: (await releases()).map((entry, index, all) => localRelease(entry, all[index + 1])),
+                    next_before: null,
+                    can_write: false
+                };
+            }
+            if (route === 'candidate') {
+                const candidate = (await history()).candidate;
+                if (candidate === null || candidate === undefined)
+                    return { candidate: null };
+                const entry = record(candidate);
+                if (typeof entry.error === 'string')
+                    throw new Error(`the candidate cannot be described: ${entry.error}`);
+                return { candidate: localCandidate(entry, (await releases())[0]) };
+            }
+            if (rest.length === 1) {
+                const version = rest[0];
+                const all = await releases();
+                const index = all.findIndex((entry) => entry.id === version || entry.version === version);
+                if (index < 0)
+                    throw notFound();
+                const found = all[index];
+                return { release: { ...localRelease(found, all[index + 1]), changes: releaseChanges(found) } };
+            }
+        }
+        throw notFound();
+    };
+    const reader = async ({ segments, query }) => {
+        try {
+            return { status: 200, body: await answer(segments, query) };
+        }
+        catch (error) {
+            if (error instanceof Refusal)
+                return { status: error.status, body: { error: error.message, ...(error.reason ? { reason: error.reason } : {}) } };
+            const message = error instanceof Error ? error.message : String(error);
+            if (BUSY.test(message)) {
+                process.stderr.write(`sdlc viewer: ${segments.join('/')} was busy: ${message}\n`);
+                return { status: 503, body: { error: 'The local stores are busy; read again in a moment.', retry: true } };
+            }
+            // The detail (a path or a database error) stays on the viewer's terminal, not the page.
+            process.stderr.write(`sdlc viewer: ${segments.join('/')} failed: ${message}\n`);
+            return { status: 500, body: { error: 'The read failed; see the sdlc viewer terminal.' } };
+        }
+    };
+    return Object.assign(reader, { invalidate: forget });
+}
+//# sourceMappingURL=app-contract-readers.js.map