@vercel/factory 0.0.3 → 0.0.4

package/dist/approval-h5aj8HYN.d.mts

@@ -0,0 +1,510 @@
+import { i as StoreDriver } from "./driver-CrZsy7sm.mjs";
+import { c as ReplyTo, n as SignalOutcome, r as SignalSource, t as Signal } from "./signal-CHVEmzvI.mjs";
+import { z } from "zod";
+//#region src/schema/id.d.ts
+declare const factoryIdSchema: z.ZodString;
+declare const repositoryIdSchema: z.ZodString;
+declare const signalIdSchema: z.ZodString;
+declare const taskIdSchema: z.ZodString;
+declare const changeIdSchema: z.ZodString;
+declare const receiptIdSchema: z.ZodString;
+declare const repositoryIdsSchema: z.ZodArray<z.ZodString>;
+type FactoryId = z.infer<typeof factoryIdSchema>;
+type RepositoryId = z.infer<typeof repositoryIdSchema>;
+type SignalId = z.infer<typeof signalIdSchema>;
+type TaskId = z.infer<typeof taskIdSchema>;
+type ChangeId = z.infer<typeof changeIdSchema>;
+type ReceiptId = z.infer<typeof receiptIdSchema>;
+//#endregion
+//#region src/schema/change.d.ts
+declare const levelSchema: z.ZodEnum<{
+  low: "low";
+  medium: "medium";
+  high: "high";
+}>;
+declare const changeStateSchema: z.ZodEnum<{
+  verifying: "verifying";
+  ready: "ready";
+  merged: "merged";
+  deployed: "deployed";
+  rolled_out: "rolled_out";
+  rolled_back: "rolled_back";
+  closed: "closed";
+}>;
+declare const changeEvidenceSchema: z.ZodObject<{
+  reproVerified: z.ZodBoolean;
+  testsAdded: z.ZodNumber;
+  checksGreen: z.ZodBoolean;
+  attackPassed: z.ZodBoolean;
+  scopeMatches: z.ZodBoolean;
+  previewUrl: z.ZodOptional<z.ZodURL>;
+}, z.core.$strict>;
+declare const changeSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  repositoryId: z.ZodString;
+  taskId: z.ZodOptional<z.ZodString>;
+  groupId: z.ZodOptional<z.ZodString>;
+  prNumber: z.ZodNumber;
+  prUrl: z.ZodURL;
+  author: z.ZodString;
+  risk: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>;
+  confidence: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+  }>;
+  evidence: z.ZodObject<{
+    reproVerified: z.ZodBoolean;
+    testsAdded: z.ZodNumber;
+    checksGreen: z.ZodBoolean;
+    attackPassed: z.ZodBoolean;
+    scopeMatches: z.ZodBoolean;
+    previewUrl: z.ZodOptional<z.ZodURL>;
+  }, z.core.$strict>;
+  state: z.ZodEnum<{
+    verifying: "verifying";
+    ready: "ready";
+    merged: "merged";
+    deployed: "deployed";
+    rolled_out: "rolled_out";
+    rolled_back: "rolled_back";
+    closed: "closed";
+  }>;
+  decidedBy: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodISODateTime;
+  updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type Level = z.infer<typeof levelSchema>;
+type ChangeState = z.infer<typeof changeStateSchema>;
+type ChangeEvidence = z.infer<typeof changeEvidenceSchema>;
+type Change = z.infer<typeof changeSchema>;
+//#endregion
+//#region src/schema/receipt.d.ts
+/** States the engine writes on transitions. Any vocabulary value is valid. */
+declare const standardReceiptStates: readonly ["approved", "rejected", "dispatched", "succeeded", "failed", "needs_human", "cancelled", "settled", "merged", "deployed", "rolled_out", "rolled_back"];
+/** Phases the standard loop uses. Any vocabulary value is valid. */
+declare const standardReceiptPhases: readonly ["approval", "budget", "dispatch", "implementation", "verification", "pull_request", "cleanup"];
+/** Kinds the standard loop writes: the standard task kinds plus "change". */
+declare const standardReceiptKinds: readonly ["code_change", "verification", "investigation", "question", "change"];
+declare const receiptStateSchema: z.ZodString;
+declare const receiptPhaseSchema: z.ZodString;
+declare const receiptKindSchema: z.ZodString;
+declare const costSchema: z.ZodObject<{
+  totalUsd: z.ZodNumber;
+}, z.core.$strict>;
+declare const receiptSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  receiptId: z.ZodString;
+  repositoryIds: z.ZodArray<z.ZodString>;
+  taskId: z.ZodOptional<z.ZodString>;
+  changeId: z.ZodOptional<z.ZodString>;
+  kind: z.ZodString;
+  state: z.ZodString;
+  phase: z.ZodOptional<z.ZodString>;
+  reason: z.ZodOptional<z.ZodString>;
+  attempt: z.ZodNumber;
+  cost: z.ZodOptional<z.ZodObject<{
+    totalUsd: z.ZodNumber;
+  }, z.core.$strict>>;
+  decidedBy: z.ZodOptional<z.ZodString>;
+  recordedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type ReceiptState = z.infer<typeof receiptStateSchema>;
+type ReceiptPhase = z.infer<typeof receiptPhaseSchema>;
+type ReceiptKind = z.infer<typeof receiptKindSchema>;
+type Cost = z.infer<typeof costSchema>;
+type Receipt = z.infer<typeof receiptSchema>;
+//#endregion
+//#region src/schema/repository.d.ts
+declare const repositorySlugSchema: z.ZodString;
+declare const repositorySchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  slug: z.ZodString;
+  defaultBranch: z.ZodString;
+  enabled: z.ZodBoolean;
+  dependsOn: z.ZodArray<z.ZodString>;
+  devbox: z.ZodOptional<z.ZodObject<{
+    projectId: z.ZodString;
+    teamId: z.ZodString;
+    snapshot: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  connectedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type RepositorySlug = z.infer<typeof repositorySlugSchema>;
+type Repository = z.infer<typeof repositorySchema>;
+//#endregion
+//#region src/schema/task.d.ts
+/**
+ * Kinds the standard loop understands. Any vocabulary value is valid; the
+ * kind-scoped rules below apply only to these standard kinds.
+ */
+declare const standardTaskKinds: readonly ["code_change", "verification", "investigation", "question"];
+declare const taskKindSchema: z.ZodString;
+declare const taskStateSchema: z.ZodEnum<{
+  queued: "queued";
+  running: "running";
+  verifying: "verifying";
+  succeeded: "succeeded";
+  failed: "failed";
+  needs_human: "needs_human";
+  cancelled: "cancelled";
+}>;
+declare const taskApprovalSchema: z.ZodEnum<{
+  required: "required";
+  granted: "granted";
+  denied: "denied";
+}>;
+declare const harnessSchema: z.ZodString;
+declare const taskOriginSchema: z.ZodObject<{
+  signalId: z.ZodOptional<z.ZodString>;
+  parentTaskId: z.ZodOptional<z.ZodString>;
+  operator: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const taskDevboxSchema: z.ZodObject<{
+  devboxId: z.ZodString;
+  remoteId: z.ZodString;
+  harness: z.ZodString;
+}, z.core.$strict>;
+declare const taskQuestionSchema: z.ZodObject<{
+  text: z.ZodString;
+  options: z.ZodArray<z.ZodString>;
+  answer: z.ZodOptional<z.ZodString>;
+  answeredBy: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const taskSchema: z.ZodObject<{
+  schemaVersion: z.ZodLiteral<1>;
+  id: z.ZodString;
+  repositoryIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  kind: z.ZodString;
+  area: z.ZodOptional<z.ZodString>;
+  state: z.ZodEnum<{
+    queued: "queued";
+    running: "running";
+    verifying: "verifying";
+    succeeded: "succeeded";
+    failed: "failed";
+    needs_human: "needs_human";
+    cancelled: "cancelled";
+  }>;
+  approval: z.ZodOptional<z.ZodEnum<{
+    required: "required";
+    granted: "granted";
+    denied: "denied";
+  }>>;
+  origin: z.ZodObject<{
+    signalId: z.ZodOptional<z.ZodString>;
+    parentTaskId: z.ZodOptional<z.ZodString>;
+    operator: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  replyTo: z.ZodObject<{
+    channel: z.ZodString;
+    address: z.ZodString;
+  }, z.core.$strict>;
+  devbox: z.ZodOptional<z.ZodObject<{
+    devboxId: z.ZodString;
+    remoteId: z.ZodString;
+    harness: z.ZodString;
+  }, z.core.$strict>>;
+  attempt: z.ZodNumber;
+  reservedUsd: z.ZodOptional<z.ZodNumber>;
+  settledUsd: z.ZodOptional<z.ZodNumber>;
+  question: z.ZodOptional<z.ZodObject<{
+    text: z.ZodString;
+    options: z.ZodArray<z.ZodString>;
+    answer: z.ZodOptional<z.ZodString>;
+    answeredBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  changeId: z.ZodOptional<z.ZodString>;
+  reportRef: z.ZodOptional<z.ZodString>;
+  createdAt: z.ZodISODateTime;
+  updatedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+type TaskApproval = z.infer<typeof taskApprovalSchema>;
+type TaskKind = z.infer<typeof taskKindSchema>;
+type TaskState = z.infer<typeof taskStateSchema>;
+type Task = z.infer<typeof taskSchema>;
+//#endregion
+//#region src/store/engine.d.ts
+/** An approval decision that does not apply to the task's current approval or state. */
+declare class ApprovalError extends Error {
+  readonly taskId: TaskId;
+  readonly reason: string;
+  constructor(taskId: TaskId, reason: string);
+}
+interface CreateSignalInput {
+  repositoryId: RepositoryId;
+  source: SignalSource;
+  deliveryId: string;
+  replyTo: ReplyTo;
+  payload: unknown;
+}
+interface DecideSignalOptions {
+  detail?: string;
+  reason?: string;
+}
+interface CreateTaskInput {
+  repositoryIds: RepositoryId[];
+  kind: Task["kind"];
+  origin: Task["origin"];
+  replyTo: ReplyTo;
+  area?: string;
+  dependsOn?: TaskId[];
+  question?: Task["question"];
+  /** Stamp the task as needing a human decision before dispatch. */
+  approval?: "required";
+}
+interface ApprovalDecision {
+  /** Authenticated operator making the decision. */
+  by: string;
+  reason?: string;
+}
+type TaskPatch = Partial<Pick<Task, "devbox" | "changeId" | "reportRef" | "reservedUsd" | "settledUsd" | "question">>;
+interface TaskTransitionOptions {
+  patch?: TaskPatch;
+  reason?: string;
+}
+interface CreateChangeInput {
+  repositoryId: RepositoryId;
+  taskId?: TaskId;
+  groupId?: TaskId;
+  prNumber: number;
+  prUrl: string;
+  author: string;
+  risk: Level;
+  confidence: Level;
+  evidence: Change["evidence"];
+}
+type ChangePatch = Partial<Pick<Change, "confidence" | "evidence" | "decidedBy">>;
+interface ChangeTransitionOptions {
+  patch?: ChangePatch;
+  reason?: string;
+}
+interface AppendReceiptInput {
+  repositoryIds: RepositoryId[];
+  taskId?: TaskId;
+  changeId?: ChangeId;
+  kind: string;
+  state: string;
+  phase?: string;
+  reason?: string;
+  attempt?: number;
+  cost?: Cost;
+  decidedBy?: string;
+  /** Same key twice appends one receipt and returns the existing one. */
+  dedupeKey?: string;
+}
+interface FactoryStores {
+  driverName: string;
+  repositories: {
+    put(repository: Repository): Promise<Repository>;
+    get(id: RepositoryId): Promise<Repository | null>;
+    list(): Promise<Repository[]>;
+  };
+  signals: {
+    create(input: CreateSignalInput): Promise<Signal>;
+    get(id: SignalId): Promise<Signal | null>;
+    decide(id: SignalId, outcome: SignalOutcome, options?: DecideSignalOptions): Promise<Signal>;
+    list(): Promise<Signal[]>;
+  };
+  tasks: {
+    create(input: CreateTaskInput): Promise<Task>;
+    get(id: TaskId): Promise<Task | null>;
+    transition(id: TaskId, to: TaskState, options?: TaskTransitionOptions): Promise<Task>;
+    /** Grant a required approval. The task stays queued; dispatch may now take it. */
+    approve(id: TaskId, decision: ApprovalDecision): Promise<Task>;
+    /** Deny a required approval. The task is cancelled with the reason. */
+    reject(id: TaskId, decision: ApprovalDecision): Promise<Task>;
+    list(): Promise<Task[]>;
+  };
+  changes: {
+    create(input: CreateChangeInput): Promise<Change>;
+    get(id: ChangeId): Promise<Change | null>;
+    transition(id: ChangeId, to: ChangeState, options?: ChangeTransitionOptions): Promise<Change>;
+    list(): Promise<Change[]>;
+  };
+  receipts: {
+    append(input: AppendReceiptInput): Promise<Receipt>;
+    get(id: string): Promise<Receipt | null>;
+    list(): Promise<Receipt[]>;
+  };
+}
+interface CreateStoresOptions {
+  driver: StoreDriver;
+  now?: () => string;
+}
+declare function createStores(options: CreateStoresOptions): FactoryStores;
+//#endregion
+//#region src/schema/finding.d.ts
+declare const findingPrioritySchema: z.ZodEnum<{
+  P0: "P0";
+  P1: "P1";
+  P2: "P2";
+  P3: "P3";
+}>;
+declare const findingCategorySchema: z.ZodEnum<{
+  security: "security";
+  correctness: "correctness";
+  reliability: "reliability";
+  performance: "performance";
+  compatibility: "compatibility";
+  accessibility: "accessibility";
+  documentation: "documentation";
+  maintainability: "maintainability";
+  testing: "testing";
+  usability: "usability";
+}>;
+declare const findingVerificationLevelSchema: z.ZodEnum<{
+  unverified: "unverified";
+  supported: "supported";
+  confirmed: "confirmed";
+}>;
+declare const findingVerificationMethodSchema: z.ZodEnum<{
+  documentation: "documentation";
+  code_inspection: "code_inspection";
+  static_analysis: "static_analysis";
+  manual_reproduction: "manual_reproduction";
+  unit_test: "unit_test";
+  integration_test: "integration_test";
+  e2e_test: "e2e_test";
+  runtime_observation: "runtime_observation";
+}>;
+/**
+ * What was done to check the finding. Forces a reporter to distinguish "I
+ * think this is a problem" from "I demonstrated it", which is the axis a human
+ * approving fixes cares about most.
+ */
+declare const findingVerificationSchema: z.ZodObject<{
+  level: z.ZodEnum<{
+    unverified: "unverified";
+    supported: "supported";
+    confirmed: "confirmed";
+  }>;
+  method: z.ZodEnum<{
+    documentation: "documentation";
+    code_inspection: "code_inspection";
+    static_analysis: "static_analysis";
+    manual_reproduction: "manual_reproduction";
+    unit_test: "unit_test";
+    integration_test: "integration_test";
+    e2e_test: "e2e_test";
+    runtime_observation: "runtime_observation";
+  }>;
+  summary: z.ZodString;
+  limitations: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** A single problem found in a repository, as a scanner or agent reports it. */
+declare const findingSchema: z.ZodObject<{
+  title: z.ZodString;
+  body: z.ZodString;
+  path: z.ZodOptional<z.ZodString>;
+  line: z.ZodOptional<z.ZodNumber>;
+  endLine: z.ZodOptional<z.ZodNumber>;
+  priority: z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>;
+  category: z.ZodEnum<{
+    security: "security";
+    correctness: "correctness";
+    reliability: "reliability";
+    performance: "performance";
+    compatibility: "compatibility";
+    accessibility: "accessibility";
+    documentation: "documentation";
+    maintainability: "maintainability";
+    testing: "testing";
+    usability: "usability";
+  }>;
+  verification: z.ZodObject<{
+    level: z.ZodEnum<{
+      unverified: "unverified";
+      supported: "supported";
+      confirmed: "confirmed";
+    }>;
+    method: z.ZodEnum<{
+      documentation: "documentation";
+      code_inspection: "code_inspection";
+      static_analysis: "static_analysis";
+      manual_reproduction: "manual_reproduction";
+      unit_test: "unit_test";
+      integration_test: "integration_test";
+      e2e_test: "e2e_test";
+      runtime_observation: "runtime_observation";
+    }>;
+    summary: z.ZodString;
+    limitations: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>;
+  tool: z.ZodOptional<z.ZodString>;
+  ruleId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type FindingPriority = z.infer<typeof findingPrioritySchema>;
+type FindingCategory = z.infer<typeof findingCategorySchema>;
+type FindingVerification = z.infer<typeof findingVerificationSchema>;
+type Finding = z.infer<typeof findingSchema>;
+/**
+ * Stable identity of a finding across scans, used as the signal's delivery id
+ * so re-reporting is a no-op instead of a second task. A scanner finding is
+ * the same problem when the same tool reports the same rule on the same file;
+ * its title is model-written prose and changes between runs, so it is left
+ * out. Without a rule id the title is all there is, normalised.
+ */
+declare function findingFingerprint(repositoryId: string, finding: Finding): string;
+//#endregion
+//#region src/approval.d.ts
+/**
+ * One approval rule. Every listed field must match for the rule to apply;
+ * absent fields match anything. Rules are evaluated first-match.
+ */
+declare const approvalRuleSchema: z.ZodObject<{
+  source: z.ZodOptional<z.ZodString>;
+  kind: z.ZodOptional<z.ZodString>;
+  priority: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>>>;
+  require: z.ZodBoolean;
+}, z.core.$strict>;
+declare const approvalPolicySchema: z.ZodArray<z.ZodObject<{
+  source: z.ZodOptional<z.ZodString>;
+  kind: z.ZodOptional<z.ZodString>;
+  priority: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>>>;
+  require: z.ZodBoolean;
+}, z.core.$strict>>;
+type ApprovalRule = z.infer<typeof approvalRuleSchema>;
+type ApprovalPolicy = z.infer<typeof approvalPolicySchema>;
+/**
+ * The default: fixes for security findings wait for a human; everything else
+ * runs as it always has. Handoffs between agents (verification) never wait,
+ * because a human already approved the work they continue.
+ */
+declare const defaultApprovalPolicy: ApprovalPolicy;
+interface ApprovalSubject {
+  source?: string;
+  kind: string;
+  priority?: FindingPriority;
+}
+/**
+ * Decide at task-creation time whether a task needs approval. Pure: the answer
+ * is stamped on the task and never re-evaluated, so a later policy change
+ * cannot silently release work a human was expecting to see.
+ */
+declare function requiresApproval(policy: ApprovalPolicy, subject: ApprovalSubject): boolean;
+//#endregion
+export { ReceiptPhase as $, TaskPatch as A, taskDevboxSchema as B, ChangeTransitionOptions as C, changeIdSchema as Ct, CreateTaskInput as D, repositoryIdsSchema as Dt, CreateStoresOptions as E, repositoryIdSchema as Et, TaskKind as F, taskStateSchema as G, taskOriginSchema as H, TaskState as I, repositorySchema as J, Repository as K, harnessSchema as L, createStores as M, Task as N, DecideSignalOptions as O, signalIdSchema as Ot, TaskApproval as P, ReceiptKind as Q, standardTaskKinds as R, ChangePatch as S, TaskId as St, CreateSignalInput as T, receiptIdSchema as Tt, taskQuestionSchema as U, taskKindSchema as V, taskSchema as W, Cost as X, repositorySlugSchema as Y, Receipt as Z, findingVerificationMethodSchema as _, ChangeId as _t, approvalRuleSchema as a, receiptStateSchema as at, ApprovalDecision as b, RepositoryId as bt, Finding as c, standardReceiptStates as ct, FindingVerification as d, ChangeState as dt, ReceiptState as et, findingCategorySchema as f, Level as ft, findingVerificationLevelSchema as g, levelSchema as gt, findingSchema as h, changeStateSchema as ht, approvalPolicySchema as i, receiptSchema as it, TaskTransitionOptions as j, FactoryStores as k, taskIdSchema as kt, FindingCategory as l, Change as lt, findingPrioritySchema as m, changeSchema as mt, ApprovalRule as n, receiptKindSchema as nt, defaultApprovalPolicy as o, standardReceiptKinds as ot, findingFingerprint as p, changeEvidenceSchema as pt, RepositorySlug as q, ApprovalSubject as r, receiptPhaseSchema as rt, requiresApproval as s, standardReceiptPhases as st, ApprovalPolicy as t, costSchema as tt, FindingPriority as u, ChangeEvidence as ut, findingVerificationSchema as v, FactoryId as vt, CreateChangeInput as w, factoryIdSchema as wt, ApprovalError as x, SignalId as xt, AppendReceiptInput as y, ReceiptId as yt, taskApprovalSchema as z };
+//# sourceMappingURL=approval-h5aj8HYN.d.mts.map

package/dist/blob/index.d.mts

@@ -0,0 +1,32 @@
+import { i as StoreDriver } from "../driver-CrZsy7sm.mjs";
+//#region src/blob/index.d.ts
+interface BlobObject {
+  body: string;
+  etag: string;
+}
+/** The narrow blob operations the driver needs; injectable for tests. */
+interface BlobClient {
+  /** Must return the latest content, never a cached copy. */
+  read(pathname: string): Promise<BlobObject | null>;
+  /** Must reject if overwrite is false and the path exists, or if ifMatch is given and the ETag differs. */
+  write(pathname: string, body: string, overwrite: boolean, ifMatch?: string): Promise<void>;
+  listPaths(prefix: string): Promise<string[]>;
+}
+declare const vercelBlobClient: BlobClient;
+interface BlobDriverOptions {
+  client?: BlobClient;
+  /** Path prefix inside the blob store; defaults to "factory". */
+  prefix?: string;
+}
+/**
+ * Store driver on Vercel Blob: durable and dependency-free (one Blob store on
+ * the project, no database). Inserts and receipts are exactly as safe as on
+ * Postgres (create-if-absent is atomic). Updates read the latest content,
+ * bypassing Blob's CDN cache, and write with an ETag precondition, so a
+ * writer that lost a race gets a VersionConflictError rather than
+ * overwriting the winner.
+ */
+declare function createBlobDriver(options?: BlobDriverOptions): StoreDriver;
+//#endregion
+export { BlobClient, BlobDriverOptions, BlobObject, createBlobDriver, vercelBlobClient };
+//# sourceMappingURL=index.d.mts.map

package/dist/blob/index.mjs

@@ -0,0 +1,141 @@
+import { n as RecordNotFoundError, r as VersionConflictError, t as RecordExistsError } from "../driver-Bbd25rNM.mjs";
+import { get, list, put } from "@vercel/blob";
+//#region src/blob/index.ts
+function isNotFoundError(error) {
+	return error instanceof Error && (error.name === "BlobNotFoundError" || /does not exist|not.?found|404/iu.test(error.message));
+}
+function isAlreadyExistsError(error) {
+	return error instanceof Error && /already exists|not allowed to overwrite|overwrite/iu.test(error.message);
+}
+function isPreconditionError(error) {
+	return error instanceof Error && (error.name === "BlobPreconditionFailedError" || /precondition|etag|412/iu.test(error.message));
+}
+const vercelBlobClient = {
+	async read(pathname) {
+		let result;
+		try {
+			result = await get(pathname, {
+				access: "private",
+				useCache: false
+			});
+		} catch (error) {
+			if (isNotFoundError(error)) return null;
+			throw error;
+		}
+		if (result === null || result.stream === null) return null;
+		return {
+			body: await new Response(result.stream).text(),
+			etag: result.blob.etag
+		};
+	},
+	async write(pathname, body, overwrite, ifMatch) {
+		await put(pathname, body, {
+			access: "private",
+			allowOverwrite: overwrite,
+			contentType: "application/json",
+			...ifMatch === void 0 ? {} : { ifMatch }
+		});
+	},
+	async listPaths(prefix) {
+		const paths = [];
+		let cursor;
+		do {
+			const page = await list({
+				prefix,
+				cursor,
+				limit: 1e3
+			});
+			paths.push(...page.blobs.map((blob) => blob.pathname));
+			cursor = page.hasMore ? page.cursor : void 0;
+		} while (cursor !== void 0);
+		return paths;
+	}
+};
+/**
+* Store driver on Vercel Blob: durable and dependency-free (one Blob store on
+* the project, no database). Inserts and receipts are exactly as safe as on
+* Postgres (create-if-absent is atomic). Updates read the latest content,
+* bypassing Blob's CDN cache, and write with an ETag precondition, so a
+* writer that lost a race gets a VersionConflictError rather than
+* overwriting the winner.
+*/
+function createBlobDriver(options = {}) {
+	const client = options.client ?? vercelBlobClient;
+	const prefix = options.prefix ?? "factory";
+	function pathFor(collection, id) {
+		return `${prefix}/${collection}/${id}.json`;
+	}
+	async function readRecord(collection, id) {
+		let object;
+		try {
+			object = await client.read(pathFor(collection, id));
+		} catch (error) {
+			if (isNotFoundError(error)) return null;
+			throw error;
+		}
+		if (object === null) return null;
+		const parsed = JSON.parse(object.body);
+		if (typeof parsed.version !== "number") throw new Error(`malformed stored record at ${pathFor(collection, id)}`);
+		return {
+			value: parsed.value,
+			version: parsed.version,
+			etag: object.etag
+		};
+	}
+	return {
+		name: "blob",
+		async get(collection, id) {
+			const record = await readRecord(collection, id);
+			return record === null ? null : {
+				value: record.value,
+				version: record.version
+			};
+		},
+		async insert(collection, id, value) {
+			try {
+				await client.write(pathFor(collection, id), JSON.stringify({
+					value,
+					version: 1
+				}), false);
+			} catch (error) {
+				if (isAlreadyExistsError(error)) throw new RecordExistsError(collection, id);
+				throw error;
+			}
+		},
+		async update(collection, id, value, expectedVersion) {
+			const existing = await readRecord(collection, id);
+			if (existing === null) throw new RecordNotFoundError(collection, id);
+			if (existing.version !== expectedVersion) throw new VersionConflictError(collection, id, expectedVersion);
+			try {
+				await client.write(pathFor(collection, id), JSON.stringify({
+					value,
+					version: expectedVersion + 1
+				}), true, existing.etag.replace(/^W\//u, ""));
+			} catch (error) {
+				if (isPreconditionError(error)) throw new VersionConflictError(collection, id, expectedVersion);
+				throw error;
+			}
+		},
+		async list(collection) {
+			const dir = `${prefix}/${collection}/`;
+			const paths = await client.listPaths(dir);
+			const entries = [];
+			for (const pathname of paths) {
+				const id = pathname.slice(dir.length).replace(/\.json$/u, "");
+				const record = await readRecord(collection, id);
+				if (record !== null) entries.push({
+					id,
+					record: {
+						value: record.value,
+						version: record.version
+					}
+				});
+			}
+			return entries;
+		}
+	};
+}
+//#endregion
+export { createBlobDriver, vercelBlobClient };
+
+//# sourceMappingURL=index.mjs.map