@vercel/factory 0.0.0 → 0.0.1

package/dist/{engine-BXVTLiXU.d.ts → approval-Z7iaWibT.d.ts}

@@ -84,9 +84,9 @@ type ChangeEvidence = z.infer<typeof changeEvidenceSchema>;
 type Change = z.infer<typeof changeSchema>;
 
 /** States the engine writes on transitions. Any vocabulary value is valid. */
-declare const standardReceiptStates: readonly ["dispatched", "succeeded", "failed", "needs_human", "cancelled", "settled", "merged", "deployed", "rolled_out", "rolled_back"];
+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 ["budget", "dispatch", "implementation", "verification", "pull_request", "cleanup"];
+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;
@@ -137,7 +137,7 @@ type RepositorySlug = z.infer<typeof repositorySlugSchema>;
 type Repository = z.infer<typeof repositorySchema>;
 
 /** Sources used by the standard connectors. Any vocabulary value is valid. */
-declare const standardSignalSources: readonly ["github_issue", "github_pr", "github_pr_comment", "slack", "human", "github_ci_failure", "vercel_deploy_failure", "investigation", "api"];
+declare const standardSignalSources: readonly ["github_issue", "github_pr", "github_pr_comment", "slack", "human", "github_ci_failure", "vercel_deploy_failure", "security_scan", "investigation", "api"];
 declare const signalSourceSchema: z.ZodString;
 declare const signalOutcomeSchema: z.ZodEnum<{
     pending: "pending";
@@ -190,6 +190,11 @@ declare const taskStateSchema: z.ZodEnum<{
     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>;
@@ -222,6 +227,11 @@ declare const taskSchema: z.ZodObject<{
         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>;
@@ -251,10 +261,17 @@ declare const taskSchema: z.ZodObject<{
     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>;
 
+/** 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;
@@ -274,6 +291,13 @@ interface CreateTaskInput {
     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 {
@@ -327,6 +351,10 @@ interface FactoryStores {
         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: {
@@ -347,4 +375,167 @@ interface CreateStoresOptions {
 }
 declare function createStores(options: CreateStoresOptions): FactoryStores;
 
-export { signalOutcomeSchema as $, type AppendReceiptInput as A, changeEvidenceSchema as B, type ChangeState as C, type DecideSignalOptions as D, changeIdSchema as E, type FactoryStores as F, changeSchema as G, changeStateSchema as H, costSchema as I, createStores as J, factoryIdSchema as K, type Level as L, harnessSchema as M, levelSchema as N, receiptIdSchema as O, receiptKindSchema as P, receiptPhaseSchema as Q, type Receipt as R, type SignalOutcome as S, type Task as T, receiptSchema as U, receiptStateSchema as V, repositoryIdSchema as W, repositoryIdsSchema as X, repositorySchema as Y, repositorySlugSchema as Z, signalIdSchema as _, type TaskId as a, signalSchema as a0, signalSourceSchema as a1, standardReceiptKinds as a2, standardReceiptPhases as a3, standardReceiptStates as a4, standardSignalSources as a5, standardTaskKinds as a6, taskDevboxSchema as a7, taskIdSchema as a8, taskKindSchema as a9, taskOriginSchema as aa, taskQuestionSchema as ab, taskSchema as ac, taskStateSchema as ad, type TaskState as b, type Change as c, type ChangeEvidence as d, type ChangeId as e, type ChangePatch as f, type ChangeTransitionOptions as g, type Cost as h, type CreateChangeInput as i, type CreateSignalInput as j, type CreateStoresOptions as k, type CreateTaskInput as l, type FactoryId as m, type ReceiptId as n, type ReceiptKind as o, type ReceiptPhase as p, type ReceiptState as q, type Repository as r, type RepositoryId as s, type RepositorySlug as t, type Signal as u, type SignalId as v, type SignalSource as w, type TaskKind as x, type TaskPatch as y, type TaskTransitionOptions as z };
+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;
+
+/**
+ * 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;
+
+export { factoryIdSchema as $, type ApprovalPolicy as A, type ReceiptPhase as B, type ChangeState as C, type DecideSignalOptions as D, type ReceiptState as E, type FactoryStores as F, type RepositoryId as G, type RepositorySlug as H, type SignalId as I, type SignalSource as J, type TaskApproval as K, type Level as L, type TaskKind as M, type TaskPatch as N, type TaskTransitionOptions as O, approvalPolicySchema as P, approvalRuleSchema as Q, type Repository as R, type SignalOutcome as S, type Task as T, changeEvidenceSchema as U, changeIdSchema as V, changeSchema as W, changeStateSchema as X, costSchema as Y, createStores as Z, defaultApprovalPolicy as _, type Finding as a, findingCategorySchema as a0, findingFingerprint as a1, findingPrioritySchema as a2, findingSchema as a3, findingVerificationLevelSchema as a4, findingVerificationMethodSchema as a5, findingVerificationSchema as a6, harnessSchema as a7, levelSchema as a8, receiptIdSchema as a9, receiptKindSchema as aa, receiptPhaseSchema as ab, receiptSchema as ac, receiptStateSchema as ad, repositoryIdSchema as ae, repositoryIdsSchema as af, repositorySchema as ag, repositorySlugSchema as ah, requiresApproval as ai, signalIdSchema as aj, signalOutcomeSchema as ak, signalSchema as al, signalSourceSchema as am, standardReceiptKinds as an, standardReceiptPhases as ao, standardReceiptStates as ap, standardSignalSources as aq, standardTaskKinds as ar, taskApprovalSchema as as, taskDevboxSchema as at, taskIdSchema as au, taskKindSchema as av, taskOriginSchema as aw, taskQuestionSchema as ax, taskSchema as ay, taskStateSchema as az, type TaskId as b, type TaskState as c, type CreateSignalInput as d, type Signal as e, type AppendReceiptInput as f, type ApprovalDecision as g, ApprovalError as h, type ApprovalRule as i, type ApprovalSubject as j, type Change as k, type ChangeEvidence as l, type ChangeId as m, type ChangePatch as n, type ChangeTransitionOptions as o, type Cost as p, type CreateChangeInput as q, type CreateStoresOptions as r, type CreateTaskInput as s, type FactoryId as t, type FindingCategory as u, type FindingPriority as v, type FindingVerification as w, type Receipt as x, type ReceiptId as y, type ReceiptKind as z };

package/dist/blob/index.d.ts

@@ -0,0 +1,26 @@
+import { S as StoreDriver } from '../driver-tRNggCCJ.js';
+
+/** The narrow blob operations the driver needs; injectable for tests. */
+interface BlobClient {
+    read(pathname: string): Promise<string | null>;
+    /** Must reject with an already-exists error when overwrite is false and the path exists. */
+    write(pathname: string, body: string, overwrite: boolean): 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). The compare-and-swap update is
+ * BEST-EFFORT: the version check reads then writes without a lock, so two
+ * simultaneous writers can race. Acceptable for low-volume factories; use the
+ * Postgres driver when concurrent dispatchers are expected.
+ */
+declare function createBlobDriver(options?: BlobDriverOptions): StoreDriver;
+
+export { type BlobClient, type BlobDriverOptions, createBlobDriver, vercelBlobClient };

package/dist/blob/index.js

@@ -0,0 +1,127 @@
+import {
+  RecordExistsError,
+  RecordNotFoundError,
+  VersionConflictError
+} from "../chunk-CEF6VJZC.js";
+
+// src/blob/index.ts
+import { get, head, list, put } from "@vercel/blob";
+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);
+}
+var vercelBlobClient = {
+  async read(pathname) {
+    let url;
+    try {
+      url = (await head(pathname)).url;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return null;
+      }
+      throw error;
+    }
+    const result = await get(url, { access: "private" });
+    if (result === null) {
+      return null;
+    }
+    return new Response(result.stream).text();
+  },
+  async write(pathname, body, overwrite) {
+    await put(pathname, body, {
+      access: "private",
+      allowOverwrite: overwrite,
+      contentType: "application/json"
+    });
+  },
+  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;
+  }
+};
+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 text;
+    try {
+      text = await client.read(pathFor(collection, id));
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return null;
+      }
+      throw error;
+    }
+    if (text === null) {
+      return null;
+    }
+    const parsed = JSON.parse(text);
+    if (typeof parsed.version !== "number") {
+      throw new Error(`malformed stored record at ${pathFor(collection, id)}`);
+    }
+    return parsed;
+  }
+  return {
+    name: "blob",
+    get(collection, id) {
+      return readRecord(collection, id);
+    },
+    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);
+      }
+      await client.write(
+        pathFor(collection, id),
+        JSON.stringify({ value, version: expectedVersion + 1 }),
+        true
+      );
+    },
+    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 });
+        }
+      }
+      return entries;
+    }
+  };
+}
+export {
+  createBlobDriver,
+  vercelBlobClient
+};
+//# sourceMappingURL=index.js.map

