@rex0220/ksql-flownet 1.0.0

package/dist/persistence/network-lock.js

@@ -0,0 +1,408 @@
+import { createHash, randomUUID } from "node:crypto";
+import { MAX_KINTONE_UNIQUE_KEY_LENGTH, networkLockKey, } from "../domain/canonical-lock-key.js";
+import { KintoneApiError, KintoneClient, KintoneTransportError, } from "./kintone/client.js";
+export class NetworkLockError extends Error {
+    code;
+    causeDetail;
+    constructor(code, message, causeDetail) {
+        super(message);
+        this.name = "NetworkLockError";
+        this.code = code;
+        this.causeDetail = causeDetail;
+    }
+}
+const field = (value) => ({ value });
+const text = (record, code) => String(record[code]?.value ?? "");
+const revisionOf = (record) => Number(record.$revision?.value);
+const idOf = (record) => text(record, "$id");
+function quote(value) {
+    return `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`;
+}
+function recordKeyFor(lockKey) {
+    const value = `LOCK:${lockKey}`;
+    if (value.length > MAX_KINTONE_UNIQUE_KEY_LENGTH) {
+        throw new NetworkLockError("LOCK_UNAVAILABLE", `network lock record key exceeds ${MAX_KINTONE_UNIQUE_KEY_LENGTH} characters`);
+    }
+    return value;
+}
+export function releaseTombstoneRecordKey(uniqueValue) {
+    const direct = `LOCKDONE:${uniqueValue}`;
+    if (direct.length <= MAX_KINTONE_UNIQUE_KEY_LENGTH)
+        return direct;
+    const digest = createHash("sha256")
+        .update(uniqueValue, "utf8")
+        .digest("base64url");
+    return `LOCKDONE:${digest}`;
+}
+function decodeReference(record, lockKey, recordKey, leaseDurationSec) {
+    return {
+        lockKey,
+        recordId: idOf(record),
+        originalRecordKey: recordKey,
+        leaseToken: text(record, "lease_token"),
+        ownerInvocationId: text(record, "owner_invocation_id"),
+        leaseDurationSec,
+        revision: revisionOf(record),
+        businessRevision: Number(record.revision?.value),
+        heartbeatAt: text(record, "heartbeat_at"),
+        leaseExpiresAt: text(record, "lease_expires_at"),
+    };
+}
+export class NetworkLockManager {
+    client;
+    config;
+    now;
+    uuid;
+    lockKey;
+    recordKey;
+    constructor(config) {
+        if (!Number.isSafeInteger(config.leaseDurationSec) ||
+            config.leaseDurationSec <= 0) {
+            throw new TypeError("leaseDurationSec must be a positive integer");
+        }
+        this.config = config;
+        this.now = config.now ?? (() => new Date());
+        this.uuid = config.uuid ?? randomUUID;
+        this.lockKey = networkLockKey(config.profile, config.networkId);
+        this.recordKey = recordKeyFor(this.lockKey);
+        this.client = new KintoneClient({
+            baseUrl: config.baseUrl,
+            appId: config.appId,
+            apiToken: config.apiToken,
+            ...(config.fetch ? { fetch: config.fetch } : {}),
+        });
+    }
+    async acquire() {
+        const acquiredAt = this.now();
+        const leaseToken = this.uuid();
+        const leaseExpiresAt = new Date(acquiredAt.getTime() + this.config.leaseDurationSec * 1000).toISOString();
+        const record = {
+            record_key: field(this.recordKey),
+            record_type: field("NETWORK_LOCK"),
+            lock_key: field(this.lockKey),
+            profile: field(this.config.profile),
+            owner_invocation_id: field(this.config.ownerInvocationId),
+            lease_token: field(leaseToken),
+            started_at: field(acquiredAt.toISOString()),
+            heartbeat_at: field(acquiredAt.toISOString()),
+            lease_expires_at: field(leaseExpiresAt),
+            status: field("RUNNING"),
+            revision: field(1),
+            status_reason: field(`owner_instance_id=${this.config.ownerInstanceId}`),
+        };
+        try {
+            const created = await this.client.postRecord(record);
+            return decodeReference({
+                ...record,
+                $id: field(created.id),
+                $revision: field(created.revision),
+            }, this.lockKey, this.recordKey, this.config.leaseDurationSec);
+        }
+        catch (error) {
+            if (!(error instanceof KintoneTransportError ||
+                (error instanceof KintoneApiError &&
+                    error.status === 400 &&
+                    error.apiCode === "CB_VA01"))) {
+                throw new NetworkLockError("LOCK_UNAVAILABLE", "network lock insert failed", error);
+            }
+            const current = await this.getUniqueAfterAcquireFailure(error);
+            if (text(current, "status") === "RUNNING" &&
+                text(current, "lease_token") === leaseToken &&
+                text(current, "owner_invocation_id") === this.config.ownerInvocationId) {
+                return decodeReference(current, this.lockKey, this.recordKey, this.config.leaseDurationSec);
+            }
+            if (text(current, "status") === "RUNNING") {
+                throw new NetworkLockError("LOCK_CONFLICT", "network lock is held", error);
+            }
+            throw new NetworkLockError("LOCK_UNAVAILABLE", "network lock insert outcome could not be confirmed", error);
+        }
+    }
+    async heartbeat(reference) {
+        const current = await this.getUnique(reference.originalRecordKey);
+        this.assertFence(current, reference);
+        const at = this.now();
+        const leaseExpiresAt = new Date(at.getTime() + reference.leaseDurationSec * 1000).toISOString();
+        let revision;
+        try {
+            revision = await this.client.putRecord(reference.originalRecordKey, reference.revision, {
+                heartbeat_at: field(at.toISOString()),
+                lease_expires_at: field(leaseExpiresAt),
+                revision: field(reference.businessRevision + 1),
+            });
+        }
+        catch (error) {
+            if (error instanceof KintoneApiError && error.status === 409) {
+                throw new NetworkLockError("LEASE_REVISION_CONFLICT", "network lease revision conflicted", error);
+            }
+            if (error instanceof KintoneTransportError) {
+                const adjudicated = await this.getUnique(reference.originalRecordKey);
+                if (text(adjudicated, "lease_token") === reference.leaseToken &&
+                    revisionOf(adjudicated) === reference.revision + 1 &&
+                    text(adjudicated, "heartbeat_at") === at.toISOString() &&
+                    text(adjudicated, "lease_expires_at") === leaseExpiresAt) {
+                    revision = revisionOf(adjudicated);
+                }
+                else {
+                    throw new NetworkLockError("LOCK_UNAVAILABLE", "network heartbeat outcome could not be confirmed", error);
+                }
+            }
+            else {
+                throw new NetworkLockError("LOCK_UNAVAILABLE", "network heartbeat failed", error);
+            }
+        }
+        reference.revision = revision;
+        reference.businessRevision += 1;
+        reference.heartbeatAt = at.toISOString();
+        reference.leaseExpiresAt = leaseExpiresAt;
+        return reference;
+    }
+    async release(reference, status = "SUCCESS", resultCode = "NORMAL") {
+        const current = await this.getUnique(reference.originalRecordKey);
+        this.assertFence(current, reference);
+        const tombstone = releaseTombstoneRecordKey(`${reference.lockKey}:${reference.leaseToken}`);
+        const releaseRecord = () => this.client.putRecordById(reference.recordId, reference.revision, {
+            record_key: field(tombstone),
+            lock_key: field(""),
+            owner_invocation_id: field(""),
+            lease_token: field(""),
+            status: field(status),
+            status_reason: field(resultCode),
+            finished_at: field(this.now().toISOString()),
+            revision: field(reference.businessRevision + 1),
+        });
+        const adjudicateLostResponse = async (cause) => {
+            try {
+                const adjudicated = await this.getUnique(tombstone);
+                if (text(adjudicated, "lock_key") === "" &&
+                    text(adjudicated, "lease_token") === "" &&
+                    text(adjudicated, "status") === status) {
+                    reference.revision = revisionOf(adjudicated);
+                    reference.businessRevision = Number(adjudicated.revision?.value);
+                    return { released: true, recordKey: tombstone };
+                }
+            }
+            catch {
+                // The stable error below intentionally hides ambiguous remote details.
+            }
+            throw new NetworkLockError("LOCK_UNAVAILABLE", "network lock release outcome could not be confirmed", cause);
+        };
+        try {
+            const revision = await releaseRecord();
+            reference.revision = revision;
+            reference.businessRevision += 1;
+            return { released: true, recordKey: tombstone };
+        }
+        catch (error) {
+            if (error instanceof KintoneApiError && error.status === 409) {
+                let latest;
+                try {
+                    latest = await this.getUnique(reference.originalRecordKey);
+                }
+                catch (retryError) {
+                    throw new NetworkLockError("LEASE_REVISION_CONFLICT", "network lock release revision conflicted", retryError);
+                }
+                if (text(latest, "record_key") !== reference.originalRecordKey ||
+                    text(latest, "lease_token") !== reference.leaseToken) {
+                    throw new NetworkLockError("LEASE_REVISION_CONFLICT", "network lock release revision conflicted", error);
+                }
+                // A revision advanced by our own heartbeat is safe to release once.
+                reference.revision = revisionOf(latest);
+                reference.businessRevision = Number(latest.revision?.value);
+                try {
+                    const revision = await releaseRecord();
+                    reference.revision = revision;
+                    reference.businessRevision += 1;
+                    return { released: true, recordKey: tombstone };
+                }
+                catch (retryError) {
+                    if (retryError instanceof KintoneApiError &&
+                        retryError.status === 409)
+                        throw new NetworkLockError("LEASE_REVISION_CONFLICT", "network lock release revision conflicted", retryError);
+                    if (retryError instanceof KintoneTransportError)
+                        return adjudicateLostResponse(retryError);
+                    throw new NetworkLockError("LOCK_UNAVAILABLE", "network lock release failed", retryError);
+                }
+            }
+            if (error instanceof KintoneTransportError) {
+                return adjudicateLostResponse(error);
+            }
+            throw new NetworkLockError("LOCK_UNAVAILABLE", "network lock release failed", error);
+        }
+    }
+    async getUniqueAfterAcquireFailure(cause) {
+        try {
+            return await this.getUnique(this.recordKey);
+        }
+        catch (error) {
+            throw new NetworkLockError("LOCK_UNAVAILABLE", "network lock holder could not be confirmed", { cause, adjudication: error });
+        }
+    }
+    async getUnique(recordKey) {
+        let records;
+        try {
+            records = await this.client.getRecords(`record_key in (${quote(recordKey)})`);
+        }
+        catch (error) {
+            throw new NetworkLockError("LOCK_UNAVAILABLE", "network lock read failed", error);
+        }
+        if (records.length !== 1) {
+            throw new NetworkLockError("LOCK_UNAVAILABLE", `network lock read returned ${records.length} records`);
+        }
+        return records[0];
+    }
+    assertFence(current, reference) {
+        if (text(current, "lease_token") !== reference.leaseToken) {
+            throw new NetworkLockError("LEASE_TOKEN_MISMATCH", "network lease token no longer matches");
+        }
+        if (revisionOf(current) !== reference.revision) {
+            throw new NetworkLockError("LEASE_REVISION_MISMATCH", "network lease revision no longer matches");
+        }
+    }
+}
+export class LeaseMonitor {
+    manager;
+    reference;
+    config;
+    state = "HELD";
+    failures = 0;
+    timer = null;
+    tickInFlight = null;
+    listeners = new Set();
+    now;
+    failureThreshold;
+    safetyMs;
+    schedule;
+    cancelSchedule;
+    constructor(manager, reference, config) {
+        this.manager = manager;
+        this.reference = reference;
+        this.config = config;
+        validateMonitorConfig(config);
+        this.now = config.now ?? (() => new Date());
+        this.failureThreshold = config.consecutiveFailureThreshold ?? 3;
+        this.safetyMs =
+            (config.remainingLeaseSafetySec ?? config.heartbeatIntervalSec) * 1000;
+        this.schedule =
+            config.schedule ??
+                ((callback, intervalMs) => setInterval(callback, intervalMs));
+        this.cancelSchedule =
+            config.cancelSchedule ??
+                ((handle) => clearInterval(handle));
+    }
+    get currentState() {
+        return this.state;
+    }
+    canStartNewNode() {
+        return this.state === "HELD";
+    }
+    canPersistResults() {
+        return this.state === "HELD" || this.state === "FINAL_WRITE_CONFIRMED";
+    }
+    requiresNetworkLeaseInterruptedFinalization() {
+        return this.state === "FINAL_WRITE_CONFIRMED";
+    }
+    markControlPlaneUnreachable() {
+        if (this.state !== "LEASE_UNCERTAIN")
+            this.transition("LEASE_UNCERTAIN", "FAILURE_THRESHOLD");
+    }
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => this.listeners.delete(listener);
+    }
+    async tick() {
+        if (this.tickInFlight !== null)
+            return this.tickInFlight;
+        const operation = this.performTick();
+        this.tickInFlight = operation;
+        try {
+            return await operation;
+        }
+        finally {
+            if (this.tickInFlight === operation)
+                this.tickInFlight = null;
+        }
+    }
+    async performTick() {
+        if (this.state !== "HELD")
+            return false;
+        try {
+            await this.manager.heartbeat(this.reference);
+            this.failures = 0;
+            return true;
+        }
+        catch (error) {
+            this.failures += 1;
+            const fenceLost = error instanceof NetworkLockError &&
+                (error.code === "LEASE_TOKEN_MISMATCH" ||
+                    error.code === "LEASE_REVISION_MISMATCH" ||
+                    error.code === "LEASE_REVISION_CONFLICT");
+            if (fenceLost)
+                this.transition("LEASE_UNCERTAIN", "FENCE_LOST");
+            else if (this.failures >= this.failureThreshold)
+                this.transition("LEASE_UNCERTAIN", "FAILURE_THRESHOLD");
+            else if (this.remainingLeaseMs() <= this.safetyMs)
+                this.transition("LEASE_UNCERTAIN", "LEASE_SAFETY_THRESHOLD");
+            return false;
+        }
+    }
+    async confirmLeaseForFinalWrite() {
+        if (this.tickInFlight !== null)
+            await this.tickInFlight;
+        if (this.state !== "LEASE_UNCERTAIN")
+            return false;
+        try {
+            await this.manager.heartbeat(this.reference);
+            this.transition("FINAL_WRITE_CONFIRMED", "FINAL_WRITE_CONFIRMED");
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    start() {
+        if (this.timer !== null)
+            return;
+        this.timer = this.schedule(() => void this.tick().catch(() => undefined), this.config.heartbeatIntervalSec * 1000);
+    }
+    stop() {
+        if (this.timer === null)
+            return;
+        this.cancelSchedule(this.timer);
+        this.timer = null;
+    }
+    remainingLeaseMs() {
+        return Date.parse(this.reference.leaseExpiresAt) - this.now().getTime();
+    }
+    transition(current, reason) {
+        if (this.state === current)
+            return;
+        const previous = this.state;
+        this.state = current;
+        const event = { previous, current, reason, at: this.now().toISOString() };
+        for (const listener of this.listeners)
+            listener(event);
+    }
+}
+function validateMonitorConfig(config) {
+    if ((config.schedule === undefined) !==
+        (config.cancelSchedule === undefined)) {
+        throw new TypeError("schedule and cancelSchedule must be provided together");
+    }
+    for (const [name, value] of [
+        ["leaseDurationSec", config.leaseDurationSec],
+        ["heartbeatIntervalSec", config.heartbeatIntervalSec],
+        ["consecutiveFailureThreshold", config.consecutiveFailureThreshold ?? 3],
+        [
+            "remainingLeaseSafetySec",
+            config.remainingLeaseSafetySec ?? config.heartbeatIntervalSec,
+        ],
+    ]) {
+        if (!Number.isSafeInteger(value) || value <= 0) {
+            throw new TypeError(`${name} must be a positive integer`);
+        }
+    }
+    if (config.heartbeatIntervalSec >= config.leaseDurationSec) {
+        throw new TypeError("heartbeatIntervalSec must be shorter than leaseDurationSec");
+    }
+}
+//# sourceMappingURL=network-lock.js.map

package/dist/persistence/repository.d.ts

@@ -0,0 +1,101 @@
+import type { AttemptResolution, CancelRequest, NetworkRun, NetworkRunStatus, NodeAttempt, NodeAttemptStatus, NodeState, OperationAudit, RunInvocation, RunInvocationStatus } from "../domain/persistence-model.js";
+export type RepositoryErrorCode = "DUPLICATE_RECORD" | "REVISION_CONFLICT" | "INVALID_STATE_TRANSITION" | "ATTEMPT_NUMBER_CONFLICT" | "ATTEMPT_TERMINAL" | "ATTEMPT_LIFECYCLE_VIOLATION" | "AMBIGUOUS_WRITE" | "RECORD_NOT_FOUND" | "MULTIPLE_RECORDS" | "UNIQUE_KEY_TOO_LONG" | "REMOTE_ERROR" | "AUDIT_CONFLICT";
+export declare class RepositoryError extends Error {
+    readonly code: RepositoryErrorCode;
+    readonly causeDetail: unknown;
+    constructor(code: RepositoryErrorCode, message: string, causeDetail?: unknown);
+}
+export interface Versioned<T> {
+    value: T;
+    revision: number;
+}
+export interface RunAggregateUpdate {
+    status: NetworkRunStatus;
+    started_at: string | null;
+    finished_at: string | null;
+    updated_at: string;
+}
+export interface InvocationFinalization {
+    status: Exclude<RunInvocationStatus, "RUNNING">;
+    result_code: string;
+    finished_at: string;
+    selected_node_ids?: readonly string[];
+    preserved_node_ids?: readonly string[];
+    blocked_node_ids?: readonly string[];
+    reason?: string;
+}
+export interface NodeStateWrite {
+    value: NodeState;
+    expected_revision: number | null;
+    resolution_event?: {
+        event_type: "ATTEMPT_RESOLVED";
+        attempt_id: string;
+        resolved_outcome: "SUCCESS" | "FAILED" | "CANCELLED";
+        resolved_at: string;
+    };
+}
+export interface CreateAttemptInput {
+    node_state: Versioned<NodeState>;
+    node_attempt_id: string;
+    invocation_id: string;
+}
+export interface AttemptExecutionStart {
+    execution_started_at: string;
+}
+export interface AttemptInputBaselineWrite {
+    error_message: string;
+}
+export interface AttemptFinalization {
+    status: Exclude<NodeAttemptStatus, "RUNNING">;
+    result_code: string;
+    runner_execution_started_at: string | null;
+    execution_id: string | null;
+    finished_at: string;
+    duration_sec: number | null;
+    error_message: string | null;
+    read_count: number;
+    written_count: number;
+    last_successful_chunk_no: number | null;
+    last_written_key: string | null;
+}
+export type Inconsistency = {
+    code: "ACTIVE_ATTEMPT_MISSING";
+    node_state: Versioned<NodeState>;
+} | {
+    code: "STATE_ATTEMPT_STATUS_MISMATCH";
+    node_state: Versioned<NodeState>;
+    attempt: Versioned<NodeAttempt>;
+} | {
+    code: "MULTIPLE_RUNNING_ATTEMPTS";
+    node_state: Versioned<NodeState>;
+    attempts: Versioned<NodeAttempt>[];
+};
+export interface PersistenceRepository {
+    createRun(run: NetworkRun): Promise<Versioned<NetworkRun>>;
+    getRun(runId: string): Promise<Versioned<NetworkRun>>;
+    getRunByBusinessKey(profile: string, networkId: string, businessKey: string): Promise<Versioned<NetworkRun> | null>;
+    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>>;
+    setAttemptInputBaseline(attemptId: string, expectedRevision: number, write: AttemptInputBaselineWrite): Promise<Versioned<NodeAttempt>>;
+    setAttemptExecutionStarted(attemptId: string, expectedRevision: number, start: AttemptExecutionStart): 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[]>;
+}
+/** The complete persistence surface available to read-only status inspection. */
+export type StatusReadRepository = Pick<PersistenceRepository, "getRun" | "getRunByBusinessKey" | "listRuns" | "getInvocations" | "getNodeStates" | "getAttempts" | "getResolutions" | "getCancelRequest">;
+//# sourceMappingURL=repository.d.ts.map

package/dist/persistence/repository.js

@@ -0,0 +1,11 @@
+export class RepositoryError extends Error {
+    code;
+    causeDetail;
+    constructor(code, message, causeDetail) {
+        super(message);
+        this.name = "RepositoryError";
+        this.code = code;
+        this.causeDetail = causeDetail;
+    }
+}
+//# sourceMappingURL=repository.js.map

package/dist/persistence/state-transition.d.ts

@@ -0,0 +1,4 @@
+import type { NodeStateStatus } from "../domain/persistence-model.js";
+export declare function isAllowedNodeStateTransition(from: NodeStateStatus, to: NodeStateStatus): boolean;
+export declare function isAllowedResolutionTransition(from: NodeStateStatus, to: NodeStateStatus): boolean;
+//# sourceMappingURL=state-transition.d.ts.map

package/dist/persistence/state-transition.js

@@ -0,0 +1,25 @@
+const ALLOWED_TRANSITIONS = {
+    WAITING: new Set(["WAITING", "RUNNING", "BLOCKED"]),
+    RUNNING: new Set([
+        "RUNNING",
+        "WAITING",
+        "SUCCESS",
+        "FAILED",
+        "CANCELLED",
+        "UNKNOWN",
+    ]),
+    SUCCESS: new Set(["SUCCESS", "WAITING"]),
+    FAILED: new Set(["FAILED", "WAITING"]),
+    BLOCKED: new Set(["BLOCKED", "WAITING"]),
+    SKIPPED: new Set(["SKIPPED"]),
+    CANCELLED: new Set(["CANCELLED", "WAITING"]),
+    UNKNOWN: new Set(["UNKNOWN", "SUCCESS", "FAILED", "CANCELLED"]),
+};
+export function isAllowedNodeStateTransition(from, to) {
+    return ALLOWED_TRANSITIONS[from].has(to);
+}
+export function isAllowedResolutionTransition(from, to) {
+    return (from === "FAILED" &&
+        (to === "SUCCESS" || to === "FAILED" || to === "CANCELLED"));
+}
+//# sourceMappingURL=state-transition.js.map

package/dist/requests/flownet-child-client.d.ts

@@ -0,0 +1,78 @@
+import type { ArchiveRunOutcome } from "../orchestration/archive-run.js";
+import type { StatusOutput } from "../orchestration/status.js";
+import type { PollRequestsNetwork } from "./poll-requests-config.js";
+import type { RequestRecord } from "./request-model.js";
+import type { StartNetworkInput } from "./start-request.js";
+export declare const DEFAULT_CHILD_OUTPUT_LIMIT: number;
+export declare const REQUESTED_BY_MAX_LENGTH = 1024;
+export interface ChildProcessResult {
+    readonly exitCode: number | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly stdoutTruncated: boolean;
+    readonly stderrTruncated: boolean;
+    readonly spawnError?: string;
+}
+export interface RunNetworkJsonOutput {
+    readonly outcome: "NEW" | "RESUME" | "NOOP" | "REJECTED";
+    readonly run_id: string | null;
+    readonly invocation_id: string | null;
+    readonly aggregate_status: string | null;
+    readonly invocation_result_code: string;
+    readonly retry_brake_node_ids?: readonly string[];
+    readonly blocked_run_ids?: readonly string[];
+}
+export interface FlownetChildClientOptions {
+    readonly profile: string;
+    readonly environment?: NodeJS.ProcessEnv;
+    readonly outputLimit?: number;
+    readonly cliPath?: string;
+    readonly execute?: (command: string, args: readonly string[], options: {
+        readonly env: NodeJS.ProcessEnv;
+        readonly shell: false;
+    }) => Promise<ChildProcessResult>;
+    readonly makeTempDirectory?: () => Promise<string>;
+    readonly removeTempDirectory?: (path: string) => Promise<void>;
+}
+export declare class FlownetChildClient {
+    private readonly profile;
+    private readonly environment;
+    private readonly outputLimit;
+    private readonly cliPath;
+    private readonly executeProcess;
+    private readonly makeTempDirectory;
+    private readonly removeTempDirectory;
+    constructor(options: FlownetChildClientOptions);
+    status(network: PollRequestsNetwork, selector: string | {
+        readonly businessKey: string;
+    }): Promise<StatusOutput | null>;
+    runNetwork(network: PollRequestsNetwork, request: RequestRecord): Promise<{
+        readonly output: RunNetworkJsonOutput | null;
+        readonly process: ChildProcessResult;
+    }>;
+    startNetwork(network: PollRequestsNetwork, request: Pick<RequestRecord, "id" | "creatorCode">, input: StartNetworkInput): Promise<{
+        readonly output: RunNetworkJsonOutput | null;
+        readonly process: ChildProcessResult;
+    }>;
+    cancelRun(request: RequestRecord, release: boolean): Promise<ChildProcessResult>;
+    archiveRun(network: PollRequestsNetwork, request: RequestRecord): Promise<{
+        readonly output: ArchiveRunOutcome | null;
+        readonly process: ChildProcessResult;
+    }>;
+    private run;
+}
+export declare class ChildClientError extends Error {
+    readonly code: string;
+    readonly result: ChildProcessResult;
+    constructor(code: string, message: string, result: ChildProcessResult, cause?: unknown);
+}
+export declare function requestedBy(request: Pick<RequestRecord, "id" | "creatorCode">): string;
+export declare class RequestCorrelationError extends Error {
+    readonly code = "REQUESTED_BY_INVALID";
+    constructor(message: string, cause?: unknown);
+}
+export declare function executeChild(command: string, args: readonly string[], options: {
+    readonly env: NodeJS.ProcessEnv;
+    readonly shell: false;
+}, limit: number): Promise<ChildProcessResult>;
+//# sourceMappingURL=flownet-child-client.d.ts.map