opencode-plugin-flow 4.1.10 → 4.1.12

package/dist/runtime/api.d.ts

@@ -0,0 +1,123 @@
+import { z } from "zod";
+export type RuntimeResponse = Record<string, unknown>;
+export declare const FlowPlanSaveSchema: z.ZodObject<{
+    goal: z.ZodOptional<z.ZodString>;
+    plan: z.ZodOptional<z.ZodObject<{
+        summary: z.ZodString;
+        overview: z.ZodString;
+        requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        finalReviewPolicy: z.ZodOptional<z.ZodEnum<{
+            broad: "broad";
+            detailed: "detailed";
+        }>>;
+        features: z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            id: z.ZodString;
+            title: z.ZodString;
+            status: z.ZodOptional<z.ZodEnum<{
+                pending: "pending";
+                in_progress: "in_progress";
+                completed: "completed";
+                blocked: "blocked";
+            }>>;
+            targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            validation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const FlowRunStartSchema: z.ZodObject<{
+    featureId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const FlowFeatureResetSchema: z.ZodObject<{
+    featureId: z.ZodString;
+}, z.core.$strict>;
+export declare const FlowSessionCloseSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        completed: "completed";
+        deferred: "deferred";
+        abandoned: "abandoned";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const FlowFeatureCompleteToolSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        ok: "ok";
+        needs_input: "needs_input";
+    }>;
+    featureId: z.ZodString;
+    summary: z.ZodString;
+    artifactsChanged: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>>;
+    validationRun: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+    }, z.core.$strict>>>;
+    validationScope: z.ZodOptional<z.ZodEnum<{
+        targeted: "targeted";
+        broad: "broad";
+    }>>;
+    featureReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    finalReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+        reviewDepth: z.ZodEnum<{
+            broad: "broad";
+            detailed: "detailed";
+        }>;
+    }, z.core.$strict>>;
+    outcome: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            completed: "completed";
+            blocked: "blocked";
+            needs_input: "needs_input";
+            replan_required: "replan_required";
+        }>>;
+        summary: z.ZodOptional<z.ZodString>;
+        resolutionHint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            blocked: "blocked";
+            needs_input: "needs_input";
+            replan_required: "replan_required";
+        }>>;
+        summary: z.ZodString;
+        resolutionHint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare function flowStatus(worktree: string): Promise<RuntimeResponse>;
+export declare function flowPlanSave(worktree: string, input: unknown): Promise<RuntimeResponse>;
+export declare function flowPlanApprove(worktree: string): Promise<RuntimeResponse>;
+export declare function flowRunStart(worktree: string, input: unknown): Promise<RuntimeResponse>;
+export declare function flowFeatureComplete(worktree: string, input: unknown): Promise<RuntimeResponse>;
+export declare function flowFeatureReset(worktree: string, input: unknown): Promise<RuntimeResponse>;
+export declare function flowSessionClose(worktree: string, input: unknown): Promise<RuntimeResponse>;

package/dist/runtime/json/strict-object.d.ts

