@adobe/data-lit 0.10.31 → 0.10.33

package/dist/hooks/use-memo.js

@@ -1,13 +1,15 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import { useEffect } from "./use-effect.js";
-import { useState } from "./use-state.js";
+import { equalsShallow } from "@adobe/data/equals-shallow";
+import { Component_stack } from "./component/stack.js";
 export function useMemo(calculateValue, dependencies = []) {
-    const [state, setState] = useState(undefined);
-    let currentValue = state;
-    useEffect(() => {
-        currentValue = calculateValue();
-        setState(currentValue);
-    }, dependencies);
-    return currentValue;
+    const component = Component_stack.active();
+    const hookIndex = component.hookIndex++;
+    const memo = component.hooks[hookIndex];
+    if (memo && equalsShallow(dependencies, memo.dependencies)) {
+        return memo.value;
+    }
+    const value = calculateValue();
+    component.hooks[hookIndex] = { value, dependencies };
+    return value;
 }
 //# sourceMappingURL=use-memo.js.map

package/dist/hooks/use-memo.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-memo.js","sourceRoot":"","sources":["../../src/hooks/use-memo.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,UAAU,OAAO,CAAI,cAAuB,EAAE,eAA0B,EAAE;IAC5E,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAgB,SAAS,CAAC,CAAC;IAC7D,IAAI,YAAY,GAAG,KAAK,CAAC;IAEzB,SAAS,CAAC,GAAG,EAAE;QACX,YAAY,GAAG,cAAc,EAAE,CAAC;QAChC,QAAQ,CAAC,YAAY,CAAC,CAAC;IAC3B,CAAC,EAAE,YAAY,CAAC,CAAC;IAEjB,OAAO,YAAa,CAAC;AACzB,CAAC"}
+{"version":3,"file":"use-memo.js","sourceRoot":"","sources":["../../src/hooks/use-memo.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAOvD,MAAM,UAAU,OAAO,CAAI,cAAuB,EAAE,eAA0B,EAAE;IAC5E,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC;IAC3C,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,EAAE,CAAC;IACxC,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,SAAS,CAAwB,CAAC;IAC/D,IAAI,IAAI,IAAI,aAAa,CAAC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;QACzD,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IACD,MAAM,KAAK,GAAG,cAAc,EAAE,CAAC;IAC/B,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,EAAE,YAAY,EAAoB,CAAC;IACvE,OAAO,KAAK,CAAC;AACjB,CAAC"}

package/dist/hooks/use-observable.d.ts

@@ -1,2 +1,6 @@
 import { Observe } from "@adobe/data/observe";
+/**
+ * Subscribes to `observable` and returns its latest value. Every notification
+ * requests a render, including one that repeats the previous value or reference.
+ */
 export declare function useObservable<T>(observable: Observe<T>): T | undefined;

package/dist/hooks/use-observable.js

@@ -1,13 +1,18 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import { useState } from "./use-state.js";
+import { Component_stack } from "./component/stack.js";
 import { useEffect } from "./use-effect.js";
+import { useRef } from "./use-ref.js";
+/**
+ * Subscribes to `observable` and returns its latest value. Every notification
+ * requests a render, including one that repeats the previous value or reference.
+ */
 export function useObservable(observable) {
-    let [value, setValue] = useState(undefined);
-    useEffect(() => {
-        return observable(newValue => {
-            setValue(value = newValue);
-        });
-    }, [observable]);
-    return value;
+    const component = Component_stack.active();
+    const latest = useRef(undefined);
+    useEffect(() => observable(value => {
+        latest.current = value;
+        component.requestUpdate();
+    }), [observable]);
+    return latest.current;
 }
 //# sourceMappingURL=use-observable.js.map

package/dist/hooks/use-observable.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-observable.js","sourceRoot":"","sources":["../../src/hooks/use-observable.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAG5C,MAAM,UAAU,aAAa,CAAI,UAAsB;IACnD,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAgB,SAAS,CAAC,CAAC;IAC3D,SAAS,CAAC,GAAG,EAAE;QACX,OAAO,UAAU,CAAC,QAAQ,CAAC,EAAE;YACzB,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,CAAC;QAC/B,CAAC,CAAC,CAAC;IACP,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IACjB,OAAO,KAAK,CAAC;AACjB,CAAC"}
+{"version":3,"file":"use-observable.js","sourceRoot":"","sources":["../../src/hooks/use-observable.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAI,UAAsB;IACnD,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC;IAC3C,MAAM,MAAM,GAAG,MAAM,CAAgB,SAAS,CAAC,CAAC;IAChD,SAAS,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE;QAC/B,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,SAAS,CAAC,aAAa,EAAE,CAAC;IAC9B,CAAC,CAAC,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;IAClB,OAAO,MAAM,CAAC,OAAO,CAAC;AAC1B,CAAC"}

package/dist/hooks/use-ref.js

@@ -1,7 +1,8 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import { useState } from "./use-state.js";
+import { Component_stack } from "./component/stack.js";
 export function useRef(initialValue) {
-    const [state] = useState({ current: initialValue });
-    return state;
+    const component = Component_stack.active();
+    const hookIndex = component.hookIndex++;
+    return component.hooks[hookIndex] ??= { current: initialValue };
 }
 //# sourceMappingURL=use-ref.js.map

package/dist/hooks/use-ref.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-ref.js","sourceRoot":"","sources":["../../src/hooks/use-ref.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,UAAU,MAAM,CAAI,YAAe;IACrC,MAAM,CAAC,KAAK,CAAC,GAAG,QAAQ,CAAC,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC,CAAC;IACpD,OAAO,KAAK,CAAC;AACjB,CAAC"}
+{"version":3,"file":"use-ref.js","sourceRoot":"","sources":["../../src/hooks/use-ref.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAEvD,MAAM,UAAU,MAAM,CAAI,YAAe;IACrC,MAAM,SAAS,GAAG,eAAe,CAAC,MAAM,EAAE,CAAC;IAC3C,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,EAAE,CAAC;IACxC,OAAO,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,CAAC;AACpE,CAAC"}

package/dist/hooks/use-window-event.js

@@ -6,6 +6,6 @@ export function useWindowEvent(event, callbackFactory, deps = []) {
     useEffect(() => {
         window.addEventListener(event, callback);
         return () => window.removeEventListener(event, callback);
-    }, [callback]);
+    }, [event, callback]);
 }
 //# sourceMappingURL=use-window-event.js.map

package/dist/hooks/use-window-event.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-window-event.js","sourceRoot":"","sources":["../../src/hooks/use-window-event.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,MAAM,UAAU,cAAc,CAC1B,KAAQ,EACR,eAAqD,EACrD,OAAc,EAAE;IAEhB,MAAM,QAAQ,GAAG,OAAO,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;IAChD,SAAS,CAAC,GAAG,EAAE;QACX,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACzC,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;AACnB,CAAC"}
+{"version":3,"file":"use-window-event.js","sourceRoot":"","sources":["../../src/hooks/use-window-event.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,MAAM,UAAU,cAAc,CAC1B,KAAQ,EACR,eAAqD,EACrD,OAAc,EAAE;IAEhB,MAAM,QAAQ,GAAG,OAAO,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;IAChD,SAAS,CAAC,GAAG,EAAE;QACX,MAAM,CAAC,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACzC,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IAC7D,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC;AAC1B,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-lit",
-  "version": "0.10.31",
+  "version": "0.10.33",
   "description": "Adobe data Lit bindings - hooks, elements, decorators",
   "type": "module",
   "private": false,
@@ -12,7 +12,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@adobe/data": "0.10.31"
+    "@adobe/data": "0.10.33"
   },
   "peerDependencies": {
     "lit": "^3.3.1"
@@ -34,6 +34,6 @@
     "dev": "tsc -b -w",
     "link": "pnpm build && pnpm link --global",
     "test": "vitest --run --passWithNoTests",
-    "typecheck": "tsc -b"
+    "typecheck": "tsc -b && tsc -p tsconfig.test.json"
   }
 }

package/src/decorators/apply-decorator.test.ts

@@ -0,0 +1,37 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it, vi } from "vitest";
+import { applyDecorator } from "./apply-decorator.js";
+
+const double = (_target: unknown, _key: string, descriptor: PropertyDescriptor) => {
+    const original = descriptor.value as (this: unknown) => number;
+    return { ...descriptor, value(this: unknown) { return original.call(this) * 2; } };
+};
+
+describe("applyDecorator", () => {
+    it("decorates a method found on the prototype chain and defines it on the target", () => {
+        class Base { value = 2; get() { return this.value; } }
+        class Derived extends Base {}
+        applyDecorator(Derived.prototype, "get", double);
+        expect(new Derived().get()).toBe(4);
+        expect(new Base().get()).toBe(2);
+        expect(Object.prototype.hasOwnProperty.call(Derived.prototype, "get")).toBe(true);
+    });
+
+    it("decorates an own property and passes target, key, and descriptor", () => {
+        const method = () => 1;
+        const target = { method };
+        const decorator = vi.fn((_target: unknown, _key: string, descriptor: PropertyDescriptor) => descriptor);
+        applyDecorator(target, "method", decorator);
+        expect(decorator).toHaveBeenCalledWith(target, "method", expect.objectContaining({ value: method }));
+    });
+
+    it("defines exactly the descriptor the decorator returns", () => {
+        const target = { method: () => 1 };
+        applyDecorator(target, "method", () => ({ value: 5, enumerable: false, writable: false, configurable: true }));
+        expect(Object.getOwnPropertyDescriptor(target, "method")).toEqual({ value: 5, enumerable: false, writable: false, configurable: true });
+    });
+
+    it("throws when the property is not on the prototype chain", () => {
+        expect(() => applyDecorator({}, "missing", double)).toThrow("Property missing not found in prototype chain");
+    });
+});

