@preact-mvc/core 0.0.0 → 0.1.1

package/dist/router/module.js

@@ -0,0 +1,32 @@
+import { getModuleMeta } from '../module';
+import { ROUTES, ROUTER_BASE, Router, defaultBasePath } from './router';
+// RouterModule.forRoot(routes) returns a module-shaped object — anything with
+// __module metadata can sit in `imports`, so static config works the same as
+// a decorated module class.
+export class RouterModule {
+    static forRoot(routes, opts = {}) {
+        return {
+            __module: {
+                providers: [
+                    { provide: ROUTES, useValue: routes },
+                    { provide: ROUTER_BASE, useValue: opts.basePath ?? defaultBasePath() },
+                    {
+                        provide: Router,
+                        useFactory: (r, base) => new Router(r, base),
+                        deps: [ROUTES, ROUTER_BASE],
+                    },
+                ],
+            },
+        };
+    }
+}
+// Resolve which view a matched route should render: an explicit component, or
+// the module's declared bootstrap component.
+export function routeComponent(match) {
+    const { route } = match;
+    if (route.component)
+        return route.component;
+    if (route.module)
+        return getModuleMeta(route.module)?.bootstrap?.[0] ?? null;
+    return null;
+}

package/dist/router/outlet.d.ts

@@ -0,0 +1 @@
+export declare function RouterOutlet(): import("preact").JSX.Element | null;

package/dist/router/outlet.js

@@ -0,0 +1,44 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { createContext } from 'preact';
+import { useContext } from 'preact/hooks';
+import PRRouter from 'preact-router';
+import { useInjector, useService, InjectorContext } from '../context';
+import { getModuleInjector } from '../module';
+import { routeComponent } from './module';
+import { Router } from './router';
+/**
+ * Which depth of the matched chain this outlet renders — the root outlet
+ * is depth 0, an outlet inside a routed view is depth 1, and so on.
+ */
+const OutletDepth = createContext(0);
+/**
+ * The preact-router bridge: a mounted PR <Router> claiming every URL via a
+ * `default` sink child. Its existence makes preact-router's machinery live
+ * in this app — foreign `route()` calls and the global `<a href>` click
+ * interceptor resolve through it — and its onChange feeds our `url`
+ * signal, so navigations from ANY preact-routing code drive our router.
+ * The sink renders nothing; url/matches props die on the component.
+ */
+const BridgeSink = () => null;
+export function RouterOutlet() {
+    const router = useService(Router);
+    const parent = useInjector();
+    const depth = useContext(OutletDepth);
+    const matches = router.matches.value;
+    const match = matches?.[depth];
+    if (!match) {
+        // The outermost outlet keeps the bridge mounted even with no match, so
+        // route() interop survives 404s.
+        return depth === 0 ? (_jsx(PRRouter, { onChange: (e) => router.syncUrl(e.url), children: _jsx(BridgeSink, { default: true }) })) : null;
+    }
+    const Component = routeComponent(match);
+    if (!Component)
+        return null;
+    // A route with `module` gets the module's injector — its providers are
+    // scoped to that feature. Nesting is automatic: a deeper outlet resolves
+    // its module under this level's injector.
+    const injector = match.route.module
+        ? getModuleInjector(match.route.module, parent)
+        : parent;
+    return (_jsxs(OutletDepth.Provider, { value: depth + 1, children: [depth === 0 && (_jsx(PRRouter, { onChange: (e) => router.syncUrl(e.url), children: _jsx(BridgeSink, { default: true }) })), _jsx(InjectorContext.Provider, { value: injector, children: _jsx(Component, {}) })] }));
+}

package/dist/router/router.d.ts

