@repogo/plugins 0.1.35 → 0.1.38

package/dist/workflow/state.d.ts

@@ -0,0 +1,41 @@
+import type { RunMetadata } from "./contracts";
+import type { StepPolicy } from "./policy";
+import { type JournalEvent, type JournalFailure, type JSONValue } from "./events";
+export type StepState = {
+    status: "running" | "waiting" | "completed" | "failed" | "unknown";
+    attempt: number;
+    limit: number;
+    policy: StepPolicy;
+    result: JSONValue;
+    error: JournalFailure | null;
+    nextAttemptAt: string | null;
+};
+export type SleepState = {
+    status: "waiting" | "completed";
+    durationMs: number;
+    wakeAt: string;
+};
+export type RunState = {
+    version: 2;
+    lastSeq: number;
+    status: "pending" | "running" | "waiting" | "attention" | "completed" | "failed" | "cancelled" | "expired" | "unknown";
+    workflow: string | null;
+    input: JSONValue;
+    currentStep: string | null;
+    operationOrder: string[];
+    steps: Record<string, StepState>;
+    sleeps: Record<string, SleepState>;
+    result: JSONValue;
+    error: JournalFailure | null;
+    expiryReason: string | null;
+    deadlineAt: string | null;
+    /** The run's lifetime, which a restart starts again. */
+    timeoutMs: number | null;
+    cancelRequested: boolean;
+    updatedAt: string | null;
+    endedAt: string | null;
+    metadata: RunMetadata | null;
+};
+export declare function initialState(): RunState;
+/** One reducer defines state both during execution and journal recovery. */
+export declare function applyEvent(state: RunState, event: JournalEvent): RunState;

package/dist/workflow/storage.d.ts

@@ -0,0 +1,22 @@
+export declare const maxRecordBytes: number;
+export declare const maxJournalBytes: number;
+/** Storage methods resolve only after their writes have been flushed. */
+export interface JournalStorage {
+    readEvents(): Promise<Uint8Array>;
+    append(record: Uint8Array): Promise<void>;
+    truncateEvents(bytes: number): Promise<void>;
+    replaceSnapshot(snapshot: string): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class FileJournalStorage implements JournalStorage {
+    private directory;
+    private events;
+    private release;
+    private constructor();
+    static open(directory: string, create?: boolean): Promise<FileJournalStorage>;
+    readEvents(): Promise<Uint8Array>;
+    append(record: Uint8Array): Promise<void>;
+    truncateEvents(bytes: number): Promise<void>;
+    replaceSnapshot(snapshot: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/workflow/summary.d.ts

@@ -0,0 +1,80 @@
+import type { RunMetadata, RunSummary } from "./contracts";
+import { type RunState } from "./state";
+import type { JournalFailure, JSONValue } from "./events";
+export declare function summarize(run: RunMetadata, state: RunState): RunSummary;
+export declare const terminalStatuses: Set<string>;
+export declare const activeStatuses: Set<string>;
+/** Not finished: what Cancel all reaches, and what a deadline can still expire. */
+export declare const openStatuses: Set<string>;
+export declare function describe(state: RunState): {
+    error: {
+        message: string;
+        code?: string | undefined;
+    } | null;
+    input: unknown;
+    result: unknown;
+    resultTruncated: boolean;
+    inputTruncated: boolean;
+    expiryReason: string | null;
+    cancelRequested: boolean;
+    steps: ({
+        id: string;
+        kind: string;
+        status: "waiting" | "completed";
+        attempt: number;
+        attempts: number;
+        error: null;
+        nextAttemptAt: string | null;
+        durationMs: number;
+    } | {
+        id: string;
+        kind: string;
+        durationMs: null;
+        status: "running" | "failed" | "waiting" | "completed" | "unknown";
+        attempt: number;
+        attempts: number;
+        error: {
+            message: string;
+            code?: string | undefined;
+        } | null;
+        nextAttemptAt: string | null;
+    })[];
+};
+export declare function briefError(error: JournalFailure | null): {
+    message: string;
+    code?: string | undefined;
+} | null;
+export declare function unavailableDetail(input: JSONValue, error: string | null): {
+    error: {
+        message: string;
+        code?: string | undefined;
+    } | null;
+    input: unknown;
+    result: unknown;
+    resultTruncated: boolean;
+    inputTruncated: boolean;
+    expiryReason: string | null;
+    cancelRequested: boolean;
+    steps: ({
+        id: string;
+        kind: string;
+        status: "waiting" | "completed";
+        attempt: number;
+        attempts: number;
+        error: null;
+        nextAttemptAt: string | null;
+        durationMs: number;
+    } | {
+        id: string;
+        kind: string;
+        durationMs: null;
+        status: "running" | "failed" | "waiting" | "completed" | "unknown";
+        attempt: number;
+        attempts: number;
+        error: {
+            message: string;
+            code?: string | undefined;
+        } | null;
+        nextAttemptAt: string | null;
+    })[];
+};

package/dist/workflow/testing.d.ts

@@ -0,0 +1,12 @@
+import "../self";
+import type { TestCall, TestHost } from "../testing";
+/** File-backed fixtures exercise the same pinned executors and durable storage as the host. */
+export declare function testWorkflowRuntime(directory: string, options?: {
+    root?: string;
+    host?: TestHost;
+}): Promise<{
+    call: (method: string, input?: unknown, call?: TestCall) => Promise<unknown>;
+    manifest: () => import("..").Manifest;
+    wait: (method: string, id: string, timeout?: number) => Promise<unknown>;
+    close: () => Promise<void>;
+}>;