@wildo-ai/saas-frontend-lib 1.0.1 → 1.1.0

package/dist/esm/core/execution/useExecutionParticipationPrefetch.d.ts

@@ -0,0 +1,145 @@
+import { type ExecutionParticipationPrefetchIntent } from './ExecutionRuntimeContext';
+/**
+ * Input shape for the generic primitive participation-prefetch hook.
+ *
+ * Contract anchored at
+ * `saas.frontend.execution-view.loading-aggregation.participation-prefetch.shell-data-hydrator`
+ * in `ExecutionRuntimeContext.tsx`. The primitive owns lifecycle plumbing
+ * (begin/end pairing, AbortController, latest-error surfacing, optional
+ * shell-aggregator bridge); the consumer's `run` callback owns the actual
+ * fetch — typically a `doOperation()` invocation, but the hook is
+ * intentionally fetch-mechanism-agnostic so future producers (a
+ * relationship-projection source-resource hydrator, a lazy-binding
+ * resolver) can reuse the same lifecycle without adopting `doOperation()`
+ * semantics they do not need.
+ */
+export interface UseExecutionParticipationPrefetchInput<TData> {
+    /**
+     * Stable consumer-authored identity for the prefetch unit. Reused
+     * across consecutive `refetch()` cycles so the shell's
+     * `clearFailedActionsForPrefetchKey(key)` verb can drop matching
+     * entries on the next successful settle. Distinct from the
+     * per-run `prefetchRuntimeId` minted internally by the hook on
+     * every fire — see invariant #1 in the sub-anchor JSDoc.
+     *
+     * Consumers should prefer keys that include enough context to make
+     * the unit identifiable in failure-aggregator UX (e.g.
+     * `prefetch:todoList:${listId}` rather than `'load'`).
+     */
+    prefetchKey: string;
+    /**
+     * Participation refs whose data is being hydrated by this prefetch.
+     * Threaded into the registered `ExecutionPendingPrefetch` so per-ref
+     * predicates on `loading.isParticipationPrefetching(...)` can narrow
+     * to "is *this ref* loading?". Must contain at least one ref —
+     * `assertExecutionPendingPrefetchShape` enforces this at the nav
+     * helper boundary.
+     */
+    participationRefs: readonly string[];
+    /**
+     * Primary resource type being hydrated. Mirrors
+     * `ExecutionPendingAction.resourceType` so per-resource UI filtering
+     * composes uniformly across the loading aggregator's two tiers.
+     */
+    resourceType: string;
+    /**
+     * Whether this is `INITIAL` (full-screen skeleton UX) or `REFRESH`
+     * (subtle indicator UX). The primitive does NOT auto-toggle the
+     * `bridgeFailuresToShellAggregator` default off intent; see the
+     * wrapper (`useExecutionParticipationDataPrefetch`) for the
+     * intent-aware bridge default policy.
+     */
+    intent: ExecutionParticipationPrefetchIntent;
+    /**
+     * Async work to perform. Receives an `AbortSignal` that the hook
+     * triggers on unmount or on a fresh `run()` while one is already in
+     * flight. Consumers SHOULD thread the signal into their underlying
+     * fetch (e.g. `doOperation(..., { signal })`) so cancellation actually
+     * stops the network call rather than just discarding the result on
+     * settle.
+     */
+    run: (params: {
+        signal: AbortSignal;
+    }) => Promise<TData>;
+    /** Optional human-readable label ("Loading task graph"). Opaque to the shell. */
+    label?: string;
+    /**
+     * When `true`, captured failures are also bridged into
+     * `execution.errors.failedActions` under
+     * `ExecutionFailedActionScope.PARTICIPATION_PREFETCH` (with the same
+     * `prefetchKey`), where they participate in the cross-component
+     * failure aggregator. The hook auto-clears entries with this scope
+     * and key on the next successful settle (via
+     * `clearFailedActionsForPrefetchKey`), so a stale failure banner
+     * vanishes the moment the next attempt succeeds.
+     *
+     * Defaults to `false` on the primitive — it has no intent-aware
+     * default to lean on. The wrapper
+     * (`useExecutionParticipationDataPrefetch`) applies a default split
+     * (INITIAL=true, REFRESH=false) that matches typical UX.
+     */
+    bridgeFailuresToShellAggregator?: boolean;
+}
+/**
+ * Return shape for the generic primitive participation-prefetch hook.
+ */
+export interface UseExecutionParticipationPrefetchValue<TData> {
+    /**
+     * Most recently settled successful payload, or `undefined` when no
+     * successful settle has happened yet. Stale-while-revalidate: stays
+     * pinned through `isLoading: true` rerun cycles so renderers can
+     * keep showing the prior data while a `REFRESH` is in flight.
+     */
+    data: TData | undefined;
+    /** `true` while a `run({ signal })` invocation is in flight. */
+    isLoading: boolean;
+    /**
+     * Latest settle's rejection (or `undefined` after a successful
+     * settle). Resets to `undefined` on every successful settle and is
+     * set to the rejection on every failed one. `AbortError` rejections
+     * are NOT surfaced here — cancellations are not failures.
+     */
+    error: unknown;
+    /** Consumer-authored stable identity (echo of input for diagnostics). */
+    prefetchKey: string;
+    /**
+     * Trigger a fresh run. Aborts any in-flight one first (and removes
+     * its `ExecutionPendingPrefetch` entry) before minting a fresh
+     * `prefetchRuntimeId` and beginning the new unit. Returns the
+     * resolved data, or `undefined` if the run was aborted or rejected
+     * (the hook's `error` state surfaces the rejection).
+     */
+    refetch: () => Promise<TData | undefined>;
+    /**
+     * Cancel the current in-flight run, if any. Does NOT trigger a
+     * follow-up — the hook's state stays at whatever it was right
+     * before the abort (data unchanged, isLoading drops to false,
+     * error unchanged). Typical use: a "Cancel loading" button next
+     * to a long-running prefetch.
+     */
+    abort: () => void;
+}
+/**
+ * Generic primitive hook for the participation-prefetch tier (Slice K).
+ *
+ * Owns the `ExecutionPendingPrefetch` lifecycle plumbing so consumer
+ * `run()` callbacks can focus on the actual async work. See the
+ * `loading-aggregation.participation-prefetch.shell-data-hydrator`
+ * sub-anchor in `ExecutionRuntimeContext.tsx` for the full producer
+ * contract (stable `prefetchKey`, one in-flight unit per hook,
+ * settle-always-clears, optional shell-aggregator bridge, latest-error
+ * surfacing, etc.).
+ *
+ * Most consumers want the opinionated wrapper
+ * `useExecutionParticipationDataPrefetch` instead — it handles the
+ * common case (hydrate a single participation's resource data via
+ * `doOperation()`) without the consumer having to author the
+ * operation-path-key derivation or the per-intent bridge default.
+ * Reach for this primitive directly when the underlying fetch is not
+ * a `doOperation()` call (e.g. a `WebSocket` subscription warm-up, a
+ * client-side computed projection that just needs to register as
+ * "loading" in the aggregator) or when the unit hydrates multiple
+ * participations from a single call.
+ */
+export declare function useExecutionParticipationPrefetch<TData>(input: UseExecutionParticipationPrefetchInput<TData>): UseExecutionParticipationPrefetchValue<TData>;
+//# sourceMappingURL=useExecutionParticipationPrefetch.d.ts.map