@@ -0,0 +1,52 @@
+import { InjectionToken } from '../injector';
+export interface Route {
+    path: string;
+    component?: any;
+    module?: any;
+    children?: Route[];
+}
+export interface RouteMatch {
+    route: Route;
+    params: Record<string, string>;
+}
+export declare const ROUTES: InjectionToken<Route[]>;
+export declare const ROUTER_BASE: InjectionToken<string>;
+/**
+ * The directory the app's document lives at, e.g. '/demo/' when the page is
+ * served from `host/demo/index.html`. Deriving the base from baseURI (rather
+ * than baking it at build time) means the same bundle works under any mount
+ * path — GitHub Pages project dirs, reverse-proxy prefixes, iframed demos.
+ */
+export declare function defaultBasePath(): string;
+export declare class Router {
+    private routes;
+    /** Mount prefix, normalized to '' or '/demo' (no trailing slash). */
+    readonly base: string;
+    url: import("@preact/signals-core").Signal<string>;
+    /**
+     * The matched chain outermost → innermost — depth d is what the d-th
+     * nested <RouterOutlet/> renders.
+     */
+    matches: import("@preact/signals-core").ReadonlySignal<RouteMatch[] | null>;
+    /** Back-compat: the chain's outermost match. */
+    match: import("@preact/signals-core").ReadonlySignal<RouteMatch | null>;
+    /** Params merged across the whole chain (inner levels win on collision). */
+    params: import("@preact/signals-core").ReadonlySignal<any>;
+    constructor(routes: Route[], base?: string);
+    /**
+     * Static-host deep links: the site's 404 shim redirects
+     * `/docs/<app>/<rest>` to `<app>/?__pmvc_path=<rest>` so the app loads;
+     * restore the real URL via replaceState before seeding `url` — the
+     * browser history never sees the hop. No-op everywhere else.
+     */
+    private consumeShimParam;
+    private strip;
+    /** Absolute href for an in-app path — what <a href> and pushState see. */
+    href(to: string): string;
+    /** Called by the preact-router bridge on any URL change it sees —
+     *  foreign route() calls, its global <a> interceptor, popstate. */
+    syncUrl(fullUrl: string): void;
+    private onPopState;
+    navigate(to: string): void;
+    isActive(path: string): boolean;
+}

package/dist/router/router.js

