@pithy-sh/core 0.6.1 → 0.7.0

package/dist/migrations/runner.d.ts

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: MIT
 import type { D1Database } from "@cloudflare/workers-types";
 import { type MigrationProvider, type MigrationResult } from "kysely/migration";
+import { RetainedBudget } from "./retained";
 /**
  * Which database a run is reporting on — what a failure names.
  *
@@ -16,6 +17,19 @@ export interface MigrationTarget {
     /** The database name: a capability's `databases` key. Throw-site context, not the adopter's handle. */
     database: string;
 }
+/**
+ * What a caller that reverses migrations says about retained rows (#588) — see `./retained`.
+ *
+ * Optional, and absent is the safe answer: a caller that says nothing has counted nothing, so any `down`
+ * against a database holding retained rows is refused.
+ */
+export interface RetainedConsent {
+    /**
+     * The retained rows the caller agreed to destroy. Pass one budget to every database in a run, so one
+     * agreement is spent once; a caller reversing a single database builds its own. Absent means none.
+     */
+    budget?: RetainedBudget;
+}
 /** Run every pending migration to latest. An empty provider resolves to `[]`. */
 export declare function runMigrations(database: D1Database, provider: MigrationProvider, target?: MigrationTarget): Promise<MigrationResult[]>;
 /** One database's ledger beside the declaration it is supposed to match — see {@link readMigrationLedger}. */
