@homeflare/alchemy 0.58.0 → 0.59.0

package/README.md

@@ -385,6 +385,23 @@ before export: every header dropped, every query string stripped, a denylisted h
 blanked. Options, the redaction policy and what a spike measured actually arriving at a collector:
 [docs/telemetry.md](./docs/telemetry.md) · [docs/telemetry-spike.md](./docs/telemetry-spike.md).
 
+## Duplicate resource ids — `@homeflare/alchemy/scope`
+
+⛔ Two resources of different types declaring the same logical id in one stack scope used to
+collide silently — Alchemy's own idempotent-registration path treats the second one as a
+reference to the first, and the second resource's props never reach a plan. `guardDuplicateIds`
+wraps a resource class so a collision dies at registration, naming both types:
+
+```ts
+import { Resource } from 'alchemy';
+import { guardDuplicateIds } from '@homeflare/alchemy/scope';
+
+export const MyResource = guardDuplicateIds(Resource<MyResource>('My.Resource'));
+```
+
+The measured incident, what this does and does not cover, and the upstream issue proposed for
+`alchemy` itself: [docs/duplicate-resource-id.md](./docs/duplicate-resource-id.md).
+
 ## Credentials
 
 ⛔ **Mint a short-lived, scoped token** — never a long-lived one, never a Global API Key. How each

package/dist/caddy/config.d.ts

