@homeflare/alchemy 0.59.0 → 0.61.0

package/patches/alchemy@2.0.0-beta.81.patch

@@ -0,0 +1,147 @@
+diff --git a/lib/Resource.d.ts b/lib/Resource.d.ts
+index 07b92ae346b5f16475e8162e6d72284fceb8ce1c..868e8d1b6b23dbdfd558e1ff03a535c1be70801c 100644
+--- a/lib/Resource.d.ts
++++ b/lib/Resource.d.ts
+@@ -229,6 +229,23 @@ export declare class MissingImplementationError extends MissingImplementationErr
+ }> {
+ }
+ export declare const missingImplementation: (type: string, id: string) => MissingImplementationError;
++declare const DuplicateResourceIdError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
++    readonly _tag: "DuplicateResourceIdError";
++} & Readonly<A>;
++/**
++ * HOMEFLARE PATCH (homeflare-kit PR superseding #468) — see Resource.ts for the full comment.
++ * A second resource of a DIFFERENT type registered at a logical id an earlier resource
++ * already claimed in the same scope (namespace + id, i.e. the same FQN).
++ */
++export declare class DuplicateResourceIdError extends DuplicateResourceIdError_base<{
++    message: string;
++    fqn: string;
++    /** The type that first claimed `fqn`. */
++    firstType: string;
++    /** The different type that tried to claim it again. */
++    secondType: string;
++}> {
++}
+ /**
+  * Creates a resource constructor for a concrete resource type.
+  *
+diff --git a/lib/Resource.js b/lib/Resource.js
+index 71d9a3a4e0784ed09484736677d735c7c77444f8..e3b64e60b29538bfe46b094cfcf755eaea6673e7 100644
+--- a/lib/Resource.js
++++ b/lib/Resource.js
+@@ -4,7 +4,7 @@ import * as Effectable from "effect/Effectable";
+ import * as Layer from "effect/Layer";
+ import * as Option from "effect/Option";
+ import { AdoptPolicy } from "./AdoptPolicy.js";
+-import { toFqn } from "./FQN.js";
++import { toFqn, toPath } from "./FQN.js";
+ import { CurrentNamespace } from "./Namespace.js";
+ import * as Output from "./Output.js";
+ import { Provider } from "./Provider.js";
+@@ -60,6 +60,13 @@ export const isResourceOfType = (value, type) => (typeof value === "object" || t
+  */
+ export class MissingImplementationError extends Data.TaggedError("MissingImplementationError") {
+ }
++/**
++ * HOMEFLARE PATCH (homeflare-kit PR superseding #468) — see Resource.ts for the full comment.
++ * A second resource of a DIFFERENT type registered at a logical id an earlier resource
++ * already claimed in the same scope (namespace + id, i.e. the same FQN).
++ */
++export class DuplicateResourceIdError extends Data.TaggedError("DuplicateResourceIdError") {
++}
+ export const missingImplementation = (type, id) => new MissingImplementationError({
+     type,
+     id,
+@@ -128,7 +135,17 @@ export function Resource(type, options) {
+                     conflictingMode: ambientMode,
+                 }));
+             }
+-            // // TODO(sam): check if props are different and die
++            // HOMEFLARE PATCH: Type, not Props — see Resource.ts for why.
++            if (existing.Type !== type) {
++                return yield* Effect.die(new DuplicateResourceIdError({
++                    message: `REFUSING: duplicate resource id "${fqn}" in scope ` +
++                        `${toPath(namespace).join("/") || "(root)"}: first declared by ` +
++                        `${existing.Type}, again by ${type}`,
++                    fqn,
++                    firstType: existing.Type,
++                    secondType: type,
++                }));
++            }
+             return existing;
+         }
+         const bind = (...args) => typeof args[0] === "string"
+diff --git a/src/Resource.ts b/src/Resource.ts
+index d34c1809b90aba6ff7dc7d3952e3ab87e62e61c1..24b4d4d4d8a26c67e17e761b6b1080d38068f858 100644
+--- a/src/Resource.ts
++++ b/src/Resource.ts
+@@ -5,7 +5,7 @@ import * as Layer from "effect/Layer";
+ import * as Option from "effect/Option";
+ import type { Pipeable } from "effect/Pipeable";
+ import { AdoptPolicy } from "./AdoptPolicy.ts";
+-import { toFqn } from "./FQN.ts";
++import { toFqn, toPath } from "./FQN.ts";
+ import type { Input, InputProps, PropsInput } from "./Input.ts";
+ import { CurrentNamespace, type NamespaceNode } from "./Namespace.ts";
+ import * as Output from "./Output.ts";
+@@ -293,6 +293,30 @@ export class MissingImplementationError extends Data.TaggedError("MissingImpleme
+   id: string;
+ }> {}
+ 
++/**
++ * A second resource of a DIFFERENT type registered (`yield*`ed) at a logical id an earlier
++ * resource already claimed in the same scope (namespace + id, i.e. the same FQN).
++ *
++ * ★ HOMEFLARE PATCH (homeflare-kit PR superseding #468, 2026-10-19). Upstream's own
++ *   idempotent-registration branch below used to return the FIRST-registered resource for ANY
++ *   second `yield*` at an already-claimed FQN — correct for "the same resource read from two
++ *   call sites," but it never compared `Type`, so a second, DIFFERENT resource that merely
++ *   picked the same id silently lost: its props were never written to `stack.resources`, so
++ *   neither `Plan.make` nor any later inspection could tell two different resources ever
++ *   registered. Measured: `NixJobRetirement` and `Caddy.Config` both declaring id `caddy` in
++ *   one stack planned `[caddy] noop` and dropped the retirement entirely. This error, and the
++ *   `Type` check below, close that gap. Only `Type` is compared, not `Props` — see the check's
++ *   own comment for why.
++ */
++export class DuplicateResourceIdError extends Data.TaggedError("DuplicateResourceIdError")<{
++  message: string;
++  fqn: string;
++  /** The type that first claimed `fqn`. */
++  firstType: string;
++  /** The different type that tried to claim it again. */
++  secondType: string;
++}> {}
++
+ export const missingImplementation = (type: string, id: string) =>
+   new MissingImplementationError({
+     type,
+@@ -373,7 +397,27 @@ export function Resource<R extends ResourceLike>(
+             }),
+           );
+         }
+-        // // TODO(sam): check if props are different and die
++        // HOMEFLARE PATCH: the TODO above asked whether PROPS differ; this checks TYPE
++        // instead, which is the question that actually matters. Comparing props would be
++        // wrong — `Platform.ts`'s own tagged resources rewrite Props after first registration
++        // (Platform.ts ~581), and a bare-tag forward reference legitimately registers with
++        // `Props: undefined` until its `.make(...)` Layer builds (MissingImplementationError's
++        // own doc comment above). Type is stable from the resource's very first `yield*` and is
++        // exactly what distinguishes "the same resource, referenced twice" from "two different
++        // resources that picked the same id."
++        if (existing.Type !== type) {
++          return yield* Effect.die(
++            new DuplicateResourceIdError({
++              message:
++                `REFUSING: duplicate resource id "${fqn}" in scope ` +
++                `${toPath(namespace).join("/") || "(root)"}: first declared by ` +
++                `${existing.Type}, again by ${type}`,
++              fqn,
++              firstType: existing.Type,
++              secondType: type,
++            }),
++          );
++        }
+         return existing;
+       }
+       const bind = (

package/patches/alchemy@2.0.0-beta.83.patch

@@ -0,0 +1,149 @@
+diff --git a/lib/Resource.d.ts b/lib/Resource.d.ts
+index 07b92ae..bfd1a13 100644
+--- a/lib/Resource.d.ts
++++ b/lib/Resource.d.ts
+@@ -228,6 +228,24 @@ export declare class MissingImplementationError extends MissingImplementationErr
+     id: string;
+ }> {
+ }
++declare const DuplicateResourceIdError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
++    readonly _tag: "DuplicateResourceIdError";
++} & Readonly<A>;
++/**
++ * HOMEFLARE PATCH (homeflare-kit PR superseding #468; re-cut for alchemy@2.0.0-beta.83) — see
++ * Resource.ts for the full comment.
++ * A second resource of a DIFFERENT type registered at a logical id an earlier resource
++ * already claimed in the same scope (namespace + id, i.e. the same FQN).
++ */
++export declare class DuplicateResourceIdError extends DuplicateResourceIdError_base<{
++    message: string;
++    fqn: string;
++    /** The type that first claimed `fqn`. */
++    firstType: string;
++    /** The different type that tried to claim it again. */
++    secondType: string;
++}> {
++}
+ export declare const missingImplementation: (type: string, id: string) => MissingImplementationError;
+ /**
+  * Creates a resource constructor for a concrete resource type.
+diff --git a/lib/Resource.js b/lib/Resource.js
+index cbc4f09..b57d530 100644
+--- a/lib/Resource.js
++++ b/lib/Resource.js
+@@ -4,7 +4,7 @@ import * as Effectable from "effect/Effectable";
+ import * as Layer from "effect/Layer";
+ import * as Option from "effect/Option";
+ import { AdoptPolicy } from "./AdoptPolicy.js";
+-import { toFqn } from "./FQN.js";
++import { toFqn, toPath } from "./FQN.js";
+ import { CurrentNamespace } from "./Namespace.js";
+ import * as Output from "./Output.js";
+ import { Provider } from "./Provider.js";
+@@ -58,6 +58,14 @@ export const isResourceOfType = (value, type) => (typeof value === "object" || t
+  */
+ export class MissingImplementationError extends Data.TaggedError("MissingImplementationError") {
+ }
++/**
++ * HOMEFLARE PATCH (homeflare-kit PR superseding #468; re-cut for alchemy@2.0.0-beta.83) — see
++ * Resource.ts for the full comment.
++ * A second resource of a DIFFERENT type registered at a logical id an earlier resource
++ * already claimed in the same scope (namespace + id, i.e. the same FQN).
++ */
++export class DuplicateResourceIdError extends Data.TaggedError("DuplicateResourceIdError") {
++}
+ export const missingImplementation = (type, id) => new MissingImplementationError({
+     type,
+     id,
+@@ -126,7 +134,17 @@ export function Resource(type, options) {
+                     conflictingMode: ambientMode,
+                 }));
+             }
+-            // // TODO(sam): check if props are different and die
++            // HOMEFLARE PATCH: Type, not Props — see Resource.ts for why.
++            if (existing.Type !== type) {
++                return yield* Effect.die(new DuplicateResourceIdError({
++                    message: `REFUSING: duplicate resource id "${fqn}" in scope ` +
++                        `${toPath(namespace).join("/") || "(root)"}: first declared by ` +
++                        `${existing.Type}, again by ${type}`,
++                    fqn,
++                    firstType: existing.Type,
++                    secondType: type,
++                }));
++            }
+             return existing;
+         }
+         const bind = (...args) => typeof args[0] === "string"
+diff --git a/src/Resource.ts b/src/Resource.ts
+index c4d0a36..29e5ca7 100644
+--- a/src/Resource.ts
++++ b/src/Resource.ts
+@@ -5,7 +5,7 @@ import * as Layer from "effect/Layer";
+ import * as Option from "effect/Option";
+ import type { Pipeable } from "effect/Pipeable";
+ import { AdoptPolicy } from "./AdoptPolicy.ts";
+-import { toFqn } from "./FQN.ts";
++import { toFqn, toPath } from "./FQN.ts";
+ import type { Input, InputProps, PropsInput } from "./Input.ts";
+ import { CurrentNamespace, type NamespaceNode } from "./Namespace.ts";
+ import * as Output from "./Output.ts";
+@@ -292,6 +292,30 @@ export class MissingImplementationError extends Data.TaggedError("MissingImpleme
+   id: string;
+ }> {}
+ 
++/**
++ * A second resource of a DIFFERENT type registered (`yield*`ed) at a logical id an earlier
++ * resource already claimed in the same scope (namespace + id, i.e. the same FQN).
++ *
++ * ★ HOMEFLARE PATCH (homeflare-kit PR superseding #468, 2026-10-19; re-cut for
++ *   alchemy@2.0.0-beta.83). Upstream's own idempotent-registration branch below used to
++ *   return the FIRST-registered resource for ANY second `yield*` at an already-claimed FQN —
++ *   correct for "the same resource read from two call sites," but it never compared `Type`,
++ *   so a second, DIFFERENT resource that merely picked the same id silently lost: its props
++ *   were never written to `stack.resources`, so neither `Plan.make` nor any later inspection
++ *   could tell two different resources ever registered. Measured: `NixJobRetirement` and
++ *   `Caddy.Config` both declaring id `caddy` in one stack planned `[caddy] noop` and dropped
++ *   the retirement entirely. This error, and the `Type` check below, close that gap. Only
++ *   `Type` is compared, not `Props` — see the check's own comment for why.
++ */
++export class DuplicateResourceIdError extends Data.TaggedError("DuplicateResourceIdError")<{
++  message: string;
++  fqn: string;
++  /** The type that first claimed `fqn`. */
++  firstType: string;
++  /** The different type that tried to claim it again. */
++  secondType: string;
++}> {}
++
+ export const missingImplementation = (type: string, id: string) =>
+   new MissingImplementationError({
+     type,
+@@ -372,7 +396,27 @@ export function Resource<R extends ResourceLike>(
+             }),
+           );
+         }
+-        // // TODO(sam): check if props are different and die
++        // HOMEFLARE PATCH: the TODO above asked whether PROPS differ; this checks TYPE
++        // instead, which is the question that actually matters. Comparing props would be
++        // wrong — `Platform.ts`'s own tagged resources rewrite Props after first registration
++        // (Platform.ts ~581), and a bare-tag forward reference legitimately registers with
++        // `Props: undefined` until its `.make(...)` Layer builds (MissingImplementationError's
++        // own doc comment above). Type is stable from the resource's very first `yield*` and is
++        // exactly what distinguishes "the same resource, referenced twice" from "two different
++        // resources that picked the same id."
++        if (existing.Type !== type) {
++          return yield* Effect.die(
++            new DuplicateResourceIdError({
++              message:
++                `REFUSING: duplicate resource id "${fqn}" in scope ` +
++                `${toPath(namespace).join("/") || "(root)"}: first declared by ` +
++                `${existing.Type}, again by ${type}`,
++              fqn,
++              firstType: existing.Type,
++              secondType: type,
++            }),
++          );
++        }
+         return existing;
+       }
+       const bind = (

package/src/caddy/config.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 { Unowned } from 'alchemy/AdoptPolicy';
@@ -42,7 +40,6 @@ import * as Provider from 'alchemy/Provider';
 import * as Effect from 'effect/Effect';
 import { resolvedString } from '../launchd/host-effect.ts';
 import { adoptEnabled } from '../ownership/adopt.ts';
-import { guardDuplicateIds } from '../scope/guard.ts';
 import { CaddyAdminService, CaddyAdminTransport } from './admin.ts';
 import { isUnreachable } from './caddy-http-client.ts';
 import type { CaddyConfigAttributes, CaddyConfigProps } from './config-form.ts';
@@ -58,11 +55,9 @@ export interface CaddyConfig extends Resource<
   CaddyConfigAttributes
 > {}
 
-export const CaddyConfig = guardDuplicateIds(
-  Resource<CaddyConfig>('Caddy.Config', {
-    defaultRemovalPolicy: 'retain',
-  }),
-);
+export const CaddyConfig = Resource<CaddyConfig>('Caddy.Config', {
+  defaultRemovalPolicy: 'retain',
+});
 
 /**
  * ⚠️ A STOPPED CADDY MUST NOT FAIL THE PLAN THAT BRINGS IT BACK. Its launchd job usually sits in the

package/src/scope/duplicate-id.test.ts

@@ -1,95 +1,154 @@
 /**
- * `claimResourceId` against a minimal `Stack` + `Namespace` context — no real resources, no
- * provider, so these stay fast and pin the registry's own semantics directly. guard.test.ts
- * drives the same cases through a REAL `Alchemy.Stack(...)` with real `Resource()` classes, to
- * prove the wiring in guard.ts, not just this file's logic in isolation.
+ * The regression test for the measured incident (homeflare-mini PR 329): two different
+ * resource types sharing a logical id in one stack, driven through a REAL `Alchemy.Stack(...)`
+ * with real `Resource()` classes over the patched `alchemy` this package's own root
+ * `patchedDependencies` applies (see `../../../patches/alchemy@2.0.0-beta.81.patch`) — the same
+ * shape `litellm/fake-stack.ts` uses for the same reason its own header gives: a diff answer
+ * proves nothing about what the ENGINE actually does; only running it does.
+ *
+ * ⚠️ IF THIS SUITE EVER PASSES WITHOUT THE PATCH APPLIED, THE PATCH IS NOT REACHING THIS
+ *   PACKAGE'S OWN TESTS — re-run `bun install` at the workspace root and re-check
+ *   `patchedDependencies` in the root `package.json`. `patch-check.test.ts` is the test that
+ *   would catch that for a CONSUMER; this file has no equivalent self-check because it would
+ *   just be this file re-asserting itself.
  */
 import { describe, expect, test } from 'bun:test';
+import * as Alchemy from 'alchemy';
 import { push as pushNamespace } from 'alchemy/Namespace';
-import { Stack } from 'alchemy/Stack';
+import type { Resource } from 'alchemy/Resource';
 import * as Effect from 'effect/Effect';
-import { DuplicateResourceIdError, claimResourceId } from './duplicate-id.ts';
+import * as Layer from 'effect/Layer';
+import ownPackage from '../../package.json';
+import { PATCHED_ALCHEMY_VERSION } from './duplicate-id.ts';
 
-/** A bare `Stack` service good enough for `claimResourceId`: only `resources` is ever `yield*`ed. */
-const fakeStack = () => ({ name: 'test', stage: 'test', resources: {}, bindings: {}, actions: {} });
+interface Props {
+  readonly value?: number;
+}
+/** A plain, otherwise-meaningless resource shape — only the `Type` string matters here. */
+interface TestResource extends Resource<string, Props, object> {}
+const testResource = (type: string) => Alchemy.Resource<TestResource>(type);
 
-const withStack = <A, E>(effect: Effect.Effect<A, E, Stack>) =>
-  effect.pipe(Effect.provideService(Stack, fakeStack() as never));
+type StackBody = Effect.Effect<unknown, unknown, unknown>;
 
-describe('claimResourceId', () => {
-  test('a fresh id is claimed without error', async () => {
-    await Effect.runPromise(withStack(claimResourceId('Test.A', 'one')));
+const stack = Alchemy.Stack as unknown as (
+  stackName: string,
+  options: { providers: Layer.Layer<never>; state: ReturnType<typeof Alchemy.inMemoryState> },
+  body: StackBody,
+) => Effect.Effect<{ readonly resources: Record<string, unknown> }, unknown, never>;
+
+const run = (body: StackBody, name: string) =>
+  Effect.runPromiseExit(
+    stack(name, { providers: Layer.empty, state: Alchemy.inMemoryState() }, body).pipe(
+      Effect.provideService(Alchemy.Stage, 'test'),
+      Effect.scoped,
+    ),
+  );
+
+describe('PATCHED_ALCHEMY_VERSION', () => {
+  test('matches this package’s own peer pin, so a bump that forgets to re-cut the patch fails here', () => {
+    expect(PATCHED_ALCHEMY_VERSION).toBe(ownPackage.peerDependencies.alchemy);
   });
+});
 
-  test('the same type re-claiming its own id is fine (idempotent re-reference)', async () => {
-    await Effect.runPromise(
-      withStack(
-        Effect.gen(function* () {
-          yield* claimResourceId('Test.A', 'one');
-          yield* claimResourceId('Test.A', 'one');
-        }),
-      ),
+describe('the patched alchemy, driven through a real Stack', () => {
+  test('two different types sharing an id die naming both', async () => {
+    const Retirement = testResource('Nix.JobRetirement');
+    const Caddy = testResource('Caddy.Config');
+    const exit = await run(
+      Effect.gen(function* () {
+        yield* Retirement('caddy', { value: 1 });
+        yield* Caddy('caddy', { value: 2 });
+      }),
+      'IncidentStack',
+    );
+    expect(exit._tag).toBe('Failure');
+    if (exit._tag !== 'Failure') return;
+    const [reason] = (exit.cause as { reasons: readonly { _tag: string; defect?: unknown }[] })
+      .reasons;
+    expect(reason === undefined ? undefined : reason._tag).toBe('Die');
+    const defect = reason === undefined ? undefined : (reason.defect as { message?: string });
+    expect(defect?.message).toContain(
+      'REFUSING: duplicate resource id "caddy" in scope (root): ' +
+        'first declared by Nix.JobRetirement, again by Caddy.Config',
     );
   });
 
-  test('distinct ids never collide', async () => {
-    await Effect.runPromise(
-      withStack(
-        Effect.gen(function* () {
-          yield* claimResourceId('Test.A', 'one');
-          yield* claimResourceId('Test.B', 'two');
-        }),
-      ),
+  test('the reverse order dies the same way — order never decides the winner', async () => {
+    const Retirement = testResource('Nix.JobRetirement');
+    const Caddy = testResource('Caddy.Config');
+    const exit = await run(
+      Effect.gen(function* () {
+        yield* Caddy('caddy', { value: 2 });
+        yield* Retirement('caddy', { value: 1 });
+      }),
+      'IncidentStackReversed',
     );
+    expect(exit._tag).toBe('Failure');
   });
 
-  test('a second, different type claiming a taken id dies naming both types', async () => {
-    const run = Effect.runPromiseExit(
-      withStack(
-        Effect.gen(function* () {
-          yield* claimResourceId('Nix.JobRetirement', 'caddy');
-          yield* claimResourceId('Caddy.Config', 'caddy');
-        }),
-      ),
+  test('the same type re-registering its own id stays a noop, not a death', async () => {
+    const A = testResource('Test.A');
+    const exit = await run(
+      Effect.gen(function* () {
+        yield* A('shared', { value: 1 });
+        yield* A('shared', { value: 1 });
+      }),
+      'GoodStack',
     );
-    const exit = await run;
-    expect(exit._tag).toBe('Failure');
-    if (exit._tag !== 'Failure') return;
-    const [reason] = exit.cause.reasons;
-    const defect = reason?._tag === 'Die' ? reason.defect : undefined;
-    expect(defect).toBeInstanceOf(DuplicateResourceIdError);
-    const error = defect as DuplicateResourceIdError;
-    expect(error.message).toContain('REFUSING: duplicate resource id "caddy"');
-    expect(error.message).toContain('first declared by Nix.JobRetirement');
-    expect(error.message).toContain('again by Caddy.Config');
-    expect(error.scope).toBe('(root)');
+    expect(exit._tag).toBe('Success');
   });
 
-  test('the same id in a nested namespace is a different scope, so it does not collide', async () => {
-    await Effect.runPromise(
-      withStack(
-        Effect.gen(function* () {
-          yield* claimResourceId('Caddy.Config', 'caddy');
-          yield* pushNamespace('child', claimResourceId('Nix.JobRetirement', 'caddy'));
-        }),
-      ),
+  test('distinct ids never collide', async () => {
+    const A = testResource('Test.A');
+    const B = testResource('Test.B');
+    const exit = await run(
+      Effect.gen(function* () {
+        yield* A('one', { value: 1 });
+        yield* B('two', { value: 2 });
+      }),
+      'DistinctStack',
     );
+    expect(exit._tag).toBe('Success');
   });
 
-  test('two unrelated stacks never see each others claims', async () => {
-    const stackOne = fakeStack();
-    const stackTwo = fakeStack();
-    await Effect.runPromise(
-      claimResourceId('Caddy.Config', 'caddy').pipe(
-        Effect.provideService(Stack, stackOne as never),
-      ),
+  test('the same id in a nested namespace is a different scope', async () => {
+    const A = testResource('Test.A');
+    const B = testResource('Test.B');
+    const exit = await run(
+      Effect.gen(function* () {
+        yield* A('shared', { value: 1 });
+        yield* pushNamespace('child', B('shared', { value: 2 }));
+      }),
+      'NestedStack',
     );
-    // A DIFFERENT stack object claiming the same id with a different type is fine — the
-    // registry is keyed by the Stack instance (see duplicate-id.ts), not the bare fqn string.
-    await Effect.runPromise(
-      claimResourceId('Nix.JobRetirement', 'caddy').pipe(
-        Effect.provideService(Stack, stackTwo as never),
-      ),
+    expect(exit._tag).toBe('Success');
+  });
+
+  test('the thrown defect carries the exact fields DuplicateResourceIdError documents', async () => {
+    const A = testResource('Test.A');
+    const B = testResource('Test.B');
+    const exit = await run(
+      Effect.gen(function* () {
+        yield* A('x', {});
+        yield* B('x', {});
+      }),
+      'ShapeStack',
     );
+    expect(exit._tag).toBe('Failure');
+    if (exit._tag !== 'Failure') return;
+    const [reason] = (exit.cause as { reasons: readonly { defect?: unknown }[] }).reasons;
+    // Not `instanceof DuplicateResourceIdError` — alchemy's patched copy and this package's
+    // export are two separately defined classes with the same `_tag` by construction
+    // (duplicate-id.ts's own header explains why `catchTag` still works across that split).
+    const defect = reason?.defect as {
+      _tag?: string;
+      fqn?: string;
+      firstType?: string;
+      secondType?: string;
+    };
+    expect(defect._tag).toBe('DuplicateResourceIdError');
+    expect(defect.fqn).toBe('x');
+    expect(defect.firstType).toBe('Test.A');
+    expect(defect.secondType).toBe('Test.B');
   });
 });