@homeflare/alchemy 0.59.0 → 0.60.0

package/README.md

@@ -385,22 +385,24 @@ 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`
+## Duplicate resource ids — a patch to `alchemy`, `@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'));
+reference to the first, and the second resource's props never reach a plan. The fix is a PATCH
+to `alchemy`'s own `Resource.ts` (`patches/alchemy@2.0.0-beta.81.patch`), applied at each
+consuming stack's own root since `alchemy` is a peer dependency here:
+
+```sh
+cp node_modules/@homeflare/alchemy/patches/alchemy@2.0.0-beta.81.patch patches/
+# then add to package.json: "patchedDependencies": { "alchemy@2.0.0-beta.81": "patches/alchemy@2.0.0-beta.81.patch" }
+bun install
 ```
 
-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).
+`checkAlchemyPatch` (`@homeflare/alchemy/scope`) is what a stack's own `check` calls to catch a
+version bump that silently drops the patch. The measured incident, why a kit-side `Proxy`
+wrapper could not actually fix it, and the upstream issue proposed for `alchemy` itself:
+[docs/duplicate-resource-id.md](./docs/duplicate-resource-id.md).
 
 ## Credentials
 

package/dist/caddy/config.d.ts

@@ -28,12 +28,10 @@
  *   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.
+ * ⚠️ `CADDY_ID`-style collisions with another resource's id in the same stack (MEASURED,
+ *   homeflare-mini PR 329: `NixJobRetirement('caddy', …)` beside this resource's own `caddy`)
+ *   are refused by the patched `alchemy` every consuming stack applies — not by anything in
+ *   this file. See `packages/alchemy/docs/duplicate-resource-id.md`.
  */
 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/caddy/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;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"}

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 Effect13 from "effect/Effect";
+import * as Effect11 from "effect/Effect";
 
 // src/launchd/host-effect.ts
 import * as Effect2 from "effect/Effect";
@@ -395,88 +395,21 @@ 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 Effect11 from "effect/Effect";
+import * as Effect9 from "effect/Effect";
 import * as Result2 from "effect/Result";
 
 // src/caddy/admin-calls.ts
