@rex0220/ksql-flownet 1.0.0

package/dist/orchestration/status.d.ts

@@ -0,0 +1,91 @@
+import type { NetworkRun, NodeAttempt, NodeState, RunInvocation } from "../domain/persistence-model.js";
+import type { NetworkLockStatus, NetworkLockStatusReader } from "../persistence/network-lock-reader.js";
+import type { StatusReadRepository } from "../persistence/repository.js";
+import { type RunActivity } from "./run-activity.js";
+export { deriveRunActivity, type ActivityInput, type RunActivity, } from "./run-activity.js";
+export interface StatusInput {
+    readonly networkId: string;
+    readonly profile: string;
+    readonly runId?: string;
+    readonly businessKey?: string;
+}
+export interface StatusDependencies {
+    readonly repository: StatusReadRepository;
+    readonly lockReader: NetworkLockStatusReader;
+    readonly now?: () => Date;
+}
+export interface StatusOutput {
+    readonly network_id: string;
+    readonly profile: string;
+    readonly lock: (NetworkLockStatus & {
+        readonly stale_candidate: boolean;
+    }) | null;
+    readonly runs: readonly RunStatusOutput[];
+}
+export interface RunSummaryOutput {
+    readonly run_id: string;
+    readonly business_key: string;
+    readonly status: NetworkRun["status"];
+    readonly resume_allowed: boolean;
+    readonly lifecycle_status: NetworkRun["lifecycle_status"];
+    readonly created_at: string;
+    readonly started_at: string | null;
+    readonly finished_at: string | null;
+    readonly updated_at: string;
+    readonly hold: {
+        readonly state: "REQUESTED" | "ACCEPTED";
+        readonly requested_by: string;
+        readonly requested_at: string;
+    } | null;
+    readonly activity?: RunActivity;
+}
+export interface RunStatusOutput extends RunSummaryOutput {
+    readonly invocations?: readonly InvocationOutput[];
+    readonly node_states?: readonly NodeStateOutput[];
+    readonly reconciliation?: {
+        readonly inconsistencies: readonly {
+            readonly code: string;
+            readonly node_id?: string;
+            readonly detail: string;
+            readonly attempt_ids?: readonly string[];
+        }[];
+    };
+    readonly recovery_identifiers?: {
+        readonly resolve_node: readonly {
+            readonly run_id: string;
+            readonly node_id: string;
+        }[];
+        readonly force_unlock_network: {
+            readonly network_id: string;
+            readonly profile: string;
+            readonly expected_owner_invocation_id: string;
+        } | null;
+        readonly run_network: {
+            readonly resume_run: string;
+        };
+    };
+}
+interface InvocationOutput {
+    readonly invocation_id: string;
+    readonly mode: RunInvocation["mode"];
+    readonly status: RunInvocation["status"];
+    readonly result_code: string;
+}
+interface AttemptSummaryOutput {
+    readonly node_attempt_id: string;
+    readonly attempt_no: number;
+    readonly status: NodeAttempt["status"];
+    readonly result_code: string;
+}
+interface NodeStateOutput {
+    readonly node_id: string;
+    readonly status: NodeState["status"];
+    readonly status_reason: string | null;
+    readonly idempotent: boolean;
+    readonly latest_attempt_no: number;
+    readonly active_attempt_id: string | null;
+    readonly latest_attempt: AttemptSummaryOutput | null;
+    readonly active_attempt: AttemptSummaryOutput | null;
+}
+export declare function inspectStatus(input: StatusInput, dependencies: StatusDependencies): Promise<StatusOutput>;
+//# sourceMappingURL=status.d.ts.map

package/dist/orchestration/status.js

