@rex0220/ksql-flownet 1.0.0

package/dist/requests/request-model.js

@@ -0,0 +1,305 @@
+export const REQUEST_TYPES = [
+    "RERUN",
+    "STOP",
+    "RELEASE",
+    "START",
+    "CLOSE",
+];
+export const REQUEST_STATES = [
+    "REQUESTED",
+    "ACCEPTED",
+    "DONE",
+    "REJECTED",
+    "CANCELLED",
+];
+export const REQUEST_VALUE_LIMITS = {
+    runId: 128,
+    networkId: 128,
+    businessKey: 128,
+    rerunFromNode: 128,
+    reason: 65_535,
+    creatorCode: 256,
+    claimedHost: 256,
+    resultCode: 128,
+    resultMessage: 65_535,
+};
+export class RequestValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(issues.map(({ code, field }) => `${field}:${code}`).join(", "));
+        this.name = "RequestValidationError";
+        this.issues = issues;
+    }
+}
+function rawValue(record, field) {
+    return record[field]?.value;
+}
+function stringValue(record, field) {
+    const value = rawValue(record, field);
+    if (typeof value !== "string") {
+        throw new RequestValidationError([
+            { code: "FIELD_TYPE_INVALID", field, message: "must be a string" },
+        ]);
+    }
+    return value;
+}
+function optionalString(record, field) {
+    const value = stringValue(record, field);
+    return value === "" ? null : value;
+}
+function additiveOptionalString(record, field) {
+    if (!Object.hasOwn(record, field))
+        return null;
+    return optionalString(record, field);
+}
+function creatorCode(record) {
+    const value = rawValue(record, "作成者");
+    if (typeof value !== "object" ||
+        value === null ||
+        !("code" in value) ||
+        typeof value.code !== "string") {
+        throw new RequestValidationError([
+            {
+                code: "CREATOR_INVALID",
+                field: "作成者",
+                message: "creator code is missing",
+            },
+        ]);
+    }
+    return value.code;
+}
+function cancelRequested(record) {
+    if (!Object.hasOwn(record, "cancel_requested"))
+        return false;
+    const value = rawValue(record, "cancel_requested");
+    if (!Array.isArray(value) ||
+        value.length > 1 ||
+        value.some((item) => item !== "取消")) {
+        throw new RequestValidationError([
+            {
+                code: "FIELD_TYPE_INVALID",
+                field: "cancel_requested",
+                message: 'must be [] or ["取消"]',
+            },
+        ]);
+    }
+    return value.length === 1;
+}
+function choice(value, allowed, field) {
+    if (!allowed.includes(value)) {
+        throw new RequestValidationError([
+            {
+                code: "UNKNOWN_CHOICE",
+                field,
+                message: `unsupported value: ${value}`,
+            },
+        ]);
+    }
+    return value;
+}
+function isIsoDateTime(value) {
+    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/.test(value)) {
+        return false;
+    }
+    const milliseconds = Date.parse(value);
+    if (Number.isNaN(milliseconds))
+        return false;
+    const canonical = new Date(milliseconds).toISOString();
+    return value === canonical || value === canonical.replace(".000Z", "Z");
+}
+function addLengthIssue(issues, field, value, maximum) {
+    if (value !== null && Array.from(value).length > maximum) {
+        issues.push({
+            code: "VALUE_TOO_LONG",
+            field,
+            message: `must be at most ${maximum} Unicode characters`,
+        });
+    }
+}
+export function validateRequestRecord(record) {
+    const issues = [];
+    if (!/^\d+$/.test(record.id)) {
+        issues.push({
+            code: "ID_INVALID",
+            field: "$id",
+            message: "must be decimal",
+        });
+    }
+    if (!Number.isSafeInteger(record.revision) || record.revision < 1) {
+        issues.push({
+            code: "REVISION_INVALID",
+            field: "$revision",
+            message: "must be a positive integer",
+        });
+    }
+    if (!isIsoDateTime(record.createdAt)) {
+        issues.push({
+            code: "DATETIME_INVALID",
+            field: "作成日時",
+            message: "must be an ISO UTC datetime",
+        });
+    }
+    if (record.requestType !== "START" && record.runId.trim() === "") {
+        issues.push({
+            code: "REQUIRED",
+            field: "run_id",
+            message: "must not be blank",
+        });
+    }
+    if (record.reason.trim() === "") {
+        issues.push({
+            code: "REQUIRED",
+            field: "reason",
+            message: "must not be blank",
+        });
+    }
+    if (record.creatorCode.trim() === "") {
+        issues.push({
+            code: "REQUIRED",
+            field: "作成者",
+            message: "must not be blank",
+        });
+    }
+    addLengthIssue(issues, "run_id", record.runId, REQUEST_VALUE_LIMITS.runId);
+    addLengthIssue(issues, "network_id", record.networkId, REQUEST_VALUE_LIMITS.networkId);
+    addLengthIssue(issues, "business_key", record.businessKey, REQUEST_VALUE_LIMITS.businessKey);
+    addLengthIssue(issues, "rerun_from_node", record.rerunFromNode, REQUEST_VALUE_LIMITS.rerunFromNode);
+    addLengthIssue(issues, "reason", record.reason, REQUEST_VALUE_LIMITS.reason);
+    addLengthIssue(issues, "作成者", record.creatorCode, REQUEST_VALUE_LIMITS.creatorCode);
+    addLengthIssue(issues, "claimed_host", record.claimedHost, REQUEST_VALUE_LIMITS.claimedHost);
+    addLengthIssue(issues, "result_code", record.resultCode, REQUEST_VALUE_LIMITS.resultCode);
+    addLengthIssue(issues, "result_message", record.resultMessage, REQUEST_VALUE_LIMITS.resultMessage);
+    if (record.requestType !== "RERUN" && record.rerunFromNode !== null) {
+        issues.push({
+            code: "FIELD_NOT_ALLOWED",
+            field: "rerun_from_node",
+            message: "is only allowed for RERUN",
+        });
+    }
+    const claimValues = [
+        record.claimedAt,
+        record.claimedHost,
+        record.claimHeartbeatAt,
+    ];
+    const claimCount = claimValues.filter((value) => value !== null).length;
+    if (claimCount !== 0 && claimCount !== claimValues.length) {
+        issues.push({
+            code: "CLAIM_FIELDS_INCOMPLETE",
+            field: "claimed_at",
+            message: "claim fields must be all empty or all populated",
+        });
+    }
+    if (record.claimedHost !== null && record.claimedHost.trim() === "") {
+        issues.push({
+            code: "REQUIRED",
+            field: "claimed_host",
+            message: "must not be blank when populated",
+        });
+    }
+    for (const [field, value] of [
+        ["claimed_at", record.claimedAt],
+        ["claim_heartbeat_at", record.claimHeartbeatAt],
+    ]) {
+        if (value !== null && !isIsoDateTime(value)) {
+            issues.push({
+                code: "DATETIME_INVALID",
+                field,
+                message: "must be ISO UTC",
+            });
+        }
+    }
+    const hasResult = record.resultCode !== null || record.resultMessage !== null;
+    if (record.requestState === "REQUESTED") {
+        if (claimCount !== 0 || hasResult) {
+            issues.push({
+                code: "STATE_FIELDS_INVALID",
+                field: "request_state",
+                message: "REQUESTED must not contain machine-owned values",
+            });
+        }
+    }
+    else if (record.requestState === "ACCEPTED") {
+        if (claimCount !== claimValues.length || hasResult) {
+            issues.push({
+                code: "STATE_FIELDS_INVALID",
+                field: "request_state",
+                message: "ACCEPTED requires claim fields and no result",
+            });
+        }
+    }
+    else if (record.resultCode === null || record.resultCode.trim() === "") {
+        issues.push({
+            code: "RESULT_REQUIRED",
+            field: "result_code",
+            message: "terminal requests require a result code",
+        });
+    }
+    if (record.requestState === "CANCELLED" && claimCount !== 0) {
+        issues.push({
+            code: "STATE_FIELDS_INVALID",
+            field: "request_state",
+            message: `${record.requestState} must not contain claim fields`,
+        });
+    }
+    return issues;
+}
+export function parseRequestEnvelope(record) {
+    const revisionText = stringValue(record, "$revision");
+    let cancellation;
+    try {
+        cancellation = cancelRequested(record);
+    }
+    catch {
+        cancellation = "INVALID";
+    }
+    const envelope = {
+        id: stringValue(record, "$id"),
+        revision: Number(revisionText),
+        requestState: choice(stringValue(record, "request_state"), REQUEST_STATES, "request_state"),
+        cancelRequested: cancellation,
+    };
+    const issues = [];
+    if (!/^\d+$/.test(envelope.id))
+        issues.push({
+            code: "ID_INVALID",
+            field: "$id",
+            message: "must be decimal",
+        });
+    if (!Number.isSafeInteger(envelope.revision) || envelope.revision < 1)
+        issues.push({
+            code: "REVISION_INVALID",
+            field: "$revision",
+            message: "must be a positive integer",
+        });
+    if (issues.length > 0)
+        throw new RequestValidationError(issues);
+    return envelope;
+}
+export function parseRequestRecord(record) {
+    const revisionText = stringValue(record, "$revision");
+    const parsed = {
+        id: stringValue(record, "$id"),
+        revision: Number(revisionText),
+        creatorCode: creatorCode(record),
+        createdAt: stringValue(record, "作成日時"),
+        requestType: choice(stringValue(record, "request_type"), REQUEST_TYPES, "request_type"),
+        runId: stringValue(record, "run_id"),
+        networkId: additiveOptionalString(record, "network_id"),
+        businessKey: additiveOptionalString(record, "business_key"),
+        scheduledFor: additiveOptionalString(record, "scheduled_for"),
+        rerunFromNode: optionalString(record, "rerun_from_node"),
+        reason: stringValue(record, "reason"),
+        requestState: choice(stringValue(record, "request_state"), REQUEST_STATES, "request_state"),
+        cancelRequested: cancelRequested(record),
+        claimedAt: optionalString(record, "claimed_at"),
+        claimedHost: optionalString(record, "claimed_host"),
+        claimHeartbeatAt: optionalString(record, "claim_heartbeat_at"),
+        resultCode: optionalString(record, "result_code"),
+        resultMessage: optionalString(record, "result_message"),
+    };
+    const issues = validateRequestRecord(parsed);
+    if (issues.length > 0)
+        throw new RequestValidationError(issues);
+    return parsed;
+}
+//# sourceMappingURL=request-model.js.map

