@motujs/adapter-next 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Scorbutics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/archipelago.d.ts

@@ -0,0 +1,63 @@
+import { type ReactNode } from 'react';
+import { type ElementSpec } from '@motujs/react';
+import type { AnyArchipelagoConfig, Channel, HostBridge, IslandIsolation, MotuTheme } from '@motujs/core';
+export interface ArchipelagoProps {
+    /**
+     * The archipelago being mounted (from the project's archipelagos registry).
+     *
+     * Erased region type: mounting only ROUTES a region — it never reads a bind key — so insisting on the
+     * declared shape here would force every composition root to be generic for no checking gained. The
+     * checking happens where the archipelago is declared.
+     */
+    config: AnyArchipelagoConfig;
+    /** The project's element registry — the same one the lagoon uses. */
+    elements: ElementSpec[];
+    /** Compiled island stylesheet text (the project's shared sheet). Only used by `mount="element"`. */
+    css?: string;
+    /** Outward seam: navigate/action intents. Build one with `nextHostBridge(useRouter())`. */
+    host?: HostBridge;
+    /** Initial store contents, so bound islands render meaningfully on first paint. */
+    seed?: Record<string, unknown>;
+    /** Inbound channels: host signals mirrored into the store. */
+    channels?: Channel[];
+    /** Default skin. A Next host has no legacy skin to match, so 'motu'. */
+    defaultTheme?: MotuTheme;
+    /**
+     * Region encapsulation. Defaults to 'light' — the opposite of the framework default, and on purpose.
+     * A shadow root is right for an ocean whose stylesheet would otherwise bleed into the islands. Here
+     * the app's stylesheet is the POINT: islands are the app's own components, styled by the app's own
+     * Tailwind, and a shadow root blocks exactly that, rendering them unstyled inside their own page.
+     * Only meaningful for `mount="element"`.
+     */
+    isolation?: IslandIsolation;
+    /** How islands attach. See the note at the top of this file. */
+    mount?: 'react' | 'element';
+    className?: string;
+    /**
+     * Place islands yourself with `<Island slot="…">`, anywhere in the page's own markup. Without
+     * children every declared slot renders in config order, which is the sensible default for a region
+     * that owns its whole area.
+     */
+    children?: ReactNode;
+}
+/**
+ * Render one archipelago into a Next page.
+ *
+ * ```tsx
+ * 'use client';
+ * export function Actions() {
+ *   const router = useRouter();
+ *   const host = useMemo(() => nextHostBridge(router), [router]);
+ *   return (
+ *     <Archipelago config={getArchipelago('actions')!} elements={ELEMENT_REGISTRY} host={host}>
+ *       <div className="grid gap-6 lg:grid-cols-2">
+ *         <Island slot="network-stats" />
+ *         <Island slot="revenue-thanks" />
+ *       </div>
+ *     </Archipelago>
+ *   );
+ * }
+ * ```
+ */
+export declare function Archipelago(props: ArchipelagoProps): import("react").JSX.Element;
+//# sourceMappingURL=archipelago.d.ts.map

package/dist/archipelago.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archipelago.d.ts","sourceRoot":"","sources":["../src/archipelago.tsx"],"names":[],"mappings":"AAmBA,OAAO,EAA+B,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACpE,OAAO,EAA8C,KAAK,WAAW,EAAwB,MAAM,eAAe,CAAC;AAEnH,OAAO,KAAK,EAAE,oBAAoB,EAAE,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE1G,MAAM,WAAW,gBAAgB;IAC/B;;;;;;OAMG;IACH,MAAM,EAAE,oBAAoB,CAAC;IAC7B,qEAAqE;IACrE,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,oGAAoG;IACpG,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,2FAA2F;IAC3F,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,mFAAmF;IACnF,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;IACrB,wEAAwE;IACxE,YAAY,CAAC,EAAE,SAAS,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,gEAAgE;IAChE,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;CACtB;AAwBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,gBAAgB,+BAyBlD"}

package/dist/archipelago.js

