@repogo/plugins 0.1.35 → 0.1.38

package/dist/tracking.d.ts

@@ -29,6 +29,11 @@ export type Tracked<T> = {
  * that committed before the error are still announced.
  */
 export declare function tracked<T>(readOnly: boolean, announce: (tags: string[]) => void, work: () => Promise<T>): Promise<Tracked<T>>;
+/**
+ * Runs `work` read-only in a scope of its own, apart from the call that started
+ * it: what it reads isn't that call's, so a detached fetch can outlive it.
+ */
+export declare function isolated<T>(work: () => Promise<T>): Promise<T>;
 export declare function recordRead(tag: string): void;
 /** Called before a write runs: a query, and anything it calls, may not write. */
 export declare function assertWritable(tag: string): void;

package/dist/uploads.d.ts

@@ -0,0 +1,24 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { z } from "zod";
+/** A file the phone uploaded for this call, staged on the environment until a day after its last use. */
+export type UploadedFile = {
+    id: string;
+    name: string;
+    type: string;
+    size: number;
+    path: string;
+};
+/** The files the host attached to the running call; a method it calls sees them too. */
+export declare const callFiles: AsyncLocalStorage<UploadedFile[]>;
+/**
+ * One file from an `<Upload>`: `files: z.array(upload())`. It accepts only a
+ * file the host attached to this call, so input written by hand can't point a
+ * method at another path. Copy what you keep: `put({ body: Bun.file(file.path) })`.
+ */
+export declare function upload(): z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    size: z.ZodNumber;
+    path: z.ZodString;
+}, z.core.$strip>;

package/dist/workflow/attempts.d.ts

@@ -0,0 +1,25 @@
+import type { WorkflowClock } from "./clock";
+import type { JournalFailure, JSONValue } from "./events";
+import type { StepPolicy } from "./policy";
+export type StepContext = {
+    stepId: string;
+    attempt: number;
+    attempts: number;
+    signal: AbortSignal;
+};
+export type AttemptOutcome<T> = {
+    type: "completed";
+    result: T;
+} | {
+    type: "failed";
+    error: JournalFailure;
+    retryable: boolean;
+} | {
+    type: "unknown";
+    error: JournalFailure;
+} | {
+    type: "stopped";
+    invoked: boolean;
+};
+/** A timed-out invocation retains ownership until its callback settles. */
+export declare function invokeAttempt<T extends JSONValue>(callback: (ctx: StepContext) => T | Promise<T>, stepId: string, attempt: number, policy: StepPolicy, limit: number, clock: WorkflowClock, signal: AbortSignal): Promise<AttemptOutcome<T>>;

package/dist/workflow/availability.d.ts

@@ -0,0 +1,8 @@
+export type Availability = {
+    seen: number;
+    offlineSince: number | null;
+};
+export type NetworkSource = () => boolean | null;
+/** An assigned nonlocal interface detects known disconnection without external probes. */
+export declare const networkAvailable: NetworkSource;
+export declare function nextAvailability(saved: Availability | null, now: number, online: boolean | null): Availability;

package/dist/workflow/catalog.d.ts

