@pithy-sh/core 0.6.1 → 0.6.2

package/dist/naming/provisionScope.d.ts

@@ -118,8 +118,14 @@ 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.
+     *
+     * `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: string, declared?: string): string;
     /**
      * This scope's CF Secrets Store entry name for a declared secret.
      *
@@ -165,13 +171,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 +211,12 @@ 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;
 //# 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;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;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAClD;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,cAAc,CAerF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,YAAY,CAAC,QAAQ,EAAE,eAAe,GAAG,cAAc,CAatE"}

package/dist/naming/provisionScope.js

@@ -38,13 +38,25 @@ function bindingResourceName(project, binding, kind, naming, scoped) {
 * 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.
 */
 function environmentScope(project, environment) {
 	assertValidEnvironment(environment);
@@ -54,7 +66,7 @@ function environmentScope(project, environment) {
 		source: true,
 		honorsGlobal: true,
 		resource: (binding, kind, naming) => bindingResourceName(project, binding, kind, naming, (thing) => names[KIND_NAMER[kind]](thing)),
-		worker: (worker) => `${worker}-${environment}`,
+		worker: (worker, declared) => declared ?? `${worker}-${environment}`,
 		secretEntry: (secret, secretScope) => secretEntryName(project, secret, secretScope, () => names.secretEntry(secret))
 	};
 }
@@ -77,6 +89,12 @@ function environmentScope(project, environment) {
 * `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.
 */
 function featureScope(identity) {
 	return {

package/dist/version.generated.d.ts

@@ -3,5 +3,5 @@
 /** This package's npm name — the join key against a release feed. */
 export declare const PACKAGE_NAME = "@pithy-sh/core";
 /** This package's version, stamped from its own package.json at generation time. */
-export declare const PACKAGE_VERSION = "0.6.1";
+export declare const PACKAGE_VERSION = "0.6.2";
 //# sourceMappingURL=version.generated.d.ts.map

package/dist/version.generated.js

@@ -4,6 +4,6 @@
 /** This package's npm name — the join key against a release feed. */
 const PACKAGE_NAME = "@pithy-sh/core";
 /** This package's version, stamped from its own package.json at generation time. */
-const PACKAGE_VERSION = "0.6.1";
+const PACKAGE_VERSION = "0.6.2";
 //#endregion
 export { PACKAGE_NAME, PACKAGE_VERSION };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pithy-sh/core",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/naming/provisionScope.ts

@@ -133,8 +133,14 @@ 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.
+   *
+   * `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: string, declared?: string): string;
   /**
    * This scope's CF Secrets Store entry name for a declared secret.
    *
@@ -228,13 +234,25 @@ export function bindingResourceName(
  * 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 function environmentScope(project: string, environment: string): ProvisionScope {
   assertValidEnvironment(environment);
@@ -247,7 +265,7 @@ export function environmentScope(project: string, environment: string): Provisio
     honorsGlobal: true,
     resource: (binding, kind, naming) =>
       bindingResourceName(project, binding, kind, naming, (thing) => names[KIND_NAMER[kind]](thing)),
-    worker: (worker) => `${worker}-${environment}`,
+    worker: (worker, declared) => declared ?? `${worker}-${environment}`,
     secretEntry: (secret, secretScope) =>
       secretEntryName(project, secret, secretScope, () => names.secretEntry(secret)),
   };
@@ -272,6 +290,12 @@ export function environmentScope(project: string, environment: string): Provisio
  * `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 function featureScope(identity: FeatureIdentity): ProvisionScope {
   return {

package/src/version.generated.ts

@@ -13,4 +13,4 @@
 export const PACKAGE_NAME = "@pithy-sh/core";
 
 /** This package's version, stamped from its own package.json at generation time. */
-export const PACKAGE_VERSION = "0.6.1";
+export const PACKAGE_VERSION = "0.6.2";