@@ -0,0 +1,94 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+// Mounting an archipelago inside a Next page.
+//
+// There is no bridge script here and no injected markers: a Next host is already React, so islands
+// render in the page's own tree, in place. What the archipelago still buys — and the reason this is
+// not just an import of the ui components — is the discipline: one declared Store per region,
+// declarative `bind` from store key to island prop, the host-intent seam, and the seam lens's view of
+// all three.
+//
+// `mount` picks HOW islands attach:
+//
+//   'react'   (default) each island renders inside this page's React tree. Context, error boundaries
+//             and Suspense from the page reach it, and there is one React root for the whole page.
+//   'element' each island mounts as a <motu-island> custom element with its own React root. For the
+//             case a React host does not actually own the DOM the island lands in — markup rendered
+//             by a CMS, a slot filled imperatively — where there is no tree to join.
+//
+// Isolation is a different axis and is unaffected by this: it decides whether the host's stylesheet
+// reaches the island, not which tree the island renders in.
+import { useEffect, useRef, useState } from 'react';
+import { ArchipelagoProvider, Island, defineMotuApp } from '@motujs/react';
+import { setDefaultIsolation } from '@motujs/core';
+// defineMotuApp registers custom elements, which is global and one-shot per tag: calling it twice for
+// the same archipelago throws on re-registration. React StrictMode double-invokes effects and Next
+// remounts across navigations, so guard by archipelago id.
+const defined = new Set();
+function defineElements(props) {
+    if (defined.has(props.config.id))
+        return;
+    defined.add(props.config.id);
+    // Must be set before the elements are defined: <motu-archipelago> reads the default when it
+    // connects, and a region that has already attached a shadow root cannot give it back.
+    setDefaultIsolation(props.isolation ?? 'light');
+    const archipelagos = [
+        { config: props.config, options: { host: props.host, seed: props.seed, channels: props.channels } },
+    ];
+    defineMotuApp({
+        elements: props.elements,
+        archipelagos,
+        css: props.css,
+        defaultTheme: props.defaultTheme ?? 'motu',
+    });
+}
+/**
+ * Render one archipelago into a Next page.
+ *
+ * ```tsx
+ * 'use client';
+ * export function Actions() {
+ *   const router = useRouter();
+ *   const host = useMemo(() => nextHostBridge(router), [router]);
+ *   return (
+ *     <Archipelago config={getArchipelago('actions')!} elements={ELEMENT_REGISTRY} host={host}>
+ *       <div className="grid gap-6 lg:grid-cols-2">
+ *         <Island slot="network-stats" />
+ *         <Island slot="revenue-thanks" />
+ *       </div>
+ *     </Archipelago>
+ *   );
+ * }
+ * ```
+ */
+export function Archipelago(props) {
+    if (props.mount === 'element')
+        return _jsx(ElementArchipelago, { ...props });
+    // Without children, every declared slot renders in config order — the sensible default for a region
+    // that owns its whole area. The annotation keeps the union from widening across the React 18/19
+    // type boundary this package can be compiled over.
+    const placed = props.children ?? (_jsx(_Fragment, { children: props.config.islands.map((i) => (_jsx(Island, { slot: i.slot }, i.slot))) }));
+    return (_jsx(ArchipelagoProvider, { config: props.config, elements: props.elements, host: props.host, seed: props.seed, channels: props.channels, children: placed }));
+}
+/** The custom-element path: one React root per island, for a host that does not own this DOM. */
+function ElementArchipelago(props) {
+    const ref = useRef(null);
+    // Custom elements only exist in the browser; defining during render would run on the server too.
+    const [ready, setReady] = useState(false);
+    useEffect(() => {
+        defineElements(props);
+        setReady(true);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [props.config.id]);
+    useEffect(() => {
+        const mount = ref.current;
+        if (!ready || !mount)
+            return;
+        const el = document.createElement('motu-archipelago');
+        el.setAttribute('name', props.config.id);
+        mount.appendChild(el);
+        return () => el.remove();
+    }, [ready, props.config.id]);
+    return _jsx("div", { ref: ref, className: props.className });
+}
+//# sourceMappingURL=archipelago.js.map

package/dist/archipelago.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"archipelago.js","sourceRoot":"","sources":["../src/archipelago.tsx"],"names":[],"mappings":"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"}

package/dist/contract.d.ts

@@ -0,0 +1,21 @@
+import type { MotuServiceMap } from './services.js';
+/** The client's shape: the server's service map, with every method reachable as-is. */
+export type Contract<S extends MotuServiceMap> = {
+    readonly [Service in keyof S]: {
+        readonly [Method in keyof S[Service]]: S[Service][Method];
+    };
+};
+/**
+ * Build the typed contract client. Pass the server's service map type; nothing is imported from the
+ * server at runtime (the type argument is erased), so this stays safe in a client component.
+ *
+ * ```ts
+ * import type { AppServices } from '@/motu/server/services'   // type-only: erased at build
+ * export const contract = createContract<AppServices>()
+ * ```
+ *
+ * The proxy is lazy and shallow — two levels, resolved on access — so adding a service or method on
+ * the server needs no change here at all.
+ */
+export declare function createContract<S extends MotuServiceMap>(): Contract<S>;
+//# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,uFAAuF;AACvF,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,cAAc,IAAI;IAC/C,QAAQ,EAAE,OAAO,IAAI,MAAM,CAAC,GAAG;QAC7B,QAAQ,EAAE,MAAM,IAAI,MAAM,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC;KAC1D;CACF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,cAAc,KAAK,QAAQ,CAAC,CAAC,CAAC,CAqBtE"}