package/src/decorators/apply-service-decorators.test.ts

@@ -0,0 +1,53 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { describe, expect, it, vi } from "vitest";
+import { applyServiceDecorators } from "./apply-service-decorators.js";
+import { Component_stack } from "../hooks/component/stack.js";
+import { useState } from "../hooks/use-state.js";
+
+function createElement(render: (this: unknown) => unknown, service?: unknown) {
+    return Object.assign(new EventTarget(), {
+        service,
+        hookIndex: 0,
+        hooks: [] as unknown[],
+        updatedListeners: new Set<() => void>(),
+        requestUpdate: vi.fn(),
+        isConnected: true,
+        render,
+    });
+}
+
+describe("applyServiceDecorators", () => {
+    it("renders null without calling render while there is no service", () => {
+        const render = vi.fn(() => "rendered");
+        const element = createElement(render);
+        applyServiceDecorators(element);
+        expect(element.render()).toBeNull();
+        expect(render).not.toHaveBeenCalled();
+    });
+
+    it("renders with hooks once a service is set", () => {
+        const element = createElement(function (this: unknown) {
+            expect(Component_stack.active()).toBe(this);
+            return useState("value")[0];
+        }, {});
+        applyServiceDecorators(element);
+        expect(element.render()).toBe("value");
+        expect(Component_stack.active()).toBeUndefined();
+    });
+
+    it("decorates a render inherited from the prototype", () => {
+        class Base { service = {}; render() { return "inherited"; } }
+        const element = Object.assign(new Base(), { hooks: [], hookIndex: 0 });
+        applyServiceDecorators(element);
+        expect(Object.prototype.hasOwnProperty.call(element, "render")).toBe(true);
+        expect(element.render()).toBe("inherited");
+    });
+
+    it("restores the hook stack when render throws", () => {
+        const element = createElement(() => { throw new Error("render failed"); }, {});
+        applyServiceDecorators(element);
+        expect(() => element.render()).toThrow("render failed");
+        expect(Component_stack.active()).toBeUndefined();
+    });
+});