@@ -0,0 +1,171 @@
+import { KINTONE_DATETIME_TRUNCATION_MS } from "../persistence/kintone/design-notes.js";
+import { RepositoryError } from "../persistence/repository.js";
+import { detectReconciliation } from "./reconciliation.js";
+import { deriveRunActivity } from "./run-activity.js";
+export { deriveRunActivity, } from "./run-activity.js";
+function summary(run, activity, cancelRequest) {
+    return {
+        run_id: run.run_id,
+        business_key: run.business_key,
+        status: run.status,
+        resume_allowed: run.resume_allowed,
+        lifecycle_status: run.lifecycle_status,
+        created_at: run.created_at,
+        started_at: run.started_at,
+        finished_at: run.finished_at,
+        updated_at: run.updated_at,
+        hold: cancelRequest !== null &&
+            (cancelRequest.value.state === "REQUESTED" ||
+                cancelRequest.value.state === "ACCEPTED")
+            ? {
+                state: cancelRequest.value.state,
+                requested_by: cancelRequest.value.requested_by,
+                requested_at: cancelRequest.value.requested_at,
+            }
+            : null,
+        ...(activity === null ? {} : { activity }),
+    };
+}
+function requireMatchingRun(run, input) {
+    if (run.value.network_id !== input.networkId ||
+        run.value.resolved_profile_snapshot.profile !== input.profile) {
+        throw new RepositoryError("RECORD_NOT_FOUND", "the selected Run does not belong to the requested network and profile");
+    }
+    return run;
+}
+async function detail(run, lock, repository, currentTime) {
+    const runId = run.value.run_id;
+    const [invocations, states, attempts, reconciliation, cancelRequest] = await Promise.all([
+        repository.getInvocations(runId),
+        repository.getNodeStates(runId),
+        repository.getAttempts(runId),
+        detectReconciliation(repository, runId),
+        repository.getCancelRequest(runId),
+    ]);
+    const attemptsById = new Map(attempts.map((attempt) => [attempt.value.node_attempt_id, attempt.value]));
+    const attemptsByNodeAndNumber = new Map(attempts.map((attempt) => [
+        `${attempt.value.node_id}\0${attempt.value.attempt_no}`,
+        attempt.value,
+    ]));
+    return {
+        ...summary(run.value, deriveRunActivity({
+            status: run.value.status,
+            startedAt: run.value.started_at,
+            invocationIds: invocations.map(({ value }) => value.invocation_id),
+            lock,
+            cancelState: cancelRequest?.value.state ?? null,
+            nowMs: currentTime,
+        }), cancelRequest),
+        invocations: invocations.map(({ value }) => ({
+            invocation_id: value.invocation_id,
+            mode: value.mode,
+            status: value.status,
+            result_code: value.result_code,
+        })),
+        node_states: states.map(({ value }) => {
+            const active = value.active_attempt_id === null
+                ? undefined
+                : attemptsById.get(value.active_attempt_id);
+            const latest = value.latest_attempt_no === 0
+                ? undefined
+                : attemptsByNodeAndNumber.get(`${value.node_id}\0${value.latest_attempt_no}`);
+            return {
+                node_id: value.node_id,
+                status: value.status,
+                status_reason: value.status_reason,
+                idempotent: value.idempotent,
+                latest_attempt_no: value.latest_attempt_no,
+                active_attempt_id: value.active_attempt_id,
+                latest_attempt: latest === undefined ? null : attemptSummary(latest),
+                active_attempt: active === undefined ? null : attemptSummary(active),
+            };
+        }),
+        reconciliation: {
+            inconsistencies: reconciliation.inconsistencies.map((item) => ({
+                code: item.code,
+                ...(item.nodeId === undefined ? {} : { node_id: item.nodeId }),
+                detail: item.detail,
+                ...(item.attemptIds === undefined
+                    ? {}
+                    : { attempt_ids: item.attemptIds }),
+            })),
+        },
+        recovery_identifiers: {
+            resolve_node: states
+                .filter(({ value }) => value.status === "UNKNOWN" ||
+                (value.status === "FAILED" && !value.idempotent))
+                .map(({ value }) => ({ run_id: runId, node_id: value.node_id })),
+            force_unlock_network: lock === null
+                ? null
+                : {
+                    network_id: run.value.network_id,
+                    profile: run.value.resolved_profile_snapshot.profile,
+                    expected_owner_invocation_id: lock.owner_invocation_id,
+                },
+            run_network: { resume_run: runId },
+        },
+    };
+}
+function attemptSummary(attempt) {
+    return {
+        node_attempt_id: attempt.node_attempt_id,
+        attempt_no: attempt.attempt_no,
+        status: attempt.status,
+        result_code: attempt.result_code,
+    };
+}
+export async function inspectStatus(input, dependencies) {
+    const currentTime = (dependencies.now ?? (() => new Date()))().getTime();
+    const lockValue = await dependencies.lockReader.getNetworkLock(input.profile, input.networkId);
+    const lock = lockValue === null
+        ? null
+        : {
+            record_id: lockValue.record_id,
+            owner_invocation_id: lockValue.owner_invocation_id,
+            owner_instance_id: lockValue.owner_instance_id,
+            heartbeat_at: lockValue.heartbeat_at,
+            lease_expires_at: lockValue.lease_expires_at,
+            // The persisted lease expiry may be truncated by up to 59 seconds, so add the upper bound before marking it stale.
+            stale_candidate: currentTime >
+                Date.parse(lockValue.lease_expires_at) +
+                    KINTONE_DATETIME_TRUNCATION_MS,
+            revision: lockValue.revision,
+        };
+    if (input.runId !== undefined || input.businessKey !== undefined) {
+        const found = input.runId !== undefined
+            ? await dependencies.repository.getRun(input.runId)
+            : await dependencies.repository.getRunByBusinessKey(input.profile, input.networkId, input.businessKey);
+        if (found === null) {
+            throw new RepositoryError("RECORD_NOT_FOUND", "Run was not found");
+        }
+        const run = requireMatchingRun(found, input);
+        return {
+            network_id: input.networkId,
+            profile: input.profile,
+            lock,
+            runs: [await detail(run, lock, dependencies.repository, currentTime)],
+        };
+    }
+    const runs = await dependencies.repository.listRuns(input.profile, input.networkId);
+    const summaries = await Promise.all(runs.map(async (run) => {
+        const [invocations, cancelRequest] = await Promise.all([
+            dependencies.repository.getInvocations(run.value.run_id),
+            dependencies.repository.getCancelRequest(run.value.run_id),
+        ]);
+        return summary(run.value, deriveRunActivity({
+            status: run.value.status,
+            startedAt: run.value.started_at,
+            invocationIds: invocations.map(({ value }) => value.invocation_id),
+            lock,
+            cancelState: cancelRequest?.value.state ?? null,
+            nowMs: currentTime,
+        }), cancelRequest);
+    }));
+    return {
+        network_id: input.networkId,
+        profile: input.profile,
+        lock,
+        runs: summaries,
+    };
+}
+//# sourceMappingURL=status.js.map