@@ -0,0 +1,151 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { computed, signal } from '@preact/signals';
+import { route as prRoute } from 'preact-router';
+import { Injectable } from '../decorators';
+import { InjectionToken } from '../injector';
+export const ROUTES = new InjectionToken('ROUTES');
+export const ROUTER_BASE = new InjectionToken('ROUTER_BASE');
+/**
+ * The directory the app's document lives at, e.g. '/demo/' when the page is
+ * served from `host/demo/index.html`. Deriving the base from baseURI (rather
+ * than baking it at build time) means the same bundle works under any mount
+ * path — GitHub Pages project dirs, reverse-proxy prefixes, iframed demos.
+ */
+export function defaultBasePath() {
+    if (typeof document === 'undefined')
+        return '/';
+    const p = new URL(document.baseURI).pathname;
+    return p.endsWith('/') ? p : p.slice(0, p.lastIndexOf('/') + 1);
+}
+/**
+ * Prefix match: consume the pattern's leading segments off `segs`, returning
+ * the captured params and the unconsumed tail. `'*'` consumes everything;
+ * `''` consumes nothing (an index route — leaf check decides validity).
+ */
+function matchPrefix(pattern, segs) {
+    if (pattern === '*')
+        return { params: {}, rest: [] };
+    const pSegs = pattern.split('/').filter(Boolean);
+    if (pSegs.length > segs.length)
+        return null;
+    const params = {};
+    for (let i = 0; i < pSegs.length; i++) {
+        const p = pSegs[i];
+        const u = decodeURIComponent(segs[i]);
+        if (p.startsWith(':'))
+            params[p.slice(1)] = u;
+        else if (p !== u)
+            return null;
+    }
+    return { params, rest: segs.slice(pSegs.length) };
+}
+/**
+ * Match `segs` against a route list into a chain outermost → innermost.
+ * A route with `children` matches by prefix and the tail recurses; a leaf
+ * route must consume the whole tail. Parents may match alone when the tail
+ * is exhausted (Angular semantics: `/users` renders the parent shell even
+ * if it has children).
+ */
+function matchSegments(routes, segs) {
+    for (const route of routes) {
+        const m = matchPrefix(route.path, segs);
+        if (m === null)
+            continue;
+        if (route.children?.length) {
+            const child = matchSegments(route.children, m.rest);
+            if (child !== null)
+                return [{ route, params: m.params }, ...child];
+            if (m.rest.length === 0)
+                return [{ route, params: m.params }];
+            continue;
+        }
+        if (m.rest.length === 0)
+            return [{ route, params: m.params }];
+    }
+    return null;
+}
+function matchRoutes(routes, url) {
+    const path = url.split('?')[0].split('#')[0];
+    return matchSegments(routes, path.split('/').filter(Boolean));
+}
+let Router = class Router {
+    constructor(routes, base = defaultBasePath()) {
+        this.routes = routes;
+        this.url = signal(typeof location === 'undefined' ? '/' : '');
+        /**
+         * The matched chain outermost → innermost — depth d is what the d-th
+         * nested <RouterOutlet/> renders.
+         */
+        this.matches = computed(() => matchRoutes(this.routes, this.url.value));
+        /** Back-compat: the chain's outermost match. */
+        this.match = computed(() => this.matches.value?.[0] ?? null);
+        /** Params merged across the whole chain (inner levels win on collision). */
+        this.params = computed(() => Object.assign({}, ...(this.matches.value ?? []).map((m) => m.params)));
+        this.onPopState = () => {
+            this.syncUrl(location.pathname + location.search);
+        };
+        this.base = base === '/' ? '' : base.replace(/\/+$/, '');
+        this.consumeShimParam();
+        if (typeof location !== 'undefined') {
+            this.url.value = this.strip(location.pathname) + location.search;
+        }
+        if (typeof window !== 'undefined') {
+            window.addEventListener('popstate', this.onPopState);
+        }
+    }
+    /**
+     * Static-host deep links: the site's 404 shim redirects
+     * `/docs/<app>/<rest>` to `<app>/?__pmvc_path=<rest>` so the app loads;
+     * restore the real URL via replaceState before seeding `url` — the
+     * browser history never sees the hop. No-op everywhere else.
+     */
+    consumeShimParam() {
+        if (typeof location === 'undefined' || typeof history === 'undefined')
+            return;
+        const rest = new URL(location.href).searchParams.get('__pmvc_path');
+        if (rest === null)
+            return;
+        history.replaceState(null, '', this.base + '/' + rest);
+    }
+    strip(path) {
+        if (this.base && path.startsWith(this.base)) {
+            return path.slice(this.base.length) || '/';
+        }
+        return path;
+    }
+    /** Absolute href for an in-app path — what <a href> and pushState see. */
+    href(to) {
+        return this.base + to;
+    }
+    /** Called by the preact-router bridge on any URL change it sees —
+     *  foreign route() calls, its global <a> interceptor, popstate. */
+    syncUrl(fullUrl) {
+        const [path, search = ''] = fullUrl.split('?');
+        const stripped = this.strip(path);
+        const next = stripped + (search ? `?${search}` : '');
+        if (next !== this.url.value)
+            this.url.value = next;
+    }
+    navigate(to) {
+        // Through preact-router: updates every mounted <Router> in the tree —
+        // ours and foreign ones — not just our own subscriber. route() is a
+        // no-op when no mounted PR Router claims the url, so fall back to a
+        // manual push when the bridge isn't up yet.
+        if (!prRoute(this.base + to)) {
+            history.pushState(null, '', this.base + to);
+            this.url.value = to;
+        }
+    }
+    isActive(path) {
+        return this.url.value === path;
+    }
+};
+Router = __decorate([
+    Injectable()
+], Router);
+export { Router };

package/dist/signals.d.ts

@@ -0,0 +1,4 @@
+import { effect as preactEffect } from '@preact/signals';
+export { signal, computed, batch, untracked } from '@preact/signals';
+export type { Signal, ReadonlySignal } from '@preact/signals';
+export declare function effect(fn: Parameters<typeof preactEffect>[0]): () => void;

package/{src/signals.ts → dist/signals.js}

@@ -3,17 +3,14 @@
 // is installed before any view uses it.
 import { effect as preactEffect } from '@preact/signals';
 import { getCurrentInjector } from './injector';
-
 export { signal, computed, batch, untracked } from '@preact/signals';
