@atolljs/react-island 0.1.12 → 0.1.13

package/dist/chunk-Q7NIXFLZ.js

@@ -0,0 +1,226 @@
+// src/index.tsx
+import { useEffect, useRef, useState } from "react";
+import { createPortal } from "react-dom";
+import {
+  connectIslandWorker,
+  contractWorkerOf,
+  islandAppNameOf,
+  mountIsland
+} from "@atolljs/islands";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function Island({
+  app,
+  worker,
+  client: clientProp,
+  workerOptions,
+  mode,
+  framework,
+  props,
+  onEvent,
+  onActivity,
+  slots,
+  onReady,
+  onError,
+  ref,
+  ...rest
+}) {
+  const containerRef = useRef(null);
+  const islandRef = useRef(null);
+  const [slotTargets, setSlotTargets] = useState({});
+  const propsRef = useRef(props);
+  const onEventRef = useRef(onEvent);
+  const onActivityRef = useRef(onActivity);
+  const slotsRef = useRef(slots);
+  const onReadyRef = useRef(onReady);
+  const onErrorRef = useRef(onError);
+  propsRef.current = props;
+  onEventRef.current = onEvent;
+  onActivityRef.current = onActivity;
+  slotsRef.current = slots;
+  onReadyRef.current = onReady;
+  onErrorRef.current = onError;
+  const setRefs = (el) => {
+    containerRef.current = el;
+    if (typeof ref === "function") ref(el);
+    else if (ref != null) ref.current = el;
+  };
+  const appName = app === void 0 ? "main" : islandAppNameOf(app);
+  useEffect(() => {
+    const el = containerRef.current;
+    if (el === null) return;
+    let cancelled = false;
+    let island = null;
+    const report = (err) => {
+      if (onErrorRef.current !== void 0) onErrorRef.current(err);
+      else console.error("[Island] mount failed:", err);
+    };
+    if (appName === void 0) {
+      report(
+        new Error(
+          "<Island> could not resolve an app name \u2014 pass the registry key or stamp the app with islandApp(name, app)"
+        )
+      );
+      return;
+    }
+    const resolvedWorker = worker ?? contractWorkerOf(app);
+    const client = clientProp ?? (resolvedWorker !== void 0 ? connectIslandWorker({
+      name: appName,
+      worker: resolvedWorker,
+      doorbell: mode !== "poll",
+      ...workerOptions
+    }) : void 0);
+    if (client === void 0) {
+      report(new Error("<Island> requires either `worker` or `client`"));
+      return;
+    }
+    const slotProxy = new Proxy({}, {
+      get: (_t, name) => (e) => {
+        setSlotTargets((prev) => prev[name] === e ? prev : { ...prev, [name]: e });
+      },
+      has: (_t, name) => slotsRef.current?.[name] != null
+    });
+    void (async () => {
+      try {
+        const handle = await mountIsland({
+          client,
+          el,
+          app: appName,
+          mode,
+          framework,
+          // Serialized across the wire either way — cast preserves inference
+          // for props types without an index signature.
+          props: propsRef.current ?? {},
+          onEvent: (name, payload) => onEventRef.current?.(name, payload),
+          onActivity: () => onActivityRef.current?.(),
+          slots: slotProxy
+        });
+        if (cancelled) {
+          handle.destroy();
+          return;
+        }
+        island = handle;
+        islandRef.current = handle;
+        onReadyRef.current?.(handle);
+      } catch (err) {
+        if (!cancelled) report(err);
+      }
+    })();
+    return () => {
+      cancelled = true;
+      islandRef.current = null;
+      island?.destroy();
+    };
+  }, [app, appName, clientProp]);
+  const propsJson = JSON.stringify(props ?? {});
+  useEffect(() => {
+    const island = islandRef.current;
+    if (island === null) return;
+    island.updateProps(props ?? {}).catch((err) => {
+      if (onErrorRef.current !== void 0) onErrorRef.current(err);
+      else console.error("[Island] updateProps failed:", err);
+    });
+  }, [propsJson]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("div", { ref: setRefs, ...rest }),
+    Object.entries(slotTargets).map(
+      ([name, el]) => el && slotsRef.current?.[name] != null ? createPortal(slotsRef.current[name], el, `atoll-slot-${name}`) : null
+    )
+  ] });
+}
+var SHELL_PROP_KEYS = /* @__PURE__ */ new Set([
+  "worker",
+  "client",
+  "workerOptions",
+  "mode",
+  "framework",
+  "onEvent",
+  "onActivity",
+  "onReady",
+  "onError",
+  "slots",
+  "fallback",
+  "containerProps"
+]);
+var splitProxyProps = (raw) => {
+  const shell = {};
+  const islandProps = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (SHELL_PROP_KEYS.has(key)) shell[key] = value;
+    else islandProps[key] = value;
+  }
+  return { shell, islandProps };
+};
+var lazyCache = /* @__PURE__ */ new WeakMap();
+function useLazyApp(loader) {
+  let state = lazyCache.get(loader);
+  if (state === void 0) {
+    state = {
+      promise: Promise.resolve().then(loader).then((mod) => {
+        const unwrapped = mod !== null && typeof mod === "object" && "default" in mod ? mod.default : mod;
+        const isContract = unwrapped !== null && typeof unwrapped === "object" && "app" in unwrapped;
+        const resolvedApp = isContract ? unwrapped.app : unwrapped;
+        const resolvedWorker = isContract ? unwrapped.worker : void 0;
+        state.value = resolvedApp;
+        state.worker = resolvedWorker;
+        return resolvedApp;
+      }).catch((err) => {
+        state.error = err;
+        throw err;
+      })
+    };
+    lazyCache.set(loader, state);
+  }
+  if (state.error !== void 0) throw state.error;
+  if (state.value === void 0) throw state.promise;
+  return { app: state.value, worker: state.worker };
+}
+function ProxyIsland({
+  source,
+  ...raw
+}) {
+  const resolved = source.kind === "static" ? { app: source.app } : useLazyApp(source.loader);
+  const { shell, islandProps } = splitProxyProps(raw);
+  const [ready, setReady] = useState(false);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    !ready ? shell.fallback : null,
+    /* @__PURE__ */ jsx(
+      Island,
+      {
+        app: resolved.app,
+        worker: shell.worker ?? resolved.worker,
+        client: shell.client,
+        workerOptions: shell.workerOptions,
+        mode: shell.mode,
+        framework: shell.framework,
+        props: islandProps,
+        onEvent: shell.onEvent,
+        onActivity: shell.onActivity,
+        slots: shell.slots,
+        onReady: (h) => {
+          shell.onReady?.(h);
+          setReady(true);
+        },
+        onError: shell.onError,
+        ...shell.containerProps
+      }
+    )
+  ] });
+}
+function islandComponent(app) {
+  const Proxy2 = (props) => /* @__PURE__ */ jsx(ProxyIsland, { source: { kind: "static", app }, ...props });
+  Proxy2.displayName = `IslandComponent(${islandAppNameOf(app) ?? "main"})`;
+  return Proxy2;
+}
+function lazyIsland(loader) {
+  const Proxy2 = (props) => /* @__PURE__ */ jsx(ProxyIsland, { source: { kind: "lazy", loader }, ...props });
+  Proxy2.displayName = "LazyIsland";
+  return Proxy2;
+}
+var index_default = Island;
+
+export {
+  Island,
+  islandComponent,
+  lazyIsland,
+  index_default
+};