package/src/decorators/require-service.test.ts

@@ -0,0 +1,31 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it, vi } from "vitest";
+import { requireService } from "./require-service.js";
+
+function guard(render: (this: { service?: unknown }) => unknown) {
+    return requireService()({}, "render", { value: render }).value as (this: { service?: unknown }) => unknown;
+}
+
+describe("requireService", () => {
+    it("returns null without calling render while there is no service", () => {
+        const render = vi.fn(() => "rendered");
+        expect(guard(render).call({})).toBeNull();
+        expect(render).not.toHaveBeenCalled();
+    });
+
+    it("calls render with the receiver once a service is set", () => {
+        const host = { service: {} as unknown };
+        const render = vi.fn(function (this: unknown) { return this; });
+        expect(guard(render).call(host)).toBe(host);
+    });
+
+    it("propagates errors from render", () => {
+        const render = () => { throw new Error("render failed"); };
+        expect(() => guard(render).call({ service: {} })).toThrow("render failed");
+    });
+
+    it("returns the descriptor it modified", () => {
+        const descriptor: PropertyDescriptor = { value: () => 1 };
+        expect(requireService()({}, "render", descriptor)).toBe(descriptor);
+    });
+});

package/src/elements/application-element.test.ts

@@ -0,0 +1,80 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it } from "vitest";
+import { html } from "lit";
+import type { Service } from "@adobe/data/service";
+import { ApplicationElement } from "./application-element.js";
+import { useState } from "../hooks/use-state.js";
+
+type MainService = Service & { kind: "main" };
+const createService = (kind: string) => ({ serviceName: kind, kind }) as unknown as MainService;
+
+class ProbeElement extends ApplicationElement<MainService> {
+    override render() {
+        const [value] = useState("hooked");
+        return html`${value}`;
+    }
+}
+customElements.define("application-element-probe", ProbeElement);
+
+class UnrenderedElement extends ApplicationElement<MainService> {}
+customElements.define("application-element-unrendered", UnrenderedElement);
+
+function under(parent: Element) {
+    const element = document.createElement("application-element-probe") as ProbeElement;
+    parent.append(element);
+    return element;
+}
+
+afterEach(async () => {
+    document.body.replaceChildren();
+    await Promise.resolve();
+});
+
+describe("ApplicationElement", () => {
+    it("finds the nearest ancestor service on connect", () => {
+        const outer = Object.assign(document.createElement("div"), { service: createService("outer") });
+        const inner = Object.assign(document.createElement("div"), { service: createService("inner") });
+        outer.append(inner);
+        document.body.append(outer);
+        expect(under(inner).service).toBe(inner.service);
+    });
+
+    it("keeps an injected service", () => {
+        const parent = Object.assign(document.createElement("div"), { service: createService("ancestor") });
+        document.body.append(parent);
+        const injected = createService("injected");
+        const element = document.createElement("application-element-probe") as ProbeElement;
+        element.service = injected;
+        parent.append(element);
+        expect(element.service).toBe(injected);
+    });
+
+    it("skips ancestors that fail the type guard", () => {
+        const matching = Object.assign(document.createElement("div"), { service: createService("main") });
+        const other = Object.assign(document.createElement("div"), { service: { serviceName: "other" } });
+        matching.append(other);
+        document.body.append(matching);
+        const element = document.createElement("application-element-probe") as ProbeElement;
+        element.typeGuard = (service): service is MainService => (service as MainService | undefined)?.kind === "main";
+        other.append(element);
+        expect(element.service).toBe(matching.service);
+    });
+
+    it("skips values that are not services and leaves service unset without a provider", () => {
+        const parent = Object.assign(document.createElement("div"), { service: { notAService: true } });
+        document.body.append(parent);
+        expect(under(parent).service).toBeUndefined();
+    });
+
+    it("renders with hooks", async () => {
+        const element = under(document.body);
+        await element.updateComplete;
+        expect(element.shadowRoot?.textContent).toBe("hooked");
+    });
+
+    it("throws from the default render", () => {
+        const element = new UnrenderedElement();
+        expect(() => element.render()).toThrow("render function must be overridden");
+    });
+});