package/dist/blob/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/blob/index.ts"],"sourcesContent":["import { get, head, list, put } from \"@vercel/blob\";\nimport {\n  RecordExistsError,\n  RecordNotFoundError,\n  VersionConflictError,\n  type CollectionName,\n  type StoredEntry,\n  type StoreDriver,\n} from \"../store/driver\";\n\n/** The narrow blob operations the driver needs; injectable for tests. */\nexport interface BlobClient {\n  read(pathname: string): Promise<string | null>;\n  /** Must reject with an already-exists error when overwrite is false and the path exists. */\n  write(pathname: string, body: string, overwrite: boolean): Promise<void>;\n  listPaths(prefix: string): Promise<string[]>;\n}\n\n// @vercel/blob throws BlobNotFoundError with the message\n// \"Vercel Blob: The requested blob does not exist\".\nfunction isNotFoundError(error: unknown): boolean {\n  return (\n    error instanceof Error &&\n    (error.name === \"BlobNotFoundError\" ||\n      /does not exist|not.?found|404/iu.test(error.message))\n  );\n}\n\nfunction isAlreadyExistsError(error: unknown): boolean {\n  return (\n    error instanceof Error &&\n    /already exists|not allowed to overwrite|overwrite/iu.test(error.message)\n  );\n}\n\nexport const vercelBlobClient: BlobClient = {\n  async read(pathname) {\n    let url: string;\n    try {\n      url = (await head(pathname)).url;\n    } catch (error) {\n      if (isNotFoundError(error)) {\n        return null;\n      }\n      throw error;\n    }\n    const result = await get(url, { access: \"private\" });\n    if (result === null) {\n      return null;\n    }\n    return new Response(result.stream).text();\n  },\n\n  async write(pathname, body, overwrite) {\n    await put(pathname, body, {\n      access: \"private\",\n      allowOverwrite: overwrite,\n      contentType: \"application/json\",\n    });\n  },\n\n  async listPaths(prefix) {\n    const paths: string[] = [];\n    let cursor: string | undefined;\n    do {\n      const page = await list({ prefix, cursor, limit: 1000 });\n      paths.push(...page.blobs.map((blob) => blob.pathname));\n      cursor = page.hasMore ? page.cursor : undefined;\n    } while (cursor !== undefined);\n    return paths;\n  },\n};\n\nexport interface BlobDriverOptions {\n  client?: BlobClient;\n  /** Path prefix inside the blob store; defaults to \"factory\". */\n  prefix?: string;\n}\n\n/**\n * Store driver on Vercel Blob: durable and dependency-free (one Blob store on\n * the project, no database). Inserts and receipts are exactly as safe as on\n * Postgres (create-if-absent is atomic). The compare-and-swap update is\n * BEST-EFFORT: the version check reads then writes without a lock, so two\n * simultaneous writers can race. Acceptable for low-volume factories; use the\n * Postgres driver when concurrent dispatchers are expected.\n */\nexport function createBlobDriver(options: BlobDriverOptions = {}): StoreDriver {\n  const client = options.client ?? vercelBlobClient;\n  const prefix = options.prefix ?? \"factory\";\n\n  function pathFor(collection: CollectionName, id: string): string {\n    return `${prefix}/${collection}/${id}.json`;\n  }\n\n  async function readRecord(\n    collection: CollectionName,\n    id: string,\n  ): Promise<{ value: unknown; version: number } | null> {\n    let text: string | null;\n    try {\n      text = await client.read(pathFor(collection, id));\n    } catch (error) {\n      if (isNotFoundError(error)) {\n        return null;\n      }\n      throw error;\n    }\n    if (text === null) {\n      return null;\n    }\n    const parsed = JSON.parse(text) as { value: unknown; version: number };\n    if (typeof parsed.version !== \"number\") {\n      throw new Error(`malformed stored record at ${pathFor(collection, id)}`);\n    }\n    return parsed;\n  }\n\n  return {\n    name: \"blob\",\n\n    get(collection, id) {\n      return readRecord(collection, id);\n    },\n\n    async insert(collection, id, value) {\n      try {\n        await client.write(\n          pathFor(collection, id),\n          JSON.stringify({ value, version: 1 }),\n          false,\n        );\n      } catch (error) {\n        if (isAlreadyExistsError(error)) {\n          throw new RecordExistsError(collection, id);\n        }\n        throw error;\n      }\n    },\n\n    async update(collection, id, value, expectedVersion) {\n      const existing = await readRecord(collection, id);\n      if (existing === null) {\n        throw new RecordNotFoundError(collection, id);\n      }\n      if (existing.version !== expectedVersion) {\n        throw new VersionConflictError(collection, id, expectedVersion);\n      }\n      await client.write(\n        pathFor(collection, id),\n        JSON.stringify({ value, version: expectedVersion + 1 }),\n        true,\n      );\n    },\n\n    async list(collection) {\n      const dir = `${prefix}/${collection}/`;\n      const paths = await client.listPaths(dir);\n      const entries: StoredEntry[] = [];\n      for (const pathname of paths) {\n        const id = pathname.slice(dir.length).replace(/\\.json$/u, \"\");\n        const record = await readRecord(collection, id);\n        if (record !== null) {\n          entries.push({ id, record });\n        }\n      }\n      return entries;\n    },\n  };\n}\n"],"mappings":"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","names":[]}