@@ -28,6 +28,12 @@
  *   place that discharges them — scoped to the handful of effects that actually call
  *   `@distilled.cloud/caddy`'s operations, never leaking into a sibling fetch-based provider merged
  *   into the same stack (admin.ts's own ⛔; MEASURED 2026-09-26, admin-transport-scope.test.ts).
+ * ⛔ `CaddyConfig` IS WRAPPED IN `guardDuplicateIds` (scope/guard.ts). MEASURED, homeflare-mini PR
+ *   329: a `NixJobRetirement('caddy', …)` declared in the same stack as this resource's `CADDY_ID
+ *   = 'caddy'` collided silently — Alchemy's own `Resource()` treated the second registration as
+ *   an idempotent re-reference to the first, so the retirement's props were never written
+ *   anywhere a plan could see (`scope/duplicate-id.ts` has the full mechanism). This resource was
+ *   one half of that collision, so it is the first to carry the guard.
  */
 import { Resource } from 'alchemy';
 import * as Provider from 'alchemy/Provider';

package/dist/caddy/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/caddy/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAI7C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAKhF,YAAY,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEhF,MAAM,WAAW,WAAY,SAAQ,QAAQ,CAC3C,cAAc,EACd,gBAAgB,EAChB,qBAAqB,CACtB;CAAG;AAEJ,eAAO,MAAM,WAAW,8CAEtB,CAAC;AAoBH,eAAO,MAAM,mBAAmB,oHA+F7B,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/caddy/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAK7C,OAAO,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAKhF,YAAY,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEhF,MAAM,WAAW,WAAY,SAAQ,QAAQ,CAC3C,cAAc,EACd,gBAAgB,EAChB,qBAAqB,CACtB;CAAG;AAEJ,eAAO,MAAM,WAAW,8CAIvB,CAAC;AAoBF,eAAO,MAAM,mBAAmB,oHA+F7B,CAAC"}

package/dist/caddy/index.js

@@ -169,7 +169,7 @@ import { Resource } from "alchemy";
 import { Unowned as Unowned2 } from "alchemy/AdoptPolicy";
 import { isResolved } from "alchemy/Diff";
 import * as Provider from "alchemy/Provider";
-import * as Effect11 from "effect/Effect";
+import * as Effect13 from "effect/Effect";
 
 // src/launchd/host-effect.ts
 import * as Effect2 from "effect/Effect";
@@ -395,21 +395,88 @@ var refuseTakeover = (owner, what) => Effect6.gen(function* () {
 });
 var claimFor = (owner) => (what) => refuseTakeover(owner, what);
 
+// src/scope/guard.ts
+import * as Effect8 from "effect/Effect";
+
+// src/scope/duplicate-id.ts
+import { toFqn } from "alchemy/FQN";
+import { CurrentNamespace } from "alchemy/Namespace";
+import { Stack as Stack4 } from "alchemy/Stack";
+import * as Data from "effect/Data";
+import * as Effect7 from "effect/Effect";
+
+class DuplicateResourceIdError extends Data.TaggedError("DuplicateResourceIdError") {
+}
+var scopeLabel = (namespace) => {
+  if (!namespace)
+    return "(root)";
+  const path = [];
+  let node = namespace;
+  while (node) {
+    path.unshift(node.Id);
+    node = node.Parent;
+  }
+  return path.join("/");
+};
+var registries = new WeakMap;
+var registryFor = (stack) => {
+  const existing = registries.get(stack);
+  if (existing)
+    return existing;
+  const created = new Map;
+  registries.set(stack, created);
+  return created;
+};
+var claimResourceId = (type, id) => Effect7.gen(function* () {
+  const stack = yield* Stack4;
+  const namespace = yield* CurrentNamespace;
+  const fqn = toFqn(namespace, id);
+  const registry = registryFor(stack);
+  const firstType = registry.get(fqn);
+  if (firstType === undefined) {
+    registry.set(fqn, type);
+    return;
+  }
+  if (firstType !== type) {
+    return yield* Effect7.die(new DuplicateResourceIdError({
+      message: `REFUSING: duplicate resource id "${fqn}" in scope ${scopeLabel(namespace)}: ` + `first declared by ${firstType}, again by ${type}`,
+      fqn,
+      scope: scopeLabel(namespace),
+      firstType,
+      secondType: type
+    }));
+  }
+});
+
+// src/scope/guard.ts
+var guardDuplicateIds = (resourceClass) => new Proxy(resourceClass, {
+  apply(target, thisArg, args) {
+    const id = args[0];
+    if (typeof id !== "string") {
+      return Reflect.apply(target, thisArg, args);
+    }
+    return Effect8.gen(function* () {
+      yield* claimResourceId(resourceClass.Type, id);
+      return yield* Reflect.apply(target, thisArg, args);
+    });
+  }
+});
+
 // src/caddy/config-lifecycle.ts
-import * as Effect9 from "effect/Effect";
+import * as Effect11 from "effect/Effect";
 import * as Result2 from "effect/Result";
 
 // src/caddy/admin-calls.ts
-import * as Effect7 from "effect/Effect";
+import * as Effect9 from "effect/Effect";
 import * as Caddy from "@distilled.cloud/caddy";
 var CADDYFILE = "text/caddyfile";
 var describe = (warning) => `${warning.file ?? "Caddyfile"}:${String(warning.line ?? 0)}: ${warning.message ?? "(no message)"}`;
-var adaptCaddyfile = (caddyfile) => Effect7.map(Caddy.Services.admin.adaptConfig({ config: caddyfile, contentType: CADDYFILE }), (response) => ({
+var adaptCaddyfile = (caddyfile) => Effect9.map(Caddy.Services.admin.adaptConfig({ config: caddyfile, contentType: CADDYFILE }), (response) => ({
   config: response.result ?? null,
   warnings: (response.warnings ?? []).map(describe)
 }));
-var readRunningConfig = () => Effect7.map(Caddy.Services.admin.getConfig({ path: "" }), (response) => response.value ?? null);
-var loadCaddyfile = (caddyfile, sourceFile) => Effect7.map(Caddy.Services.admin.loadConfig({
+var readRunningConfig = () => Effect9.map(Caddy.Services.admin.getConfig({ path: "" }), (response) => response.value ?? null);
+var loadCaddyfile = (caddyfile, sourceFile) => Effect9.map(Caddy.Services.admin.loadConfig({
   config: caddyfile,
   contentType: CADDYFILE,
   ...sourceFile === undefined ? {} : { sourceAdapter: "caddyfile", sourceFile }
@@ -494,12 +561,12 @@ var adminProblems = (adapted, transport) => {
 };
 
 // src/caddy/config-errors.ts
-import * as Effect8 from "effect/Effect";
+import * as Effect10 from "effect/Effect";
 var refuse = (endpoint, message) => new Error(`Caddy.Config at ${endpoint}: ${message}`);
 var short = (digest) => digest.slice(0, 12);
 var messageOf = (error) => ("message" in error) && typeof error.message === "string" ? error.message : String(error);
 var operationFailure = (endpoint, op, error) => error._tag === "LoadRefused" ? refuse(endpoint, `Caddy refused the Caddyfile (${error._tag}, a 200 whose body carried the error, not a ` + `failure status) — ${error.message}`) : refuse(endpoint, `${op} failed (${error._tag}) — ${messageOf(error)}`);
-var wrapOperation = (endpoint, op) => (effect) => effect.pipe(Effect8.mapError((error) => isUnreachable(error) ? error : operationFailure(endpoint, op, error)));
+var wrapOperation = (endpoint, op) => (effect) => effect.pipe(Effect10.mapError((error) => isUnreachable(error) ? error : operationFailure(endpoint, op, error)));
 
 // src/launchd/secret-tripwire.ts
 var ALTERNATIVE = "props are stored unencrypted in Alchemy state. Have a secret renderer (e.g. openbao-agent) " + "write it to a root-owned file and declare the file path instead (FOO_FILE=/path, --foo-file /path).";
@@ -848,18 +915,18 @@ var servesNothing = (config) => {
   const apps = typeof config === "object" && config !== null ? config.apps : undefined;
   return typeof apps !== "object" || apps === null || Object.keys(apps).length === 0;
 };
-var desiredConfig = (props) => Effect9.gen(function* () {
+var desiredConfig = (props) => Effect11.gen(function* () {
   const { endpoint, listener } = yield* CaddyAdminService;
   const found = configProblems(props);
   if (found.length > 0)
-    return yield* Effect9.fail(refuse(endpoint, found.join("; ")));
+    return yield* Effect11.fail(refuse(endpoint, found.join("; ")));
   const adapted = yield* adaptCaddyfile(props.caddyfile).pipe(wrapOperation(endpoint, "POST /adapt"));
   if (servesNothing(adapted.config)) {
-    return yield* Effect9.fail(refuse(endpoint, "the Caddyfile adapts to no apps — loading it would stop every site"));
+    return yield* Effect11.fail(refuse(endpoint, "the Caddyfile adapts to no apps — loading it would stop every site"));
   }
   const guard = adminProblems(adapted.config, listener);
   if (guard.length > 0)
-    return yield* Effect9.fail(refuse(endpoint, guard.join("; ")));
+    return yield* Effect11.fail(refuse(endpoint, guard.join("; ")));
   return { digest: configDigest(adapted.config), warnings: adapted.warnings };
 });
 var attributesOf = (endpoint, running, sourceFile) => ({
@@ -867,13 +934,13 @@ var attributesOf = (endpoint, running, sourceFile) => ({
   endpoint,
   ...sourceFile === undefined ? {} : { sourceFile }
 });
-var readLive = (sourceFile) => Effect9.gen(function* () {
+var readLive = (sourceFile) => Effect11.gen(function* () {
   const { endpoint } = yield* CaddyAdminService;
   const running = yield* readRunningConfig().pipe(wrapOperation(endpoint, "GET /config/"));
   return attributesOf(endpoint, running, sourceFile);
 });
 var claimable = (running, declaredDigest) => servesNothing(running) || configDigest(running) === declaredDigest;
-var probeLive = (caddyfile, sourceFile) => Effect9.gen(function* () {
+var probeLive = (caddyfile, sourceFile) => Effect11.gen(function* () {
   const { endpoint } = yield* CaddyAdminService;
   const running = yield* readRunningConfig();
   if (servesNothing(running))
@@ -882,12 +949,12 @@ var probeLive = (caddyfile, sourceFile) => Effect9.gen(function* () {
   if (caddyfile === undefined) {
     return { attributes, ours: false, unchecked: "the stored Caddyfile is not plain text" };
   }
-  const desired = yield* Effect9.result(desiredConfig({ caddyfile }));
+  const desired = yield* Effect11.result(desiredConfig({ caddyfile }));
   if (Result2.isSuccess(desired)) {
     return { attributes, ours: claimable(running, desired.success.digest) };
   }
   if (isUnreachable(desired.failure))
-    return yield* Effect9.fail(desired.failure);
+    return yield* Effect11.fail(desired.failure);
   const cause = desired.failure;
   return {
     attributes,
@@ -897,7 +964,7 @@ var probeLive = (caddyfile, sourceFile) => Effect9.gen(function* () {
 });
 
 // src/caddy/config-reconcile.ts
-import * as Effect10 from "effect/Effect";
+import * as Effect12 from "effect/Effect";
 import * as Result3 from "effect/Result";
 
 // src/caddy/format-warnings.ts
@@ -909,100 +976,100 @@ var splitFormattingWarning = (warnings) => ({
 var formattingFixLine = (endpoint) => `Caddy.Config at ${endpoint}: Caddyfile is not formatted — run \`caddy fmt\` on it, or format ` + "it with this package's formatCaddyfile() before declaring it, to silence this warning.";
 
 // src/caddy/config-reconcile.ts
-var diffConfig = (news, output) => Effect10.gen(function* () {
+var diffConfig = (news, output) => Effect12.gen(function* () {
   const { endpoint } = yield* CaddyAdminService;
   const want = yield* desiredConfig(news);
   const { formatting } = splitFormattingWarning(want.warnings);
   if (formatting.length > 0)
-    yield* Effect10.logWarning(formattingFixLine(endpoint));
+    yield* Effect12.logWarning(formattingFixLine(endpoint));
   const live = yield* readLive();
   const converged = want.digest === live.configSha256 && live.configSha256 === output.configSha256 && news.sourceFile === output.sourceFile && endpoint === output.endpoint;
   return converged ? { action: "noop" } : { action: "update" };
 });
-var reconcileConfig = (props, authority) => Effect10.gen(function* () {
+var reconcileConfig = (props, authority) => Effect12.gen(function* () {
   const { endpoint } = yield* CaddyAdminService;
   const want = yield* desiredConfig(props);
   const running = yield* readRunningConfig().pipe(wrapOperation(endpoint, "GET /config/"));
   const before = configDigest(running);
   const known = before === authority.stored || claimable(running, want.digest);
   if (!authority.takeOver && !known) {
-    return yield* Effect10.fail(refuse(endpoint, `Caddy runs config ${short(before)}, which this stack did not load, and the Caddyfile ` + `adapts to ${short(want.digest)} — loading it would replace every site that config ` + "serves. Deploy with --adopt (or wrap the resource in adopt(true)) to take this Caddy " + "over, or point caddyProviders() at the Caddy you meant."));
+    return yield* Effect12.fail(refuse(endpoint, `Caddy runs config ${short(before)}, which this stack did not load, and the Caddyfile ` + `adapts to ${short(want.digest)} — loading it would replace every site that config ` + "serves. Deploy with --adopt (or wrap the resource in adopt(true)) to take this Caddy " + "over, or point caddyProviders() at the Caddy you meant."));
   }
   let warnings = want.warnings;
   const loaded = before !== want.digest;
   if (loaded) {
-    const outcome = yield* Effect10.result(loadCaddyfile(props.caddyfile, props.sourceFile));
+    const outcome = yield* Effect12.result(loadCaddyfile(props.caddyfile, props.sourceFile));
     if (Result3.isFailure(outcome)) {
       const error = outcome.failure;
       if (isUnreachable(error))
-        return yield* Effect10.fail(error);
-      const afterRead = yield* Effect10.result(readLive());
+        return yield* Effect12.fail(error);
+      const afterRead = yield* Effect12.result(readLive());
       const after = Result3.isSuccess(afterRead) ? afterRead.success : undefined;
       const state = after === undefined ? "and the running config could not be read back" : after.configSha256 === before ? "Caddy kept the previous config (still serving)" : `and the running config is now ${short(after.configSha256)}, not the previous ${short(before)}`;
       const reason = error._tag === "LoadRefused" ? `${error.message} (LoadRefused: a 200 whose body carried the error, not a failure status)` : messageOf(error);
-      return yield* Effect10.fail(refuse(endpoint, `Caddy refused the Caddyfile — ${reason}; ${state}`));
+      return yield* Effect12.fail(refuse(endpoint, `Caddy refused the Caddyfile — ${reason}; ${state}`));
     }
     warnings = outcome.success;
   }
   const attributes = yield* readLive(props.sourceFile);
   if (attributes.configSha256 !== want.digest) {
-    return yield* Effect10.fail(refuse(endpoint, `after the load Caddy runs config ${short(attributes.configSha256)}, not the ` + `${short(want.digest)} this Caddyfile adapts to — another writer changed it, or it was ` + "not applied"));
+    return yield* Effect12.fail(refuse(endpoint, `after the load Caddy runs config ${short(attributes.configSha256)}, not the ` + `${short(want.digest)} this Caddyfile adapts to — another writer changed it, or it was ` + "not applied"));
   }
   return { attributes, loaded, warnings };
 });
 
 // src/caddy/config.ts
-var CaddyConfig = Resource("Caddy.Config", {
+var CaddyConfig = guardDuplicateIds(Resource("Caddy.Config", {
   defaultRemovalPolicy: "retain"
-});
-var planWithoutCaddy = (admin, fallback) => (error) => Effect11.as(Effect11.logWarning(`Caddy.Config: no Caddy at ${admin.endpoint} ` + `(${error instanceof Error ? error.message : String(error)}); planning without it — ` + "the Caddyfile is validated when the deploy reaches Caddy"), fallback);
-var CaddyConfigProvider = () => Provider.effect(CaddyConfig, Effect11.gen(function* () {
+}));
+var planWithoutCaddy = (admin, fallback) => (error) => Effect13.as(Effect13.logWarning(`Caddy.Config: no Caddy at ${admin.endpoint} ` + `(${error instanceof Error ? error.message : String(error)}); planning without it — ` + "the Caddyfile is validated when the deploy reaches Caddy"), fallback);
+var CaddyConfigProvider = () => Provider.effect(CaddyConfig, Effect13.gen(function* () {
   const admin = yield* CaddyAdminService;
   const transportLayer = yield* CaddyAdminTransport;
-  const probe = (caddyfile, sourceFile) => Effect11.flatMap(probeLive(caddyfile, sourceFile), (found) => {
+  const probe = (caddyfile, sourceFile) => Effect13.flatMap(probeLive(caddyfile, sourceFile), (found) => {
     if (found === undefined)
-      return Effect11.succeed(undefined);
+      return Effect13.succeed(undefined);
     if (found.ours)
-      return Effect11.succeed(found.attributes);
+      return Effect13.succeed(found.attributes);
     const unowned = Unowned2(found.attributes);
-    return found.unchecked === undefined ? Effect11.succeed(unowned) : Effect11.as(Effect11.logWarning(`Caddy.Config at ${admin.endpoint}: the running config could not be compared ` + `with the declared Caddyfile (${found.unchecked}), so it is not treated as ours`), unowned);
+    return found.unchecked === undefined ? Effect13.succeed(unowned) : Effect13.as(Effect13.logWarning(`Caddy.Config at ${admin.endpoint}: the running config could not be compared ` + `with the declared Caddyfile (${found.unchecked}), so it is not treated as ours`), unowned);
   });
   return CaddyConfig.Provider.of({
-    list: () => Effect11.succeed([]),
-    read: ({ olds, output }) => Effect11.gen(function* () {
+    list: () => Effect13.succeed([]),
+    read: ({ olds, output }) => Effect13.gen(function* () {
       return output === undefined ? yield* probe(resolvedString(olds, "caddyfile"), resolvedString(olds, "sourceFile")) : yield* readLive(resolvedString(olds, "sourceFile"));
-    }).pipe(Effect11.provide(transportLayer), Effect11.catchIf(isUnreachable, planWithoutCaddy(admin, undefined))),
+    }).pipe(Effect13.provide(transportLayer), Effect13.catchIf(isUnreachable, planWithoutCaddy(admin, undefined))),
     diff: ({ news, output }) => {
       if (output === undefined)
-        return Effect11.succeed(undefined);
+        return Effect13.succeed(undefined);
       const update = planWithoutCaddy(admin, { action: "update" });
       if (isResolved(news)) {
-        return diffConfig(news, output).pipe(Effect11.provide(transportLayer), Effect11.catchIf(isUnreachable, update));
+        return diffConfig(news, output).pipe(Effect13.provide(transportLayer), Effect13.catchIf(isUnreachable, update));
       }
       const caddyfile = resolvedString(news, "caddyfile");
       if (caddyfile === undefined)
-        return Effect11.succeed(undefined);
-      return Effect11.as(diffConfig({ caddyfile }, output), { action: "update" }).pipe(Effect11.provide(transportLayer), Effect11.catchIf(isUnreachable, update));
+        return Effect13.succeed(undefined);
+      return Effect13.as(diffConfig({ caddyfile }, output), { action: "update" }).pipe(Effect13.provide(transportLayer), Effect13.catchIf(isUnreachable, update));
     },
-    reconcile: ({ fqn, news, output }) => Effect11.gen(function* () {
+    reconcile: ({ fqn, news, output }) => Effect13.gen(function* () {
       const sameCaddy = output !== undefined && output.endpoint === admin.endpoint;
       const takeOver = sameCaddy || (yield* adoptEnabled(fqn));
       const stored = output === undefined ? {} : { stored: output.configSha256 };
-      const applied = yield* reconcileConfig(news, { takeOver, ...stored }).pipe(Effect11.provide(transportLayer));
+      const applied = yield* reconcileConfig(news, { takeOver, ...stored }).pipe(Effect13.provide(transportLayer));
       const { formatting, rest } = splitFormattingWarning(applied.warnings);
       if (formatting.length > 0) {
-        yield* Effect11.logWarning(formattingFixLine(admin.endpoint));
+        yield* Effect13.logWarning(formattingFixLine(admin.endpoint));
       }
       for (const warning of rest) {
-        yield* Effect11.logWarning(`Caddy.Config at ${admin.endpoint}: ${warning}`);
+        yield* Effect13.logWarning(`Caddy.Config at ${admin.endpoint}: ${warning}`);
       }
       return applied.attributes;
     }),
-    delete: () => Effect11.void
+    delete: () => Effect13.void
   });
 }));
 // src/caddy/format.ts
-import * as Effect12 from "effect/Effect";
+import * as Effect14 from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as ChildProcess from "effect/process/ChildProcess";
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
@@ -1029,7 +1096,7 @@ class CaddyFmtFailed extends Error {
     this.name = "CaddyFmtFailed";
   }
 }
-var formatCaddyfile = (text, options = {}) => Effect12.gen(function* () {
+var formatCaddyfile = (text, options = {}) => Effect14.gen(function* () {
   const binaryPath = options.binaryPath ?? DEFAULT_CADDY_BINARY;
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const input = new TextEncoder().encode(text);
@@ -1038,13 +1105,13 @@ var formatCaddyfile = (text, options = {}) => Effect12.gen(function* () {
     stderr: "pipe",
     stdin: Stream.make(input),
     stdout: "pipe"
-  }).pipe(spawner.spawn, Effect12.flatMap((child) => Effect12.all({
+  }).pipe(spawner.spawn, Effect14.flatMap((child) => Effect14.all({
     exitCode: child.exitCode,
-    stderr: child.stderr.pipe(Stream.decodeText, Stream.mkString, Effect12.map((out) => out.trim())),
+    stderr: child.stderr.pipe(Stream.decodeText, Stream.mkString, Effect14.map((out) => out.trim())),
     stdout: child.stdout.pipe(Stream.decodeText, Stream.mkString)
-  }, { concurrency: "unbounded" })), Effect12.scoped, Effect12.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect12.fail(new CaddyFmtNotFound(binaryPath, error)) : Effect12.fail(error)));
+  }, { concurrency: "unbounded" })), Effect14.scoped, Effect14.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect14.fail(new CaddyFmtNotFound(binaryPath, error)) : Effect14.fail(error)));
   if (result4.exitCode !== 0) {
-    return yield* Effect12.fail(new CaddyFmtFailed(binaryPath, result4.exitCode, result4.stderr));
+    return yield* Effect14.fail(new CaddyFmtFailed(binaryPath, result4.exitCode, result4.stderr));
   }
   return result4.stdout;
 });
@@ -1115,7 +1182,7 @@ var localCaddyAdmin = (options = {}) => {
 import * as Layer4 from "effect/Layer";
 var caddyProviders = (transport = localCaddyAdmin()) => CaddyConfigProvider().pipe(Layer4.provideMerge(caddyAdminLayer(transport)));
 // src/caddy/with-file.ts
-import * as Effect14 from "effect/Effect";
+import * as Effect16 from "effect/Effect";
 import * as RemovalPolicy from "alchemy/RemovalPolicy";
 
 // src/launchd/host-file.ts
@@ -1123,7 +1190,7 @@ import { Resource as Resource2 } from "alchemy";
 import { Unowned as Unowned3 } from "alchemy/AdoptPolicy";
 import { isResolved as isResolved2 } from "alchemy/Diff";
 import * as Provider2 from "alchemy/Provider";
-import * as Effect13 from "effect/Effect";
+import * as Effect15 from "effect/Effect";
 
 // src/launchd/file-identity.ts
 var sameEntry = (a, b) => {
@@ -1318,10 +1385,10 @@ var deleteFile = (runner, output) => removeWholeFile(runner, output, refuse3);
 
 // src/launchd/host-file.ts
 var HostFile = Resource2("Host.File");
-var HostFileProvider = () => Provider2.effect(HostFile, Effect13.gen(function* () {
+var HostFileProvider = () => Provider2.effect(HostFile, Effect15.gen(function* () {
   const runner = yield* HostRunnerService;
   return HostFile.Provider.of({
-    list: () => Effect13.succeed([]),
+    list: () => Effect15.succeed([]),
     read: ({ olds, output }) => lift(async () => {
       const found = await readFileAttributes(runner, olds.path);
       if (found === undefined)
@@ -1335,19 +1402,19 @@ var HostFileProvider = () => Provider2.effect(HostFile, Effect13.gen(function* (
         return lift(() => diffFile(runner, news, output));
       const path = resolvedString(news, "path");
       if (path === undefined || path === output.path)
-        return Effect13.succeed(undefined);
+        return Effect15.succeed(undefined);
       return lift(async () => await oneFile(runner, path, output.path) === true ? undefined : { action: "replace" });
     },
-    reconcile: ({ fqn, instanceId, news, output }) => Effect13.flatMap(adoptsAtApply({ fqn, instanceId, output }), (adopt) => lift(() => reconcileFile(runner, news, output, adopt))),
+    reconcile: ({ fqn, instanceId, news, output }) => Effect15.flatMap(adoptsAtApply({ fqn, instanceId, output }), (adopt) => lift(() => reconcileFile(runner, news, output, adopt))),
     delete: ({ output }) => lift(() => deleteFile(runner, output))
   });
 }));
 
 // src/caddy/with-file.ts
-var caddyWithFile = (id, props) => Effect14.gen(function* () {
+var caddyWithFile = (id, props) => Effect16.gen(function* () {
   const found = configProblems({ caddyfile: props.caddyfile, sourceFile: props.path });
   if (found.length > 0) {
-    return yield* Effect14.fail(new Error(`caddyWithFile ${id}: ${found.join("; ")}`));
+    return yield* Effect16.fail(new Error(`caddyWithFile ${id}: ${found.join("; ")}`));
   }
   const file = yield* HostFile(`${id}-file`, {
     content: props.caddyfile,
@@ -1377,5 +1444,5 @@ export {
   verifierProblems
 };
 
-//# debugId=A4890D1A8DCAD67064756E2164756E21
+//# debugId=E80D7FC971F2355764756E2164756E21
 //# sourceMappingURL=index.js.map