package/dist/contract.js

@@ -0,0 +1,47 @@
+// The client half of the contract seam: a typed façade over the one `call()` seam in @motujs/runtime.
+//
+// This is what `@motujs/contract` is on the Jakarta side, minus the generator. The service map's TYPE
+// is the contract, so `contract.directory.getSectors()` carries the real signature of the function
+// the route handler will run, and a change to that function fails `tsc` here — no regeneration, no
+// window where the two disagree.
+//
+// Everything goes through `call()`, which is why an island using this still works in the lagoon: the
+// lagoon configures MockTransport instead of HttpTransport and the same component replays fixtures
+// with no backend at all.
+import { call } from '@motujs/runtime';
+/**
+ * Build the typed contract client. Pass the server's service map type; nothing is imported from the
+ * server at runtime (the type argument is erased), so this stays safe in a client component.
+ *
+ * ```ts
+ * import type { AppServices } from '@/motu/server/services'   // type-only: erased at build
+ * export const contract = createContract<AppServices>()
+ * ```
+ *
+ * The proxy is lazy and shallow — two levels, resolved on access — so adding a service or method on
+ * the server needs no change here at all.
+ */
+export function createContract() {
+    const services = new Map();
+    return new Proxy(Object.create(null), {
+        get(_target, service) {
+            // A bare property read (a bundler probing for `then`, devtools inspecting) must not be
+            // mistaken for a service name.
+            if (typeof service !== 'string')
+                return undefined;
+            const cached = services.get(service);
+            if (cached)
+                return cached;
+            const methods = new Proxy(Object.create(null), {
+                get(_t, method) {
+                    if (typeof method !== 'string')
+                        return undefined;
+                    return (...args) => call(service, method, args);
+                },
+            });
+            services.set(service, methods);
+            return methods;
+        },
+    });
+}
+//# sourceMappingURL=contract.js.map

package/dist/contract.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.js","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,EAAE;AACF,sGAAsG;AACtG,mGAAmG;AACnG,mGAAmG;AACnG,iCAAiC;AACjC,EAAE;AACF,qGAAqG;AACrG,mGAAmG;AACnG,0BAA0B;AAC1B,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAUvC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc;IAC5B,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAmB,CAAC;IAE5C,OAAO,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAgB,EAAE;QACnD,GAAG,CAAC,OAAO,EAAE,OAAwB;YACnC,uFAAuF;YACvF,+BAA+B;YAC/B,IAAI,OAAO,OAAO,KAAK,QAAQ;gBAAE,OAAO,SAAS,CAAC;YAClD,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;YACrC,IAAI,MAAM;gBAAE,OAAO,MAAM,CAAC;YAE1B,MAAM,OAAO,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;gBAC7C,GAAG,CAAC,EAAE,EAAE,MAAuB;oBAC7B,IAAI,OAAO,MAAM,KAAK,QAAQ;wBAAE,OAAO,SAAS,CAAC;oBACjD,OAAO,CAAC,GAAG,IAAe,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;gBAC7D,CAAC;aACF,CAAC,CAAC;YACH,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC/B,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC,CAAC;AACL,CAAC"}

package/dist/host-bridge.d.ts

@@ -0,0 +1,42 @@
+import type { HostBridge } from '@motujs/core';
+/** The slice of Next's App Router this bridge needs — structural, so it accepts the real
+ *  `useRouter()` return value without importing next/navigation into the framework. */
+export interface NextRouterLike {
+    push(href: string): void;
+    replace(href: string): void;
+    back(): void;
+}
+export interface NextHostBridgeOptions {
+    /** Use `router.replace` instead of `router.push` (navigation that should not stack history). */
+    replace?: boolean;
+    /** Event name dispatched on `document` for outward actions. Default 'motu:action'. */
+    actionEvent?: string;
+    /** Handle an action inline instead of (not as well as) dispatching the DOM event. */
+    onAction?: (name: string, detail: unknown) => void;
+}
+/**
+ * Build a HostBridge backed by the Next App Router.
+ *
+ * ```tsx
+ * 'use client';
+ * const router = useRouter();
+ * const host = useMemo(() => nextHostBridge(router), [router]);
+ * ```
+ *
+ * Actions surface as a DOM CustomEvent so host code can listen without the island knowing who is
+ * listening — the same shape the AngularJS adapter uses, so an island's outward contract does not
+ * change when the ocean recedes.
+ */
+export declare function nextHostBridge(router: NextRouterLike, opts?: NextHostBridgeOptions): HostBridge;
+/**
+ * A HostBridge for contexts with no router — server rendering, tests, or a host that has not wired
+ * one yet. Navigation intents are collected rather than performed, so nothing silently no-ops:
+ * assert on `intents` in a test, or read it while wiring a page up.
+ */
+export declare function collectingHostBridge(): HostBridge & {
+    intents: {
+        kind: string;
+        value: unknown;
+    }[];
+};
+//# sourceMappingURL=host-bridge.d.ts.map