package/src/elements/application-host.test.ts

@@ -0,0 +1,57 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { html } from "lit";
+import type { Service } from "@adobe/data/service";
+import "./application-host.js";
+
+function deferred<T>() {
+    let resolve!: (value: T) => void;
+    const promise = new Promise<T>(r => { resolve = r; });
+    return { promise, resolve };
+}
+
+afterEach(() => {
+    document.body.replaceChildren();
+});
+
+describe("ApplicationHost", () => {
+    it("creates one service across a DOM move", async () => {
+        const service = { serviceName: "main" } as unknown as Service;
+        const pending = deferred<Service>();
+        const createService = vi.fn(() => pending.promise);
+        const host = document.createElement("application-host");
+        host.createService = createService;
+        host.renderElement = () => html``;
+
+        const [parentA, parentB] = [document.createElement("div"), document.createElement("div")];
+        document.body.append(parentA, parentB);
+        parentA.append(host);
+        parentB.append(host);
+        pending.resolve(service);
+        await pending.promise;
+        await host.updateComplete;
+
+        expect(createService).toHaveBeenCalledTimes(1);
+        expect(host.service).toBe(service);
+
+        parentA.append(host);
+        await host.updateComplete;
+        expect(createService).toHaveBeenCalledTimes(1);
+    });
+
+    it("retries creation after a failure", async () => {
+        const service = { serviceName: "main" } as unknown as Service;
+        const createService = vi.fn()
+            .mockRejectedValueOnce(new Error("offline"))
+            .mockResolvedValueOnce(service);
+        const host = document.createElement("application-host");
+        host.createService = createService;
+        host.renderElement = () => html``;
+
+        await expect(host.connectedCallback()).rejects.toThrow("offline");
+        await host.connectedCallback();
+
+        expect(createService).toHaveBeenCalledTimes(2);
+        expect(host.service).toBe(service);
+    });
+});

