@praxisjs/decorators 0.4.3 → 0.6.0

package/src/__tests__/memo.test.ts

@@ -4,87 +4,205 @@ import { signal } from "@praxisjs/core/internal";
 import { Memo } from "../functions/memo";
 
 function mockCtx(name: string) {
-  return { name, kind: "method" as const } as ClassMethodDecoratorContext;
+  const initializers: Array<(this: object) => void> = [];
+  return {
+    name,
+    kind: "method" as const,
+    addInitializer(fn: (this: object) => void) {
+      initializers.push(fn);
+    },
+    runInitializers(instance: object) {
+      initializers.forEach((fn) => { fn.call(instance); });
+    },
+  } as unknown as ClassMethodDecoratorContext & { runInitializers(instance: object): void };
 }
 
 describe("Memo", () => {
   it("returns the computed value", () => {
     const fn = vi.fn((x: unknown) => (x as number) * 2);
-    const wrapped = Memo()(fn, mockCtx("double"));
+    const ctx = mockCtx("double");
+    Memo()(fn, ctx);
+
     const obj = {};
-    expect(wrapped.call(obj, 5)).toBe(10);
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).double;
+
+    expect(method(5)).toBe(10);
   });
 
   it("caches result for same args — calls original only once", () => {
     const fn = vi.fn((x: unknown) => (x as number) + 1);
-    const wrapped = Memo()(fn, mockCtx("inc"));
+    const ctx = mockCtx("inc");
+    Memo()(fn, ctx);
+
     const obj = {};
-    wrapped.call(obj, 3);
-    wrapped.call(obj, 3);
-    wrapped.call(obj, 3);
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).inc;
+
+    method(3);
+    method(3);
+    method(3);
     expect(fn).toHaveBeenCalledTimes(1);
   });
 
   it("computes separately for different args", () => {
     const fn = vi.fn((x: unknown) => (x as number) * 10);
-    const wrapped = Memo()(fn, mockCtx("mul"));
+    const ctx = mockCtx("mul");
+    Memo()(fn, ctx);
+
     const obj = {};
-    expect(wrapped.call(obj, 2)).toBe(20);
-    expect(wrapped.call(obj, 3)).toBe(30);
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).mul;
+
+    expect(method(2)).toBe(20);
+    expect(method(3)).toBe(30);
     expect(fn).toHaveBeenCalledTimes(2);
   });
 
   it("is per-instance — different instances have separate caches", () => {
     const fn = vi.fn(() => Math.random());
-    const wrapped = Memo()(fn, mockCtx("rand"));
+    const ctx = mockCtx("rand");
+    Memo()(fn, ctx);
+
     const a = {};
     const b = {};
-    const v1 = wrapped.call(a);
-    const v2 = wrapped.call(b);
+    ctx.runInitializers(a);
+    ctx.runInitializers(b);
+
+    const methodA = (a as Record<string, () => unknown>).rand;
+    const methodB = (b as Record<string, () => unknown>).rand;
+    const v1 = methodA();
+    const v2 = methodB();
     expect(fn).toHaveBeenCalledTimes(2);
     expect(v1).not.toBe(v2); // different random values per instance
   });
 
   it("serializes no-args calls with __no_args__ key", () => {
     const fn = vi.fn(() => 42);
-    const wrapped = Memo()(fn, mockCtx("noop"));
+    const ctx = mockCtx("noop");
+    Memo()(fn, ctx);
+
     const obj = {};
-    wrapped.call(obj);
-    wrapped.call(obj);
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, () => unknown>).noop;
+
+    method();
+    method();
     expect(fn).toHaveBeenCalledTimes(1);
   });
 
   it("serializes object args via JSON.stringify", () => {
     const fn = vi.fn((o: unknown) => JSON.stringify(o));
-    const wrapped = Memo()(fn, mockCtx("obj"));
+    const ctx = mockCtx("obj");
+    Memo()(fn, ctx);
+
     const obj = {};
-    wrapped.call(obj, { a: 1 });
-    wrapped.call(obj, { a: 1 }); // same key
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).obj;
+
+    method({ a: 1 });
+    method({ a: 1 }); // same key
     expect(fn).toHaveBeenCalledTimes(1);
   });
 
   it("re-evaluates when a reactive signal read inside the method changes", () => {
     const s = signal(1);
     const fn = vi.fn(() => s() * 10);
-    const wrapped = Memo()(fn, mockCtx("reactive"));
+    const ctx = mockCtx("reactive");
+    Memo()(fn, ctx);
+
     const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, () => unknown>).reactive;
 
-    expect(wrapped.call(obj)).toBe(10);
+    expect(method()).toBe(10);
     expect(fn).toHaveBeenCalledTimes(1);
 
     s.set(5);
     // The computed tracks s() — next read triggers recomputation
-    expect(wrapped.call(obj)).toBe(50);
+    expect(method()).toBe(50);
     expect(fn).toHaveBeenCalledTimes(2);
   });
 
   it("serializes symbol args via toString()", () => {
     const fn = vi.fn((s: unknown) => String(s));
-    const wrapped = Memo()(fn, mockCtx("sym"));
+    const ctx = mockCtx("sym");
+    Memo()(fn, ctx);
+
     const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).sym;
+
     const sym = Symbol("test");
-    wrapped.call(obj, sym);
-    wrapped.call(obj, sym);
+    method(sym);
+    method(sym);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("circular object argument does not crash — falls back to stable identity key", () => {
+    const fn = vi.fn((o: unknown) => o);
+    const ctx = mockCtx("circular");
+    Memo()(fn, ctx);
+
+    const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).circular;
+
+    // Create a circular reference
+    const circ: Record<string, unknown> = {};
+    circ.self = circ;
+
+    expect(() => method(circ)).not.toThrow();
+    // Calling again with the same object should hit cache (not call fn again)
+    method(circ);
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("two circular objects produce different cache keys", () => {
+    const fn = vi.fn((o: unknown) => o);
+    const ctx = mockCtx("circular2");
+    Memo()(fn, ctx);
+
+    const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).circular2;
+
+    const a: Record<string, unknown> = {};
+    a.self = a;
+    const b: Record<string, unknown> = {};
+    b.self = b;
+
+    method(a);
+    method(b);
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("undefined vs null as arguments produce different cache keys", () => {
+    const fn = vi.fn((x: unknown) => x);
+    const ctx = mockCtx("nullUndef");
+    Memo()(fn, ctx);
+
+    const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).nullUndef;
+
+    method(undefined);
+    method(null);
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("BigInt argument does not crash JSON.stringify path", () => {
+    const fn = vi.fn((x: unknown) => x);
+    const ctx = mockCtx("bigint");
+    Memo()(fn, ctx);
+
+    const obj = {};
+    ctx.runInitializers(obj);
+    const method = (obj as Record<string, (...a: unknown[]) => unknown>).bigint;
+
+    // BigInt is a non-object, non-symbol primitive — goes through String() path
+    expect(() => method(BigInt(42))).not.toThrow();
+    method(BigInt(42));
     expect(fn).toHaveBeenCalledTimes(1);
   });
 });

package/src/__tests__/properties.test.ts

@@ -5,6 +5,7 @@ import { signal, computed } from "@praxisjs/core/internal";
 
 import { Watch } from "../functions/watch";
 import { When } from "../functions/when";
+import { Compose } from "../properties/compose";
 import { Computed } from "../properties/computed";
 import { History } from "../properties/history";
 import { Prop } from "../properties/prop";
@@ -723,3 +724,235 @@ describe("Watch decorator — reading computed values", () => {
     expect(handler).toHaveBeenCalledTimes(1);
   });
 });