package/dist/host-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-bridge.d.ts","sourceRoot":"","sources":["../src/host-bridge.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;uFACuF;AACvF,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,IAAI,IAAI,IAAI,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,gGAAgG;IAChG,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,sFAAsF;IACtF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;CACpD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,IAAI,GAAE,qBAA0B,GAAG,UAAU,CAcnG;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,GAAG;IAAE,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,EAAE,CAAA;CAAE,CAOnG"}

package/dist/host-bridge.js

@@ -0,0 +1,44 @@
+/**
+ * Build a HostBridge backed by the Next App Router.
+ *
+ * ```tsx
+ * 'use client';
+ * const router = useRouter();
+ * const host = useMemo(() => nextHostBridge(router), [router]);
+ * ```
+ *
+ * Actions surface as a DOM CustomEvent so host code can listen without the island knowing who is
+ * listening — the same shape the AngularJS adapter uses, so an island's outward contract does not
+ * change when the ocean recedes.
+ */
+export function nextHostBridge(router, opts = {}) {
+    const actionEvent = opts.actionEvent ?? 'motu:action';
+    return {
+        navigate(path) {
+            if (opts.replace)
+                router.replace(path);
+            else
+                router.push(path);
+        },
+        action(name, detail) {
+            opts.onAction?.(name, detail);
+            if (typeof document !== 'undefined') {
+                document.dispatchEvent(new CustomEvent(actionEvent, { detail: { name, detail }, bubbles: true }));
+            }
+        },
+    };
+}
+/**
+ * A HostBridge for contexts with no router — server rendering, tests, or a host that has not wired
+ * one yet. Navigation intents are collected rather than performed, so nothing silently no-ops:
+ * assert on `intents` in a test, or read it while wiring a page up.
+ */
+export function collectingHostBridge() {
+    const intents = [];
+    return {
+        intents,
+        navigate: (path) => void intents.push({ kind: 'navigate', value: path }),
+        action: (name, detail) => void intents.push({ kind: name, value: detail }),
+    };
+}
+//# sourceMappingURL=host-bridge.js.map

package/dist/host-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-bridge.js","sourceRoot":"","sources":["../src/host-bridge.ts"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,cAAc,CAAC,MAAsB,EAAE,OAA8B,EAAE;IACrF,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,IAAI,aAAa,CAAC;IACtD,OAAO;QACL,QAAQ,CAAC,IAAY;YACnB,IAAI,IAAI,CAAC,OAAO;gBAAE,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;;gBAClC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC;QACD,MAAM,CAAC,IAAY,EAAE,MAAe;YAClC,IAAI,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC9B,IAAI,OAAO,QAAQ,KAAK,WAAW,EAAE,CAAC;gBACpC,QAAQ,CAAC,aAAa,CAAC,IAAI,WAAW,CAAC,WAAW,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YACpG,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB;IAClC,MAAM,OAAO,GAAuC,EAAE,CAAC;IACvD,OAAO;QACL,OAAO;QACP,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;QACxE,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;KAC3E,CAAC;AACJ,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { nextHostBridge, collectingHostBridge } from './host-bridge.js';
+export type { NextRouterLike, NextHostBridgeOptions } from './host-bridge.js';
+export { Archipelago } from './archipelago.js';
+export { createRegion } from '@motujs/react';
+export type { CreateRegionOptions, RegionBinding } from '@motujs/react';
+export type { ArchipelagoProps } from './archipelago.js';
+export { Island, useMotuStore } from '@motujs/react';
+export type { IslandProps } from '@motujs/react';
+export { defineServices } from './services.js';
+export type { MotuServiceMap, MotuMethod } from './services.js';
+export { createContract } from './contract.js';
+export type { Contract } from './contract.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AACrE,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC7C,YAAY,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,YAAY,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEtD,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACrD,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,YAAY,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,19 @@
+// @motujs/adapter-next — the Next.js host adapter.
+//
+// Deliberately small. The AngularJS adapter is large because AngularJS is a foreign framework: it needs
+// channels to mirror $http/$scope into the store, and a custom-element definer to cross the boundary.
+// A Next host is already React, so neither applies — an island mounts directly. What remains is the
+// part that is genuinely host-specific: turning outward intents into App Router navigation, declaring
+// the browser-callable surface, and (in ./verify, loaded by `motu island verify`) policing the RSC
+// boundary an island must stay inside.
+//
+// The server dispatcher lives behind ./server so a client bundle can never pull it in by accident.
+export { nextHostBridge, collectingHostBridge } from './host-bridge.js';
+export { Archipelago } from './archipelago.js';
+// Re-exported so a Next host has one import site for the region surface.
+export { createRegion } from '@motujs/react';
+// Re-exported so a page places islands without also importing @motujs/react directly.
+export { Island, useMotuStore } from '@motujs/react';
+export { defineServices } from './services.js';
+export { createContract } from './contract.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,mDAAmD;AACnD,EAAE;AACF,wGAAwG;AACxG,sGAAsG;AACtG,oGAAoG;AACpG,sGAAsG;AACtG,mGAAmG;AACnG,uCAAuC;AACvC,EAAE;AACF,mGAAmG;AACnG,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAErE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,yEAAyE;AACzE,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAG7C,sFAAsF;AACtF,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAErD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/server.d.ts