package/dist/esm/core/execution/useExecutionParticipationPrefetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecutionParticipationPrefetch.d.ts","sourceRoot":"","sources":["../../../../../src/core/execution/useExecutionParticipationPrefetch.ts"],"names":[],"mappings":"AASA,OAAO,EAIL,KAAK,oCAAoC,EAE1C,MAAM,2BAA2B,CAAC;AA8CnC;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,sCAAsC,CAAC,KAAK;IAC3D;;;;;;;;;;;OAWG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;;OAOG;IACH,iBAAiB,EAAE,SAAS,MAAM,EAAE,CAAC;IACrC;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,MAAM,EAAE,oCAAoC,CAAC;IAC7C;;;;;;;OAOG;IACH,GAAG,EAAE,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IACzD,iFAAiF;IACjF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;;;;;;;OAcG;IACH,+BAA+B,CAAC,EAAE,OAAO,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,sCAAsC,CAAC,KAAK;IAC3D;;;;;OAKG;IACH,IAAI,EAAE,KAAK,GAAG,SAAS,CAAC;IACxB,gEAAgE;IAChE,SAAS,EAAE,OAAO,CAAC;IACnB;;;;;OAKG;IACH,KAAK,EAAE,OAAO,CAAC;IACf,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC;IAC1C;;;;;;OAMG;IACH,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iCAAiC,CAAC,KAAK,EACrD,KAAK,EAAE,sCAAsC,CAAC,KAAK,CAAC,GACnD,sCAAsC,CAAC,KAAK,CAAC,CAgL/C"}

package/dist/esm/core/execution/useExecutionParticipationPrefetch.js