package/dist/hostConfig.d.ts

@@ -0,0 +1,203 @@
+/**
+ * React-reconciler host adapter for the worker DOM backend.
+ *
+ * The generic instance state (op queues, instance ids, handler registry,
+ * doorbell, geometry) lives in `@atolljs/islands/worker`'s instance module.
+ * This file only wires the reconciler's create/append/update/remove/commit
+ * hooks to that backend.
+ *
+ * react-reconciler@0.34 reads ~150 fields off the config object. Most are
+ * stubs for features this renderer doesn't implement (hydration,
+ * persistence, resources, singletons, view transitions, test selectors,
+ * scope/hydratable APIs) — they exist so nothing throws when the reconciler
+ * destructures them; they are never invoked behind the `supports*` flags.
+ */
+import { bumpOpsVersion, type ElementInstance, type HostInstance, type TextInstance } from '@atolljs/islands/worker';
+declare const noop: () => void;
+declare const NULL: () => null;
+declare const FALSE: () => boolean;
+declare const TRUE: () => boolean;
+interface HostContext {
+    ns?: string;
+}
+export declare const hostConfig: {
+    rendererVersion: string;
+    rendererPackageName: string;
+    extraDevToolsConfig: null;
+    isPrimaryRenderer: boolean;
+    warnsIfNotActing: boolean;
+    supportsMutation: boolean;
+    supportsPersistence: boolean;
+    supportsHydration: boolean;
+    supportsResources: boolean;
+    supportsSingletons: boolean;
+    supportsMicrotasks: boolean;
+    supportsTestSelectors: boolean;
+    getPublicInstance: (instance: HostInstance) => unknown;
+    getRootHostContext: (container: unknown) => HostContext;
+    getChildHostContext: (parent: HostContext, type: string) => HostContext;
+    prepareForCommit: typeof NULL;
+    resetAfterCommit: typeof bumpOpsVersion;
+    createInstance: (type: string, props: Record<string, unknown>, rootContainer: unknown, hostContext: unknown, _internalHandle: unknown) => ElementInstance;
+    createTextInstance: (text: string, rootContainer: unknown, _hostContext: unknown, _internalHandle: unknown) => TextInstance;
+    finalizeInitialChildren: typeof FALSE;
+    shouldSetTextContent: typeof FALSE;
+    appendInitialChild: (parent: HostInstance, child: HostInstance) => void;
+    appendChild: (parent: HostInstance, child: HostInstance) => void;
+    appendChildToContainer: (container: unknown, child: HostInstance) => void;
+    insertBefore: (parent: HostInstance, child: HostInstance, before: HostInstance) => void;
+    insertInContainerBefore: (container: unknown, child: HostInstance, before: HostInstance) => void;
+    removeChild: (_parent: HostInstance, child: HostInstance) => void;
+    removeChildFromContainer: (_container: unknown, child: HostInstance) => void;
+    clearContainer: () => void;
+    commitUpdate: (instance: ElementInstance, _type: string, _oldProps: Record<string, unknown>, newProps: Record<string, unknown>, _internalHandle: unknown) => void;
+    commitTextUpdate: (instance: TextInstance, _oldText: string, newText: string) => void;
+    commitMount: typeof noop;
+    resetTextContent: (instance: ElementInstance) => void;
+    hideInstance: (instance: ElementInstance) => void;
+    unhideInstance: (instance: ElementInstance) => void;
+    hideTextInstance: (instance: TextInstance) => void;
+    unhideTextInstance: (instance: TextInstance, text: string) => void;
+    detachDeletedInstance: (instance: HostInstance) => void;
+    scheduleTimeout: typeof setTimeout;
+    cancelTimeout: typeof clearTimeout;
+    noTimeout: number;
+    scheduleMicrotask: (fn: () => void) => void;
+    setCurrentUpdatePriority: (p: number) => void;
+    getCurrentUpdatePriority: () => number;
+    resolveUpdatePriority: () => number;
+    resolveEventType: typeof NULL;
+    resolveEventTimeStamp: () => number;
+    trackSchedulerEvent: typeof noop;
+    shouldAttemptEagerTransition: typeof FALSE;
+    getInstanceFromNode: typeof NULL;
+    beforeActiveInstanceBlur: typeof noop;
+    afterActiveInstanceBlur: typeof noop;
+    preparePortalMount: typeof noop;
+    prepareScopeUpdate: typeof noop;
+    getInstanceFromScope: typeof NULL;
+    requestPostPaintCallback: typeof noop;
+    maySuspendCommit: typeof FALSE;
+    maySuspendCommitOnUpdate: typeof FALSE;
+    maySuspendCommitInSyncRender: typeof FALSE;
+    preloadInstance: typeof TRUE;
+    startSuspendingCommit: typeof noop;
+    suspendInstance: typeof noop;
+    suspendOnActiveViewTransition: typeof noop;
+    waitForCommitToBeReady: typeof NULL;
+    getSuspendedCommitReason: () => number;
+    NotPendingTransition: Readonly<{
+        pending: false;
+        data: null;
+        method: null;
+        action: null;
+    }>;
+    HostTransitionContext: import("react").Context<Readonly<{
+        pending: false;
+        data: null;
+        method: null;
+        action: null;
+    }>>;
+    resetFormInstance: typeof noop;
+    bindToConsole: (methodName: string, args: unknown[]) => (...args: unknown[]) => void;
+    createContainerChildSet: () => never[];
+    appendChildToContainerChildSet: typeof noop;
+    finalizeContainerChildren: typeof noop;
+    replaceContainerChildren: typeof noop;
+    cloneInstance: typeof NULL;
+    cloneMutableInstance: (instance: HostInstance) => HostInstance;
+    cloneMutableTextInstance: (instance: HostInstance) => HostInstance;
+    cloneHiddenInstance: (instance: HostInstance) => HostInstance;
+    cloneHiddenTextInstance: (instance: HostInstance) => HostInstance;
+    createFragmentInstance: () => {};
+    updateFragmentInstanceFiber: typeof noop;
+    commitNewChildToFragmentInstance: typeof noop;
+    deleteChildFromFragmentInstance: typeof noop;
+    createViewTransitionInstance: (name: string) => {
+        name: string;
+        autoName: null;
+    };
+    applyViewTransitionName: typeof noop;
+    restoreViewTransitionName: typeof noop;
+    cancelViewTransitionName: typeof noop;
+    cancelRootViewTransitionName: typeof noop;
+    restoreRootViewTransitionName: typeof noop;
+    cloneRootViewTransitionContainer: typeof noop;
+    removeRootViewTransitionClone: typeof noop;
+    measureInstance: typeof NULL;
+    measureClonedInstance: typeof NULL;
+    wasInstanceInViewport: typeof FALSE;
+    hasInstanceChanged: typeof FALSE;
+    hasInstanceAffectedParent: typeof FALSE;
+    startViewTransition: typeof NULL;
+    startGestureTransition: typeof NULL;
+    stopViewTransition: typeof noop;
+    addViewTransitionFinishedListener: typeof noop;
+    getCurrentGestureOffset: () => number;
+    isSuspenseInstancePending: typeof FALSE;
+    isSuspenseInstanceFallback: typeof FALSE;
+    getSuspenseInstanceFallbackErrorDetails: () => {};
+    registerSuspenseInstanceRetry: typeof noop;
+    getNextHydratableSibling: typeof NULL;
+    getNextHydratableSiblingAfterSingleton: typeof NULL;
+    getFirstHydratableChild: typeof NULL;
+    getFirstHydratableChildWithinContainer: typeof NULL;
+    getFirstHydratableChildWithinActivityInstance: typeof NULL;
+    getFirstHydratableChildWithinSingleton: typeof NULL;
+    getFirstHydratableChildWithinSuspenseInstance: typeof NULL;
+    canHydrateInstance: typeof NULL;
+    canHydrateTextInstance: typeof NULL;
+    canHydrateActivityInstance: typeof NULL;
+    canHydrateSuspenseInstance: typeof NULL;
+    canHydrateFormStateMarker: typeof NULL;
+    isFormStateMarkerMatching: typeof FALSE;
+    hydrateInstance: typeof noop;
+    hydrateTextInstance: typeof noop;
+    hydrateActivityInstance: typeof noop;
+    hydrateSuspenseInstance: typeof noop;
+    getNextHydratableInstanceAfterActivityInstance: typeof NULL;
+    getNextHydratableInstanceAfterSuspenseInstance: typeof NULL;
+    commitHydratedInstance: typeof noop;
+    commitHydratedContainer: typeof noop;
+    commitHydratedSuspenseInstance: typeof noop;
+    finalizeHydratedChildren: typeof FALSE;
+    flushHydrationEvents: typeof noop;
+    clearActivityBoundary: typeof FALSE;
+    clearSuspenseBoundary: typeof FALSE;
+    clearActivityBoundaryFromContainer: typeof FALSE;
+    clearSuspenseBoundaryFromContainer: typeof FALSE;
+    hideDehydratedBoundary: typeof noop;
+    unhideDehydratedBoundary: typeof noop;
+    shouldDeleteUnhydratedTailInstances: typeof FALSE;
+    diffHydratedPropsForDevWarnings: typeof NULL;
+    diffHydratedTextForDevWarnings: typeof NULL;
+    describeHydratableInstanceForDevWarnings: typeof NULL;
+    validateHydratableInstance: typeof TRUE;
+    validateHydratableTextInstance: typeof TRUE;
+    isHostHoistableType: typeof FALSE;
+    getHoistableRoot: typeof NULL;
+    getResource: typeof NULL;
+    acquireResource: typeof noop;
+    releaseResource: typeof noop;
+    hydrateHoistable: typeof noop;
+    mountHoistable: typeof noop;
+    unmountHoistable: typeof noop;
+    createHoistableInstance: typeof NULL;
+    prepareToCommitHoistables: typeof noop;
+    mayResourceSuspendCommit: typeof FALSE;
+    preloadResource: typeof TRUE;
+    suspendResource: typeof noop;
+    resolveSingletonInstance: typeof NULL;
+    acquireSingletonInstance: typeof noop;
+    releaseSingletonInstance: typeof noop;
+    isHostSingletonType: typeof FALSE;
+    isSingletonScope: typeof FALSE;
+    findFiberRoot: typeof NULL;
+    getBoundingRect: typeof NULL;
+    getTextContent: typeof NULL;
+    isHiddenSubtree: typeof FALSE;
+    matchAccessibilityRole: typeof FALSE;
+    setFocusIfFocusable: typeof FALSE;
+    setupIntersectionObserver: typeof noop;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,165 @@
+import type { HTMLAttributes, ReactElement, ReactNode, Ref } from 'react';
+import type { IslandAppLike, IslandAppProps, IslandClient, IslandContract, IslandContractEventHandler, IslandContractProps, IslandHandle, IslandWorkerOptions, Mode } from '@atolljs/islands';
+export type { IslandAppLike, IslandAppProps, IslandHandle };
+/** What `app` accepts: the registry name, or a component/def to resolve. */
+export type IslandAppRef<A> = A | string;
+export interface IslandProps<A = string> extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    /**
+     * Which app to mount — the `apps` registry key ('charts') or the app
+     * itself (`ChartsApp`, an `islandApp(...)`-stamped def, `{ imperative }`).
+     * A reference infers `props` from its own signature. Optional against a
+     * `defineMonoWorker` (1:1) worker — its single app mounts regardless.
+     */
+    app?: IslandAppRef<A>;
+    /**
+     * How to reach the worker — either a bundler-detectable factory
+     * `() => new Worker(new URL('./x.worker.ts', import.meta.url), { type: 'module' })`
+     * (the common case) or a pre-connected `IslandClient`. Exactly one is required.
+     */
+    worker?: (() => Worker) | URL;
+    client?: IslandClient;
+    /**
+     * Extra client options — taskTimeout, respawn, lazy… (always one
+     * dedicated worker, no pool). `doorbell: false` builds the shorthand client message-only — no
+     * SharedArrayBuffer, no COOP/COEP requirement (same as `mode: 'poll'` on
+     * a direct `mountIsland` shorthand mount).
+     */
+    workerOptions?: IslandWorkerOptions & {
+        doorbell?: boolean;
+    };
+    /**
+     * Initial flush mode — 'push' (default) drives op replay off the
+     * shared-memory doorbell (needs cross-origin isolation); 'poll' drains on
+     * a 50ms interval and, for `worker`-shorthand mounts, builds the client
+     * doorbell-free — no SharedArrayBuffer, no COOP/COEP requirement.
+     * Mount-time only; switch later via the handle's `setMode`.
+     */
+    mode?: Mode;
+    /** Renderer tag reported to devtools on mount ('react', 'vue', …). */
+    framework?: string;
+    /** Initial + updated root props — serialized to the worker. */
+    props?: IslandAppProps<A>;
+    /** Island → shell channel: every `emit` op lands here. */
+    onEvent?: (name: string, payload: unknown) => void;
+    /**
+     * Transclusion slots — a worker `<div data-atoll-slot="name">` becomes a
+     * React portal mount point. The element's contents are rendered by React
+     * on the main thread; the worker only owns the empty anchor.
+     */
+    slots?: Record<string, ReactNode>;
+    /** Fired after each applied op batch — stats hooks. */
+    onActivity?: () => void;
+    /** The mounted handle (pid, updateProps, flush, setMode…) once ready. */
+    onReady?: (island: IslandHandle) => void;
+    /** Mount/update errors surface here instead of an unhandled rejection. */
+    onError?: (err: unknown) => void;
+    /** The container div (React 19 ref-as-prop). */
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Island<A = string>({ app, worker, client: clientProp, workerOptions, mode, framework, props, onEvent, onActivity, slots, onReady, onError, ref, ...rest }: IslandProps<A>): ReactElement;
+/**
+ * Props consumed by a proxy component itself — everything else forwards to
+ * the island as its props.
+ */
+export interface IslandShellProps {
+    /** How to reach the worker — see IslandProps.worker/client. */
+    worker?: (() => Worker) | URL;
+    client?: IslandClient;
+    /** See IslandProps.workerOptions — `doorbell` included. */
+    workerOptions?: IslandWorkerOptions & {
+        doorbell?: boolean;
+    };
+    /** Initial flush mode — see IslandProps.mode. */
+    mode?: Mode;
+    /** Devtools renderer tag — see IslandProps.framework. */
+    framework?: string;
+    /** Island → shell channel: every `emit` op lands here. */
+    onEvent?: (name: string, payload: unknown) => void;
+    /** Fired after each applied op batch. */
+    onActivity?: () => void;
+    /** The mounted handle (pid, updateProps, flush, setMode…) once ready. */
+    onReady?: (island: IslandHandle) => void;
+    /** Mount/update errors surface here instead of an unhandled rejection. */
+    onError?: (err: unknown) => void;
+    /** Transclusion slots — see IslandProps.slots. */
+    slots?: Record<string, ReactNode>;
+    /** Rendered while the worker mounts — the lazy-side fallback. */
+    fallback?: ReactNode;
+    /**
+     * Attributes for the island's container div (className/id/style/data-*).
+     * `onError` is omitted — it collides with the mount-error callback.
+     */
+    containerProps?: Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onError'>;
+}
+type LazyModule<A> = A | {
+    default: A;
+} | {
+    app: A | string;
+    worker?: (() => Worker) | URL;
+};
+/**
+ * The app a lazy module resolves to — unwraps `{ default: A }` and the
+ * contract-module shape `{ app: A, worker? }`, passes bare A through.
+ */
+export type LazyResolvedApp<T extends Promise<unknown>> = [
+    Awaited<T>
+] extends [never] ? string : Awaited<T> extends {
+    readonly islandContract: true;
+} ? Awaited<T> : Awaited<T> extends {
+    app: infer A;
+} ? A : Awaited<T> extends {
+    default: infer D;
+} ? D : Awaited<T>;
+/**
+ * `islandComponent<P>('charts')` — a proxy component for a worker app that
+ * the shell NEVER imports. `P` is the contract (usually an `import type` of
+ * the worker component's props); the string is the registry key. Against a
+ * `defineMonoWorker` (1:1) worker the name can be omitted entirely.
+ *
+ * ```tsx
+ * import type { TableProps } from './worker/apps.js';
+ * const TableIsland = islandComponent<TableProps>('data-table');
+ * <TableIsland worker={renderWorker} filter={filter} desc={desc} />
+ * ```
+ */
+/**
+ * `islandComponent(checkoutContract)` — the cross-framework facade: a
+ * worker app described by `defineIslandContract` mounts by the contract's
+ * `app` key, props come from its schema, and `onEvent` narrows to the
+ * declared event vocabulary. The shell imports the CONTRACT module only —
+ * never the component or its framework.
+ */
+export declare function islandComponent<C extends IslandContract>(app: C): (props: IslandContractProps<C> & Omit<IslandShellProps, 'onEvent'> & {
+    onEvent?: IslandContractEventHandler<C>;
+}) => ReactElement;
+export declare function islandComponent<P extends object = Record<string, unknown>>(app?: string): (props: P & IslandShellProps) => ReactElement;
+export declare function islandComponent<A extends IslandAppLike>(app: A): (props: IslandAppProps<A> & IslandShellProps) => ReactElement;
+/**
+ * `lazyIsland(() => import('./worker/apps.js').then(m => ({ default: m.ChartsApp })))`
+ * — the `React.lazy` mirror for worker apps. The returned component suspends
+ * while the module loads (wrap it in `<Suspense>`), then proxies all props to
+ * the island. The dynamic import gives bundlers a split point, so the worker
+ * component's dependencies only load when the island mounts.
+ *
+ * ```tsx
+ * const ChartsIsland = lazyIsland(() => import('./worker/apps.js').then(m => ({ default: m.ChartsApp })));
+ * <Suspense fallback="loading…"><ChartsIsland width={520} worker={renderWorker} /></Suspense>
+ * ```
+ *
+ * CONTRACT MODULES: for `defineMonoWorker` (1:1) topologies the loader can
+ * resolve `{ app, worker }` — the island then carries its own worker factory
+ * and call sites need no `worker` prop at all:
+ *
+ * ```ts
+ * // worker/map.island.ts — shell-safe contract (never the .worker.ts entry
+ * // itself: defining a worker installs instance globals, don't import it)
+ * export { mapApp as app } from './map.js';
+ * export const worker = () => new Worker(new URL('./map.worker.ts', import.meta.url), { type: 'module' });
+ *
+ * // shell.tsx
+ * const MapIsland = lazyIsland(() => import('./worker/map.island.js'));
+ * <MapIsland />  // app + worker both from the contract
+ * ```
+ */
+export declare function lazyIsland<T extends Promise<LazyModule<IslandAppLike>>>(loader: () => T): (props: IslandAppProps<LazyResolvedApp<T>> & IslandShellProps) => ReactElement;
+export default Island;

package/dist/index.js

@@ -0,0 +1,12 @@
+import {
+  Island,
+  index_default,
+  islandComponent,
+  lazyIsland
+} from "./chunk-Q7NIXFLZ.js";
+export {
+  Island,
+  index_default as default,
+  islandComponent,
+  lazyIsland
+};

package/dist/reactInstance.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The React-runtime half of a React island — `react`, `react-reconciler`
+ * and the host config live HERE so a worker bundle whose registry holds only
+ * non-React apps (Vue/Svelte/Solid/Angular/imperative) never pulls the
+ * reconciler in. `@atolljs/react-island/worker` reaches this module through
+ * `reactIslandApp`'s mount, inside the RenderedIslandApp contract.
+ */
+import type { ReactElement } from 'react';
+import Reconciler from 'react-reconciler';
+/**
+ * A mounted React tree — carries its own reconciler + container and the
+ * `render`/`unmountTree`/`flush` verbs the adapter maps onto the
+ * RenderedHandle contract. Identity (key/app/pid) lives on the core
+ * Instance — this object is only the renderer half.
+ */
+export interface ReactInstance {
+    reconciler: ReturnType<typeof Reconciler>;
+    container: unknown;
+    /**
+     * Commit synchronously around `fn`.
+     *
+     * In 0.34, `updateContainer`/setState only *schedule* work — the actual
+     * render+commit happens when the root scheduler task runs (a macrotask via
+     * the `scheduler` package). `flushSyncFromReconciler` pins the update
+     * priority to the discrete/sync lane for the duration of `fn` and
+     * `flushSyncWork` flushes pending sync work, so by the time it returns the
+     * mutation hooks have run and the instance's op queue is full.
+     */
+    sync(fn: () => void): void;
+    /** Schedule a mount/re-render of `el` — call inside `sync`. */
+    render(el: ReactElement): void;
+    /** Schedule the detach — emits the remove ops; call inside `sync`. */
+    unmountTree(): void;
+    /** Passive effects + pending sync work — the `flush` task's React branch. */
+    flush(): void;
+}
+/**
+ * Legacy root (tag 0) — no concurrent features. Container creation is
+ * per-instance, not module-level, so a second mount() can't collide with the
+ * first instance's tree.
+ */
+export declare function createReactInstance(instance: string): ReactInstance;

package/dist/slot.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A transclusion slot — renders a leaf element marked `data-atoll-slot`.
+ * The element's BOX belongs to this worker tree (layout/style ops apply as
+ * usual); its CONTENTS belong to the shell: when the create op lands on the
+ * main thread, the island's `slots[name]` callback gets the real element
+ * and can mount anything inside — a canvas, Monaco, a main-thread React
+ * root — all real DOM with real events and zero wire traffic.
+ *
+ * Must stay a LEAF in this tree: if worker-side children were appended here
+ * their ops would interleave with shell-owned content. There is also no
+ * measurement channel — the island knows the box it laid out, not the
+ * pixel size the shell put inside it.
+ */
+import type { ReactElement } from 'react';
+export declare function Slot({ name, style }: {
+    name: string;
+    style?: Record<string, unknown>;
+}): ReactElement;