package/dist/persistence/in-memory-repository.d.ts

@@ -0,0 +1,41 @@
+import type { AttemptResolution, CancelRequest, NetworkRun, NodeAttempt, NodeState, OperationAudit, RunInvocation } from "../domain/persistence-model.js";
+import type { AttemptExecutionStart, AttemptInputBaselineWrite, AttemptFinalization, CreateAttemptInput, Inconsistency, InvocationFinalization, NodeStateWrite, PersistenceRepository, RunAggregateUpdate, Versioned } from "./repository.js";
+/** A deterministic component-test fake. It intentionally models unique keys and revisions. */
+export declare class InMemoryPersistenceRepository implements PersistenceRepository {
+    private readonly runs;
+    private readonly runKeys;
+    private readonly invocations;
+    private readonly cancelRequests;
+    private readonly states;
+    private readonly attempts;
+    private readonly attemptIds;
+    private readonly resolutions;
+    private readonly operationAudits;
+    createRun(run: NetworkRun): Promise<Versioned<NetworkRun>>;
+    getRunByBusinessKey(profile: string, networkId: string, businessKey: string): Promise<Versioned<NetworkRun> | null>;
+    getRun(runId: string): Promise<Versioned<NetworkRun>>;
+    listRuns(profile: string, networkId: string): Promise<Versioned<NetworkRun>[]>;
+    getCancelRequest(runId: string): Promise<Versioned<CancelRequest> | null>;
+    createCancelRequest(request: CancelRequest): Promise<Versioned<CancelRequest>>;
+    updateCancelRequest(runId: string, expectedRevision: number, request: CancelRequest): Promise<Versioned<CancelRequest>>;
+    updateRunAggregate(runId: string, expectedRevision: number, update: RunAggregateUpdate): Promise<Versioned<NetworkRun>>;
+    archiveRun(runId: string, expectedRevision: number, at: string): Promise<Versioned<NetworkRun>>;
+    createInvocation(invocation: RunInvocation): Promise<Versioned<RunInvocation>>;
+    getInvocations(runId: string): Promise<Versioned<RunInvocation>[]>;
+    finalizeInvocation(invocationId: string, expectedRevision: number, finalization: InvocationFinalization): Promise<Versioned<RunInvocation>>;
+    getNodeStates(runId: string): Promise<Versioned<NodeState>[]>;
+    getAttempts(runId: string): Promise<Versioned<NodeAttempt>[]>;
+    getResolutions(runId: string): Promise<Versioned<AttemptResolution>[]>;
+    upsertNodeState(write: NodeStateWrite): Promise<Versioned<NodeState>>;
+    createAttempt(input: CreateAttemptInput): Promise<Versioned<NodeAttempt>>;
+    setAttemptExecutionStarted(attemptId: string, expectedRevision: number, start: AttemptExecutionStart): Promise<Versioned<NodeAttempt>>;
+    setAttemptInputBaseline(attemptId: string, expectedRevision: number, write: AttemptInputBaselineWrite): Promise<Versioned<NodeAttempt>>;
+    finalizeAttempt(attemptId: string, expectedRevision: number, finalization: AttemptFinalization): Promise<Versioned<NodeAttempt>>;
+    appendResolution(resolution: AttemptResolution): Promise<Versioned<AttemptResolution>>;
+    appendOperationAudit(audit: OperationAudit): Promise<Versioned<OperationAudit>>;
+    getOperationAuditByEventId(eventId: string): Promise<Versioned<OperationAudit> | null>;
+    listInconsistencies(runId: string): Promise<Inconsistency[]>;
+    private required;
+    private attemptById;
+}
+//# sourceMappingURL=in-memory-repository.d.ts.map

