@vercel/factory 0.0.0

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+import { T as Task, a as TaskId, F as FactoryStores, C as ChangeState, S as SignalOutcome, b as TaskState } from './engine-BXVTLiXU.js';
+export { A as AppendReceiptInput, c as Change, d as ChangeEvidence, e as ChangeId, f as ChangePatch, g as ChangeTransitionOptions, h as Cost, i as CreateChangeInput, j as CreateSignalInput, k as CreateStoresOptions, l as CreateTaskInput, D as DecideSignalOptions, m as FactoryId, L as Level, R as Receipt, n as ReceiptId, o as ReceiptKind, p as ReceiptPhase, q as ReceiptState, r as Repository, s as RepositoryId, t as RepositorySlug, u as Signal, v as SignalId, w as SignalSource, x as TaskKind, y as TaskPatch, z as TaskTransitionOptions, B as changeEvidenceSchema, E as changeIdSchema, G as changeSchema, H as changeStateSchema, I as costSchema, J as createStores, K as factoryIdSchema, M as harnessSchema, N as levelSchema, O as receiptIdSchema, P as receiptKindSchema, Q as receiptPhaseSchema, U as receiptSchema, V as receiptStateSchema, W as repositoryIdSchema, X as repositoryIdsSchema, Y as repositorySchema, Z as repositorySlugSchema, _ as signalIdSchema, $ as signalOutcomeSchema, a0 as signalSchema, a1 as signalSourceSchema, a2 as standardReceiptKinds, a3 as standardReceiptPhases, a4 as standardReceiptStates, a5 as standardSignalSources, a6 as standardTaskKinds, a7 as taskDevboxSchema, a8 as taskIdSchema, a9 as taskKindSchema, aa as taskOriginSchema, ab as taskQuestionSchema, ac as taskSchema, ad as taskStateSchema } from './engine-BXVTLiXU.js';
+import { z } from 'zod';
+export { R as ReplyTo, S as SCHEMA_VERSION, i as isoDateTimeSchema, r as replyToSchema, s as schemaVersionSchema, u as usdSchema, v as vocabularySchema } from './common-CaHaEOAS.js';
+import { S as StoreDriver } from './driver-tRNggCCJ.js';
+export { C as CollectionName, R as RecordExistsError, a as RecordNotFoundError, b as StoredEntry, c as StoredRecord, V as VersionConflictError } from './driver-tRNggCCJ.js';
+
+declare class DispatchRefusedError extends Error {
+    readonly taskId: TaskId;
+    readonly reason: string;
+    constructor(taskId: TaskId, reason: string);
+}
+interface DispatchOptions {
+    /**
+     * Starts the durable execution for the task (an Eve agent run). Runs after
+     * the task has won the queued -> running transition. The execution owns its
+     * own provisioning: it creates its Devbox as its first step and patches the
+     * task record with the result.
+     */
+    launch: (task: Task) => Promise<void>;
+}
+/**
+ * The handshake between recorded work and execution: win the store-gated
+ * transition (at most one dispatcher can succeed), then start the run. A
+ * launch failure moves the task to failed; a crash between the transition and
+ * the launch leaves a running task with no execution, which the sweep reaps.
+ */
+declare function dispatchTask(stores: FactoryStores, taskId: TaskId, options: DispatchOptions): Promise<Task>;
+
+declare const budgetMonthSchema: z.ZodString;
+declare const budgetSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    factoryId: z.ZodString;
+    month: z.ZodString;
+    limits: z.ZodObject<{
+        totalUsd: z.ZodNumber;
+        investigationUsd: z.ZodNumber;
+        perTaskReservationUsd: z.ZodNumber;
+        warningPercent: z.ZodNumber;
+        perRepositoryUsd: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strict>;
+    notices: z.ZodObject<{
+        warningAt: z.ZodOptional<z.ZodISODateTime>;
+        exhaustedAt: z.ZodOptional<z.ZodISODateTime>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type Budget = z.infer<typeof budgetSchema>;
+
+type TransitionActor = "system" | "reconciler" | "foreman" | "operator" | "webhook" | "human";
+interface Transition<State extends string> {
+    readonly from: State;
+    readonly to: State;
+    readonly trigger: string;
+    readonly actor: TransitionActor;
+}
+declare const taskInitialState = "queued";
+declare const taskTransitions: readonly Transition<TaskState>[];
+declare const changeInitialState = "verifying";
+declare const changeTransitions: readonly Transition<ChangeState>[];
+declare const signalInitialOutcome = "pending";
+declare const signalOutcomeTransitions: readonly Transition<SignalOutcome>[];
+declare function isTransitionAllowed<State extends string>(transitions: readonly Transition<State>[], from: State, to: State): boolean;
+declare function legalNextStates<State extends string>(transitions: readonly Transition<State>[], from: State): readonly State[];
+declare class InvalidTransitionError<State extends string> extends Error {
+    readonly from: State;
+    readonly to: State;
+    readonly legalNextStates: readonly State[];
+    constructor(from: State, to: State, legal: readonly State[]);
+}
+declare function assertTransition<State extends string>(transitions: readonly Transition<State>[], from: State, to: State): void;
+declare function terminalStates<State extends string>(transitions: readonly Transition<State>[]): readonly State[];
+
+declare function createInMemoryDriver(): StoreDriver;
+
+export { type Budget, ChangeState, type DispatchOptions, DispatchRefusedError, FactoryStores, InvalidTransitionError, SignalOutcome, StoreDriver, Task, TaskId, TaskState, type Transition, type TransitionActor, assertTransition, budgetMonthSchema, budgetSchema, changeInitialState, changeTransitions, createInMemoryDriver, dispatchTask, isTransitionAllowed, legalNextStates, signalInitialOutcome, signalOutcomeTransitions, taskInitialState, taskTransitions, terminalStates };