package/dist/subIsland.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `SubIsland` — the original name for a nested mount, kept as an alias.
+ * New code uses `Island` from `@atolljs/react-island/worker`, which is the
+ * same component (and props) the page uses: inside a worker its container
+ * is a proxy element, so `mountIsland` routes to the nested path.
+ *
+ *   const subWorker = () =>
+ *     new Worker(new URL('./counter.worker.tsx', import.meta.url), { type: 'module' });
+ *
+ *   function Dashboard() {
+ *     return <Island worker={subWorker} app="counter" props={{ label: 'nested' }} />;
+ *   }
+ *
+ * `SubIsland` differs only in defaults: it tags devtools mounts as
+ * `framework: 'react'` and stamps `data-atoll-sub-island` on its host div.
+ */
+import type { CSSProperties, ReactElement } from 'react';
+import type { IslandClient, IslandHandle, Mode } from '@atolljs/islands/worker';
+export interface SubIslandProps {
+    /** Bundler-detectable sub-worker entry, evaluated INSIDE this worker. */
+    worker?: (() => Worker) | URL;
+    /** A shared `connectIslandWorker` client built inside this worker. */
+    client?: IslandClient;
+    /** Registry app name — a key of the sub-worker's `apps` map. */
+    app?: string;
+    /** Wire props for the sub-app's root — serializable data only. */
+    props?: Record<string, unknown>;
+    /** Sub-island emit channel — a plain worker-side call. */
+    onEvent?: (name: string, payload: unknown) => void;
+    /** Flush transport — 'push' (default) or 'poll'. */
+    mode?: Mode;
+    className?: string;
+    style?: CSSProperties;
+    /** Receives the mounted handle (pid, instance, updateProps, destroy). */
+    onReady?: (handle: IslandHandle) => void;
+}
+export declare function SubIsland(props: SubIslandProps): ReactElement;