-export type { Signal, ReadonlySignal } from '@preact/signals';
-
 // Scope-bound effect: created during a class's construction (field
 // initializers or constructor body), it registers on that scope's injector
 // and is disposed automatically when the scope is deactivated — Angular's
 // DestroyRef semantics. Outside an injection context it's the raw primitive:
 // call the returned disposer yourself.
-export function effect(fn: Parameters<typeof preactEffect>[0]): () => void {
-  const dispose = preactEffect(fn);
-  getCurrentInjector()?.registerCleanup(dispose);
-  return dispose;
+export function effect(fn) {
+    const dispose = preactEffect(fn);
+    getCurrentInjector()?.registerCleanup(dispose);
+    return dispose;
 }

package/dist/view.d.ts

@@ -0,0 +1,8 @@
+import { Component as PreactComponent } from 'preact';
+import type { ComponentChildren } from 'preact';
+export declare abstract class View<P = {}> extends PreactComponent<P> {
+    abstract render(): ComponentChildren;
+    setState(): never;
+    forceUpdate(): never;
+}
+export declare function installViewInterop(): void;

package/dist/view.js

@@ -0,0 +1,133 @@
+import { Component as PreactComponent, h, options } from 'preact';
+import { useLayoutEffect, useRef } from 'preact/hooks';
+import { InjectorContext, useInjector } from './context';
+import { Injector } from './injector';
+import { registerModule } from './module';
+import { ownerOf } from './decorators';
+// --- Class-based views -----------------------------------------------------
+// A View subclass is never instantiated by Preact. The options.vnode hook
+// below swaps any vnode whose type is a View subclass for a host function
+// component, which constructs the class ONCE per mount inside a child
+// injector — so `inject()` in field initializers resolves against that view's
+// scope (component providers -> module providers -> root).
+//
+// render() runs on every render pass with no framework involvement: signals
+// read inside it subscribe the host component automatically.
+export class View extends PreactComponent {
+    // Views are signal-driven; setState/forceUpdate would hit Preact internals
+    // on an instance Preact never mounted. Fail loudly instead of corrupting.
+    setState() {
+        throw new Error('View components are signal-driven — assign a signal instead of calling setState()');
+    }
+    forceUpdate() {
+        throw new Error('View components are signal-driven — assign a signal instead of calling forceUpdate()');
+    }
+}
+function isViewClass(t) {
+    return typeof t === 'function' && t.prototype instanceof View;
+}
+// --- Error boundary ----------------------------------------------------------
+// Real Preact class component (not a View — it must be instantiated by Preact).
+// Wraps every view host so mount/render failures stay local instead of
+// aborting the whole render pass.
+class ViewErrorBoundary extends PreactComponent {
+    constructor() {
+        super(...arguments);
+        this.state = { error: null };
+    }
+    componentDidCatch(error) {
+        console.error(`[framework] ${this.props.viewName} failed:`, error);
+        this.setState({ error });
+    }
+    render() {
+        const err = this.state.error;
+        if (!err)
+            return this.props.children;
+        return h('div', {
+            style: {
+                border: '1px solid #e53935',
+                background: '#ffebee',
+                padding: '0.75rem',
+                borderRadius: '4px',
+                fontFamily: 'monospace',
+                fontSize: '0.85rem',
+            },
+        }, h('strong', null, `${this.props.viewName} failed to mount`), h('pre', { style: { whiteSpace: 'pre-wrap', margin: '0.5rem 0' } }, String(err?.message ?? err)), h('button', { onClick: () => this.setState({ error: null }) }, 'Retry'));
+    }
+}
+// --- Host -------------------------------------------------------------------
+const hostCache = new Map();
+function hostFor(cls) {
+    let host = hostCache.get(cls);
+    if (host)
+        return host;
+    const meta = (cls.__component ?? {});
+    const inner = function ViewHost(props) {
+        const parent = useInjector();
+        const ref = useRef(null);
+        if (!ref.current) {
+            // Module ownership: a view declared in a module's components/bootstrap
+            // may only mount where that module's injector is an ancestor — Angular's
+            // declaration rule enforced at mount. Undeclared views mount freely.
+            const owner = ownerOf(cls);
+            if (owner) {
+                let node = parent;
+                while (node && !node.modules.has(owner))
+                    node = node.parent;
+                if (!node) {
+                    throw new Error(`${cls.name} is declared by ${owner.name ?? 'a module'} but mounted outside its injector scope. ` +
+                        `Mount it under a route/module that includes ${owner.name ?? 'that module'}.`);
+                }
+            }
+            const inj = new Injector(parent, `view ${cls.name}`);
+            // Standalone scope: imported modules contribute providers (and mark
+            // themselves visible for ownership checks); view-level providers and
+            // declared controllers register on top, closest-scope-wins.
+            const seen = new Set();
+            for (const imp of meta.imports ?? [])
+                registerModule(imp, inj, seen);
+            for (const p of meta.providers ?? [])
+                inj.provide(p);
+            for (const c of meta.controllers ?? [])
+                inj.provide(c);
+            ref.current = { inj, inst: inj.instantiate(cls, props) };
+        }
+        const { inj, inst } = ref.current;
+        inst.props = props;
+        // Mount activates the whole view scope: onInit for the view and every
+        // controller/provider its injector constructed; unmount fires onDestroy.
+        // useLayoutEffect (synchronous at commit) is deliberate: deferred
+        // useEffect callbacks are dropped if the host unmounts before they flush,
+        // which would silently lose onInit on same-tick mount+navigate.
+        useLayoutEffect(() => {
+            inj.activate();
+            return () => inj.deactivate();
+        }, []);
+        // The view's injector becomes the scope for everything it renders, so
+        // child components resolve through it — the element-injector hierarchy.
+        return h(InjectorContext.Provider, { value: inj }, inst.render());
+    };
+    inner.displayName = cls.name;
+    host = function BoundedView(props) {
+        return h(ViewErrorBoundary, { viewName: cls.name }, h(inner, props));
+    };
+    host.displayName = cls.name;
+    hostCache.set(cls, host);
+    return host;
+}
+let installed = false;
+// Install the vnode interceptor. Must run before any view class is rendered;
+// called on module load and again defensively from bootstrap().
+export function installViewInterop() {
+    if (installed)
+        return;
+    installed = true;
+    const prev = options.vnode;
+    options.vnode = (vnode) => {
+        const t = vnode.type;
+        if (isViewClass(t))
+            vnode.type = hostFor(t);
+        prev?.(vnode);
+    };
+}
+installViewInterop();

package/package.json

@@ -1,20 +1,22 @@
 {
   "name": "@preact-mvc/core",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "description": "Angular-inspired modules/DI/decorators + class-based JSX views rendered by Preact + signal reactivity",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
     "./package.json": "./package.json",
-    "./*": "./src/*"
+    "./*": "./dist/*"
   },
   "files": [
-    "src",
-    "!src/**/*.test.ts",
-    "!src/**/*.test.tsx"
+    "dist"
   ],
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json"
   },
   "dependencies": {
     "@preact/signals": "^1.3.0",
@@ -25,5 +27,11 @@
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
-  "license": "MIT"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jwhenry3/preact-mvc",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "types": "./dist/index.d.ts"
 }