@@ -46,24 +60,47 @@ export interface MigrationLedger {
  * warn-only "schema is behind" check, and the refusal `pithy migrate` raises before it writes.
  */
 export declare function readMigrationLedger(database: D1Database, provider: MigrationProvider): Promise<MigrationLedger>;
-/** Step the latest applied migration back — one step, the `pithy migrate --rollback` seam. */
-export declare function rollbackMigration(database: D1Database, provider: MigrationProvider, target?: MigrationTarget): Promise<MigrationResult[]>;
+/**
+ * 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).
+ */
+export declare function rollbackMigration(database: D1Database, provider: MigrationProvider, target?: MigrationTarget, consent?: RetainedConsent): Promise<MigrationResult[]>;
 /**
  * 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
  * schema comes back empty, the ordinary non-destructive seed writes (`INSERT OR IGNORE`, KV
  * 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.
+ * 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).
+ */
+export declare function resetMigrations(database: D1Database, provider: MigrationProvider, target?: MigrationTarget, consent?: RetainedConsent): Promise<MigrationResult[]>;
+/**
+ * What a drop reverses, and the database it reverses it in.
+ *
+ * Two providers because they answer two questions. `reverse` is the part being removed — one capability's
+ * migrations. `database` is every migration composed into that D1, and it is what the retained guard counts:
+ * a table is retained in a *database*, and the capability being dropped is the one least likely to declare
+ * the vault it shares a database with (#588). Handed only the part, the guard counted what the part declared
+ * — nothing — while the vault beside it held rows.
  */
-export declare function resetMigrations(database: D1Database, provider: MigrationProvider, target?: MigrationTarget): Promise<MigrationResult[]>;
+export interface DropSelection {
+    /** Every migration composed into this database — the set whose retained declarations are counted. */
+    database: MigrationProvider;
+    /** The migrations to reverse: a part of `database`, by composed name. */
+    reverse: MigrationProvider;
+}
 /**
- * Surgically drop **one capability's** migrations: run each of the provider's `down` functions in
+ * Surgically drop **one capability's** migrations: run each of `drop.reverse`'s `down` functions in
  * reverse order and delete only those ledger rows, leaving every other capability's tables and
  * bookkeeping untouched. The seam behind `pithy remove --drop`. Kysely's stepwise `Migrator` refuses a
  * provider that doesn't span the whole ledger (it reads a foreign row as corrupt state), so a
  * per-capability drop can't go through it — this reverses the capability's own migrations directly.
- * Only migrations recorded in the ledger are reversed; an absent ledger drops nothing.
+ * Only migrations recorded in the ledger are reversed; an absent ledger drops nothing. Refused, before the
+ * first `down`, while a retained table **anywhere in `drop.database`** holds rows the caller has not counted
+ * in `consent` (#588). A name `drop.reverse` carries that `drop.database` does not is an internal fault: the
+ * guard would not have counted the database the `down` runs in.
  */
-export declare function dropMigrations(database: D1Database, provider: MigrationProvider, target?: MigrationTarget): Promise<MigrationResult[]>;
+export declare function dropMigrations(database: D1Database, drop: DropSelection, target?: MigrationTarget, consent?: RetainedConsent): Promise<MigrationResult[]>;
 //# sourceMappingURL=runner.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/migrations/runner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAA2B,MAAM,kBAAkB,CAAC;AA0DzG;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAC;IAChB,uGAAuG;IACvG,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,iFAAiF;AACjF,wBAAsB,aAAa,CACjC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,EAAE,CAAC,CAG5B;AAED,8GAA8G;AAC9G,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAOrH;AAED,8FAA8F;AAC9F,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,EAAE,CAAC,CAG5B;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,EAAE,CAAC,CAO5B;AAgBD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,EAAE,CAAC,CA+B5B"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/migrations/runner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,eAAe,EAA2B,MAAM,kBAAkB,CAAC;AAKzG,OAAO,EAAgC,cAAc,EAAE,MAAM,YAAY,CAAC;AA4D1E;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,wFAAwF;IACxF,OAAO,EAAE,MAAM,CAAC;IAChB,uGAAuG;IACvG,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAC;CACzB;AAUD,iFAAiF;AACjF,wBAAsB,aAAa,CACjC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,EAAE,CAAC,CAG5B;AAED,8GAA8G;AAC9G,MAAM,WAAW,eAAe;IAC9B,iEAAiE;IACjE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC,CAOrH;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,CAAC,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,eAAe,EAAE,CAAC,CAG5B;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,UAAU,EACpB,QAAQ,EAAE,iBAAiB,EAC3B,MAAM,CAAC,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,eAAe,EAAE,CAAC,CAO5B;AAgBD;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC5B,qGAAqG;IACrG,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,yEAAyE;IACzE,OAAO,EAAE,iBAAiB,CAAC;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,UAAU,EACpB,IAAI,EAAE,aAAa,EACnB,MAAM,CAAC,EAAE,eAAe,EACxB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,eAAe,EAAE,CAAC,CA4C5B"}

package/dist/migrations/runner.js

@@ -4,6 +4,7 @@ import { InternalError } from "../error/pithyError.js";
 import { causeMessage } from "../error/cause.js";
 import { MIGRATION_LOCK_TABLE, MIGRATION_TABLE, migrationKysely } from "./bookkeeping.js";
 import { batchedProvider } from "./batch.js";
+import { RetainedBudget, guardRetained, isDownRefusal } from "./retained.js";
 import { sql } from "kysely";
 import { Migrator, NO_MIGRATIONS } from "kysely/migration";
 //#region src/migrations/runner.ts
@@ -46,18 +47,25 @@ import { Migrator, NO_MIGRATIONS } from "kysely/migration";
 * capability arrives with its whole set. Refusing the add with an actionable error was the
 * alternative; it explains the corner instead of removing it.
 */
-function migrator(database, provider) {
+function migrator(database, provider, target, consent) {
 	return new Migrator({
 		db: migrationKysely(database),
-		provider: batchedProvider(provider, database),
+		provider: batchedProvider(guardRetained(provider, database, guardOptions(target, consent)), database),
 		migrationTableName: MIGRATION_TABLE,
 		migrationLockTableName: MIGRATION_LOCK_TABLE,
 		allowUnorderedMigrations: true
 	});
 }
+/** The guard's options: the binding its refusal names, and the budget the caller agreed to. */
+function guardOptions(target, consent) {
+	return {
+		binding: target?.binding ?? "this database",
+		budget: consent?.budget ?? new RetainedBudget(void 0)
+	};
+}
 /** Run every pending migration to latest. An empty provider resolves to `[]`. */
 async function runMigrations(database, provider, target) {
-	const { error, results } = await migrator(database, provider).migrateToLatest();
+	const { error, results } = await migrator(database, provider, target, void 0).migrateToLatest();
 	return settle("run", error, results, target);
 }
 /**
@@ -85,9 +93,13 @@ async function readMigrationLedger(database, provider) {
 		undeclared: [...applied].filter((name) => !declared.includes(name)).sort()
 	};
 }
-/** Step the latest applied migration back — one step, the `pithy migrate --rollback` seam. */
-async function rollbackMigration(database, provider, target) {
-	const { error, results } = await migrator(database, provider).migrateDown();
+/**
+* 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).
+*/
+async function rollbackMigration(database, provider, target, consent) {
+	const { error, results } = await migrator(database, provider, target, consent).migrateDown();
 	return settle("rollback", error, results, target);
 }
 /**
@@ -96,10 +108,11 @@ async function rollbackMigration(database, provider, target) {
 * `up` reapplies from empty. The seam behind `pithy seed --redo`'s destructive rebuild: because the
 * schema comes back empty, the ordinary non-destructive seed writes (`INSERT OR IGNORE`, KV
 * 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.
+* 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).
 */
-async function resetMigrations(database, provider, target) {
-	const runner = migrator(database, provider);
+async function resetMigrations(database, provider, target, consent) {
+	const runner = migrator(database, provider, target, consent);
 	const down = await runner.migrateTo(NO_MIGRATIONS);
 	const downResults = settle("resetDown", down.error, down.results, target);
 	const up = await runner.migrateToLatest();
@@ -117,19 +130,30 @@ async function appliedMigrationNames(db) {
 	return new Set(rows.map((row) => row.name));
 }
 /**
-* Surgically drop **one capability's** migrations: run each of the provider's `down` functions in
+* Surgically drop **one capability's** migrations: run each of `drop.reverse`'s `down` functions in
 * reverse order and delete only those ledger rows, leaving every other capability's tables and
 * bookkeeping untouched. The seam behind `pithy remove --drop`. Kysely's stepwise `Migrator` refuses a
 * provider that doesn't span the whole ledger (it reads a foreign row as corrupt state), so a
 * per-capability drop can't go through it — this reverses the capability's own migrations directly.
-* Only migrations recorded in the ledger are reversed; an absent ledger drops nothing.
+* Only migrations recorded in the ledger are reversed; an absent ledger drops nothing. Refused, before the
+* first `down`, while a retained table **anywhere in `drop.database`** holds rows the caller has not counted
+* in `consent` (#588). A name `drop.reverse` carries that `drop.database` does not is an internal fault: the
+* guard would not have counted the database the `down` runs in.
 */
-async function dropMigrations(database, provider, target) {
+async function dropMigrations(database, drop, target, consent) {
 	const db = migrationKysely(database);
-	const migrations = await batchedProvider(provider, database).getMigrations();
+	const guarded = guardRetained(drop.database, database, guardOptions(target, consent));
+	const migrations = await batchedProvider(guarded, database).getMigrations();
+	const reversing = Object.keys(await drop.reverse.getMigrations());
+	const stray = reversing.filter((name) => !(name in migrations));
+	if (stray.length > 0) throw new InternalError({
+		message: `Couldn't drop ${stray.map((name) => `"${name}"`).join(", ")}${on(target)}. The database's migrations do not carry it.`,
+		detail: `${where(target)} A drop counts retained rows over the database's whole set, so every migration it reverses must be in it.`,
+		action: "Build the drop from the database's composed migrations. Nothing was dropped."
+	});
 	const applied = await appliedMigrationNames(db);
 	const results = [];
-	for (const name of Object.keys(migrations).sort().reverse()) {
+	for (const name of reversing.sort().reverse()) {
 		if (!applied.has(name)) continue;
 		const down = migrations[name]?.down;
 		if (!down) continue;
@@ -142,6 +166,7 @@ async function dropMigrations(database, provider, target) {
 				status: "Success"
 			});
 		} catch (error) {
+			if (isDownRefusal(error)) throw error;
 			const dropped = results.map((result) => `"${result.migrationName}"`);
 			throw new InternalError({
 				message: `Couldn't drop "${name}"${on(target)}. ${reasonOf(error)}`,
@@ -162,7 +187,7 @@ const VOICE = {
 	rollback: {
 		failed: (key) => `Couldn't roll back "${key}"`,
 		fallback: "The rollback failed",
-		action: "Fix the migration. Run pithy migrate --rollback again."
+		action: "Fix the migration's down. Run pithy doctor to see where each database stands."
 	},
 	resetDown: {
 		failed: (key) => `Couldn't roll back "${key}" during reset`,
@@ -203,6 +228,7 @@ function reasonOf(error) {
 }
 function settle(verb, error, results, target) {
 	if (error !== void 0) {
+		if (isDownRefusal(error)) throw error;
 		const voice = VOICE[verb];
 		const failed = results?.find((result) => result.status === "Error");
 		const applied = results?.filter((result) => result.status === "Success").map((result) => result.migrationName);

package/dist/naming/environment.d.ts

@@ -43,6 +43,18 @@ export declare const GLOBAL_SCOPE = "global";
  * that rejects it would be a cycle.
  */
 export declare const FEATURE_ENVIRONMENT = "feature";
+/**
+ * **The segment a feature takes where an environment sits** — `f<issue>`, as in `<project>-f69-demo-db-d1`.
+ *
+ * Defined here, beside the environment rule, because the two share a slot in every composed name and the
+ * environment rule has to refuse this shape: `feature.ts` composes a feature's head with it, and
+ * {@link isValidEnvironment} refuses an environment that starts with one. A marker composed in one module and
+ * recognized in another would be two statements of one shape, and the next person to change one would not
+ * find the other.
+ */
+export declare function featureMarker(issue: string): string;
+/** Is this whole hyphen-delimited segment a feature's marker? `f1` and `f01` are; `f1a` and `feature` are not. */
+export declare function isFeatureMarker(segment: string): boolean;
 /**
  * The longest an environment name may be — **the longest canonical one, `staging`**.
  *

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;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,QAAqE,CAAC;AAEvG;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CA4BzD;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;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"}

package/dist/naming/environment.js

@@ -49,6 +49,37 @@ const GLOBAL_SCOPE = "global";
 */
 const FEATURE_ENVIRONMENT = "feature";
 /**
+* **The segment a feature takes where an environment sits** — `f<issue>`, as in `<project>-f69-demo-db-d1`.
+*
+* Defined here, beside the environment rule, because the two share a slot in every composed name and the
+* environment rule has to refuse this shape: `feature.ts` composes a feature's head with it, and
+* {@link isValidEnvironment} refuses an environment that starts with one. A marker composed in one module and
+* recognized in another would be two statements of one shape, and the next person to change one would not
+* find the other.
+*/
+function featureMarker(issue) {
+	return `f${issue}`;
+}
+/** Every string {@link featureMarker} can compose: an `f` and one or more digits, as a whole segment. */
+const FEATURE_MARKER = /^f[0-9]+$/;
+/** Is this whole hyphen-delimited segment a feature's marker? `f1` and `f01` are; `f1a` and `feature` are not. */
+function isFeatureMarker(segment) {
+	return FEATURE_MARKER.test(segment);
+}
+/**
+* Does this environment start where a feature's name does?
+*
+* **Exactly the environments that can collide with a feature (#587).** A declared environment composes
+* `<project>-<env>-<thing>`, a feature `<project>-f<issue>-<slug>-<thing>`, and a feature Worker's name has no
+* kind suffix to tell the two apart. After the shared `<project>-`, the two strings can only be equal when the
+* environment's first segment is the feature's marker — `f1-demo` meets feature 1-demo's Worker `api`, and `f1`
+* meets it too, through a Worker called `demo-api`. Any other first segment differs from every marker, so no
+* name composed under it can be a feature's. So this is the whole rule, not one case of it.
+*/
+function startsWithFeatureMarker(name) {
+	return isFeatureMarker(name.split("-")[0] ?? "");
+}
+/**
 * The longest an environment name may be — **the longest canonical one, `staging`**.
 *
 * This is a derivation input, not a preference: `WORKFLOW_DERIVED_PROJECT_NAME` and
@@ -72,6 +103,7 @@ const MAX_ENVIRONMENT_NAME = Math.max(...ENVIRONMENTS.map((environment) => envir
 */
 function isValidEnvironment(name) {
 	if (name === "global") return false;
+	if (startsWithFeatureMarker(name)) return false;
 	return name.length <= MAX_ENVIRONMENT_NAME && NAME_SEGMENT.test(name);
 }
 /**
@@ -94,6 +126,11 @@ function assertValidEnvironment(name) {
 		action: `Name the environment one of ${ENVIRONMENTS.join(", ")}.`,
 		detail: `${GLOBAL_SCOPE} occupies the environment slot of a composed name for values shared across every environment.`
 	});
+	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.`
+	});
 	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}.`,
 		action: `Use one of ${ENVIRONMENTS.join(", ")}, or a shorter name.`,
@@ -189,4 +226,4 @@ const DeclaredEnvironments = z.array(z.string().describe("One deployed environme
 	}
 }).describe("Every deployed environment this project has, in the order provisioning walks them — least-production first. Declared once in the root pithy.config.ts, because the set cannot be per-Worker. `dev` is never listed: it is local and always present.");
 //#endregion
-export { DEFAULT_ENVIRONMENTS, DeclaredEnvironments, ENVIRONMENTS, FEATURE_ENVIRONMENT, GLOBAL_SCOPE, LOCAL_ENVIRONMENT, MAX_ENVIRONMENT_NAME, assertValidEnvironment, isValidEnvironment };
+export { DEFAULT_ENVIRONMENTS, DeclaredEnvironments, ENVIRONMENTS, FEATURE_ENVIRONMENT, GLOBAL_SCOPE, LOCAL_ENVIRONMENT, MAX_ENVIRONMENT_NAME, assertValidEnvironment, featureMarker, isFeatureMarker, isValidEnvironment };

package/dist/naming/feature.d.ts

@@ -65,6 +65,12 @@ export declare function featureSecretEntryName(identity: FeatureIdentity, secret
  * floored the slug at one character and never touched the worker segment, so it ran unbounded — 69
  * characters for a worker called `collaboration-realtime-gateway`, 109 for a 70-character one. `apps/<name>`
  * has a charset rule and no length rule, so nothing upstream was going to stop it either.
+ *
+ * **`app` is the `apps/<app>` directory, never the deploy name.** A scaffolded Worker deploys as
+ * `<project>-<app>`, and handing that here composed `<project>-f<issue>-<slug>-<project>-<app>` — the
+ * project twice, spent out of the budget above (#587). This function takes a string and cannot tell the
+ * two apart, so the provisioning path reaches it only through `featureScope`, which is handed both names
+ * and picks.
  */
-export declare function featureWorkerName(identity: FeatureIdentity, worker: string): string;
+export declare function featureWorkerName(identity: FeatureIdentity, app: string): string;
 //# sourceMappingURL=feature.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../src/naming/feature.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AAEH,iHAAiH;AACjH,MAAM,MAAM,mBAAmB,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,EAAE,SAAS,mBAAmB,EAAuB,CAAC;AAEzF,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,6FAA6F;IAC7F,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;CACd;AAkED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAQjH;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAQxF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEnF"}
+{"version":3,"file":"feature.d.ts","sourceRoot":"","sources":["../../src/naming/feature.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;GAgBG;AAEH,iHAAiH;AACjH,MAAM,MAAM,mBAAmB,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAErD,6EAA6E;AAC7E,eAAO,MAAM,sBAAsB,EAAE,SAAS,mBAAmB,EAAuB,CAAC;AAEzF,6EAA6E;AAC7E,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,6FAA6F;IAC7F,KAAK,EAAE,MAAM,CAAC;IACd,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;CACd;AAkED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAQjH;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAQxF;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhF"}

package/dist/naming/feature.js

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: 2026 Pithy
 // SPDX-License-Identifier: MIT
 import { ValidationError } from "../error/pithyError.js";
+import { featureMarker } from "./environment.js";
 import { NAMESPACE_LIMITS } from "./limits.js";
 import { assertValidProjectName, fitSegment, kebab } from "./resource.js";
 //#region src/naming/feature.ts
@@ -32,7 +33,7 @@ function assertIssue(issue) {
 function head(identity) {
 	assertValidProjectName(identity.project);
 	assertIssue(identity.issue);
-	return `${kebab(identity.project)}-f${identity.issue}`;
+	return `${kebab(identity.project)}-${featureMarker(identity.issue)}`;
 }
 /**
 * Fit `<head>-<slug>-<tail><fixed>` into `budget`, truncating the slug first and the tail only if the
@@ -100,9 +101,15 @@ function featureSecretEntryName(identity, secret) {
 * floored the slug at one character and never touched the worker segment, so it ran unbounded — 69
 * characters for a worker called `collaboration-realtime-gateway`, 109 for a 70-character one. `apps/<name>`
 * has a charset rule and no length rule, so nothing upstream was going to stop it either.
+*
+* **`app` is the `apps/<app>` directory, never the deploy name.** A scaffolded Worker deploys as
+* `<project>-<app>`, and handing that here composed `<project>-f<issue>-<slug>-<project>-<app>` — the
+* project twice, spent out of the budget above (#587). This function takes a string and cannot tell the
+* two apart, so the provisioning path reaches it only through `featureScope`, which is handed both names
+* and picks.
 */
-function featureWorkerName(identity, worker) {
-	return composeFeatureName(head(identity), kebab(identity.slug), kebab(worker), "", NAMESPACE_LIMITS.worker.maxLength);
+function featureWorkerName(identity, app) {
+	return composeFeatureName(head(identity), kebab(identity.slug), kebab(app), "", NAMESPACE_LIMITS.worker.maxLength);
 }
 //#endregion
 export { FEATURE_RESOURCE_KINDS, featureResourceName, featureSecretEntryName, featureWorkerName };

package/dist/naming/provisionScope.d.ts

@@ -74,6 +74,27 @@ export interface BindingNaming {
 export interface ProjectGlobalNaming extends BindingNaming {
     readonly scope: "global";
 }
+/**
+ * The two names one Worker answers to before a scope has named it — **and why a scope is handed both.**
+ *
+ * `pithy init replay --worker board` writes `apps/board/wrangler.jsonc` with `"name": "replay-board"`.
+ * So the Worker's directory says `board` and its deploy name says `replay-board`, and the two scopes need
+ * different ones. A declared environment's fallback is wrangler's own `<script>-<env>`, which is built on
+ * the deploy name. A feature's name is `<project>-f<issue>-<slug>-<app>`, which already leads with the
+ * project, so it is built on the directory.
+ *
+ * This was one string until #587, and the string was the deploy name, so every feature Worker carried the
+ * project twice: `replay-f69-demo-replay-board`. That was not only untidy. The name is held to the Worker
+ * cap of 63, and the doubled segment spent that budget where the truncation lands on the part that says
+ * *which* Worker. Carrying both names is what lets each scope take the one its shape is built from, and
+ * lets neither caller choose on the scope's behalf.
+ */
+export interface ProvisionWorkerNames {
+    /** The Worker's `apps/<app>` directory basename — the name a sibling's `service` binding targets it by. */
+    readonly app: string;
+    /** The Worker's deploy name — the top-level `name` of its `wrangler.jsonc`, e.g. `replay-board`. */
+    readonly script: string;
+}
 /** Where a provisioning run's resources are named, and where their ids are written. */
 export interface ProvisionScope {
     /** The `env.<stanza>` key in each Worker's config that this scope's ids are written into. */
@@ -118,8 +139,18 @@ export interface ProvisionScope {
      * is created, judged to be the project's, kept out of the teardown record, and orphaned.
      */
     readonly honorsGlobal: boolean;
-    /** The script name a Worker deploys under in this scope. */
-    worker(worker: string): string;
+    /**
+     * The script name a Worker deploys under in this scope.
+     *
+     * `worker` carries **both** of the Worker's names, because the two scopes compose from different ones:
+     * a declared environment falls back to wrangler's `<script>-<env>`, and a feature composes
+     * `<project>-f<issue>-<slug>-<app>`. See {@link ProvisionWorkerNames}.
+     *
+     * `declared` is the name that scope's stanza already carries, when it carries one. A scope may honor it
+     * or compose its own; see {@link environmentScope} and {@link featureScope}, which answer differently
+     * and say why. Passing it is how a caller asks the scope rather than deciding for itself.
+     */
+    worker(worker: ProvisionWorkerNames, declared?: string): string;
     /**
      * This scope's CF Secrets Store entry name for a declared secret.
      *
@@ -158,6 +189,22 @@ export interface ProvisionScope {
  */
 export declare function bindingResourceName(project: string, binding: string, kind: FeatureResourceKind, naming: ProjectGlobalNaming): string;
 export declare function bindingResourceName(project: string, binding: string, kind: FeatureResourceKind, naming: BindingNaming, scoped: (thing: string) => string): string;
+/**
+ * **Is this name inside a feature's namespace** — `<project>-f<issue>-…`, the project and then a feature's
+ * marker, with something after it?
+ *
+ * The namespace, not one feature's names, because that is what has to stay disjoint: `pithy feature destroy`
+ * deletes by exact name, and a feature Worker's name has no kind suffix, so a declared environment's name
+ * that lands anywhere in here is one some branch's teardown can delete (#587). Every name {@link featureScope}
+ * composes is inside; {@link environmentScope} refuses to name a Worker inside, and `isValidEnvironment`
+ * refuses every environment whose composed names could be.
+ *
+ * **What it does not see.** It is stated for one project. A second project on the same account whose name is
+ * this one's plus `-f<issue>` — `acme-f1` beside `acme` — composes names inside `acme`'s namespace from an
+ * ordinary environment, and nothing here can tell, because a project name carries no boundary a later hyphen
+ * cannot fake. That is the hyphen ambiguity every composed name carries, one segment further left.
+ */
+export declare function isFeatureName(project: string, name: string): boolean;
 /**
  * A declared environment's scope — `staging`, `prod`, or whatever the root `pithy.config.ts` lists.
  *
@@ -165,13 +212,25 @@ export declare function bindingResourceName(project: string, binding: string, ki
  * every name below, so an illegal one must fail before anything is created rather than at the fourth
  * getter that happened to use it.
  *
- * **A Worker's script name is wrangler's own, `<script>-<env>`, deliberately.** It is the one name here
- * that is not `<project>-<env>-<thing>`, because `wrangler deploy --env staging` has always appended the
- * environment to the top-level `name` — so every project that ever deployed is already at that address.
- * A Worker script is a `refuse`-policy namespace precisely because renaming one orphans the deployment
- * and every `service` binding pointing at it; composing a "more correct" name here would do exactly
- * that, silently, on the next deploy. The name is written out rather than left implicit so a service
- * binding and a deploy agree on one string that is in the file.
+ * **A declared name wins; the fallback is wrangler's own, `<script>-<env>`.**
+ *
+ * This reverses the rule that stood here until #580, and the reversal is worth reading rather than
+ * assuming. The old rule *recomputed* `<script>-<env>` on every provision and wrote it over whatever the
+ * stanza said, on the argument that wrangler has always appended the environment to the top-level `name`,
+ * so every project that ever deployed is already at that address.
+ *
+ * That argument is still true about the **fallback**, and the fallback is unchanged: a stanza that names
+ * nothing gets `<script>-<env>` and every existing adopter deploys exactly where they always did. What was
+ * wrong was recomputing over a name somebody wrote down. Since #580 the starter template writes one —
+ * `<project>-<env>-<worker>`, the shape every other resource here takes — so recompute would have made the
+ * template's stamp pointless, and worse: it would have silently renamed the Worker of every project that
+ * had taken the new shape, on their next `pithy provision`. A Worker script is a `refuse`-policy namespace
+ * precisely because renaming one orphans the deployment, its routes, and every `service` binding pointing
+ * at it. Doing that as a side effect of provisioning is the failure the old rule was written to prevent,
+ * arriving from the other direction.
+ *
+ * So the name is read, not composed, when the file already holds one — and written out when it does not,
+ * so a service binding and a deploy still agree on one string that is in the file.
  */
 export declare function environmentScope(project: string, environment: string): ProvisionScope;
 /**
@@ -193,6 +252,35 @@ export declare function environmentScope(project: string, environment: string):
  * `resource` is ignored for the same reason it is moot: a feature's `<thing>` segment is the binding plus
  * the kind, and the whole name is recomputed on teardown rather than looked up, so nothing outside the
  * feature reads the string.
+ *
+ * **And a declared Worker name is ignored here too — the other half of the #580 asymmetry.** A declared
+ * environment's script name is the adopter's, written in a tracked file, and provisioning reads it. A
+ * feature's is the kit's: it is composed from the branch, written into a generated config nobody commits,
+ * and **recomputed on teardown**. Honoring a declared one would leave `pithy feature destroy` computing a
+ * name the deployment does not answer to, which is a Worker nothing deletes.
  */
 export declare function featureScope(identity: FeatureIdentity): ProvisionScope;
+/**
+ * **Every script name one Worker can be deployed under in a feature — what teardown looks for (#592).**
+ *
+ * The first is the name {@link featureScope} composes today, taken from the scope rather than composed a
+ * second time, so provisioning and teardown cannot disagree about it. The second is the one it composed
+ * until #587, from the deploy name: `<project>-f<issue>-<slug>-<project>-<app>`. A feature provisioned and
+ * deployed before that upgrade is still running under it, and after its next deploy it runs under both —
+ * so teardown looks for both. One entry when the two coincide, as they do for a Worker whose deploy name
+ * is its directory.
+ *
+ * **Exact names, never a prefix.** A prefix scan of `<project>-f<issue>-<slug>-` reaches a sibling whose
+ * slug extends this one's. The exact names can still meet a sibling in one shape: the doubled name for
+ * slug `demo` and deploy name `acme-api` is the current name for slug `demo-acme` and directory `api`, on
+ * the same issue number. That is the same hyphen ambiguity every feature name here carries.
+ *
+ * **They cannot meet a declared environment's Worker**, which has no suffix either and is `<project>-<env>-<app>`
+ * since #580: every name either shape yields is inside {@link isFeatureName}'s namespace, no environment may
+ * start with a feature's marker, and {@link environmentScope} refuses a declared or fallback Worker name inside
+ * it. What that does not reach is a name nothing in the kit chose — a stanza written by hand and deployed
+ * without `pithy provision --env` ever reading it, or another project on the account, as {@link isFeatureName}
+ * says.
+ */
+export declare function featureWorkerScriptNames(identity: FeatureIdentity, worker: ProvisionWorkerNames): string[];
 //# sourceMappingURL=provisionScope.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"provisionScope.d.ts","sourceRoot":"","sources":["../../src/naming/provisionScope.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAIzB,MAAM,WAAW,CAAC;AAGnB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,aAAa,GAAG,MAAM,CAAC;IACpF;;;;;;;;;OASG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,4DAA4D;IAC5D,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAC/B;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,eAAe,GAAG,MAAM,CAAC;CACnE;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,mBAAmB,GAC1B,MAAM,CAAC;AACV,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAChC,MAAM,CAAC;AAsBV;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,cAAc,CAerF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,cAAc,CAatE"}
+{"version":3,"file":"provisionScope.d.ts","sourceRoot":"","sources":["../../src/naming/provisionScope.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAIzB,MAAM,WAAW,CAAC;AAInB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,QAAQ,CAAC;AAEvD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,eAAe,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;CAC1B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,oBAAoB;IACnC,2GAA2G;IAC3G,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,oGAAoG;IACpG,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,uFAAuF;AACvF,MAAM,WAAW,cAAc;IAC7B,6FAA6F;IAC7F,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,aAAa,GAAG,MAAM,CAAC;IACpF;;;;;;;;;OASG;IACH,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,MAAM,EAAE,oBAAoB,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChE;;;;;;OAMG;IACH,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,eAAe,GAAG,MAAM,CAAC;CACnE;AAiBD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,mBAAmB,GAC1B,MAAM,CAAC;AACV,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,GAChC,MAAM,CAAC;AAsBV;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAKpE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,cAAc,CA6BrF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,cAAc,CAetE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,eAAe,EAAE,MAAM,EAAE,oBAAoB,GAAG,MAAM,EAAE,CAI1G"}