+
+// ── Watch — additional new tests ──────────────────────────────────────────────
+
+describe("Watch decorator — new cases", () => {
+  it("NaN → NaN does NOT fire (Object.is semantics)", () => {
+    const { ctx, run } = methodCtx("onNaN");
+    const handler = vi.fn();
+    Watch("nanProp" as never)(handler, ctx as unknown as ClassMethodDecoratorContext);
+
+    const s = signal<number>(NaN);
+    const instance = new TestComponent();
+    Object.defineProperty(instance, "nanProp", { get: () => s(), configurable: true });
+    run(instance);
+    (instance as unknown as { onMount: () => void }).onMount?.();
+
+    s.set(NaN); // Object.is(NaN, NaN) === true → no change
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it("watch callback that throws does not crash the effect system", () => {
+    const { ctx, run } = methodCtx("onThrow");
+    const throwingHandler = vi.fn(() => { throw new Error("handler error"); });
+    Watch("tProp" as never)(throwingHandler, ctx as unknown as ClassMethodDecoratorContext);
+
+    const s = signal(0);
+    const instance = new TestComponent();
+    Object.defineProperty(instance, "tProp", { get: () => s(), configurable: true });
+    run(instance);
+    (instance as unknown as { onMount: () => void }).onMount?.();
+
+    // Even if the handler throws, the signal change shouldn't crash the effect framework
+    // The throw propagates from the effect, so we catch it here
+    expect(() => { s.set(1); }).toThrow("handler error");
+    // The system should still be intact — further calls are not tested for recovery
+    expect(throwingHandler).toHaveBeenCalledTimes(1);
+  });
+
+  it("multiple @Watch decorators on different methods both fire independently", () => {
+    const { ctx: ctxA, run: runA } = methodCtx("onA");
+    const { ctx: ctxB, run: runB } = methodCtx("onB");
+    const handlerA = vi.fn();
+    const handlerB = vi.fn();
+    Watch("propA" as never)(handlerA, ctxA as unknown as ClassMethodDecoratorContext);
+    Watch("propB" as never)(handlerB, ctxB as unknown as ClassMethodDecoratorContext);
+
+    const sa = signal(0);
+    const sb = signal(0);
+    const instance = new TestComponent();
+    Object.defineProperty(instance, "propA", { get: () => sa(), configurable: true });
+    Object.defineProperty(instance, "propB", { get: () => sb(), configurable: true });
+    runA(instance);
+    runB(instance);
+    (instance as unknown as { onMount: () => void }).onMount?.();
+
+    sa.set(1);
+    expect(handlerA).toHaveBeenCalledTimes(1);
+    expect(handlerB).not.toHaveBeenCalled();
+
+    sb.set(1);
+    expect(handlerA).toHaveBeenCalledTimes(1);
+    expect(handlerB).toHaveBeenCalledTimes(1);
+  });
+});
+
+// ── When — additional new tests ───────────────────────────────────────────────
+
+describe("When decorator — new cases", () => {
+  function methodCtxFor(name: string) {
+    const initializers: Array<(this: unknown) => void> = [];
+    return {
+      ctx: {
+        name,
+        kind: "method" as const,
+        addInitializer(fn: (this: unknown) => void) {
+          initializers.push(fn);
+        },
+      } as ClassMethodDecoratorContext,
+      run(instance: unknown) {
+        initializers.forEach((fn) => { fn.call(instance); });
+      },
+    };
+  }
+
+  it("@When fires only once — first truthy value; subsequent truthy values are ignored", () => {
+    const { ctx, run } = methodCtxFor("onToggle");
+    const handler = vi.fn();
+    When("toggle")(handler, ctx as unknown as ClassMethodDecoratorContext);
+
+    const s = signal<number | null>(null);
+    const instance = new TestComponent();
+    (instance as unknown as Record<string, unknown>).toggle = s;
+    run(instance);
+    (instance as unknown as { onMount: () => void }).onMount?.();
+
+    s.set(1);    // truthy → fires (first and only time)
+    s.set(null); // falsy
+    s.set(2);    // truthy again — but when() has already disposed itself
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith(1);
+  });
+
+  it("@When callback that throws — onUnmount cleanup still works", () => {
+    const { ctx, run } = methodCtxFor("onThrowWhen");
+    const throwingHandler = vi.fn(() => { throw new Error("when error"); });
+    When("whenProp")(throwingHandler, ctx as unknown as ClassMethodDecoratorContext);
+
+    const s = signal<number | null>(null);
+    const instance = new TestComponent();
+    (instance as unknown as Record<string, unknown>).whenProp = s;
+    run(instance);
+    (instance as unknown as { onMount: () => void }).onMount?.();
+
+    // Triggering truthy fires handler which throws
+    expect(() => { s.set(1); }).toThrow("when error");
+
+    // onUnmount should still work without crashing
+    expect(() => {
+      (instance as unknown as { onUnmount: () => void }).onUnmount?.();
+    }).not.toThrow();
+  });
+});
+
+// ── State — additional new tests ──────────────────────────────────────────────
+
+describe("State decorator — new cases", () => {
+  it("two @State fields can be set independently without cross-contamination", () => {
+    const { ctx: ctxX, run: runX } = fieldCtx("x");
+    const { ctx: ctxY, run: runY } = fieldCtx("y");
+    State()(undefined, ctxX);
+    State()(undefined, ctxY);
+
+    const instance = new TestComponent();
+    (instance as unknown as Record<string, unknown>).x = 10;
+    (instance as unknown as Record<string, unknown>).y = 20;
+    runX(instance);
+    runY(instance);
+
+    (instance as unknown as Record<string, unknown>).x = 99;
+    expect((instance as unknown as Record<string, unknown>).x).toBe(99);
+    expect((instance as unknown as Record<string, unknown>).y).toBe(20);
+
+    (instance as unknown as Record<string, unknown>).y = 77;
+    expect((instance as unknown as Record<string, unknown>).x).toBe(99);
+    expect((instance as unknown as Record<string, unknown>).y).toBe(77);
+  });
+
+  it("setting @State to undefined works (signal stores undefined)", () => {
+    const { ctx, run } = fieldCtx("maybeVal");
+    State()(undefined, ctx);
+
+    const instance = new TestComponent();
+    (instance as unknown as Record<string, unknown>).maybeVal = "initial";
+    run(instance);
+
+    (instance as unknown as Record<string, unknown>).maybeVal = undefined;
+    expect((instance as unknown as Record<string, unknown>).maybeVal).toBeUndefined();
+  });
+});
+
+// ── Prop — additional new tests ───────────────────────────────────────────────
+
+describe("Prop decorator — new cases", () => {
+  it("function prop that throws — getter propagates the error", () => {
+    const { ctx, run } = fieldCtx("dynProp");
+    Prop()(undefined, ctx);
+
+    const throwingFn = () => { throw new Error("prop error"); };
+    const instance = new TestComponent({ dynProp: throwingFn });
+    run(instance);
+
+    expect(() => (instance as unknown as Record<string, unknown>).dynProp).toThrow("prop error");
+  });
+
+  it("undefined passed explicitly vs key not present — both fall back to default", () => {
+    const { ctx: ctx1, run: run1 } = fieldCtx("optA");
+    const { ctx: ctx2, run: run2 } = fieldCtx("optB");
+    Prop()(undefined, ctx1);
+    Prop()(undefined, ctx2);
+
+    // Case 1: key explicitly set to undefined in rawProps
+    const instance1 = new TestComponent({ optA: undefined });
+    (instance1 as unknown as Record<string, unknown>).optA = "default-a";
+    run1(instance1);
+    // undefined from rawProps — Prop checks `!== undefined`, so falls back to default
+    expect((instance1 as unknown as Record<string, unknown>).optA).toBe("default-a");
+
+    // Case 2: key not present in rawProps at all
+    const instance2 = new TestComponent({});
+    (instance2 as unknown as Record<string, unknown>).optB = "default-b";
+    run2(instance2);
+    expect((instance2 as unknown as Record<string, unknown>).optB).toBe("default-b");
+  });
+});
+
+// ── Compose — additional new tests ────────────────────────────────────────────
+
+describe("@Compose decorator — new cases", () => {
+  it("setup() that throws — field access on the instance throws", () => {
+    class ThrowingComposable {
+      setup(): Record<string, unknown> {
+        throw new Error("setup failed");
+      }
+    }
+
+    const { ctx, run } = fieldCtx("throwing");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(() => {
+      const instance = new TestComponent();
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      Compose(ThrowingComposable as any)(undefined, ctx);
+      run(instance);
+    }).toThrow("setup failed");
+  });
+
+  it("string argument resolution where the instance property is undefined", () => {
+    class ArgComposable {
+      constructor(private val: unknown) {}
+      setup() { return { resolved: this.val }; }
+    }
+
+    const { ctx, run } = fieldCtx("strArgUndef");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    Compose(ArgComposable as any, "missingProp")(undefined, ctx);
+
+    const instance = new TestComponent();
+    // missingProp is not set on instance — resolves to undefined
+    run(instance);
+
+    const view = (instance as unknown as Record<string, unknown>).strArgUndef as Record<string, unknown>;
+    expect(view.resolved).toBeUndefined();
+  });
+});

package/src/__tests__/resource.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi } from "vitest";
+
+import { Resource } from "../properties/resource";
+
+function makeFieldCtx(name: string) {
+  const initializers: Array<(this: unknown) => void> = [];
+  return {
+    ctx: {
+      name,
+      kind: "field" as const,
+      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
+    } as ClassFieldDecoratorContext,
+    run(instance: unknown) { initializers.forEach((fn) => { fn.call(instance); }); },
+  };
+}
+
+describe("@Resource", () => {
+  it("binds a Resource object to the field", () => {
+    const { ctx, run } = makeFieldCtx("users");
+    Resource(() => Promise.resolve([]))(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.users as Record<string, unknown>;
+    expect(typeof r.data).toBe("function");
+    expect(typeof r.pending).toBe("function");
+    expect(typeof r.error).toBe("function");
+    expect(typeof r.status).toBe("function");
+    expect(typeof r.refetch).toBe("function");
+    expect(typeof r.cancel).toBe("function");
+    expect(typeof r.mutate).toBe("function");
+  });
+
+  it("starts in pending state when immediate=true (default)", () => {
+    const { ctx, run } = makeFieldCtx("data");
+    Resource(() => new Promise(() => {}))(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.data as { pending: () => boolean; status: () => string };
+    expect(r.pending()).toBe(true);
+    expect(r.status()).toBe("pending");
+  });
+
+  it("starts idle when immediate=false", () => {
+    const { ctx, run } = makeFieldCtx("data");
+    Resource(() => Promise.resolve(42), { immediate: false })(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.data as { status: () => string; pending: () => boolean };
+    expect(r.status()).toBe("idle");
+    expect(r.pending()).toBe(false);
+  });
+
+  it("resolves data asynchronously", async () => {
+    const { ctx, run } = makeFieldCtx("items");
+    Resource(() => Promise.resolve([1, 2, 3]))(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.items as { data: () => unknown; status: () => string };
+    await vi.waitFor(() => r.status() === "success");
+    expect(r.data()).toEqual([1, 2, 3]);
+  });
+
+  it("sets error state on rejection", async () => {
+    const { ctx, run } = makeFieldCtx("items");
+    Resource(() => Promise.reject(new Error("fetch failed")))(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.items as { error: () => Error | null; status: () => string };
+    await new Promise((res) => setTimeout(res, 0));
+    expect(r.status()).toBe("error");
+    expect((r.error() as Error).message).toBe("fetch failed");
+  });
+
+  it("each instance gets its own resource", () => {
+    const { ctx, run } = makeFieldCtx("r");
+    Resource(() => Promise.resolve(0))(undefined, ctx);
+    const a: Record<string, unknown> = {};
+    const b: Record<string, unknown> = {};
+    run(a);
+    run(b);
+    expect(a.r).not.toBe(b.r);
+  });
+
+  it("mutate() updates data immediately", async () => {
+    const { ctx, run } = makeFieldCtx("r");
+    Resource(() => Promise.resolve(1))(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.r as { mutate: (v: number) => void; data: () => number; status: () => string };
+    r.mutate(99);
+    expect(r.data()).toBe(99);
+    expect(r.status()).toBe("success");
+  });
+
+  it("cancel() stops a pending fetch", async () => {
+    const { ctx, run } = makeFieldCtx("r");
+    Resource(() => new Promise(() => {}))(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.r as { cancel: () => void; status: () => string };
+    r.cancel();
+    expect(r.status()).toBe("idle");
+  });
+
+  it("uses initialData option", () => {
+    const { ctx, run } = makeFieldCtx("r");
+    Resource(() => Promise.resolve("new"), { initialData: "default", immediate: false })(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.r as { data: () => string };
+    expect(r.data()).toBe("default");
+  });
+
+  it("cancel() called when not pending — no-op, no crash", () => {
+    const { ctx, run } = makeFieldCtx("r");
+    Resource(() => Promise.resolve(42), { immediate: false })(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.r as { cancel: () => void; status: () => string };
+    // Not pending (immediate=false → idle)
+    expect(r.status()).toBe("idle");
+    expect(() => r.cancel()).not.toThrow();
+    expect(r.status()).toBe("idle");
+  });
+
+  it("refetch() called after successful load — re-fetches", async () => {
+    let callCount = 0;
+    const { ctx, run } = makeFieldCtx("r");
+    Resource(() => Promise.resolve(++callCount))(undefined, ctx);
+    const instance: Record<string, unknown> = {};
+    run(instance);
+    const r = instance.r as { refetch: () => void; data: () => number; status: () => string };
+
+    await vi.waitFor(() => r.status() === "success");
+    expect(r.data()).toBe(1);
+
+    r.refetch();
+    await vi.waitFor(() => r.status() === "success" && r.data() === 2);
+    expect(callCount).toBe(2);
+  });
+});

package/src/__tests__/slot.test.ts

@@ -61,6 +61,19 @@ describe("initSlots / getSlot", () => {
     initSlots(instance, [null, el, undefined]);
     expect(getSlot(instance, "default")).toEqual([el]);
   });
+
+  it("appends to existing named slot when same slot name appears twice", () => {
+    const instance = {};
+    const a = document.createElement("div");
+    a.setAttribute("slot", "header");
+    const b = document.createElement("div");
+    b.setAttribute("slot", "header");
+    initSlots(instance, [a, b]);
+    const headerSlot = getSlot(instance, "header");
+    expect(headerSlot).toHaveLength(2);
+    expect(headerSlot[0]).toBe(a);
+    expect(headerSlot[1]).toBe(b);
+  });
 });
 
 // ── Slot decorator ───────────────────────────────────────────────────────────
@@ -116,6 +129,31 @@ describe("Slot decorator", () => {
     expect(slot[0]).toBe(el);
   });
 
+  it("skips warn on direct assignment in production mode", () => {
+    class MyComp extends StatefulComponent {
+      render() { return null; }
+    }
+
+    const initializers: Array<(this: unknown) => void> = [];
+    const ctx = {
+      name: "default",
+      kind: "field" as const,
+      addInitializer(fn: (this: unknown) => void) { initializers.push(fn); },
+    } as ClassFieldDecoratorContext<StatefulComponent>;
+
+    Slot()(undefined, ctx);
+
+    const instance = new MyComp() as unknown as Record<string, unknown>;
+    initializers.forEach((fn) => { fn.call(instance); });
+
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    vi.stubEnv("NODE_ENV", "production");
+    (instance as Record<string, unknown>).default = "bad";
+    expect(warn).not.toHaveBeenCalled();
+    vi.unstubAllEnvs();
+    warn.mockRestore();
+  });
+
   it("warns on direct assignment in non-production", () => {
     class MyComp extends StatefulComponent {
       render() { return null; }