@@ -0,0 +1,41 @@
+import type { MotuServiceMap } from './services.js';
+export interface MotuRouteOptions {
+    /**
+     * Coarse gate run before dispatch. Return false (or throw) to refuse. This is a cheap early exit,
+     * NOT the authorization boundary — that stays with the app's own data access rules.
+     */
+    authorize?: (req: Request, call: {
+        service: string;
+        method: string;
+    }) => boolean | Promise<boolean>;
+    /** Map a thrown error to a status. Default 500. */
+    statusForError?: (err: unknown) => number;
+    /** Called for every failure, so the host can log through its own reporting. */
+    onError?: (err: unknown, call: {
+        service: string;
+        method: string;
+    }) => void;
+}
+/**
+ * Build the POST handler for `app/api/motu/[...call]/route.ts`.
+ *
+ * The URL shape (`<base>/<service>/<method>`, args as a JSON array body) is HttpTransport's, so an
+ * island needs no Next-specific transport: point `configure(new HttpTransport('/api/motu'))` at this
+ * and the same component works against the real app here and against MockTransport in the lagoon.
+ *
+ * ```ts
+ * // app/api/motu/[...call]/route.ts
+ * import { createMotuRoute } from '@motujs/adapter-next/server'
+ * import { services } from '@/motu/server/services'
+ * export const { POST } = createMotuRoute(services)
+ * export const dynamic = 'force-dynamic'
+ * ```
+ */
+export declare function createMotuRoute(services: MotuServiceMap, opts?: MotuRouteOptions): {
+    POST: (req: Request, ctx: {
+        params: Promise<{
+            call?: string[];
+        }>;
+    }) => Promise<Response>;
+};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACpG,mDAAmD;IACnD,cAAc,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,CAAC;IAC1C,+EAA+E;IAC/E,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;CAC7E;AAOD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,cAAc,EAAE,IAAI,GAAE,gBAAqB;gBAC1D,OAAO,OAAO;QAAE,MAAM,EAAE,OAAO,CAAC;YAAE,IAAI,CAAC,EAAE,MAAM,EAAE,CAAA;SAAE,CAAC,CAAA;KAAE;EA+ChF"}

package/dist/server.js

@@ -0,0 +1,72 @@
+/** Unknown service/method is indistinguishable from an unknown URL: deny-by-default leaks nothing. */
+function notFound() {
+    return Response.json({ error: 'not found' }, { status: 404 });
+}
+/**
+ * Build the POST handler for `app/api/motu/[...call]/route.ts`.
+ *
+ * The URL shape (`<base>/<service>/<method>`, args as a JSON array body) is HttpTransport's, so an
+ * island needs no Next-specific transport: point `configure(new HttpTransport('/api/motu'))` at this
+ * and the same component works against the real app here and against MockTransport in the lagoon.
+ *
+ * ```ts
+ * // app/api/motu/[...call]/route.ts
+ * import { createMotuRoute } from '@motujs/adapter-next/server'
+ * import { services } from '@/motu/server/services'
+ * export const { POST } = createMotuRoute(services)
+ * export const dynamic = 'force-dynamic'
+ * ```
+ */
+export function createMotuRoute(services, opts = {}) {
+    async function POST(req, ctx) {
+        const segments = (await ctx.params)?.call ?? [];
+        if (segments.length !== 2)
+            return notFound();
+        const [service, method] = segments;
+        // Own-property lookups only: a plain `services[service]` would happily resolve 'constructor' or
+        // '__proto__' and hand back something that is not an exposed method at all.
+        if (!Object.prototype.hasOwnProperty.call(services, service))
+            return notFound();
+        const impl = services[service];
+        if (!impl || !Object.prototype.hasOwnProperty.call(impl, method))
+            return notFound();
+        const fn = impl[method];
+        if (typeof fn !== 'function')
+            return notFound();
+        if (opts.authorize) {
+            let allowed = false;
+            try {
+                allowed = await opts.authorize(req, { service, method });
+            }
+            catch {
+                allowed = false;
+            }
+            // 401, not 403: the caller is unauthenticated. Existence is already established by this point.
+            if (!allowed)
+                return Response.json({ error: 'unauthorized' }, { status: 401 });
+        }
+        let args;
+        try {
+            args = await req.json();
+        }
+        catch {
+            return Response.json({ error: 'body must be a JSON array of arguments' }, { status: 400 });
+        }
+        if (!Array.isArray(args)) {
+            return Response.json({ error: 'body must be a JSON array of arguments' }, { status: 400 });
+        }
+        try {
+            const result = await fn(...args);
+            // `undefined` is not JSON; a void method should still answer 200 with a body fetch can parse.
+            return Response.json(result ?? null);
+        }
+        catch (err) {
+            opts.onError?.(err, { service, method });
+            const status = opts.statusForError?.(err) ?? 500;
+            // The message is the app's own; do not leak a stack.
+            return Response.json({ error: err instanceof Error ? err.message : 'error' }, { status });
+        }
+    }
+    return { POST };
+}
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/services.d.ts

