@rex0220/ksql-flownet 1.0.0

package/dist/orchestration/run-activity.js

@@ -0,0 +1,14 @@
+import { KINTONE_DATETIME_TRUNCATION_MS } from "../persistence/kintone/design-notes.js";
+export function deriveRunActivity(input) {
+    if (["SUCCESS", "FAILED", "CANCELLED", "UNKNOWN"].includes(input.status))
+        return null;
+    if (input.cancelState === "REQUESTED" || input.cancelState === "ACCEPTED")
+        return "STOPPED";
+    if (input.lock !== null &&
+        input.invocationIds.includes(input.lock.owner_invocation_id) &&
+        input.nowMs <=
+            Date.parse(input.lock.lease_expires_at) + KINTONE_DATETIME_TRUNCATION_MS)
+        return "LIVE";
+    return input.startedAt === null ? "IDLE" : "INTERRUPTED";
+}
+//# sourceMappingURL=run-activity.js.map

package/dist/orchestration/sequential-scheduler.d.ts

@@ -0,0 +1,79 @@
+import type { NetworkRun, NetworkRunStatus, NodeAttempt, NodeStateStatus, RunInvocation, RunInvocationStatus } from "../domain/persistence-model.js";
+import type { AttemptExecutionOutcome, AttemptExecutorInput } from "../executor/attempt-executor.js";
+import type { JobLogReader } from "../executor/job-log-reader.js";
+import type { PersistenceRepository, Versioned } from "../persistence/repository.js";
+export interface SchedulerLeaseMonitor {
+    canStartNewNode(): boolean;
+    canPersistResults(): boolean;
+    confirmLeaseForFinalWrite(): Promise<boolean>;
+    requiresNetworkLeaseInterruptedFinalization(): boolean;
+    markControlPlaneUnreachable?(): void;
+    /** A heartbeat is also the fencing read before an ordinary state write. */
+    tick?(): Promise<boolean>;
+    start?(): void;
+    stop?(): void;
+}
+export interface SchedulerAttemptExecutor {
+    execute(input: AttemptExecutorInput): Promise<AttemptExecutionOutcome>;
+}
+export interface SchedulerCloseInput {
+    readonly status: Exclude<RunInvocationStatus, "RUNNING">;
+    readonly resultCode: string;
+    readonly selectedNodeIds: readonly string[];
+    readonly preservedNodeIds: readonly string[];
+    readonly blockedNodeIds: readonly string[];
+    readonly reason?: string;
+    readonly persistInvocation?: boolean;
+}
+export interface SequentialSchedulerInput {
+    readonly run: Versioned<NetworkRun>;
+    readonly invocation: Versioned<RunInvocation>;
+    readonly bundleBytes: Uint8Array;
+    readonly repository: PersistenceRepository;
+    readonly attemptExecutor: SchedulerAttemptExecutor;
+    readonly jobLogReader?: Pick<JobLogReader, "findAttemptResult">;
+    readonly leaseMonitor: SchedulerLeaseMonitor;
+    readonly profile: string;
+    readonly configPath: string;
+    readonly executionRoot?: string;
+    readonly ioRoot?: string;
+    readonly close: (input: SchedulerCloseInput) => Promise<void>;
+    readonly now?: () => Date;
+    readonly uuid?: () => string;
+    readonly controlPlaneDrain?: {
+        readonly retryDelayMs?: number;
+        readonly nowMs?: () => number;
+        readonly sleep?: (delayMs: number) => Promise<void>;
+    };
+}
+export type SchedulerNodeDisposition = "EXECUTED" | "PRESERVED" | "BLOCKED" | "DEFERRED" | "EXCLUDED";
+export interface SchedulerNodeResult {
+    readonly nodeId: string;
+    readonly disposition: SchedulerNodeDisposition;
+    readonly status: NodeStateStatus;
+    readonly attemptNo: number | null;
+    readonly resultCode: string | null;
+}
+export interface SequentialSchedulerSummary {
+    readonly nodeResults: readonly SchedulerNodeResult[];
+    readonly aggregateStatus: NetworkRunStatus;
+    readonly invocationStatus: Exclude<RunInvocationStatus, "RUNNING">;
+    readonly invocationResultCode: string;
+    readonly selectedNodeIds: readonly string[];
+    readonly preservedNodeIds: readonly string[];
+    readonly blockedNodeIds: readonly string[];
+    readonly retryBrakeNodeIds: readonly string[];
+    readonly reconciliationRequired: boolean;
+}
+export declare class SchedulerLeaseInterruptedError extends Error {
+    readonly reconciliationRequired: boolean;
+    readonly code = "NETWORK_LEASE_INTERRUPTED";
+    constructor(reconciliationRequired: boolean, options?: ErrorOptions);
+}
+/** FN-10 Phase 1 scheduler: one invocation, one node at a time. */
+export declare function runSequentialScheduler(input: SequentialSchedulerInput): Promise<SequentialSchedulerSummary>;
+export declare function retryBrakeForNode(attempts: readonly Versioned<NodeAttempt>[], nodeId: string): {
+    failureKind: string;
+    count: number;
+} | null;
+//# sourceMappingURL=sequential-scheduler.d.ts.map