package/dist/worker.d.ts

@@ -0,0 +1,87 @@
+/**
+ * `@atolljs/react-island/worker` — the worker-side half of React
+ * islands: `reactIslandApp(Component)` wraps a React component as a islands
+ * `RenderedIslandApp`, so it can sit in a `definePolyWorker` `apps`
+ * registry beside Vue/Svelte/Solid/Angular and imperative apps:
+ *
+ *   // render.worker.ts — React-only registry
+ *   import { defineReactPolyWorker } from '@atolljs/react-island/worker';
+ *   export const renderWorker = defineReactPolyWorker({
+ *     apps: { controls: ControlsApp, charts: ChartsApp },
+ *   });
+ *
+ *   // one-app worker
+ *   import { defineReactMonoWorker } from '@atolljs/react-island/worker';
+ *   export const worker = defineReactMonoWorker(ChartsApp);
+ *
+ *   // mixed-framework registry — compose the adapters directly
+ *   import { definePolyWorker } from '@atolljs/islands/worker';
+ *   import { reactIslandApp } from '@atolljs/react-island/worker';
+ *   export const renderWorker = definePolyWorker({ apps: {
+ *     charts: reactIslandApp(ChartsApp),
+ *     badge: vueIslandApp(VueBadge),
+ *   }});
+ *
+ * The reconciler + host config live in `reactInstance.ts`/`hostConfig.ts`:
+ * importing THIS module is what pulls `react` + `react-reconciler` into a
+ * worker bundle (once, shared across every React app in the registry).
+ * `@atolljs/islands/worker` itself stays framework-neutral — non-React
+ * registries never see this code.
+ */
+import { type ComponentType } from 'react';
+import type { SharedMemory, WorkerDefinition } from '@atolljs/core';
+import type { DoorbellSpec, ImperativeIslandApp, IslandContract, IslandWorkerMethods, RenderedIslandApp } from '@atolljs/islands/worker';
+export { emit, runInInstance } from '@atolljs/islands/worker';
+export { Slot } from './slot.js';
+export { Island, islandComponent, lazyIsland } from './index.js';
+export type { IslandProps, IslandShellProps, IslandAppRef } from './index.js';
+export { connectIslandWorker } from '@atolljs/islands/worker';
+export { SubIsland } from './subIsland.js';
+export type { SubIslandProps } from './subIsland.js';
+type AnyComponent = ComponentType<Record<string, unknown>>;
+/**
+ * Wrap a React component as a `RenderedIslandApp` — `mount` creates the
+ * instance's reconciler + container and renders the initial tree inside the
+ * sync lane; `update` re-renders with new props (the reconciler diffs, only
+ * changed ops emit); `sync` is the dispatch-time commit pin; `dispose`
+ * schedules the unmount; `flush` drains passive effects + pending sync work
+ * for the `flush` task.
+ *
+ * A stamped component (`islandApp('name', Comp)`) keeps its stamp through
+ * the wrap, so registry warn-checks and `defineMonoWorker` name resolution
+ * still see the shell-facing name.
+ */
+export declare function reactIslandApp(App: AnyComponent, contract?: IslandContract): RenderedIslandApp;
+/** Stamp + wrap in one step — `reactIsland('charts', ChartsApp)` yields the
+ *  registry value AND the name the shell mounts by. */
+export declare const reactIsland: (name: string, App: AnyComponent, contract?: IslandContract) => RenderedIslandApp & {
+    readonly islandAppName: string;
+};
+export interface ReactPolyWorkerRegistry {
+    /**
+     * Name → React component (or `{ imperative }` app) registry, mirroring
+     * `definePolyWorker({ apps })`. Components pass through `reactIslandApp`;
+     * imperative defs and already-wrapped apps (e.g. `reactIsland()` results)
+     * register as-is.
+     */
+    apps: Record<string, AnyComponent | ImperativeIslandApp | RenderedIslandApp>;
+    /** Doorbell contract override — forwarded to `definePolyWorker`. */
+    sharedMemory?: SharedMemory<DoorbellSpec>;
+}
+/**
+ * `definePolyWorker` for React apps — maps each component in the registry
+ * through `reactIslandApp` and delegates. One worker, many React islands;
+ * for a mixed-framework registry call `definePolyWorker` with the per-app
+ * adapters instead.
+ */
+export declare function defineReactPolyWorker(registry: ReactPolyWorkerRegistry, options?: {
+    sharedMemory?: SharedMemory<DoorbellSpec>;
+}): WorkerDefinition<DoorbellSpec, IslandWorkerMethods>;
+/**
+ * `defineMonoWorker` for React apps — one worker pinned to a single
+ * component (or `{ imperative }` app), the isolated-bundle host shape.
+ */
+export declare function defineReactMonoWorker(app: AnyComponent | ImperativeIslandApp | RenderedIslandApp, options?: {
+    sharedMemory?: SharedMemory<DoorbellSpec>;
+    contract?: IslandContract;
+}): WorkerDefinition<DoorbellSpec, IslandWorkerMethods>;