@@ -0,0 +1,24 @@
+/** A browser-callable method. Args and result cross the wire as JSON, so both must be serialisable. */
+export type MotuMethod = (...args: never[]) => Promise<unknown>;
+/** The callable surface: service name -> method name -> implementation. */
+export type MotuServiceMap = Record<string, Record<string, MotuMethod>>;
+/**
+ * Declare the browser-callable surface.
+ *
+ * Identity at runtime; its job is to fix the type so `typeof services` can be handed to
+ * `createContract` on the client. Keep the returned type — do not widen it to MotuServiceMap, or the
+ * contract loses every signature.
+ *
+ * ```ts
+ * export const services = defineServices({
+ *   directory: {
+ *     // Thin wrappers the APP owns: they build the request-scoped client, so the app's own
+ *     // row-level security decides what this user may read. motu never sees a credential.
+ *     async getSectors() { return getDirectorySectors(await createSupabaseServerClient()) },
+ *   },
+ * })
+ * export type AppServices = typeof services
+ * ```
+ */
+export declare function defineServices<const S extends MotuServiceMap>(services: S): S;
+//# sourceMappingURL=services.d.ts.map

package/dist/services.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.d.ts","sourceRoot":"","sources":["../src/services.ts"],"names":[],"mappings":"AAaA,uGAAuG;AACvG,MAAM,MAAM,UAAU,GAAG,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAEhE,2EAA2E;AAC3E,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAAC,KAAK,CAAC,CAAC,SAAS,cAAc,EAAE,QAAQ,EAAE,CAAC,GAAG,CAAC,CAE7E"}

package/dist/services.js

@@ -0,0 +1,34 @@
+// The contract seam for a Next host — the analogue of `@BrowserCallable` + `MotuEndpoint` on the
+// Jakarta side, and the piece that lets an island's server I/O be replayed by MockTransport.
+//
+// The Java seam needs an annotation processor because it has to DISCOVER which methods are callable
+// across a whole compiled codebase. TypeScript needs no such thing: the callable surface is an object
+// literal the app writes, and its type IS the contract. That is strictly better than codegen here —
+// there is no regeneration step to forget, and a signature change fails `tsc` at the call site
+// immediately rather than after someone re-runs a generator.
+//
+// Deny-by-default is structural rather than enforced: a method is reachable only if it appears in
+// this map. Nothing else in the app is exposed, and there is no pattern, prefix or convention that
+// could accidentally widen the surface.
+/**
+ * Declare the browser-callable surface.
+ *
+ * Identity at runtime; its job is to fix the type so `typeof services` can be handed to
+ * `createContract` on the client. Keep the returned type — do not widen it to MotuServiceMap, or the
+ * contract loses every signature.
+ *
+ * ```ts
+ * export const services = defineServices({
+ *   directory: {
+ *     // Thin wrappers the APP owns: they build the request-scoped client, so the app's own
+ *     // row-level security decides what this user may read. motu never sees a credential.
+ *     async getSectors() { return getDirectorySectors(await createSupabaseServerClient()) },
+ *   },
+ * })
+ * export type AppServices = typeof services
+ * ```
+ */
+export function defineServices(services) {
+    return services;
+}
+//# sourceMappingURL=services.js.map