package/src/elements/application-host.ts

@@ -3,13 +3,12 @@
 import { LitElement, nothing, TemplateResult, css } from 'lit';
 import { customElement, property } from 'lit/decorators.js';
 import { Service } from '@adobe/data/service';
-import { ApplicationElement } from './application-element.js';
 
 const tagName = "application-host";
 
 declare global {
    interface HTMLElementTagNameMap {
-      'application-element': ApplicationElement<Service>;
+      'application-host': ApplicationHost;
    }
 }
 
@@ -31,9 +30,23 @@ export class ApplicationHost<MainService extends Service = Service> extends LitE
    @property({ attribute: false })
    public service!: MainService;
 
+   #pendingService?: Promise<MainService>;
+
+   /**
+    * Creates the service once per host: reconnecting, including a DOM move, reuses the
+    * service or the in-flight creation. A failed creation is retried on the next connect.
+    */
    override async connectedCallback() {
       super.connectedCallback();
-      this.service = await this.createService();
+      if (this.service) return;
+      const pending = this.#pendingService ??= this.createService();
+      try {
+         const service = await pending;
+         this.service ??= service;
+      } catch (error) {
+         if (this.#pendingService === pending) this.#pendingService = undefined;
+         throw error;
+      }
    }
 
    override render() {

package/src/elements/database-element.test.ts

@@ -0,0 +1,111 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { html } from "lit";
+import { Database } from "@adobe/data/ecs";
+import { DatabaseElement } from "./database-element.js";
+
+const rootPlugin = Database.Plugin.create({ resources: { name: { default: "root" as string } } });
+const childPlugin = Database.Plugin.create({ resources: { count: { default: 0 as number } } });
+
+class ProbeElement extends DatabaseElement<typeof childPlugin> {
+    get plugin() {
+        return childPlugin;
+    }
+    fullDatabase() {
+        return this.database;
+    }
+    override render() {
+        return html`${this.database.resources.count}`;
+    }
+}
+customElements.define("database-element-probe", ProbeElement);
+
+class UnrenderedElement extends DatabaseElement<typeof childPlugin> {
+    get plugin() {
+        return childPlugin;
+    }
+}
+customElements.define("database-element-unrendered", UnrenderedElement);
+
+const create = () => document.createElement("database-element-probe") as ProbeElement;
+const resources = (db: unknown) => (db as { resources: Record<string, unknown> }).resources;
+
+afterEach(async () => {
+    document.body.replaceChildren();
+    await Promise.resolve();
+});
+
+describe("DatabaseElement", () => {
+    it("creates its own database when no ancestor provides one", async () => {
+        const element = create();
+        document.body.append(element);
+        expect(Database.is(element.fullDatabase())).toBe(true);
+        expect(resources(element.service).count).toBe(0);
+        await element.updateComplete;
+        expect(element.shadowRoot?.textContent).toBe("0");
+    });
+
+    it("extends the nearest ancestor database with its plugin", () => {
+        const root = Database.create(rootPlugin);
+        const parent = Object.assign(document.createElement("div"), { service: root });
+        document.body.append(parent);
+        const element = create();
+        parent.append(element);
+        expect(resources(element.service).name).toBe("root");
+        expect(resources(element.service).count).toBe(0);
+    });
+
+    it("finds the database of an ancestor database element", () => {
+        const outer = create();
+        document.body.append(outer);
+        const inner = create();
+        outer.append(inner);
+        expect(inner.fullDatabase()).toBe(outer.fullDatabase());
+    });
+
+    it("skips ancestor services that are not databases", () => {
+        const parent = Object.assign(document.createElement("div"), { service: { serviceName: "other" } });
+        document.body.append(parent);
+        const element = create();
+        parent.append(element);
+        expect(Database.is(element.fullDatabase())).toBe(true);
+    });
+
+    it("keeps an injected database and requests an update when it changes", () => {
+        const injected = Database.create(childPlugin);
+        const element = create();
+        const requestUpdate = vi.spyOn(element, "requestUpdate");
+        element.service = injected;
+        expect(requestUpdate).toHaveBeenCalledWith("service", undefined);
+        document.body.append(element);
+        expect(element.fullDatabase()).toBe(injected);
+    });
+
+    it("routes a database bound before the element upgraded through the service setter", () => {
+        const injected = Database.create(childPlugin);
+        const element = document.createElement("database-element-late");
+        (element as unknown as { service: unknown }).service = injected;
+        document.body.append(element);
+
+        class LateElement extends ProbeElement {}
+        customElements.define("database-element-late", LateElement);
+        const upgraded = element as unknown as LateElement;
+        expect(Object.prototype.hasOwnProperty.call(upgraded, "service")).toBe(false);
+        expect(upgraded.fullDatabase()).toBe(injected);
+    });
+
+    it("keeps its database across a reconnect", () => {
+        const element = create();
+        document.body.append(element);
+        const database = element.fullDatabase();
+        element.remove();
+        document.body.append(element);
+        expect(element.fullDatabase()).toBe(database);
+    });
+
+    it("throws from the default render", () => {
+        const element = new UnrenderedElement();
+        expect(() => element.render()).toThrow("render function must be overridden");
+    });
+});

package/src/functions/iterate-self-and-ancestors.test.ts

@@ -0,0 +1,29 @@
+// @vitest-environment happy-dom
+import { describe, expect, it } from "vitest";
+import { iterateSelfAndAncestors } from "./iterate-self-and-ancestors.js";
+
+const tags = (element: Element) => [...iterateSelfAndAncestors(element)].map(e => e.tagName.toLowerCase());
+
+describe("iterateSelfAndAncestors", () => {
+    it("walks light-DOM parents", () => {
+        const section = document.createElement("section");
+        const span = section.appendChild(document.createElement("div")).appendChild(document.createElement("span"));
+        expect(tags(span)).toEqual(["span", "div", "section"]);
+    });
+
+    it("crosses from a shadow root to its host", () => {
+        const host = document.createElement("section");
+        const inner = host.attachShadow({ mode: "open" }).appendChild(document.createElement("article"));
+        expect(tags(inner)).toEqual(["article", "section"]);
+    });
+
+    it("follows an assigned slot through the shadow tree before the light parent", () => {
+        const host = document.createElement("section");
+        const article = host.attachShadow({ mode: "open" }).appendChild(document.createElement("article"));
+        const slot = article.appendChild(document.createElement("slot"));
+        const span = host.appendChild(document.createElement("span"));
+        Object.defineProperty(span, "assignedSlot", { value: slot });
+
+        expect(tags(span)).toEqual(["span", "slot", "article", "section"]);
+    });
+});

package/src/functions/iterate-self-and-ancestors.ts

@@ -1,13 +1,13 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 
+/** Yields `element` and its ancestors along the composed tree: assigned slots, parents, then shadow hosts. */
 export function* iterateSelfAndAncestors(element: Element): IterableIterator<Element> {
     let current: Element | null = element;
 
     while (current) {
         yield current;
 
-        if (current instanceof HTMLSlotElement && current.assignedSlot) {
-            // Move to the slot's parent if the current element is assigned to a slot
+        if (current.assignedSlot) {
             current = current.assignedSlot;
         } else if (current.parentNode instanceof Element) {
             // Move up to the parent node if it is an element

package/src/hooks/attach-decorator.test.ts

@@ -0,0 +1,45 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, expect, it, vi } from "vitest";
+import { attachDecorator } from "./attach-decorator.js";
+
+const double = (_target: unknown, _key: string, descriptor: PropertyDescriptor) => {
+    const original = descriptor.value as (this: unknown, ...args: unknown[]) => number;
+    return { ...descriptor, value(this: unknown, ...args: unknown[]) { return original.apply(this, args) * 2; } };
+};
+
+describe("attachDecorator", () => {
+    it("decorates an inherited method and installs it on the instance", () => {
+        class Base { value = 3; get() { return this.value; } }
+        const instance = new Base();
+        attachDecorator(instance, "get", double);
+        expect(instance.get()).toBe(6);
+        expect(Object.prototype.hasOwnProperty.call(instance, "get")).toBe(true);
+        expect(new Base().get()).toBe(3);
+    });
+
+    it("decorates an own method", () => {
+        const instance = { get: () => 2 };
+        attachDecorator(instance, "get", double);
+        expect(instance.get()).toBe(4);
+    });
+
+    it("passes the instance, property name, and current method to the decorator", () => {
+        const method = () => 1;
+        const instance = { method };
+        const decorator = vi.fn((_target: unknown, _key: string, descriptor: PropertyDescriptor) => descriptor);
+        attachDecorator(instance, "method", decorator);
+        expect(decorator).toHaveBeenCalledWith(instance, "method", expect.objectContaining({ value: method }));
+    });
+
+    it("applies repeated decorators in order", () => {
+        const instance = { get: () => 1 };
+        attachDecorator(instance, "get", double);
+        attachDecorator(instance, "get", double);
+        expect(instance.get()).toBe(4);
+    });
+
+    it("throws for a missing property", () => {
+        const instance = {} as { missing?: () => void };
+        expect(() => attachDecorator(instance, "missing", double)).toThrow("Property missing does not exist");
+    });
+});