@pithy-sh/cloudflare 0.7.1 → 0.8.0

package/dist/ai/vectorizeProvisioner.d.ts

@@ -74,6 +74,16 @@ export type VectorizeIndexSpec = {
 } | {
     preset: VectorizePreset;
 };
+/**
+ * Whether an error means "that metadata index is already there": `400` with error code 40004, the answer to
+ * creating a property that is already indexed. Narrow for the same reason {@link isAbsentMetadataIndexError} is:
+ * every other `400` stays an error.
+ *
+ * It is how a create retried by the SDK comes back. The SDK retries a request that timed out, lost its
+ * connection, or answered 408, 409, 429 or a 5xx, twice by default and a POST included, so a create Cloudflare
+ * applied can be sent again and refused as a duplicate of itself.
+ */
+export declare function isExistingMetadataIndexError(error: unknown): boolean;
 /** Options a new index accepts beyond its name and shape. */
 export interface CreateVectorizeIndexOptions {
     /** A human description stored on the index, surfaced in the Cloudflare dashboard. */
@@ -111,6 +121,12 @@ export declare class CloudflareVectorizeProvisioner extends CloudflareManager {
      * Make a metadata property filterable. Cloudflare caps an index at 10 indexed properties, and only vectors
      * written **after** the metadata index exists are covered — so declare these before the first insert.
      * The change is enqueued asynchronously; the returned promise resolving means accepted, not live.
+     *
+     * Idempotent, like {@link deleteMetadataIndex}. A property already indexed answers `400`/40004
+     * ({@link isExistingMetadataIndexError}); the list then decides. Listed with the same type, the create has
+     * already happened and this returns. Listed with another type, it throws `core/conflict` naming both, since a
+     * metadata index's type is fixed. Not listed yet, it returns too: Cloudflare has just said the index exists,
+     * the list lags, and the caller's own settle wait reads its type.
      */
     createMetadataIndex(indexName: string, propertyName: string, indexType: VectorizeMetadataIndexType): Promise<void>;
     /** List an index's indexed metadata properties — the read that proves a `createMetadataIndex` has landed. */

package/dist/ai/vectorizeProvisioner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vectorizeProvisioner.d.ts","sourceRoot":"","sources":["../../src/ai/vectorizeProvisioner.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,kHAAkH;AAClH,eAAO,MAAM,eAAe;;;;EAEgF,CAAC;AAC7G,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;EAQiF,CAAC;AAC9G,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,4GAA4G;AAC5G,eAAO,MAAM,oBAAoB;;;;;;;iBAS2E,CAAC;AAC7G,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEzE,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAMqF,CAAC;AACrH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE,sHAAsH;AACtH,eAAO,MAAM,0BAA0B;;;;EAEqE,CAAC;AAC7G,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAiBpF,2GAA2G;AAC3G,eAAO,MAAM,sBAAsB;;;;;;;iBAK+E,CAAC;AACnH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC;AAuC/G,6DAA6D;AAC7D,MAAM,WAAW,2BAA2B;IAC1C,qFAAqF;IACrF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,8BAA+B,SAAQ,iBAAiB;IACnE,cAAc,IAAI,MAAM,CAEvB;IAED,iGAAiG;IAC3F,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAO9C;IAED,uGAAuG;IACjG,WAAW,CACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,kBAAkB,CAAC,CAU7B;IAED,qHAAqH;IAC/G,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS7C;IAED,uGAAuG;IACjG,WAAW,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAQjD;IAED;;;;;OAKG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAUtE;IAED;;;;OAIG;IACG,mBAAmB,CACvB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,0BAA0B,GACpC,OAAO,CAAC,IAAI,CAAC,CAQf;IAED,6GAA6G;IACvG,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAS9E;IAED;;;;OAIG;IACG,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhF;CACF"}
+{"version":3,"file":"vectorizeProvisioner.d.ts","sourceRoot":"","sources":["../../src/ai/vectorizeProvisioner.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,kHAAkH;AAClH,eAAO,MAAM,eAAe;;;;EAEgF,CAAC;AAC7G,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;EAQiF,CAAC;AAC9G,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAE9D,4GAA4G;AAC5G,eAAO,MAAM,oBAAoB;;;;;;;iBAS2E,CAAC;AAC7G,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEzE,0FAA0F;AAC1F,eAAO,MAAM,kBAAkB;;;;;;;;;;;iBAMqF,CAAC;AACrH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAErE,sHAAsH;AACtH,eAAO,MAAM,0BAA0B;;;;EAEqE,CAAC;AAC7G,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAiBpF,2GAA2G;AAC3G,eAAO,MAAM,sBAAsB;;;;;;;iBAK+E,CAAC;AACnH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC;AA0C/G;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAKpE;AAED,6DAA6D;AAC7D,MAAM,WAAW,2BAA2B;IAC1C,qFAAqF;IACrF,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;;;GAUG;AACH,qBAAa,8BAA+B,SAAQ,iBAAiB;IACnE,cAAc,IAAI,MAAM,CAEvB;IAED,iGAAiG;IAC3F,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAO9C;IAED,uGAAuG;IACjG,WAAW,CACf,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,kBAAkB,EAC1B,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,kBAAkB,CAAC,CAU7B;IAED,qHAAqH;IAC/G,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS7C;IAED,uGAAuG;IACjG,WAAW,IAAI,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAQjD;IAED;;;;;OAKG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAUtE;IAED;;;;;;;;;;OAUG;IACG,mBAAmB,CACvB,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,0BAA0B,GACpC,OAAO,CAAC,IAAI,CAAC,CAsBf;IAED,6GAA6G;IACvG,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,EAAE,CAAC,CAS9E;IAED;;;;OAIG;IACG,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYhF;CACF"}

package/dist/ai/vectorizeProvisioner.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: MIT
 import { cloudflareRequest, decodeResponse, isNotFoundError } from "../client/errors.js";
 import { CloudflareManager } from "../client/manager.js";
+import { ConflictError } from "@pithy-sh/core/src/error/pithyError";
 import { z } from "zod";
 //#region src/ai/vectorizeProvisioner.ts
 /** The distance metric an index scores nearest neighbors with. Fixed at creation — it cannot be changed later. */
@@ -87,6 +88,23 @@ function isAbsentMetadataIndexError(error) {
 	if (status !== 400 || !Array.isArray(errors)) return false;
 	return errors.some((entry) => entry?.code === METADATA_INDEX_ABSENT_CODE);
 }
+/** Vectorize's error code for "a metadata index with that name already exists". */
+const METADATA_INDEX_EXISTS_CODE = 40004;
+/**
+* Whether an error means "that metadata index is already there": `400` with error code 40004, the answer to
+* creating a property that is already indexed. Narrow for the same reason {@link isAbsentMetadataIndexError} is:
+* every other `400` stays an error.
+*
+* It is how a create retried by the SDK comes back. The SDK retries a request that timed out, lost its
+* connection, or answered 408, 409, 429 or a 5xx, twice by default and a POST included, so a create Cloudflare
+* applied can be sent again and refused as a duplicate of itself.
+*/
+function isExistingMetadataIndexError(error) {
+	if (typeof error !== "object" || error === null) return false;
+	const { status, errors } = error;
+	if (status !== 400 || !Array.isArray(errors)) return false;
+	return errors.some((entry) => entry?.code === METADATA_INDEX_EXISTS_CODE);
+}
 /**
 * Account-level Vectorize control plane: **create and delete indexes, and manage their metadata indexes**.
 * `pithy vector provision` uses this to stand up a per-environment index and declare which metadata
@@ -161,13 +179,32 @@ var CloudflareVectorizeProvisioner = class extends CloudflareManager {
 	* Make a metadata property filterable. Cloudflare caps an index at 10 indexed properties, and only vectors
 	* written **after** the metadata index exists are covered — so declare these before the first insert.
 	* The change is enqueued asynchronously; the returned promise resolving means accepted, not live.
+	*
+	* Idempotent, like {@link deleteMetadataIndex}. A property already indexed answers `400`/40004
+	* ({@link isExistingMetadataIndexError}); the list then decides. Listed with the same type, the create has
+	* already happened and this returns. Listed with another type, it throws `core/conflict` naming both, since a
+	* metadata index's type is fixed. Not listed yet, it returns too: Cloudflare has just said the index exists,
+	* the list lags, and the caller's own settle wait reads its type.
 	*/
 	async createMetadataIndex(indexName, propertyName, indexType) {
-		await cloudflareRequest(`create Vectorize metadata index ${indexName}.${propertyName}`, () => this.getClient().vectorize.indexes.metadataIndex.create(indexName, {
-			account_id: this.accountId,
-			indexType,
-			propertyName
-		}));
+		await cloudflareRequest(`create Vectorize metadata index ${indexName}.${propertyName}`, async () => {
+			try {
+				await this.getClient().vectorize.indexes.metadataIndex.create(indexName, {
+					account_id: this.accountId,
+					indexType,
+					propertyName
+				});
+			} catch (error) {
+				if (!isExistingMetadataIndexError(error)) throw error;
+				const live = (await this.listMetadataIndexes(indexName)).find((entry) => entry.propertyName === propertyName);
+				if (live === void 0 || live.indexType === indexType) return;
+				throw new ConflictError({
+					message: `Metadata index ${indexName}.${propertyName} already exists as ${live.indexType}, not ${indexType}.`,
+					action: `A metadata index's type is fixed. Declare ${propertyName} as ${live.indexType}, or delete the metadata index and create it again.`,
+					detail: `Cloudflare answered 40004 to a create of ${propertyName} as ${indexType}; the list holds it as ${live.indexType}.`
+				}, { cause: error });
+			}
+		});
 	}
 	/** List an index's indexed metadata properties — the read that proves a `createMetadataIndex` has landed. */
 	async listMetadataIndexes(indexName) {
@@ -194,4 +231,4 @@ var CloudflareVectorizeProvisioner = class extends CloudflareManager {
 	}
 };
 //#endregion
-export { CloudflareVectorizeProvisioner, VectorizeIndexConfig, VectorizeIndexInfo, VectorizeMetadataIndex, VectorizeMetadataIndexType, VectorizeMetric, VectorizePreset };
+export { CloudflareVectorizeProvisioner, VectorizeIndexConfig, VectorizeIndexInfo, VectorizeMetadataIndex, VectorizeMetadataIndexType, VectorizeMetric, VectorizePreset, isExistingMetadataIndexError };

package/dist/artifacts/artifactsManager.d.ts

@@ -23,6 +23,13 @@ export declare class CloudflareArtifactsManager extends CloudflareManager {
      * clean no-op rather than a failure.
      */
     listRepos(namespace: string): Promise<string[]>;
+    /**
+     * Every namespace name on the account, across every page. The live suites' debris sweep reads it to find the
+     * `pithy-int-` namespaces an aborted run left behind, since nothing else lists them.
+     */
+    listNamespaces(): Promise<string[]>;
+    /** Every `name` a paged listing answers, following its cursor. A 404 is an empty listing. */
+    private names;
     /**
      * Delete one repo and every token on it. **Resolves whether one was there**, so teardown re-runs safely: a repo
      * already gone is `false`, not an error. Cloudflare answers `202 Accepted`, so the storage may take a moment to

package/dist/artifacts/artifactsManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"artifactsManager.d.ts","sourceRoot":"","sources":["../../src/artifacts/artifactsManager.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAoCtD;;;;;;;;;;;GAWG;AACH,qBAAa,0BAA2B,SAAQ,iBAAiB;IAC/D,cAAc,IAAI,MAAM,CAEvB;IAED,gFAAgF;IAC1E,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAO9C;IAED;;;;OAIG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAmBpD;IAED;;;;OAIG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOlE;IAED;;;;;;;;;OASG;IACG,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC,CAOnF;IAED,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,IAAI;IAIZ;;;;OAIG;YACW,IAAI;CAwCnB"}
+{"version":3,"file":"artifactsManager.d.ts","sourceRoot":"","sources":["../../src/artifacts/artifactsManager.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAoCtD;;;;;;;;;;;GAWG;AACH,qBAAa,0BAA2B,SAAQ,iBAAiB;IAC/D,cAAc,IAAI,MAAM,CAEvB;IAED,gFAAgF;IAC1E,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAO9C;IAED;;;;OAIG;IACG,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAKpD;IAED;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAIxC;IAED,6FAA6F;YAC/E,KAAK;IAkBnB;;;;OAIG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOlE;IAED;;;;;;;;;OASG;IACG,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,QAAQ,GAAG,UAAU,CAAC,CAOnF;IAED,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,IAAI;IAIZ;;;;OAIG;YACW,IAAI;CAwCnB"}

package/dist/artifacts/artifactsManager.js

@@ -23,8 +23,8 @@ const Envelope = z.object({
 	errors: z.array(z.unknown()).optional().describe("Cloudflare's own error entries."),
 	result_info: z.object({ cursor: z.string().nullable().optional().describe("The next page's cursor, when there is one.") }).loose().optional().describe("Pagination, for a listing.")
 }).describe("A Cloudflare REST envelope.");
-/** One page of `GET …/repos`: only the name of each repo is read. */
-const RepoPage = z.array(z.object({ name: z.string().describe("The repo's name in the namespace.") }).loose()).describe("One page of an Artifacts namespace's repos.");
+/** One page of `GET …/repos` or `GET …/namespaces`: only the name of each entry is read. */
+const NamedPage = z.array(z.object({ name: z.string().describe("The repo's or the namespace's name.") }).loose()).describe("One page of an Artifacts listing of repos or namespaces.");
 /**
 * Account-level Artifacts control plane: **list and delete the repos in a namespace, then the namespace** (#673).
 *
@@ -56,21 +56,30 @@ var CloudflareArtifactsManager = class extends CloudflareManager {
 	*/
 	async listRepos(namespace) {
 		assertName(namespace, "namespace");
-		return cloudflareRequest(`list Artifacts repos in ${namespace}`, async () => {
-			const names = /* @__PURE__ */ new Set();
-			const followed = /* @__PURE__ */ new Set();
-			let cursor;
-			for (;;) {
-				const query = `limit=${PAGE_LIMIT}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
-				const page = await this.call("GET", `${this.namespacePath(namespace)}/repos?${query}`);
-				if (page === null) return [...names];
-				for (const repo of decodeResponse(RepoPage, page.result, "Artifacts repo list")) names.add(repo.name);
-				const next = page.result_info?.cursor ?? void 0;
-				if (!next || followed.has(next)) return [...names];
-				followed.add(next);
-				cursor = next;
-			}
-		});
+		return cloudflareRequest(`list Artifacts repos in ${namespace}`, () => this.names(`${this.namespacePath(namespace)}/repos`, "Artifacts repo list"));
+	}
+	/**
+	* Every namespace name on the account, across every page. The live suites' debris sweep reads it to find the
+	* `pithy-int-` namespaces an aborted run left behind, since nothing else lists them.
+	*/
+	async listNamespaces() {
+		return cloudflareRequest("list Artifacts namespaces", () => this.names(`/accounts/${this.getAccountId()}/artifacts/namespaces`, "Artifacts namespace list"));
+	}
+	/** Every `name` a paged listing answers, following its cursor. A 404 is an empty listing. */
+	async names(path, what) {
+		const names = /* @__PURE__ */ new Set();
+		const followed = /* @__PURE__ */ new Set();
+		let cursor;
+		for (;;) {
+			const query = `limit=${PAGE_LIMIT}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
+			const page = await this.call("GET", `${path}?${query}`);
+			if (page === null) return [...names];
+			for (const entry of decodeResponse(NamedPage, page.result, what)) names.add(entry.name);
+			const next = page.result_info?.cursor ?? void 0;
+			if (!next || followed.has(next)) return [...names];
+			followed.add(next);
+			cursor = next;
+		}
 	}
 	/**
 	* Delete one repo and every token on it. **Resolves whether one was there**, so teardown re-runs safely: a repo

package/dist/r2/r2Provisioner.d.ts

@@ -7,6 +7,24 @@ export declare const R2BucketInfo: z.ZodObject<{
     name: z.ZodString;
 }, z.core.$strip>;
 export type R2BucketInfo = z.output<typeof R2BucketInfo>;
+/** One R2 bucket lock rule: objects under `prefix` cannot be overwritten or deleted while its condition holds. */
+export declare const R2LockRule: z.ZodObject<{
+    id: z.ZodString;
+    enabled: z.ZodBoolean;
+    prefix: z.ZodOptional<z.ZodString>;
+    condition: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"Age">;
+        maxAgeSeconds: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"Date">;
+        date: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"Indefinite">;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+export type R2LockRule = z.output<typeof R2LockRule>;
+/** What asking for an indefinite lock did. */
+export type R2LockOutcome = "locked" | "already";
 /**
  * Account-level R2 control plane: **create and delete buckets**. Customers use this to stand up and
  * tear down per-environment buckets (e.g. ephemeral staging), and worktree teardown uses it to
@@ -29,6 +47,18 @@ export declare class CloudflareR2Provisioner extends CloudflareManager {
     listBuckets(): Promise<R2BucketInfo[]>;
     /** Create an R2 bucket by name; returns its name. */
     createBucket(name: string): Promise<R2BucketInfo>;
+    /** The bucket's lock rules. A bucket with none answers an empty list. */
+    bucketLockRules(name: string): Promise<R2LockRule[]>;
+    /** Whether some enabled rule locks every object under `prefix` indefinitely. */
+    static locksPrefixIndefinitely(rules: readonly R2LockRule[], prefix: string): boolean;
+    /** Whether the bucket's rules lock every object under `prefix` indefinitely, read from the account. */
+    prefixLockedIndefinitely(name: string, prefix: string): Promise<boolean>;
+    /**
+     * Lock every object under `prefix` indefinitely, beside whatever rules the bucket already has. Idempotent: a
+     * rule already in force is left alone and answered `already`. The update replaces the bucket's whole rule set,
+     * so the existing rules are read and written back with the new one — never dropped.
+     */
+    lockPrefixIndefinitely(name: string, prefix: string, id: string): Promise<R2LockOutcome>;
     /**
      * Delete an R2 bucket by name. Idempotent — a missing bucket is not an error, so teardown can re-run safely.
      *

package/dist/r2/r2Provisioner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"r2Provisioner.d.ts","sourceRoot":"","sources":["../../src/r2/r2Provisioner.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,6GAA6G;AAC7G,eAAO,MAAM,YAAY;;iBAIkE,CAAC;AAC5F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC;AAEzD;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,iBAAiB;IAC5D,cAAc,IAAI,MAAM,CAEvB;IAED,iGAAiG;IAC3F,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAO9C;IAED,2FAA2F;IACrF,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAGjE;IAED;;;;;OAKG;IACG,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAsB3C;IAED,qDAAqD;IAC/C,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtD;IAED;;;;;;OAMG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS9C;CACF"}
+{"version":3,"file":"r2Provisioner.d.ts","sourceRoot":"","sources":["../../src/r2/r2Provisioner.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAEtD,6GAA6G;AAC7G,eAAO,MAAM,YAAY;;iBAIkE,CAAC;AAC5F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC;AAEzD,kHAAkH;AAClH,eAAO,MAAM,UAAU;;;;;;;;;;;;;iBAuBe,CAAC;AACvC,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,UAAU,CAAC,CAAC;AAErD,8CAA8C;AAC9C,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEjD;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,iBAAiB;IAC5D,cAAc,IAAI,MAAM,CAEvB;IAED,iGAAiG;IAC3F,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAO9C;IAED,2FAA2F;IACrF,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAGjE;IAED;;;;;OAKG;IACG,WAAW,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC,CAsB3C;IAED,qDAAqD;IAC/C,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAKtD;IAED,yEAAyE;IACnE,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAWzD;IAED,gFAAgF;IAChF,MAAM,CAAC,uBAAuB,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAIpF;IAED,uGAAuG;IACjG,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAE7E;IAED;;;;OAIG;IACG,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAW7F;IAED;;;;;;OAMG;IACG,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAS9C;CACF"}

package/dist/r2/r2Provisioner.js

@@ -6,6 +6,23 @@ import { z } from "zod";
 //#region src/r2/r2Provisioner.ts
 /** An R2 bucket's identity, decoded from the create/list response. Buckets are addressed by name, not id. */
 const R2BucketInfo = z.object({ name: z.string().describe("The bucket name — R2's sole address for a bucket (no separate uuid id).") }).describe("A Cloudflare R2 bucket's identity, as returned by the create/list endpoints.");
+/** One R2 bucket lock rule: objects under `prefix` cannot be overwritten or deleted while its condition holds. */
+const R2LockRule = z.object({
+	id: z.string().describe("The rule's id, unique within the bucket."),
+	enabled: z.boolean().describe("Whether the rule is in force."),
+	prefix: z.string().optional().describe("The key prefix it covers. Absent or empty covers every object."),
+	condition: z.discriminatedUnion("type", [
+		z.object({
+			type: z.literal("Age").describe("Locked for a time after each object is written."),
+			maxAgeSeconds: z.number().describe("How long, in seconds.")
+		}).describe("Locked for an age."),
+		z.object({
+			type: z.literal("Date").describe("Locked until a date."),
+			date: z.string().describe("The date, ISO-8601.")
+		}).describe("Locked until a date."),
+		z.object({ type: z.literal("Indefinite").describe("Locked for ever.") }).describe("Locked for ever.")
+	]).describe("How long the objects stay locked.")
+}).describe("An R2 bucket lock rule.");
 /**
 * Account-level R2 control plane: **create and delete buckets**. Customers use this to stand up and
 * tear down per-environment buckets (e.g. ephemeral staging), and worktree teardown uses it to
@@ -13,7 +30,7 @@ const R2BucketInfo = z.object({ name: z.string().describe("The bucket name — R
 * one already-provisioned bucket (presigned object URLs), this manager is account-scoped and
 * addresses buckets **by name** — R2 buckets carry no separate uuid id the way D1 databases do.
 */
-var CloudflareR2Provisioner = class extends CloudflareManager {
+var CloudflareR2Provisioner = class CloudflareR2Provisioner extends CloudflareManager {
 	getServiceType() {
 		return "Cloudflare R2 (control plane)";
 	}
@@ -66,6 +83,39 @@ var CloudflareR2Provisioner = class extends CloudflareManager {
 		}));
 		return decodeResponse(R2BucketInfo, response, "R2 bucket create");
 	}
+	/** The bucket's lock rules. A bucket with none answers an empty list. */
+	async bucketLockRules(name) {
+		const response = await cloudflareRequest(`read lock rules of R2 bucket ${name}`, () => this.getClient().r2.buckets.locks.get(name, { account_id: this.accountId }));
+		return decodeResponse(z.object({ rules: z.array(R2LockRule).optional() }).describe("A bucket's lock rules."), response, "R2 bucket lock rules").rules ?? [];
+	}
+	/** Whether some enabled rule locks every object under `prefix` indefinitely. */
+	static locksPrefixIndefinitely(rules, prefix) {
+		return rules.some((rule) => rule.enabled && rule.condition.type === "Indefinite" && prefix.startsWith(rule.prefix ?? ""));
+	}
+	/** Whether the bucket's rules lock every object under `prefix` indefinitely, read from the account. */
+	async prefixLockedIndefinitely(name, prefix) {
+		return CloudflareR2Provisioner.locksPrefixIndefinitely(await this.bucketLockRules(name), prefix);
+	}
+	/**
+	* Lock every object under `prefix` indefinitely, beside whatever rules the bucket already has. Idempotent: a
+	* rule already in force is left alone and answered `already`. The update replaces the bucket's whole rule set,
+	* so the existing rules are read and written back with the new one — never dropped.
+	*/
+	async lockPrefixIndefinitely(name, prefix, id) {
+		const rules = await this.bucketLockRules(name);
+		if (CloudflareR2Provisioner.locksPrefixIndefinitely(rules, prefix)) return "already";
+		const next = [...rules.filter((rule) => rule.id !== id), {
+			id,
+			enabled: true,
+			prefix,
+			condition: { type: "Indefinite" }
+		}];
+		await cloudflareRequest(`lock R2 bucket ${name}`, () => this.getClient().r2.buckets.locks.update(name, {
+			account_id: this.accountId,
+			rules: next
+		}));
+		return "locked";
+	}
 	/**
 	* Delete an R2 bucket by name. Idempotent — a missing bucket is not an error, so teardown can re-run safely.
 	*
@@ -85,4 +135,4 @@ var CloudflareR2Provisioner = class extends CloudflareManager {
 	}
 };
 //#endregion
-export { CloudflareR2Provisioner, R2BucketInfo };
+export { CloudflareR2Provisioner, R2BucketInfo, R2LockRule };

package/dist/test-utils/reap.d.ts

@@ -1,5 +1,6 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
+import type { CloudflareArtifactsManager } from "../artifacts/artifactsManager";
 import { type IntegrationCreds, type ReapableKind, testResourceAge } from "./harness";
 /**
  * The reap registry: every throwaway resource kind a live suite can mint, in one place, swept once per
@@ -87,6 +88,14 @@ export declare function reapKinds(plan: readonly ReapPlanEntry[], options?: {
     now?: number;
     staleAfterMs?: number;
 }): Promise<ReapKindResult[]>;
+/**
+ * Remove one throwaway Artifacts namespace: every repository in it, then the namespace.
+ *
+ * Cloudflare refuses to delete a namespace that still holds a repository, and a repository delete is `202 Accepted`,
+ * so one just reaped can hold the namespace a moment longer. That case throws, so the sweep reports it as not reaped
+ * and the next run tries again, rather than waiting here on Cloudflare's clock. A namespace already gone is done.
+ */
+export declare function reapArtifactsNamespace(artifacts: Pick<CloudflareArtifactsManager, "listRepos" | "deleteRepo" | "deleteNamespace">, namespace: string): Promise<void>;
 /**
  * Build the sweep plan for an account.
  *

package/dist/test-utils/reap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reap.d.ts","sourceRoot":"","sources":["../../src/test-utils/reap.ts"],"names":[],"mappings":"AAMA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,YAAY,EAEjB,eAAe,EAChB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,gHAAgH;IAChH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,kFAAkF;AAClF,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,uFAAuF;AACvF,MAAM,MAAM,aAAa,GAAG,CAAC,YAAY,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,eAAe,CAAC;AAEjF,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,+EAA+E;IAC/E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAOD,uGAAuG;AACvG,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,EAAE,CAEvE;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,SAAS,aAAa,EAAE,EAC9B,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CAAC,cAAc,EAAE,CAAC,CA+B3B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,GAAE,SAAc,GAAG,aAAa,EAAE,CAkHtG;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,gBAAgB,EACvB,OAAO,GAAE,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAChE,OAAO,CAAC,cAAc,EAAE,CAAC,CAc3B;AAED,kFAAkF;AAClF,OAAO,EAAE,eAAe,EAAE,CAAC"}
+{"version":3,"file":"reap.d.ts","sourceRoot":"","sources":["../../src/test-utils/reap.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAGhF,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,YAAY,EAEjB,eAAe,EAChB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,gHAAgH;IAChH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,kFAAkF;AAClF,MAAM,WAAW,eAAe;IAC9B,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,oFAAoF;IACpF,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,uFAAuF;AACvF,MAAM,MAAM,aAAa,GAAG,CAAC,YAAY,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,eAAe,CAAC;AAEjF,qFAAqF;AACrF,MAAM,WAAW,cAAc;IAC7B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,kCAAkC;IAClC,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,+EAA+E;IAC/E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6DAA6D;IAC7D,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAOD,uGAAuG;AACvG,wBAAgB,cAAc,CAAC,IAAI,EAAE,SAAS,aAAa,EAAE,GAAG,MAAM,EAAE,CAEvE;AAED;;;;;;GAMG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,SAAS,aAAa,EAAE,EAC9B,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GACpD,OAAO,CAAC,cAAc,EAAE,CAAC,CA+B3B;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,IAAI,CAAC,0BAA0B,EAAE,WAAW,GAAG,YAAY,GAAG,iBAAiB,CAAC,EAC3F,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,GAAE,SAAc,GAAG,aAAa,EAAE,CAyHtG;AAED;;;;;GAKG;AACH,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,gBAAgB,EACvB,OAAO,GAAE,SAAS,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAChE,OAAO,CAAC,cAAc,EAAE,CAAC,CAc3B;AAED,kFAAkF;AAClF,OAAO,EAAE,eAAe,EAAE,CAAC"}

package/dist/test-utils/reap.js

@@ -3,6 +3,7 @@
 import { CloudflareClients } from "../client/clients.js";
 import { listEmailRoutingRules, namedRules } from "./emailRoutingRules.js";
 import { emptyTestBucket, staleTestResourceNames, testResourceAge } from "./harness.js";
+import { ConflictError } from "@pithy-sh/core/src/error/pithyError";
 import { Cloudflare } from "cloudflare";
 //#region src/test-utils/reap.ts
 /** Whether a plan entry is a stand-in for a kind that cannot run. */
@@ -62,6 +63,20 @@ async function reapKinds(plan, options = {}) {
 	return results;
 }
 /**
+* Remove one throwaway Artifacts namespace: every repository in it, then the namespace.
+*
+* Cloudflare refuses to delete a namespace that still holds a repository, and a repository delete is `202 Accepted`,
+* so one just reaped can hold the namespace a moment longer. That case throws, so the sweep reports it as not reaped
+* and the next run tries again, rather than waiting here on Cloudflare's clock. A namespace already gone is done.
+*/
+async function reapArtifactsNamespace(artifacts, namespace) {
+	for (const repo of await artifacts.listRepos(namespace)) await artifacts.deleteRepo(namespace, repo);
+	if (await artifacts.deleteNamespace(namespace) === "occupied") throw new ConflictError({
+		message: `Artifacts namespace ${namespace} still holds a repository.`,
+		detail: "a repository delete is 202 Accepted; the next sweep deletes the namespace once it is released"
+	});
+}
+/**
 * Build the sweep plan for an account.
 *
 * Alphabetical by label, so the set is readable as a list rather than as an accident of construction
@@ -92,6 +107,11 @@ function testResourceReapPlan(creds, options = {}) {
 				await tokens.deleteTokensByName(name);
 			}
 		},
+		{
+			label: "Artifacts namespace",
+			list: () => clients.artifacts().listNamespaces(),
+			remove: (name) => reapArtifactsNamespace(clients.artifacts(), name)
+		},
 		{
 			label: "D1 database",
 			list: async () => (await d1.listDatabases()).map((database) => database.name),
@@ -184,4 +204,4 @@ async function reapAllStaleTestResources(creds, options = {}) {
 	return results;
 }
 //#endregion
-export { reapAllStaleTestResources, reapKinds, reapPlanLabels, testResourceAge, testResourceReapPlan };
+export { reapAllStaleTestResources, reapArtifactsNamespace, reapKinds, reapPlanLabels, testResourceAge, testResourceReapPlan };

package/dist/test-utils/settle.d.ts

@@ -2,12 +2,21 @@
 // SPDX-License-Identifier: MIT
 /**
  * **Waiting on an eventually consistent control plane, for the live suites.** One budget and one rule, shared
- * by `@pithy-sh/cloudflare`'s Vectorize suite and `@pithy-sh/vector`'s, because the cloudflare suite kept a
- * 60s budget and a single confirming read of its own and failed on exactly that (#709).
+ * by `@pithy-sh/cloudflare`'s Vectorize suite and `@pithy-sh/vector`'s, so neither keeps a shorter budget or a
+ * single confirming read of its own.
  *
- * **The budget is 120s, and 300s for a metadata index.** A Vectorize index became visible 25-50s after the
- * call that made it, measured live, and an upsert became queryable in about 30s. A metadata index is slower:
- * about 97s on one run of #709 and over 120s on the next, so its waits take {@link METADATA_INDEX_SETTLE_MS}.
+ * **The budget is 120s, 300s for an upsert, and 600s for a metadata index.** A Vectorize index became visible
+ * 25-50s after the call that made it, measured live. An upsert usually becomes queryable in about 30s, but one
+ * written right after a metadata index was still unqueryable at 121s, with the vectors before it visible, so the
+ * waits for an upsert take {@link UPSERT_SETTLE_MS}. A metadata index is the slowest: about 97s on one run, over
+ * 120s on the next, and one of two still missing at 300s on a third. Cloudflare documents no readiness time and no
+ * readiness signal for one, so its waits take {@link METADATA_INDEX_SETTLE_MS}, twice the longest measured.
+ *
+ * **An upsert is waited on by its outcome, never by its mutation id.** `describe()` reports a
+ * `processedUpToMutation` watermark, and the manager reads it. The watermark moves through mutation ids the
+ * caller never issued, and a probe watched it step past ours one second after matching it. A mutation id is a
+ * UUID with no order, so "processed up to ours" cannot be computed from a later id, and a poll for equality
+ * misses the one moment it holds. So a wait polls the query until it returns what was written.
  *
  * **A metadata-index wait compares names and types, never a count.** {@link metadataIndexesSettled} is the
  * predicate; a list of the right length can still be the wrong list.
@@ -19,19 +28,25 @@
  * than a fresh read, which can disagree with the one before it.
  *
  * **A test that waits several times shares one deadline across them.** Each wait's own budget bounds that
- * wait and nothing else, so a test making eight of them in a row could outrun its vitest timeout with every
- * step inside budget. Vitest then abandoned the body mid-poll: the failure said only "Test timed out", and the
- * teardown that deletes the index never ran (#709). Pass the same {@link SettleOptions.deadline} to every
- * wait and the step in progress when it passes fails by name, inside the body, where the teardown still runs.
+ * wait and nothing else, so a test making eight of them in a row can outrun its vitest timeout with every
+ * step inside budget. Vitest then abandons the body mid-poll: the failure says only "Test timed out", and the
+ * teardown that deletes the index never runs. Pass the same {@link SettleOptions.deadline} to every wait, set
+ * below the test's vitest timeout, and the step in progress when it passes fails by name, inside the body,
+ * where the teardown still runs.
  */
-/** Ceiling for any one wait. Measured at 25-50s for a control-plane change, and about 30s for an upsert. */
+/** Ceiling for any one wait. Measured at 25-50s for a control-plane change. */
 export declare const SETTLE_TIMEOUT_MS = 120000;
 /**
- * Ceiling for a metadata-index wait, and only for that. A metadata index is the slowest change Vectorize
- * applies: on #709 one settled in about 97s and the next was still unsettled at 120s, so the shared budget
- * undercut exactly this wait. `pithy vector provision` waits on the same measurement.
+ * Ceiling for a metadata-index wait. A metadata index is the slowest change Vectorize applies: one settled in
+ * about 97s, the next was unsettled at 120s, and a third was still missing at 300s. Twice that last figure, and
+ * `pithy vector provision` waits on the same number.
+ */
+export declare const METADATA_INDEX_SETTLE_MS = 600000;
+/**
+ * Ceiling for an upsert to become queryable. About 30s is usual, and one written right after a metadata index
+ * was still missing from the query at 121s, so the waits for an upsert take more than the shared budget.
  */
-export declare const METADATA_INDEX_SETTLE_MS = 300000;
+export declare const UPSERT_SETTLE_MS = 300000;
 /**
  * Consecutive agreeing reads that count as settled. Three, because one confirming read can be a stale replica,
  * and two in a row six seconds apart is a far weaker coincidence.

package/dist/test-utils/settle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"settle.d.ts","sourceRoot":"","sources":["../../src/test-utils/settle.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,4GAA4G;AAC5G,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,SAAU,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,oHAAoH;AACpH,eAAO,MAAM,gBAAgB,OAAQ,CAAC;AAEtC,+FAA+F;AAC/F,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kHAAkH;IAClH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAmBD;;;GAGG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYrH;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,EAC9B,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,CAAC,CAAC,CAiBZ;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,SAAS;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,GAC/D,CAAC,IAAI,EAAE,SAAS;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,OAAO,CAK3E"}
+{"version":3,"file":"settle.d.ts","sourceRoot":"","sources":["../../src/test-utils/settle.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,+EAA+E;AAC/E,eAAO,MAAM,iBAAiB,SAAU,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,SAAU,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,SAAU,CAAC;AAExC;;;GAGG;AACH,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,oHAAoH;AACpH,eAAO,MAAM,gBAAgB,OAAQ,CAAC;AAEtC,+FAA+F;AAC/F,MAAM,WAAW,aAAa;IAC5B,sEAAsE;IACtE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iEAAiE;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kHAAkH;IAClH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAmBD;;;GAGG;AACH,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAAE,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAYrH;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,EAC9B,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,CAAC,CAAC,CAiBZ;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,SAAS;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,GAC/D,CAAC,IAAI,EAAE,SAAS;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,OAAO,CAK3E"}

package/dist/test-utils/settle.js

@@ -3,12 +3,21 @@
 //#region src/test-utils/settle.ts
 /**
 * **Waiting on an eventually consistent control plane, for the live suites.** One budget and one rule, shared
-* by `@pithy-sh/cloudflare`'s Vectorize suite and `@pithy-sh/vector`'s, because the cloudflare suite kept a
-* 60s budget and a single confirming read of its own and failed on exactly that (#709).
+* by `@pithy-sh/cloudflare`'s Vectorize suite and `@pithy-sh/vector`'s, so neither keeps a shorter budget or a
+* single confirming read of its own.
 *
-* **The budget is 120s, and 300s for a metadata index.** A Vectorize index became visible 25-50s after the
-* call that made it, measured live, and an upsert became queryable in about 30s. A metadata index is slower:
-* about 97s on one run of #709 and over 120s on the next, so its waits take {@link METADATA_INDEX_SETTLE_MS}.
+* **The budget is 120s, 300s for an upsert, and 600s for a metadata index.** A Vectorize index became visible
+* 25-50s after the call that made it, measured live. An upsert usually becomes queryable in about 30s, but one
+* written right after a metadata index was still unqueryable at 121s, with the vectors before it visible, so the
+* waits for an upsert take {@link UPSERT_SETTLE_MS}. A metadata index is the slowest: about 97s on one run, over
+* 120s on the next, and one of two still missing at 300s on a third. Cloudflare documents no readiness time and no
+* readiness signal for one, so its waits take {@link METADATA_INDEX_SETTLE_MS}, twice the longest measured.
+*
+* **An upsert is waited on by its outcome, never by its mutation id.** `describe()` reports a
+* `processedUpToMutation` watermark, and the manager reads it. The watermark moves through mutation ids the
+* caller never issued, and a probe watched it step past ours one second after matching it. A mutation id is a
+* UUID with no order, so "processed up to ours" cannot be computed from a later id, and a poll for equality
+* misses the one moment it holds. So a wait polls the query until it returns what was written.
 *
 * **A metadata-index wait compares names and types, never a count.** {@link metadataIndexesSettled} is the
 * predicate; a list of the right length can still be the wrong list.
@@ -20,19 +29,25 @@
 * than a fresh read, which can disagree with the one before it.
 *
 * **A test that waits several times shares one deadline across them.** Each wait's own budget bounds that
-* wait and nothing else, so a test making eight of them in a row could outrun its vitest timeout with every
-* step inside budget. Vitest then abandoned the body mid-poll: the failure said only "Test timed out", and the
-* teardown that deletes the index never ran (#709). Pass the same {@link SettleOptions.deadline} to every
-* wait and the step in progress when it passes fails by name, inside the body, where the teardown still runs.
+* wait and nothing else, so a test making eight of them in a row can outrun its vitest timeout with every
+* step inside budget. Vitest then abandons the body mid-poll: the failure says only "Test timed out", and the
+* teardown that deletes the index never runs. Pass the same {@link SettleOptions.deadline} to every wait, set
+* below the test's vitest timeout, and the step in progress when it passes fails by name, inside the body,
+* where the teardown still runs.
 */
-/** Ceiling for any one wait. Measured at 25-50s for a control-plane change, and about 30s for an upsert. */
+/** Ceiling for any one wait. Measured at 25-50s for a control-plane change. */
 const SETTLE_TIMEOUT_MS = 12e4;
 /**
-* Ceiling for a metadata-index wait, and only for that. A metadata index is the slowest change Vectorize
-* applies: on #709 one settled in about 97s and the next was still unsettled at 120s, so the shared budget
-* undercut exactly this wait. `pithy vector provision` waits on the same measurement.
+* Ceiling for a metadata-index wait. A metadata index is the slowest change Vectorize applies: one settled in
+* about 97s, the next was unsettled at 120s, and a third was still missing at 300s. Twice that last figure, and
+* `pithy vector provision` waits on the same number.
+*/
+const METADATA_INDEX_SETTLE_MS = 6e5;
+/**
+* Ceiling for an upsert to become queryable. About 30s is usual, and one written right after a metadata index
+* was still missing from the query at 121s, so the waits for an upsert take more than the shared budget.
 */
-const METADATA_INDEX_SETTLE_MS = 3e5;
+const UPSERT_SETTLE_MS = 3e5;
 /**
 * Consecutive agreeing reads that count as settled. Three, because one confirming read can be a stale replica,
 * and two in a row six seconds apart is a far weaker coincidence.
@@ -102,4 +117,4 @@ function metadataIndexesSettled(declared) {
 	};
 }
 //#endregion
-export { METADATA_INDEX_SETTLE_MS, POLL_INTERVAL_MS, SETTLE_TIMEOUT_MS, STABLE_READS, metadataIndexesSettled, waitFor, waitForStable };
+export { METADATA_INDEX_SETTLE_MS, POLL_INTERVAL_MS, SETTLE_TIMEOUT_MS, STABLE_READS, UPSERT_SETTLE_MS, metadataIndexesSettled, waitFor, waitForStable };

package/dist/test-utils/workerAnswer.d.ts

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+/**
+ * **Reading a live probe Worker's answer, for the suites that deploy one.** A probe Worker answers JSON, its
+ * own failures included. An HTML page in its place is Cloudflare's, not the Worker's: a workers.dev address
+ * that has not reached every machine yet, or a platform error page such as 1101 (an exception the Worker did
+ * not catch) or 1102 (a resource limit). `response.json()` reports any of those as `Unexpected token '<'`,
+ * which names none of them, so {@link readWorkerAnswer} reads the body as text and, when it is not JSON, fails
+ * with the status, the `cf-ray`, the Cloudflare error code and the page's title.
+ */
+/** How much of a body that is not JSON a failure quotes. */
+export declare const BODY_EXCERPT_CHARS = 300;
+/** The Cloudflare error code and title an HTML error page carries, when it carries them. */
+export declare function cloudflareErrorPage(body: string): {
+    code: string | null;
+    title: string | null;
+};
+/** One line describing an answer that was not the JSON the probe sends: status, ray, error code, title, excerpt. */
+export declare function describeNonJsonAnswer(what: string, answer: {
+    status: number;
+    ray: string | null;
+    body: string;
+}): string;
+/**
+ * The probe's JSON answer, or a failure that says what came back instead. A non-2xx JSON answer is the Worker's
+ * own failure and is reported with its body; a body that is not JSON is Cloudflare's page, described by
+ * {@link describeNonJsonAnswer}.
+ */
+export declare function readWorkerAnswer(what: string, response: Response): Promise<unknown>;
+//# sourceMappingURL=workerAnswer.d.ts.map

package/dist/test-utils/workerAnswer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerAnswer.d.ts","sourceRoot":"","sources":["../../src/test-utils/workerAnswer.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH,4DAA4D;AAC5D,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC,4FAA4F;AAC5F,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAO/F;AAED,oHAAoH;AACpH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC3D,MAAM,CAUR;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,OAAO,CAAC,CAYzF"}

package/dist/test-utils/workerAnswer.js

@@ -0,0 +1,53 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+//#region src/test-utils/workerAnswer.ts
+/**
+* **Reading a live probe Worker's answer, for the suites that deploy one.** A probe Worker answers JSON, its
+* own failures included. An HTML page in its place is Cloudflare's, not the Worker's: a workers.dev address
+* that has not reached every machine yet, or a platform error page such as 1101 (an exception the Worker did
+* not catch) or 1102 (a resource limit). `response.json()` reports any of those as `Unexpected token '<'`,
+* which names none of them, so {@link readWorkerAnswer} reads the body as text and, when it is not JSON, fails
+* with the status, the `cf-ray`, the Cloudflare error code and the page's title.
+*/
+/** How much of a body that is not JSON a failure quotes. */
+const BODY_EXCERPT_CHARS = 300;
+/** The Cloudflare error code and title an HTML error page carries, when it carries them. */
+function cloudflareErrorPage(body) {
+	return {
+		code: /class="cf-error-code"[^>]*>\s*(\d{3,4})\s*</i.exec(body)?.[1] ?? /\bError(?:\s+code)?\s*:?\s*(1\d{3})\b/i.exec(body)?.[1] ?? null,
+		title: /<title>([^<]*)<\/title>/i.exec(body)?.[1]?.replace(/\s+/g, " ").trim() || null
+	};
+}
+/** One line describing an answer that was not the JSON the probe sends: status, ray, error code, title, excerpt. */
+function describeNonJsonAnswer(what, answer) {
+	const { code, title } = cloudflareErrorPage(answer.body);
+	const excerpt = answer.body.replace(/\s+/g, " ").trim().slice(0, 300);
+	return `${[
+		`${what} answered ${answer.status} with a body that is not JSON`,
+		`cf-ray ${answer.ray ?? "absent"}`,
+		`Cloudflare error ${code ?? "none named"}`,
+		...title ? [`title "${title}"`] : []
+	].join(", ")}. Body: ${excerpt}`;
+}
+/**
+* The probe's JSON answer, or a failure that says what came back instead. A non-2xx JSON answer is the Worker's
+* own failure and is reported with its body; a body that is not JSON is Cloudflare's page, described by
+* {@link describeNonJsonAnswer}.
+*/
+async function readWorkerAnswer(what, response) {
+	const body = await response.text();
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch {
+		throw new Error(describeNonJsonAnswer(what, {
+			status: response.status,
+			ray: response.headers.get("cf-ray"),
+			body
+		}));
+	}
+	if (!response.ok) throw new Error(`${what} answered ${response.status}: ${JSON.stringify(parsed)}`);
+	return parsed;
+}
+//#endregion
+export { BODY_EXCERPT_CHARS, cloudflareErrorPage, describeNonJsonAnswer, readWorkerAnswer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pithy-sh/cloudflare",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -40,7 +40,7 @@
     "js-base64": "^3.9.2"
   },
   "peerDependencies": {
-    "@pithy-sh/core": "^0.13.0",
+    "@pithy-sh/core": "^0.14.0",
     "zod": "^4.4.0"
   },
   "devDependencies": {

package/src/ai/vectorizeProvisioner.ts

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 
+import { ConflictError } from "@pithy-sh/core/src/error/pithyError";
 import { z } from "zod";
 import { cloudflareRequest, decodeResponse, isNotFoundError } from "../client/errors";
 import { CloudflareManager } from "../client/manager";
@@ -124,6 +125,25 @@ function isAbsentMetadataIndexError(error: unknown): boolean {
   return errors.some((entry) => (entry as { code?: unknown } | null)?.code === METADATA_INDEX_ABSENT_CODE);
 }
 
+/** Vectorize's error code for "a metadata index with that name already exists". */
+const METADATA_INDEX_EXISTS_CODE = 40004;
+
+/**
+ * Whether an error means "that metadata index is already there": `400` with error code 40004, the answer to
+ * creating a property that is already indexed. Narrow for the same reason {@link isAbsentMetadataIndexError} is:
+ * every other `400` stays an error.
+ *
+ * It is how a create retried by the SDK comes back. The SDK retries a request that timed out, lost its
+ * connection, or answered 408, 409, 429 or a 5xx, twice by default and a POST included, so a create Cloudflare
+ * applied can be sent again and refused as a duplicate of itself.
+ */
+export function isExistingMetadataIndexError(error: unknown): boolean {
+  if (typeof error !== "object" || error === null) return false;
+  const { status, errors } = error as { status?: unknown; errors?: unknown };
+  if (status !== 400 || !Array.isArray(errors)) return false;
+  return errors.some((entry) => (entry as { code?: unknown } | null)?.code === METADATA_INDEX_EXISTS_CODE);
+}
+
 /** Options a new index accepts beyond its name and shape. */
 export interface CreateVectorizeIndexOptions {
   /** A human description stored on the index, surfaced in the Cloudflare dashboard. */
@@ -218,19 +238,39 @@ export class CloudflareVectorizeProvisioner extends CloudflareManager {
    * Make a metadata property filterable. Cloudflare caps an index at 10 indexed properties, and only vectors
    * written **after** the metadata index exists are covered — so declare these before the first insert.
    * The change is enqueued asynchronously; the returned promise resolving means accepted, not live.
+   *
+   * Idempotent, like {@link deleteMetadataIndex}. A property already indexed answers `400`/40004
+   * ({@link isExistingMetadataIndexError}); the list then decides. Listed with the same type, the create has
+   * already happened and this returns. Listed with another type, it throws `core/conflict` naming both, since a
+   * metadata index's type is fixed. Not listed yet, it returns too: Cloudflare has just said the index exists,
+   * the list lags, and the caller's own settle wait reads its type.
    */
   async createMetadataIndex(
     indexName: string,
     propertyName: string,
     indexType: VectorizeMetadataIndexType,
   ): Promise<void> {
-    await cloudflareRequest(`create Vectorize metadata index ${indexName}.${propertyName}`, () =>
-      this.getClient().vectorize.indexes.metadataIndex.create(indexName, {
-        account_id: this.accountId,
-        indexType,
-        propertyName,
-      }),
-    );
+    await cloudflareRequest(`create Vectorize metadata index ${indexName}.${propertyName}`, async () => {
+      try {
+        await this.getClient().vectorize.indexes.metadataIndex.create(indexName, {
+          account_id: this.accountId,
+          indexType,
+          propertyName,
+        });
+      } catch (error) {
+        if (!isExistingMetadataIndexError(error)) throw error;
+        const live = (await this.listMetadataIndexes(indexName)).find((entry) => entry.propertyName === propertyName);
+        if (live === undefined || live.indexType === indexType) return;
+        throw new ConflictError(
+          {
+            message: `Metadata index ${indexName}.${propertyName} already exists as ${live.indexType}, not ${indexType}.`,
+            action: `A metadata index's type is fixed. Declare ${propertyName} as ${live.indexType}, or delete the metadata index and create it again.`,
+            detail: `Cloudflare answered 40004 to a create of ${propertyName} as ${indexType}; the list holds it as ${live.indexType}.`,
+          },
+          { cause: error },
+        );
+      }
+    });
   }
 
   /** List an index's indexed metadata properties — the read that proves a `createMetadataIndex` has landed. */

package/src/artifacts/artifactsManager.ts

@@ -42,10 +42,10 @@ const Envelope = z
   })
   .describe("A Cloudflare REST envelope.");
 
-/** One page of `GET …/repos`: only the name of each repo is read. */
-const RepoPage = z
-  .array(z.object({ name: z.string().describe("The repo's name in the namespace.") }).loose())
-  .describe("One page of an Artifacts namespace's repos.");
+/** One page of `GET …/repos` or `GET …/namespaces`: only the name of each entry is read. */
+const NamedPage = z
+  .array(z.object({ name: z.string().describe("The repo's or the namespace's name.") }).loose())
+  .describe("One page of an Artifacts listing of repos or namespaces.");
 
 /**
  * Account-level Artifacts control plane: **list and delete the repos in a namespace, then the namespace** (#673).
@@ -81,23 +81,38 @@ export class CloudflareArtifactsManager extends CloudflareManager {
    */
   async listRepos(namespace: string): Promise<string[]> {
     assertName(namespace, "namespace");
-    return cloudflareRequest(`list Artifacts repos in ${namespace}`, async () => {
-      const names = new Set<string>();
-      const followed = new Set<string>();
-      let cursor: string | undefined;
-      for (;;) {
-        const query = `limit=${PAGE_LIMIT}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
-        const page = await this.call("GET", `${this.namespacePath(namespace)}/repos?${query}`);
-        if (page === null) return [...names];
-        for (const repo of decodeResponse(RepoPage, page.result, "Artifacts repo list")) names.add(repo.name);
-        const next = page.result_info?.cursor ?? undefined;
-        // A cursor already followed is the last page answering again; stopping there is what keeps a listing
-        // that never empties its cursor from looping forever.
-        if (!next || followed.has(next)) return [...names];
-        followed.add(next);
-        cursor = next;
-      }
-    });
+    return cloudflareRequest(`list Artifacts repos in ${namespace}`, () =>
+      this.names(`${this.namespacePath(namespace)}/repos`, "Artifacts repo list"),
+    );
+  }
+
+  /**
+   * Every namespace name on the account, across every page. The live suites' debris sweep reads it to find the
+   * `pithy-int-` namespaces an aborted run left behind, since nothing else lists them.
+   */
+  async listNamespaces(): Promise<string[]> {
+    return cloudflareRequest("list Artifacts namespaces", () =>
+      this.names(`/accounts/${this.getAccountId()}/artifacts/namespaces`, "Artifacts namespace list"),
+    );
+  }
+
+  /** Every `name` a paged listing answers, following its cursor. A 404 is an empty listing. */
+  private async names(path: string, what: string): Promise<string[]> {
+    const names = new Set<string>();
+    const followed = new Set<string>();
+    let cursor: string | undefined;
+    for (;;) {
+      const query = `limit=${PAGE_LIMIT}${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
+      const page = await this.call("GET", `${path}?${query}`);
+      if (page === null) return [...names];
+      for (const entry of decodeResponse(NamedPage, page.result, what)) names.add(entry.name);
+      const next = page.result_info?.cursor ?? undefined;
+      // A cursor already followed is the last page answering again; stopping there is what keeps a listing
+      // that never empties its cursor from looping forever.
+      if (!next || followed.has(next)) return [...names];
+      followed.add(next);
+      cursor = next;
+    }
   }
 
   /**

package/src/r2/r2Provisioner.ts

@@ -13,6 +13,36 @@ export const R2BucketInfo = z
   .describe("A Cloudflare R2 bucket's identity, as returned by the create/list endpoints.");
 export type R2BucketInfo = z.output<typeof R2BucketInfo>;
 
+/** One R2 bucket lock rule: objects under `prefix` cannot be overwritten or deleted while its condition holds. */
+export const R2LockRule = z
+  .object({
+    id: z.string().describe("The rule's id, unique within the bucket."),
+    enabled: z.boolean().describe("Whether the rule is in force."),
+    prefix: z.string().optional().describe("The key prefix it covers. Absent or empty covers every object."),
+    condition: z
+      .discriminatedUnion("type", [
+        z
+          .object({
+            type: z.literal("Age").describe("Locked for a time after each object is written."),
+            maxAgeSeconds: z.number().describe("How long, in seconds."),
+          })
+          .describe("Locked for an age."),
+        z
+          .object({
+            type: z.literal("Date").describe("Locked until a date."),
+            date: z.string().describe("The date, ISO-8601."),
+          })
+          .describe("Locked until a date."),
+        z.object({ type: z.literal("Indefinite").describe("Locked for ever.") }).describe("Locked for ever."),
+      ])
+      .describe("How long the objects stay locked."),
+  })
+  .describe("An R2 bucket lock rule.");
+export type R2LockRule = z.output<typeof R2LockRule>;
+
+/** What asking for an indefinite lock did. */
+export type R2LockOutcome = "locked" | "already";
+
 /**
  * Account-level R2 control plane: **create and delete buckets**. Customers use this to stand up and
  * tear down per-environment buckets (e.g. ephemeral staging), and worktree teardown uses it to
@@ -79,6 +109,50 @@ export class CloudflareR2Provisioner extends CloudflareManager {
     return decodeResponse(R2BucketInfo, response, "R2 bucket create");
   }
 
+  /** The bucket's lock rules. A bucket with none answers an empty list. */
+  async bucketLockRules(name: string): Promise<R2LockRule[]> {
+    const response = await cloudflareRequest(`read lock rules of R2 bucket ${name}`, () =>
+      this.getClient().r2.buckets.locks.get(name, { account_id: this.accountId }),
+    );
+    return (
+      decodeResponse(
+        z.object({ rules: z.array(R2LockRule).optional() }).describe("A bucket's lock rules."),
+        response,
+        "R2 bucket lock rules",
+      ).rules ?? []
+    );
+  }
+
+  /** Whether some enabled rule locks every object under `prefix` indefinitely. */
+  static locksPrefixIndefinitely(rules: readonly R2LockRule[], prefix: string): boolean {
+    return rules.some(
+      (rule) => rule.enabled && rule.condition.type === "Indefinite" && prefix.startsWith(rule.prefix ?? ""),
+    );
+  }
+
+  /** Whether the bucket's rules lock every object under `prefix` indefinitely, read from the account. */
+  async prefixLockedIndefinitely(name: string, prefix: string): Promise<boolean> {
+    return CloudflareR2Provisioner.locksPrefixIndefinitely(await this.bucketLockRules(name), prefix);
+  }
+
+  /**
+   * Lock every object under `prefix` indefinitely, beside whatever rules the bucket already has. Idempotent: a
+   * rule already in force is left alone and answered `already`. The update replaces the bucket's whole rule set,
+   * so the existing rules are read and written back with the new one — never dropped.
+   */
+  async lockPrefixIndefinitely(name: string, prefix: string, id: string): Promise<R2LockOutcome> {
+    const rules = await this.bucketLockRules(name);
+    if (CloudflareR2Provisioner.locksPrefixIndefinitely(rules, prefix)) return "already";
+    const next = [
+      ...rules.filter((rule) => rule.id !== id),
+      { id, enabled: true, prefix, condition: { type: "Indefinite" as const } },
+    ];
+    await cloudflareRequest(`lock R2 bucket ${name}`, () =>
+      this.getClient().r2.buckets.locks.update(name, { account_id: this.accountId, rules: next }),
+    );
+    return "locked";
+  }
+
   /**
    * Delete an R2 bucket by name. Idempotent — a missing bucket is not an error, so teardown can re-run safely.
    *

package/src/test-utils/reap.ts

@@ -1,7 +1,9 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 
+import { ConflictError } from "@pithy-sh/core/src/error/pithyError";
 import { Cloudflare } from "cloudflare";
+import type { CloudflareArtifactsManager } from "../artifacts/artifactsManager";
 import { CloudflareClients } from "../client/clients";
 import { listEmailRoutingRules, namedRules } from "./emailRoutingRules";
 import {
@@ -141,6 +143,26 @@ export async function reapKinds(
   return results;
 }
 
+/**
+ * Remove one throwaway Artifacts namespace: every repository in it, then the namespace.
+ *
+ * Cloudflare refuses to delete a namespace that still holds a repository, and a repository delete is `202 Accepted`,
+ * so one just reaped can hold the namespace a moment longer. That case throws, so the sweep reports it as not reaped
+ * and the next run tries again, rather than waiting here on Cloudflare's clock. A namespace already gone is done.
+ */
+export async function reapArtifactsNamespace(
+  artifacts: Pick<CloudflareArtifactsManager, "listRepos" | "deleteRepo" | "deleteNamespace">,
+  namespace: string,
+): Promise<void> {
+  for (const repo of await artifacts.listRepos(namespace)) await artifacts.deleteRepo(namespace, repo);
+  if ((await artifacts.deleteNamespace(namespace)) === "occupied") {
+    throw new ConflictError({
+      message: `Artifacts namespace ${namespace} still holds a repository.`,
+      detail: "a repository delete is 202 Accepted; the next sweep deletes the namespace once it is released",
+    });
+  }
+}
+
 /**
  * Build the sweep plan for an account.
  *
@@ -172,6 +194,13 @@ export function testResourceReapPlan(creds: IntegrationCreds, options: ReapScope
         await tokens.deleteTokensByName(name);
       },
     },
+    {
+      // Minted by `@pithy-sh/artifacts`' `revokeAll.integration.test.ts`: a Worker bound to a throwaway namespace,
+      // which Cloudflare creates on the first repository and nothing but this deletes.
+      label: "Artifacts namespace",
+      list: () => clients.artifacts().listNamespaces(),
+      remove: (name) => reapArtifactsNamespace(clients.artifacts(), name),
+    },
     {
       label: "D1 database",
       list: async () => (await d1.listDatabases()).map((database) => database.name),

package/src/test-utils/settle.ts

@@ -3,12 +3,21 @@
 
 /**
  * **Waiting on an eventually consistent control plane, for the live suites.** One budget and one rule, shared
- * by `@pithy-sh/cloudflare`'s Vectorize suite and `@pithy-sh/vector`'s, because the cloudflare suite kept a
- * 60s budget and a single confirming read of its own and failed on exactly that (#709).
+ * by `@pithy-sh/cloudflare`'s Vectorize suite and `@pithy-sh/vector`'s, so neither keeps a shorter budget or a
+ * single confirming read of its own.
  *
- * **The budget is 120s, and 300s for a metadata index.** A Vectorize index became visible 25-50s after the
- * call that made it, measured live, and an upsert became queryable in about 30s. A metadata index is slower:
- * about 97s on one run of #709 and over 120s on the next, so its waits take {@link METADATA_INDEX_SETTLE_MS}.
+ * **The budget is 120s, 300s for an upsert, and 600s for a metadata index.** A Vectorize index became visible
+ * 25-50s after the call that made it, measured live. An upsert usually becomes queryable in about 30s, but one
+ * written right after a metadata index was still unqueryable at 121s, with the vectors before it visible, so the
+ * waits for an upsert take {@link UPSERT_SETTLE_MS}. A metadata index is the slowest: about 97s on one run, over
+ * 120s on the next, and one of two still missing at 300s on a third. Cloudflare documents no readiness time and no
+ * readiness signal for one, so its waits take {@link METADATA_INDEX_SETTLE_MS}, twice the longest measured.
+ *
+ * **An upsert is waited on by its outcome, never by its mutation id.** `describe()` reports a
+ * `processedUpToMutation` watermark, and the manager reads it. The watermark moves through mutation ids the
+ * caller never issued, and a probe watched it step past ours one second after matching it. A mutation id is a
+ * UUID with no order, so "processed up to ours" cannot be computed from a later id, and a poll for equality
+ * misses the one moment it holds. So a wait polls the query until it returns what was written.
  *
  * **A metadata-index wait compares names and types, never a count.** {@link metadataIndexesSettled} is the
  * predicate; a list of the right length can still be the wrong list.
@@ -20,21 +29,28 @@
  * than a fresh read, which can disagree with the one before it.
  *
  * **A test that waits several times shares one deadline across them.** Each wait's own budget bounds that
- * wait and nothing else, so a test making eight of them in a row could outrun its vitest timeout with every
- * step inside budget. Vitest then abandoned the body mid-poll: the failure said only "Test timed out", and the
- * teardown that deletes the index never ran (#709). Pass the same {@link SettleOptions.deadline} to every
- * wait and the step in progress when it passes fails by name, inside the body, where the teardown still runs.
+ * wait and nothing else, so a test making eight of them in a row can outrun its vitest timeout with every
+ * step inside budget. Vitest then abandons the body mid-poll: the failure says only "Test timed out", and the
+ * teardown that deletes the index never runs. Pass the same {@link SettleOptions.deadline} to every wait, set
+ * below the test's vitest timeout, and the step in progress when it passes fails by name, inside the body,
+ * where the teardown still runs.
  */
 
-/** Ceiling for any one wait. Measured at 25-50s for a control-plane change, and about 30s for an upsert. */
+/** Ceiling for any one wait. Measured at 25-50s for a control-plane change. */
 export const SETTLE_TIMEOUT_MS = 120_000;
 
 /**
- * Ceiling for a metadata-index wait, and only for that. A metadata index is the slowest change Vectorize
- * applies: on #709 one settled in about 97s and the next was still unsettled at 120s, so the shared budget
- * undercut exactly this wait. `pithy vector provision` waits on the same measurement.
+ * Ceiling for a metadata-index wait. A metadata index is the slowest change Vectorize applies: one settled in
+ * about 97s, the next was unsettled at 120s, and a third was still missing at 300s. Twice that last figure, and
+ * `pithy vector provision` waits on the same number.
+ */
+export const METADATA_INDEX_SETTLE_MS = 600_000;
+
+/**
+ * Ceiling for an upsert to become queryable. About 30s is usual, and one written right after a metadata index
+ * was still missing from the query at 121s, so the waits for an upsert take more than the shared budget.
  */
-export const METADATA_INDEX_SETTLE_MS = 300_000;
+export const UPSERT_SETTLE_MS = 300_000;
 
 /**
  * Consecutive agreeing reads that count as settled. Three, because one confirming read can be a stale replica,

package/src/test-utils/workerAnswer.ts

@@ -0,0 +1,59 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+
+/**
+ * **Reading a live probe Worker's answer, for the suites that deploy one.** A probe Worker answers JSON, its
+ * own failures included. An HTML page in its place is Cloudflare's, not the Worker's: a workers.dev address
+ * that has not reached every machine yet, or a platform error page such as 1101 (an exception the Worker did
+ * not catch) or 1102 (a resource limit). `response.json()` reports any of those as `Unexpected token '<'`,
+ * which names none of them, so {@link readWorkerAnswer} reads the body as text and, when it is not JSON, fails
+ * with the status, the `cf-ray`, the Cloudflare error code and the page's title.
+ */
+
+/** How much of a body that is not JSON a failure quotes. */
+export const BODY_EXCERPT_CHARS = 300;
+
+/** The Cloudflare error code and title an HTML error page carries, when it carries them. */
+export function cloudflareErrorPage(body: string): { code: string | null; title: string | null } {
+  const code =
+    /class="cf-error-code"[^>]*>\s*(\d{3,4})\s*</i.exec(body)?.[1] ??
+    /\bError(?:\s+code)?\s*:?\s*(1\d{3})\b/i.exec(body)?.[1] ??
+    null;
+  const title = /<title>([^<]*)<\/title>/i.exec(body)?.[1]?.replace(/\s+/g, " ").trim() || null;
+  return { code, title };
+}
+
+/** One line describing an answer that was not the JSON the probe sends: status, ray, error code, title, excerpt. */
+export function describeNonJsonAnswer(
+  what: string,
+  answer: { status: number; ray: string | null; body: string },
+): string {
+  const { code, title } = cloudflareErrorPage(answer.body);
+  const excerpt = answer.body.replace(/\s+/g, " ").trim().slice(0, BODY_EXCERPT_CHARS);
+  const parts = [
+    `${what} answered ${answer.status} with a body that is not JSON`,
+    `cf-ray ${answer.ray ?? "absent"}`,
+    `Cloudflare error ${code ?? "none named"}`,
+    ...(title ? [`title "${title}"`] : []),
+  ];
+  return `${parts.join(", ")}. Body: ${excerpt}`;
+}
+
+/**
+ * The probe's JSON answer, or a failure that says what came back instead. A non-2xx JSON answer is the Worker's
+ * own failure and is reported with its body; a body that is not JSON is Cloudflare's page, described by
+ * {@link describeNonJsonAnswer}.
+ */
+export async function readWorkerAnswer(what: string, response: Response): Promise<unknown> {
+  const body = await response.text();
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    throw new Error(
+      describeNonJsonAnswer(what, { status: response.status, ray: response.headers.get("cf-ray"), body }),
+    );
+  }
+  if (!response.ok) throw new Error(`${what} answered ${response.status}: ${JSON.stringify(parsed)}`);
+  return parsed;
+}