@playfast/react 0.0.1

package/dist/cjs/errors.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownSlot = exports.ComposeOutsideProvider = void 0;
+const effect_1 = require("effect");
+/**
+ * Tagged errors for the React host's render-time boundaries. Thrown (React has
+ * no Effect error channel during render), but tagged and structured so they are
+ * never bare `Error`s.
+ */
+/** `<Compose>` was used without a surrounding `<ReformProvider>` (no runtime). */
+class ComposeOutsideProvider extends effect_1.Data.TaggedError('reform/react/ComposeOutsideProvider') {
+    get message() {
+        return 'reform: <Compose> must be rendered inside a <ReformProvider> (use mount)';
+    }
+}
+exports.ComposeOutsideProvider = ComposeOutsideProvider;
+/** A composition was asked for a slot name its manifest does not declare. */
+class UnknownSlot extends effect_1.Data.TaggedError('reform/react/UnknownSlot') {
+    get message() {
+        return `reform: composition '${this.composition}' has no slot '${this.slot}'`;
+    }
+}
+exports.UnknownSlot = UnknownSlot;

package/dist/cjs/index.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reform = exports.Compose = exports.ReformProvider = void 0;
+const effect_1 = require("effect");
+const react_1 = require("react");
+const reform_1 = require("reform");
+const errors_js_1 = require("./errors.js");
+const RuntimeContext = (0, react_1.createContext)(null);
+const ReformProvider = (props) => (0, react_1.createElement)(RuntimeContext.Provider, { value: props.runtime }, props.children);
+exports.ReformProvider = ReformProvider;
+const useReform = () => {
+    const runtime = (0, react_1.useContext)(RuntimeContext);
+    if (runtime === null) {
+        throw new errors_js_1.ComposeOutsideProvider();
+    }
+    return runtime;
+};
+/**
+ * Build the slot bindings for one composition instance: each slot name maps to a
+ * *stable* React component (cached) that renders the wired child, so children
+ * reconcile across re-renders instead of remounting.
+ */
+const makeSlotHost = (comp, reform) => {
+    const declared = comp.manifest.slots ?? {};
+    const cache = new Map();
+    return {
+        slot: (name) => {
+            const cached = cache.get(name);
+            if (cached !== undefined)
+                return cached;
+            const slotClass = declared[name];
+            if (slotClass === undefined) {
+                throw new errors_js_1.UnknownSlot({ composition: comp.manifest.name, slot: name });
+            }
+            const child = reform.read(slotClass.tag);
+            // A slot filled by a lazy feature holds a `FeatureBinding` — render it through
+            // `FeatureHost`, which drives the load/mount lifecycle and paints the
+            // placeholders. A plain composition (a normal fill or a default feature) goes
+            // straight through `Compose`.
+            const component = (0, reform_1.isFeatureBinding)(child)
+                ? (childProps) => (0, react_1.createElement)(FeatureHost, { binding: child, props: childProps, reform })
+                : (childProps) => (0, react_1.createElement)(exports.Compose, { comp: child, props: childProps });
+            cache.set(name, component);
+            return component;
+        },
+    };
+};
+/**
+ * Render one composition. Each React render runs the composition's synchronous
+ * `render(env)`, recording the state slices it reads; the component is driven by
+ * `useSyncExternalStore` whose snapshot is the sum of those slices' versions.
+ *
+ * Using `useSyncExternalStore` (rather than a manual `useReducer` + post-commit
+ * `subscribe`) is what makes the bridge correct under React 19: its snapshot is
+ * re-read right after subscribe, so a slice that changes in the gap between
+ * render and subscription forces a re-render instead of being silently dropped,
+ * and concurrent renders can't tear. Dependencies are dynamic (a family key can
+ * appear/disappear between renders), so the live subscription is re-pointed at
+ * the latest tracked set after every commit.
+ */
+const ComposeImpl = ({ comp, props }) => {
+    const reform = useReform();
+    const service = (0, react_1.useMemo)(() => reform.read(comp.tag), [reform, comp]);
+    const slots = (0, react_1.useMemo)(() => makeSlotHost(comp, reform), [reform, comp]);
+    const tracked = (0, react_1.useRef)(new Set());
+    const sub = (0, react_1.useRef)({ cb: null, live: new Map(), snapshot: 0, dirty: true });
+    // Point the live subscription at the currently-tracked set by DELTA: subscribe
+    // only newly-tracked sources, unsubscribe only dropped ones. An unchanged dep
+    // set (the common case) does two cheap `has` scans and zero subscribe/
+    // unsubscribe calls, instead of tearing down and rebuilding every slice's
+    // subscription on every commit. Marking `dirty` forces the next snapshot to
+    // recompute from live versions, which is what catches a slice that changed in
+    // the gap between render and the post-commit re-point.
+    const repoint = (0, react_1.useCallback)(() => {
+        const { cb, live } = sub.current;
+        if (cb === null)
+            return;
+        const next = tracked.current;
+        for (const source of next) {
+            if (!live.has(source))
+                live.set(source, source.subscribe(cb));
+        }
+        for (const [source, off] of live) {
+            if (!next.has(source)) {
+                off();
+                live.delete(source);
+            }
+        }
+        sub.current.dirty = true;
+    }, []);
+    const subscribe = (0, react_1.useCallback)((onStoreChange) => {
+        // A slice notification marks the snapshot dirty before waking React, so the
+        // next `getSnapshot` recomputes once and then serves O(1) until the next change.
+        sub.current.cb = () => {
+            sub.current.dirty = true;
+            onStoreChange();
+        };
+        repoint();
+        return () => {
+            for (const off of sub.current.live.values())
+                off();
+            sub.current = { cb: null, live: new Map(), snapshot: 0, dirty: true };
+        };
+    }, [repoint]);
+    // Snapshot = number of tracked slices + sum of their versions. It moves on any
+    // dependency change (so React re-renders) and is stable otherwise (so React
+    // bails out). Recomputed from live versions only when `dirty` (a notification or
+    // a re-point) — O(1) on the hot path where React polls an unchanged snapshot —
+    // and crucially still reflects changes that land between render and subscribe,
+    // because the post-commit re-point sets `dirty`.
+    const getSnapshot = (0, react_1.useCallback)(() => {
+        const current = sub.current;
+        if (current.dirty) {
+            let snapshot = tracked.current.size;
+            for (const source of tracked.current)
+                snapshot = (snapshot + source.getVersion()) >>> 0;
+            current.snapshot = snapshot;
+            current.dirty = false;
+        }
+        return current.snapshot;
+    }, []);
+    (0, react_1.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+    // Run the logic, collecting this render's dependencies.
+    const deps = new Set();
+    const env = { props, tracker: { add: (source) => deps.add(source) }, slots };
+    const node = reform.runRender(reform_1.Composition.render(service, env));
+    tracked.current = deps;
+    // Re-point the live subscription at this render's dep set after commit.
+    (0, react_1.useEffect)(() => {
+        repoint();
+    });
+    return node;
+};
+/**
+ * Shallow value-equality over a composition's prop record. A composition's only
+ * reactive inputs are (a) its props and (b) the store slices it reads — and (b)
+ * re-renders this node directly through its own `useSyncExternalStore`
+ * subscription, independent of the parent. So a child can safely skip a
+ * parent-driven re-render whenever its props are unchanged: that's exactly what
+ * this comparison decides.
+ */
+const shallowEqualProps = (a, b) => {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null)
+        return false;
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length)
+        return false;
+    for (const key of ak) {
+        if (!Object.is(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * The memo boundary that stops a parent's re-render from cascading into every
+ * descendant. Without it, a slice change that re-renders a parent re-runs the
+ * synchronous `render(env)` of all its children even when their inputs never
+ * moved — turning fine-grained per-slice reactivity into O(subtree) work on the
+ * way down. With it, a child re-renders only when its own props change (compared
+ * here) or its own tracked slices change (its `useSyncExternalStore`
+ * subscription), giving O(changed nodes) updates. `comp` is a stable class; the
+ * inner `props` object is rebuilt by the parent each render, so it's compared by
+ * value, not reference — pass referentially-stable props (e.g. ids, not freshly
+ * derived objects) to keep the boundary effective for large lists.
+ */
+exports.Compose = (0, react_1.memo)(ComposeImpl, (a, b) => a.comp === b.comp && shallowEqualProps(a.props, b.props));
+/**
+ * Host a lazy feature in a slot. On mount it loads + builds the feature against the
+ * parent runtime (sharing its engine), painting `placeholder.loading` meanwhile and
+ * `placeholder.failed` (with a `retry`) on failure. Once live it renders the
+ * feature's composition under a nested provider over the child runtime, so the
+ * feature's own stores/composition resolve from its built context while shared
+ * reads and dispatch flow through the one engine. Unmounting disposes the feature.
+ *
+ * Placeholders render through the *parent* provider (their `.live` is eager, in the
+ * parent runtime); only the live composition uses the child runtime.
+ */
+const FeatureHost = ({ binding, props, reform, }) => {
+    const [state, setState] = (0, react_1.useState)({ _tag: 'Loading' });
+    // Bumping `attempt` re-runs the mount effect — that's how `retry` works.
+    const [attempt, setAttempt] = (0, react_1.useState)(0);
+    (0, react_1.useEffect)(() => {
+        const alive = { current: true };
+        setState({ _tag: 'Loading' });
+        const dispose = reform.mountFeature(binding, {
+            onLive: (runtime) => {
+                if (alive.current)
+                    setState({ _tag: 'Live', runtime });
+            },
+            onFailed: (error) => {
+                if (alive.current)
+                    setState({ _tag: 'Failed', error });
+            },
+        });
+        return () => {
+            alive.current = false;
+            dispose();
+        };
+    }, [reform, binding, attempt]);
+    if (state._tag === 'Live') {
+        return (0, react_1.createElement)(exports.ReformProvider, {
+            runtime: state.runtime,
+            children: (0, react_1.createElement)(exports.Compose, { comp: binding.composition, props }),
+        });
+    }
+    if (state._tag === 'Failed') {
+        if (binding.placeholder === undefined)
+            return null;
+        const retry = () => setAttempt((n) => n + 1);
+        return (0, react_1.createElement)(exports.Compose, {
+            comp: binding.placeholder.failed,
+            props: { error: state.error, retry },
+        });
+    }
+    return binding.placeholder === undefined
+        ? null
+        : (0, react_1.createElement)(exports.Compose, { comp: binding.placeholder.loading, props });
+};
+/**
+ * Build the concrete `ReformRuntime` over a `ManagedRuntime` made from a scene's
+ * closed layers. The mounted runtime provides every reform tag, so reading any
+ * one needs no further context; we erase the requirement the generic tag carries.
+ * Shared by the DOM host (`Reform`) and the React-Native root.
+ */
+const buildRuntime = (provide) => {
+    // A scene always provides at least one layer; merge them into the app layer.
+    const layer = provide.reduce((a, b) => effect_1.Layer.merge(a, b));
+    const runtime = effect_1.ManagedRuntime.make(layer);
+    // The full app context (all services), captured once. A feature's `.live` layer
+    // is built against this so it shares the one engine (bus + registries). Typed as
+    // the host's `MountedServices` subset; at runtime it carries every service.
+    const rootContext = runtime.runSync(effect_1.Effect.context());
+    // A child runtime over a feature's merged context (feature services + the shared
+    // engine). Reads resolve from that context; renders run on the parent runtime
+    // (the captured render Effect is self-contained); dispatch shares the one bus.
+    const makeChildRuntime = (context) => ({
+        read: (tag) => effect_1.Context.unsafeGet(context, tag),
+        runRender: (effect) => runtime.runSync(effect),
+        dispatch: (priority, event) => {
+            runtime.runFork((0, reform_1.publish)(priority, event));
+        },
+        mountFeature: (binding, handlers) => mountFeatureOnto(binding, handlers),
+    });
+    const mountFeatureOnto = (binding, handlers) => {
+        const scope = effect_1.Effect.runSync(effect_1.Scope.make());
+        runtime.runFork((0, reform_1.mountFeature)(binding, rootContext).pipe(effect_1.Effect.provideService(effect_1.Scope.Scope, scope), effect_1.Effect.matchCause({
+            onFailure: (cause) => handlers.onFailed(effect_1.Option.getOrElse(effect_1.Cause.failureOption(cause), () => new reform_1.FeatureLoadFailed({ cause }))),
+            onSuccess: (context) => handlers.onLive(makeChildRuntime(context)),
+        })));
+        return () => {
+            runtime.runFork(effect_1.Scope.close(scope, effect_1.Exit.succeed(undefined)));
+        };
+    };
+    const reform = {
+        read: (tag) => runtime.runSync(tag),
+        runRender: (effect) => runtime.runSync(effect),
+        dispatch: (priority, event) => {
+            runtime.runFork((0, reform_1.publish)(priority, event));
+        },
+        mountFeature: (binding, handlers) => mountFeatureOnto(binding, handlers),
+    };
+    return { reform, dispose: () => void runtime.dispose() };
+};
+/**
+ * The application entry point: host a scene as a live React tree. Builds the one
+ * `ManagedRuntime` from the scene's closed layers (memoised per scene), renders
+ * its composition, and disposes the runtime when the scene changes or the tree
+ * unmounts. The app owns the React root — `createRoot(el).render(<Reform scene={…} />)`.
+ *
+ * Boot events fire from a committed effect (not the render body): the app layer's
+ * procedure fibers subscribe to the `Bus` as the runtime builds, and dispatching
+ * boot only after commit guarantees those subscribers exist, so an event like
+ * `RequestedTodos` is never dropped into an empty bus. The effect is keyed on the
+ * built runtime, so a new scene re-boots against its fresh runtime.
+ */
+const Reform = ({ scene }) => {
+    const runtime = (0, react_1.useMemo)(() => buildRuntime(scene.provide), [scene]);
+    (0, react_1.useEffect)(() => {
+        for (const event of scene.boot ?? [])
+            runtime.reform.dispatch('High', event);
+        return runtime.dispose;
+    }, [runtime, scene]);
+    return (0, react_1.createElement)(exports.ReformProvider, {
+        runtime: runtime.reform,
+        children: (0, react_1.createElement)(exports.Compose, { comp: scene.composition, props: {} }),
+    });
+};
+exports.Reform = Reform;

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "sideEffects": []
+}

package/dist/dts/errors.d.ts

@@ -0,0 +1,24 @@
+declare const ComposeOutsideProvider_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/react/ComposeOutsideProvider";
+} & Readonly<A>;
+/**
+ * Tagged errors for the React host's render-time boundaries. Thrown (React has
+ * no Effect error channel during render), but tagged and structured so they are
+ * never bare `Error`s.
+ */
+/** `<Compose>` was used without a surrounding `<ReformProvider>` (no runtime). */
+export declare class ComposeOutsideProvider extends ComposeOutsideProvider_base<{}> {
+    get message(): string;
+}
+declare const UnknownSlot_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform/react/UnknownSlot";
+} & Readonly<A>;
+/** A composition was asked for a slot name its manifest does not declare. */
+export declare class UnknownSlot extends UnknownSlot_base<{
+    readonly composition: string;
+    readonly slot: string;
+}> {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/dts/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AAEH,kFAAkF;AAClF,qBAAa,sBAAuB,SAAQ,4BAAwD,EAAE,CAAC;IACrG,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,6EAA6E;AAC7E,qBAAa,WAAY,SAAQ,iBAA6C;IAC5E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/dts/index.d.ts

@@ -0,0 +1,71 @@
+import { Context, Effect } from 'effect';
+import { type ReactNode } from 'react';
+import { FeatureLoadFailed } from 'reform';
+import type { CompositionClass, FeatureBinding, Node, Priority, Scene, Tagged } from 'reform';
+/**
+ * The capabilities a host needs from a built reform runtime. A concrete one is
+ * built by `buildRuntime` (below) over a `ManagedRuntime`; `Compose` depends
+ * only on this interface.
+ */
+export interface ReformRuntime {
+    /**
+     * Resolve any reform DI tag (a composition's mounted logic, a slot's wired
+     * child) from the app context. The mounted runtime provides every reform
+     * service, so this never fails for tags from the same app.
+     */
+    read<A>(tag: Context.Tag<A, A>): A;
+    /** Run a fully-provided, synchronous render to its node (D2). */
+    runRender(effect: Effect.Effect<Node, never, never>): Node;
+    /** Dispatch a runtime/boot event onto the bus. */
+    dispatch(priority: Priority, event: Tagged): void;
+    /**
+     * Mount a feature against this runtime: load its module (lazy = dynamic import),
+     * build its `.live` layer on a fresh scope sharing this runtime's engine, and
+     * call `onLive` with a child runtime that reads the feature's composition/stores
+     * (and the shared services), or `onFailed` with a typed `FeatureLoadFailed`.
+     * Returns a disposer that closes the feature's scope — stopping its fibers and
+     * reclaiming its reducers/stores. Used by `FeatureHost` for lazy slots.
+     */
+    mountFeature(binding: FeatureBinding, handlers: {
+        readonly onLive: (runtime: ReformRuntime) => void;
+        readonly onFailed: (error: FeatureLoadFailed) => void;
+    }): () => void;
+}
+export declare const ReformProvider: (props: {
+    readonly runtime: ReformRuntime;
+    readonly children: ReactNode;
+}) => ReactNode;
+interface ComposeProps {
+    readonly comp: CompositionClass<unknown>;
+    readonly props: unknown;
+}
+/**
+ * The memo boundary that stops a parent's re-render from cascading into every
+ * descendant. Without it, a slice change that re-renders a parent re-runs the
+ * synchronous `render(env)` of all its children even when their inputs never
+ * moved — turning fine-grained per-slice reactivity into O(subtree) work on the
+ * way down. With it, a child re-renders only when its own props change (compared
+ * here) or its own tracked slices change (its `useSyncExternalStore`
+ * subscription), giving O(changed nodes) updates. `comp` is a stable class; the
+ * inner `props` object is rebuilt by the parent each render, so it's compared by
+ * value, not reference — pass referentially-stable props (e.g. ids, not freshly
+ * derived objects) to keep the boundary effective for large lists.
+ */
+export declare const Compose: (props: ComposeProps) => ReactNode;
+/**
+ * The application entry point: host a scene as a live React tree. Builds the one
+ * `ManagedRuntime` from the scene's closed layers (memoised per scene), renders
+ * its composition, and disposes the runtime when the scene changes or the tree
+ * unmounts. The app owns the React root — `createRoot(el).render(<Reform scene={…} />)`.
+ *
+ * Boot events fire from a committed effect (not the render body): the app layer's
+ * procedure fibers subscribe to the `Bus` as the runtime builds, and dispatching
+ * boot only after commit guarantees those subscribers exist, so an event like
+ * `RequestedTodos` is never dropped into an empty bus. The effect is keyed on the
+ * built runtime, so a new scene re-boots against its fresh runtime.
+ */
+export declare const Reform: ({ scene }: {
+    readonly scene: Scene;
+}) => ReactNode;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,OAAO,EAAE,MAAM,EAA8C,MAAM,QAAQ,CAAA;AAC3F,OAAO,EAIL,KAAK,SAAS,EAQf,MAAM,OAAO,CAAA;AACd,OAAO,EAEL,iBAAiB,EAIlB,MAAM,QAAQ,CAAA;AAEf,OAAO,KAAK,EACV,gBAAgB,EAChB,cAAc,EAEd,IAAI,EACJ,QAAQ,EAER,KAAK,EAGL,MAAM,EACP,MAAM,QAAQ,CAAA;AASf;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;IAClC,iEAAiE;IACjE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI,CAAA;IAC1D,kDAAkD;IAClD,QAAQ,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACjD;;;;;;;OAOG;IACH,YAAY,CACV,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE;QACR,QAAQ,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,aAAa,KAAK,IAAI,CAAA;QACjD,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;KACtD,GACA,MAAM,IAAI,CAAA;CACd;AAID,eAAO,MAAM,cAAc,GAAI,OAAO;IACpC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;IAC/B,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAA;CAC7B,KAAG,SAA6F,CAAA;AAyCjG,UAAU,YAAY;IACpB,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IACxC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;CACxB;AAgID;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,EAGf,CAAC,KAAK,EAAE,YAAY,KAAK,SAAS,CAAA;AA+IvC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,GAAI,WAAW;IAAE,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CAAE,KAAG,SAU7D,CAAA"}

package/dist/esm/errors.js

@@ -0,0 +1,19 @@
+import { Data } from 'effect';
+/**
+ * Tagged errors for the React host's render-time boundaries. Thrown (React has
+ * no Effect error channel during render), but tagged and structured so they are
+ * never bare `Error`s.
+ */
+/** `<Compose>` was used without a surrounding `<ReformProvider>` (no runtime). */
+export class ComposeOutsideProvider extends Data.TaggedError('reform/react/ComposeOutsideProvider') {
+    get message() {
+        return 'reform: <Compose> must be rendered inside a <ReformProvider> (use mount)';
+    }
+}
+/** A composition was asked for a slot name its manifest does not declare. */
+export class UnknownSlot extends Data.TaggedError('reform/react/UnknownSlot') {
+    get message() {
+        return `reform: composition '${this.composition}' has no slot '${this.slot}'`;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B;;;;GAIG;AAEH,kFAAkF;AAClF,MAAM,OAAO,sBAAuB,SAAQ,IAAI,CAAC,WAAW,CAAC,qCAAqC,CAAK;IACrG,IAAa,OAAO;QAClB,OAAO,0EAA0E,CAAA;IACnF,CAAC;CACF;AAED,6EAA6E;AAC7E,MAAM,OAAO,WAAY,SAAQ,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAG1E;IACA,IAAa,OAAO;QAClB,OAAO,wBAAwB,IAAI,CAAC,WAAW,kBAAkB,IAAI,CAAC,IAAI,GAAG,CAAA;IAC/E,CAAC;CACF"}

package/dist/esm/index.js

@@ -0,0 +1,288 @@
+import { Cause, Context, Effect, Exit, Layer, ManagedRuntime, Option, Scope } from 'effect';
+import { createContext, createElement, memo, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
+import { Composition, FeatureLoadFailed, isFeatureBinding, mountFeature as mountFeatureContext, publish, } from 'reform';
+import { ComposeOutsideProvider, UnknownSlot } from './errors.js';
+const RuntimeContext = createContext(null);
+export const ReformProvider = (props) => createElement(RuntimeContext.Provider, { value: props.runtime }, props.children);
+const useReform = () => {
+    const runtime = useContext(RuntimeContext);
+    if (runtime === null) {
+        throw new ComposeOutsideProvider();
+    }
+    return runtime;
+};
+/**
+ * Build the slot bindings for one composition instance: each slot name maps to a
+ * *stable* React component (cached) that renders the wired child, so children
+ * reconcile across re-renders instead of remounting.
+ */
+const makeSlotHost = (comp, reform) => {
+    const declared = comp.manifest.slots ?? {};
+    const cache = new Map();
+    return {
+        slot: (name) => {
+            const cached = cache.get(name);
+            if (cached !== undefined)
+                return cached;
+            const slotClass = declared[name];
+            if (slotClass === undefined) {
+                throw new UnknownSlot({ composition: comp.manifest.name, slot: name });
+            }
+            const child = reform.read(slotClass.tag);
+            // A slot filled by a lazy feature holds a `FeatureBinding` — render it through
+            // `FeatureHost`, which drives the load/mount lifecycle and paints the
+            // placeholders. A plain composition (a normal fill or a default feature) goes
+            // straight through `Compose`.
+            const component = isFeatureBinding(child)
+                ? (childProps) => createElement(FeatureHost, { binding: child, props: childProps, reform })
+                : (childProps) => createElement(Compose, { comp: child, props: childProps });
+            cache.set(name, component);
+            return component;
+        },
+    };
+};
+/**
+ * Render one composition. Each React render runs the composition's synchronous
+ * `render(env)`, recording the state slices it reads; the component is driven by
+ * `useSyncExternalStore` whose snapshot is the sum of those slices' versions.
+ *
+ * Using `useSyncExternalStore` (rather than a manual `useReducer` + post-commit
+ * `subscribe`) is what makes the bridge correct under React 19: its snapshot is
+ * re-read right after subscribe, so a slice that changes in the gap between
+ * render and subscription forces a re-render instead of being silently dropped,
+ * and concurrent renders can't tear. Dependencies are dynamic (a family key can
+ * appear/disappear between renders), so the live subscription is re-pointed at
+ * the latest tracked set after every commit.
+ */
+const ComposeImpl = ({ comp, props }) => {
+    const reform = useReform();
+    const service = useMemo(() => reform.read(comp.tag), [reform, comp]);
+    const slots = useMemo(() => makeSlotHost(comp, reform), [reform, comp]);
+    const tracked = useRef(new Set());
+    const sub = useRef({ cb: null, live: new Map(), snapshot: 0, dirty: true });
+    // Point the live subscription at the currently-tracked set by DELTA: subscribe
+    // only newly-tracked sources, unsubscribe only dropped ones. An unchanged dep
+    // set (the common case) does two cheap `has` scans and zero subscribe/
+    // unsubscribe calls, instead of tearing down and rebuilding every slice's
+    // subscription on every commit. Marking `dirty` forces the next snapshot to
+    // recompute from live versions, which is what catches a slice that changed in
+    // the gap between render and the post-commit re-point.
+    const repoint = useCallback(() => {
+        const { cb, live } = sub.current;
+        if (cb === null)
+            return;
+        const next = tracked.current;
+        for (const source of next) {
+            if (!live.has(source))
+                live.set(source, source.subscribe(cb));
+        }
+        for (const [source, off] of live) {
+            if (!next.has(source)) {
+                off();
+                live.delete(source);
+            }
+        }
+        sub.current.dirty = true;
+    }, []);
+    const subscribe = useCallback((onStoreChange) => {
+        // A slice notification marks the snapshot dirty before waking React, so the
+        // next `getSnapshot` recomputes once and then serves O(1) until the next change.
+        sub.current.cb = () => {
+            sub.current.dirty = true;
+            onStoreChange();
+        };
+        repoint();
+        return () => {
+            for (const off of sub.current.live.values())
+                off();
+            sub.current = { cb: null, live: new Map(), snapshot: 0, dirty: true };
+        };
+    }, [repoint]);
+    // Snapshot = number of tracked slices + sum of their versions. It moves on any
+    // dependency change (so React re-renders) and is stable otherwise (so React
+    // bails out). Recomputed from live versions only when `dirty` (a notification or
+    // a re-point) — O(1) on the hot path where React polls an unchanged snapshot —
+    // and crucially still reflects changes that land between render and subscribe,
+    // because the post-commit re-point sets `dirty`.
+    const getSnapshot = useCallback(() => {
+        const current = sub.current;
+        if (current.dirty) {
+            let snapshot = tracked.current.size;
+            for (const source of tracked.current)
+                snapshot = (snapshot + source.getVersion()) >>> 0;
+            current.snapshot = snapshot;
+            current.dirty = false;
+        }
+        return current.snapshot;
+    }, []);
+    useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+    // Run the logic, collecting this render's dependencies.
+    const deps = new Set();
+    const env = { props, tracker: { add: (source) => deps.add(source) }, slots };
+    const node = reform.runRender(Composition.render(service, env));
+    tracked.current = deps;
+    // Re-point the live subscription at this render's dep set after commit.
+    useEffect(() => {
+        repoint();
+    });
+    return node;
+};
+/**
+ * Shallow value-equality over a composition's prop record. A composition's only
+ * reactive inputs are (a) its props and (b) the store slices it reads — and (b)
+ * re-renders this node directly through its own `useSyncExternalStore`
+ * subscription, independent of the parent. So a child can safely skip a
+ * parent-driven re-render whenever its props are unchanged: that's exactly what
+ * this comparison decides.
+ */
+const shallowEqualProps = (a, b) => {
+    if (Object.is(a, b))
+        return true;
+    if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null)
+        return false;
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length)
+        return false;
+    for (const key of ak) {
+        if (!Object.is(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+};
+/**
+ * The memo boundary that stops a parent's re-render from cascading into every
+ * descendant. Without it, a slice change that re-renders a parent re-runs the
+ * synchronous `render(env)` of all its children even when their inputs never
+ * moved — turning fine-grained per-slice reactivity into O(subtree) work on the
+ * way down. With it, a child re-renders only when its own props change (compared
+ * here) or its own tracked slices change (its `useSyncExternalStore`
+ * subscription), giving O(changed nodes) updates. `comp` is a stable class; the
+ * inner `props` object is rebuilt by the parent each render, so it's compared by
+ * value, not reference — pass referentially-stable props (e.g. ids, not freshly
+ * derived objects) to keep the boundary effective for large lists.
+ */
+export const Compose = memo(ComposeImpl, (a, b) => a.comp === b.comp && shallowEqualProps(a.props, b.props));
+/**
+ * Host a lazy feature in a slot. On mount it loads + builds the feature against the
+ * parent runtime (sharing its engine), painting `placeholder.loading` meanwhile and
+ * `placeholder.failed` (with a `retry`) on failure. Once live it renders the
+ * feature's composition under a nested provider over the child runtime, so the
+ * feature's own stores/composition resolve from its built context while shared
+ * reads and dispatch flow through the one engine. Unmounting disposes the feature.
+ *
+ * Placeholders render through the *parent* provider (their `.live` is eager, in the
+ * parent runtime); only the live composition uses the child runtime.
+ */
+const FeatureHost = ({ binding, props, reform, }) => {
+    const [state, setState] = useState({ _tag: 'Loading' });
+    // Bumping `attempt` re-runs the mount effect — that's how `retry` works.
+    const [attempt, setAttempt] = useState(0);
+    useEffect(() => {
+        const alive = { current: true };
+        setState({ _tag: 'Loading' });
+        const dispose = reform.mountFeature(binding, {
+            onLive: (runtime) => {
+                if (alive.current)
+                    setState({ _tag: 'Live', runtime });
+            },
+            onFailed: (error) => {
+                if (alive.current)
+                    setState({ _tag: 'Failed', error });
+            },
+        });
+        return () => {
+            alive.current = false;
+            dispose();
+        };
+    }, [reform, binding, attempt]);
+    if (state._tag === 'Live') {
+        return createElement(ReformProvider, {
+            runtime: state.runtime,
+            children: createElement(Compose, { comp: binding.composition, props }),
+        });
+    }
+    if (state._tag === 'Failed') {
+        if (binding.placeholder === undefined)
+            return null;
+        const retry = () => setAttempt((n) => n + 1);
+        return createElement(Compose, {
+            comp: binding.placeholder.failed,
+            props: { error: state.error, retry },
+        });
+    }
+    return binding.placeholder === undefined
+        ? null
+        : createElement(Compose, { comp: binding.placeholder.loading, props });
+};
+/**
+ * Build the concrete `ReformRuntime` over a `ManagedRuntime` made from a scene's
+ * closed layers. The mounted runtime provides every reform tag, so reading any
+ * one needs no further context; we erase the requirement the generic tag carries.
+ * Shared by the DOM host (`Reform`) and the React-Native root.
+ */
+const buildRuntime = (provide) => {
+    // A scene always provides at least one layer; merge them into the app layer.
+    const layer = provide.reduce((a, b) => Layer.merge(a, b));
+    const runtime = ManagedRuntime.make(layer);
+    // The full app context (all services), captured once. A feature's `.live` layer
+    // is built against this so it shares the one engine (bus + registries). Typed as
+    // the host's `MountedServices` subset; at runtime it carries every service.
+    const rootContext = runtime.runSync(Effect.context());
+    // A child runtime over a feature's merged context (feature services + the shared
+    // engine). Reads resolve from that context; renders run on the parent runtime
+    // (the captured render Effect is self-contained); dispatch shares the one bus.
+    const makeChildRuntime = (context) => ({
+        read: (tag) => Context.unsafeGet(context, tag),
+        runRender: (effect) => runtime.runSync(effect),
+        dispatch: (priority, event) => {
+            runtime.runFork(publish(priority, event));
+        },
+        mountFeature: (binding, handlers) => mountFeatureOnto(binding, handlers),
+    });
+    const mountFeatureOnto = (binding, handlers) => {
+        const scope = Effect.runSync(Scope.make());
+        runtime.runFork(mountFeatureContext(binding, rootContext).pipe(Effect.provideService(Scope.Scope, scope), Effect.matchCause({
+            onFailure: (cause) => handlers.onFailed(Option.getOrElse(Cause.failureOption(cause), () => new FeatureLoadFailed({ cause }))),
+            onSuccess: (context) => handlers.onLive(makeChildRuntime(context)),
+        })));
+        return () => {
+            runtime.runFork(Scope.close(scope, Exit.succeed(undefined)));
+        };
+    };
+    const reform = {
+        read: (tag) => runtime.runSync(tag),
+        runRender: (effect) => runtime.runSync(effect),
+        dispatch: (priority, event) => {
+            runtime.runFork(publish(priority, event));
+        },
+        mountFeature: (binding, handlers) => mountFeatureOnto(binding, handlers),
+    };
+    return { reform, dispose: () => void runtime.dispose() };
+};
+/**
+ * The application entry point: host a scene as a live React tree. Builds the one
+ * `ManagedRuntime` from the scene's closed layers (memoised per scene), renders
+ * its composition, and disposes the runtime when the scene changes or the tree
+ * unmounts. The app owns the React root — `createRoot(el).render(<Reform scene={…} />)`.
+ *
+ * Boot events fire from a committed effect (not the render body): the app layer's
+ * procedure fibers subscribe to the `Bus` as the runtime builds, and dispatching
+ * boot only after commit guarantees those subscribers exist, so an event like
+ * `RequestedTodos` is never dropped into an empty bus. The effect is keyed on the
+ * built runtime, so a new scene re-boots against its fresh runtime.
+ */
+export const Reform = ({ scene }) => {
+    const runtime = useMemo(() => buildRuntime(scene.provide), [scene]);
+    useEffect(() => {
+        for (const event of scene.boot ?? [])
+            runtime.reform.dispatch('High', event);
+        return runtime.dispose;
+    }, [runtime, scene]);
+    return createElement(ReformProvider, {
+        runtime: runtime.reform,
+        children: createElement(Compose, { comp: scene.composition, props: {} }),
+    });
+};
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": []
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@playfast/react",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": [],
+  "license": "MIT",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/dts/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": "*",
+    "react": "^19.0.0",
+    "@playfast/reform": "^0.0.1"
+  }
+}