package/dist/worker.js

@@ -0,0 +1,450 @@
+import {
+  Island,
+  islandComponent,
+  lazyIsland
+} from "./chunk-Q7NIXFLZ.js";
+
+// src/worker.ts
+import { createElement } from "react";
+import {
+  defineMonoWorker,
+  definePolyWorker,
+  islandApp,
+  islandAppNameOf,
+  withContract
+} from "@atolljs/islands/worker";
+
+// src/reactInstance.ts
+import Reconciler from "react-reconciler";
+
+// src/hostConfig.ts
+import { createContext } from "react";
+import {
+  bumpOpsVersion,
+  docForInstance,
+  getActiveInstance,
+  getLastActiveInstance,
+  instances,
+  newElement,
+  newText,
+  pushOp,
+  serializeProps,
+  unregisterHandler
+} from "@atolljs/islands/worker";
+var currentUpdatePriority = 0;
+var DEFAULT_EVENT_PRIORITY = 32;
+var NotPendingTransition = Object.freeze({ pending: false, data: null, method: null, action: null });
+var HostTransitionContext = createContext(NotPendingTransition);
+var noop = () => {
+};
+var NULL = () => null;
+var FALSE = () => false;
+var TRUE = () => true;
+var publicInstanceFor = (instance) => docForInstance(instance.instance).adopt(instance);
+var containerParentId = (container) => {
+  const inst = container?.instance;
+  if (inst && typeof inst.id === "number") return inst.id;
+  const id = container?.id;
+  return typeof id === "number" ? id : 0;
+};
+var containerInstance = (container) => {
+  const inner = container?.instance;
+  if (typeof inner === "string") return inner;
+  return inner?.instance ?? (getActiveInstance() !== "" ? getActiveInstance() : getLastActiveInstance());
+};
+var SVG_NS = "http://www.w3.org/2000/svg";
+var MATH_NS = "http://www.w3.org/1998/Math/MathML";
+var HTML_CTX = Object.freeze({});
+var SVG_CTX = Object.freeze({ ns: SVG_NS });
+var MATH_CTX = Object.freeze({ ns: MATH_NS });
+var childHostContextFor = (parent, type) => {
+  if (type === "svg") return SVG_CTX;
+  if (type === "math") return MATH_CTX;
+  if (type === "foreignObject" || type === "desc" || type === "title") return HTML_CTX;
+  return parent;
+};
+var hostConfig = {
+  // Identity / capabilities
+  rendererVersion: "0.34.0",
+  rendererPackageName: "@atolljs/react-island",
+  extraDevToolsConfig: null,
+  isPrimaryRenderer: true,
+  warnsIfNotActing: false,
+  supportsMutation: true,
+  supportsPersistence: false,
+  supportsHydration: false,
+  supportsResources: false,
+  supportsSingletons: false,
+  supportsMicrotasks: false,
+  supportsTestSelectors: false,
+  getPublicInstance: (instance) => publicInstanceFor(instance),
+  // Host contexts must be non-null objects (the reconciler pushes them on a
+  // context stack and warns "Expected host context to exist" on null). This
+  // renderer carries no per-subtree context — echo a single frozen sentinel.
+  // Host contexts must be non-null objects (the reconciler warns on null).
+  // Ours carries only the element namespace: <svg>/<math> enter their
+  // namespaces; foreignObject/desc/title are HTML-integration points that
+  // flip children back to HTML; everything else inherits the parent's.
+  // For portals, this becomes the context the portal subtree renders under —
+  // derived from the container's own namespace so children of an SVG portal
+  // target (recharts zIndex <g> layers) stay in the SVG namespace.
+  getRootHostContext: (container) => {
+    const ns = container?.instance?.ns;
+    if (ns === SVG_NS) return SVG_CTX;
+    if (ns === MATH_NS) return MATH_CTX;
+    return HTML_CTX;
+  },
+  getChildHostContext: (parent, type) => childHostContextFor(parent, type),
+  prepareForCommit: NULL,
+  // The doorbell: every commit bumps opsVersion once — the main thread's
+  // observe() wakes (Atomics.waitAsync) and flushes the op queue, so commits
+  // made outside task calls (effects, timers, async setState) arrive as a
+  // push instead of waiting on a poll. Task-returned ops bump too; the
+  // follow-up flush just finds an empty queue.
+  resetAfterCommit: bumpOpsVersion,
+  // Creation — emit ops
+  createInstance: (type, props, rootContainer, hostContext, _internalHandle) => {
+    const ctx = childHostContextFor(hostContext, type);
+    const instance = newElement(type, props, ctx.ns, containerInstance(rootContainer));
+    pushOp(instance.instance, {
+      t: "create",
+      id: instance.id,
+      type,
+      props: instance.props,
+      ns: instance.ns
+    });
+    return instance;
+  },
+  createTextInstance: (text, rootContainer, _hostContext, _internalHandle) => {
+    const instance = newText(text, containerInstance(rootContainer));
+    pushOp(instance.instance, { t: "text", id: instance.id, text });
+    return instance;
+  },
+  finalizeInitialChildren: FALSE,
+  // Always false: string/number children become real text instances, so the
+  // tree arrives as linear ops and `utext` handles every text update. (The
+  // `true` path would expect commitUpdate to set textContent from
+  // props.children — which we deliberately never serialize.)
+  shouldSetTextContent: FALSE,
+  // Tree wiring — emit ops
+  appendInitialChild: (parent, child) => {
+    pushOp(parent.instance, { t: "append", parent: parent.id, child: child.id });
+  },
+  appendChild: (parent, child) => {
+    pushOp(parent.instance, { t: "append", parent: parent.id, child: child.id });
+  },
+  appendChildToContainer: (container, child) => {
+    pushOp(child.instance, { t: "append", parent: containerParentId(container), child: child.id });
+  },
+  insertBefore: (parent, child, before) => {
+    pushOp(parent.instance, { t: "append", parent: parent.id, child: child.id, before: before.id });
+  },
+  insertInContainerBefore: (container, child, before) => {
+    pushOp(child.instance, {
+      t: "append",
+      parent: containerParentId(container),
+      child: child.id,
+      before: before.id
+    });
+  },
+  removeChild: (_parent, child) => {
+    pushOp(child.instance, { t: "remove", child: child.id });
+  },
+  removeChildFromContainer: (_container, child) => {
+    pushOp(child.instance, { t: "remove", child: child.id });
+  },
+  // No instance argument — routed by the task's active instance (only reached
+  // inside mount/remount's syncCommit).
+  clearContainer: () => {
+    pushOp(getActiveInstance(), { t: "clear" });
+  },
+  // Updates — emit ops
+  commitUpdate: (instance, _type, _oldProps, newProps, _internalHandle) => {
+    instance.props = serializeProps(instance, newProps);
+    pushOp(instance.instance, { t: "update", id: instance.id, props: instance.props });
+  },
+  commitTextUpdate: (instance, _oldText, newText2) => {
+    instance.text = newText2;
+    pushOp(instance.instance, { t: "utext", id: instance.id, text: newText2 });
+  },
+  commitMount: noop,
+  // Unreachable while shouldSetTextContent is always false; still emit the
+  // spec'd op for completeness.
+  resetTextContent: (instance) => {
+    instance.props = {};
+    pushOp(instance.instance, { t: "update", id: instance.id, props: {} });
+  },
+  // Suspense visibility — `hidden` is a global HTML attribute the main
+  // thread applies like any other prop.
+  hideInstance: (instance) => {
+    pushOp(instance.instance, { t: "update", id: instance.id, props: { ...instance.props, hidden: true } });
+  },
+  unhideInstance: (instance) => {
+    pushOp(instance.instance, { t: "update", id: instance.id, props: { ...instance.props } });
+  },
+  hideTextInstance: (instance) => {
+    pushOp(instance.instance, { t: "utext", id: instance.id, text: "" });
+  },
+  unhideTextInstance: (instance, text) => {
+    pushOp(instance.instance, { t: "utext", id: instance.id, text });
+  },
+  // GC hook — drop the record and its handler slots.
+  detachDeletedInstance: (instance) => {
+    instances.delete(instance.id);
+    if (instance.kind === "element") {
+      for (const hid of Object.values(instance.listenerSlots)) unregisterHandler(hid);
+    }
+  },
+  // Scheduler
+  scheduleTimeout: setTimeout,
+  cancelTimeout: clearTimeout,
+  noTimeout: -1,
+  // supportsMicrotasks is false, so the reconciler schedules root work via
+  // the `scheduler` package (MessageChannel in a worker). This export is
+  // still destructured — provide a real one for completeness.
+  scheduleMicrotask: (fn) => queueMicrotask(fn),
+  // Event priorities (see note above — values are lane numbers).
+  setCurrentUpdatePriority: (p) => {
+    currentUpdatePriority = p;
+  },
+  getCurrentUpdatePriority: () => currentUpdatePriority,
+  resolveUpdatePriority: () => currentUpdatePriority !== 0 ? currentUpdatePriority : DEFAULT_EVENT_PRIORITY,
+  resolveEventType: NULL,
+  resolveEventTimeStamp: () => -1.1,
+  trackSchedulerEvent: noop,
+  shouldAttemptEagerTransition: FALSE,
+  // Events/portals/scopes — no DOM event system exists worker-side.
+  getInstanceFromNode: NULL,
+  beforeActiveInstanceBlur: noop,
+  afterActiveInstanceBlur: noop,
+  preparePortalMount: noop,
+  prepareScopeUpdate: noop,
+  getInstanceFromScope: NULL,
+  // React 19 "suspend on commit" — never suspend.
+  requestPostPaintCallback: noop,
+  maySuspendCommit: FALSE,
+  maySuspendCommitOnUpdate: FALSE,
+  maySuspendCommitInSyncRender: FALSE,
+  preloadInstance: TRUE,
+  startSuspendingCommit: noop,
+  suspendInstance: noop,
+  suspendOnActiveViewTransition: noop,
+  waitForCommitToBeReady: NULL,
+  getSuspendedCommitReason: () => 0,
+  // Transitions / forms / console
+  NotPendingTransition,
+  HostTransitionContext,
+  resetFormInstance: noop,
+  bindToConsole: (methodName, args) => console[methodName]?.bind(console, ...args) ?? noop,
+  // Persistence (supportsPersistence: false — destructured, never called)
+  createContainerChildSet: () => [],
+  appendChildToContainerChildSet: noop,
+  finalizeContainerChildren: noop,
+  replaceContainerChildren: noop,
+  cloneInstance: NULL,
+  cloneMutableInstance: (instance) => instance,
+  cloneMutableTextInstance: (instance) => instance,
+  cloneHiddenInstance: (instance) => instance,
+  cloneHiddenTextInstance: (instance) => instance,
+  // Fragment instances (only used for `<Fragment ref={…}>` — unimplemented)
+  createFragmentInstance: () => ({}),
+  updateFragmentInstanceFiber: noop,
+  commitNewChildToFragmentInstance: noop,
+  deleteChildFromFragmentInstance: noop,
+  // View transitions (React 19) — all stubs
+  createViewTransitionInstance: (name) => ({ name, autoName: null }),
+  applyViewTransitionName: noop,
+  restoreViewTransitionName: noop,
+  cancelViewTransitionName: noop,
+  cancelRootViewTransitionName: noop,
+  restoreRootViewTransitionName: noop,
+  cloneRootViewTransitionContainer: noop,
+  removeRootViewTransitionClone: noop,
+  measureInstance: NULL,
+  measureClonedInstance: NULL,
+  wasInstanceInViewport: FALSE,
+  hasInstanceChanged: FALSE,
+  hasInstanceAffectedParent: FALSE,
+  startViewTransition: NULL,
+  startGestureTransition: NULL,
+  stopViewTransition: noop,
+  addViewTransitionFinishedListener: noop,
+  getCurrentGestureOffset: () => 0,
+  // Hydration (supportsHydration: false — destructured, never called)
+  isSuspenseInstancePending: FALSE,
+  isSuspenseInstanceFallback: FALSE,
+  getSuspenseInstanceFallbackErrorDetails: () => ({}),
+  registerSuspenseInstanceRetry: noop,
+  getNextHydratableSibling: NULL,
+  getNextHydratableSiblingAfterSingleton: NULL,
+  getFirstHydratableChild: NULL,
+  getFirstHydratableChildWithinContainer: NULL,
+  getFirstHydratableChildWithinActivityInstance: NULL,
+  getFirstHydratableChildWithinSingleton: NULL,
+  getFirstHydratableChildWithinSuspenseInstance: NULL,
+  canHydrateInstance: NULL,
+  canHydrateTextInstance: NULL,
+  canHydrateActivityInstance: NULL,
+  canHydrateSuspenseInstance: NULL,
+  canHydrateFormStateMarker: NULL,
+  isFormStateMarkerMatching: FALSE,
+  hydrateInstance: noop,
+  hydrateTextInstance: noop,
+  hydrateActivityInstance: noop,
+  hydrateSuspenseInstance: noop,
+  getNextHydratableInstanceAfterActivityInstance: NULL,
+  getNextHydratableInstanceAfterSuspenseInstance: NULL,
+  commitHydratedInstance: noop,
+  commitHydratedContainer: noop,
+  commitHydratedSuspenseInstance: noop,
+  finalizeHydratedChildren: FALSE,
+  flushHydrationEvents: noop,
+  clearActivityBoundary: FALSE,
+  clearSuspenseBoundary: FALSE,
+  clearActivityBoundaryFromContainer: FALSE,
+  clearSuspenseBoundaryFromContainer: FALSE,
+  hideDehydratedBoundary: noop,
+  unhideDehydratedBoundary: noop,
+  shouldDeleteUnhydratedTailInstances: FALSE,
+  diffHydratedPropsForDevWarnings: NULL,
+  diffHydratedTextForDevWarnings: NULL,
+  describeHydratableInstanceForDevWarnings: NULL,
+  validateHydratableInstance: TRUE,
+  validateHydratableTextInstance: TRUE,
+  // Host resources (stylesheets/scripts — supportsResources: false)
+  isHostHoistableType: FALSE,
+  getHoistableRoot: NULL,
+  getResource: NULL,
+  acquireResource: noop,
+  releaseResource: noop,
+  hydrateHoistable: noop,
+  mountHoistable: noop,
+  unmountHoistable: noop,
+  createHoistableInstance: NULL,
+  prepareToCommitHoistables: noop,
+  mayResourceSuspendCommit: FALSE,
+  preloadResource: TRUE,
+  suspendResource: noop,
+  // Singletons (supportsSingletons: false)
+  resolveSingletonInstance: NULL,
+  acquireSingletonInstance: noop,
+  releaseSingletonInstance: noop,
+  isHostSingletonType: FALSE,
+  isSingletonScope: FALSE,
+  // Test selectors (supportsTestSelectors: false)
+  findFiberRoot: NULL,
+  getBoundingRect: NULL,
+  getTextContent: NULL,
+  isHiddenSubtree: FALSE,
+  matchAccessibilityRole: FALSE,
+  setFocusIfFocusable: FALSE,
+  setupIntersectionObserver: noop
+};
+
+// src/reactInstance.ts
+function createReactInstance(instance) {
+  const reconciler = Reconciler(hostConfig);
+  const container = reconciler.createContainer(
+    // Instance-stamped root container — createInstance reads `.instance` off it,
+    // binding every element to this instance even in out-of-task commits.
+    { id: 0, instance },
+    0,
+    null,
+    false,
+    null,
+    "",
+    console.error,
+    // onUncaughtError
+    console.error,
+    // onCaughtError
+    console.error,
+    // onRecoverableError
+    null
+    // onDefaultTransitionIndicator
+  );
+  return {
+    reconciler,
+    container,
+    sync: (fn) => {
+      reconciler.flushSyncFromReconciler(fn);
+      reconciler.flushSyncWork();
+    },
+    render: (el) => reconciler.updateContainer(el, container, null, null),
+    unmountTree: () => reconciler.updateContainer(null, container, null, null),
+    flush: () => {
+      reconciler.flushPassiveEffects();
+      reconciler.flushSyncWork();
+    }
+  };
+}
+
+// src/worker.ts
+import { emit, runInInstance } from "@atolljs/islands/worker";
+
+// src/slot.tsx
+import { jsx } from "react/jsx-runtime";
+function Slot({ name, style }) {
+  return /* @__PURE__ */ jsx("div", { "data-atoll-slot": name, style });
+}
+
+// src/worker.ts
+import { connectIslandWorker } from "@atolljs/islands/worker";
+
+// src/subIsland.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function SubIsland(props) {
+  return /* @__PURE__ */ jsx2(Island, { framework: "react", "data-atoll-sub-island": "", ...props });
+}
+
+// src/worker.ts
+function reactIslandApp(App, contract) {
+  const app = {
+    renderer: "react",
+    mount({ instance, props }) {
+      const react = createReactInstance(instance);
+      const render = (next) => react.sync(() => react.render(createElement(App, next)));
+      render(props);
+      return {
+        update: render,
+        sync: (fn) => react.sync(fn),
+        dispose: () => react.sync(() => react.unmountTree()),
+        flush: () => react.flush()
+      };
+    }
+  };
+  const stamp = islandAppNameOf(App);
+  if (stamp !== void 0) app.islandAppName = stamp;
+  return contract !== void 0 ? withContract(contract, app) : app;
+}
+var reactIsland = (name, App, contract) => islandApp(name, reactIslandApp(App, contract));
+function defineReactPolyWorker(registry, options) {
+  const apps = {};
+  for (const [key, app] of Object.entries(registry.apps)) {
+    apps[key] = typeof app === "function" ? reactIslandApp(app) : app;
+  }
+  return definePolyWorker({
+    apps,
+    sharedMemory: registry.sharedMemory ?? options?.sharedMemory
+  });
+}
+function defineReactMonoWorker(app, options) {
+  const resolved = typeof app === "function" ? reactIslandApp(app) : app;
+  return defineMonoWorker(
+    options?.contract !== void 0 ? withContract(options.contract, resolved) : resolved,
+    options
+  );
+}
+export {
+  Island,
+  Slot,
+  SubIsland,
+  connectIslandWorker,
+  defineReactMonoWorker,
+  defineReactPolyWorker,
+  emit,
+  islandComponent,
+  lazyIsland,
+  reactIsland,
+  reactIslandApp,
+  runInInstance
+};

package/package.json

@@ -1,23 +1,33 @@
 {
   "name": "@atolljs/react-island",
-  "version": "0.1.12",
+  "version": "0.1.13",
   "description": "React shell components for atoll-islands islands — <Island/>, islandComponent, lazyIsland",
   "homepage": "https://jwhenry3.github.io/atolljs/consumer/quickstart/",
   "type": "module",
   "exports": {
-    ".": "./src/index.tsx",
-    "./worker": "./src/worker.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "default": "./dist/worker.js"
+    }
   },
   "files": [
-    "src"
+    "src",
+    "dist"
   ],
+  "scripts": {
+    "build": "node ../../scripts/build-lib.mjs"
+  },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
   "peerDependencies": {
-    "@atolljs/core": "0.1.12",
-    "@atolljs/islands": "0.1.12",
+    "@atolljs/core": "0.1.13",
+    "@atolljs/islands": "0.1.13",
     "react": "^19.3.0",
     "react-dom": "^19.3.0",
     "react-reconciler": "^0.34.0"