@@ -0,0 +1,234 @@
+import { useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { assertExecutionRuntimeContext, ExecutionFailedActionScope, ExecutionRuntimeContext, } from './ExecutionRuntimeContext.js';
+import { buildExecutionFailedAction } from './execution-failure-handling.utils.js';
+/**
+ * Opaque, collision-resistant id minted per in-flight prefetch unit by the
+ * primitive hook. Distinct namespace from `actionRuntimeId` /
+ * `failureRuntimeId` so consumers reading the loading aggregator can tell
+ * apart prefetch entries from execute-action entries by id-prefix alone.
+ *
+ * Distinct from `prefetchKey`, which is the consumer-authored stable
+ * identity reused across consecutive settle cycles. See the
+ * `loading-aggregation.participation-prefetch.shell-data-hydrator`
+ * sub-anchor JSDoc in `ExecutionRuntimeContext.tsx` for why both ids exist.
+ */
+function createExecutionPrefetchRuntimeId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return `execution-prefetch-${crypto.randomUUID()}`;
+    }
+    return `execution-prefetch-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+function createExecutionPrefetchFailureRuntimeId() {
+    if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+        return `execution-failure-${crypto.randomUUID()}`;
+    }
+    return `execution-failure-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+/**
+ * Discriminator for distinguishing `AbortError` rejections (which are
+ * "settled by cancellation, not by failure") from real errors. The
+ * `AbortController` API rejects with `DOMException(name: 'AbortError')`
+ * by default; matching by `name` (rather than `instanceof DOMException`)
+ * keeps the check resilient across environments where the global
+ * `DOMException` constructor is not present (Node test runners, some
+ * SSR setups). Custom abort reasons that the consumer's `run` callback
+ * may throw still surface here as long as they expose `name === 'AbortError'`.
+ */
+function isAbortError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const candidate = error;
+    return candidate.name === 'AbortError';
+}
+/**
+ * Generic primitive hook for the participation-prefetch tier (Slice K).
+ *
+ * Owns the `ExecutionPendingPrefetch` lifecycle plumbing so consumer
+ * `run()` callbacks can focus on the actual async work. See the
+ * `loading-aggregation.participation-prefetch.shell-data-hydrator`
+ * sub-anchor in `ExecutionRuntimeContext.tsx` for the full producer
+ * contract (stable `prefetchKey`, one in-flight unit per hook,
+ * settle-always-clears, optional shell-aggregator bridge, latest-error
+ * surfacing, etc.).
+ *
+ * Most consumers want the opinionated wrapper
+ * `useExecutionParticipationDataPrefetch` instead — it handles the
+ * common case (hydrate a single participation's resource data via
+ * `doOperation()`) without the consumer having to author the
+ * operation-path-key derivation or the per-intent bridge default.
+ * Reach for this primitive directly when the underlying fetch is not
+ * a `doOperation()` call (e.g. a `WebSocket` subscription warm-up, a
+ * client-side computed projection that just needs to register as
+ * "loading" in the aggregator) or when the unit hydrates multiple
+ * participations from a single call.
+ */
+export function useExecutionParticipationPrefetch(input) {
+    const executionRuntime = assertExecutionRuntimeContext(useContext(ExecutionRuntimeContext));
+    // Snapshot the consumer-authored input into refs so the public
+    // `refetch` callback identity stays stable across input changes (it
+    // depends only on the navigation seam below). Identity churn on
+    // `refetch` would defeat the canonical `useEffect([refetch])`
+    // auto-run pattern consumers reach for — same identity-stability
+    // discipline `useExecution`'s `actions` value applies (Slice F/G
+    // regression notes).
+    const inputRef = useRef(input);
+    inputRef.current = input;
+    // Stash the live navigation seam in a ref, NOT a useCallback dep.
+    // Keeping `navigation` out of the dep arrays for `cancelInFlight` /
+    // `refetch` / the cleanup effect is load-bearing for two reasons:
+    //
+    // 1. **Identity-stability discipline.** Same shape Slice F/G dodged
+    //    a re-render loop with — depending on `navigation` here would
+    //    flip `refetch` identity whenever any nested provider reshapes
+    //    the navigation memo, breaking the canonical
+    //    `useEffect([refetch])` auto-run pattern.
+    //
+    // 2. **Cleanup-effect race avoidance.** If `cancelInFlight` depended
+    //    on `navigation`, a navigation-memo change WHILE a prefetch is
+    //    in flight would re-fire the cleanup effect and abort the
+    //    live unit — even though the consumer never re-keyed the hook.
+    //    The deps must be empty so cleanup runs ONLY on real unmount.
+    const navigationRef = useRef(executionRuntime.navigation);
+    navigationRef.current = executionRuntime.navigation;
+    // Per-mount controller for the latest fire. Replaced atomically on
+    // every `run()` so a stale promise settling after a fresh `run()`
+    // (or after unmount) cannot mutate hook state. Mirrors the canonical
+    // race-free fetch pattern.
+    const controllerRef = useRef(null);
+    // Per-mount tracking of the live `prefetchRuntimeId` so the cleanup
+    // / abort path knows which entry to `endParticipationPrefetch` even
+    // if the consumer's `run` callback never read the id itself.
+    const liveRuntimeIdRef = useRef(null);
+    const [data, setData] = useState(undefined);
+    const [error, setError] = useState(undefined);
+    const [isLoading, setIsLoading] = useState(false);
+    /**
+     * Internal helper used by both `abort()` and the unmount cleanup.
+     * Synchronously aborts the live controller and ends the live
+     * prefetch entry — guarantees `endParticipationPrefetch` runs even
+     * if the in-flight promise rejects later (its no-op handler in the
+     * `try`/`finally` will be a second `endParticipationPrefetch` call,
+     * which is idempotent because the runtime id is already gone — the
+     * `endParticipationPrefetch` JSDoc explicitly documents the unknown-id
+     * no-op behavior).
+     */
+    const cancelInFlight = useCallback(() => {
+        const liveController = controllerRef.current;
+        const liveRuntimeId = liveRuntimeIdRef.current;
+        controllerRef.current = null;
+        liveRuntimeIdRef.current = null;
+        if (liveController && !liveController.signal.aborted) {
+            liveController.abort();
+        }
+        if (liveRuntimeId !== null) {
+            navigationRef.current.endParticipationPrefetch(liveRuntimeId);
+        }
+    }, []);
+    const refetch = useCallback(async () => {
+        // Snapshot every consumer-authored field at the start of the run so
+        // a subsequent input change mid-flight cannot retroactively shift
+        // which `prefetchKey` we clear on settle, which `participationRefs`
+        // we register, etc. The hook semantics are "the run uses the inputs
+        // it was kicked off with" — not "the run uses whatever inputs are
+        // current at settle time".
+        const snapshot = inputRef.current;
+        const fireRuntimeId = createExecutionPrefetchRuntimeId();
+        const fireController = new AbortController();
+        // Replace the live controller atomically. Any in-flight run loses
+        // ownership: its end-handler in the `try`/`finally` will see
+        // `controllerRef.current !== fireController` and will skip the
+        // state mutation (so a slow rejection cannot bring back stale
+        // `error`). The prior runtime id is ended via `cancelInFlight()`
+        // below, BEFORE we begin the new entry — so the registry never
+        // shows two entries from the same hook.
+        cancelInFlight();
+        controllerRef.current = fireController;
+        liveRuntimeIdRef.current = fireRuntimeId;
+        const pendingPrefetch = {
+            prefetchRuntimeId: fireRuntimeId,
+            participationRefs: snapshot.participationRefs,
+            resourceType: snapshot.resourceType,
+            intent: snapshot.intent,
+            startedAt: Date.now(),
+            ...(snapshot.label !== undefined ? { label: snapshot.label } : {}),
+        };
+        navigationRef.current.beginParticipationPrefetch(pendingPrefetch);
+        setIsLoading(true);
+        try {
+            const result = await snapshot.run({ signal: fireController.signal });
+            // If the hook was abort-cancelled or replaced mid-flight, the
+            // controller ref no longer points to ours — do not mutate state.
+            if (controllerRef.current !== fireController) {
+                return undefined;
+            }
+            setData(result);
+            setError(undefined);
+            // Stable-key auto-prune: any prior `PARTICIPATION_PREFETCH`-scoped
+            // failure for this same `prefetchKey` is implicitly resolved by a
+            // successful settle. The verb is a no-op when no entry matches,
+            // so the call is cheap on the happy path.
+            navigationRef.current.clearFailedActionsForPrefetchKey(snapshot.prefetchKey);
+            return result;
+        }
+        catch (caughtError) {
+            if (controllerRef.current !== fireController) {
+                return undefined;
+            }
+            if (isAbortError(caughtError)) {
+                return undefined;
+            }
+            setError(caughtError);
+            if (snapshot.bridgeFailuresToShellAggregator === true) {
+                const failedAction = buildExecutionFailedAction({
+                    failureRuntimeId: createExecutionPrefetchFailureRuntimeId(),
+                    error: caughtError,
+                    resourceType: snapshot.resourceType,
+                    startedAt: pendingPrefetch.startedAt,
+                    ...(snapshot.label !== undefined ? { label: snapshot.label } : {}),
+                    scope: ExecutionFailedActionScope.PARTICIPATION_PREFETCH,
+                    prefetchKey: snapshot.prefetchKey,
+                });
+                navigationRef.current.captureFailedAction(failedAction);
+            }
+            return undefined;
+        }
+        finally {
+            // End the prefetch entry regardless of success / failure / abort.
+            // Race-safe: if a fresh `run()` raced ahead and replaced the
+            // controller, our `liveRuntimeIdRef` was already replaced too;
+            // guard the end call against double-clearing the new fire's id.
+            if (liveRuntimeIdRef.current === fireRuntimeId) {
+                liveRuntimeIdRef.current = null;
+                controllerRef.current = null;
+                navigationRef.current.endParticipationPrefetch(fireRuntimeId);
+                setIsLoading(false);
+            }
+        }
+    }, [cancelInFlight]);
+    const abort = useCallback(() => {
+        if (controllerRef.current === null) {
+            return;
+        }
+        cancelInFlight();
+        setIsLoading(false);
+    }, [cancelInFlight]);
+    // Cleanup on unmount: synchronously abort + end so the prefetch
+    // registry doesn't leak entries past the hook's lifetime. The
+    // in-flight promise's `finally` will see a stale runtime id and
+    // skip the second end call (idempotent unknown-id no-op).
+    useEffect(() => {
+        return () => {
+            cancelInFlight();
+        };
+    }, [cancelInFlight]);
+    return useMemo(() => ({
+        data,
+        isLoading,
+        error,
+        prefetchKey: input.prefetchKey,
+        refetch,
+        abort,
+    }), [abort, data, error, input.prefetchKey, isLoading, refetch]);
+}
+//# sourceMappingURL=useExecutionParticipationPrefetch.js.map