package/dist/services.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"services.js","sourceRoot":"","sources":["../src/services.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,6FAA6F;AAC7F,EAAE;AACF,oGAAoG;AACpG,sGAAsG;AACtG,oGAAoG;AACpG,+FAA+F;AAC/F,6DAA6D;AAC7D,EAAE;AACF,kGAAkG;AAClG,mGAAmG;AACnG,wCAAwC;AAQxC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,cAAc,CAAiC,QAAW;IACxE,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "@motujs/adapter-next",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Scorbutics/motu.git",
+    "directory": "packages/adapters/next"
+  },
+  "homepage": "https://github.com/Scorbutics/motu#readme",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    },
+    "./verify": "./verify.mjs"
+  },
+  "dependencies": {
+    "@motujs/core": "0.1.0",
+    "@motujs/react": "0.1.0",
+    "@motujs/runtime": "0.1.0"
+  },
+  "peerDependencies": {
+    "next": ">=14",
+    "react": ">=18"
+  },
+  "files": [
+    "dist",
+    "verify.mjs"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/verify.mjs

@@ -0,0 +1,169 @@
+// Adapter-owned verify layer for Next.js islands. Core `motu island verify` runs the framework-neutral
+// static/config/runtime checks; it cannot judge the one coupling unique to this host — the RSC
+// boundary.
+//
+// Why this is the Next analogue of the AngularJS adapter's host-scope check: both police the ONE way an
+// island can silently bind itself to its host. On AngularJS that is reaching up the scope chain. On
+// Next it is reaching across the server/client split. An island that imports `next/headers`, or awaits
+// a server action, or omits 'use client', is a component only Next can render — and the lagoon is a
+// plain Vite SPA with no Next runtime at all. It would pass every static check and then fail to mount,
+// or worse, mount only in the host and never in the loop. The loop is the product; this keeps islands
+// inside it.
+//
+// Operates on the source text + the structured coupling the CLI extracts from element.ts via AST (no
+// ts-morph dependency here — the CLI owns parsing, the adapter owns semantics). Discovery is by package
+// export (`@motujs/adapter-next/verify`), resolved from the adapter the island actually imports.
+
+/** Modules that only exist on the server. Importing one makes the component unmountable in the lagoon. */
+const SERVER_ONLY = [
+  'server-only',
+  'next/headers',
+  'next/server',
+  'next/cache',
+  'next/og',
+];
+
+/** Next modules an island may use — the lagoon stubs exactly these (see the scaffolded next-stubs). */
+const STUBBED = ['next/link', 'next/image', 'next/navigation'];
+
+/**
+ * @param {{ source?: string, coupling?: { serverActions?: boolean } }} input
+ *   source   — the ui component's source text (the CLI reads the file; the adapter judges it)
+ *   coupling — structured `contract.coupling` from element.ts
+ * @returns {{ level: 'error'|'warn'|'ok', check: string, msg: string }[]}
+ */
+export function checkCoupling({ source, coupling, graph } = {}) {
+  const findings = [];
+  if (typeof source !== 'string') return findings;
+
+  // Strip comments so a rule is not tripped by prose ABOUT the rule (this file would fail itself).
+  const code = source.replace(/\/\*[\s\S]*?\*\//g, '').replace(/^\s*\/\/.*$/gm, '');
+
+  // Type-only imports are erased at build, so they cannot drag server code into a client bundle —
+  // and importing the SERVER'S service-map type is exactly how a typed contract is declared. Judging
+  // them as runtime imports would make the correct pattern unusable.
+  const runtimeCode = code.replace(/^\s*import\s+type\s[\s\S]*?from\s*['"][^'"]+['"];?/gm, '');
+  const imports = [...runtimeCode.matchAll(/(?:from|import)\s*\(?\s*['"]([^'"]+)['"]/g)].map((m) => m[1]);
+
+  // 1. Server-only imports — the island could never mount in the lagoon.
+  const serverImports = imports.filter((s) => SERVER_ONLY.some((m) => s === m || s.startsWith(m + '/')));
+  if (serverImports.length) {
+    for (const s of serverImports) {
+      findings.push({
+        level: 'error',
+        check: 'rsc-boundary',
+        msg: `imports server-only '${s}' — an island must mount in the lagoon, which has no Next runtime`,
+      });
+    }
+  } else {
+    // THE SAME QUESTION, ASKED OF THE WHOLE BUNDLE. The island's own file was never where this
+    // boundary lived: a Next app puts `'use server'` in an actions module and `server-only` in the
+    // lib beneath it, so an island four ordinary hops away from either still cannot be bundled for a
+    // Vite lagoon. Reported with the CHAIN, because "this island cannot mount" is useless without
+    // the hop that made it true — the failure it replaces was an unattributable rollup error.
+    const reached = [];
+    for (const node of graph ?? []) {
+      if (node.truncated) {
+        findings.push({
+          level: 'warn',
+          check: 'rsc-boundary',
+          msg: "the island's import graph was larger than this check walks, so the part beyond the cap is unexamined",
+        });
+        continue;
+      }
+      const hop = String(node.source ?? '')
+        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/^\s*\/\/.*$/gm, '')
+        .replace(/^\s*import\s+type\s[\s\S]*?from\s*['"][^'"]+['"];?/gm, '');
+      const bad = [...hop.matchAll(/(?:from|import)\s*\(?\s*['"]([^'"]+)['"]/g)]
+        .map((m) => m[1])
+        .filter((s) => SERVER_ONLY.some((m) => s === m || s.startsWith(m + '/')));
+      const action = /^\s*['"]use server['"]/m.test(hop);
+      if (bad.length || action) reached.push({ file: node.file, why: bad.length ? `imports server-only '${bad[0]}'` : "is a 'use server' module" });
+    }
+    if (reached.length) {
+      // ONE ROOT CAUSE, ONE FINDING. This emitted a line per offending module (three, then "…and N
+      // more"), which read as four separate problems and was counted as four every time the report
+      // was re-run. Measured across three cold-start benches: 50% of every finding an agent read in
+      // the `motu check` loop was a repeat of one already seen, and in the worst arm this single
+      // unfixable coupling accounted for 28 of the 48 findings read — the same four lines, seven
+      // times. The modules are evidence for one boundary violation, so they belong in one finding.
+      const [first, ...rest] = reached;
+      const more = rest.length
+        ? ` Also via ${rest.slice(0, 2).map((r) => r.file).join(', ')}${rest.length > 2 ? ` and ${rest.length - 2} other module(s)` : ''}.`
+        : '';
+      findings.push({
+        level: 'error',
+        check: 'rsc-boundary',
+        msg:
+          `reaches ${first.file}, which ${first.why} — the island itself is clean, but everything it ` +
+          `imports is in the same bundle, and the lagoon has no Next runtime to strip it.${more} ` +
+          `This is the APPLICATION's own coupling: it does not change until that import chain does.`,
+      });
+    } else {
+      findings.push({
+        level: 'ok',
+        check: 'rsc-boundary',
+        msg: `no server-only imports${graph?.length ? ` (island + ${graph.length} reachable module(s))` : ''}`,
+      });
+    }
+  }
+
+  // 2. 'use client'. An island always REACHES the browser — it mounts inside a custom element, which
+  //    only ever runs client-side — so the directive is not what makes it work today. It is what keeps
+  //    it working on the way out: motu's exit path is dropping the wrapper and importing the ui
+  //    component directly, and at that moment a hook-using component with no directive breaks the
+  //    first server page that renders it. So: an error once the component actually uses hooks (the
+  //    break is real and mechanical), a warning otherwise (a pure projection is safe either way).
+  const hasUseClient = /^\s*['"]use client['"]/.test(code);
+  const usesHooks = /\buse(State|Effect|Reducer|Ref|Callback|Memo|Context|LayoutEffect|Transition|Optimistic)\s*\(/.test(code);
+  if (hasUseClient) {
+    findings.push({ level: 'ok', check: 'use-client', msg: "declares 'use client'" });
+  } else if (usesHooks) {
+    findings.push({
+      level: 'error',
+      check: 'use-client',
+      msg: "uses hooks without 'use client' — mounts fine as an island, but breaks the moment the component is imported directly (the exit path)",
+    });
+  } else {
+    findings.push({
+      level: 'warn',
+      check: 'use-client',
+      msg: "no 'use client' — safe while it stays a pure projection; add it before the component grows state",
+    });
+  }
+
+  // 3. Server actions. A 'use server' function is an RPC the lagoon cannot serve; server I/O belongs
+  //    on the contract seam, which MockTransport can stand in for.
+  if (/['"]use server['"]/.test(code)) {
+    findings.push({
+      level: 'error',
+      check: 'rsc-boundary',
+      msg: "contains a 'use server' action — server I/O goes through the contract seam, not an RPC the lagoon cannot replay",
+    });
+  } else if (coupling?.serverActions) {
+    findings.push({
+      level: 'warn',
+      check: 'rsc-boundary',
+      msg: 'declares serverActions coupling — the lagoon cannot replay these; prefer the contract seam',
+    });
+  }
+
+  // 4. Stubbed Next modules, REPORTED ON THE OK LINE rather than as their own standing warning.
+  //
+  // `next-stubs` used to be a warning of its own, fired whenever the island imported one of these —
+  // legitimate imports, with no state in which the warning could be cleared except not using them.
+  // The information is worth having (what the lagoon renders for them is inert, so an island leaning
+  // on their real behaviour passes here and is still wrong in the host); the unclearable warning was
+  // not, because a warning nobody can action is how a project learns to skim past the real ones.
+  const stubbed = imports.filter((s) => STUBBED.includes(s));
+  if (stubbed.length) {
+    findings.push({
+      level: 'ok',
+      check: 'rsc-boundary',
+      msg: `uses ${stubbed.join(', ')} — INERT in the lagoon (navigation is a host intent), so this passes here and can still be wrong in the host`,
+    });
+  }
+
+  return findings;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.