@@ -0,0 +1,9 @@
+type StrictJsonObjectParseResult = {
+    ok: true;
+    value: Record<string, unknown>;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function parseStrictJsonObject(raw: string, label: string): StrictJsonObjectParseResult;
+export {};

package/dist/runtime/schema.d.ts

@@ -0,0 +1,490 @@
+import { z } from "zod";
+export declare const FEATURE_ID_PATTERN: RegExp;
+export declare const FEATURE_ID_MESSAGE = "Feature ids must be lowercase kebab-case";
+export declare const FeatureStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    in_progress: "in_progress";
+    completed: "completed";
+    blocked: "blocked";
+}>;
+export declare const SessionStatusSchema: z.ZodEnum<{
+    completed: "completed";
+    blocked: "blocked";
+    planning: "planning";
+    ready: "ready";
+    running: "running";
+}>;
+export declare const ReviewStatusSchema: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+}>;
+export declare const ValidationStatusSchema: z.ZodEnum<{
+    passed: "passed";
+    failed: "failed";
+}>;
+export declare const ValidationScopeSchema: z.ZodEnum<{
+    targeted: "targeted";
+    broad: "broad";
+}>;
+export declare const FinalReviewPolicySchema: z.ZodEnum<{
+    broad: "broad";
+    detailed: "detailed";
+}>;
+export declare const ReviewFindingSchema: z.ZodObject<{
+    summary: z.ZodString;
+    severity: z.ZodDefault<z.ZodEnum<{
+        blocking: "blocking";
+        advisory: "advisory";
+    }>>;
+}, z.core.$strict>;
+export declare const ReviewSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    summary: z.ZodString;
+    blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        summary: z.ZodString;
+        severity: z.ZodDefault<z.ZodEnum<{
+            blocking: "blocking";
+            advisory: "advisory";
+        }>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export declare const FinalReviewSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    summary: z.ZodString;
+    blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        summary: z.ZodString;
+        severity: z.ZodDefault<z.ZodEnum<{
+            blocking: "blocking";
+            advisory: "advisory";
+        }>>;
+    }, z.core.$strict>>>;
+    reviewDepth: z.ZodEnum<{
+        broad: "broad";
+        detailed: "detailed";
+    }>;
+}, z.core.$strict>;
+export declare const ValidationRunSchema: z.ZodObject<{
+    command: z.ZodString;
+    status: z.ZodEnum<{
+        passed: "passed";
+        failed: "failed";
+    }>;
+    summary: z.ZodString;
+}, z.core.$strict>;
+export declare const ArtifactSchema: z.ZodObject<{
+    path: z.ZodString;
+}, z.core.$strict>;
+export declare const FeatureSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    summary: z.ZodString;
+    status: z.ZodDefault<z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        blocked: "blocked";
+    }>>;
+    targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const PlanSchema: z.ZodObject<{
+    summary: z.ZodString;
+    overview: z.ZodString;
+    requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    finalReviewPolicy: z.ZodDefault<z.ZodEnum<{
+        broad: "broad";
+        detailed: "detailed";
+    }>>;
+    features: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        summary: z.ZodString;
+        status: z.ZodDefault<z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+            blocked: "blocked";
+        }>>;
+        targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const PlanInputSchema: z.ZodObject<{
+    summary: z.ZodString;
+    overview: z.ZodString;
+    requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    finalReviewPolicy: z.ZodOptional<z.ZodEnum<{
+        broad: "broad";
+        detailed: "detailed";
+    }>>;
+    features: z.ZodArray<z.ZodObject<{
+        summary: z.ZodString;
+        id: z.ZodString;
+        title: z.ZodString;
+        status: z.ZodOptional<z.ZodEnum<{
+            pending: "pending";
+            in_progress: "in_progress";
+            completed: "completed";
+            blocked: "blocked";
+        }>>;
+        targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        validation: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const WorkerOutcomeSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        needs_input: "needs_input";
+        replan_required: "replan_required";
+    }>>;
+    summary: z.ZodOptional<z.ZodString>;
+    resolutionHint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const NeedsInputOutcomeSchema: z.ZodObject<{
+    kind: z.ZodDefault<z.ZodEnum<{
+        blocked: "blocked";
+        needs_input: "needs_input";
+        replan_required: "replan_required";
+    }>>;
+    summary: z.ZodString;
+    resolutionHint: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const WorkerResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"ok">;
+    featureId: z.ZodString;
+    summary: z.ZodString;
+    artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>>;
+    validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+    }, z.core.$strict>>>;
+    validationScope: z.ZodEnum<{
+        targeted: "targeted";
+        broad: "broad";
+    }>;
+    featureReview: z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>;
+    finalReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+        reviewDepth: z.ZodEnum<{
+            broad: "broad";
+            detailed: "detailed";
+        }>;
+    }, z.core.$strict>>;
+    outcome: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            completed: "completed";
+            blocked: "blocked";
+            needs_input: "needs_input";
+            replan_required: "replan_required";
+        }>>;
+        summary: z.ZodOptional<z.ZodString>;
+        resolutionHint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"needs_input">;
+    featureId: z.ZodString;
+    summary: z.ZodString;
+    artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>>;
+    validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+    }, z.core.$strict>>>;
+    validationScope: z.ZodOptional<z.ZodEnum<{
+        targeted: "targeted";
+        broad: "broad";
+    }>>;
+    featureReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    finalReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+        reviewDepth: z.ZodEnum<{
+            broad: "broad";
+            detailed: "detailed";
+        }>;
+    }, z.core.$strict>>;
+    outcome: z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            blocked: "blocked";
+            needs_input: "needs_input";
+            replan_required: "replan_required";
+        }>>;
+        summary: z.ZodString;
+        resolutionHint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "status">;
+export declare const ExecutionHistoryEntrySchema: z.ZodObject<{
+    featureId: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        needs_input: "needs_input";
+    }>;
+    summary: z.ZodString;
+    recordedAt: z.ZodString;
+    artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>>>;
+    validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+    }, z.core.$strict>>>;
+    validationScope: z.ZodOptional<z.ZodEnum<{
+        targeted: "targeted";
+        broad: "broad";
+    }>>;
+    featureReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    finalReview: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            passed: "passed";
+            failed: "failed";
+        }>;
+        summary: z.ZodString;
+        blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            summary: z.ZodString;
+            severity: z.ZodDefault<z.ZodEnum<{
+                blocking: "blocking";
+                advisory: "advisory";
+            }>>;
+        }, z.core.$strict>>>;
+        reviewDepth: z.ZodEnum<{
+            broad: "broad";
+            detailed: "detailed";
+        }>;
+    }, z.core.$strict>>;
+    outcome: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodDefault<z.ZodEnum<{
+            completed: "completed";
+            blocked: "blocked";
+            needs_input: "needs_input";
+            replan_required: "replan_required";
+        }>>;
+        summary: z.ZodOptional<z.ZodString>;
+        resolutionHint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const SessionSchema: z.ZodObject<{
+    version: z.ZodLiteral<2>;
+    id: z.ZodString;
+    goal: z.ZodString;
+    status: z.ZodEnum<{
+        completed: "completed";
+        blocked: "blocked";
+        planning: "planning";
+        ready: "ready";
+        running: "running";
+    }>;
+    approval: z.ZodEnum<{
+        pending: "pending";
+        approved: "approved";
+    }>;
+    plan: z.ZodNullable<z.ZodObject<{
+        summary: z.ZodString;
+        overview: z.ZodString;
+        requirements: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        decisions: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        finalReviewPolicy: z.ZodDefault<z.ZodEnum<{
+            broad: "broad";
+            detailed: "detailed";
+        }>>;
+        features: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            summary: z.ZodString;
+            status: z.ZodDefault<z.ZodEnum<{
+                pending: "pending";
+                in_progress: "in_progress";
+                completed: "completed";
+                blocked: "blocked";
+            }>>;
+            targets: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            validation: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            dependsOn: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    activeFeatureId: z.ZodNullable<z.ZodString>;
+    history: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        featureId: z.ZodString;
+        status: z.ZodEnum<{
+            completed: "completed";
+            blocked: "blocked";
+            needs_input: "needs_input";
+        }>;
+        summary: z.ZodString;
+        recordedAt: z.ZodString;
+        artifactsChanged: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>>>;
+        validationRun: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>;
+            summary: z.ZodString;
+        }, z.core.$strict>>>;
+        validationScope: z.ZodOptional<z.ZodEnum<{
+            targeted: "targeted";
+            broad: "broad";
+        }>>;
+        featureReview: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>;
+            summary: z.ZodString;
+            blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                summary: z.ZodString;
+                severity: z.ZodDefault<z.ZodEnum<{
+                    blocking: "blocking";
+                    advisory: "advisory";
+                }>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>>;
+        finalReview: z.ZodOptional<z.ZodObject<{
+            status: z.ZodEnum<{
+                passed: "passed";
+                failed: "failed";
+            }>;
+            summary: z.ZodString;
+            blockingFindings: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                summary: z.ZodString;
+                severity: z.ZodDefault<z.ZodEnum<{
+                    blocking: "blocking";
+                    advisory: "advisory";
+                }>>;
+            }, z.core.$strict>>>;
+            reviewDepth: z.ZodEnum<{
+                broad: "broad";
+                detailed: "detailed";
+            }>;
+        }, z.core.$strict>>;
+        outcome: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodDefault<z.ZodEnum<{
+                completed: "completed";
+                blocked: "blocked";
+                needs_input: "needs_input";
+                replan_required: "replan_required";
+            }>>;
+            summary: z.ZodOptional<z.ZodString>;
+            resolutionHint: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>>;
+    closure: z.ZodNullable<z.ZodObject<{
+        kind: z.ZodEnum<{
+            completed: "completed";
+            deferred: "deferred";
+            abandoned: "abandoned";
+        }>;
+        summary: z.ZodString;
+        recordedAt: z.ZodString;
+    }, z.core.$strict>>;
+    lastError: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        tool: z.ZodString;
+        summary: z.ZodString;
+        recovery: z.ZodOptional<z.ZodString>;
+        recordedAt: z.ZodString;
+    }, z.core.$strict>>>;
+    timestamps: z.ZodObject<{
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+        completedAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type Artifact = z.infer<typeof ArtifactSchema>;
+export type ExecutionHistoryEntry = z.infer<typeof ExecutionHistoryEntrySchema>;
+export type Feature = z.infer<typeof FeatureSchema>;
+export type FinalReview = z.infer<typeof FinalReviewSchema>;
+export type Plan = z.infer<typeof PlanSchema>;
+export type PlanInput = z.input<typeof PlanInputSchema>;
+export type Review = z.infer<typeof ReviewSchema>;
+export type Session = z.infer<typeof SessionSchema>;
+export type ValidationRun = z.infer<typeof ValidationRunSchema>;
+export type WorkerResult = z.infer<typeof WorkerResultSchema>;

package/dist/runtime/time.d.ts

@@ -0,0 +1,2 @@
+export declare function setNowForTests(next: (() => string) | null): void;
+export declare function nowIso(): string;