package/dist/requests/request-poller.d.ts

@@ -0,0 +1,33 @@
+import type { StatusOutput, RunStatusOutput } from "../orchestration/status.js";
+import { type FlownetChildClient } from "./flownet-child-client.js";
+import type { KintoneRequestStore, RequestResult } from "./kintone-request-store.js";
+import type { PollRequestsConfig, PollRequestsNetwork } from "./poll-requests-config.js";
+import type { RequestRecord } from "./request-model.js";
+export interface RequestPollerDependencies {
+    readonly store: Pick<KintoneRequestStore, "listRequested" | "listAccepted" | "rejectInvalid" | "cancelBeforeClaim" | "claim" | "heartbeat" | "getById" | "writeResult">;
+    readonly child: Pick<FlownetChildClient, "status" | "runNetwork" | "startNetwork" | "cancelRun" | "archiveRun">;
+    readonly config: PollRequestsConfig;
+    readonly host: string;
+    readonly now?: () => Date;
+    readonly wait?: (milliseconds: number) => Promise<void>;
+    readonly log?: (code: string, detail: string) => void;
+}
+export interface PollRequestsSummary {
+    readonly requested: number;
+    readonly claimed: number;
+    readonly completed: number;
+    readonly cancelled: number;
+    readonly invalid: number;
+    readonly skippedMalformed: number;
+    readonly stale: number;
+}
+interface ResolvedRun {
+    readonly network: PollRequestsNetwork;
+    readonly status: StatusOutput;
+    readonly run: RunStatusOutput;
+}
+export declare function pollRequests(dependencies: RequestPollerDependencies): Promise<PollRequestsSummary>;
+export declare function reviewRequest(request: Pick<RequestRecord, "requestType">, resolved: Pick<ResolvedRun, "status" | "run">, nowMs: number, leaseAllowanceMs: number): RequestResult | null;
+export declare function hasLiveOwner(status: StatusOutput, run: RunStatusOutput, nowMs: number, leaseAllowanceMs: number): boolean;
+export {};
+//# sourceMappingURL=request-poller.d.ts.map