@@ -0,0 +1,21 @@
+import type { Availability } from "./availability";
+import type { RunMetadata, RunSummary } from "./contracts";
+export type CatalogRun = {
+    run: RunMetadata;
+    summary: RunSummary;
+    seen: number;
+    terminal: number | null;
+    error: string | null;
+};
+export declare class WorkflowCatalog {
+    private sql;
+    private release;
+    private constructor();
+    static open(directory: string): Promise<WorkflowCatalog>;
+    all(): Promise<CatalogRun[]>;
+    put(value: CatalogRun): Promise<void>;
+    availability(): Promise<Availability | null>;
+    heartbeat(value: Availability): Promise<void>;
+    remove(id: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/workflow/clock.d.ts

@@ -0,0 +1,6 @@
+export interface WorkflowClock {
+    now(): number;
+    schedule(at: number, callback: () => void): () => void;
+}
+export declare const systemClock: WorkflowClock;
+export declare function deadlineFrom(at: string, milliseconds: number): string;

package/dist/workflow/contracts.d.ts

@@ -0,0 +1,121 @@
+import type { describe } from "./summary";
+import { z } from "zod";
+import type { HostCaller, SentNotice } from "../runtime";
+import type { LogRecord } from "../logs";
+export declare const RunSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    workflow: z.ZodString;
+    status: z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        waiting: "waiting";
+        completed: "completed";
+        unknown: "unknown";
+        pending: "pending";
+        attention: "attention";
+        cancelled: "cancelled";
+        expired: "expired";
+        blocked: "blocked";
+    }>;
+    currentStep: z.ZodNullable<z.ZodString>;
+    attempt: z.ZodNumber;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    nextAttemptAt: z.ZodNullable<z.ZodString>;
+    deadlineAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type RunSummary = z.infer<typeof RunSummarySchema>;
+export type WorkflowTarget = {
+    dir: string;
+    plugin: string;
+    namespace: string;
+    workflow: string;
+    root: string;
+};
+export type WorkflowRequest = WorkflowTarget & {
+    operation: "start" | "list" | "get" | "cancel" | "cancelAll" | "retry" | "restart";
+    input: Record<string, unknown>;
+    caller?: "card" | "agent" | "cron" | "code" | "http";
+    settings?: {
+        timeoutMs: number;
+        maxOfflineMs: number;
+        retentionMs: number;
+    };
+};
+export type WorkflowBridge = (request: WorkflowRequest) => Promise<unknown>;
+export declare const RunMetadataSchema: z.ZodObject<{
+    id: z.ZodString;
+    dir: z.ZodString;
+    root: z.ZodString;
+    namespace: z.ZodString;
+    plugin: z.ZodString;
+    caller: z.ZodEnum<{
+        card: "card";
+        agent: "agent";
+        cron: "cron";
+        code: "code";
+        http: "http";
+    }>;
+    workflow: z.ZodString;
+    input: z.ZodJSONSchema;
+    key: z.ZodNullable<z.ZodString>;
+    timeoutMs: z.ZodNumber;
+    maxOfflineMs: z.ZodNumber;
+    retentionMs: z.ZodNumber;
+    createdAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const RunLocationSchema: z.ZodObject<{
+    id: z.ZodString;
+    key: z.ZodNullable<z.ZodString>;
+    maxOfflineMs: z.ZodNumber;
+    retentionMs: z.ZodNumber;
+    dir: z.ZodString;
+    root: z.ZodString;
+    namespace: z.ZodString;
+    plugin: z.ZodString;
+    caller: z.ZodEnum<{
+        card: "card";
+        agent: "agent";
+        cron: "cron";
+        code: "code";
+        http: "http";
+    }>;
+}, z.core.$strict>;
+export type RunMetadata = z.infer<typeof RunMetadataSchema>;
+export type ExecutorStart = {
+    type: "start";
+    run: RunMetadata;
+    directory: string;
+    dataDir: string;
+};
+export type ExecutorMessage = {
+    type: "host";
+    id: number;
+    plugin: string;
+    method: string;
+    params: unknown;
+} | {
+    type: "state";
+    summary: RunSummary;
+    detail: ReturnType<typeof describe>;
+} | {
+    type: "invalidated";
+    tags: string[];
+} | {
+    type: "notice";
+    notice: SentNotice;
+} | {
+    type: "log";
+    records: LogRecord[];
+} | {
+    type: "done";
+} | {
+    type: "error";
+    message: string;
+};
+export type WorkflowCallbacks = {
+    host: HostCaller;
+    invalidate: (tags: string[]) => void;
+    notify: (notice: SentNotice) => void;
+    logs: (dir: string, records: LogRecord[]) => void;
+};

package/dist/workflow/definition.d.ts

@@ -0,0 +1,35 @@
+import type { z } from "zod";
+import type { Context } from "../context";
+import type { Duration } from "../duration";
+import type { StepContext as AttemptContext } from "./attempts";
+import type { StepOptions } from "./policy";
+import type { JSONValue } from "./events";
+import type { RunContext } from "./runner";
+export type StepContext = AttemptContext & {
+    runId: string;
+    idempotencyKey: string;
+};
+export type WorkflowSteps = {
+    run<T extends JSONValue>(name: string, callback: (ctx: StepContext) => T | Promise<T>, options?: StepOptions): Promise<T>;
+};
+export type WorkflowContext = Context & Omit<RunContext, "step"> & {
+    runId: string;
+    step: WorkflowSteps;
+};
+export declare function workflowContext(base: Context, run: RunContext & {
+    root: string;
+    runId: string;
+}): WorkflowContext;
+export type WorkflowOptions<O extends z.ZodType = z.ZodType> = {
+    description?: string;
+    output?: O;
+    confirm?: string;
+    timeout?: Duration;
+    maxOffline?: Duration;
+    retention?: Duration;
+};
+export type Workflow<I extends z.ZodType = z.ZodType, O extends z.ZodType = z.ZodType> = WorkflowOptions<O> & {
+    input: I;
+    run: (input: z.infer<I>, ctx: WorkflowContext) => unknown | Promise<unknown>;
+};
+export declare function workflow<I extends z.ZodType, O extends z.ZodType = z.ZodType>(input: I, run: (input: z.infer<I>, ctx: WorkflowContext) => unknown | Promise<unknown>, options?: WorkflowOptions<O>): Workflow<I, O>;

package/dist/workflow/errors.d.ts

@@ -0,0 +1,19 @@
+import type { JournalFailure } from "./events";
+export declare class NonRetryable extends Error {
+    constructor(message: string);
+}
+export declare class RunnerError extends Error {
+    readonly code: "FAILED" | "BUSY" | "IDENTITY" | "REPLAY" | "CHANGED" | "ATTENTION" | "STEP" | "UNKNOWN" | "CANCELLED" | "EXPIRED" | "PAUSED" | "USAGE" | "WAITING";
+    readonly failure: JournalFailure | null;
+    constructor(code: "FAILED" | "BUSY" | "IDENTITY" | "REPLAY" | "CHANGED" | "ATTENTION" | "STEP" | "UNKNOWN" | "CANCELLED" | "EXPIRED" | "PAUSED" | "USAGE" | "WAITING", message: string, failure?: JournalFailure | null);
+}
+export declare class RunWaiting extends RunnerError {
+    readonly stepId: string;
+    readonly attempt: number;
+    readonly nextAttemptAt: string;
+    constructor(stepId: string, attempt: number, nextAttemptAt: string);
+}
+export declare function failure(error: unknown): JournalFailure;
+export declare function asError(error: unknown): Error;
+export declare function outcomeError(status: "failed" | "unknown", error: JournalFailure): RunnerError;
+export declare function terminalError(status: "cancelled" | "expired"): RunnerError;

package/dist/workflow/events.d.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+export declare const sleepId: (position: number) => string;
+declare const Failure: z.ZodObject<{
+    message: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const EventInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"run.started">;
+    workflow: z.ZodString;
+    input: z.ZodJSONSchema;
+    timeoutMs: z.ZodNumber;
+    location: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodNullable<z.ZodString>;
+        maxOfflineMs: z.ZodNumber;
+        retentionMs: z.ZodNumber;
+        dir: z.ZodString;
+        root: z.ZodString;
+        namespace: z.ZodString;
+        plugin: z.ZodString;
+        caller: z.ZodEnum<{
+            card: "card";
+            agent: "agent";
+            cron: "cron";
+            code: "code";
+            http: "http";
+        }>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"sleep.scheduled">;
+    sleepId: z.ZodString;
+    durationMs: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"sleep.completed">;
+    sleepId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    policy: z.ZodObject<{
+        kind: z.ZodEnum<{
+            query: "query";
+            mutation: "mutation";
+        }>;
+        attempts: z.ZodNumber;
+        timeoutMs: z.ZodNumber;
+        backoff: z.ZodObject<{
+            initialMs: z.ZodNumber;
+            factor: z.ZodNumber;
+            maxMs: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    stepId: z.ZodString;
+    attempt: z.ZodNumber;
+    type: z.ZodLiteral<"step.started">;
+}, z.core.$strict>, z.ZodObject<{
+    result: z.ZodJSONSchema;
+    stepId: z.ZodString;
+    attempt: z.ZodNumber;
+    type: z.ZodLiteral<"step.completed">;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    stepId: z.ZodString;
+    attempt: z.ZodNumber;
+    type: z.ZodLiteral<"step.failed">;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    stepId: z.ZodString;
+    attempt: z.ZodNumber;
+    type: z.ZodLiteral<"step.unknown">;
+}, z.core.$strict>, z.ZodObject<{
+    error: z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    delayMs: z.ZodNumber;
+    stepId: z.ZodString;
+    attempt: z.ZodNumber;
+    type: z.ZodLiteral<"step.retryScheduled">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.retryRequested">;
+    stepId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.completed">;
+    result: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.failed">;
+    error: z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.cancelRequested">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.cancelled">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.expired">;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.unknown">;
+    error: z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.attention">;
+    error: z.ZodObject<{
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"run.restarted">;
+}, z.core.$strict>], "type">;
+declare const Envelope: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    seq: z.ZodNumber;
+    at: z.ZodISODateTime;
+}, z.core.$strict>;
+export type EventInput = z.infer<typeof EventInputSchema>;
+export type JournalEvent = EventInput & z.infer<typeof Envelope>;
+export type JournalFailure = z.infer<typeof Failure>;
+export type JSONValue = z.infer<ReturnType<typeof z.json>>;
+export declare class JournalError extends Error {
+    readonly code: "NOT_DUE" | "INVALID_EVENT" | "CORRUPT_JOURNAL" | "LOCKED" | "CLOSED" | "POISONED" | "LIMIT";
+    constructor(code: "NOT_DUE" | "INVALID_EVENT" | "CORRUPT_JOURNAL" | "LOCKED" | "CLOSED" | "POISONED" | "LIMIT", message: string);
+}
+export declare function eventInput(value: unknown): EventInput;
+export declare function storedEvent(value: unknown): JournalEvent;
+export {};

package/dist/workflow/interrupted.d.ts

@@ -0,0 +1,3 @@
+import type { RunJournal } from "./journal";
+/** Terminal control preserves uncertainty about an attempt's external effects. */
+export declare function settleInterrupted(journal: RunJournal, code: "CANCELLED" | "EXPIRED"): Promise<void>;

package/dist/workflow/journal.d.ts

@@ -0,0 +1,28 @@
+import { type WorkflowClock } from "./clock";
+import { type EventInput, type JournalEvent } from "./events";
+import { type RunState } from "./state";
+import { type JournalStorage } from "./storage";
+/** Internal durable history for one run; the snapshot is only a readable projection. */
+export declare class RunJournal {
+    private storage;
+    readonly clock: WorkflowClock;
+    private value;
+    private listeners;
+    private bytes;
+    private queue;
+    private closing;
+    private poisoned;
+    private snapshotFailure;
+    private constructor();
+    static open(directory: string, clock?: WorkflowClock): Promise<RunJournal>;
+    static openExisting(directory: string, clock?: WorkflowClock): Promise<RunJournal>;
+    /** The injected storage owns its lock; recovery closes it on failure. */
+    static recover(storage: JournalStorage, clock: WorkflowClock): Promise<RunJournal>;
+    onChange(listener: () => void): () => void;
+    get state(): RunState;
+    /** A failed snapshot does not invalidate an event already committed to the journal. */
+    get snapshotError(): unknown;
+    append(input: EventInput): Promise<JournalEvent>;
+    close(): Promise<void>;
+    private checkpoint;
+}

package/dist/workflow/lease.d.ts

@@ -0,0 +1,2 @@
+/** An OS-managed SQLite lock is released on process death without stale-file deletion. */
+export declare function acquireOwner(path: string): Promise<() => Promise<void>>;

package/dist/workflow/lifetime.d.ts

@@ -0,0 +1,27 @@
+import type { WorkflowClock } from "./clock";
+import type { RunJournal } from "./journal";
+/** Cancellation is durable before notifying callbacks; expiry already has a recorded deadline. */
+export declare class RunLifetime {
+    private journal;
+    private clock;
+    readonly deadlineAt: string | null;
+    private signal?;
+    private suspend?;
+    private maxOfflineMs?;
+    readonly controller: AbortController;
+    reason: "cancelled" | "expired" | "paused" | null;
+    private pending;
+    private closed;
+    private failure;
+    expiryReason: string;
+    private lastSeen;
+    private removeHeartbeat;
+    private removeTimer;
+    private pause;
+    private cancel;
+    constructor(journal: RunJournal, clock: WorkflowClock, deadlineAt: string | null, signal?: AbortSignal | undefined, suspend?: AbortSignal | undefined, maxOfflineMs?: number | undefined);
+    private heartbeat;
+    check(): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/workflow/policy.d.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { type Duration } from "../duration";
+declare const StepOptionsSchema: z.ZodObject<{
+    kind: z.ZodOptional<z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+    }>>;
+    attempts: z.ZodOptional<z.ZodNumber>;
+    timeout: z.ZodOptional<z.ZodCustom<Duration, Duration>>;
+    backoff: z.ZodOptional<z.ZodObject<{
+        initial: z.ZodOptional<z.ZodCustom<Duration, Duration>>;
+        factor: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodCustom<Duration, Duration>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StepOptions = z.infer<typeof StepOptionsSchema>;
+export declare const maxDurationMs: number;
+export declare const DurationMsSchema: z.ZodNumber;
+export declare const StepPolicySchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        query: "query";
+        mutation: "mutation";
+    }>;
+    attempts: z.ZodNumber;
+    timeoutMs: z.ZodNumber;
+    backoff: z.ZodObject<{
+        initialMs: z.ZodNumber;
+        factor: z.ZodNumber;
+        maxMs: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type StepPolicy = z.infer<typeof StepPolicySchema>;
+export declare function durationMs(value: Duration): number;
+export declare function stepPolicy(options?: StepOptions): StepPolicy;
+export declare function retryDelay(policy: StepPolicy, attempt: number, random: () => number): number;
+export {};

package/dist/workflow/register.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from "../context";
+import type { RegisteredMethod } from "../runtime";
+import type { Workflow } from "./definition";
+import type { WorkflowBridge } from "./contracts";
+export declare function workflowTag(namespace: string): string;
+export declare function workflowMethods(plugin: string, namespace: string, name: string, definition: Workflow, ctx: Context, bridge: WorkflowBridge | undefined, directory: () => string | null): RegisteredMethod[];
+export declare function workflowSettings(definition: Workflow): {
+    timeoutMs: number;
+    maxOfflineMs: number;
+    retentionMs: number;
+};

package/dist/workflow/retry.d.ts

@@ -0,0 +1,14 @@
+import { type StepContext } from "./attempts";
+import { type WorkflowClock } from "./clock";
+import { RunWaiting } from "./errors";
+import { type JournalFailure, type JSONValue } from "./events";
+import type { RunJournal } from "./journal";
+import type { RunLifetime } from "./lifetime";
+import { type StepPolicy } from "./policy";
+import type { StepState } from "./state";
+export type ExecutionEnvironment = {
+    clock: WorkflowClock;
+    random: () => number;
+};
+export declare function scheduleRetry(append: RunJournal["append"], name: string, attempt: number, policy: StepPolicy, error: JournalFailure, environment: ExecutionEnvironment): Promise<RunWaiting>;
+export declare function executeStep<T extends JSONValue>(name: string, callback: (ctx: StepContext) => T | Promise<T>, policy: StepPolicy, saved: StepState | undefined, append: RunJournal["append"], environment: ExecutionEnvironment, lifetime: RunLifetime, stopped: () => unknown, markUncertain: () => void): Promise<T>;

package/dist/workflow/runner.d.ts

@@ -0,0 +1,29 @@
+import type { Duration } from "../duration";
+import type { StepContext } from "./attempts";
+import { type JSONValue } from "./events";
+import { RunJournal } from "./journal";
+import { type StepOptions } from "./policy";
+export { RunnerError, RunWaiting, NonRetryable } from "./errors";
+export type { StepContext } from "./attempts";
+export type { StepOptions } from "./policy";
+export type RunIdentity = {
+    workflow: string;
+    input: JSONValue;
+};
+export type WorkflowSteps = {
+    run<T extends JSONValue>(name: string, callback: (ctx: StepContext) => T | Promise<T>, options?: StepOptions): Promise<T>;
+};
+export type RunContext = {
+    step: WorkflowSteps;
+    sleep: (duration: Duration) => Promise<void>;
+    signal: AbortSignal;
+};
+export type RunOptions = {
+    timeout?: Duration;
+    maxOffline?: Duration;
+    signal?: AbortSignal;
+    suspend?: AbortSignal;
+    random?: () => number;
+};
+/** Internal executor over the current code; callers own journal closure. */
+export declare function runWorkflow<T extends JSONValue>(journal: RunJournal, identity: RunIdentity, handler: (input: JSONValue, ctx: RunContext) => T | Promise<T>, options?: RunOptions): Promise<T>;

package/dist/workflow/scope.d.ts

@@ -0,0 +1,4 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import type { StepContext } from "./attempts";
+export declare const attemptScope: AsyncLocalStorage<StepContext>;
+export declare const workflowScope: AsyncLocalStorage<boolean>;

package/dist/workflow/service.d.ts

@@ -0,0 +1,48 @@
+import { type NetworkSource } from "./availability";
+import { type WorkflowClock } from "./clock";
+import { type RunSummary, type WorkflowCallbacks, type WorkflowRequest } from "./contracts";
+export declare class WorkflowService {
+    private dataDir;
+    private catalog;
+    private callbacks;
+    private clock;
+    private storageLimit;
+    private network;
+    private queue;
+    private details;
+    private rows;
+    private unrecovered;
+    private maintenanceErrors;
+    private cancelling;
+    private active;
+    private observers;
+    private timer;
+    private closing;
+    private started;
+    private constructor();
+    static open(dataDir: string, callbacks: WorkflowCallbacks, options?: {
+        clock?: WorkflowClock;
+        storageLimit?: number;
+        network?: NetworkSource;
+    }): Promise<WorkflowService>;
+    private directory;
+    private serial;
+    observe(listener: (summary: RunSummary) => void): () => void;
+    start(): void;
+    private wake;
+    private save;
+    request(request: WorkflowRequest): Promise<unknown>;
+    /** Cancels every unfinished run of the workflow in the project, or only those in one status. */
+    private cancelAll;
+    /** A run whose process already exited, as a sleeping one's has, is cancelled from its journal. */
+    private cancel;
+    private cancelIdle;
+    private cancelActive;
+    private create;
+    tick(): Promise<void>;
+    private launch;
+    private openJournal;
+    private recoverCatalog;
+    private bytes;
+    close(): Promise<void>;
+}

package/dist/workflow/sleep.d.ts

@@ -0,0 +1,6 @@
+import type { Duration } from "../duration";
+import type { WorkflowClock } from "./clock";
+import type { RunJournal } from "./journal";
+import type { SleepState } from "./state";
+/** The scheduled event anchors the wait; replay never calculates a fresh deadline. */
+export declare function executeSleep(id: string, duration: Duration, saved: SleepState | undefined, append: RunJournal["append"], clock: WorkflowClock, check: () => void): Promise<void>;