package/dist/persistence/in-memory-repository.js

@@ -0,0 +1,333 @@
+import { attemptKey, runKey } from "../domain/canonical-record-key.js";
+import { RepositoryError } from "./repository.js";
+import { isAllowedNodeStateTransition, isAllowedResolutionTransition, } from "./state-transition.js";
+function copy(stored) {
+    return structuredClone(stored);
+}
+function next(stored, value) {
+    stored.value = structuredClone(value);
+    stored.revision += 1;
+    return copy(stored);
+}
+function assertRevision(stored, expected) {
+    if (stored.revision !== expected) {
+        throw new RepositoryError("REVISION_CONFLICT", `expected revision ${expected}, actual ${stored.revision}`);
+    }
+}
+function isAllowedCancelTransition(from, to) {
+    return ((from === "REQUESTED" && (to === "ACCEPTED" || to === "RELEASED")) ||
+        (from === "ACCEPTED" && to === "RELEASED") ||
+        (from === "RELEASED" && to === "REQUESTED"));
+}
+/** A deterministic component-test fake. It intentionally models unique keys and revisions. */
+export class InMemoryPersistenceRepository {
+    runs = new Map();
+    runKeys = new Map();
+    invocations = new Map();
+    cancelRequests = new Map();
+    states = new Map();
+    attempts = new Map();
+    attemptIds = new Map();
+    resolutions = [];
+    operationAudits = [];
+    async createRun(run) {
+        const key = runKey(run.resolved_profile_snapshot.profile, run.network_id, run.business_key);
+        if (this.runs.has(run.run_id)) {
+            throw new RepositoryError("DUPLICATE_RECORD", `run ${run.run_id} exists`);
+        }
+        if (this.runKeys.has(key)) {
+            throw new RepositoryError("DUPLICATE_RECORD", "profile/network/business key already exists");
+        }
+        const stored = { value: structuredClone(run), revision: 1 };
+        this.runs.set(run.run_id, stored);
+        this.runKeys.set(key, run.run_id);
+        return copy(stored);
+    }
+    async getRunByBusinessKey(profile, networkId, businessKey) {
+        const runId = this.runKeys.get(runKey(profile, networkId, businessKey));
+        return runId ? copy(this.required(this.runs, runId, "run")) : null;
+    }
+    async getRun(runId) {
+        return copy(this.required(this.runs, runId, "run"));
+    }
+    async listRuns(profile, networkId) {
+        return [...this.runs.values()]
+            .filter(({ value }) => value.resolved_profile_snapshot.profile === profile &&
+            value.network_id === networkId)
+            .map(copy)
+            .sort((left, right) => left.value.run_id.localeCompare(right.value.run_id));
+    }
+    async getCancelRequest(runId) {
+        const stored = this.cancelRequests.get(runId);
+        return stored === undefined ? null : copy(stored);
+    }
+    async createCancelRequest(request) {
+        if (this.cancelRequests.has(request.run_id))
+            throw new RepositoryError("DUPLICATE_RECORD", "cancel request exists");
+        if (request.state !== "REQUESTED")
+            throw new RepositoryError("INVALID_STATE_TRANSITION", "a new cancel request must be REQUESTED");
+        const stored = { value: structuredClone(request), revision: 1 };
+        this.cancelRequests.set(request.run_id, stored);
+        return copy(stored);
+    }
+    async updateCancelRequest(runId, expectedRevision, request) {
+        const stored = this.required(this.cancelRequests, runId, "cancel request");
+        assertRevision(stored, expectedRevision);
+        if (request.run_id !== runId ||
+            !isAllowedCancelTransition(stored.value.state, request.state))
+            throw new RepositoryError("INVALID_STATE_TRANSITION", `${stored.value.state} -> ${request.state} is not allowed`);
+        return next(stored, request);
+    }
+    async updateRunAggregate(runId, expectedRevision, update) {
+        const stored = this.required(this.runs, runId, "run");
+        assertRevision(stored, expectedRevision);
+        return next(stored, { ...stored.value, ...update });
+    }
+    async archiveRun(runId, expectedRevision, at) {
+        const stored = this.required(this.runs, runId, "run");
+        assertRevision(stored, expectedRevision);
+        return next(stored, {
+            ...stored.value,
+            lifecycle_status: "ARCHIVED",
+            updated_at: at,
+        });
+    }
+    async createInvocation(invocation) {
+        if (this.invocations.has(invocation.invocation_id)) {
+            throw new RepositoryError("DUPLICATE_RECORD", "invocation exists");
+        }
+        const stored = { value: structuredClone(invocation), revision: 1 };
+        this.invocations.set(invocation.invocation_id, stored);
+        return copy(stored);
+    }
+    async getInvocations(runId) {
+        // 実機の$id順に合わせ、挿入順を保持する(started_atは分精度のため順序に使わない)
+        return [...this.invocations.values()]
+            .filter(({ value }) => value.run_id === runId)
+            .map(copy);
+    }
+    async finalizeInvocation(invocationId, expectedRevision, finalization) {
+        const stored = this.required(this.invocations, invocationId, "invocation");
+        assertRevision(stored, expectedRevision);
+        const currentStatus = stored.value.status;
+        if (currentStatus !== "RUNNING" && currentStatus !== "CREATED") {
+            throw new RepositoryError("INVALID_STATE_TRANSITION", "only an unterminated invocation can be finalized");
+        }
+        const value = {
+            ...stored.value,
+            status: finalization.status,
+            result_code: finalization.result_code,
+            finished_at: finalization.finished_at,
+            selected_node_ids: finalization.selected_node_ids === undefined
+                ? stored.value.selected_node_ids
+                : [...finalization.selected_node_ids],
+            preserved_node_ids: finalization.preserved_node_ids === undefined
+                ? stored.value.preserved_node_ids
+                : [...finalization.preserved_node_ids],
+            blocked_node_ids: finalization.blocked_node_ids === undefined
+                ? stored.value.blocked_node_ids
+                : [...finalization.blocked_node_ids],
+            reason: finalization.reason ?? stored.value.reason,
+        };
+        return next(stored, value);
+    }
+    async getNodeStates(runId) {
+        return [...this.states.values()]
+            .filter(({ value }) => value.run_id === runId)
+            .map(copy)
+            .sort((a, b) => a.value.node_id.localeCompare(b.value.node_id));
+    }
+    async getAttempts(runId) {
+        return [...this.attempts.values()]
+            .filter(({ value }) => value.run_id === runId)
+            .map(copy)
+            .sort((a, b) => a.value.attempt_no - b.value.attempt_no);
+    }
+    async getResolutions(runId) {
+        const attemptIds = new Set((await this.getAttempts(runId)).map(({ value }) => value.node_attempt_id));
+        return this.resolutions
+            .filter(({ value }) => attemptIds.has(value.attempt_id))
+            .map(copy);
+    }
+    async upsertNodeState(write) {
+        const key = write.value.node_state_key;
+        const stored = this.states.get(key);
+        if (!stored) {
+            if (write.expected_revision !== null) {
+                throw new RepositoryError("RECORD_NOT_FOUND", "node state not found");
+            }
+            if (write.value.status !== "WAITING") {
+                throw new RepositoryError("INVALID_STATE_TRANSITION", "a new node state must be WAITING");
+            }
+            const created = {
+                value: structuredClone({ ...write.value, revision: 1 }),
+                revision: 1,
+            };
+            this.states.set(key, created);
+            return copy(created);
+        }
+        if (write.expected_revision === null) {
+            throw new RepositoryError("DUPLICATE_RECORD", "node state exists");
+        }
+        assertRevision(stored, write.expected_revision);
+        if (write.resolution_event !== undefined &&
+            !this.resolutions.some(({ value }) => value.event_type === write.resolution_event?.event_type &&
+                value.attempt_id === write.resolution_event?.attempt_id &&
+                value.resolved_outcome === write.resolution_event?.resolved_outcome &&
+                value.resolved_at === write.resolution_event?.resolved_at)) {
+            throw new RepositoryError("RECORD_NOT_FOUND", "the correlated Attempt Resolution is not durable");
+        }
+        const resolutionTransition = write.resolution_event !== undefined &&
+            write.resolution_event.resolved_outcome === write.value.status &&
+            isAllowedResolutionTransition(stored.value.status, write.value.status);
+        if (!isAllowedNodeStateTransition(stored.value.status, write.value.status) &&
+            !resolutionTransition) {
+            throw new RepositoryError("INVALID_STATE_TRANSITION", `${stored.value.status} -> ${write.value.status} is not allowed`);
+        }
+        if ((stored.value.status === "FAILED" ||
+            stored.value.status === "CANCELLED") &&
+            write.value.status === "WAITING" &&
+            !stored.value.idempotent) {
+            throw new RepositoryError("INVALID_STATE_TRANSITION", "a non-idempotent failed/cancelled node cannot resume automatically");
+        }
+        const revision = stored.revision + 1;
+        return next(stored, { ...structuredClone(write.value), revision });
+    }
+    async createAttempt(input) {
+        const { value: state, revision } = input.node_state;
+        const attemptNo = state.latest_attempt_no + 1;
+        const key = attemptKey(state.run_id, state.node_id, attemptNo);
+        const existing = this.attempts.get(key);
+        if (existing) {
+            if (existing.value.node_attempt_id === input.node_attempt_id) {
+                return copy(existing);
+            }
+            throw new RepositoryError("ATTEMPT_NUMBER_CONFLICT", `attempt number ${attemptNo} was already allocated`);
+        }
+        if (this.attemptIds.has(input.node_attempt_id)) {
+            throw new RepositoryError("DUPLICATE_RECORD", "attempt id exists");
+        }
+        const attempt = {
+            node_attempt_id: input.node_attempt_id,
+            attempt_key: key,
+            run_id: state.run_id,
+            node_id: state.node_id,
+            job_id: state.job_id,
+            invocation_id: input.invocation_id,
+            attempt_no: attemptNo,
+            status: "RUNNING",
+            result_code: "PENDING",
+            execution_started_at: null,
+            runner_execution_started_at: null,
+            execution_id: null,
+            finished_at: null,
+            duration_sec: null,
+            error_message: null,
+            read_count: 0,
+            written_count: 0,
+            last_successful_chunk_no: null,
+            last_written_key: null,
+            state_revision_before: revision,
+        };
+        const stored = { value: attempt, revision: 1 };
+        this.attempts.set(key, stored);
+        this.attemptIds.set(input.node_attempt_id, key);
+        return copy(stored);
+    }
+    async setAttemptExecutionStarted(attemptId, expectedRevision, start) {
+        const stored = this.attemptById(attemptId);
+        assertRevision(stored, expectedRevision);
+        if (stored.value.status !== "RUNNING") {
+            throw new RepositoryError("ATTEMPT_TERMINAL", "attempt is terminal");
+        }
+        if (stored.value.execution_started_at !== null) {
+            throw new RepositoryError("ATTEMPT_LIFECYCLE_VIOLATION", "execution_started_at is already set");
+        }
+        return next(stored, { ...stored.value, ...start });
+    }
+    async setAttemptInputBaseline(attemptId, expectedRevision, write) {
+        const stored = this.attemptById(attemptId);
+        assertRevision(stored, expectedRevision);
+        if (stored.value.status !== "RUNNING" ||
+            stored.value.execution_started_at !== null)
+            throw new RepositoryError("ATTEMPT_LIFECYCLE_VIOLATION", "input baseline must be recorded before execution starts");
+        return next(stored, {
+            ...stored.value,
+            error_message: write.error_message,
+        });
+    }
+    async finalizeAttempt(attemptId, expectedRevision, finalization) {
+        const stored = this.attemptById(attemptId);
+        assertRevision(stored, expectedRevision);
+        if (stored.value.status !== "RUNNING") {
+            throw new RepositoryError("ATTEMPT_TERMINAL", "attempt is terminal");
+        }
+        return next(stored, { ...stored.value, ...finalization });
+    }
+    async appendResolution(resolution) {
+        const attempt = this.attemptById(resolution.attempt_id);
+        if (attempt.value.status !== "UNKNOWN" &&
+            attempt.value.status !== "FAILED") {
+            throw new RepositoryError("ATTEMPT_LIFECYCLE_VIOLATION", "only UNKNOWN or FAILED attempts can be resolved");
+        }
+        const stored = { value: structuredClone(resolution), revision: 1 };
+        this.resolutions.push(stored);
+        return copy(stored);
+    }
+    async appendOperationAudit(audit) {
+        if (this.operationAudits.some(({ value }) => value.event_id === audit.event_id))
+            throw new RepositoryError("DUPLICATE_RECORD", "operation audit exists");
+        const stored = { value: structuredClone(audit), revision: 1 };
+        this.operationAudits.push(stored);
+        return copy(stored);
+    }
+    async getOperationAuditByEventId(eventId) {
+        const stored = this.operationAudits.find(({ value }) => value.event_id === eventId);
+        return stored === undefined ? null : copy(stored);
+    }
+    async listInconsistencies(runId) {
+        const result = [];
+        for (const state of await this.getNodeStates(runId)) {
+            const attempts = [...this.attempts.values()]
+                .filter(({ value }) => value.run_id === runId && value.node_id === state.value.node_id)
+                .map(copy);
+            const running = attempts.filter(({ value }) => value.status === "RUNNING");
+            if (running.length > 1) {
+                result.push({
+                    code: "MULTIPLE_RUNNING_ATTEMPTS",
+                    node_state: state,
+                    attempts: running,
+                });
+            }
+            if (state.value.active_attempt_id) {
+                const active = attempts.find(({ value }) => value.node_attempt_id === state.value.active_attempt_id);
+                if (!active) {
+                    result.push({ code: "ACTIVE_ATTEMPT_MISSING", node_state: state });
+                }
+                else if (active.value.status !== state.value.status) {
+                    result.push({
+                        code: "STATE_ATTEMPT_STATUS_MISMATCH",
+                        node_state: state,
+                        attempt: active,
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    required(map, key, label) {
+        const stored = map.get(key);
+        if (!stored) {
+            throw new RepositoryError("RECORD_NOT_FOUND", `${label} not found`);
+        }
+        return stored;
+    }
+    attemptById(attemptId) {
+        const key = this.attemptIds.get(attemptId);
+        if (!key) {
+            throw new RepositoryError("RECORD_NOT_FOUND", "attempt not found");
+        }
+        return this.required(this.attempts, key, "attempt");
+    }
+}
+//# sourceMappingURL=in-memory-repository.js.map

package/dist/persistence/kintone/client.d.ts

@@ -0,0 +1,36 @@
+export interface KintoneClientConfig {
+    baseUrl: string;
+    appId: number;
+    apiToken: string;
+    fetch?: typeof fetch;
+}
+export type KintoneFieldValue = {
+    value: unknown;
+};
+export type KintoneRecord = Record<string, KintoneFieldValue>;
+export declare class KintoneApiError extends Error {
+    readonly status: number;
+    readonly apiCode: string | null;
+    readonly responseBody: unknown;
+    constructor(status: number, apiCode: string | null, responseBody: unknown);
+}
+export declare class KintoneTransportError extends Error {
+    readonly causeDetail: unknown;
+    constructor(causeDetail: unknown);
+}
+export declare class KintoneClient {
+    private readonly baseUrl;
+    private readonly appId;
+    private readonly apiToken;
+    private readonly fetchImpl;
+    constructor(config: KintoneClientConfig);
+    getRecords(query: string): Promise<KintoneRecord[]>;
+    postRecord(record: KintoneRecord): Promise<{
+        id: string;
+        revision: number;
+    }>;
+    putRecord(recordKey: string, revision: number, record: KintoneRecord): Promise<number>;
+    putRecordById(id: string, revision: number, record: KintoneRecord): Promise<number>;
+    private request;
+}
+//# sourceMappingURL=client.d.ts.map