package/dist/esm/core/execution/useExecutionParticipationPrefetch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecutionParticipationPrefetch.js","sourceRoot":"","sources":["../../../../../src/core/execution/useExecutionParticipationPrefetch.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  useCallback,\n  useContext,\n  useEffect,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\n\nimport {\n  assertExecutionRuntimeContext,\n  ExecutionFailedActionScope,\n  ExecutionRuntimeContext,\n  type ExecutionParticipationPrefetchIntent,\n  type ExecutionPendingPrefetch,\n} from './ExecutionRuntimeContext';\nimport { buildExecutionFailedAction } from './execution-failure-handling.utils';\n\n/**\n * Opaque, collision-resistant id minted per in-flight prefetch unit by the\n * primitive hook. Distinct namespace from `actionRuntimeId` /\n * `failureRuntimeId` so consumers reading the loading aggregator can tell\n * apart prefetch entries from execute-action entries by id-prefix alone.\n *\n * Distinct from `prefetchKey`, which is the consumer-authored stable\n * identity reused across consecutive settle cycles. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor JSDoc in `ExecutionRuntimeContext.tsx` for why both ids exist.\n */\nfunction createExecutionPrefetchRuntimeId(): string {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return `execution-prefetch-${crypto.randomUUID()}`;\n  }\n  return `execution-prefetch-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\nfunction createExecutionPrefetchFailureRuntimeId(): string {\n  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {\n    return `execution-failure-${crypto.randomUUID()}`;\n  }\n  return `execution-failure-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;\n}\n\n/**\n * Discriminator for distinguishing `AbortError` rejections (which are\n * \"settled by cancellation, not by failure\") from real errors. The\n * `AbortController` API rejects with `DOMException(name: 'AbortError')`\n * by default; matching by `name` (rather than `instanceof DOMException`)\n * keeps the check resilient across environments where the global\n * `DOMException` constructor is not present (Node test runners, some\n * SSR setups). Custom abort reasons that the consumer's `run` callback\n * may throw still surface here as long as they expose `name === 'AbortError'`.\n */\nfunction isAbortError(error: unknown): boolean {\n  if (!error || typeof error !== 'object') {\n    return false;\n  }\n  const candidate = error as { name?: unknown };\n  return candidate.name === 'AbortError';\n}\n\n/**\n * Input shape for the generic primitive participation-prefetch hook.\n *\n * Contract anchored at\n * `saas.frontend.execution-view.loading-aggregation.participation-prefetch.shell-data-hydrator`\n * in `ExecutionRuntimeContext.tsx`. The primitive owns lifecycle plumbing\n * (begin/end pairing, AbortController, latest-error surfacing, optional\n * shell-aggregator bridge); the consumer's `run` callback owns the actual\n * fetch — typically a `doOperation()` invocation, but the hook is\n * intentionally fetch-mechanism-agnostic so future producers (a\n * relationship-projection source-resource hydrator, a lazy-binding\n * resolver) can reuse the same lifecycle without adopting `doOperation()`\n * semantics they do not need.\n */\nexport interface UseExecutionParticipationPrefetchInput<TData> {\n  /**\n   * Stable consumer-authored identity for the prefetch unit. Reused\n   * across consecutive `refetch()` cycles so the shell's\n   * `clearFailedActionsForPrefetchKey(key)` verb can drop matching\n   * entries on the next successful settle. Distinct from the\n   * per-run `prefetchRuntimeId` minted internally by the hook on\n   * every fire — see invariant #1 in the sub-anchor JSDoc.\n   *\n   * Consumers should prefer keys that include enough context to make\n   * the unit identifiable in failure-aggregator UX (e.g.\n   * `prefetch:todoList:${listId}` rather than `'load'`).\n   */\n  prefetchKey: string;\n  /**\n   * Participation refs whose data is being hydrated by this prefetch.\n   * Threaded into the registered `ExecutionPendingPrefetch` so per-ref\n   * predicates on `loading.isParticipationPrefetching(...)` can narrow\n   * to \"is *this ref* loading?\". Must contain at least one ref —\n   * `assertExecutionPendingPrefetchShape` enforces this at the nav\n   * helper boundary.\n   */\n  participationRefs: readonly string[];\n  /**\n   * Primary resource type being hydrated. Mirrors\n   * `ExecutionPendingAction.resourceType` so per-resource UI filtering\n   * composes uniformly across the loading aggregator's two tiers.\n   */\n  resourceType: string;\n  /**\n   * Whether this is `INITIAL` (full-screen skeleton UX) or `REFRESH`\n   * (subtle indicator UX). The primitive does NOT auto-toggle the\n   * `bridgeFailuresToShellAggregator` default off intent; see the\n   * wrapper (`useExecutionParticipationDataPrefetch`) for the\n   * intent-aware bridge default policy.\n   */\n  intent: ExecutionParticipationPrefetchIntent;\n  /**\n   * Async work to perform. Receives an `AbortSignal` that the hook\n   * triggers on unmount or on a fresh `run()` while one is already in\n   * flight. Consumers SHOULD thread the signal into their underlying\n   * fetch (e.g. `doOperation(..., { signal })`) so cancellation actually\n   * stops the network call rather than just discarding the result on\n   * settle.\n   */\n  run: (params: { signal: AbortSignal }) => Promise<TData>;\n  /** Optional human-readable label (\"Loading task graph\"). Opaque to the shell. */\n  label?: string;\n  /**\n   * When `true`, captured failures are also bridged into\n   * `execution.errors.failedActions` under\n   * `ExecutionFailedActionScope.PARTICIPATION_PREFETCH` (with the same\n   * `prefetchKey`), where they participate in the cross-component\n   * failure aggregator. The hook auto-clears entries with this scope\n   * and key on the next successful settle (via\n   * `clearFailedActionsForPrefetchKey`), so a stale failure banner\n   * vanishes the moment the next attempt succeeds.\n   *\n   * Defaults to `false` on the primitive — it has no intent-aware\n   * default to lean on. The wrapper\n   * (`useExecutionParticipationDataPrefetch`) applies a default split\n   * (INITIAL=true, REFRESH=false) that matches typical UX.\n   */\n  bridgeFailuresToShellAggregator?: boolean;\n}\n\n/**\n * Return shape for the generic primitive participation-prefetch hook.\n */\nexport interface UseExecutionParticipationPrefetchValue<TData> {\n  /**\n   * Most recently settled successful payload, or `undefined` when no\n   * successful settle has happened yet. Stale-while-revalidate: stays\n   * pinned through `isLoading: true` rerun cycles so renderers can\n   * keep showing the prior data while a `REFRESH` is in flight.\n   */\n  data: TData | undefined;\n  /** `true` while a `run({ signal })` invocation is in flight. */\n  isLoading: boolean;\n  /**\n   * Latest settle's rejection (or `undefined` after a successful\n   * settle). Resets to `undefined` on every successful settle and is\n   * set to the rejection on every failed one. `AbortError` rejections\n   * are NOT surfaced here — cancellations are not failures.\n   */\n  error: unknown;\n  /** Consumer-authored stable identity (echo of input for diagnostics). */\n  prefetchKey: string;\n  /**\n   * Trigger a fresh run. Aborts any in-flight one first (and removes\n   * its `ExecutionPendingPrefetch` entry) before minting a fresh\n   * `prefetchRuntimeId` and beginning the new unit. Returns the\n   * resolved data, or `undefined` if the run was aborted or rejected\n   * (the hook's `error` state surfaces the rejection).\n   */\n  refetch: () => Promise<TData | undefined>;\n  /**\n   * Cancel the current in-flight run, if any. Does NOT trigger a\n   * follow-up — the hook's state stays at whatever it was right\n   * before the abort (data unchanged, isLoading drops to false,\n   * error unchanged). Typical use: a \"Cancel loading\" button next\n   * to a long-running prefetch.\n   */\n  abort: () => void;\n}\n\n/**\n * Generic primitive hook for the participation-prefetch tier (Slice K).\n *\n * Owns the `ExecutionPendingPrefetch` lifecycle plumbing so consumer\n * `run()` callbacks can focus on the actual async work. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor in `ExecutionRuntimeContext.tsx` for the full producer\n * contract (stable `prefetchKey`, one in-flight unit per hook,\n * settle-always-clears, optional shell-aggregator bridge, latest-error\n * surfacing, etc.).\n *\n * Most consumers want the opinionated wrapper\n * `useExecutionParticipationDataPrefetch` instead — it handles the\n * common case (hydrate a single participation's resource data via\n * `doOperation()`) without the consumer having to author the\n * operation-path-key derivation or the per-intent bridge default.\n * Reach for this primitive directly when the underlying fetch is not\n * a `doOperation()` call (e.g. a `WebSocket` subscription warm-up, a\n * client-side computed projection that just needs to register as\n * \"loading\" in the aggregator) or when the unit hydrates multiple\n * participations from a single call.\n */\nexport function useExecutionParticipationPrefetch<TData>(\n  input: UseExecutionParticipationPrefetchInput<TData>,\n): UseExecutionParticipationPrefetchValue<TData> {\n  const executionRuntime = assertExecutionRuntimeContext(useContext(ExecutionRuntimeContext));\n\n  // Snapshot the consumer-authored input into refs so the public\n  // `refetch` callback identity stays stable across input changes (it\n  // depends only on the navigation seam below). Identity churn on\n  // `refetch` would defeat the canonical `useEffect([refetch])`\n  // auto-run pattern consumers reach for — same identity-stability\n  // discipline `useExecution`'s `actions` value applies (Slice F/G\n  // regression notes).\n  const inputRef = useRef(input);\n  inputRef.current = input;\n\n  // Stash the live navigation seam in a ref, NOT a useCallback dep.\n  // Keeping `navigation` out of the dep arrays for `cancelInFlight` /\n  // `refetch` / the cleanup effect is load-bearing for two reasons:\n  //\n  // 1. **Identity-stability discipline.** Same shape Slice F/G dodged\n  //    a re-render loop with — depending on `navigation` here would\n  //    flip `refetch` identity whenever any nested provider reshapes\n  //    the navigation memo, breaking the canonical\n  //    `useEffect([refetch])` auto-run pattern.\n  //\n  // 2. **Cleanup-effect race avoidance.** If `cancelInFlight` depended\n  //    on `navigation`, a navigation-memo change WHILE a prefetch is\n  //    in flight would re-fire the cleanup effect and abort the\n  //    live unit — even though the consumer never re-keyed the hook.\n  //    The deps must be empty so cleanup runs ONLY on real unmount.\n  const navigationRef = useRef(executionRuntime.navigation);\n  navigationRef.current = executionRuntime.navigation;\n\n  // Per-mount controller for the latest fire. Replaced atomically on\n  // every `run()` so a stale promise settling after a fresh `run()`\n  // (or after unmount) cannot mutate hook state. Mirrors the canonical\n  // race-free fetch pattern.\n  const controllerRef = useRef<AbortController | null>(null);\n  // Per-mount tracking of the live `prefetchRuntimeId` so the cleanup\n  // / abort path knows which entry to `endParticipationPrefetch` even\n  // if the consumer's `run` callback never read the id itself.\n  const liveRuntimeIdRef = useRef<string | null>(null);\n\n  const [data, setData] = useState<TData | undefined>(undefined);\n  const [error, setError] = useState<unknown>(undefined);\n  const [isLoading, setIsLoading] = useState<boolean>(false);\n\n  /**\n   * Internal helper used by both `abort()` and the unmount cleanup.\n   * Synchronously aborts the live controller and ends the live\n   * prefetch entry — guarantees `endParticipationPrefetch` runs even\n   * if the in-flight promise rejects later (its no-op handler in the\n   * `try`/`finally` will be a second `endParticipationPrefetch` call,\n   * which is idempotent because the runtime id is already gone — the\n   * `endParticipationPrefetch` JSDoc explicitly documents the unknown-id\n   * no-op behavior).\n   */\n  const cancelInFlight = useCallback((): void => {\n    const liveController = controllerRef.current;\n    const liveRuntimeId = liveRuntimeIdRef.current;\n    controllerRef.current = null;\n    liveRuntimeIdRef.current = null;\n    if (liveController && !liveController.signal.aborted) {\n      liveController.abort();\n    }\n    if (liveRuntimeId !== null) {\n      navigationRef.current.endParticipationPrefetch(liveRuntimeId);\n    }\n  }, []);\n\n  const refetch = useCallback(async (): Promise<TData | undefined> => {\n    // Snapshot every consumer-authored field at the start of the run so\n    // a subsequent input change mid-flight cannot retroactively shift\n    // which `prefetchKey` we clear on settle, which `participationRefs`\n    // we register, etc. The hook semantics are \"the run uses the inputs\n    // it was kicked off with\" — not \"the run uses whatever inputs are\n    // current at settle time\".\n    const snapshot = inputRef.current;\n    const fireRuntimeId = createExecutionPrefetchRuntimeId();\n    const fireController = new AbortController();\n    // Replace the live controller atomically. Any in-flight run loses\n    // ownership: its end-handler in the `try`/`finally` will see\n    // `controllerRef.current !== fireController` and will skip the\n    // state mutation (so a slow rejection cannot bring back stale\n    // `error`). The prior runtime id is ended via `cancelInFlight()`\n    // below, BEFORE we begin the new entry — so the registry never\n    // shows two entries from the same hook.\n    cancelInFlight();\n    controllerRef.current = fireController;\n    liveRuntimeIdRef.current = fireRuntimeId;\n\n    const pendingPrefetch: ExecutionPendingPrefetch = {\n      prefetchRuntimeId: fireRuntimeId,\n      participationRefs: snapshot.participationRefs,\n      resourceType: snapshot.resourceType,\n      intent: snapshot.intent,\n      startedAt: Date.now(),\n      ...(snapshot.label !== undefined ? { label: snapshot.label } : {}),\n    };\n    navigationRef.current.beginParticipationPrefetch(pendingPrefetch);\n    setIsLoading(true);\n\n    try {\n      const result = await snapshot.run({ signal: fireController.signal });\n      // If the hook was abort-cancelled or replaced mid-flight, the\n      // controller ref no longer points to ours — do not mutate state.\n      if (controllerRef.current !== fireController) {\n        return undefined;\n      }\n      setData(result);\n      setError(undefined);\n      // Stable-key auto-prune: any prior `PARTICIPATION_PREFETCH`-scoped\n      // failure for this same `prefetchKey` is implicitly resolved by a\n      // successful settle. The verb is a no-op when no entry matches,\n      // so the call is cheap on the happy path.\n      navigationRef.current.clearFailedActionsForPrefetchKey(snapshot.prefetchKey);\n      return result;\n    } catch (caughtError) {\n      if (controllerRef.current !== fireController) {\n        return undefined;\n      }\n      if (isAbortError(caughtError)) {\n        return undefined;\n      }\n      setError(caughtError);\n      if (snapshot.bridgeFailuresToShellAggregator === true) {\n        const failedAction = buildExecutionFailedAction({\n          failureRuntimeId: createExecutionPrefetchFailureRuntimeId(),\n          error: caughtError,\n          resourceType: snapshot.resourceType,\n          startedAt: pendingPrefetch.startedAt,\n          ...(snapshot.label !== undefined ? { label: snapshot.label } : {}),\n          scope: ExecutionFailedActionScope.PARTICIPATION_PREFETCH,\n          prefetchKey: snapshot.prefetchKey,\n        });\n        navigationRef.current.captureFailedAction(failedAction);\n      }\n      return undefined;\n    } finally {\n      // End the prefetch entry regardless of success / failure / abort.\n      // Race-safe: if a fresh `run()` raced ahead and replaced the\n      // controller, our `liveRuntimeIdRef` was already replaced too;\n      // guard the end call against double-clearing the new fire's id.\n      if (liveRuntimeIdRef.current === fireRuntimeId) {\n        liveRuntimeIdRef.current = null;\n        controllerRef.current = null;\n        navigationRef.current.endParticipationPrefetch(fireRuntimeId);\n        setIsLoading(false);\n      }\n    }\n  }, [cancelInFlight]);\n\n  const abort = useCallback((): void => {\n    if (controllerRef.current === null) {\n      return;\n    }\n    cancelInFlight();\n    setIsLoading(false);\n  }, [cancelInFlight]);\n\n  // Cleanup on unmount: synchronously abort + end so the prefetch\n  // registry doesn't leak entries past the hook's lifetime. The\n  // in-flight promise's `finally` will see a stale runtime id and\n  // skip the second end call (idempotent unknown-id no-op).\n  useEffect(() => {\n    return () => {\n      cancelInFlight();\n    };\n  }, [cancelInFlight]);\n\n  return useMemo<UseExecutionParticipationPrefetchValue<TData>>(() => ({\n    data,\n    isLoading,\n    error,\n    prefetchKey: input.prefetchKey,\n    refetch,\n    abort,\n  }), [abort, data, error, input.prefetchKey, isLoading, refetch]);\n}\n"]}

package/dist/esm/core/execution/useExecutionParticipationRMM.d.ts

@@ -0,0 +1,41 @@
+import type { ResourceType } from '@wildo-ai/saas-models';
+import type { FrontendResourceOperationContext } from '../../core/resources/resources.frontend.schemas';
+import type { ConflictPolicy } from '../../core/resources/rmm/types';
+import { type UseResourceRMMResult } from '../../core/resources/rmm/useResourceRMM';
+export declare enum UseExecutionParticipationRMMUnavailableReason {
+    PARTICIPATION_NOT_FOUND = "PARTICIPATION_NOT_FOUND",
+    MISSING_CONCRETE_RESOURCE_ID = "MISSING_CONCRETE_RESOURCE_ID"
+}
+export interface UseExecutionParticipationRMMConfig {
+    participationRef: string;
+    /**
+     * Optional concrete resource id override for cases where the authored
+     * participation is non-singular (for example a relationship projection to a
+     * collection) but the execution renderer is delegating one concrete child lane
+     * to RMM.
+     */
+    resourceId?: string;
+    contextResourceIdentifiers?: FrontendResourceOperationContext['contextResourceIdentifiers'];
+    relationshipFieldOverrides?: Record<ResourceType, string>;
+    enabled?: boolean;
+    conflictPolicy?: ConflictPolicy;
+    resourceSchema?: unknown;
+}
+export interface UseExecutionParticipationRMMResult extends UseResourceRMMResult {
+    executionUnavailableReason: UseExecutionParticipationRMMUnavailableReason | null;
+    resourceType: string | null;
+    resourceId: string | null;
+    contextResourceIdentifiers: FrontendResourceOperationContext['contextResourceIdentifiers'];
+    contextualParameters: Record<string, string | number>;
+    parentResourcesRequirements: FrontendResourceOperationContext['parentResourcesRequirements'];
+}
+/**
+ * Thin execution-to-RMM bridge for one concrete participation-backed mutation
+ * lane.
+ *
+ * Execution remains the macro orchestrator, but when a renderer resolves one
+ * editable single-resource subject, this hook hands the concrete lane back to
+ * the existing RMM runtime instead of re-implementing mutation semantics.
+ */
+export declare function useExecutionParticipationRMM(config: UseExecutionParticipationRMMConfig): UseExecutionParticipationRMMResult;
+//# sourceMappingURL=useExecutionParticipationRMM.d.ts.map

package/dist/esm/core/execution/useExecutionParticipationRMM.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecutionParticipationRMM.d.ts","sourceRoot":"","sources":["../../../../../src/core/execution/useExecutionParticipationRMM.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAM1D,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,+DAA+D,CAAC;AAEtH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AACnF,OAAO,EACL,KAAK,oBAAoB,EAE1B,MAAM,uDAAuD,CAAC;AAW/D,oBAAY,6CAA6C;IACvD,uBAAuB,4BAA4B;IACnD,4BAA4B,iCAAiC;CAC9D;AAED,MAAM,WAAW,kCAAkC;IACjD,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,0BAA0B,CAAC,EAAE,gCAAgC,CAAC,4BAA4B,CAAC,CAAC;IAC5F,0BAA0B,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAC1D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,kCAAmC,SAAQ,oBAAoB;IAC9E,0BAA0B,EAAE,6CAA6C,GAAG,IAAI,CAAC;IACjF,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,0BAA0B,EAAE,gCAAgC,CAAC,4BAA4B,CAAC,CAAC;IAC3F,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC;IACtD,2BAA2B,EAAE,gCAAgC,CAAC,6BAA6B,CAAC,CAAC;CAC9F;AAoBD;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,kCAAkC,GACzC,kCAAkC,CAiIpC"}

package/dist/esm/core/execution/useExecutionParticipationRMM.js

@@ -0,0 +1,127 @@
+import { useContext, useMemo, useRef } from 'react';
+import { frontendResourceUtils, FrontendResourceUtils, } from '../../core/resources/frontend-resource.utils.js';
+import { useResourceRMM, } from '../../core/resources/rmm/useResourceRMM.js';
+import { useResourceRegistry } from '../../core/resources/useResourceRegistry.js';
+import { buildExecutionParticipationHandle, } from './execution-participation.utils.js';
+import { assertExecutionRuntimeContext, ExecutionRuntimeContext, } from './ExecutionRuntimeContext.js';
+export var UseExecutionParticipationRMMUnavailableReason;
+(function (UseExecutionParticipationRMMUnavailableReason) {
+    UseExecutionParticipationRMMUnavailableReason["PARTICIPATION_NOT_FOUND"] = "PARTICIPATION_NOT_FOUND";
+    UseExecutionParticipationRMMUnavailableReason["MISSING_CONCRETE_RESOURCE_ID"] = "MISSING_CONCRETE_RESOURCE_ID";
+})(UseExecutionParticipationRMMUnavailableReason || (UseExecutionParticipationRMMUnavailableReason = {}));
+function overrideResourceContextSlot(params) {
+    const fieldIdentifier = params.currentValue
+        ? frontendResourceUtils.getFieldIdentifier(params.currentValue)
+        : undefined;
+    if (fieldIdentifier) {
+        return {
+            fieldIdentifier,
+            resourceId: params.resourceId,
+        };
+    }
+    return params.resourceId;
+}
+/**
+ * Thin execution-to-RMM bridge for one concrete participation-backed mutation
+ * lane.
+ *
+ * Execution remains the macro orchestrator, but when a renderer resolves one
+ * editable single-resource subject, this hook hands the concrete lane back to
+ * the existing RMM runtime instead of re-implementing mutation semantics.
+ */
+export function useExecutionParticipationRMM(config) {
+    const { participationRef, resourceId: resourceIdOverride, contextResourceIdentifiers: contextResourceOverrides, relationshipFieldOverrides, enabled = true, conflictPolicy, resourceSchema, } = config;
+    const executionRuntime = assertExecutionRuntimeContext(useContext(ExecutionRuntimeContext));
+    const { registry } = useResourceRegistry();
+    const rawParticipation = executionRuntime.participations[participationRef];
+    const participationHandle = useMemo(() => {
+        if (!rawParticipation) {
+            return undefined;
+        }
+        return buildExecutionParticipationHandle({
+            participation: rawParticipation,
+            registry,
+        });
+    }, [rawParticipation, registry]);
+    const doOperationRef = useRef(executionRuntime.doOperation);
+    doOperationRef.current = executionRuntime.doOperation;
+    const resourceType = participationHandle?.resourceType ?? null;
+    const resourceId = resourceIdOverride ?? participationHandle?.resourceId ?? null;
+    const executionUnavailableReason = useMemo(() => {
+        if (!participationHandle) {
+            return UseExecutionParticipationRMMUnavailableReason.PARTICIPATION_NOT_FOUND;
+        }
+        if (!resourceId) {
+            return UseExecutionParticipationRMMUnavailableReason.MISSING_CONCRETE_RESOURCE_ID;
+        }
+        return null;
+    }, [participationHandle, resourceId]);
+    const mergedContextResourceIdentifiers = useMemo(() => {
+        const contextResourceIdentifiers = {
+            ...(executionRuntime.contextResourceIdentifiers ?? {}),
+            ...(contextResourceOverrides ?? {}),
+        };
+        if (resourceType && participationHandle?.contextIdentifier) {
+            contextResourceIdentifiers[resourceType] = participationHandle.contextIdentifier;
+        }
+        if (resourceType && resourceId) {
+            contextResourceIdentifiers[resourceType] = overrideResourceContextSlot({
+                currentValue: contextResourceIdentifiers[resourceType],
+                resourceId,
+            });
+        }
+        return contextResourceIdentifiers;
+    }, [
+        contextResourceOverrides,
+        executionRuntime.contextResourceIdentifiers,
+        participationHandle?.contextIdentifier,
+        resourceId,
+        resourceType,
+    ]);
+    const parentResourcesRequirements = useMemo(() => {
+        if (!resourceType || executionUnavailableReason) {
+            return [];
+        }
+        return frontendResourceUtils.buildParentResourcesRequirements(resourceType, mergedContextResourceIdentifiers, registry, relationshipFieldOverrides);
+    }, [
+        executionUnavailableReason,
+        mergedContextResourceIdentifiers,
+        registry,
+        relationshipFieldOverrides,
+        resourceType,
+    ]);
+    const contextualParameters = useMemo(() => {
+        if (!resourceType || executionUnavailableReason) {
+            return {};
+        }
+        return FrontendResourceUtils.buildContextualParameters(mergedContextResourceIdentifiers, registry);
+    }, [
+        executionUnavailableReason,
+        mergedContextResourceIdentifiers,
+        registry,
+        resourceType,
+    ]);
+    const rmm = useResourceRMM({
+        resourceType: resourceType ?? '',
+        resourceId,
+        doOperationRef,
+        contextualParameters,
+        parentResourcesRequirements,
+        contextResourceIdentifiers: mergedContextResourceIdentifiers,
+        resourceSchema: resourceSchema ?? (resourceType
+            ? registry.resourceConfigurations[resourceType]?.mainSchema
+            : undefined),
+        enabled: enabled && executionUnavailableReason === null,
+        conflictPolicy,
+    });
+    return {
+        ...rmm,
+        executionUnavailableReason,
+        resourceType,
+        resourceId,
+        contextResourceIdentifiers: mergedContextResourceIdentifiers,
+        contextualParameters,
+        parentResourcesRequirements,
+    };
+}
+//# sourceMappingURL=useExecutionParticipationRMM.js.map

package/dist/esm/core/execution/useExecutionParticipationRMM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecutionParticipationRMM.js","sourceRoot":"","sources":["../../../../../src/core/execution/useExecutionParticipationRMM.ts"],"names":[],"mappings":"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","sourcesContent":["import { useContext, useMemo, useRef } from 'react';\n\nimport type { ResourceType } from '@wildo-ai/saas-models';\n\nimport {\n  frontendResourceUtils,\n  FrontendResourceUtils,\n} from '~wildo-frontend-lib/core/resources/frontend-resource.utils';\nimport type { FrontendResourceOperationContext } from '~wildo-frontend-lib/core/resources/resources.frontend.schemas';\nimport type { DoOperationFn } from '~wildo-frontend-lib/core/resources/rmm/HttpTransportAdapter';\nimport type { ConflictPolicy } from '~wildo-frontend-lib/core/resources/rmm/types';\nimport {\n  type UseResourceRMMResult,\n  useResourceRMM,\n} from '~wildo-frontend-lib/core/resources/rmm/useResourceRMM';\nimport { useResourceRegistry } from '~wildo-frontend-lib/core/resources/useResourceRegistry';\nimport {\n  buildExecutionParticipationHandle,\n  type ExecutionParticipationHandle,\n} from './execution-participation.utils';\nimport {\n  assertExecutionRuntimeContext,\n  ExecutionRuntimeContext,\n} from './ExecutionRuntimeContext';\n\nexport enum UseExecutionParticipationRMMUnavailableReason {\n  PARTICIPATION_NOT_FOUND = 'PARTICIPATION_NOT_FOUND',\n  MISSING_CONCRETE_RESOURCE_ID = 'MISSING_CONCRETE_RESOURCE_ID',\n}\n\nexport interface UseExecutionParticipationRMMConfig {\n  participationRef: string;\n  /**\n   * Optional concrete resource id override for cases where the authored\n   * participation is non-singular (for example a relationship projection to a\n   * collection) but the execution renderer is delegating one concrete child lane\n   * to RMM.\n   */\n  resourceId?: string;\n  contextResourceIdentifiers?: FrontendResourceOperationContext['contextResourceIdentifiers'];\n  relationshipFieldOverrides?: Record<ResourceType, string>;\n  enabled?: boolean;\n  conflictPolicy?: ConflictPolicy;\n  resourceSchema?: unknown;\n}\n\nexport interface UseExecutionParticipationRMMResult extends UseResourceRMMResult {\n  executionUnavailableReason: UseExecutionParticipationRMMUnavailableReason | null;\n  resourceType: string | null;\n  resourceId: string | null;\n  contextResourceIdentifiers: FrontendResourceOperationContext['contextResourceIdentifiers'];\n  contextualParameters: Record<string, string | number>;\n  parentResourcesRequirements: FrontendResourceOperationContext['parentResourcesRequirements'];\n}\n\nfunction overrideResourceContextSlot(params: {\n  currentValue: FrontendResourceOperationContext['contextResourceIdentifiers'][string] | undefined;\n  resourceId: string;\n}): FrontendResourceOperationContext['contextResourceIdentifiers'][string] {\n  const fieldIdentifier = params.currentValue\n    ? frontendResourceUtils.getFieldIdentifier(params.currentValue)\n    : undefined;\n\n  if (fieldIdentifier) {\n    return {\n      fieldIdentifier,\n      resourceId: params.resourceId,\n    };\n  }\n\n  return params.resourceId;\n}\n\n/**\n * Thin execution-to-RMM bridge for one concrete participation-backed mutation\n * lane.\n *\n * Execution remains the macro orchestrator, but when a renderer resolves one\n * editable single-resource subject, this hook hands the concrete lane back to\n * the existing RMM runtime instead of re-implementing mutation semantics.\n */\nexport function useExecutionParticipationRMM(\n  config: UseExecutionParticipationRMMConfig,\n): UseExecutionParticipationRMMResult {\n  const {\n    participationRef,\n    resourceId: resourceIdOverride,\n    contextResourceIdentifiers: contextResourceOverrides,\n    relationshipFieldOverrides,\n    enabled = true,\n    conflictPolicy,\n    resourceSchema,\n  } = config;\n  const executionRuntime = assertExecutionRuntimeContext(useContext(ExecutionRuntimeContext));\n  const { registry } = useResourceRegistry();\n\n  const rawParticipation = executionRuntime.participations[participationRef];\n  const participationHandle = useMemo<ExecutionParticipationHandle | undefined>(() => {\n    if (!rawParticipation) {\n      return undefined;\n    }\n\n    return buildExecutionParticipationHandle({\n      participation: rawParticipation,\n      registry,\n    });\n  }, [rawParticipation, registry]);\n\n  const doOperationRef = useRef<DoOperationFn | null>(executionRuntime.doOperation);\n  doOperationRef.current = executionRuntime.doOperation;\n\n  const resourceType = participationHandle?.resourceType ?? null;\n  const resourceId = resourceIdOverride ?? participationHandle?.resourceId ?? null;\n\n  const executionUnavailableReason = useMemo((): UseExecutionParticipationRMMUnavailableReason | null => {\n    if (!participationHandle) {\n      return UseExecutionParticipationRMMUnavailableReason.PARTICIPATION_NOT_FOUND;\n    }\n\n    if (!resourceId) {\n      return UseExecutionParticipationRMMUnavailableReason.MISSING_CONCRETE_RESOURCE_ID;\n    }\n\n    return null;\n  }, [participationHandle, resourceId]);\n\n  const mergedContextResourceIdentifiers = useMemo<FrontendResourceOperationContext['contextResourceIdentifiers']>(() => {\n    const contextResourceIdentifiers = {\n      ...(executionRuntime.contextResourceIdentifiers ?? {}),\n      ...(contextResourceOverrides ?? {}),\n    };\n\n    if (resourceType && participationHandle?.contextIdentifier) {\n      contextResourceIdentifiers[resourceType] = participationHandle.contextIdentifier;\n    }\n\n    if (resourceType && resourceId) {\n      contextResourceIdentifiers[resourceType] = overrideResourceContextSlot({\n        currentValue: contextResourceIdentifiers[resourceType],\n        resourceId,\n      });\n    }\n\n    return contextResourceIdentifiers;\n  }, [\n    contextResourceOverrides,\n    executionRuntime.contextResourceIdentifiers,\n    participationHandle?.contextIdentifier,\n    resourceId,\n    resourceType,\n  ]);\n\n  const parentResourcesRequirements = useMemo<FrontendResourceOperationContext['parentResourcesRequirements']>(() => {\n    if (!resourceType || executionUnavailableReason) {\n      return [];\n    }\n\n    return frontendResourceUtils.buildParentResourcesRequirements(\n      resourceType as ResourceType,\n      mergedContextResourceIdentifiers,\n      registry,\n      relationshipFieldOverrides,\n    );\n  }, [\n    executionUnavailableReason,\n    mergedContextResourceIdentifiers,\n    registry,\n    relationshipFieldOverrides,\n    resourceType,\n  ]);\n\n  const contextualParameters = useMemo(() => {\n    if (!resourceType || executionUnavailableReason) {\n      return {};\n    }\n\n    return FrontendResourceUtils.buildContextualParameters(\n      mergedContextResourceIdentifiers,\n      registry,\n    );\n  }, [\n    executionUnavailableReason,\n    mergedContextResourceIdentifiers,\n    registry,\n    resourceType,\n  ]);\n\n  const rmm = useResourceRMM({\n    resourceType: resourceType ?? '',\n    resourceId,\n    doOperationRef,\n    contextualParameters,\n    parentResourcesRequirements,\n    contextResourceIdentifiers: mergedContextResourceIdentifiers,\n    resourceSchema: resourceSchema ?? (\n      resourceType\n        ? registry.resourceConfigurations[resourceType]?.mainSchema\n        : undefined\n    ),\n    enabled: enabled && executionUnavailableReason === null,\n    conflictPolicy,\n  });\n\n  return {\n    ...rmm,\n    executionUnavailableReason,\n    resourceType,\n    resourceId,\n    contextResourceIdentifiers: mergedContextResourceIdentifiers,\n    contextualParameters,\n    parentResourcesRequirements,\n  };\n}\n"]}