package/src/context.tsx

@@ -1,39 +0,0 @@
-import { createContext } from 'preact';
-import type { ComponentChildren } from 'preact';
-import { useContext, useRef } from 'preact/hooks';
-import { Injector } from './injector';
-import type { Provider, Token } from './injector';
-
-// The current injector travels through the view tree as Preact context.
-// Module and route boundaries swap in child injectors.
-
-export const InjectorContext = createContext<Injector>(null as unknown as Injector);
-
-export function useInjector(): Injector {
-  const injector = useContext(InjectorContext);
-  if (!injector) {
-    throw new Error('No injector in context — is this view mounted under bootstrap()?');
-  }
-  return injector;
-}
-
-// Resolve a service/store from the view's injector scope.
-export function useService<T>(token: Token<T>): T {
-  return useInjector().get(token);
-}
-
-// View-local provider scope: equivalent to a component-level providers array.
-// Providers created here live and die with this subtree.
-export function Provide(props: { providers: Provider[]; children?: ComponentChildren }) {
-  const parent = useInjector();
-  const ref = useRef<Injector | null>(null);
-  if (!ref.current) {
-    ref.current = new Injector(parent, 'view providers');
-    for (const p of props.providers) ref.current.provide(p);
-  }
-  return (
-    <InjectorContext.Provider value={ref.current}>
-      {props.children}
-    </InjectorContext.Provider>
-  );
-}

