@pithy-sh/core 0.9.0 → 0.11.0

package/dist/migrations/runner.js

@@ -1,9 +1,11 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
-import { InternalError } from "../error/pithyError.js";
+import { InternalError, ValidationError } from "../error/pithyError.js";
+import { pithyCommand } from "../cli/command.js";
 import { causeMessage } from "../error/cause.js";
-import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, migrationKysely } from "./bookkeeping.js";
+import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, appliedMigrationChain, migrationKysely } from "./bookkeeping.js";
 import { batchedProvider } from "./batch.js";
+import { forgetMigrationGroups, generatedMigrationGroup, readGroupPosition, recordMigrationGroup } from "./groups.js";
 import { RetainedBudget, guardRetained, isDownRefusal } from "./retained.js";
 import { sql } from "kysely";
 import { Migrator, NO_MIGRATIONS } from "kysely/migration";
@@ -31,6 +33,12 @@ import { Migrator, NO_MIGRATIONS } from "kysely/migration";
 * are argued.** The short version: a migration is now all-or-nothing where it used to be able to
 * half-apply, and nothing across a migration boundary changed, because the ledger names migrations
 * and a partial chain has to stay representable in it.
+*
+* **Every run belongs to a group, and a reversal names one — see `./groups` (#694).** A forward run
+* records the group it applied each migration under, in a table beside the ledger;
+* {@link reverseMigrationGroup} reverses one group's portion of one database, in reverse chain order and
+* nothing outside it. {@link rollbackMigration} is still the single step underneath, for a caller holding
+* one migration rather than a release — it is not what `pithy migrate --rollback` runs any more.
 */
 /**
 * **`allowUnorderedMigrations` is on, and it is not a loosening.** A composed key leads with its
@@ -63,9 +71,30 @@ function guardOptions(target, consent) {
 		budget: consent?.budget ?? new RetainedBudget(void 0)
 	};
 }
-/** Run every pending migration to latest. An empty provider resolves to `[]`. */
-async function runMigrations(database, provider, target) {
+/**
+* Run every pending migration to latest, recording the run's group against each one. An empty provider
+* resolves to `[]` and records nothing.
+*
+* **The group is written from what Kysely hands back, and before the failure is raised.** A run that
+* half-applies is retried with the key it already has, so the migrations that stuck have to be in the
+* group — otherwise the retry's group would sit on top of an ungrouped migration, and reversing the
+* retry would leave half a release applied with nothing recording it.
+*/
+async function runMigrations(database, provider, target, options) {
 	const { error, results } = await migrator(database, provider, target, void 0).migrateToLatest();
+	const applied = (results ?? []).filter((result) => result.direction === "Up" && result.status === "Success").map((result) => result.migrationName);
+	try {
+		await recordMigrationGroup(database, {
+			group: options?.group ?? generatedMigrationGroup(),
+			migrations: applied
+		});
+	} catch (cause) {
+		if (error === void 0) throw new InternalError({
+			message: `Applied ${applied.length === 1 ? "a migration" : `${applied.length} migrations`}${on(target)}, then couldn't record the group.`,
+			detail: `${where(target)} ${reasonOf(cause)}`,
+			action: "Check the database is writable. A second run records nothing for them, so they cannot be reversed by group."
+		}, { cause });
+	}
 	return settle("run", error, results, target);
 }
 /**
@@ -94,15 +123,79 @@ async function readMigrationLedger(database, provider) {
 	};
 }
 /**
-* Step this database's latest applied migration back — one step, per database. `pithy migrate --rollback`
-* calls it once for **every** database in its fan-out. Refused while a retained table here holds rows the
-* caller has not counted in `consent` (#588).
+* Step this database's latest applied migration back — **one** step, in **one** database.
+*
+* It is no longer what `pithy migrate --rollback` runs: a rollback names a group and reverses that
+* group's portion of each database ({@link reverseMigrationGroup}, #694). What this is, is the single
+* step underneath — the primitive every capability's "its `down` is the inverse of its `up`" suite
+* reverses one migration with, and the honest answer for a caller holding one migration rather than a
+* release.
+*
+* It forgets the reversed migration's group row, so the group bookkeeping follows the ledger whichever
+* way a migration came down. Refused while a retained table here holds rows the caller has not counted in
+* `consent` (#588).
 */
 async function rollbackMigration(database, provider, target, consent) {
 	const { error, results } = await migrator(database, provider, target, consent).migrateDown();
+	await forgetReversed(database, results);
 	return settle("rollback", error, results, target);
 }
 /**
+* **Reverse one group's portion of one database — the operation behind `pithy migrate --rollback
+* --group` (#694).**
+*
+* Kysely steps down from the tip, so this is `migrateDown()` once per migration in the group, in reverse
+* chain order, and **nothing outside it**. Both halves of that are read from the ledger here, not taken on
+* the caller's word: the group has to be the ledger's own tail before the first `down`, and what each step
+* brings down has to be one of the migrations that read said the group holds — anything else is an
+* internal fault and throws rather than carrying on. **And a migration with no `down` stops the group**:
+* Kysely reports one as `NotExecuted` and leaves it applied, so counting it as reversed is how a group
+* reported itself fully rolled back with half of it still in the database. The caller's pre-flight is what
+* makes a group reverse completely or not at all across databases; this is the floor under it.
+*
+* **One migrator for the whole group**, so the retained guard clears once and the caller's budget is spent
+* once across every `down` it covers (#588). Each migration's group row is forgotten as it comes down —
+* before the step's failure is raised — so a group reversal that dies partway can be re-run under the
+* same group and reverses what is left.
+*/
+async function reverseMigrationGroup(database, provider, step, target, consent) {
+	if (step.migrations.length === 0) return [];
+	const position = await readGroupPosition(database, step.group);
+	if (position.state !== "top") throw new InternalError({
+		message: `Group "${step.group}" is not the top of ${target?.binding ?? "this database"}'s chain.`,
+		detail: `${where(target)} ${position.state === "absent" ? "It records nothing under that group." : `Applied over it: ${overIt(position.above, position.ungrouped)}.`}`,
+		action: `Run ${pithyCommand("doctor")} to see where each database stands.`
+	});
+	const remaining = new Set(position.migrations);
+	const runner = migrator(database, provider, target, consent);
+	const reversed = [];
+	while (remaining.size > 0) {
+		const { error, results } = await runner.migrateDown();
+		await forgetReversed(database, results);
+		const settled = settle("rollback", error, results, target);
+		if (settled.length === 0) break;
+		for (const result of settled) {
+			if (result.status !== "Success") throw new ValidationError({
+				message: `Migration "${result.migrationName}" has no down, so group "${step.group}" cannot be reversed${on(target)}.`,
+				action: `Give ${result.migrationName} a down, then reverse the group again.`,
+				detail: [where(target), reversed.length === 0 ? "Nothing was reversed. A group reverses completely or not at all." : `Reversed before the refusal: ${reversed.map((entry) => `"${entry.migrationName}"`).join(", ")}. The rest of the group is still applied.`].filter(Boolean).join(" ")
+			});
+			if (!remaining.delete(result.migrationName)) throw new InternalError({
+				message: `Reversing group "${step.group}"${on(target)} would have reversed "${result.migrationName}", which is not in it.`,
+				detail: `${where(target)} The group was not the top of this database's chain. Kysely steps down from the tip, so only the newest group can be reversed.`,
+				action: `Run ${pithyCommand("doctor")} to see where each database stands.`
+			});
+			reversed.push(result);
+		}
+	}
+	return reversed;
+}
+/** Forget the group rows of whatever actually came down, whether or not the step then failed. */
+async function forgetReversed(database, results) {
+	const names = (results ?? []).filter((result) => result.direction === "Down" && result.status === "Success").map((result) => result.migrationName);
+	await forgetMigrationGroups(database, names);
+}
+/**
 * Fully reset one database's schema: every applied migration's `down` runs, in one pass, in reverse
 * chronological order — Kysely's `NO_MIGRATIONS` target, not just the latest — then every migration's
 * `up` reapplies from empty. The seam behind `pithy seed --redo`'s destructive rebuild: because the
@@ -110,6 +203,16 @@ async function rollbackMigration(database, provider, target, consent) {
 * skip-if-exists) simply work afterward — there is no per-row identity problem to solve. An empty
 * ledger rolls back nothing; an empty provider reapplies nothing. Refused, before the first `down`, while a
 * retained table here holds rows the caller has not counted in `consent` (#588).
+*
+* **It leaves the group bookkeeping exactly as it was (#694).** The table is not a migration, so the `down`
+* pass cannot remove it, and rewriting the rows would restamp somebody's release as having happened during
+* a `seed --redo`. Every group row still describes a migration this reset reapplied.
+*
+* **What it does not do is record a group for the rest.** A reset reapplies everything *declared*, which
+* includes migrations that were pending when it started, and those come back applied under no group — this
+* takes no group and invents none. Such a migration sits over the groups below it, so a `--rollback
+* --group` of one of them is refused by name (`./groups`, `readGroupPosition`) rather than reversing a
+* migration nobody recorded.
 */
 async function resetMigrations(database, provider, target, consent) {
 	const runner = migrator(database, provider, target, consent);
@@ -120,14 +223,12 @@ async function resetMigrations(database, provider, target, consent) {
 	return [...downResults, ...upResults];
 }
 /**
-* The applied migration names recorded in the ledger — empty when the ledger table doesn't exist yet.
-* Existence is checked against `sqlite_master` (a plain select D1 permits) rather than by catching the
-* read's error, so a genuine read failure surfaces instead of being silently treated as "none applied".
+* The applied migration names recorded in the ledger — empty when the ledger table doesn't exist yet. The
+* set half of `appliedMigrationChain`, which is the one read of the ledger: order matters to a group
+* rollback and not at all to a membership test, and two reads of one table would drift.
 */
 async function appliedMigrationNames(db) {
-	if ((await sql`select name from sqlite_master where type = 'table' and name = ${"pithy_migrations"}`.execute(db)).rows.length === 0) return /* @__PURE__ */ new Set();
-	const { rows } = await sql`select name from ${sql.table(MIGRATION_TABLE)}`.execute(db);
-	return new Set(rows.map((row) => row.name));
+	return new Set(await appliedMigrationChain(db));
 }
 /**
 * Surgically drop **one capability's** migrations: run each of `drop.reverse`'s `down` functions in
@@ -160,6 +261,7 @@ async function dropMigrations(database, drop, target, consent) {
 		try {
 			await down(db);
 			await sql`delete from ${sql.table(MIGRATION_TABLE)} where name = ${name}`.execute(db);
+			await forgetMigrationGroups(database, [name]);
 			results.push({
 				migrationName: name,
 				direction: "Down",
@@ -171,7 +273,7 @@ async function dropMigrations(database, drop, target, consent) {
 			throw new InternalError({
 				message: `Couldn't drop "${name}"${on(target)}. ${reasonOf(error)}`,
 				detail: `${where(target)}${dropped.length ? ` Dropped before the failure: ${dropped.join(", ")}.` : ""}`,
-				action: "Fix the migration's down, or drop its table by hand. Run pithy remove --drop again."
+				action: "Fix the migration's down, or drop its table by hand. Then run this again."
 			}, { cause: error });
 		}
 	}
@@ -182,24 +284,33 @@ const VOICE = {
 	run: {
 		failed: (key) => `Couldn't apply "${key}"`,
 		fallback: "The migration run failed",
-		action: "Fix the migration. Run pithy migrate again."
+		action: "Fix the migration, then run this again."
 	},
 	rollback: {
 		failed: (key) => `Couldn't roll back "${key}"`,
 		fallback: "The rollback failed",
-		action: "Fix the migration's down. Run pithy doctor to see where each database stands."
+		action: `Fix the migration's down. Run ${pithyCommand("doctor")} to see where each database stands.`
 	},
 	resetDown: {
 		failed: (key) => `Couldn't roll back "${key}" during reset`,
 		fallback: "The schema reset failed while rolling back",
-		action: "Fix the migration. Run pithy seed --redo again."
+		action: "Fix the migration, then run this again."
 	},
 	resetUp: {
 		failed: (key) => `Couldn't reapply "${key}" during reset`,
 		fallback: "The schema reset failed while reapplying",
-		action: "Fix the migration. Run pithy seed --redo again."
+		action: "Fix the migration, then run this again."
 	}
 };
+/**
+* What sits over a buried group, groups and ungrouped migrations alike, newest first.
+*
+* An ungrouped migration is named with its state, because the two are different problems: another group is
+* something to reverse first, while a migration no group claims cannot be reversed by group at all.
+*/
+function overIt(above, ungrouped) {
+	return [...above, ...ungrouped.map((name) => `${name} (ungrouped)`)].join(", ");
+}
 /** ` on DB`, or nothing at all — every problem line here ends with this and then a period. */
 function on(target) {
 	return target ? ` on ${target.binding}` : "";
@@ -243,4 +354,4 @@ function settle(verb, error, results, target) {
 	return results ?? [];
 }
 //#endregion
-export { dropMigrations, readMigrationLedger, resetMigrations, rollbackMigration, runMigrations };
+export { dropMigrations, readMigrationLedger, resetMigrations, reverseMigrationGroup, rollbackMigration, runMigrations };

package/dist/migrations/state.d.ts

@@ -0,0 +1,60 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import type { D1Database } from "@cloudflare/workers-types";
+import type { MigrationProvider } from "kysely/migration";
+/**
+ * **Where one database stands, read in one place (#729).**
+ *
+ * The control-plane seam answers `GET {basePath}/migrations` from this: what is applied, what this build
+ * declares and the database lacks, what the database holds and this build no longer declares, and which
+ * run put it there. Each half already had a reader — {@link readMigrationLedger} for both directions,
+ * {@link readMigrationGroups} and {@link readGroupPosition} for the group (#694) — and this composes them
+ * rather than reading either table a second way.
+ *
+ * Read-only. It applies nothing, creates nothing, and reverses nothing: a screen somebody opened to *ask*
+ * must not be the thing that changes the schema.
+ */
+/** Whether the last group can still be taken back by name — {@link readGroupPosition}, minus `absent`. */
+export type MigrationGroupStanding = {
+    /** The group's migrations are the contiguous tip of this ledger. The CLI's rollback has refusals of its own. */
+    state: "top";
+} | {
+    /** Something sits over the group or inside it, so reversing it by name is refused. */
+    state: "buried";
+    /** The groups in the way, newest first. */
+    above: string[];
+    /** The migrations in the way that no group claims, newest first. */
+    ungrouped: string[];
+};
+/** The newest group with anything still applied here, and whether it is still reversible. */
+export interface MigrationLastGroup {
+    /** The group's value — what `--rollback --group` takes. */
+    group: string;
+    /** When it last applied something here. */
+    appliedAt: Date;
+    /** What it applied here and is still applied, in application order. */
+    migrations: string[];
+    /** Whether it is the tip of the chain, or what is in its way. */
+    position: MigrationGroupStanding;
+}
+/** One database's migration state. */
+export interface MigrationState {
+    /** Every applied migration, in the order the ledger applied them. */
+    applied: string[];
+    /** Declared and not yet applied, in the order they would run. */
+    pending: string[];
+    /** Applied and not declared by this build, sorted. Kysely refuses the whole chain on any one of these. */
+    undeclared: string[];
+    /** The newest group with anything applied here, or null when nothing applied here was ever grouped. */
+    lastGroup: MigrationLastGroup | null;
+}
+/**
+ * Read one database's migration state against the provider this build composes for it.
+ *
+ * **The last group is the newest one with something still applied.** Group rows are forgotten as their
+ * migrations come down, so this is ordinarily the newest group recorded. A group whose rows outlived their
+ * ledger rows reads as `absent` and is passed over: naming it as where the environment stands would name a
+ * release that is no longer in the database.
+ */
+export declare function readMigrationState(database: D1Database, provider: MigrationProvider): Promise<MigrationState>;
+//# sourceMappingURL=state.d.ts.map

package/dist/migrations/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/migrations/state.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAK1D;;;;;;;;;;;GAWG;AAEH,0GAA0G;AAC1G,MAAM,MAAM,sBAAsB,GAC9B;IACE,gHAAgH;IAChH,KAAK,EAAE,KAAK,CAAC;CACd,GACD;IACE,sFAAsF;IACtF,KAAK,EAAE,QAAQ,CAAC;IAChB,2CAA2C;IAC3C,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,oEAAoE;IACpE,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEN,6FAA6F;AAC7F,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,KAAK,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,SAAS,EAAE,IAAI,CAAC;IAChB,uEAAuE;IACvE,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,iEAAiE;IACjE,QAAQ,EAAE,sBAAsB,CAAC;CAClC;AAED,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,iEAAiE;IACjE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,0GAA0G;IAC1G,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,uGAAuG;IACvG,SAAS,EAAE,kBAAkB,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,cAAc,CAAC,CAInH"}

package/dist/migrations/state.js

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: 2026 Pithy
+// SPDX-License-Identifier: MIT
+import { appliedMigrationChain, migrationKysely } from "./bookkeeping.js";
+import { readGroupPosition, readMigrationGroups } from "./groups.js";
+import { readMigrationLedger } from "./runner.js";
+//#region src/migrations/state.ts
+/**
+* Read one database's migration state against the provider this build composes for it.
+*
+* **The last group is the newest one with something still applied.** Group rows are forgotten as their
+* migrations come down, so this is ordinarily the newest group recorded. A group whose rows outlived their
+* ledger rows reads as `absent` and is passed over: naming it as where the environment stands would name a
+* release that is no longer in the database.
+*/
+async function readMigrationState(database, provider) {
+	const { pending, undeclared } = await readMigrationLedger(database, provider);
+	const applied = await appliedMigrationChain(migrationKysely(database));
+	return {
+		applied,
+		pending,
+		undeclared,
+		lastGroup: await lastGroupOf(database, applied)
+	};
+}
+/** Walk the groups newest first and stop at the first one this database still holds any of. */
+async function lastGroupOf(database, applied) {
+	const held = new Set(applied);
+	const groups = await readMigrationGroups(database);
+	for (const group of [...groups].reverse()) {
+		const position = await readGroupPosition(database, group.group);
+		if (position.state === "absent") continue;
+		return {
+			group: group.group,
+			appliedAt: group.appliedAt,
+			migrations: group.migrations.filter((name) => held.has(name)),
+			position: position.state === "top" ? { state: "top" } : {
+				state: "buried",
+				above: position.above,
+				ungrouped: position.ungrouped
+			}
+		};
+	}
+	return null;
+}
+//#endregion
+export { readMigrationState };

package/dist/naming/domains.d.ts

@@ -24,6 +24,23 @@ import { type AmbientEnv } from "../env/ambient";
  * them rather than a side effect of a parser version.
  */
 export declare function isPublicHostname(hostname: string): boolean;
+/**
+ * Why a string is not a hostname a Worker can answer on — the reason, not a boolean.
+ *
+ * **It exists so a refusal can say which rule it broke.** {@link isPublicHostname} is the answer when the
+ * caller only needs yes or no; `WorkerDomain` needs the reason, because the three are not interchangeable
+ * to the adopter reading the message. A name over the limit is a typo. A name with a scheme on it is a
+ * misunderstanding. An internationalized name is neither — it is a thing this kit cannot do, for a reason
+ * that is not this kit's, and a message about bare hostnames would send that adopter looking for a typo
+ * they do not have (#665).
+ *
+ * Ordered by how specific the answer is. The length check is first because a name that long is over the
+ * limit whatever else is wrong with it, and `punycode` last because it is only reachable for a string that
+ * is otherwise a well-formed hostname.
+ */
+export declare function publicHostnameProblem(hostname: string): HostnameProblem | null;
+/** The three ways a string fails {@link publicHostnameProblem}, each with its own sentence to say. */
+export type HostnameProblem = "too-long" | "shape" | "punycode";
 /** The environments a domain may be declared for — every managed one, never `dev`. */
 export declare const DOMAIN_ENVIRONMENTS: ("prod" | "staging")[];
 /** One environment's public address for one Worker. */

package/dist/naming/domains.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"domains.d.ts","sourceRoot":"","sources":["../../src/naming/domains.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,gBAAgB,CAAC;AAgD7D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,wBAA8D,CAAC;AAE/F,uDAAuD;AACvD,eAAO,MAAM,YAAY;;;iBA+BrB,CAAC;AACL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;iBAOvB,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI,CAKlH;AAED,gHAAgH;AAChH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAEvD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,qBAAqB,CAAC;AAE/C,yFAAyF;AACzF,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAetG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAC3B,cAAc,CAShB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,GAAG,GAAE,UAAyB,GAC7B,MAAM,CAER"}
+{"version":3,"file":"domains.d.ts","sourceRoot":"","sources":["../../src/naming/domains.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,KAAK,UAAU,EAAc,MAAM,gBAAgB,CAAC;AAgD7D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE1D;AAKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAK9E;AAED,sGAAsG;AACtG,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC;AAyChE,sFAAsF;AACtF,eAAO,MAAM,mBAAmB,wBAA8D,CAAC;AAE/F,uDAAuD;AACvD,eAAO,MAAM,YAAY;;;iBAwBrB,CAAC;AACL,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;iBAOvB,CAAC;AACJ,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,SAAS,EAAE,WAAW,EAAE,MAAM,GAAG,SAAS,GAAG,YAAY,GAAG,IAAI,CAKlH;AAED,gHAAgH;AAChH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAEvD;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,qBAAqB,CAAC;AAE/C,yFAAyF;AACzF,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAetG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,GAC3B,cAAc,CAShB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,SAAS,CACvB,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,OAAO,EAAE,aAAa,GAAG,SAAS,EAClC,GAAG,GAAE,UAAyB,GAC7B,MAAM,CAER"}

package/dist/naming/domains.js

@@ -68,14 +68,72 @@ const PUNYCODE_LABEL = /(^|\.)xn--/;
 * them rather than a side effect of a parser version.
 */
 function isPublicHostname(hostname) {
-	return hostname.length <= 253 && HOSTNAME_PATTERN.test(hostname) && !PUNYCODE_LABEL.test(hostname);
+	return publicHostnameProblem(hostname) === null;
+}
+/** The DNS limit on a whole name, and the only length any caller measures. */
+const MAX_HOSTNAME_LENGTH = 253;
+/**
+* Why a string is not a hostname a Worker can answer on — the reason, not a boolean.
+*
+* **It exists so a refusal can say which rule it broke.** {@link isPublicHostname} is the answer when the
+* caller only needs yes or no; `WorkerDomain` needs the reason, because the three are not interchangeable
+* to the adopter reading the message. A name over the limit is a typo. A name with a scheme on it is a
+* misunderstanding. An internationalized name is neither — it is a thing this kit cannot do, for a reason
+* that is not this kit's, and a message about bare hostnames would send that adopter looking for a typo
+* they do not have (#665).
+*
+* Ordered by how specific the answer is. The length check is first because a name that long is over the
+* limit whatever else is wrong with it, and `punycode` last because it is only reachable for a string that
+* is otherwise a well-formed hostname.
+*/
+function publicHostnameProblem(hostname) {
+	if (hostname.length > MAX_HOSTNAME_LENGTH) return "too-long";
+	if (!HOSTNAME_PATTERN.test(hostname)) return "shape";
+	if (PUNYCODE_LABEL.test(hostname)) return "punycode";
+	return null;
+}
+/**
+* What an adopter is told, per reason, for a hostname this kit refuses.
+*
+* `shape` is the caller's to say, because what a bare hostname is differs between a `pattern` and a
+* `zone` and each already had a sentence worth keeping. The other two are the same wherever they are hit.
+*
+* **The internationalized-domain sentence names Cloudflare**, and that is deliberate: the limit is not
+* ours. `pithy-sh/pithy#691` tested it against a real zone — adding `tëst.pithy-sh.com` as a Worker
+* Custom Domain returns *Internationalized Domain Names not supported* — so the kit refuses what the
+* platform will not route rather than inventing a rule of its own. `docs/ACCEPTED-LIMITS.md` carries the
+* evidence and the condition that would lift it.
+*/
+const HOSTNAME_PROBLEM_MESSAGES = {
+	"too-long": `A hostname is at most ${MAX_HOSTNAME_LENGTH} characters — the DNS limit on a whole name.`,
+	punycode: "Internationalized domains are not supported: Cloudflare Workers will not route one, so a Worker could never answer on it. Use an ASCII hostname."
+};
+/**
+* One `pattern` or `zone` field, held to the one hostname rule.
+*
+* **Through {@link publicHostnameProblem}, never `HOSTNAME_PATTERN` directly.** A configured domain was
+* the third caller of that rule and the only one that did not go through the function — it handed the
+* pattern to `.regex()`, so it took a punycode A-label and a 267-character name that `pithy seed --host`
+* refused for the same string. Two answers to one question, forty lines apart (#665). A rule added to the
+* function now reaches a configured domain without anyone remembering to.
+*/
+function hostnameField(shapeMessage) {
+	return z.string().check((ctx) => {
+		const problem = publicHostnameProblem(ctx.value);
+		if (problem === null) return;
+		ctx.issues.push({
+			code: "custom",
+			input: ctx.value,
+			message: problem === "shape" ? shapeMessage : HOSTNAME_PROBLEM_MESSAGES[problem]
+		});
+	});
 }
 /** The environments a domain may be declared for — every managed one, never `dev`. */
 const DOMAIN_ENVIRONMENTS = ENVIRONMENTS.filter((environment) => environment !== "dev");
 /** One environment's public address for one Worker. */
 const WorkerDomain = z.object({
-	pattern: z.string().regex(HOSTNAME_PATTERN, "A domain is a bare hostname — no scheme, no path, no port (e.g. `api.example.com`, not `https://api.example.com/`).").describe("The hostname this Worker answers on in this environment, e.g. `api.example.com`. Written into `wrangler.jsonc` as a `routes` entry with `custom_domain: true`, and into `vars.BASE_URL` as `https://<pattern>`. A bare hostname rather than a URL, because that is what wrangler's route matcher takes — a scheme here would be silently wrong."),
-	zone: z.string().regex(HOSTNAME_PATTERN, "A zone is the registrable domain on your Cloudflare account, e.g. `example.com`.").describe("The Cloudflare zone `pattern` sits under — the registrable domain as it appears on your account, e.g. `example.com` for `api.example.com`. Cloudflare needs it to attach a custom domain, and it is not always derivable from the hostname: a zone can be a subdomain, and a public-suffix guess would be wrong for exactly the adopters who are hardest to debug.")
+	pattern: hostnameField("A domain is a bare hostname — no scheme, no path, no port (e.g. `api.example.com`, not `https://api.example.com/`).").describe("The hostname this Worker answers on in this environment, e.g. `api.example.com`. Written into `wrangler.jsonc` as a `routes` entry with `custom_domain: true`, and into `vars.BASE_URL` as `https://<pattern>`. A bare hostname rather than a URL, because that is what wrangler's route matcher takes — a scheme here would be silently wrong."),
+	zone: hostnameField("A zone is the registrable domain on your Cloudflare account, e.g. `example.com`.").describe("The Cloudflare zone `pattern` sits under — the registrable domain as it appears on your account, e.g. `example.com` for `api.example.com`. Cloudflare needs it to attach a custom domain, and it is not always derivable from the hostname: a zone can be a subdomain, and a public-suffix guess would be wrong for exactly the adopters who are hardest to debug.")
 }).describe("Where one Worker answers in one environment: the hostname, and the Cloudflare zone it sits under.").check((ctx) => {
 	const { pattern, zone } = ctx.value;
 	if (pattern !== zone && !pattern.endsWith(`.${zone}`)) ctx.issues.push({
@@ -234,4 +292,4 @@ function originFor(environment, domains, env = ambientEnv()) {
 	return resolveOrigin(environment, domains, env[BASE_URL_VAR]).origin;
 }
 //#endregion
-export { DOMAIN_ENVIRONMENTS, LOCAL_ORIGIN, WorkerDomain, WorkerDomains, baseUrlFor, domainFor, featureOrigin, isPublicHostname, originFor, resolveOrigin };
+export { DOMAIN_ENVIRONMENTS, LOCAL_ORIGIN, WorkerDomain, WorkerDomains, baseUrlFor, domainFor, featureOrigin, isPublicHostname, originFor, publicHostnameProblem, resolveOrigin };

package/dist/naming/environment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/naming/environment.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,YAAY,YAAI,KAAK,EAAE,SAAS,EAAE,MAAM,CAAU,CAAC;AAEhE,wGAAwG;AACxG,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAE7C;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD;AAKD,kHAAkH;AAClH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAgBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,QAAqE,CAAC;AAEvG;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIxD;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmCzD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,YAAI,SAAS,EAAE,MAAM,CAAU,CAAC;AAEjE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,yBA2D9B,CAAC;AAEJ,sGAAsG;AACtG,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/naming/environment.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB;;;;;;;;GAQG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,YAAY,YAAI,KAAK,EAAE,SAAS,EAAE,MAAM,CAAU,CAAC;AAEhE,wGAAwG;AACxG,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,WAAW,CAAC;AAErC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAE7C;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD;AAKD,kHAAkH;AAClH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAExD;AAgBD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,QAAqE,CAAC;AAEvG;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAIxD;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmCzD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,YAAI,SAAS,EAAE,MAAM,CAAU,CAAC;AAEjE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,QAAQ,CAAC;AAEvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,yBA2D9B,CAAC;AAEJ,sGAAsG;AACtG,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/naming/environment.js

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 import { PithyError, ValidationError } from "../error/pithyError.js";
+import { commandName } from "../cli/command.js";
 import { NAME_SEGMENT } from "./segment.js";
 import { z } from "zod";
 //#region src/naming/environment.ts
@@ -129,7 +130,7 @@ function assertValidEnvironment(name) {
 	if (startsWithFeatureMarker(name)) throw new ValidationError({
 		message: `"${name}" starts the way a feature's name does.`,
 		action: "Start the environment with something other than f and a number.",
-		detail: `A feature takes the environment's slot with f<issue>, so <project>-${name}-<worker> can be a feature's Worker name exactly, and \`pithy feature destroy\` deletes that Worker.`
+		detail: `A feature takes the environment's slot with f<issue>, so <project>-${name}-<worker> can be a feature's Worker name exactly, and \`${commandName("feature destroy")}\` deletes that Worker.`
 	});
 	if (name.length > MAX_ENVIRONMENT_NAME && NAME_SEGMENT.test(name)) throw new ValidationError({
 		message: `"${name}" is ${name.length} characters. An environment stops at ${MAX_ENVIRONMENT_NAME}.`,

package/dist/naming/feature.d.ts

@@ -27,10 +27,19 @@
  * It lives in `core`, beside the rest of the naming rule, so the CLI and the facade compose one
  * implementation rather than two that drift.
  */
-/** A Cloudflare resource kind a feature can provision. All two characters — `MAX_FEATURE_KIND` in `./limits`. */
-export type FeatureResourceKind = "d1" | "kv" | "r2";
+/** A Cloudflare resource kind Pithy names and creates — in a feature, and in every declared environment. */
+export type FeatureResourceKind = "d1" | "kv" | "r2" | "queue";
 /** Every feature resource kind, for tests and for callers that enumerate. */
 export declare const FEATURE_RESOURCE_KINDS: readonly FeatureResourceKind[];
+/**
+ * **The segment each kind ends a feature resource's name with — never more than `MAX_FEATURE_KIND` (#662).**
+ *
+ * `d1`, `kv` and `r2` spell themselves. A queue is `q`, and that is load-bearing: `MAX_FEATURE_KIND` is a term in
+ * `FEATURE_DERIVED_PROJECT_NAME`, so spelling it `queue` would take the project budget from 26 to 23 — and a
+ * project name is stable forever once anything is provisioned, so a smaller budget orphans every resource of a
+ * project already named against the old one. `feature.test.ts` fails on a segment longer than the budget.
+ */
+export declare const FEATURE_KIND_SEGMENT: Readonly<Record<FeatureResourceKind, string>>;
 /** The identity of a feature — everything a feature name is derived from. */
 export interface FeatureIdentity {
     /** The project name, from the root `pithy.config.ts` (e.g. `acme`). */
@@ -126,10 +135,11 @@ export declare function maxFeatureSlug(parts: FeatureHead, shapes: readonly Feat
  */
 export declare function assertFeatureSlugFits(identity: FeatureIdentity, shapes: readonly FeatureNameShape[]): void;
 /**
- * The full Cloudflare resource name for a feature's binding — `<project>-f<issue>-<slug>--<binding>-<kind>`.
+ * The full Cloudflare resource name for a feature's binding — `<project>-f<issue>-<slug>--<binding>-<kind>`, the
+ * kind spelled by {@link FEATURE_KIND_SEGMENT}.
  *
- * Held to **R2's 63**, the strictest of the three kinds a feature provisions, so one shape is legal for
- * all of them: lowercase, hyphenated, alphanumeric at both ends. A D1 or KV name could be longer, but a
+ * Held to **R2's 63**, the strictest of the kinds a feature provisions and a queue's number too, so one shape is
+ * legal for all of them: lowercase, hyphenated, alphanumeric at both ends. A D1 or KV name could be longer, but a
  * feature that provisions a bucket and a database wants them recognizably the same name.
  */
 export declare function featureResourceName(identity: FeatureIdentity, binding: string, kind: FeatureResourceKind): string;
@@ -168,6 +178,18 @@ export declare function featureSecretEntryName(identity: FeatureIdentity, secret
  * and picks.
  */
 export declare function featureWorkerName(identity: FeatureIdentity, app: string): string;
+/** The `<thing>` a feature's Artifacts namespace ends with, after {@link FEATURE_TAIL_SEPARATOR} (#673). */
+export declare const FEATURE_ARTIFACTS_THING = "artifacts";
+/**
+ * A feature's **Artifacts namespace** — `<project>-f<issue>-<slug>--artifacts` (#673).
+ *
+ * A declared environment's namespace is `<project>-<env>` and has no `<thing>`. A feature's needs one, because the
+ * separator and what follows it are what make a name a feature name: {@link isFeatureOwnedName} reads this one back
+ * as this feature's, so `pithy feature destroy` reaps the repos of exactly this branch and of no sibling. Held to the
+ * namespace's 63, the same number the rest of a feature's names are derived against, and `artifacts` is shorter than
+ * the shortest binding tail, so it moves no slug budget.
+ */
+export declare function featureArtifactsNamespace(identity: FeatureIdentity): string;
 /**
  * The deployed name of one of a feature's **Workflows** — `<project>-f<issue>-<slug>--<capability>-<job>` (#643).
  *

package/dist/naming/feature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../src/naming/feature.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../src/naming/feature.ts"],"names":[],"mappings":"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"}