package/dist/requests/request-poller.js

@@ -0,0 +1,353 @@
+import { requestedBy, } from "./flownet-child-client.js";
+import { classifyCancelResult, classifyArchiveRun, classifyRunNetworkResult, classifyStartNetworkResult, rejected, } from "./request-result.js";
+import { prepareStartRequest, startNetworkNotAllowed, } from "./start-request.js";
+export async function pollRequests(dependencies) {
+    const now = dependencies.now ?? (() => new Date());
+    const log = dependencies.log ?? (() => undefined);
+    const listed = await dependencies.store.listRequested();
+    // Establish the REQUESTED read boundary before performing any write. A failed
+    // primary GET must leave both requests and stale candidates untouched.
+    const stale = await recoverStale(dependencies, now, log);
+    if (listed.skipped > 0) {
+        log("REQUEST_RECORD_UNIDENTIFIABLE", `count=${listed.skipped}`);
+    }
+    let cancelled = 0;
+    for (const invalid of listed.invalid) {
+        if (invalid.cancelRequested === true) {
+            if (await cancelBeforeClaim(dependencies, invalid, log))
+                cancelled += 1;
+            continue;
+        }
+        await rejectInvalid(dependencies, invalid);
+    }
+    let claimedCount = 0;
+    let completed = 0;
+    for (const request of listed.valid) {
+        if (request.cancelRequested) {
+            if (await cancelBeforeClaim(dependencies, request, log))
+                cancelled += 1;
+            continue;
+        }
+        const claimed = await dependencies.store.claim(request, dependencies.host, now().toISOString());
+        if (claimed === null)
+            continue;
+        claimedCount += 1;
+        const result = await processClaimed(dependencies, claimed, now, log);
+        if (await finalizeResult(dependencies, result.request, result.result, log))
+            completed += 1;
+    }
+    return {
+        requested: listed.valid.length,
+        claimed: claimedCount,
+        completed,
+        cancelled,
+        invalid: listed.invalid.length,
+        skippedMalformed: listed.skipped,
+        stale,
+    };
+}
+async function cancelBeforeClaim(dependencies, request, log) {
+    const cancelled = await dependencies.store.cancelBeforeClaim(request, {
+        state: "CANCELLED",
+        code: "CANCELLED_BY_REQUESTER",
+        message: "requester cancelled before claim",
+    });
+    if (!cancelled)
+        log("CANCEL_FINALIZE_CONFLICT", `request_id=${request.id}`);
+    return cancelled;
+}
+async function finalizeResult(dependencies, request, result, log) {
+    let current;
+    try {
+        current = await dependencies.store.getById(request.id);
+    }
+    catch {
+        log("RESULT_FINALIZE_ABANDONED", `request_id=${request.id}`);
+        return false;
+    }
+    if (current?.requestState !== "ACCEPTED") {
+        log("RESULT_STATE_MISMATCH", `request_id=${request.id}`);
+        return false;
+    }
+    const finalized = current.cancelRequested
+        ? { ...result, message: `${result.message} (cancel_ignored)` }
+        : result;
+    try {
+        await dependencies.store.writeResult(current, finalized);
+        return true;
+    }
+    catch {
+        log("RESULT_FINALIZE_ABANDONED", `request_id=${request.id}`);
+        return false;
+    }
+}
+async function rejectInvalid(dependencies, invalid) {
+    const codes = [...new Set(invalid.issues.map(({ code }) => code))].sort();
+    await dependencies.store.rejectInvalid(invalid, {
+        state: "REJECTED",
+        code: "REQUEST_INVALID",
+        message: `request validation failed: ${codes.join(",")}`,
+    });
+}
+async function processClaimed(dependencies, claimed, now, log) {
+    if (claimed.requestType === "START") {
+        return processStart(dependencies, claimed, now, log);
+    }
+    try {
+        requestedBy(claimed);
+    }
+    catch {
+        return {
+            request: claimed,
+            result: rejected("REQUESTED_BY_INVALID", "Request creator correlation is invalid or too long"),
+        };
+    }
+    let resolved;
+    try {
+        const matches = await resolveRun(dependencies, claimed.runId);
+        if (matches.length === 0) {
+            return {
+                request: claimed,
+                result: rejected("RUN_NOT_FOUND", "Run was not found in the allowlist"),
+            };
+        }
+        if (matches.length > 1) {
+            return {
+                request: claimed,
+                result: rejected("RUN_ID_AMBIGUOUS", "Run ID matched multiple allowed networks"),
+            };
+        }
+        resolved = matches[0];
+    }
+    catch {
+        return {
+            request: claimed,
+            result: rejected("STATUS_UNAVAILABLE", "Run status could not be verified"),
+        };
+    }
+    const review = reviewRequest(claimed, resolved, now().getTime(), dependencies.config.stalePrecisionAllowanceMs);
+    if (review !== null)
+        return { request: claimed, result: review };
+    switch (claimed.requestType) {
+        case "RERUN":
+            return withHeartbeat(dependencies, claimed, () => dependencies.child.runNetwork(resolved.network, claimed), classifyRunNetworkResult, now, log);
+        case "STOP":
+        case "RELEASE":
+            return withHeartbeat(dependencies, claimed, () => dependencies.child.cancelRun(claimed, claimed.requestType === "RELEASE"), (result) => classifyCancelResult(result, claimed.requestType === "RELEASE"), now, log);
+        case "CLOSE":
+            return withHeartbeat(dependencies, claimed, () => dependencies.child.archiveRun(resolved.network, claimed), classifyArchiveRun, now, log);
+        default: {
+            const exhaustive = claimed.requestType;
+            return exhaustive;
+        }
+    }
+}
+async function processStart(dependencies, claimed, now, log) {
+    if (claimed.runId.trim() !== "") {
+        return {
+            request: claimed,
+            result: rejected("RUN_ID_NOT_ALLOWED", "STARTではrun_idを指定できません。"),
+        };
+    }
+    const network = claimed.networkId === null
+        ? undefined
+        : dependencies.config.networks.find(({ networkId }) => networkId === claimed.networkId);
+    if (network === undefined) {
+        return {
+            request: claimed,
+            result: startNetworkNotAllowed("NOT_IN_ALLOWLIST"),
+        };
+    }
+    if (!network.appStart) {
+        return {
+            request: claimed,
+            result: startNetworkNotAllowed("APP_START_DISABLED"),
+        };
+    }
+    let prepared = prepareStartRequest(network, claimed);
+    if (!prepared.ok)
+        return { request: claimed, result: prepared.result };
+    try {
+        requestedBy(claimed);
+    }
+    catch {
+        return {
+            request: claimed,
+            result: rejected("REQUESTED_BY_INVALID", "Request creator correlation is invalid or too long"),
+        };
+    }
+    // Minimize the definition gate-to-spawn window by re-reading immediately
+    // before constructing the child invocation.
+    prepared = prepareStartRequest(network, claimed);
+    if (!prepared.ok)
+        return { request: claimed, result: prepared.result };
+    const input = prepared.value.input;
+    return withHeartbeat(dependencies, claimed, () => dependencies.child.startNetwork(network, claimed, input), classifyStartNetworkResult, now, log);
+}
+async function withHeartbeat(dependencies, initial, start, classify, now, log) {
+    const child = start().then((value) => ({ kind: "done", value }), () => ({ kind: "failed" }));
+    let current = initial;
+    for (;;) {
+        const event = await waitForChildOrHeartbeat(child, dependencies.config.heartbeatIntervalMs, dependencies.wait);
+        if (event.kind === "done") {
+            return { request: current, result: classify(event.value) };
+        }
+        if (event.kind === "failed") {
+            return {
+                request: current,
+                result: rejected("CHILD_EXECUTION_FAILED", "child execution failed before a result was available"),
+            };
+        }
+        try {
+            current = await dependencies.store.heartbeat(current, now().toISOString());
+        }
+        catch {
+            log("CLAIM_HEARTBEAT_FAILED", `request_id=${current.id}`);
+        }
+    }
+}
+async function resolveRun(dependencies, runId) {
+    const matches = [];
+    for (const network of dependencies.config.networks) {
+        const status = await dependencies.child.status(network, runId);
+        if (status === null)
+            continue;
+        const matchingRuns = status.runs.filter((run) => run.run_id === runId);
+        for (const run of matchingRuns)
+            matches.push({ network, status, run });
+    }
+    return matches;
+}
+export function reviewRequest(request, resolved, nowMs, leaseAllowanceMs) {
+    const run = resolved.run;
+    const live = hasLiveOwner(resolved.status, run, nowMs, leaseAllowanceMs);
+    switch (request.requestType) {
+        case "RERUN":
+            if (!["CREATED", "RUNNING", "FAILED", "CANCELLED"].includes(run.status))
+                return rejected("RUN_STATUS_NOT_RERUNNABLE", `Run status ${run.status} is not rerunnable`);
+            if (!run.resume_allowed || run.lifecycle_status !== "ACTIVE")
+                return rejected("RUN_NOT_RESUMABLE", "Run is not active and resumable");
+            if (run.hold !== null || run.activity === "STOPPED")
+                return rejected("RUN_ON_HOLD", "Run is on hold");
+            if (run.activity === "LIVE" || live)
+                return rejected("RUN_LIVE", "Run has a live Invocation owner");
+            return null;
+        case "STOP":
+            if (["SUCCESS", "FAILED", "CANCELLED", "UNKNOWN"].includes(run.status))
+                return rejected("RUN_TERMINAL", `Run status ${run.status} is terminal`);
+            if (run.activity === "STOPPED")
+                return rejected("RUN_ALREADY_ON_HOLD", "Run is already on hold");
+            return null;
+        case "RELEASE":
+            return run.hold === null
+                ? rejected("RUN_NOT_ON_HOLD", "Run is not on hold")
+                : null;
+        case "START":
+            return null;
+        case "CLOSE":
+            if (run.lifecycle_status === "ARCHIVED")
+                return {
+                    state: "DONE",
+                    code: "RUN_ALREADY_ARCHIVED",
+                    message: "Run is already archived",
+                };
+            if (run.status === "SUCCESS")
+                return rejected("RUN_STATUS_NOT_CLOSABLE", "Successful Runs cannot be closed");
+            if (run.status === "UNKNOWN")
+                return rejected("RUN_UNKNOWN_NOT_CLOSABLE", "Unknown Runs cannot be closed");
+            if (run.status === "CREATED" || run.status === "RUNNING")
+                return rejected("RUN_NOT_TERMINAL", "Run is not terminal");
+            if (run.hold !== null)
+                return rejected("RUN_ON_HOLD", "Run is on hold");
+            if (live)
+                return rejected("RUN_LIVE", "Run has a live Invocation owner");
+            return null;
+        default: {
+            const exhaustive = request.requestType;
+            return exhaustive;
+        }
+    }
+}
+export function hasLiveOwner(status, run, nowMs, leaseAllowanceMs) {
+    if (status.lock === null)
+        return false;
+    const invocationIds = new Set((run.invocations ?? []).map(({ invocation_id }) => invocation_id));
+    return (invocationIds.has(status.lock.owner_invocation_id) &&
+        nowMs <= Date.parse(status.lock.lease_expires_at) + leaseAllowanceMs);
+}
+async function recoverStale(dependencies, now, log) {
+    const accepted = await dependencies.store.listAccepted();
+    let recovered = 0;
+    const nowMs = now().getTime();
+    for (const request of accepted) {
+        const heartbeat = request.claimHeartbeatAt;
+        if (heartbeat === null ||
+            nowMs <=
+                Date.parse(heartbeat) +
+                    dependencies.config.staleAfterMs +
+                    dependencies.config.stalePrecisionAllowanceMs) {
+            continue;
+        }
+        try {
+            if (request.requestType === "START") {
+                const recoveredStart = await recoverStaleStart(dependencies, request, nowMs);
+                if (!recoveredStart)
+                    continue;
+                await dependencies.store.writeResult(request, rejected("STALE", "Execution and result are unknown; do not request another operation until Run and audit records are reconciled"));
+                recovered += 1;
+                continue;
+            }
+            const matches = await resolveRun(dependencies, request.runId);
+            if (matches.length !== 1)
+                continue;
+            const resolved = matches[0];
+            if (resolved.run.activity === "LIVE" ||
+                hasLiveOwner(resolved.status, resolved.run, nowMs, dependencies.config.stalePrecisionAllowanceMs)) {
+                continue;
+            }
+            await dependencies.store.writeResult(request, rejected("STALE", "Execution and result are unknown; do not request another operation until Run and audit records are reconciled"));
+            recovered += 1;
+        }
+        catch {
+            log("STALE_STATUS_UNAVAILABLE", `request_id=${request.id}`);
+        }
+    }
+    return recovered;
+}
+async function recoverStaleStart(dependencies, request, nowMs) {
+    if (request.networkId === null)
+        return false;
+    const network = dependencies.config.networks.find(({ networkId }) => networkId === request.networkId);
+    if (network === undefined)
+        return false;
+    const prepared = prepareStartRequest(network, request);
+    if (!prepared.ok)
+        return false;
+    const status = await dependencies.child.status(network, {
+        businessKey: prepared.value.businessKey,
+    });
+    if (status === null)
+        return false;
+    const matches = status.runs.filter(({ business_key }) => business_key === prepared.value.businessKey);
+    if (matches.length !== 1)
+        return false;
+    const run = matches[0];
+    return (run.activity !== "LIVE" &&
+        !hasLiveOwner(status, run, nowMs, dependencies.config.stalePrecisionAllowanceMs));
+}
+function waitForChildOrHeartbeat(child, milliseconds, customWait) {
+    if (customWait !== undefined) {
+        return Promise.race([
+            child,
+            customWait(milliseconds).then(() => ({ kind: "heartbeat" })),
+        ]);
+    }
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve({ kind: "heartbeat" }), milliseconds);
+        void child.then((event) => {
+            clearTimeout(timer);
+            resolve(event);
+        });
+    });
+}
+//# sourceMappingURL=request-poller.js.map