package/src/controller.ts

@@ -1,30 +0,0 @@
-import { useLayoutEffect, useRef } from 'preact/hooks';
-import { useInjector } from './context';
-import { Injector } from './injector';
-import type { Type } from './injector';
-
-export interface OnInit {
-  onInit(): void;
-}
-export interface OnDestroy {
-  onDestroy(): void;
-}
-
-// Binds a controller class to a view instance. The controller is created once
-// per mounted view inside its own child injector, so `inject()` in its
-// constructor sees every provider from the enclosing module scope upward.
-// Lifecycle maps to mount/unmount: onInit on mount, onDestroy on unmount.
-export function useController<T extends object>(cls: Type<T>): T {
-  const parent = useInjector();
-  const ref = useRef<{ injector: Injector; ctrl: T } | null>(null);
-  if (!ref.current) {
-    const injector = new Injector(parent, `controller ${cls.name}`);
-    ref.current = { injector, ctrl: injector.instantiate(cls) };
-  }
-  const { ctrl, injector } = ref.current;
-  useLayoutEffect(() => {
-    injector.activate();
-    return () => injector.deactivate();
-  }, []);
-  return ctrl;
-}

package/src/decorators.ts

@@ -1,77 +0,0 @@
-import type { Provider, Type } from './injector';
-
-// Decorators attach metadata to the class constructor. They work with
-// experimentalDecorators (esbuild honors the tsconfig flag) and can also be
-// invoked manually: `Module({ ... })(MyModule)`.
-
-export interface InjectableMeta {
-  providedIn?: 'root';
-}
-
-export function Injectable(meta: InjectableMeta = {}) {
-  return function <T extends Type<any>>(target: T): T {
-    (target as any).__injectable = meta;
-    return target;
-  };
-}
-
-export function Controller() {
-  return function <T extends Type<any>>(target: T): T {
-    (target as any).__controller = true;
-    return target;
-  };
-}
-
-export interface ComponentMeta {
-  // Scoped to the component instance — like Angular component-level providers.
-  providers?: Provider[];
-  // Controllers registered in this view's scope: shared with the entire
-  // subtree (a child view injecting the same controller gets this instance).
-  // Undeclared controllers stay transient — one per injecting scope.
-  controllers?: Type<any>[];
-  // Modules whose providers and declared components join this view's scope —
-  // Angular's standalone-component `imports`. Enables module-less views that
-  // still participate in module-based scoping.
-  imports?: any[];
-}
-
-export function Component(meta: ComponentMeta = {}) {
-  return function <T>(target: T): T {
-    (target as any).__component = meta;
-    return target;
-  };
-}
-
-export interface ModuleMeta {
-  imports?: any[];
-  providers?: Provider[];
-  controllers?: Type<any>[];
-  components?: any[];
-  exports?: any[];
-  bootstrap?: any[];
-}
-
-// View class -> the module that declared it. Built as module classes are
-// decorated; consulted at mount time to enforce scope ownership.
-const componentOwners = new Map<any, any>();
-
-export function ownerOf(view: any): any {
-  return componentOwners.get(view);
-}
-
-export function Module(meta: ModuleMeta) {
-  return function <T>(target: T): T {
-    (target as any).__module = meta;
-    for (const c of [...(meta.components ?? []), ...(meta.bootstrap ?? [])]) {
-      const prev = componentOwners.get(c);
-      if (prev && prev !== target) {
-        console.warn(
-          `[framework] ${c.name ?? c} is declared by both ${prev.name} and ${(target as any).name}; keeping ${prev.name}`
-        );
-        continue;
-      }
-      componentOwners.set(c, target);
-    }
-    return target;
-  };
-}