-import * as Effect9 from "effect/Effect";
+import * as Effect7 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) => Effect9.map(Caddy.Services.admin.adaptConfig({ config: caddyfile, contentType: CADDYFILE }), (response) => ({
+var adaptCaddyfile = (caddyfile) => Effect7.map(Caddy.Services.admin.adaptConfig({ config: caddyfile, contentType: CADDYFILE }), (response) => ({
   config: response.result ?? null,
   warnings: (response.warnings ?? []).map(describe)
 }));
-var readRunningConfig = () => Effect9.map(Caddy.Services.admin.getConfig({ path: "" }), (response) => response.value ?? null);
-var loadCaddyfile = (caddyfile, sourceFile) => Effect9.map(Caddy.Services.admin.loadConfig({
+var readRunningConfig = () => Effect7.map(Caddy.Services.admin.getConfig({ path: "" }), (response) => response.value ?? null);
+var loadCaddyfile = (caddyfile, sourceFile) => Effect7.map(Caddy.Services.admin.loadConfig({
   config: caddyfile,
   contentType: CADDYFILE,
   ...sourceFile === undefined ? {} : { sourceAdapter: "caddyfile", sourceFile }
@@ -561,12 +494,12 @@ var adminProblems = (adapted, transport) => {
 };
 
 // src/caddy/config-errors.ts
-import * as Effect10 from "effect/Effect";
+import * as Effect8 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(Effect10.mapError((error) => isUnreachable(error) ? error : operationFailure(endpoint, op, error)));
+var wrapOperation = (endpoint, op) => (effect) => effect.pipe(Effect8.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).";
@@ -915,18 +848,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) => Effect11.gen(function* () {
+var desiredConfig = (props) => Effect9.gen(function* () {
   const { endpoint, listener } = yield* CaddyAdminService;
   const found = configProblems(props);
   if (found.length > 0)
-    return yield* Effect11.fail(refuse(endpoint, found.join("; ")));
+    return yield* Effect9.fail(refuse(endpoint, found.join("; ")));
   const adapted = yield* adaptCaddyfile(props.caddyfile).pipe(wrapOperation(endpoint, "POST /adapt"));
   if (servesNothing(adapted.config)) {
-    return yield* Effect11.fail(refuse(endpoint, "the Caddyfile adapts to no apps — loading it would stop every site"));
+    return yield* Effect9.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* Effect11.fail(refuse(endpoint, guard.join("; ")));
+    return yield* Effect9.fail(refuse(endpoint, guard.join("; ")));
   return { digest: configDigest(adapted.config), warnings: adapted.warnings };
 });
 var attributesOf = (endpoint, running, sourceFile) => ({
@@ -934,13 +867,13 @@ var attributesOf = (endpoint, running, sourceFile) => ({
   endpoint,
   ...sourceFile === undefined ? {} : { sourceFile }
 });
-var readLive = (sourceFile) => Effect11.gen(function* () {
+var readLive = (sourceFile) => Effect9.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) => Effect11.gen(function* () {
+var probeLive = (caddyfile, sourceFile) => Effect9.gen(function* () {
   const { endpoint } = yield* CaddyAdminService;
   const running = yield* readRunningConfig();
   if (servesNothing(running))
@@ -949,12 +882,12 @@ var probeLive = (caddyfile, sourceFile) => Effect11.gen(function* () {
   if (caddyfile === undefined) {
     return { attributes, ours: false, unchecked: "the stored Caddyfile is not plain text" };
   }
-  const desired = yield* Effect11.result(desiredConfig({ caddyfile }));
+  const desired = yield* Effect9.result(desiredConfig({ caddyfile }));
   if (Result2.isSuccess(desired)) {
     return { attributes, ours: claimable(running, desired.success.digest) };
   }
   if (isUnreachable(desired.failure))
-    return yield* Effect11.fail(desired.failure);
+    return yield* Effect9.fail(desired.failure);
   const cause = desired.failure;
   return {
     attributes,
@@ -964,7 +897,7 @@ var probeLive = (caddyfile, sourceFile) => Effect11.gen(function* () {
 });
 
 // src/caddy/config-reconcile.ts
-import * as Effect12 from "effect/Effect";
+import * as Effect10 from "effect/Effect";
 import * as Result3 from "effect/Result";
 
 // src/caddy/format-warnings.ts
@@ -976,100 +909,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) => Effect12.gen(function* () {
+var diffConfig = (news, output) => Effect10.gen(function* () {
   const { endpoint } = yield* CaddyAdminService;
   const want = yield* desiredConfig(news);
   const { formatting } = splitFormattingWarning(want.warnings);
   if (formatting.length > 0)
-    yield* Effect12.logWarning(formattingFixLine(endpoint));
+    yield* Effect10.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) => Effect12.gen(function* () {
+var reconcileConfig = (props, authority) => Effect10.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* 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."));
+    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."));
   }
   let warnings = want.warnings;
   const loaded = before !== want.digest;
   if (loaded) {
-    const outcome = yield* Effect12.result(loadCaddyfile(props.caddyfile, props.sourceFile));
+    const outcome = yield* Effect10.result(loadCaddyfile(props.caddyfile, props.sourceFile));
     if (Result3.isFailure(outcome)) {
       const error = outcome.failure;
       if (isUnreachable(error))
-        return yield* Effect12.fail(error);
-      const afterRead = yield* Effect12.result(readLive());
+        return yield* Effect10.fail(error);
+      const afterRead = yield* Effect10.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* Effect12.fail(refuse(endpoint, `Caddy refused the Caddyfile — ${reason}; ${state}`));
+      return yield* Effect10.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* 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 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 { attributes, loaded, warnings };
 });
 
 // src/caddy/config.ts
-var CaddyConfig = guardDuplicateIds(Resource("Caddy.Config", {
+var CaddyConfig = Resource("Caddy.Config", {
   defaultRemovalPolicy: "retain"
-}));
-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* () {
+});
+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* () {
   const admin = yield* CaddyAdminService;
   const transportLayer = yield* CaddyAdminTransport;
-  const probe = (caddyfile, sourceFile) => Effect13.flatMap(probeLive(caddyfile, sourceFile), (found) => {
+  const probe = (caddyfile, sourceFile) => Effect11.flatMap(probeLive(caddyfile, sourceFile), (found) => {
     if (found === undefined)
-      return Effect13.succeed(undefined);
+      return Effect11.succeed(undefined);
     if (found.ours)
-      return Effect13.succeed(found.attributes);
+      return Effect11.succeed(found.attributes);
     const unowned = Unowned2(found.attributes);
-    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 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 CaddyConfig.Provider.of({
-    list: () => Effect13.succeed([]),
-    read: ({ olds, output }) => Effect13.gen(function* () {
+    list: () => Effect11.succeed([]),
+    read: ({ olds, output }) => Effect11.gen(function* () {
       return output === undefined ? yield* probe(resolvedString(olds, "caddyfile"), resolvedString(olds, "sourceFile")) : yield* readLive(resolvedString(olds, "sourceFile"));
-    }).pipe(Effect13.provide(transportLayer), Effect13.catchIf(isUnreachable, planWithoutCaddy(admin, undefined))),
+    }).pipe(Effect11.provide(transportLayer), Effect11.catchIf(isUnreachable, planWithoutCaddy(admin, undefined))),
     diff: ({ news, output }) => {
       if (output === undefined)
-        return Effect13.succeed(undefined);
+        return Effect11.succeed(undefined);
       const update = planWithoutCaddy(admin, { action: "update" });
       if (isResolved(news)) {
-        return diffConfig(news, output).pipe(Effect13.provide(transportLayer), Effect13.catchIf(isUnreachable, update));
+        return diffConfig(news, output).pipe(Effect11.provide(transportLayer), Effect11.catchIf(isUnreachable, update));
       }
       const caddyfile = resolvedString(news, "caddyfile");
       if (caddyfile === undefined)
-        return Effect13.succeed(undefined);
-      return Effect13.as(diffConfig({ caddyfile }, output), { action: "update" }).pipe(Effect13.provide(transportLayer), Effect13.catchIf(isUnreachable, update));
+        return Effect11.succeed(undefined);
+      return Effect11.as(diffConfig({ caddyfile }, output), { action: "update" }).pipe(Effect11.provide(transportLayer), Effect11.catchIf(isUnreachable, update));
     },
-    reconcile: ({ fqn, news, output }) => Effect13.gen(function* () {
+    reconcile: ({ fqn, news, output }) => Effect11.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(Effect13.provide(transportLayer));
+      const applied = yield* reconcileConfig(news, { takeOver, ...stored }).pipe(Effect11.provide(transportLayer));
       const { formatting, rest } = splitFormattingWarning(applied.warnings);
       if (formatting.length > 0) {
-        yield* Effect13.logWarning(formattingFixLine(admin.endpoint));
+        yield* Effect11.logWarning(formattingFixLine(admin.endpoint));
       }
       for (const warning of rest) {
-        yield* Effect13.logWarning(`Caddy.Config at ${admin.endpoint}: ${warning}`);
+        yield* Effect11.logWarning(`Caddy.Config at ${admin.endpoint}: ${warning}`);
       }
       return applied.attributes;
     }),
-    delete: () => Effect13.void
+    delete: () => Effect11.void
   });
 }));
 // src/caddy/format.ts
-import * as Effect14 from "effect/Effect";
+import * as Effect12 from "effect/Effect";
 import * as Stream from "effect/Stream";
 import * as ChildProcess from "effect/process/ChildProcess";
 import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
@@ -1096,7 +1029,7 @@ class CaddyFmtFailed extends Error {
     this.name = "CaddyFmtFailed";
   }
 }
-var formatCaddyfile = (text, options = {}) => Effect14.gen(function* () {
+var formatCaddyfile = (text, options = {}) => Effect12.gen(function* () {
   const binaryPath = options.binaryPath ?? DEFAULT_CADDY_BINARY;
   const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
   const input = new TextEncoder().encode(text);
@@ -1105,13 +1038,13 @@ var formatCaddyfile = (text, options = {}) => Effect14.gen(function* () {
     stderr: "pipe",
     stdin: Stream.make(input),
     stdout: "pipe"
-  }).pipe(spawner.spawn, Effect14.flatMap((child) => Effect14.all({
+  }).pipe(spawner.spawn, Effect12.flatMap((child) => Effect12.all({
     exitCode: child.exitCode,
-    stderr: child.stderr.pipe(Stream.decodeText, Stream.mkString, Effect14.map((out) => out.trim())),
+    stderr: child.stderr.pipe(Stream.decodeText, Stream.mkString, Effect12.map((out) => out.trim())),
     stdout: child.stdout.pipe(Stream.decodeText, Stream.mkString)
-  }, { concurrency: "unbounded" })), Effect14.scoped, Effect14.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect14.fail(new CaddyFmtNotFound(binaryPath, error)) : Effect14.fail(error)));
+  }, { concurrency: "unbounded" })), Effect12.scoped, Effect12.catchTag("PlatformError", (error) => error.reason._tag === "NotFound" ? Effect12.fail(new CaddyFmtNotFound(binaryPath, error)) : Effect12.fail(error)));
   if (result4.exitCode !== 0) {
-    return yield* Effect14.fail(new CaddyFmtFailed(binaryPath, result4.exitCode, result4.stderr));
+    return yield* Effect12.fail(new CaddyFmtFailed(binaryPath, result4.exitCode, result4.stderr));
   }
   return result4.stdout;
 });
@@ -1182,7 +1115,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 Effect16 from "effect/Effect";
+import * as Effect14 from "effect/Effect";
 import * as RemovalPolicy from "alchemy/RemovalPolicy";
 
 // src/launchd/host-file.ts
@@ -1190,7 +1123,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 Effect15 from "effect/Effect";
+import * as Effect13 from "effect/Effect";
 
 // src/launchd/file-identity.ts
 var sameEntry = (a, b) => {
@@ -1385,10 +1318,10 @@ var deleteFile = (runner, output) => removeWholeFile(runner, output, refuse3);
 
 // src/launchd/host-file.ts
 var HostFile = Resource2("Host.File");
-var HostFileProvider = () => Provider2.effect(HostFile, Effect15.gen(function* () {
+var HostFileProvider = () => Provider2.effect(HostFile, Effect13.gen(function* () {
   const runner = yield* HostRunnerService;
   return HostFile.Provider.of({
-    list: () => Effect15.succeed([]),
+    list: () => Effect13.succeed([]),
     read: ({ olds, output }) => lift(async () => {
       const found = await readFileAttributes(runner, olds.path);
       if (found === undefined)
@@ -1402,19 +1335,19 @@ var HostFileProvider = () => Provider2.effect(HostFile, Effect15.gen(function* (
         return lift(() => diffFile(runner, news, output));
       const path = resolvedString(news, "path");
       if (path === undefined || path === output.path)
-        return Effect15.succeed(undefined);
+        return Effect13.succeed(undefined);
       return lift(async () => await oneFile(runner, path, output.path) === true ? undefined : { action: "replace" });
     },
-    reconcile: ({ fqn, instanceId, news, output }) => Effect15.flatMap(adoptsAtApply({ fqn, instanceId, output }), (adopt) => lift(() => reconcileFile(runner, news, output, adopt))),
+    reconcile: ({ fqn, instanceId, news, output }) => Effect13.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) => Effect16.gen(function* () {
+var caddyWithFile = (id, props) => Effect14.gen(function* () {
   const found = configProblems({ caddyfile: props.caddyfile, sourceFile: props.path });
   if (found.length > 0) {
-    return yield* Effect16.fail(new Error(`caddyWithFile ${id}: ${found.join("; ")}`));
+    return yield* Effect14.fail(new Error(`caddyWithFile ${id}: ${found.join("; ")}`));
   }
   const file = yield* HostFile(`${id}-file`, {
     content: props.caddyfile,
@@ -1444,5 +1377,5 @@ export {
   verifierProblems
 };
 
-//# debugId=E80D7FC971F2355764756E2164756E21
+//# debugId=A4890D1A8DCAD67064756E2164756E21
 //# sourceMappingURL=index.js.map