npm - @wildo-ai/saas-frontend-lib - Versions diffs - 1.1.2 → 1.1.3 - Mend

@wildo-ai/saas-frontend-lib 1.1.2 → 1.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1917) hide show

package/dist/esm/core/execution/ExecutionRuntimeContext.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"ExecutionRuntimeContext.d.ts","sourceRoot":"","sources":["~~../../../../../~~src/core/execution/ExecutionRuntimeContext.tsx"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"ExecutionRuntimeContext.d.ts","sourceRoot":"","sources":["../../../../src/core/execution/ExecutionRuntimeContext.tsx"],"names":[],"mappings":"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"}

package/dist/esm/core/execution/ExecutionRuntimeContext.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"ExecutionRuntimeContext.js","sourceRoot":"","sources":["../../../../../src/core/execution/ExecutionRuntimeContext.tsx"],"names":[],"mappings":"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","sourcesContent":["import React, { createContext, useMemo } from 'react';\n\nimport type { ExecutionViewDefinition } from '~wildo-frontend-lib/core/config/execution-view.schemas';\nimport type { ResourceRegistryContextType } from '~wildo-frontend-lib/core/resources/ResourceRegistryContext';\nimport type { NavigateOptions } from '~wildo-frontend-lib/core/navigation/useNavigationController';\nimport {\n NavigationContentType,\n type NavigationContent,\n type NavigationInitiatorContext,\n type NavigationZone,\n} from '~wildo-frontend-lib/core/navigation/navigation.schemas';\nimport type { ResolvedExecutionParticipation } from './execution-participation.utils';\n\nexport enum ExecutionAnchorSource {\n PARENT_RESOURCE_REQUIREMENT = 'parent-resource-requirement',\n ADDITIONAL_RESOURCE_REQUIREMENT = 'additional-resource-requirement',\n}\n\n/*\n Minimal resolved anchor for the first execution runtime slice.\n \n This anchor is intentionally conservative: it is only resolved from declared\n * resource requirements that also have a concrete bound identifier in the\n * execution context. Ambient primary scope alone is not enough to synthesize an\n * anchor because primary scope identifies environment, not necessarily subject.\n /\nexport interface ExecutionAnchor {\n mainResourceType: string;\n mainResourceId: string;\n bindingKey: string;\n source: ExecutionAnchorSource;\n}\n\nexport interface ExecutionLocalPaneState {\n paneId: string;\n payload?: unknown;\n}\n\n/\n @wildo_source:part:start saas.frontend.execution-view.loading-aggregation facet:layer:frontend facet:family:execution-view\n \n Execution-shell loading aggregation.\n \n The execution shell publishes one authoritative loading signal per\n * runtime-instance, aggregating only what the shell itself truthfully owns.\n * Consumers get a single `execution.loading` surface instead of re-authoring\n * spinner state for every action button.\n \n What the aggregator owns (and why):\n \n - Pending execute actions. Every `execute()` on a resource-operation\n * action verb runs through the shell's `doOperation()` bridge. The shell\n * registers a `ExecutionPendingAction` before the call and clears it on\n * settle (success or failure).\n * - Participation prefetch entries. A second tier for in-flight async\n * hydration of one or more execution participations. Wired in Slice H as\n * scaffolding ahead of a real producer (no in-tree producer exists today\n * because participation resolution is fully synchronous), so a future\n * async participation source can register prefetches without re-shaping\n * the public `ExecutionLoadingValue` surface. Spec lives at the\n * `participation-prefetch` sub-anchor below.\n \n What the aggregator intentionally does not own:\n \n - Embedded-content layout loading. The embedded slot mounts a\n * `ResourceOperationSurface`, which has its own internal read/write\n * loading contract. The execution shell does not shadow or duplicate that\n * contract; `hasEmbeddedContent` alone is not a loading signal.\n * - Router-delegated content. Once `delegateToParent(...)` fires, the\n * execution view has yielded ownership. Any downstream loading lives on\n * the router's navigation stack.\n * - Consumer-pushed phases. App code cannot register synthetic \"phase\"\n * entries to make `isBusy` reflect a multi-step workflow it owns. Every\n * tier is shell-owned (see invariant #1) — that constraint is what makes\n * the aggregator's truthfulness portable across consumers.\n \n Contract invariants:\n \n 1. Shell-owned tracking only. The aggregator is populated exclusively\n * by shell-owned hooks (`execute()` for the pending-action tier; future\n * framework-owned participation resolvers for the participation-prefetch\n * tier). App code must not push entries into it directly — the\n * `begin/endPendingAction` and `begin/endParticipationPrefetch` helpers\n * on `ExecutionNavigationValue` are internal plumbing.\n * 2. Settle always clears. Every `beginPendingAction` /\n * `beginParticipationPrefetch` has a matching `endPendingAction` /\n * `endParticipationPrefetch`, called in the promise's `finally` path.\n * Rejections clear the entry just like resolutions.\n * 3. Per-runtime-instance scope. The aggregator lives on the execution\n * runtime, not globally. Two execution views mounted in the same app do\n * not share pending-action or prefetch state.\n * 4. Orthogonal to the three-zone contract. Pending actions and prefetches\n * are operational telemetry, not a fourth navigation zone. They coexist\n * with `embeddedContent` and `localPane` on `ExecutionRuntimeState` but\n * do not represent child intent.\n * 5. `isBusy` aggregates every tier.\n * `execution.loading.isBusy = pendingActions.length > 0 \|\|\n * participationPrefetchActions.length > 0`. The renderer-facing label\n * \"anything in flight\" stays honest as new tiers are added. Per-tier\n * narrowing is reached via `isPending(...)` (execute actions) and\n * `isParticipationPrefetching(...)` (prefetches) explicitly.\n /\nexport interface ExecutionPendingAction {\n /\n Stable id for the pending action. Generated by the shell at `begin` time\n * so `end` can clear the matching entry even if the caller forgets it.\n /\n actionRuntimeId: string;\n /* Canonical `operationPathKey` the shell passed to `doOperation()`. /\n operationPathKey: string;\n /* Resource the action targets, for per-resource UI filtering. /\n resourceType: string;\n /* Operation identifier (e.g. `READ`, `UPDATE`, dictionary key). /\n operationId: string;\n /* `Date.now()` when tracking began — useful for stale-spinner detection. /\n startedAt: number;\n}\n/* @wildo_source:part:end saas.frontend.execution-view.loading-aggregation /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.loading-aggregation.participation-prefetch facet:layer:frontend facet:family:execution-view\n \n Execution-shell loading aggregation — participation-prefetch tier (Slice H).\n \n Sub-anchor of `saas.frontend.execution-view.loading-aggregation`. Defines\n * the loading aggregator's second tier: in-flight async hydration of one or\n * more execution participations.\n \n First producer landed in Slice K. `resolveExecutionParticipations(...)`\n * itself is still synchronous (a pure derivation from `viewDefinition` +\n * `registry` + `anchor` + `contextResourceIdentifiers`), but the first\n * concrete producer for this tier ships as a pair of consumer-callable\n * hooks — `useExecutionParticipationPrefetch` (generic primitive) and\n * `useExecutionParticipationDataPrefetch` (opinionated wrapper). They\n * orchestrate `doOperation()`-driven async data fetches around the\n * `beginParticipationPrefetch` / `endParticipationPrefetch` lifecycle\n * helpers below. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor (immediately after this one) for the producer-side contract.\n * Future async participation sources (e.g. a relationship-projection\n * participation that needs to fetch the source resource's data to\n * disambiguate the projection edge, or a future \"lazy participation\"\n * mode that hydrates an aliased identifier from a remote call) can\n * register through the same `beginParticipationPrefetch` /\n * `endParticipationPrefetch` seam without re-shaping the public\n * `ExecutionLoadingValue` surface.\n \n What a \"participation prefetch\" is. A bounded async unit of work\n * whose purpose is to hydrate the data backing one or more participation\n * refs before the consuming custom view treats those participations as\n * fully resolved. Examples that would qualify (none exist today):\n \n - A relationship-projection participation that needs the source\n * resource's data to pick the right edge — the helper\n * `resolveExecutionParticipations` already accepts a\n * `sourceResourceDataByParticipationRef` parameter, but it is unused at\n * the `ExecutionView` call site because no async source feeds it.\n * - A future \"participation lazy-binding\" mode where an anchor or\n * requirement participation hydrates an aliased identifier from a remote\n * call instead of from URL/ambient scope.\n \n Things that are NOT participation prefetches and must not be registered\n * here (parent invariant #1 plus tier-specific clarifications):\n \n - Consumer-driven graph reads via\n * `useExecution().actions.operation(...).execute()`. Those are pending\n * execute actions and live in the `pendingActions` tier already (and\n * carry their own `operationPathKey` correlation key, which prefetches\n * intentionally do not).\n * - Embedded-layout internal loading. Owned by the embed slot's own\n * contract; the parent anchor explicitly excludes it.\n * - Workflow / multi-step phases authored by the consumer. The aggregator\n * does not accept consumer pushes; a consumer that wants a \"view is\n * warming up\" boolean composes one in its own `useState` from\n * `execution.loading.isParticipationPrefetching(...)` plus its own\n * bookkeeping.\n \n Intent classification. Each entry carries an\n * `ExecutionParticipationPrefetchIntent`:\n \n - `INITIAL` — first-time hydration during shell bootstrap. Renderers\n * typically gate the entire view on this (full-screen skeleton).\n * - `REFRESH` — re-hydration of an already-resolved participation\n * (background revalidation). Renderers typically render through with a\n * subtle indicator. Distinct from `INITIAL` so consumers can tell the\n * two apart without authoring a side-channel boolean.\n \n Aggregation into `isBusy` (parent invariant #5). Prefetch entries\n * count toward `execution.loading.isBusy` exactly like pending execute\n * actions. Per-tier narrowing is reached via the dedicated\n * `isParticipationPrefetching(predicate?)` helper on\n * `ExecutionLoadingValue` (no overlap with `isPending(...)` which stays\n * about execute actions).\n \n Producer registration. Producers call the low-level\n * `beginParticipationPrefetch` / `endParticipationPrefetch` helpers\n * directly on `ExecutionNavigationValue` (mirrors the Slice B\n * `beginPendingAction` / `endPendingAction` pattern). The Slice K hooks\n * (`useExecutionParticipationPrefetch` /\n * `useExecutionParticipationDataPrefetch`) are the framework-shipped\n * wrappers around this seam — they own begin/end pairing, cancellation\n * via `AbortController`, latest-error surfacing, and the optional\n * bridge to `execution.errors.failedActions` (with the dedicated\n * `PARTICIPATION_PREFETCH` scope and `clearFailedActionsForPrefetchKey`\n * auto-prune lifecycle). Custom producers (e.g. a future shell-owned\n * lazy-participation resolver) call the raw helpers directly and MUST\n * pair every begin with a matching end inside a `try`/`finally` so\n * parent invariant #2 (\"settle always clears\") holds for this tier too.\n \n Contract invariants (specialization of the parent anchor's invariants):\n \n 1. Producer-minted ids; same-id re-register is idempotent-by-overwrite.\n * `prefetchRuntimeId` is minted by the producer (in contrast to\n * `actionRuntimeId`, which the shell mints at the `doOperation()` bridge).\n * The shell does not de-duplicate semantically distinct units that happen\n * to share an id — calling `beginParticipationPrefetch` with an existing\n * id REPLACES the prior entry (last-write-wins). Producers MUST mint a\n * fresh id per in-flight unit so the timeline (start time, intent,\n * participation refs) is not silently overwritten by a concurrent unit\n * that happened to recycle the id.\n * 2. Non-empty participation refs. `participationRefs` MUST contain at\n * least one ref. A prefetch that hydrates \"no participation\" has no\n * correlation handle and would be invisible to per-ref UX.\n * `assertExecutionPendingPrefetchShape` rejects empty arrays at the\n * nav helper boundary so dynamic callers (test mocks, deserialized\n * state, future authored hydrators) cannot bypass this.\n \n Not validated against `viewDefinition.participations`. The shape\n * guard intentionally does not check that each ref exists in the\n * resolved participations registry. Doing so would couple this seam\n * to the view-definition layer (the nav helpers don't currently\n * receive the view definition), and would forbid producers from\n * pre-registering prefetches for participations that materialize\n * after the prefetch begins (a plausible pattern for the future\n * \"participation lazy-binding\" mode mentioned above). When the first\n * real producer ships, re-evaluate this trade-off — until then the\n * consequence of a typoed ref is \"the entry will register but no\n * `isParticipationPrefetching((p) => p.participationRefs.includes(...))`\n * predicate will ever match\", which is observable in renderer UX and\n * therefore self-correcting.\n * 3. Resource type required. The `resourceType` field mirrors\n * `ExecutionPendingAction.resourceType` so per-resource UI filtering\n * (e.g. \"is anything tasks-related loading?\") composes uniformly across\n * both tiers.\n * 4. Intent must be a known value. `INITIAL` or `REFRESH`. Unknown\n * intents would silently bypass renderer narrowing UX.\n * `assertExecutionPendingPrefetchShape` enforces this.\n \n Acknowledged rot risk. The `INITIAL`/`REFRESH` vocabulary was\n * pinned ahead of any real producer (Slice H scaffolding). Plausible\n * additions a real producer might want — `BACKGROUND_SYNC` (idle-time\n * revalidation), `LAZY_HYDRATE` (visibility-triggered), `RETRY` (after\n * a failure) — would extend the enum additively. If a producer's\n * needed dimension does not fit the enum at all (e.g. priority,\n * cancellability), revisit `intent`'s shape rather than overload it.\n /\nexport enum ExecutionParticipationPrefetchIntent {\n INITIAL = 'initial',\n REFRESH = 'refresh',\n}\n\nexport interface ExecutionPendingPrefetch {\n /\n Stable id for this in-flight prefetch entry. Minted by the producer\n * (in contrast to `actionRuntimeId`, which the shell mints at the\n * `doOperation()` bridge). Same-id re-register is idempotent-by-overwrite:\n * the shell REPLACES the prior entry rather than de-duplicating two\n * semantically distinct units. Producers MUST mint a fresh id per\n * in-flight unit so the timeline is preserved — see invariant #1 in the\n * sub-anchor JSDoc above.\n /\n prefetchRuntimeId: string;\n /\n Participation refs whose data is being hydrated by this prefetch.\n * Multiple refs are allowed: one fetch can resolve several participations\n * (e.g. a relationship-projection that needs both endpoints).\n \n Must contain at least one ref — a prefetch with no refs cannot be\n * narrowed to per-ref UX and is a contract bug. Enforced at the nav\n * helper boundary by `assertExecutionPendingPrefetchShape`.\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 both tiers of the loading aggregator.\n /\n resourceType: string;\n /\n Whether this is the first-time hydration (`INITIAL`) or a background\n * re-hydration (`REFRESH`). Lets renderers distinguish \"full-screen\n * skeleton\" vs \"subtle indicator\" without a side-channel boolean.\n /\n intent: ExecutionParticipationPrefetchIntent;\n /* `Date.now()` when tracking began. /\n startedAt: number;\n /* Optional human-readable label (\"Loading task graph\"). Opaque to the shell. /\n label?: string;\n}\n\n/\n Belt-and-braces runtime check that an `ExecutionPendingPrefetch` entry\n * is well-formed. Mirrors `assertExecutionDirtyMarkerShape` /\n * `assertExecutionFailedActionShape` — exists for dynamic callers (test\n * mocks, deserialized state, future authored hydrators) where the type\n * may have been widened via `as`/`unknown`.\n \n Throws synchronously when:\n * - `participationRefs` is missing or empty (would render the entry\n * un-narrowable for per-ref UX);\n * - `resourceType` is missing or empty (breaks per-resource UI filtering\n * uniformity with the pending-action tier);\n * - `intent` is not a known `ExecutionParticipationPrefetchIntent` value\n * (would silently bypass renderer narrowing UX).\n /\nexport function assertExecutionPendingPrefetchShape(prefetch: ExecutionPendingPrefetch): void {\n if (!Array.isArray(prefetch.participationRefs) \|\| prefetch.participationRefs.length === 0) {\n throw new Error(\n '[ExecutionView] ExecutionPendingPrefetch must carry at least one participation ref. '\n + 'A prefetch with no refs cannot be narrowed to per-ref UX. '\n + 'If the work is not tied to any participation, do not register it as a participation prefetch.',\n );\n }\n if (typeof prefetch.resourceType !== 'string' \|\| prefetch.resourceType.length === 0) {\n throw new Error(\n '[ExecutionView] ExecutionPendingPrefetch must carry a non-empty `resourceType` '\n + 'so per-resource UI filtering composes uniformly with the pending-action tier.',\n );\n }\n if (\n prefetch.intent !== ExecutionParticipationPrefetchIntent.INITIAL\n && prefetch.intent !== ExecutionParticipationPrefetchIntent.REFRESH\n ) {\n throw new Error(\n '[ExecutionView] ExecutionPendingPrefetch.intent must be one of '\n + '`INITIAL` \| `REFRESH` so renderers can distinguish full-screen '\n + 'vs background hydration UX without a side-channel flag.',\n );\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.loading-aggregation.participation-prefetch /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.loading-aggregation.participation-prefetch.shell-data-hydrator facet:layer:frontend facet:family:execution-view facet:kind:contract facet:audience:framework-author\n \n First concrete producer for the participation-prefetch tier (Slice K).\n \n Sub-anchor of `loading-aggregation.participation-prefetch`. Defines the\n * contract for the framework-shipped producer pair:\n \n - `useExecutionParticipationPrefetch` — generic primitive hook. Owns\n * the begin/end pairing for `ExecutionPendingPrefetch` entries, the\n * `AbortController`-driven cancellation on unmount / re-run, the\n * stable per-mount `prefetchKey`, and the optional bridge of failures\n * into `execution.errors.failedActions` under\n * `ExecutionFailedActionScope.PARTICIPATION_PREFETCH`. Consumers\n * provide an async `run({ signal })` callback that performs the actual\n * work — typical use is 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 plumbing without adopting\n * `doOperation()` semantics they do not need.\n \n - `useExecutionParticipationDataPrefetch` — opinionated wrapper over\n * the primitive that targets the most common case: hydrate a single\n * participation's resource data via `doOperation()` (the canonical\n * READ operation for the resolved resource type). Consumers pass\n * `{ participationRef, intent }` and receive\n * `{ data, isLoading, error, refetch, prefetchKey }`. The wrapper\n * threads `intent`, computes the operation path key from the\n * participation's resource type, supplies the AbortController, and\n * defaults `bridgeFailuresToShellAggregator` per-intent (see invariant\n * #6 below).\n \n Why two layers (decision: layered API). A single opinionated hook\n * would force every future producer (relationship-projection hydrator,\n * lazy-binding resolver, …) to either go through the same READ-shaped\n * `doOperation()` path or drop to the raw nav helpers and duplicate the\n * lifecycle plumbing. A single primitive-only hook would push the\n * \"fetch a participation's data\" boilerplate (operation path key\n * derivation, intent-driven bridge default, single-ref shape) onto every\n * call site of the most common case. Layering the two solves both:\n * primitive owns lifecycle, wrapper owns the canonical fetch shape, and\n * consumers pick whichever level matches their use case. Rejected\n * alternatives: (a) primitive only — common-case boilerplate cost,\n * (b) wrapper only — fetch-mechanism rot risk for future producers,\n * (c) wrapper as method on `useExecution()` — would couple the public\n * `useExecution()` surface to a single fetch shape and obscure the\n * primitive seam.\n \n *Why call `doOperation()` directly, not `actions.operation().execute()`\n (decision: `fetch-doOperation-direct`).** `actions.operation().execute()`\n * registers a `pendingAction` in the execute-action tier, which would\n * double-count the same logical work in `loading.isBusy` (once via the\n * pending action, once via the prefetch entry) and would trigger the\n * shell's failure-handling-contract bridge for both tiers. The wrapper\n * therefore calls `navigation.doOperation(...)` directly inside the\n * `run({ signal })` callback, keeping the prefetch tier semantically\n * separate from the execute-action tier. The action-status snapshot's\n * JSDoc already documents that prefetches don't carry an\n * `operationPathKey` correlation key — this is the producer side of\n * that decision: prefetches are not \"actions\" the framework can retry\n * via `action.retry()`; they are revalidation cycles the consumer\n * controls via `refetch()`. Rejected alternative: route through\n * `execute()` for \"free\" outcome emission and consistency — the\n * double-tier accounting and re-emit risk outweigh the consistency win.\n \n Contract invariants (specialization of the parent sub-anchor's\n * invariants):\n \n 1. Stable `prefetchKey` per logical unit. The hook caches a\n * `prefetchKey` per mount (typically derived from the consumer's\n * keying inputs — resource type + participation ref + intent — or\n * explicitly authored). The same key is reused across consecutive\n * `refetch()` cycles so the shell's\n * `clearFailedActionsForPrefetchKey(key)` verb can drop matching\n * entries on the next successful settle. Distinct from\n * `prefetchRuntimeId`, which rotates on every fire so the parent\n * sub-anchor's invariant #1 (\"producer-minted ids; same-id\n * re-register is idempotent-by-overwrite\") is honored without the\n * consumer having to think about it.\n \n 2. One in-flight unit per hook instance. A new `run()` while a\n * prior one is in flight aborts the prior `AbortController` and\n * `endParticipationPrefetch`es the prior `prefetchRuntimeId` before\n * minting a fresh id and beginning the new unit. Prevents two\n * concurrent units from accumulating in `pendingPrefetches` for the\n * same logical key (which would inflate `isBusy` and confuse\n * per-ref UX). Consumers who legitimately want parallel hydration\n * of distinct participations mount distinct hook instances — one\n * instance per logical unit is the framework rule, mirroring the\n * `useEffect`-per-effect pattern.\n \n 3. Settle always clears (parent invariant #2 specialization). The\n * primitive's `try`/`finally` around the consumer's `run(...)`\n * guarantees `endParticipationPrefetch(prefetchRuntimeId)` runs on\n * success, throw, AND `AbortError`. On unmount, the cleanup branch\n * aborts the controller and ends the prefetch synchronously — the\n * in-flight `doOperation()` rejection arrives later in a no-op\n * settle (the runtime id is already gone, so `endParticipationPrefetch`\n * is a no-op per the public JSDoc).\n \n 4. Stale-while-revalidate for `REFRESH`. When `intent === REFRESH`,\n * the wrapper keeps the prior `data` value visible while the new\n * fetch is in flight (returning `{ data: <stale>, isLoading: true,\n * error }`). When `intent === INITIAL`, `data` is `undefined` until\n * the first successful settle. This split mirrors the parent\n * sub-anchor's intent classification (\"full-screen skeleton\" vs\n * \"subtle indicator\") on the data side.\n \n 5. Latest-error surfacing. The hook always surfaces the latest\n * settle's `error` (or `undefined` on success) in its return value —\n * `error` is reset to `undefined` on every successful settle and is\n * set to the rejection on every failed one. This is the consumer's\n * primary error-display channel; the optional shell-aggregator\n * bridge (next invariant) is for cross-component aggregation and\n * persistent failure history.\n \n 6. Optional shell-aggregator bridge (`bridgeFailuresToShellAggregator`).\n * When `true` (the wrapper's default for `INITIAL`, opt-in for\n * `REFRESH`), failures are also captured via\n * `execution.errors.capture({ scope: PARTICIPATION_PREFETCH,\n * prefetchKey, ... })`, where they participate in the cross-component\n * `failedActions` aggregator and auto-prune on the next successful\n * settle for the same key (via\n * `clearFailedActionsForPrefetchKey(prefetchKey)`, called by the hook).\n * When `false`, failures are surfaced only via the hook's `error`\n * return value — the right choice for \"background revalidation that\n * must not raise a global banner\". The default split (INITIAL=true,\n * REFRESH=false in the wrapper) reflects the typical UX: an initial\n * hydration failure is noteworthy enough to surface globally; a\n * silent revalidation failure usually is not. The primitive defaults\n * to `false` (consumers explicitly opt in) because it has no\n * intent-aware default to lean on.\n \n 7. No retry verb. Refetch is the only retry pattern. The hook\n * exposes `refetch()` (re-runs with the same inputs); the shell does\n * not synthesize a `retry()` analog of the action-status one because\n * prefetches don't carry an `operationPathKey` correlation key (see\n * `ExecutionOperationActionStatus.isPending` JSDoc on the per-tier\n * separation). Consumers wanting \"clear failure + refetch\" call\n * `refetch()` — the bridge auto-prunes the prior failure on\n * successful settle.\n \n 8. `PARTICIPATION_PREFETCH` scope is dedicated. Failures bridged\n * by these hooks land under `ExecutionFailedActionScope.PARTICIPATION_PREFETCH`\n * (NOT `CUSTOM`), which is auto-cleared by\n * `clearFailedActionsForPrefetchKey(prefetchKey)`. This is the\n * fourth scope and exists specifically because the auto-prune\n * lifecycle (per-key on successful settle) is genuinely distinct\n * from the zone-transition-based pruning of `EMBEDDED_CONTENT` /\n * `LOCAL_PANE` and the manual-only model of `CUSTOM`. See the\n * failure-handling-contract anchor for the full scope vocabulary.\n \n Where it composes with the rest of the shell. A consumer view that\n * needs to hydrate a participation's data ahead of an interaction (the\n * Slice K dogfood: chrome banner showing `todoList.name`, inspector\n * node hover prewarming the inspector pane) calls\n * `useExecutionParticipationDataPrefetch({ participationRef, intent })`\n * and threads the returned `{ data, isLoading, error }` into its UI.\n * Per-tier loading questions still flow through the public aggregator:\n * `execution.loading.isParticipationPrefetching((p) =>\n * p.participationRefs.includes(ref))` answers \"is this ref being\n * hydrated?\" from the chrome's perspective without knowing which hook\n * mounted the prefetch.\n \n @wildo_source:part:end saas.frontend.execution-view.loading-aggregation.participation-prefetch.shell-data-hydrator\n /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.dirty-state-contract facet:layer:frontend facet:family:execution-view\n \n Execution-shell dirty-state contract.\n \n The execution shell aggregates authored dirty-state markers — one per\n * distinguishable unsaved surface — so consumers can query a single truthful\n * `execution.dirty` signal before kicking zone transitions (close the embed,\n * replace the embed, switch panes, delegate to the router). The shell does\n * not enforce modals or block transitions; it only publishes the markers.\n * UX decisions (confirm dialog, toast, ignore) live with the consumer.\n \n Publisher / subscriber model (mirrors the loading-aggregation tier):\n \n - Publishers are whoever owns the unsaved state. Today that's either a\n * custom component rendering zone-B content with editable fields, or an\n * adapter wrapping an RMM-backed embedded edit surface (zone A). Publishers\n * call `execution.dirty.mark({ markerId, scope, label?, paneId? })` on\n * first edit and `execution.dirty.clear(markerId)` on save/discard.\n * - Subscribers (the execution view renderer, the shell's transition\n * verbs) read `execution.dirty.markers` / `execution.dirty.isAnyDirty` and\n * author UX accordingly.\n \n Why the shell doesn't query the embedded layout directly: the shell does\n * not hold a reference to the embedded layout's RMM instance — that\n * `ResourceMutationManager` lives inside the `ResourceOperationSurface` and\n * exposes `hasUnsavedChanges` only through `useResourceMutationManager`\n * subscribers, not through a cross-layer observable. Adding a cross-reach\n * would couple the shell to a specific mutation manager implementation. The\n * publish/subscribe contract keeps the boundary clean.\n \n Scopes classify a marker's lifecycle so the shell can safely auto-clean\n * without asking the publisher. Scope is not purely decorative — it drives\n * the auto-cleanup invariant below:\n \n - `EMBEDDED_CONTENT` — the unsaved state belongs to the current embed\n * slot. When the slot empties (close, replace), the marker is auto-cleared\n * because the layout that authored it is gone by definition.\n * - `LOCAL_PANE` — the unsaved state belongs to the currently-open\n * `localPane`. When the pane closes or a different `paneId` opens, the\n * marker is auto-cleared. If the publisher wants the draft to survive\n * pane-id transitions, it should use `CUSTOM` scope.\n * - `CUSTOM` — consumer-owned lifecycle. The shell never auto-clears these.\n * Used for draft state that outlives any single zone transition (e.g.\n * a top-level side panel authored by the custom component itself).\n \n Contract invariants:\n \n 1. Publisher owns mark/clear. The shell never synthesizes markers — no\n * \"auto-mark on first type\" magic. Publishers call `mark()` explicitly,\n * and symmetrically call `clear()` on save or discard.\n * 2. Auto-cleanup at zone boundaries. `closeEmbeddedContent`/\n * `openEmbeddedContent` clear all `EMBEDDED_CONTENT`-scoped markers;\n * `closeLocalPane`/`openLocalPane` clear all `LOCAL_PANE`-scoped markers\n * whose `paneId` no longer matches the active pane. `CUSTOM` markers are\n * untouched.\n * 3. Stable marker ids. `markerId` must be stable across re-renders of\n * the same publisher — re-marking an existing id is idempotent (replaces\n * the entry, does not produce a duplicate).\n * 4. Shell is informative, not restrictive. Transition verbs\n * (`closeEmbeddedContent`, `openEmbeddedContent`, `delegateToParent`) do\n * not block on dirty state. Consumers read `isAnyDirty` and author\n * their own confirm flow before calling the transition. Making the shell\n * block would force a modal UX the framework cannot reasonably author\n * centrally.\n * 5. Per-runtime-instance scope. The aggregator lives on\n * `ExecutionRuntimeState`, not globally. Two execution views mounted in\n * the same app do not share dirty markers.\n * 6. Orthogonal to other shell tiers. Dirty state is not a navigation\n * zone (three-zone contract) nor operational telemetry (loading\n * aggregation). It is its own shell tier with its own invariants.\n /\nexport enum ExecutionDirtyMarkerScope {\n EMBEDDED_CONTENT = 'embedded-content',\n LOCAL_PANE = 'local-pane',\n CUSTOM = 'custom',\n}\n\n/\n Common shape for every dirty marker, regardless of scope.\n \n Intentionally not exported on its own — consumers use the\n * `ExecutionDirtyMarker` discriminated union below so the type system\n * enforces \"LOCAL_PANE markers carry a `paneId`\" without requiring\n * defensive `!== undefined` checks at every read site.\n /\ninterface ExecutionDirtyMarkerBase {\n /\n Stable publisher-authored id. Re-marking the same id is idempotent —\n * the entry is replaced, not duplicated. Typically derived from a\n * resource identity (e.g. `embed:tasks:task-1:UPDATE`) or a pane-scoped\n * key (e.g. `pane:todo-inspector:draft`).\n /\n markerId: string;\n /\n Optional human-readable reason (\"Unsaved task changes\", \"Draft\n * description\"). Consumers may surface it in confirm dialogs or ambient\n * badges; the shell treats it as opaque metadata.\n /\n label?: string;\n /* `Date.now()` when the marker was first registered. /\n markedAt: number;\n}\n\n/\n Discriminated union of dirty markers.\n \n The discriminant `scope` makes \"`paneId` is required for `LOCAL_PANE`\n * markers, absent on the others\" a compile-time invariant — there is no\n * `paneId?` escape hatch on the non-pane variants. Combined with the\n * runtime assertion `assertExecutionDirtyMarkerShape`, dynamic callers\n * (test mocks, deserialized state, authored dictionaries) cannot collapse\n * the variants either.\n /\nexport type ExecutionDirtyMarker =\n \| (ExecutionDirtyMarkerBase & { scope: ExecutionDirtyMarkerScope.EMBEDDED_CONTENT })\n \| (ExecutionDirtyMarkerBase & { scope: ExecutionDirtyMarkerScope.LOCAL_PANE; paneId: string })\n \| (ExecutionDirtyMarkerBase & { scope: ExecutionDirtyMarkerScope.CUSTOM });\n\n/\n Belt-and-braces runtime check that a `ExecutionDirtyMarker` matches its\n * discriminant invariants. The type layer already enforces these for\n * statically-shaped callers; this assertion exists for dynamic callers\n * (test mocks, deserialized payloads, authored dictionaries) where the\n * type may have been widened via `as`/`unknown`.\n \n Throws synchronously when a `LOCAL_PANE` marker is registered without a\n * `paneId` — the only invariant that cannot be expressed any other way.\n /\nexport function assertExecutionDirtyMarkerShape(marker: ExecutionDirtyMarker): void {\n if (marker.scope === ExecutionDirtyMarkerScope.LOCAL_PANE) {\n const candidate = marker as { paneId?: unknown };\n if (typeof candidate.paneId !== 'string' \|\| candidate.paneId.length === 0) {\n throw new Error(\n '[ExecutionView] LOCAL_PANE-scoped dirty marker must carry a non-empty `paneId` '\n + 'so the shell can auto-clear it on pane transitions. '\n + 'Use scope=CUSTOM for markers that should outlive any single pane.',\n );\n }\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.dirty-state-contract /\n\n/\n Contract for content that an execution view is allowed to embed inside its\n * own shell. Today only `NavigationContent.RESOURCE_OPERATION` is embeddable,\n * so consumers cannot stuff arbitrary navigation content into the slot.\n \n Naming note: this is the `Embeddable` contract (what can* be embedded),\n * not an `Embedded` state. Once the runtime actually holds an instance, it\n lives in `ExecutionEmbeddedContentState`.\n /\nexport type ExecutionEmbeddableContent = Extract<\n NavigationContent,\n { contentType: NavigationContentType.RESOURCE_OPERATION }\n>;\n\n/\n State of the execution view's single embedded-content slot.\n \n The shell guarantees only one embedded surface is mounted at a time.\n * `navigationInitiator` preserves the same provenance\n * (`sourceZone`, `launcher`, `sourceOperation`, `sourceRelationship`) a\n * router-delegated surface would receive, so embedded and routed surfaces\n * behave identically downstream.\n /\nexport interface ExecutionEmbeddedContentState {\n content: ExecutionEmbeddableContent;\n navigationInitiator?: NavigationInitiatorContext;\n}\n\n/\n @wildo_source:part:start saas.frontend.execution-view.three-zone-contract facet:layer:frontend facet:family:execution-view\n \n Three-zone contract for execution-view child intent.\n \n An execution view has exactly three zones where frontend-only state and\n * child navigation intent can live. Each zone has a *distinct semantic\n purpose*, and a consumer must pick exactly one per intent. The zones are\n not stylistic variants — collapsing any two into each other destroys the\n * execution shell's ability to reason about what it owns vs what the router\n * owns.\n \n \| Zone \| Lives in \| Payload \| Owner \| Purpose \|\n * \|---\|---\|---\|---\|---\|\n * \| A. `embeddedContent` \| `ExecutionRuntimeState` \| `ExecutionEmbeddableContent` (`NavigationContent.RESOURCE_OPERATION` only) \| Execution shell (`ExecutionView`) \| Mount a downstream resource-operation surface inside the shell instead of delegating to the router (the \"embed\" seam) \|\n * \| B. `localPane` \| `ExecutionRuntimeState` \| `{ paneId: string; payload?: unknown }` — renderer-opaque data, never `NavigationContent` \| Custom component (the view's own `viewComponent`) \| Ephemeral shell state — inspectors, drawers, selection metadata. Not navigation content. \|\n * \| C. `delegateToParent` \| App router (parent navigation stack) \| Any `NavigationContent` \| App router \| Yield control to the router. The execution view loses the screen for this intent. \|\n \n Invariants that make this a contract, not three coincidental state fields:\n \n 1. Mutual exclusivity by purpose. A single intent picks exactly one\n * zone. \"Open a read surface next to the current view\" is zone A. \"Remember\n * which node the user clicked\" is zone B. \"Send the user back to the home\n * page\" is zone C.\n * 2. No content-type confusion. Zone A is resource-operation-only (typed\n * as `ExecutionEmbeddableContent`). Zone B's `payload` is not\n * `NavigationContent` — if a consumer finds itself tempted to put\n * `{ contentType: NavigationContentType.RESOURCE_OPERATION, ... }` into a\n * pane payload, that intent belongs in zone A. Zone C is the only zone\n * that accepts arbitrary `NavigationContent`, and it hands it off.\n * 3. Shell owns the shell. Zones A and B both live in\n * `ExecutionRuntimeState`, but the rendering responsibility differs:\n * `ExecutionView` renders zone A (including the close affordance);\n * the custom component renders zone B itself using the pane state it\n * authored. Consumers never reinvent the zone A shell.\n * 4. One slot per zone. Zones A and B are single-slot. Opening a new\n * embed replaces the previous one; opening a new pane replaces the\n * previous one. If a surface truly needs \"many open inspectors at once\",\n * that's renderer state inside a single pane payload, not multiple panes.\n * 5. Provenance parity. Zones A and C both thread\n * `NavigationInitiatorContext` (`sourceZone`, `launcher`, `sourceOperation`,\n * `sourceRelationship`) — see the embedding-principle anchor at\n * `saas.frontend.execution-view.navigation-handling-and-embedding`. An\n * embedded read surface behaves indistinguishably from a routed read\n * surface of the same resource.\n * 6. Defensive validation at the zone boundary. The runtime fails fast\n * when a caller misroutes an intent — `openLocalPane` rejects payloads\n * shaped like `ExecutionEmbeddableContent` and `openEmbeddedContent`\n * rejects non-`RESOURCE_OPERATION` content — see\n * `assertExecutionLocalPanePayloadIsNotEmbeddableContent` and\n * `assertExecutionEmbeddableContent` below. These assertions are\n * belt-and-braces over the type layer; they exist so dynamic callers (test\n * mocks, deserialized state, authored dictionaries) cannot silently collapse\n * the zones.\n /\nexport interface ExecutionRuntimeState {\n embeddedContent: ExecutionEmbeddedContentState \| null;\n localPane: ExecutionLocalPaneState \| null;\n /\n Pending shell-tracked actions keyed by `actionRuntimeId`. See the\n * loading-aggregation anchor above — this is operational telemetry, not\n * a navigation zone.\n /\n pendingActions: Record<string, ExecutionPendingAction>;\n /\n In-flight participation prefetch entries keyed by `prefetchRuntimeId`.\n * See the `loading-aggregation.participation-prefetch` sub-anchor above.\n * Today this slot is wired but not populated — no in-tree producer\n * registers prefetches because participation resolution is fully\n * synchronous. The slot exists so that the day a real async producer\n * materializes, the public `ExecutionLoadingValue` can expose\n * `participationPrefetchActions` / `isAnyParticipationPrefetching` /\n * `isParticipationPrefetching(...)` without re-shaping the API.\n /\n participationPrefetchActions: Record<string, ExecutionPendingPrefetch>;\n /\n Authored dirty-state markers keyed by `markerId`. See the\n * dirty-state-contract anchor above — scope-based auto-cleanup applies at\n * zone transitions but the shell never synthesizes or forces-blocks on\n * these markers.\n /\n dirtyMarkers: Record<string, ExecutionDirtyMarker>;\n /\n Captured failed-action entries keyed by `failureRuntimeId`. See the\n * failure-handling-contract anchor — scope-based auto-cleanup mirrors\n * `dirtyMarkers`; the shell captures and bridges, but does not retry or\n * suppress consumer error UX.\n /\n failedActions: Record<string, ExecutionFailedAction>;\n}\n\n/\n Validates that a `localPane` payload is not accidentally an\n * `ExecutionEmbeddableContent`. See the three-zone contract above: zone B\n * payloads are renderer-opaque data, not navigation content.\n \n Throws with a message pointing the caller to\n * `openEmbeddedContent`/`execution.actions.operation(...).embed()` when a\n * misroute is detected. No-op for normal renderer payloads.\n /\nexport function assertExecutionLocalPanePayloadIsNotEmbeddableContent(\n payload: unknown,\n): void {\n if (payload === null \|\| typeof payload !== 'object') {\n return;\n }\n const candidate = payload as { contentType?: unknown };\n if (candidate.contentType === NavigationContentType.RESOURCE_OPERATION) {\n throw new Error(\n '[ExecutionView] localPane payload must not be an ExecutionEmbeddableContent. '\n + 'Resource-operation content belongs in the embedded-content slot. '\n + 'Use openEmbeddedContent() or execution.actions.operation(...).embed() instead.',\n );\n }\n}\n\n/\n Validates that a value claimed to be `ExecutionEmbeddableContent` truly is\n * one. Today that means `contentType === NavigationContent.RESOURCE_OPERATION`;\n * see the three-zone contract above.\n \n The type layer already enforces this, so this assertion is belt-and-braces\n * for dynamic callers (test mocks, deserialized content, authored action\n * dictionaries) where the type may have been widened via `as`/`unknown`.\n /\nexport function assertExecutionEmbeddableContent(\n content: ExecutionEmbeddableContent,\n): void {\n if (!content \|\| content.contentType !== NavigationContentType.RESOURCE_OPERATION) {\n throw new Error(\n '[ExecutionView] embeddedContent.content must be a '\n + 'NavigationContent.RESOURCE_OPERATION. Non-resource-operation '\n + 'navigation content must go through delegateToParent() (the app router), '\n + 'not the execution shell\\'s embed slot.',\n );\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.three-zone-contract /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.outcome-emission-contract facet:layer:frontend facet:family:execution-view\n \n Execution-shell operation-outcome emission contract.\n \n The execution shell is a canonical producer on the app-level\n * `FrontendEvents` bus (`EventBus`) for every successful `.execute()` call.\n * It does not introduce a parallel execution-scoped outcome bus — the\n * framework already has one (`RESOURCE_OPERATION_EXECUTED` + `RESOURCE_REFRESH`\n * consumed by `NotificationContext`, `WebSocketEventBridge`, `useListInvalidation`,\n * and `resourceRefreshEvent` subscribers). A second bus would double-plumb the\n * same signal and force every subscriber to learn two APIs.\n \n Emission site: `useExecution().execute()` → `emitResourceOperationOutcome`\n * (see `execution-outcome-emission.utils.ts`). Payloads mirror\n * `useResourceOperationActions.handleExecuteOperation` exactly, so\n * execution-shell-driven operations are indistinguishable from\n * resource-layout-driven ones on the wire.\n \n Contract invariants:\n \n 1. Single canonical bus. No new public surface on `useExecution()` for\n * outcomes. Consumers subscribe via `useEventBus` / `useEventSubscription`\n * just like for any other operation producer. An execution-local bus\n * would hide signals from app-global subscribers (toast policy, WS bridge,\n * analytics) that must see every operation.\n \n 2. Emit `RESOURCE_OPERATION_EXECUTED` unconditionally on success.\n * Every resolved `.execute()` is a canonical operation-outcome event.\n * `NotificationContext` does not subscribe to this event (it is under\n * `NEED_REFRESH`, not `NOTIFY_USER`), so emitting for READ / LIST / custom\n * operations never produces unintended toasts. User-visible toasts travel\n * on `NOTIFY_RESOURCE_`, which the backend drives.\n \n * 3. Emit `RESOURCE_REFRESH` only for real mutations + WS disconnected.\n * Gate: `shouldEmitResourceRefreshAfterDirectOperation(operation)\n * && !isWebSocketConnected`. When the WS bridge is up it pushes refreshes\n * natively; emitting from here too would double-fire every listener.\n * Non-mutating operations (READ / LIST / custom) never trigger list\n * refreshes — refresh is an authored consequence of data change, not a\n * signal of \"some operation happened\".\n \n 4. Silent on failure. Rejected promises do not emit an outcome\n * event — subscribers use `.catch()` or the `NOTIFY_RESOURCE_ERROR`\n * channel for failure UX. Emitting a failure variant here would force a\n * specific error-UX on every consumer, which mirrors the dirty-state\n * contract's \"informative, not restrictive\" stance.\n \n 5. Emission before settle. Emit fires inside the `try` block, before\n * the `finally` clause calls `endPendingAction`. Subscribers that check\n * `execution.loading.isBusy` during their handler therefore still see\n * `true` — this matches `runPostOperationEffects` in\n * `useResourceOperationActions`, which runs before its own\n * `isExecuting = false` cleanup.\n \n 6. Payload parity with canonical. Shape, field names, and optional\n * discriminator threading must match the emissions from\n * `useResourceOperationActions` / `ResourceLayout_Update`. Any drift is a\n * bug — downstream subscribers rely on a single uniform payload across\n * producers.\n /\n/* @wildo_source:part:end saas.frontend.execution-view.outcome-emission-contract /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.failure-handling-contract facet:layer:frontend facet:family:execution-view\n \n Execution-shell failure-handling contract.\n \n The execution shell aggregates failed actions as a symmetric counterpart\n * to the loading-aggregation tier (Slice B) and the outcome-emission tier\n * (Slice D). Every `useExecution().execute()` rejection — and any\n * consumer-authored failure (render-adjacent caught exceptions, manual\n * `errors.capture(...)` calls) — is captured into a single shell-owned bag of\n * `ExecutionFailedAction` entries. Consumers read `execution.errors` to drive\n * inline retry UX without rebuilding ad hoc per-component error state.\n \n What this tier owns (and why):\n \n - Captured failures. The shell's `execute()` catch path captures the\n * raw error alongside the originating action's identity (`actionRuntimeId`,\n * `operationPathKey`, `resourceType`, `operationId`) so consumers can render\n * targeted \"Retry CREATE on Task\" affordances instead of generic banners.\n * - Conditional bridge to the canonical bus. Most rejections come from\n * the HTTP layer, which has already been processed by\n * `errorManagement.handleHttpError(...)` (built a `WildoError_Frontend`,\n * applied the configured behavior, conditionally emitted `ERROR_OCCURED`\n * based on the per-status policy and the request's `silent` flag). The\n * shell detects this via the `error.wildoError` marker that\n * `wildo-http-client` attaches and *defers to that upstream processing\n instead of re-emitting*. Synchronous throws and non-axios rejections\n (no `wildoError`) are bridged once via `errorManagement.handleError(...)`\n * so global subscribers (`GlobalErrorHandler`, `NotificationContext` for\n * `NOTIFY_RESOURCE_ERROR`) still see them.\n \n Note: HTTP rejections marked by `wildo-http-client` may not have\n * actually emitted to the bus (silent requests, `emitEvent: false` in\n * the per-status matrix). The shell honors that consumer-requested\n * silence rather than re-emitting on its own — see\n * `markedByHttpClient` vs. `bridgedByExecutionShell` on\n * `ExecutionFailedAction` for the truthful per-entry provenance.\n \n What this tier intentionally does not own:\n \n - A second error bus. The framework already has `ERROR_OCCURED`,\n * `NOTIFY_RESOURCE_ERROR`, and `NOTIFY_CUSTOM_ERROR` on the canonical bus.\n * Adding an execution-scoped error stream would force consumers to learn\n * two APIs and would hide failures from app-global subscribers.\n * - A new render-error boundary. Render crashes inside the execution view\n * surface through the existing application `ErrorBoundary` (see\n * `core/errors/ErrorBoundary.tsx`) which already emits `ERROR_OCCURED` and\n * renders the canonical `AppLayout_ErrorBoundary` fallback. The execution\n * shell wraps its content in that boundary instead of reinventing one.\n * - Built-in retry orchestration. The shell exposes failed-action\n * metadata; the consumer owns the retry call site. A built-in\n * `retry()` would have to re-author the original action verb (which the\n * shell does not retain), and would obscure idempotency / context-refresh\n * decisions that only the consumer can make. Consumers retry by re-invoking\n * the same action verb after `clear(failureRuntimeId)`.\n \n Scopes classify a failure's lifecycle so the shell can safely\n * auto-clean without asking the publisher. They mirror\n * `ExecutionDirtyMarkerScope` exactly to keep the mental model uniform:\n \n - `EMBEDDED_CONTENT` — the failure belongs to the current embed slot.\n * Auto-cleared on `openEmbeddedContent` / `closeEmbeddedContent`.\n * - `LOCAL_PANE` — the failure belongs to the currently-open `localPane`.\n * Auto-cleared on pane close, or when a different `paneId` opens.\n * - `CUSTOM` — consumer-owned lifecycle. Default for all `execute()`-captured\n * failures (the shell does not know which zone the consumer's action verb\n * belongs to). The shell never auto-clears these.\n * - `PARTICIPATION_PREFETCH` — the failure originated from the participation-\n * prefetch tier (Slice K's first producer). Auto-cleared on the next\n * successful prefetch with the same `prefetchKey`. The 4th scope was\n * added rather than overloading `CUSTOM` because the auto-prune lifecycle\n * is genuinely distinct: prefetch failures live in a \"stale-data\n * indicator\" UX where the next successful refetch implicitly resolves\n * them, whereas `CUSTOM` failures persist until consumer-cleared. Carries\n * a `prefetchKey: string` discriminant payload — the consumer-authored\n * stable identity (NOT the per-run `prefetchRuntimeId` which rotates per\n * in-flight unit) — so the shell's `clearFailedActionsForPrefetchKey(key)`\n * verb can target the right entries on settle. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the producer-side contract this scope serves.\n \n Contract invariants:\n \n 1. Capture always, bridge at most once. Every `execute()` rejection\n * produces exactly one `ExecutionFailedAction` entry. The shell calls\n * `errorManagement.handleError(...)` only when no upstream layer has\n * already processed the error (detected via the `error.wildoError`\n * marker that `wildo-http-client.handleHttpError` attaches). The shell\n * never re-bridges an HTTP-marked error even if that upstream processing\n * suppressed emission via `silent` or `emitEvent: false` — honoring\n * consumer-requested silence is part of the contract. Each captured\n * entry records `markedByHttpClient` and `bridgedByExecutionShell`\n * truthfully so consumers can reason about provenance per entry.\n * 2. Re-throw after capture. `execute()` re-throws the original error\n * after capturing + (conditionally) bridging, so consumer `.catch()`\n * handlers and `await`-style call sites still observe the rejection.\n * The shell augments the canonical contract; it does not swallow it.\n * 3. *Capture happens before pending clears, but the renderer sees both\n in the same React commit.** Mechanically the `catch` block runs\n * `captureFailedAction(...)` then re-throws, after which the `finally`\n * block runs `endPendingAction(...)`. React batches the resulting\n * `setState` updates inside the same microtask, so consumers render\n * with `pending=false` and `errored=true` simultaneously — there is no\n * intermediate \"still-pending-but-already-failed\" state visible to a\n * rendered component. (Subscribers that observe state through refs or\n * custom selectors during the catch microtask may briefly see both\n * flags true; that path is shell-internal plumbing only.)\n * 4. Auto-cleanup at zone boundaries (and at prefetch settle).\n * `openEmbeddedContent`/`closeEmbeddedContent` clear all\n * `EMBEDDED_CONTENT`-scoped failures; `openLocalPane`/`closeLocalPane`\n * clear all `LOCAL_PANE`-scoped failures whose `paneId` no longer matches\n * the active pane; `PARTICIPATION_PREFETCH`-scoped failures are cleared\n * by `clearFailedActionsForPrefetchKey(prefetchKey)` (called by the\n * Slice K hooks on the next successful settle of the same prefetch\n * unit). `CUSTOM` failures are untouched by every auto-cleanup path —\n * the shell never collects them on its own. This mirrors the\n * dirty-state contract auto-cleanup so consumers reason about all tiers\n * with the same scope vocabulary, just with one extra trigger\n * (per-`prefetchKey` settle) for the prefetch lifecycle.\n * 5. Stable failure ids. `failureRuntimeId` is generated by the shell at\n * capture time. Re-capturing an `originatingActionRuntimeId` (e.g.\n * consumer retried, action failed again) produces a new failure entry\n * rather than mutating the prior one — the timeline is preserved so\n * consumers can render attempt count or last-attempt-time UX.\n * 6. Per-runtime-instance scope. The aggregator lives on\n * `ExecutionRuntimeState`, not globally. Two execution views mounted in\n * the same app do not share failed-action state.\n * 7. Shell is informative, not restrictive. Capturing a failure does\n * not alter execution lifecycle, block transitions, or veto subsequent\n * `execute()` calls. UX (banner vs. toast vs. inline retry button) is\n * owned by the consumer.\n /\nexport enum ExecutionFailedActionScope {\n EMBEDDED_CONTENT = 'embedded-content',\n LOCAL_PANE = 'local-pane',\n CUSTOM = 'custom',\n /\n Slice K — failure originated from the participation-prefetch tier\n * (the shell-data-hydrator producer hooks). Carries a discriminant\n * `prefetchKey: string` so the shell can auto-prune on the next\n * successful prefetch with the same key. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the producer-side contract.\n /\n PARTICIPATION_PREFETCH = 'participation-prefetch',\n}\n\n/\n Common shape for every captured failure entry, regardless of scope.\n \n Intentionally not exported on its own — consumers use the\n * `ExecutionFailedAction` discriminated union below so the type system\n * enforces \"LOCAL_PANE entries carry a `paneId`\" without requiring\n * defensive `!== undefined` checks at every read site.\n /\ninterface ExecutionFailedActionBase {\n /\n Stable id for the failed action entry. Generated by the shell at capture\n * time, distinct from the originating `actionRuntimeId` so re-attempts\n * produce fresh entries.\n /\n failureRuntimeId: string;\n /\n Mirrors `ExecutionPendingAction.actionRuntimeId` for `execute()`-captured\n * failures. Absent for consumer-authored captures via\n * `execution.errors.capture(...)` that did not originate from the shell's\n * `execute()` bridge.\n \n Informational only — no first-class selector today. The shell\n * does not expose a `errors.findByOriginatingAction(actionRuntimeId)`\n * helper because no in-tree consumer needs it yet (the dogfood derives\n * `latestFailure` purely from `capturedAt`). Consumers that want to\n * correlate a failure entry to a specific pending action can do so via\n * `errors.isErrored((entry) => entry.originatingActionRuntimeId === id)`\n * or by filtering `errors.failedActions` directly. A dedicated selector\n * will be added the first time per-button retry UX dogfoods this field.\n /\n originatingActionRuntimeId?: string;\n /* Canonical operation path key, when available. /\n operationPathKey?: string;\n /* Resource the failed action targeted, when available. /\n resourceType?: string;\n /* Operation identifier the failed action invoked, when available. /\n operationId?: string;\n /* `Date.now()` when capture happened. /\n capturedAt: number;\n /\n Mirrors the originating pending action's `startedAt` so consumers can\n * render duration-aware UX. Absent for consumer-authored captures.\n /\n startedAt?: number;\n /\n Raw error reference. Consumers may inspect `error.wildoError` (set by\n * `wildo-http-client`) for typed metadata, but the shell does not normalize\n * the shape — keeping the original preserves whatever upstream provenance\n * the rejected value carried (stack traces for `Error` instances, typed\n * payloads for HTTP-marked errors, primitive values when the call site\n * threw something exotic).\n /\n error: unknown;\n /\n Optional human-readable label (\"Could not load todo graph\"). Consumers\n * may render it inline; the shell treats it as opaque metadata.\n /\n label?: string;\n /\n `true` when the originating error carries the `wildoError` marker\n * stamped by `wildo-http-client.handleHttpError`. That marker means an\n * upstream layer already classified the error and applied its configured\n * behavior (potentially emitting `ERROR_OCCURED`, potentially staying\n * silent if the request opted in or the per-status policy disabled\n * emission). The shell defers to that processing instead of re-bridging.\n /\n markedByHttpClient: boolean;\n /\n `true` when this capture site invoked `errorManagement.handleError(...)`\n * itself. The shell sets this:\n * - `true` for `execute()` rejections without `markedByHttpClient`.\n * - `false` for `execute()` rejections WITH `markedByHttpClient` (deferred\n * to upstream).\n * - `true`/`false` per `bridgeToCanonicalBus` opt-out for\n * `execution.errors.capture(...)` calls.\n \n Note: `bridgedByExecutionShell === true` does not strictly guarantee\n * an `ERROR_OCCURED` event was emitted — `errorManagement.handleError`\n * may itself drop emission for silent contexts. Consumers needing the\n * ground truth of \"was a canonical event emitted\" should subscribe to\n * `FrontendEvents.ERROR_OCCURED` directly rather than infer it from this\n * flag.\n /\n bridgedByExecutionShell: boolean;\n}\n\n/\n Discriminated union of captured failure entries.\n \n The discriminant `scope` makes \"`paneId` is required for `LOCAL_PANE`\n * entries, absent on the others\" a compile-time invariant. Combined with\n * the runtime assertion `assertExecutionFailedActionShape`, dynamic\n * callers (test mocks, deserialized state, authored dictionaries) cannot\n * collapse the variants either.\n /\nexport type ExecutionFailedAction =\n \| (ExecutionFailedActionBase & { scope: ExecutionFailedActionScope.EMBEDDED_CONTENT })\n \| (ExecutionFailedActionBase & { scope: ExecutionFailedActionScope.LOCAL_PANE; paneId: string })\n \| (ExecutionFailedActionBase & { scope: ExecutionFailedActionScope.CUSTOM })\n \| (ExecutionFailedActionBase & {\n scope: ExecutionFailedActionScope.PARTICIPATION_PREFETCH;\n /\n Stable consumer-authored identity for the prefetch unit. Distinct\n * from the per-run `prefetchRuntimeId` (which rotates on every fire);\n * the same `prefetchKey` is reused across consecutive settle cycles\n * of the same logical prefetch so the shell's\n * `clearFailedActionsForPrefetchKey(key)` verb can drop matching\n * entries on the next successful settle.\n /\n prefetchKey: string;\n });\n\n/\n Belt-and-braces runtime check that an `ExecutionFailedAction` matches\n * its discriminant invariants. The type layer already enforces these for\n * statically-shaped callers; this assertion exists for dynamic callers\n * (test mocks, deserialized payloads, authored dictionaries) where the\n * type may have been widened via `as`/`unknown`.\n \n Throws synchronously when a `LOCAL_PANE` entry is captured without a\n * `paneId` — the only invariant that cannot be expressed any other way.\n /\nexport function assertExecutionFailedActionShape(failedAction: ExecutionFailedAction): void {\n if (failedAction.scope === ExecutionFailedActionScope.LOCAL_PANE) {\n const candidate = failedAction as { paneId?: unknown };\n if (typeof candidate.paneId !== 'string' \|\| candidate.paneId.length === 0) {\n throw new Error(\n '[ExecutionView] LOCAL_PANE-scoped failed action must carry a non-empty `paneId` '\n + 'so the shell can auto-clear it on pane transitions. '\n + 'Use scope=CUSTOM for failures that should outlive any single pane.',\n );\n }\n }\n if (failedAction.scope === ExecutionFailedActionScope.PARTICIPATION_PREFETCH) {\n const candidate = failedAction as { prefetchKey?: unknown };\n if (typeof candidate.prefetchKey !== 'string' \|\| candidate.prefetchKey.length === 0) {\n throw new Error(\n '[ExecutionView] PARTICIPATION_PREFETCH-scoped failed action must carry a '\n + 'non-empty `prefetchKey` so the shell can auto-clear it on the next '\n + 'successful prefetch settle for the same key. '\n + 'Use scope=CUSTOM for failures that should outlive any single prefetch unit.',\n );\n }\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.failure-handling-contract /\n\n/\n Minimal execution navigation contract for the first routed host slice.\n \n The execution runtime deliberately reuses the existing navigation controller\n * instead of introducing a second navigation stack owner.\n /\n/\n Navigation primitives exposed to the execution shell and the unified\n * `useExecution()` API. These are the two handling modes plus the local-pane\n * seam — intentionally small so the shell owns a single decision point per\n * action verb.\n /\nexport interface ExecutionNavigationValue {\n /* Yield the target navigation content to the app router (\"parent\" stack). /\n delegateToParent: (options: {\n content: NavigationContent;\n urlPath?: string;\n contextResourceIdentifiers?: Record<string, string>;\n relationshipTransition?: NavigateOptions['relationshipTransition'];\n initiator?: Omit<NavigationInitiatorContext, 'sourceZone'>;\n }) => void;\n /* Mount the embeddable content inside the execution shell's single slot. /\n openEmbeddedContent: (embeddedContent: ExecutionEmbeddedContentState) => void;\n /* Clear the execution shell's embedded-content slot. /\n closeEmbeddedContent: () => void;\n openLocalPane: (paneId: string, payload?: unknown) => void;\n closeLocalPane: () => void;\n /\n Register a shell-tracked pending action. Internal plumbing — app code\n * must not call this directly; `useExecution()`'s `execute()` verb wires\n * it from the `doOperation()` bridge. See the loading-aggregation anchor.\n /\n beginPendingAction: (action: ExecutionPendingAction) => void;\n /* Clear a shell-tracked pending action by `actionRuntimeId`. /\n endPendingAction: (actionRuntimeId: string) => void;\n /\n Register a shell-tracked participation prefetch. Internal plumbing\n * intended for future framework-owned async participation resolvers;\n * no in-tree producer calls it today because participation resolution\n * is fully synchronous. See the\n * `loading-aggregation.participation-prefetch` sub-anchor for the\n * contract (intent classification, settle-always-clears, non-empty\n * `participationRefs`, …) — the runtime guard\n * `assertExecutionPendingPrefetchShape` runs at this seam so dynamic\n * callers cannot bypass shape invariants.\n /\n beginParticipationPrefetch: (prefetch: ExecutionPendingPrefetch) => void;\n /\n Clear a shell-tracked participation prefetch by `prefetchRuntimeId`.\n * No-op when the id is unknown (mirrors `endPendingAction`).\n /\n endParticipationPrefetch: (prefetchRuntimeId: string) => void;\n /\n Register or update a dirty-state marker. Re-marking the same `markerId`\n * is idempotent (replaces the entry). See the dirty-state-contract anchor.\n /\n markDirty: (marker: ExecutionDirtyMarker) => void;\n /* Clear a dirty-state marker by `markerId`. No-op if the id is unknown. /\n clearDirty: (markerId: string) => void;\n /\n Drop every registered dirty marker. Mirrors `clearAllFailedActions` so\n * the shell's two consumer-authored aggregator tiers (dirty / errors)\n * expose the same bulk-clear primitive. Typical use: a top-level \"Discard\n * all unsaved edits\" affordance in the consumer view.\n /\n clearAllDirty: () => void;\n /\n Capture a failed action entry (shell-internal plumbing for `execute()`'s\n * catch path, or consumer-driven via `execution.errors.capture`). See the\n * failure-handling-contract anchor.\n /\n captureFailedAction: (failedAction: ExecutionFailedAction) => void;\n /* Clear a captured failure by `failureRuntimeId`. No-op if unknown. /\n clearFailedAction: (failureRuntimeId: string) => void;\n /* Clear every captured failure. /\n clearAllFailedActions: () => void;\n /\n Drop every `PARTICIPATION_PREFETCH`-scoped failure whose `prefetchKey`\n * matches `prefetchKey`. Internal plumbing called by the Slice K\n * producer hooks (`useExecutionParticipationPrefetch` /\n * `useExecutionParticipationDataPrefetch`) on a successful settle so a\n * stale failure indicator from a previous attempt clears the moment the\n * next attempt succeeds — no consumer cleanup required. Other scopes\n * are untouched. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the full producer contract and\n * `pruneFailedActionsForPrefetchSettlement` in\n * `execution-failure-handling.utils.ts` for the prune semantics.\n /\n clearFailedActionsForPrefetchKey: (prefetchKey: string) => void;\n}\n\n/\n Minimal runtime context carried by the framework-owned execution host.\n \n This establishes the first real execution runtime seam:\n * - view definition resolution\n * - scope/context propagation\n * - stable runtime-instance identity\n * - conservative anchor resolution from explicit declared bindings\n * - minimal framework-owned local pane state\n * - reuse of the shared `doOperation()` abstraction\n * - delegation to the existing navigation controller\n /\nexport interface ExecutionRuntimeContextValue {\n viewDefinition: ExecutionViewDefinition;\n contextResourceIdentifiers?: Record<string, string>;\n runtimeInstanceId: string;\n navigationZone: NavigationZone;\n doOperation: ResourceRegistryContextType['doOperation'];\n navigation: ExecutionNavigationValue;\n anchor: ExecutionAnchor \| null;\n participations: Record<string, ResolvedExecutionParticipation>;\n runtimeState: ExecutionRuntimeState;\n}\n\nexport interface ExecutionRuntimeProviderProps {\n children: React.ReactNode;\n viewDefinition: ExecutionViewDefinition;\n contextResourceIdentifiers?: Record<string, string>;\n runtimeInstanceId: string;\n navigationZone: NavigationZone;\n doOperation: ResourceRegistryContextType['doOperation'];\n navigation: ExecutionNavigationValue;\n anchor: ExecutionAnchor \| null;\n participations: Record<string, ResolvedExecutionParticipation>;\n runtimeState: ExecutionRuntimeState;\n}\n\nexport const ExecutionRuntimeContext = createContext<ExecutionRuntimeContextValue \| undefined>(undefined);\n\n/\n Asserts that a resolved `ExecutionRuntimeContext` value is present.\n \n Intentionally written as a non-hook assertion so consumers can inline\n * `useContext(ExecutionRuntimeContext)` at the call site without paying for a\n * dedicated custom hook wrapper. This keeps the public hook surface minimal\n * while preserving the \"must be used inside a provider\" safety check.\n */\nexport function assertExecutionRuntimeContext(\n context: ExecutionRuntimeContextValue \| undefined,\n): ExecutionRuntimeContextValue {\n if (!context) {\n throw new Error(\n 'Execution runtime context must be used within an ExecutionRuntimeProvider.',\n );\n }\n\n return context;\n}\n\nexport const ExecutionRuntimeProvider: React.FC<ExecutionRuntimeProviderProps> = ({\n children,\n viewDefinition,\n contextResourceIdentifiers,\n runtimeInstanceId,\n navigationZone,\n doOperation,\n navigation,\n anchor,\n participations,\n runtimeState,\n}) => {\n const value = useMemo<ExecutionRuntimeContextValue>(() => ({\n viewDefinition,\n contextResourceIdentifiers,\n runtimeInstanceId,\n navigationZone,\n doOperation,\n navigation,\n anchor,\n participations,\n runtimeState,\n }), [viewDefinition, contextResourceIdentifiers, runtimeInstanceId, navigationZone, doOperation, navigation, anchor, participations, runtimeState]);\n\n return (\n <ExecutionRuntimeContext.Provider value={value}>\n {children}\n </ExecutionRuntimeContext.Provider>\n );\n};\n"]}
1	+ {"version":3,"file":"ExecutionRuntimeContext.js","sourceRoot":"","sources":["../../../../src/core/execution/ExecutionRuntimeContext.tsx"],"names":[],"mappings":"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","sourcesContent":["import React, { createContext, useMemo } from 'react';\n\nimport type { ExecutionViewDefinition } from '~wildo-frontend-lib/core/config/execution-view.schemas';\nimport type { ResourceRegistryContextType } from '~wildo-frontend-lib/core/resources/ResourceRegistryContext';\nimport type { NavigateOptions } from '~wildo-frontend-lib/core/navigation/useNavigationController';\nimport {\n NavigationContentType,\n type NavigationContent,\n type NavigationInitiatorContext,\n type NavigationZone,\n} from '~wildo-frontend-lib/core/navigation/navigation.schemas';\nimport type { ResolvedExecutionParticipation } from './execution-participation.utils';\n\nexport enum ExecutionAnchorSource {\n PARENT_RESOURCE_REQUIREMENT = 'parent-resource-requirement',\n ADDITIONAL_RESOURCE_REQUIREMENT = 'additional-resource-requirement',\n}\n\n/*\n Minimal resolved anchor for the first execution runtime slice.\n \n This anchor is intentionally conservative: it is only resolved from declared\n * resource requirements that also have a concrete bound identifier in the\n * execution context. Ambient primary scope alone is not enough to synthesize an\n * anchor because primary scope identifies environment, not necessarily subject.\n /\nexport interface ExecutionAnchor {\n mainResourceType: string;\n mainResourceId: string;\n bindingKey: string;\n source: ExecutionAnchorSource;\n}\n\nexport interface ExecutionLocalPaneState {\n paneId: string;\n payload?: unknown;\n}\n\n/\n @wildo_source:part:start saas.frontend.execution-view.loading-aggregation facet:layer:frontend facet:family:execution-view\n \n Execution-shell loading aggregation.\n \n The execution shell publishes one authoritative loading signal per\n * runtime-instance, aggregating only what the shell itself truthfully owns.\n * Consumers get a single `execution.loading` surface instead of re-authoring\n * spinner state for every action button.\n \n What the aggregator owns (and why):\n \n - Pending execute actions. Every `execute()` on a resource-operation\n * action verb runs through the shell's `doOperation()` bridge. The shell\n * registers a `ExecutionPendingAction` before the call and clears it on\n * settle (success or failure).\n * - Participation prefetch entries. A second tier for in-flight async\n * hydration of one or more execution participations. Wired in Slice H as\n * scaffolding ahead of a real producer (no in-tree producer exists today\n * because participation resolution is fully synchronous), so a future\n * async participation source can register prefetches without re-shaping\n * the public `ExecutionLoadingValue` surface. Spec lives at the\n * `participation-prefetch` sub-anchor below.\n \n What the aggregator intentionally does not own:\n \n - Embedded-content layout loading. The embedded slot mounts a\n * `ResourceOperationSurface`, which has its own internal read/write\n * loading contract. The execution shell does not shadow or duplicate that\n * contract; `hasEmbeddedContent` alone is not a loading signal.\n * - Router-delegated content. Once `delegateToParent(...)` fires, the\n * execution view has yielded ownership. Any downstream loading lives on\n * the router's navigation stack.\n * - Consumer-pushed phases. App code cannot register synthetic \"phase\"\n * entries to make `isBusy` reflect a multi-step workflow it owns. Every\n * tier is shell-owned (see invariant #1) — that constraint is what makes\n * the aggregator's truthfulness portable across consumers.\n \n Contract invariants:\n \n 1. Shell-owned tracking only. The aggregator is populated exclusively\n * by shell-owned hooks (`execute()` for the pending-action tier; future\n * framework-owned participation resolvers for the participation-prefetch\n * tier). App code must not push entries into it directly — the\n * `begin/endPendingAction` and `begin/endParticipationPrefetch` helpers\n * on `ExecutionNavigationValue` are internal plumbing.\n * 2. Settle always clears. Every `beginPendingAction` /\n * `beginParticipationPrefetch` has a matching `endPendingAction` /\n * `endParticipationPrefetch`, called in the promise's `finally` path.\n * Rejections clear the entry just like resolutions.\n * 3. Per-runtime-instance scope. The aggregator lives on the execution\n * runtime, not globally. Two execution views mounted in the same app do\n * not share pending-action or prefetch state.\n * 4. Orthogonal to the three-zone contract. Pending actions and prefetches\n * are operational telemetry, not a fourth navigation zone. They coexist\n * with `embeddedContent` and `localPane` on `ExecutionRuntimeState` but\n * do not represent child intent.\n * 5. `isBusy` aggregates every tier.\n * `execution.loading.isBusy = pendingActions.length > 0 \|\|\n * participationPrefetchActions.length > 0`. The renderer-facing label\n * \"anything in flight\" stays honest as new tiers are added. Per-tier\n * narrowing is reached via `isPending(...)` (execute actions) and\n * `isParticipationPrefetching(...)` (prefetches) explicitly.\n /\nexport interface ExecutionPendingAction {\n /\n Stable id for the pending action. Generated by the shell at `begin` time\n * so `end` can clear the matching entry even if the caller forgets it.\n /\n actionRuntimeId: string;\n /* Canonical `operationPathKey` the shell passed to `doOperation()`. /\n operationPathKey: string;\n /* Resource the action targets, for per-resource UI filtering. /\n resourceType: string;\n /* Operation identifier (e.g. `READ`, `UPDATE`, dictionary key). /\n operationId: string;\n /* `Date.now()` when tracking began — useful for stale-spinner detection. /\n startedAt: number;\n}\n/* @wildo_source:part:end saas.frontend.execution-view.loading-aggregation /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.loading-aggregation.participation-prefetch facet:layer:frontend facet:family:execution-view\n \n Execution-shell loading aggregation — participation-prefetch tier (Slice H).\n \n Sub-anchor of `saas.frontend.execution-view.loading-aggregation`. Defines\n * the loading aggregator's second tier: in-flight async hydration of one or\n * more execution participations.\n \n First producer landed in Slice K. `resolveExecutionParticipations(...)`\n * itself is still synchronous (a pure derivation from `viewDefinition` +\n * `registry` + `anchor` + `contextResourceIdentifiers`), but the first\n * concrete producer for this tier ships as a pair of consumer-callable\n * hooks — `useExecutionParticipationPrefetch` (generic primitive) and\n * `useExecutionParticipationDataPrefetch` (opinionated wrapper). They\n * orchestrate `doOperation()`-driven async data fetches around the\n * `beginParticipationPrefetch` / `endParticipationPrefetch` lifecycle\n * helpers below. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor (immediately after this one) for the producer-side contract.\n * Future async participation sources (e.g. a relationship-projection\n * participation that needs to fetch the source resource's data to\n * disambiguate the projection edge, or a future \"lazy participation\"\n * mode that hydrates an aliased identifier from a remote call) can\n * register through the same `beginParticipationPrefetch` /\n * `endParticipationPrefetch` seam without re-shaping the public\n * `ExecutionLoadingValue` surface.\n \n What a \"participation prefetch\" is. A bounded async unit of work\n * whose purpose is to hydrate the data backing one or more participation\n * refs before the consuming custom view treats those participations as\n * fully resolved. Examples that would qualify (none exist today):\n \n - A relationship-projection participation that needs the source\n * resource's data to pick the right edge — the helper\n * `resolveExecutionParticipations` already accepts a\n * `sourceResourceDataByParticipationRef` parameter, but it is unused at\n * the `ExecutionView` call site because no async source feeds it.\n * - A future \"participation lazy-binding\" mode where an anchor or\n * requirement participation hydrates an aliased identifier from a remote\n * call instead of from URL/ambient scope.\n \n Things that are NOT participation prefetches and must not be registered\n * here (parent invariant #1 plus tier-specific clarifications):\n \n - Consumer-driven graph reads via\n * `useExecution().actions.operation(...).execute()`. Those are pending\n * execute actions and live in the `pendingActions` tier already (and\n * carry their own `operationPathKey` correlation key, which prefetches\n * intentionally do not).\n * - Embedded-layout internal loading. Owned by the embed slot's own\n * contract; the parent anchor explicitly excludes it.\n * - Workflow / multi-step phases authored by the consumer. The aggregator\n * does not accept consumer pushes; a consumer that wants a \"view is\n * warming up\" boolean composes one in its own `useState` from\n * `execution.loading.isParticipationPrefetching(...)` plus its own\n * bookkeeping.\n \n Intent classification. Each entry carries an\n * `ExecutionParticipationPrefetchIntent`:\n \n - `INITIAL` — first-time hydration during shell bootstrap. Renderers\n * typically gate the entire view on this (full-screen skeleton).\n * - `REFRESH` — re-hydration of an already-resolved participation\n * (background revalidation). Renderers typically render through with a\n * subtle indicator. Distinct from `INITIAL` so consumers can tell the\n * two apart without authoring a side-channel boolean.\n \n Aggregation into `isBusy` (parent invariant #5). Prefetch entries\n * count toward `execution.loading.isBusy` exactly like pending execute\n * actions. Per-tier narrowing is reached via the dedicated\n * `isParticipationPrefetching(predicate?)` helper on\n * `ExecutionLoadingValue` (no overlap with `isPending(...)` which stays\n * about execute actions).\n \n Producer registration. Producers call the low-level\n * `beginParticipationPrefetch` / `endParticipationPrefetch` helpers\n * directly on `ExecutionNavigationValue` (mirrors the Slice B\n * `beginPendingAction` / `endPendingAction` pattern). The Slice K hooks\n * (`useExecutionParticipationPrefetch` /\n * `useExecutionParticipationDataPrefetch`) are the framework-shipped\n * wrappers around this seam — they own begin/end pairing, cancellation\n * via `AbortController`, latest-error surfacing, and the optional\n * bridge to `execution.errors.failedActions` (with the dedicated\n * `PARTICIPATION_PREFETCH` scope and `clearFailedActionsForPrefetchKey`\n * auto-prune lifecycle). Custom producers (e.g. a future shell-owned\n * lazy-participation resolver) call the raw helpers directly and MUST\n * pair every begin with a matching end inside a `try`/`finally` so\n * parent invariant #2 (\"settle always clears\") holds for this tier too.\n \n Contract invariants (specialization of the parent anchor's invariants):\n \n 1. Producer-minted ids; same-id re-register is idempotent-by-overwrite.\n * `prefetchRuntimeId` is minted by the producer (in contrast to\n * `actionRuntimeId`, which the shell mints at the `doOperation()` bridge).\n * The shell does not de-duplicate semantically distinct units that happen\n * to share an id — calling `beginParticipationPrefetch` with an existing\n * id REPLACES the prior entry (last-write-wins). Producers MUST mint a\n * fresh id per in-flight unit so the timeline (start time, intent,\n * participation refs) is not silently overwritten by a concurrent unit\n * that happened to recycle the id.\n * 2. Non-empty participation refs. `participationRefs` MUST contain at\n * least one ref. A prefetch that hydrates \"no participation\" has no\n * correlation handle and would be invisible to per-ref UX.\n * `assertExecutionPendingPrefetchShape` rejects empty arrays at the\n * nav helper boundary so dynamic callers (test mocks, deserialized\n * state, future authored hydrators) cannot bypass this.\n \n Not validated against `viewDefinition.participations`. The shape\n * guard intentionally does not check that each ref exists in the\n * resolved participations registry. Doing so would couple this seam\n * to the view-definition layer (the nav helpers don't currently\n * receive the view definition), and would forbid producers from\n * pre-registering prefetches for participations that materialize\n * after the prefetch begins (a plausible pattern for the future\n * \"participation lazy-binding\" mode mentioned above). When the first\n * real producer ships, re-evaluate this trade-off — until then the\n * consequence of a typoed ref is \"the entry will register but no\n * `isParticipationPrefetching((p) => p.participationRefs.includes(...))`\n * predicate will ever match\", which is observable in renderer UX and\n * therefore self-correcting.\n * 3. Resource type required. The `resourceType` field mirrors\n * `ExecutionPendingAction.resourceType` so per-resource UI filtering\n * (e.g. \"is anything tasks-related loading?\") composes uniformly across\n * both tiers.\n * 4. Intent must be a known value. `INITIAL` or `REFRESH`. Unknown\n * intents would silently bypass renderer narrowing UX.\n * `assertExecutionPendingPrefetchShape` enforces this.\n \n Acknowledged rot risk. The `INITIAL`/`REFRESH` vocabulary was\n * pinned ahead of any real producer (Slice H scaffolding). Plausible\n * additions a real producer might want — `BACKGROUND_SYNC` (idle-time\n * revalidation), `LAZY_HYDRATE` (visibility-triggered), `RETRY` (after\n * a failure) — would extend the enum additively. If a producer's\n * needed dimension does not fit the enum at all (e.g. priority,\n * cancellability), revisit `intent`'s shape rather than overload it.\n /\nexport enum ExecutionParticipationPrefetchIntent {\n INITIAL = 'initial',\n REFRESH = 'refresh',\n}\n\nexport interface ExecutionPendingPrefetch {\n /\n Stable id for this in-flight prefetch entry. Minted by the producer\n * (in contrast to `actionRuntimeId`, which the shell mints at the\n * `doOperation()` bridge). Same-id re-register is idempotent-by-overwrite:\n * the shell REPLACES the prior entry rather than de-duplicating two\n * semantically distinct units. Producers MUST mint a fresh id per\n * in-flight unit so the timeline is preserved — see invariant #1 in the\n * sub-anchor JSDoc above.\n /\n prefetchRuntimeId: string;\n /\n Participation refs whose data is being hydrated by this prefetch.\n * Multiple refs are allowed: one fetch can resolve several participations\n * (e.g. a relationship-projection that needs both endpoints).\n \n Must contain at least one ref — a prefetch with no refs cannot be\n * narrowed to per-ref UX and is a contract bug. Enforced at the nav\n * helper boundary by `assertExecutionPendingPrefetchShape`.\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 both tiers of the loading aggregator.\n /\n resourceType: string;\n /\n Whether this is the first-time hydration (`INITIAL`) or a background\n * re-hydration (`REFRESH`). Lets renderers distinguish \"full-screen\n * skeleton\" vs \"subtle indicator\" without a side-channel boolean.\n /\n intent: ExecutionParticipationPrefetchIntent;\n /* `Date.now()` when tracking began. /\n startedAt: number;\n /* Optional human-readable label (\"Loading task graph\"). Opaque to the shell. /\n label?: string;\n}\n\n/\n Belt-and-braces runtime check that an `ExecutionPendingPrefetch` entry\n * is well-formed. Mirrors `assertExecutionDirtyMarkerShape` /\n * `assertExecutionFailedActionShape` — exists for dynamic callers (test\n * mocks, deserialized state, future authored hydrators) where the type\n * may have been widened via `as`/`unknown`.\n \n Throws synchronously when:\n * - `participationRefs` is missing or empty (would render the entry\n * un-narrowable for per-ref UX);\n * - `resourceType` is missing or empty (breaks per-resource UI filtering\n * uniformity with the pending-action tier);\n * - `intent` is not a known `ExecutionParticipationPrefetchIntent` value\n * (would silently bypass renderer narrowing UX).\n /\nexport function assertExecutionPendingPrefetchShape(prefetch: ExecutionPendingPrefetch): void {\n if (!Array.isArray(prefetch.participationRefs) \|\| prefetch.participationRefs.length === 0) {\n throw new Error(\n '[ExecutionView] ExecutionPendingPrefetch must carry at least one participation ref. '\n + 'A prefetch with no refs cannot be narrowed to per-ref UX. '\n + 'If the work is not tied to any participation, do not register it as a participation prefetch.',\n );\n }\n if (typeof prefetch.resourceType !== 'string' \|\| prefetch.resourceType.length === 0) {\n throw new Error(\n '[ExecutionView] ExecutionPendingPrefetch must carry a non-empty `resourceType` '\n + 'so per-resource UI filtering composes uniformly with the pending-action tier.',\n );\n }\n if (\n prefetch.intent !== ExecutionParticipationPrefetchIntent.INITIAL\n && prefetch.intent !== ExecutionParticipationPrefetchIntent.REFRESH\n ) {\n throw new Error(\n '[ExecutionView] ExecutionPendingPrefetch.intent must be one of '\n + '`INITIAL` \| `REFRESH` so renderers can distinguish full-screen '\n + 'vs background hydration UX without a side-channel flag.',\n );\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.loading-aggregation.participation-prefetch /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.loading-aggregation.participation-prefetch.shell-data-hydrator facet:layer:frontend facet:family:execution-view facet:kind:contract facet:audience:framework-author\n \n First concrete producer for the participation-prefetch tier (Slice K).\n \n Sub-anchor of `loading-aggregation.participation-prefetch`. Defines the\n * contract for the framework-shipped producer pair:\n \n - `useExecutionParticipationPrefetch` — generic primitive hook. Owns\n * the begin/end pairing for `ExecutionPendingPrefetch` entries, the\n * `AbortController`-driven cancellation on unmount / re-run, the\n * stable per-mount `prefetchKey`, and the optional bridge of failures\n * into `execution.errors.failedActions` under\n * `ExecutionFailedActionScope.PARTICIPATION_PREFETCH`. Consumers\n * provide an async `run({ signal })` callback that performs the actual\n * work — typical use is 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 plumbing without adopting\n * `doOperation()` semantics they do not need.\n \n - `useExecutionParticipationDataPrefetch` — opinionated wrapper over\n * the primitive that targets the most common case: hydrate a single\n * participation's resource data via `doOperation()` (the canonical\n * READ operation for the resolved resource type). Consumers pass\n * `{ participationRef, intent }` and receive\n * `{ data, isLoading, error, refetch, prefetchKey }`. The wrapper\n * threads `intent`, computes the operation path key from the\n * participation's resource type, supplies the AbortController, and\n * defaults `bridgeFailuresToShellAggregator` per-intent (see invariant\n * #6 below).\n \n Why two layers (decision: layered API). A single opinionated hook\n * would force every future producer (relationship-projection hydrator,\n * lazy-binding resolver, …) to either go through the same READ-shaped\n * `doOperation()` path or drop to the raw nav helpers and duplicate the\n * lifecycle plumbing. A single primitive-only hook would push the\n * \"fetch a participation's data\" boilerplate (operation path key\n * derivation, intent-driven bridge default, single-ref shape) onto every\n * call site of the most common case. Layering the two solves both:\n * primitive owns lifecycle, wrapper owns the canonical fetch shape, and\n * consumers pick whichever level matches their use case. Rejected\n * alternatives: (a) primitive only — common-case boilerplate cost,\n * (b) wrapper only — fetch-mechanism rot risk for future producers,\n * (c) wrapper as method on `useExecution()` — would couple the public\n * `useExecution()` surface to a single fetch shape and obscure the\n * primitive seam.\n \n *Why call `doOperation()` directly, not `actions.operation().execute()`\n (decision: `fetch-doOperation-direct`).** `actions.operation().execute()`\n * registers a `pendingAction` in the execute-action tier, which would\n * double-count the same logical work in `loading.isBusy` (once via the\n * pending action, once via the prefetch entry) and would trigger the\n * shell's failure-handling-contract bridge for both tiers. The wrapper\n * therefore calls `navigation.doOperation(...)` directly inside the\n * `run({ signal })` callback, keeping the prefetch tier semantically\n * separate from the execute-action tier. The action-status snapshot's\n * JSDoc already documents that prefetches don't carry an\n * `operationPathKey` correlation key — this is the producer side of\n * that decision: prefetches are not \"actions\" the framework can retry\n * via `action.retry()`; they are revalidation cycles the consumer\n * controls via `refetch()`. Rejected alternative: route through\n * `execute()` for \"free\" outcome emission and consistency — the\n * double-tier accounting and re-emit risk outweigh the consistency win.\n \n Contract invariants (specialization of the parent sub-anchor's\n * invariants):\n \n 1. Stable `prefetchKey` per logical unit. The hook caches a\n * `prefetchKey` per mount (typically derived from the consumer's\n * keying inputs — resource type + participation ref + intent — or\n * explicitly authored). The same key is reused across consecutive\n * `refetch()` cycles so the shell's\n * `clearFailedActionsForPrefetchKey(key)` verb can drop matching\n * entries on the next successful settle. Distinct from\n * `prefetchRuntimeId`, which rotates on every fire so the parent\n * sub-anchor's invariant #1 (\"producer-minted ids; same-id\n * re-register is idempotent-by-overwrite\") is honored without the\n * consumer having to think about it.\n \n 2. One in-flight unit per hook instance. A new `run()` while a\n * prior one is in flight aborts the prior `AbortController` and\n * `endParticipationPrefetch`es the prior `prefetchRuntimeId` before\n * minting a fresh id and beginning the new unit. Prevents two\n * concurrent units from accumulating in `pendingPrefetches` for the\n * same logical key (which would inflate `isBusy` and confuse\n * per-ref UX). Consumers who legitimately want parallel hydration\n * of distinct participations mount distinct hook instances — one\n * instance per logical unit is the framework rule, mirroring the\n * `useEffect`-per-effect pattern.\n \n 3. Settle always clears (parent invariant #2 specialization). The\n * primitive's `try`/`finally` around the consumer's `run(...)`\n * guarantees `endParticipationPrefetch(prefetchRuntimeId)` runs on\n * success, throw, AND `AbortError`. On unmount, the cleanup branch\n * aborts the controller and ends the prefetch synchronously — the\n * in-flight `doOperation()` rejection arrives later in a no-op\n * settle (the runtime id is already gone, so `endParticipationPrefetch`\n * is a no-op per the public JSDoc).\n \n 4. Stale-while-revalidate for `REFRESH`. When `intent === REFRESH`,\n * the wrapper keeps the prior `data` value visible while the new\n * fetch is in flight (returning `{ data: <stale>, isLoading: true,\n * error }`). When `intent === INITIAL`, `data` is `undefined` until\n * the first successful settle. This split mirrors the parent\n * sub-anchor's intent classification (\"full-screen skeleton\" vs\n * \"subtle indicator\") on the data side.\n \n 5. Latest-error surfacing. The hook always surfaces the latest\n * settle's `error` (or `undefined` on success) in its return value —\n * `error` is reset to `undefined` on every successful settle and is\n * set to the rejection on every failed one. This is the consumer's\n * primary error-display channel; the optional shell-aggregator\n * bridge (next invariant) is for cross-component aggregation and\n * persistent failure history.\n \n 6. Optional shell-aggregator bridge (`bridgeFailuresToShellAggregator`).\n * When `true` (the wrapper's default for `INITIAL`, opt-in for\n * `REFRESH`), failures are also captured via\n * `execution.errors.capture({ scope: PARTICIPATION_PREFETCH,\n * prefetchKey, ... })`, where they participate in the cross-component\n * `failedActions` aggregator and auto-prune on the next successful\n * settle for the same key (via\n * `clearFailedActionsForPrefetchKey(prefetchKey)`, called by the hook).\n * When `false`, failures are surfaced only via the hook's `error`\n * return value — the right choice for \"background revalidation that\n * must not raise a global banner\". The default split (INITIAL=true,\n * REFRESH=false in the wrapper) reflects the typical UX: an initial\n * hydration failure is noteworthy enough to surface globally; a\n * silent revalidation failure usually is not. The primitive defaults\n * to `false` (consumers explicitly opt in) because it has no\n * intent-aware default to lean on.\n \n 7. No retry verb. Refetch is the only retry pattern. The hook\n * exposes `refetch()` (re-runs with the same inputs); the shell does\n * not synthesize a `retry()` analog of the action-status one because\n * prefetches don't carry an `operationPathKey` correlation key (see\n * `ExecutionOperationActionStatus.isPending` JSDoc on the per-tier\n * separation). Consumers wanting \"clear failure + refetch\" call\n * `refetch()` — the bridge auto-prunes the prior failure on\n * successful settle.\n \n 8. `PARTICIPATION_PREFETCH` scope is dedicated. Failures bridged\n * by these hooks land under `ExecutionFailedActionScope.PARTICIPATION_PREFETCH`\n * (NOT `CUSTOM`), which is auto-cleared by\n * `clearFailedActionsForPrefetchKey(prefetchKey)`. This is the\n * fourth scope and exists specifically because the auto-prune\n * lifecycle (per-key on successful settle) is genuinely distinct\n * from the zone-transition-based pruning of `EMBEDDED_CONTENT` /\n * `LOCAL_PANE` and the manual-only model of `CUSTOM`. See the\n * failure-handling-contract anchor for the full scope vocabulary.\n \n Where it composes with the rest of the shell. A consumer view that\n * needs to hydrate a participation's data ahead of an interaction (the\n * Slice K dogfood: chrome banner showing `todoList.name`, inspector\n * node hover prewarming the inspector pane) calls\n * `useExecutionParticipationDataPrefetch({ participationRef, intent })`\n * and threads the returned `{ data, isLoading, error }` into its UI.\n * Per-tier loading questions still flow through the public aggregator:\n * `execution.loading.isParticipationPrefetching((p) =>\n * p.participationRefs.includes(ref))` answers \"is this ref being\n * hydrated?\" from the chrome's perspective without knowing which hook\n * mounted the prefetch.\n \n @wildo_source:part:end saas.frontend.execution-view.loading-aggregation.participation-prefetch.shell-data-hydrator\n /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.dirty-state-contract facet:layer:frontend facet:family:execution-view\n \n Execution-shell dirty-state contract.\n \n The execution shell aggregates authored dirty-state markers — one per\n * distinguishable unsaved surface — so consumers can query a single truthful\n * `execution.dirty` signal before kicking zone transitions (close the embed,\n * replace the embed, switch panes, delegate to the router). The shell does\n * not enforce modals or block transitions; it only publishes the markers.\n * UX decisions (confirm dialog, toast, ignore) live with the consumer.\n \n Publisher / subscriber model (mirrors the loading-aggregation tier):\n \n - Publishers are whoever owns the unsaved state. Today that's either a\n * custom component rendering zone-B content with editable fields, or an\n * adapter wrapping an RMM-backed embedded edit surface (zone A). Publishers\n * call `execution.dirty.mark({ markerId, scope, label?, paneId? })` on\n * first edit and `execution.dirty.clear(markerId)` on save/discard.\n * - Subscribers (the execution view renderer, the shell's transition\n * verbs) read `execution.dirty.markers` / `execution.dirty.isAnyDirty` and\n * author UX accordingly.\n \n Why the shell doesn't query the embedded layout directly: the shell does\n * not hold a reference to the embedded layout's RMM instance — that\n * `ResourceMutationManager` lives inside the `ResourceOperationSurface` and\n * exposes `hasUnsavedChanges` only through `useResourceMutationManager`\n * subscribers, not through a cross-layer observable. Adding a cross-reach\n * would couple the shell to a specific mutation manager implementation. The\n * publish/subscribe contract keeps the boundary clean.\n \n Scopes classify a marker's lifecycle so the shell can safely auto-clean\n * without asking the publisher. Scope is not purely decorative — it drives\n * the auto-cleanup invariant below:\n \n - `EMBEDDED_CONTENT` — the unsaved state belongs to the current embed\n * slot. When the slot empties (close, replace), the marker is auto-cleared\n * because the layout that authored it is gone by definition.\n * - `LOCAL_PANE` — the unsaved state belongs to the currently-open\n * `localPane`. When the pane closes or a different `paneId` opens, the\n * marker is auto-cleared. If the publisher wants the draft to survive\n * pane-id transitions, it should use `CUSTOM` scope.\n * - `CUSTOM` — consumer-owned lifecycle. The shell never auto-clears these.\n * Used for draft state that outlives any single zone transition (e.g.\n * a top-level side panel authored by the custom component itself).\n \n Contract invariants:\n \n 1. Publisher owns mark/clear. The shell never synthesizes markers — no\n * \"auto-mark on first type\" magic. Publishers call `mark()` explicitly,\n * and symmetrically call `clear()` on save or discard.\n * 2. Auto-cleanup at zone boundaries. `closeEmbeddedContent`/\n * `openEmbeddedContent` clear all `EMBEDDED_CONTENT`-scoped markers;\n * `closeLocalPane`/`openLocalPane` clear all `LOCAL_PANE`-scoped markers\n * whose `paneId` no longer matches the active pane. `CUSTOM` markers are\n * untouched.\n * 3. Stable marker ids. `markerId` must be stable across re-renders of\n * the same publisher — re-marking an existing id is idempotent (replaces\n * the entry, does not produce a duplicate).\n * 4. Shell is informative, not restrictive. Transition verbs\n * (`closeEmbeddedContent`, `openEmbeddedContent`, `delegateToParent`) do\n * not block on dirty state. Consumers read `isAnyDirty` and author\n * their own confirm flow before calling the transition. Making the shell\n * block would force a modal UX the framework cannot reasonably author\n * centrally.\n * 5. Per-runtime-instance scope. The aggregator lives on\n * `ExecutionRuntimeState`, not globally. Two execution views mounted in\n * the same app do not share dirty markers.\n * 6. Orthogonal to other shell tiers. Dirty state is not a navigation\n * zone (three-zone contract) nor operational telemetry (loading\n * aggregation). It is its own shell tier with its own invariants.\n /\nexport enum ExecutionDirtyMarkerScope {\n EMBEDDED_CONTENT = 'embedded-content',\n LOCAL_PANE = 'local-pane',\n CUSTOM = 'custom',\n}\n\n/\n Common shape for every dirty marker, regardless of scope.\n \n Intentionally not exported on its own — consumers use the\n * `ExecutionDirtyMarker` discriminated union below so the type system\n * enforces \"LOCAL_PANE markers carry a `paneId`\" without requiring\n * defensive `!== undefined` checks at every read site.\n /\ninterface ExecutionDirtyMarkerBase {\n /\n Stable publisher-authored id. Re-marking the same id is idempotent —\n * the entry is replaced, not duplicated. Typically derived from a\n * resource identity (e.g. `embed:tasks:task-1:UPDATE`) or a pane-scoped\n * key (e.g. `pane:todo-inspector:draft`).\n /\n markerId: string;\n /\n Optional human-readable reason (\"Unsaved task changes\", \"Draft\n * description\"). Consumers may surface it in confirm dialogs or ambient\n * badges; the shell treats it as opaque metadata.\n /\n label?: string;\n /* `Date.now()` when the marker was first registered. /\n markedAt: number;\n}\n\n/\n Discriminated union of dirty markers.\n \n The discriminant `scope` makes \"`paneId` is required for `LOCAL_PANE`\n * markers, absent on the others\" a compile-time invariant — there is no\n * `paneId?` escape hatch on the non-pane variants. Combined with the\n * runtime assertion `assertExecutionDirtyMarkerShape`, dynamic callers\n * (test mocks, deserialized state, authored dictionaries) cannot collapse\n * the variants either.\n /\nexport type ExecutionDirtyMarker =\n \| (ExecutionDirtyMarkerBase & { scope: ExecutionDirtyMarkerScope.EMBEDDED_CONTENT })\n \| (ExecutionDirtyMarkerBase & { scope: ExecutionDirtyMarkerScope.LOCAL_PANE; paneId: string })\n \| (ExecutionDirtyMarkerBase & { scope: ExecutionDirtyMarkerScope.CUSTOM });\n\n/\n Belt-and-braces runtime check that a `ExecutionDirtyMarker` matches its\n * discriminant invariants. The type layer already enforces these for\n * statically-shaped callers; this assertion exists for dynamic callers\n * (test mocks, deserialized payloads, authored dictionaries) where the\n * type may have been widened via `as`/`unknown`.\n \n Throws synchronously when a `LOCAL_PANE` marker is registered without a\n * `paneId` — the only invariant that cannot be expressed any other way.\n /\nexport function assertExecutionDirtyMarkerShape(marker: ExecutionDirtyMarker): void {\n if (marker.scope === ExecutionDirtyMarkerScope.LOCAL_PANE) {\n const candidate = marker as { paneId?: unknown };\n if (typeof candidate.paneId !== 'string' \|\| candidate.paneId.length === 0) {\n throw new Error(\n '[ExecutionView] LOCAL_PANE-scoped dirty marker must carry a non-empty `paneId` '\n + 'so the shell can auto-clear it on pane transitions. '\n + 'Use scope=CUSTOM for markers that should outlive any single pane.',\n );\n }\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.dirty-state-contract /\n\n/\n Contract for content that an execution view is allowed to embed inside its\n * own shell. Today only `NavigationContent.RESOURCE_OPERATION` is embeddable,\n * so consumers cannot stuff arbitrary navigation content into the slot.\n \n Naming note: this is the `Embeddable` contract (what can* be embedded),\n * not an `Embedded` state. Once the runtime actually holds an instance, it\n lives in `ExecutionEmbeddedContentState`.\n /\nexport type ExecutionEmbeddableContent = Extract<\n NavigationContent,\n { contentType: NavigationContentType.RESOURCE_OPERATION }\n>;\n\n/\n State of the execution view's single embedded-content slot.\n \n The shell guarantees only one embedded surface is mounted at a time.\n * `navigationInitiator` preserves the same provenance\n * (`sourceZone`, `launcher`, `sourceOperation`, `sourceRelationship`) a\n * router-delegated surface would receive, so embedded and routed surfaces\n * behave identically downstream.\n /\nexport interface ExecutionEmbeddedContentState {\n content: ExecutionEmbeddableContent;\n navigationInitiator?: NavigationInitiatorContext;\n}\n\n/\n @wildo_source:part:start saas.frontend.execution-view.three-zone-contract facet:layer:frontend facet:family:execution-view\n \n Three-zone contract for execution-view child intent.\n \n An execution view has exactly three zones where frontend-only state and\n * child navigation intent can live. Each zone has a *distinct semantic\n purpose*, and a consumer must pick exactly one per intent. The zones are\n not stylistic variants — collapsing any two into each other destroys the\n * execution shell's ability to reason about what it owns vs what the router\n * owns.\n \n \| Zone \| Lives in \| Payload \| Owner \| Purpose \|\n * \|---\|---\|---\|---\|---\|\n * \| A. `embeddedContent` \| `ExecutionRuntimeState` \| `ExecutionEmbeddableContent` (`NavigationContent.RESOURCE_OPERATION` only) \| Execution shell (`ExecutionView`) \| Mount a downstream resource-operation surface inside the shell instead of delegating to the router (the \"embed\" seam) \|\n * \| B. `localPane` \| `ExecutionRuntimeState` \| `{ paneId: string; payload?: unknown }` — renderer-opaque data, never `NavigationContent` \| Custom component (the view's own `viewComponent`) \| Ephemeral shell state — inspectors, drawers, selection metadata. Not navigation content. \|\n * \| C. `delegateToParent` \| App router (parent navigation stack) \| Any `NavigationContent` \| App router \| Yield control to the router. The execution view loses the screen for this intent. \|\n \n Invariants that make this a contract, not three coincidental state fields:\n \n 1. Mutual exclusivity by purpose. A single intent picks exactly one\n * zone. \"Open a read surface next to the current view\" is zone A. \"Remember\n * which node the user clicked\" is zone B. \"Send the user back to the home\n * page\" is zone C.\n * 2. No content-type confusion. Zone A is resource-operation-only (typed\n * as `ExecutionEmbeddableContent`). Zone B's `payload` is not\n * `NavigationContent` — if a consumer finds itself tempted to put\n * `{ contentType: NavigationContentType.RESOURCE_OPERATION, ... }` into a\n * pane payload, that intent belongs in zone A. Zone C is the only zone\n * that accepts arbitrary `NavigationContent`, and it hands it off.\n * 3. Shell owns the shell. Zones A and B both live in\n * `ExecutionRuntimeState`, but the rendering responsibility differs:\n * `ExecutionView` renders zone A (including the close affordance);\n * the custom component renders zone B itself using the pane state it\n * authored. Consumers never reinvent the zone A shell.\n * 4. One slot per zone. Zones A and B are single-slot. Opening a new\n * embed replaces the previous one; opening a new pane replaces the\n * previous one. If a surface truly needs \"many open inspectors at once\",\n * that's renderer state inside a single pane payload, not multiple panes.\n * 5. Provenance parity. Zones A and C both thread\n * `NavigationInitiatorContext` (`sourceZone`, `launcher`, `sourceOperation`,\n * `sourceRelationship`) — see the embedding-principle anchor at\n * `saas.frontend.execution-view.navigation-handling-and-embedding`. An\n * embedded read surface behaves indistinguishably from a routed read\n * surface of the same resource.\n * 6. Defensive validation at the zone boundary. The runtime fails fast\n * when a caller misroutes an intent — `openLocalPane` rejects payloads\n * shaped like `ExecutionEmbeddableContent` and `openEmbeddedContent`\n * rejects non-`RESOURCE_OPERATION` content — see\n * `assertExecutionLocalPanePayloadIsNotEmbeddableContent` and\n * `assertExecutionEmbeddableContent` below. These assertions are\n * belt-and-braces over the type layer; they exist so dynamic callers (test\n * mocks, deserialized state, authored dictionaries) cannot silently collapse\n * the zones.\n /\nexport interface ExecutionRuntimeState {\n embeddedContent: ExecutionEmbeddedContentState \| null;\n localPane: ExecutionLocalPaneState \| null;\n /\n Pending shell-tracked actions keyed by `actionRuntimeId`. See the\n * loading-aggregation anchor above — this is operational telemetry, not\n * a navigation zone.\n /\n pendingActions: Record<string, ExecutionPendingAction>;\n /\n In-flight participation prefetch entries keyed by `prefetchRuntimeId`.\n * See the `loading-aggregation.participation-prefetch` sub-anchor above.\n * Today this slot is wired but not populated — no in-tree producer\n * registers prefetches because participation resolution is fully\n * synchronous. The slot exists so that the day a real async producer\n * materializes, the public `ExecutionLoadingValue` can expose\n * `participationPrefetchActions` / `isAnyParticipationPrefetching` /\n * `isParticipationPrefetching(...)` without re-shaping the API.\n /\n participationPrefetchActions: Record<string, ExecutionPendingPrefetch>;\n /\n Authored dirty-state markers keyed by `markerId`. See the\n * dirty-state-contract anchor above — scope-based auto-cleanup applies at\n * zone transitions but the shell never synthesizes or forces-blocks on\n * these markers.\n /\n dirtyMarkers: Record<string, ExecutionDirtyMarker>;\n /\n Captured failed-action entries keyed by `failureRuntimeId`. See the\n * failure-handling-contract anchor — scope-based auto-cleanup mirrors\n * `dirtyMarkers`; the shell captures and bridges, but does not retry or\n * suppress consumer error UX.\n /\n failedActions: Record<string, ExecutionFailedAction>;\n}\n\n/\n Validates that a `localPane` payload is not accidentally an\n * `ExecutionEmbeddableContent`. See the three-zone contract above: zone B\n * payloads are renderer-opaque data, not navigation content.\n \n Throws with a message pointing the caller to\n * `openEmbeddedContent`/`execution.actions.operation(...).embed()` when a\n * misroute is detected. No-op for normal renderer payloads.\n /\nexport function assertExecutionLocalPanePayloadIsNotEmbeddableContent(\n payload: unknown,\n): void {\n if (payload === null \|\| typeof payload !== 'object') {\n return;\n }\n const candidate = payload as { contentType?: unknown };\n if (candidate.contentType === NavigationContentType.RESOURCE_OPERATION) {\n throw new Error(\n '[ExecutionView] localPane payload must not be an ExecutionEmbeddableContent. '\n + 'Resource-operation content belongs in the embedded-content slot. '\n + 'Use openEmbeddedContent() or execution.actions.operation(...).embed() instead.',\n );\n }\n}\n\n/\n Validates that a value claimed to be `ExecutionEmbeddableContent` truly is\n * one. Today that means `contentType === NavigationContent.RESOURCE_OPERATION`;\n * see the three-zone contract above.\n \n The type layer already enforces this, so this assertion is belt-and-braces\n * for dynamic callers (test mocks, deserialized content, authored action\n * dictionaries) where the type may have been widened via `as`/`unknown`.\n /\nexport function assertExecutionEmbeddableContent(\n content: ExecutionEmbeddableContent,\n): void {\n if (!content \|\| content.contentType !== NavigationContentType.RESOURCE_OPERATION) {\n throw new Error(\n '[ExecutionView] embeddedContent.content must be a '\n + 'NavigationContent.RESOURCE_OPERATION. Non-resource-operation '\n + 'navigation content must go through delegateToParent() (the app router), '\n + 'not the execution shell\\'s embed slot.',\n );\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.three-zone-contract /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.outcome-emission-contract facet:layer:frontend facet:family:execution-view\n \n Execution-shell operation-outcome emission contract.\n \n The execution shell is a canonical producer on the app-level\n * `FrontendEvents` bus (`EventBus`) for every successful `.execute()` call.\n * It does not introduce a parallel execution-scoped outcome bus — the\n * framework already has one (`RESOURCE_OPERATION_EXECUTED` + `RESOURCE_REFRESH`\n * consumed by `NotificationContext`, `WebSocketEventBridge`, `useListInvalidation`,\n * and `resourceRefreshEvent` subscribers). A second bus would double-plumb the\n * same signal and force every subscriber to learn two APIs.\n \n Emission site: `useExecution().execute()` → `emitResourceOperationOutcome`\n * (see `execution-outcome-emission.utils.ts`). Payloads mirror\n * `useResourceOperationActions.handleExecuteOperation` exactly, so\n * execution-shell-driven operations are indistinguishable from\n * resource-layout-driven ones on the wire.\n \n Contract invariants:\n \n 1. Single canonical bus. No new public surface on `useExecution()` for\n * outcomes. Consumers subscribe via `useEventBus` / `useEventSubscription`\n * just like for any other operation producer. An execution-local bus\n * would hide signals from app-global subscribers (toast policy, WS bridge,\n * analytics) that must see every operation.\n \n 2. Emit `RESOURCE_OPERATION_EXECUTED` unconditionally on success.\n * Every resolved `.execute()` is a canonical operation-outcome event.\n * `NotificationContext` does not subscribe to this event (it is under\n * `NEED_REFRESH`, not `NOTIFY_USER`), so emitting for READ / LIST / custom\n * operations never produces unintended toasts. User-visible toasts travel\n * on `NOTIFY_RESOURCE_`, which the backend drives.\n \n * 3. Emit `RESOURCE_REFRESH` only for real mutations + WS disconnected.\n * Gate: `shouldEmitResourceRefreshAfterDirectOperation(operation)\n * && !isWebSocketConnected`. When the WS bridge is up it pushes refreshes\n * natively; emitting from here too would double-fire every listener.\n * Non-mutating operations (READ / LIST / custom) never trigger list\n * refreshes — refresh is an authored consequence of data change, not a\n * signal of \"some operation happened\".\n \n 4. Silent on failure. Rejected promises do not emit an outcome\n * event — subscribers use `.catch()` or the `NOTIFY_RESOURCE_ERROR`\n * channel for failure UX. Emitting a failure variant here would force a\n * specific error-UX on every consumer, which mirrors the dirty-state\n * contract's \"informative, not restrictive\" stance.\n \n 5. Emission before settle. Emit fires inside the `try` block, before\n * the `finally` clause calls `endPendingAction`. Subscribers that check\n * `execution.loading.isBusy` during their handler therefore still see\n * `true` — this matches `runPostOperationEffects` in\n * `useResourceOperationActions`, which runs before its own\n * `isExecuting = false` cleanup.\n \n 6. Payload parity with canonical. Shape, field names, and optional\n * discriminator threading must match the emissions from\n * `useResourceOperationActions` / `ResourceLayout_Update`. Any drift is a\n * bug — downstream subscribers rely on a single uniform payload across\n * producers.\n /\n/* @wildo_source:part:end saas.frontend.execution-view.outcome-emission-contract /\n\n/\n @wildo_source:part:start saas.frontend.execution-view.failure-handling-contract facet:layer:frontend facet:family:execution-view\n \n Execution-shell failure-handling contract.\n \n The execution shell aggregates failed actions as a symmetric counterpart\n * to the loading-aggregation tier (Slice B) and the outcome-emission tier\n * (Slice D). Every `useExecution().execute()` rejection — and any\n * consumer-authored failure (render-adjacent caught exceptions, manual\n * `errors.capture(...)` calls) — is captured into a single shell-owned bag of\n * `ExecutionFailedAction` entries. Consumers read `execution.errors` to drive\n * inline retry UX without rebuilding ad hoc per-component error state.\n \n What this tier owns (and why):\n \n - Captured failures. The shell's `execute()` catch path captures the\n * raw error alongside the originating action's identity (`actionRuntimeId`,\n * `operationPathKey`, `resourceType`, `operationId`) so consumers can render\n * targeted \"Retry CREATE on Task\" affordances instead of generic banners.\n * - Conditional bridge to the canonical bus. Most rejections come from\n * the HTTP layer, which has already been processed by\n * `errorManagement.handleHttpError(...)` (built a `WildoError_Frontend`,\n * applied the configured behavior, conditionally emitted `ERROR_OCCURED`\n * based on the per-status policy and the request's `silent` flag). The\n * shell detects this via the `error.wildoError` marker that\n * `wildo-http-client` attaches and *defers to that upstream processing\n instead of re-emitting*. Synchronous throws and non-axios rejections\n (no `wildoError`) are bridged once via `errorManagement.handleError(...)`\n * so global subscribers (`GlobalErrorHandler`, `NotificationContext` for\n * `NOTIFY_RESOURCE_ERROR`) still see them.\n \n Note: HTTP rejections marked by `wildo-http-client` may not have\n * actually emitted to the bus (silent requests, `emitEvent: false` in\n * the per-status matrix). The shell honors that consumer-requested\n * silence rather than re-emitting on its own — see\n * `markedByHttpClient` vs. `bridgedByExecutionShell` on\n * `ExecutionFailedAction` for the truthful per-entry provenance.\n \n What this tier intentionally does not own:\n \n - A second error bus. The framework already has `ERROR_OCCURED`,\n * `NOTIFY_RESOURCE_ERROR`, and `NOTIFY_CUSTOM_ERROR` on the canonical bus.\n * Adding an execution-scoped error stream would force consumers to learn\n * two APIs and would hide failures from app-global subscribers.\n * - A new render-error boundary. Render crashes inside the execution view\n * surface through the existing application `ErrorBoundary` (see\n * `core/errors/ErrorBoundary.tsx`) which already emits `ERROR_OCCURED` and\n * renders the canonical `AppLayout_ErrorBoundary` fallback. The execution\n * shell wraps its content in that boundary instead of reinventing one.\n * - Built-in retry orchestration. The shell exposes failed-action\n * metadata; the consumer owns the retry call site. A built-in\n * `retry()` would have to re-author the original action verb (which the\n * shell does not retain), and would obscure idempotency / context-refresh\n * decisions that only the consumer can make. Consumers retry by re-invoking\n * the same action verb after `clear(failureRuntimeId)`.\n \n Scopes classify a failure's lifecycle so the shell can safely\n * auto-clean without asking the publisher. They mirror\n * `ExecutionDirtyMarkerScope` exactly to keep the mental model uniform:\n \n - `EMBEDDED_CONTENT` — the failure belongs to the current embed slot.\n * Auto-cleared on `openEmbeddedContent` / `closeEmbeddedContent`.\n * - `LOCAL_PANE` — the failure belongs to the currently-open `localPane`.\n * Auto-cleared on pane close, or when a different `paneId` opens.\n * - `CUSTOM` — consumer-owned lifecycle. Default for all `execute()`-captured\n * failures (the shell does not know which zone the consumer's action verb\n * belongs to). The shell never auto-clears these.\n * - `PARTICIPATION_PREFETCH` — the failure originated from the participation-\n * prefetch tier (Slice K's first producer). Auto-cleared on the next\n * successful prefetch with the same `prefetchKey`. The 4th scope was\n * added rather than overloading `CUSTOM` because the auto-prune lifecycle\n * is genuinely distinct: prefetch failures live in a \"stale-data\n * indicator\" UX where the next successful refetch implicitly resolves\n * them, whereas `CUSTOM` failures persist until consumer-cleared. Carries\n * a `prefetchKey: string` discriminant payload — the consumer-authored\n * stable identity (NOT the per-run `prefetchRuntimeId` which rotates per\n * in-flight unit) — so the shell's `clearFailedActionsForPrefetchKey(key)`\n * verb can target the right entries on settle. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the producer-side contract this scope serves.\n \n Contract invariants:\n \n 1. Capture always, bridge at most once. Every `execute()` rejection\n * produces exactly one `ExecutionFailedAction` entry. The shell calls\n * `errorManagement.handleError(...)` only when no upstream layer has\n * already processed the error (detected via the `error.wildoError`\n * marker that `wildo-http-client.handleHttpError` attaches). The shell\n * never re-bridges an HTTP-marked error even if that upstream processing\n * suppressed emission via `silent` or `emitEvent: false` — honoring\n * consumer-requested silence is part of the contract. Each captured\n * entry records `markedByHttpClient` and `bridgedByExecutionShell`\n * truthfully so consumers can reason about provenance per entry.\n * 2. Re-throw after capture. `execute()` re-throws the original error\n * after capturing + (conditionally) bridging, so consumer `.catch()`\n * handlers and `await`-style call sites still observe the rejection.\n * The shell augments the canonical contract; it does not swallow it.\n * 3. *Capture happens before pending clears, but the renderer sees both\n in the same React commit.** Mechanically the `catch` block runs\n * `captureFailedAction(...)` then re-throws, after which the `finally`\n * block runs `endPendingAction(...)`. React batches the resulting\n * `setState` updates inside the same microtask, so consumers render\n * with `pending=false` and `errored=true` simultaneously — there is no\n * intermediate \"still-pending-but-already-failed\" state visible to a\n * rendered component. (Subscribers that observe state through refs or\n * custom selectors during the catch microtask may briefly see both\n * flags true; that path is shell-internal plumbing only.)\n * 4. Auto-cleanup at zone boundaries (and at prefetch settle).\n * `openEmbeddedContent`/`closeEmbeddedContent` clear all\n * `EMBEDDED_CONTENT`-scoped failures; `openLocalPane`/`closeLocalPane`\n * clear all `LOCAL_PANE`-scoped failures whose `paneId` no longer matches\n * the active pane; `PARTICIPATION_PREFETCH`-scoped failures are cleared\n * by `clearFailedActionsForPrefetchKey(prefetchKey)` (called by the\n * Slice K hooks on the next successful settle of the same prefetch\n * unit). `CUSTOM` failures are untouched by every auto-cleanup path —\n * the shell never collects them on its own. This mirrors the\n * dirty-state contract auto-cleanup so consumers reason about all tiers\n * with the same scope vocabulary, just with one extra trigger\n * (per-`prefetchKey` settle) for the prefetch lifecycle.\n * 5. Stable failure ids. `failureRuntimeId` is generated by the shell at\n * capture time. Re-capturing an `originatingActionRuntimeId` (e.g.\n * consumer retried, action failed again) produces a new failure entry\n * rather than mutating the prior one — the timeline is preserved so\n * consumers can render attempt count or last-attempt-time UX.\n * 6. Per-runtime-instance scope. The aggregator lives on\n * `ExecutionRuntimeState`, not globally. Two execution views mounted in\n * the same app do not share failed-action state.\n * 7. Shell is informative, not restrictive. Capturing a failure does\n * not alter execution lifecycle, block transitions, or veto subsequent\n * `execute()` calls. UX (banner vs. toast vs. inline retry button) is\n * owned by the consumer.\n /\nexport enum ExecutionFailedActionScope {\n EMBEDDED_CONTENT = 'embedded-content',\n LOCAL_PANE = 'local-pane',\n CUSTOM = 'custom',\n /\n Slice K — failure originated from the participation-prefetch tier\n * (the shell-data-hydrator producer hooks). Carries a discriminant\n * `prefetchKey: string` so the shell can auto-prune on the next\n * successful prefetch with the same key. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the producer-side contract.\n /\n PARTICIPATION_PREFETCH = 'participation-prefetch',\n}\n\n/\n Common shape for every captured failure entry, regardless of scope.\n \n Intentionally not exported on its own — consumers use the\n * `ExecutionFailedAction` discriminated union below so the type system\n * enforces \"LOCAL_PANE entries carry a `paneId`\" without requiring\n * defensive `!== undefined` checks at every read site.\n /\ninterface ExecutionFailedActionBase {\n /\n Stable id for the failed action entry. Generated by the shell at capture\n * time, distinct from the originating `actionRuntimeId` so re-attempts\n * produce fresh entries.\n /\n failureRuntimeId: string;\n /\n Mirrors `ExecutionPendingAction.actionRuntimeId` for `execute()`-captured\n * failures. Absent for consumer-authored captures via\n * `execution.errors.capture(...)` that did not originate from the shell's\n * `execute()` bridge.\n \n Informational only — no first-class selector today. The shell\n * does not expose a `errors.findByOriginatingAction(actionRuntimeId)`\n * helper because no in-tree consumer needs it yet (the dogfood derives\n * `latestFailure` purely from `capturedAt`). Consumers that want to\n * correlate a failure entry to a specific pending action can do so via\n * `errors.isErrored((entry) => entry.originatingActionRuntimeId === id)`\n * or by filtering `errors.failedActions` directly. A dedicated selector\n * will be added the first time per-button retry UX dogfoods this field.\n /\n originatingActionRuntimeId?: string;\n /* Canonical operation path key, when available. /\n operationPathKey?: string;\n /* Resource the failed action targeted, when available. /\n resourceType?: string;\n /* Operation identifier the failed action invoked, when available. /\n operationId?: string;\n /* `Date.now()` when capture happened. /\n capturedAt: number;\n /\n Mirrors the originating pending action's `startedAt` so consumers can\n * render duration-aware UX. Absent for consumer-authored captures.\n /\n startedAt?: number;\n /\n Raw error reference. Consumers may inspect `error.wildoError` (set by\n * `wildo-http-client`) for typed metadata, but the shell does not normalize\n * the shape — keeping the original preserves whatever upstream provenance\n * the rejected value carried (stack traces for `Error` instances, typed\n * payloads for HTTP-marked errors, primitive values when the call site\n * threw something exotic).\n /\n error: unknown;\n /\n Optional human-readable label (\"Could not load todo graph\"). Consumers\n * may render it inline; the shell treats it as opaque metadata.\n /\n label?: string;\n /\n `true` when the originating error carries the `wildoError` marker\n * stamped by `wildo-http-client.handleHttpError`. That marker means an\n * upstream layer already classified the error and applied its configured\n * behavior (potentially emitting `ERROR_OCCURED`, potentially staying\n * silent if the request opted in or the per-status policy disabled\n * emission). The shell defers to that processing instead of re-bridging.\n /\n markedByHttpClient: boolean;\n /\n `true` when this capture site invoked `errorManagement.handleError(...)`\n * itself. The shell sets this:\n * - `true` for `execute()` rejections without `markedByHttpClient`.\n * - `false` for `execute()` rejections WITH `markedByHttpClient` (deferred\n * to upstream).\n * - `true`/`false` per `bridgeToCanonicalBus` opt-out for\n * `execution.errors.capture(...)` calls.\n \n Note: `bridgedByExecutionShell === true` does not strictly guarantee\n * an `ERROR_OCCURED` event was emitted — `errorManagement.handleError`\n * may itself drop emission for silent contexts. Consumers needing the\n * ground truth of \"was a canonical event emitted\" should subscribe to\n * `FrontendEvents.ERROR_OCCURED` directly rather than infer it from this\n * flag.\n /\n bridgedByExecutionShell: boolean;\n}\n\n/\n Discriminated union of captured failure entries.\n \n The discriminant `scope` makes \"`paneId` is required for `LOCAL_PANE`\n * entries, absent on the others\" a compile-time invariant. Combined with\n * the runtime assertion `assertExecutionFailedActionShape`, dynamic\n * callers (test mocks, deserialized state, authored dictionaries) cannot\n * collapse the variants either.\n /\nexport type ExecutionFailedAction =\n \| (ExecutionFailedActionBase & { scope: ExecutionFailedActionScope.EMBEDDED_CONTENT })\n \| (ExecutionFailedActionBase & { scope: ExecutionFailedActionScope.LOCAL_PANE; paneId: string })\n \| (ExecutionFailedActionBase & { scope: ExecutionFailedActionScope.CUSTOM })\n \| (ExecutionFailedActionBase & {\n scope: ExecutionFailedActionScope.PARTICIPATION_PREFETCH;\n /\n Stable consumer-authored identity for the prefetch unit. Distinct\n * from the per-run `prefetchRuntimeId` (which rotates on every fire);\n * the same `prefetchKey` is reused across consecutive settle cycles\n * of the same logical prefetch so the shell's\n * `clearFailedActionsForPrefetchKey(key)` verb can drop matching\n * entries on the next successful settle.\n /\n prefetchKey: string;\n });\n\n/\n Belt-and-braces runtime check that an `ExecutionFailedAction` matches\n * its discriminant invariants. The type layer already enforces these for\n * statically-shaped callers; this assertion exists for dynamic callers\n * (test mocks, deserialized payloads, authored dictionaries) where the\n * type may have been widened via `as`/`unknown`.\n \n Throws synchronously when a `LOCAL_PANE` entry is captured without a\n * `paneId` — the only invariant that cannot be expressed any other way.\n /\nexport function assertExecutionFailedActionShape(failedAction: ExecutionFailedAction): void {\n if (failedAction.scope === ExecutionFailedActionScope.LOCAL_PANE) {\n const candidate = failedAction as { paneId?: unknown };\n if (typeof candidate.paneId !== 'string' \|\| candidate.paneId.length === 0) {\n throw new Error(\n '[ExecutionView] LOCAL_PANE-scoped failed action must carry a non-empty `paneId` '\n + 'so the shell can auto-clear it on pane transitions. '\n + 'Use scope=CUSTOM for failures that should outlive any single pane.',\n );\n }\n }\n if (failedAction.scope === ExecutionFailedActionScope.PARTICIPATION_PREFETCH) {\n const candidate = failedAction as { prefetchKey?: unknown };\n if (typeof candidate.prefetchKey !== 'string' \|\| candidate.prefetchKey.length === 0) {\n throw new Error(\n '[ExecutionView] PARTICIPATION_PREFETCH-scoped failed action must carry a '\n + 'non-empty `prefetchKey` so the shell can auto-clear it on the next '\n + 'successful prefetch settle for the same key. '\n + 'Use scope=CUSTOM for failures that should outlive any single prefetch unit.',\n );\n }\n }\n}\n/* @wildo_source:part:end saas.frontend.execution-view.failure-handling-contract /\n\n/\n Minimal execution navigation contract for the first routed host slice.\n \n The execution runtime deliberately reuses the existing navigation controller\n * instead of introducing a second navigation stack owner.\n /\n/\n Navigation primitives exposed to the execution shell and the unified\n * `useExecution()` API. These are the two handling modes plus the local-pane\n * seam — intentionally small so the shell owns a single decision point per\n * action verb.\n /\nexport interface ExecutionNavigationValue {\n /* Yield the target navigation content to the app router (\"parent\" stack). /\n delegateToParent: (options: {\n content: NavigationContent;\n urlPath?: string;\n contextResourceIdentifiers?: Record<string, string>;\n relationshipTransition?: NavigateOptions['relationshipTransition'];\n initiator?: Omit<NavigationInitiatorContext, 'sourceZone'>;\n }) => void;\n /* Mount the embeddable content inside the execution shell's single slot. /\n openEmbeddedContent: (embeddedContent: ExecutionEmbeddedContentState) => void;\n /* Clear the execution shell's embedded-content slot. /\n closeEmbeddedContent: () => void;\n openLocalPane: (paneId: string, payload?: unknown) => void;\n closeLocalPane: () => void;\n /\n Register a shell-tracked pending action. Internal plumbing — app code\n * must not call this directly; `useExecution()`'s `execute()` verb wires\n * it from the `doOperation()` bridge. See the loading-aggregation anchor.\n /\n beginPendingAction: (action: ExecutionPendingAction) => void;\n /* Clear a shell-tracked pending action by `actionRuntimeId`. /\n endPendingAction: (actionRuntimeId: string) => void;\n /\n Register a shell-tracked participation prefetch. Internal plumbing\n * intended for future framework-owned async participation resolvers;\n * no in-tree producer calls it today because participation resolution\n * is fully synchronous. See the\n * `loading-aggregation.participation-prefetch` sub-anchor for the\n * contract (intent classification, settle-always-clears, non-empty\n * `participationRefs`, …) — the runtime guard\n * `assertExecutionPendingPrefetchShape` runs at this seam so dynamic\n * callers cannot bypass shape invariants.\n /\n beginParticipationPrefetch: (prefetch: ExecutionPendingPrefetch) => void;\n /\n Clear a shell-tracked participation prefetch by `prefetchRuntimeId`.\n * No-op when the id is unknown (mirrors `endPendingAction`).\n /\n endParticipationPrefetch: (prefetchRuntimeId: string) => void;\n /\n Register or update a dirty-state marker. Re-marking the same `markerId`\n * is idempotent (replaces the entry). See the dirty-state-contract anchor.\n /\n markDirty: (marker: ExecutionDirtyMarker) => void;\n /* Clear a dirty-state marker by `markerId`. No-op if the id is unknown. /\n clearDirty: (markerId: string) => void;\n /\n Drop every registered dirty marker. Mirrors `clearAllFailedActions` so\n * the shell's two consumer-authored aggregator tiers (dirty / errors)\n * expose the same bulk-clear primitive. Typical use: a top-level \"Discard\n * all unsaved edits\" affordance in the consumer view.\n /\n clearAllDirty: () => void;\n /\n Capture a failed action entry (shell-internal plumbing for `execute()`'s\n * catch path, or consumer-driven via `execution.errors.capture`). See the\n * failure-handling-contract anchor.\n /\n captureFailedAction: (failedAction: ExecutionFailedAction) => void;\n /* Clear a captured failure by `failureRuntimeId`. No-op if unknown. /\n clearFailedAction: (failureRuntimeId: string) => void;\n /* Clear every captured failure. /\n clearAllFailedActions: () => void;\n /\n Drop every `PARTICIPATION_PREFETCH`-scoped failure whose `prefetchKey`\n * matches `prefetchKey`. Internal plumbing called by the Slice K\n * producer hooks (`useExecutionParticipationPrefetch` /\n * `useExecutionParticipationDataPrefetch`) on a successful settle so a\n * stale failure indicator from a previous attempt clears the moment the\n * next attempt succeeds — no consumer cleanup required. Other scopes\n * are untouched. See the\n * `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the full producer contract and\n * `pruneFailedActionsForPrefetchSettlement` in\n * `execution-failure-handling.utils.ts` for the prune semantics.\n /\n clearFailedActionsForPrefetchKey: (prefetchKey: string) => void;\n}\n\n/\n Minimal runtime context carried by the framework-owned execution host.\n \n This establishes the first real execution runtime seam:\n * - view definition resolution\n * - scope/context propagation\n * - stable runtime-instance identity\n * - conservative anchor resolution from explicit declared bindings\n * - minimal framework-owned local pane state\n * - reuse of the shared `doOperation()` abstraction\n * - delegation to the existing navigation controller\n /\nexport interface ExecutionRuntimeContextValue {\n viewDefinition: ExecutionViewDefinition;\n contextResourceIdentifiers?: Record<string, string>;\n runtimeInstanceId: string;\n navigationZone: NavigationZone;\n doOperation: ResourceRegistryContextType['doOperation'];\n navigation: ExecutionNavigationValue;\n anchor: ExecutionAnchor \| null;\n participations: Record<string, ResolvedExecutionParticipation>;\n runtimeState: ExecutionRuntimeState;\n}\n\nexport interface ExecutionRuntimeProviderProps {\n children: React.ReactNode;\n viewDefinition: ExecutionViewDefinition;\n contextResourceIdentifiers?: Record<string, string>;\n runtimeInstanceId: string;\n navigationZone: NavigationZone;\n doOperation: ResourceRegistryContextType['doOperation'];\n navigation: ExecutionNavigationValue;\n anchor: ExecutionAnchor \| null;\n participations: Record<string, ResolvedExecutionParticipation>;\n runtimeState: ExecutionRuntimeState;\n}\n\nexport const ExecutionRuntimeContext = createContext<ExecutionRuntimeContextValue \| undefined>(undefined);\n\n/\n Asserts that a resolved `ExecutionRuntimeContext` value is present.\n \n Intentionally written as a non-hook assertion so consumers can inline\n * `useContext(ExecutionRuntimeContext)` at the call site without paying for a\n * dedicated custom hook wrapper. This keeps the public hook surface minimal\n * while preserving the \"must be used inside a provider\" safety check.\n */\nexport function assertExecutionRuntimeContext(\n context: ExecutionRuntimeContextValue \| undefined,\n): ExecutionRuntimeContextValue {\n if (!context) {\n throw new Error(\n 'Execution runtime context must be used within an ExecutionRuntimeProvider.',\n );\n }\n\n return context;\n}\n\nexport const ExecutionRuntimeProvider: React.FC<ExecutionRuntimeProviderProps> = ({\n children,\n viewDefinition,\n contextResourceIdentifiers,\n runtimeInstanceId,\n navigationZone,\n doOperation,\n navigation,\n anchor,\n participations,\n runtimeState,\n}) => {\n const value = useMemo<ExecutionRuntimeContextValue>(() => ({\n viewDefinition,\n contextResourceIdentifiers,\n runtimeInstanceId,\n navigationZone,\n doOperation,\n navigation,\n anchor,\n participations,\n runtimeState,\n }), [viewDefinition, contextResourceIdentifiers, runtimeInstanceId, navigationZone, doOperation, navigation, anchor, participations, runtimeState]);\n\n return (\n <ExecutionRuntimeContext.Provider value={value}>\n {children}\n </ExecutionRuntimeContext.Provider>\n );\n};\n"]}

package/dist/esm/core/execution/execution-anchor.utils.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"execution-anchor.utils.d.ts","sourceRoot":"","sources":["~~../../../../../~~src/core/execution/execution-anchor.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,wDAAwD,CAAC;AAEhE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,2BAA2B,CAAC;AAYnC;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,uBAAuB,EACvC,kCAAkC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1D,eAAe,GAAG,IAAI,CAqCxB"}
1	+ {"version":3,"file":"execution-anchor.utils.d.ts","sourceRoot":"","sources":["../../../../src/core/execution/execution-anchor.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,wDAAwD,CAAC;AAEhE,OAAO,EAEL,KAAK,eAAe,EACrB,MAAM,2BAA2B,CAAC;AAYnC;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,uBAAuB,EACvC,kCAAkC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1D,eAAe,GAAG,IAAI,CAqCxB"}

package/dist/esm/core/execution/execution-anchor.utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"execution-anchor.utils.js","sourceRoot":"","sources":["~~../../../../../~~src/core/execution/execution-anchor.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gCAAgC,GAEjC,MAAM,wDAAwD,CAAC;AAEhE,OAAO,EACL,qBAAqB,GAEtB,MAAM,2BAA2B,CAAC;AAEnC,SAAS,uBAAuB,CAC9B,WAAgE;IAEhE,OAAO,OAAO,WAAW,CAAC,YAAY,KAAK,QAAQ,IAAI,WAAW,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;AAC7F,CAAC;AAED,SAAS,wBAAwB,CAAC,WAA+D;IAC/F,OAAO,WAAW,CAAC,eAAe,IAAI,WAAW,CAAC,YAAY,CAAC;AACjE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CACpC,cAAuC,EACvC,kCAA2D;IAE3D,IAAI,CAAC,cAAc,CAAC,MAAM,IAAI,CAAC,kCAAkC,EAAE,CAAC;QAClE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,MAAM,CAAC;IACrD,MAAM,UAAU,GAAG,kCAAkC,CAAC,UAAU,CAAC,CAAC;IAElE,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,KAAK,gCAAgC,CAAC,2BAA2B;QAC1F,CAAC,CAAC,cAAc,CAAC,2BAA2B;QAC5C,CAAC,CAAC,cAAc,CAAC,8BAA8B,CAAC;IAElD,MAAM,OAAO,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE;QAC1D,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,EAAE,CAAC;YAC1C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,qBAAqB,GAAG,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpE,OAAO,qBAAqB,KAAK,UAAU,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,gBAAgB,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,YAAY;QACzC,cAAc,EAAE,UAAU;QAC1B,UAAU;QACV,MAAM,EAAE,MAAM,KAAK,gCAAgC,CAAC,2BAA2B;YAC7E,CAAC,CAAC,qBAAqB,CAAC,2BAA2B;YACnD,CAAC,CAAC,qBAAqB,CAAC,+BAA+B;KAC1D,CAAC;AACJ,CAAC","sourcesContent":["import {\n ExecutionViewAnchorBindingSource,\n type ExecutionViewDefinition,\n} from '~wildo-frontend-lib/core/config/execution-view.schemas';\n\nimport {\n ExecutionAnchorSource,\n type ExecutionAnchor,\n} from './ExecutionRuntimeContext';\n\nfunction hasConcreteResourceType(\n requirement: { resourceType?: string; foreignKeyField?: string },\n): requirement is { resourceType: string; foreignKeyField?: string } {\n return typeof requirement.resourceType === 'string' && requirement.resourceType.length > 0;\n}\n\nfunction getRequirementBindingKey(requirement: { resourceType: string; foreignKeyField?: string }): string {\n return requirement.foreignKeyField ?? requirement.resourceType;\n}\n\n/*\n Resolves the declared execution anchor from explicit navigation-time bindings.\n \n Important constraints:\n * - the anchor contract must point to one stable declared binding key\n * - merged ambient scope is intentionally ignored here\n * - duplicate declared binding keys fail closed instead of picking by order\n */\nexport function resolveExecutionAnchor(\n viewDefinition: ExecutionViewDefinition,\n explicitContextResourceIdentifiers?: Record<string, string>,\n): ExecutionAnchor \| null {\n if (!viewDefinition.anchor \|\| !explicitContextResourceIdentifiers) {\n return null;\n }\n\n const { bindingKey, source } = viewDefinition.anchor;\n const resourceId = explicitContextResourceIdentifiers[bindingKey];\n\n if (!resourceId) {\n return null;\n }\n\n const requirements = source === ExecutionViewAnchorBindingSource.PARENT_RESOURCE_REQUIREMENT\n ? viewDefinition.parentResourcesRequirements\n : viewDefinition.additionalResourceRequirements;\n\n const matches = (requirements ?? []).filter((requirement) => {\n if (!hasConcreteResourceType(requirement)) {\n return false;\n }\n\n const requirementBindingKey = getRequirementBindingKey(requirement);\n return requirementBindingKey === bindingKey;\n });\n\n if (matches.length !== 1) {\n return null;\n }\n\n return {\n mainResourceType: matches[0].resourceType,\n mainResourceId: resourceId,\n bindingKey,\n source: source === ExecutionViewAnchorBindingSource.PARENT_RESOURCE_REQUIREMENT\n ? ExecutionAnchorSource.PARENT_RESOURCE_REQUIREMENT\n : ExecutionAnchorSource.ADDITIONAL_RESOURCE_REQUIREMENT,\n };\n}\n"]}
1	+ {"version":3,"file":"execution-anchor.utils.js","sourceRoot":"","sources":["../../../../src/core/execution/execution-anchor.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gCAAgC,GAEjC,MAAM,wDAAwD,CAAC;AAEhE,OAAO,EACL,qBAAqB,GAEtB,MAAM,2BAA2B,CAAC;AAEnC,SAAS,uBAAuB,CAC9B,WAAgE;IAEhE,OAAO,OAAO,WAAW,CAAC,YAAY,KAAK,QAAQ,IAAI,WAAW,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;AAC7F,CAAC;AAED,SAAS,wBAAwB,CAAC,WAA+D;IAC/F,OAAO,WAAW,CAAC,eAAe,IAAI,WAAW,CAAC,YAAY,CAAC;AACjE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CACpC,cAAuC,EACvC,kCAA2D;IAE3D,IAAI,CAAC,cAAc,CAAC,MAAM,IAAI,CAAC,kCAAkC,EAAE,CAAC;QAClE,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,GAAG,cAAc,CAAC,MAAM,CAAC;IACrD,MAAM,UAAU,GAAG,kCAAkC,CAAC,UAAU,CAAC,CAAC;IAElE,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,MAAM,YAAY,GAAG,MAAM,KAAK,gCAAgC,CAAC,2BAA2B;QAC1F,CAAC,CAAC,cAAc,CAAC,2BAA2B;QAC5C,CAAC,CAAC,cAAc,CAAC,8BAA8B,CAAC;IAElD,MAAM,OAAO,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,EAAE;QAC1D,IAAI,CAAC,uBAAuB,CAAC,WAAW,CAAC,EAAE,CAAC;YAC1C,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,qBAAqB,GAAG,wBAAwB,CAAC,WAAW,CAAC,CAAC;QACpE,OAAO,qBAAqB,KAAK,UAAU,CAAC;IAC9C,CAAC,CAAC,CAAC;IAEH,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO;QACL,gBAAgB,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,YAAY;QACzC,cAAc,EAAE,UAAU;QAC1B,UAAU;QACV,MAAM,EAAE,MAAM,KAAK,gCAAgC,CAAC,2BAA2B;YAC7E,CAAC,CAAC,qBAAqB,CAAC,2BAA2B;YACnD,CAAC,CAAC,qBAAqB,CAAC,+BAA+B;KAC1D,CAAC;AACJ,CAAC","sourcesContent":["import {\n ExecutionViewAnchorBindingSource,\n type ExecutionViewDefinition,\n} from '~wildo-frontend-lib/core/config/execution-view.schemas';\n\nimport {\n ExecutionAnchorSource,\n type ExecutionAnchor,\n} from './ExecutionRuntimeContext';\n\nfunction hasConcreteResourceType(\n requirement: { resourceType?: string; foreignKeyField?: string },\n): requirement is { resourceType: string; foreignKeyField?: string } {\n return typeof requirement.resourceType === 'string' && requirement.resourceType.length > 0;\n}\n\nfunction getRequirementBindingKey(requirement: { resourceType: string; foreignKeyField?: string }): string {\n return requirement.foreignKeyField ?? requirement.resourceType;\n}\n\n/*\n Resolves the declared execution anchor from explicit navigation-time bindings.\n \n Important constraints:\n * - the anchor contract must point to one stable declared binding key\n * - merged ambient scope is intentionally ignored here\n * - duplicate declared binding keys fail closed instead of picking by order\n */\nexport function resolveExecutionAnchor(\n viewDefinition: ExecutionViewDefinition,\n explicitContextResourceIdentifiers?: Record<string, string>,\n): ExecutionAnchor \| null {\n if (!viewDefinition.anchor \|\| !explicitContextResourceIdentifiers) {\n return null;\n }\n\n const { bindingKey, source } = viewDefinition.anchor;\n const resourceId = explicitContextResourceIdentifiers[bindingKey];\n\n if (!resourceId) {\n return null;\n }\n\n const requirements = source === ExecutionViewAnchorBindingSource.PARENT_RESOURCE_REQUIREMENT\n ? viewDefinition.parentResourcesRequirements\n : viewDefinition.additionalResourceRequirements;\n\n const matches = (requirements ?? []).filter((requirement) => {\n if (!hasConcreteResourceType(requirement)) {\n return false;\n }\n\n const requirementBindingKey = getRequirementBindingKey(requirement);\n return requirementBindingKey === bindingKey;\n });\n\n if (matches.length !== 1) {\n return null;\n }\n\n return {\n mainResourceType: matches[0].resourceType,\n mainResourceId: resourceId,\n bindingKey,\n source: source === ExecutionViewAnchorBindingSource.PARENT_RESOURCE_REQUIREMENT\n ? ExecutionAnchorSource.PARENT_RESOURCE_REQUIREMENT\n : ExecutionAnchorSource.ADDITIONAL_RESOURCE_REQUIREMENT,\n };\n}\n"]}

package/dist/esm/core/execution/execution-dirty-markers.utils.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"execution-dirty-markers.utils.d.ts","sourceRoot":"","sources":["~~../../../../../~~src/core/execution/execution-dirty-markers.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,yBAAyB,EACzB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,qBAAqB,CAAC,cAAc,CAAC,EAC/C,KAAK,EAAE,yBAAyB,GAC/B,qBAAqB,CAAC,cAAc,CAAC,CAWvC;AAED;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,qBAAqB,CAAC,cAAc,CAAC,EAC/C,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,qBAAqB,CAAC,cAAc,CAAC,CAcvC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,8BAA8B,GAAG;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,CACA;IAAE,KAAK,EAAE,yBAAyB,CAAC,gBAAgB,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,yBAAyB,CAAC,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,KAAK,EAAE,yBAAyB,CAAC,MAAM,CAAA;CAAE,CAC9C,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,8BAA8B,GACpC,oBAAoB,CActB"}
1	+ {"version":3,"file":"execution-dirty-markers.utils.d.ts","sourceRoot":"","sources":["../../../../src/core/execution/execution-dirty-markers.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,yBAAyB,EACzB,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;GAWG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,qBAAqB,CAAC,cAAc,CAAC,EAC/C,KAAK,EAAE,yBAAyB,GAC/B,qBAAqB,CAAC,cAAc,CAAC,CAWvC;AAED;;;;;;;;GAQG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,qBAAqB,CAAC,cAAc,CAAC,EAC/C,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,qBAAqB,CAAC,cAAc,CAAC,CAcvC;AAED;;;;;;GAMG;AACH,MAAM,MAAM,8BAA8B,GAAG;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,CACA;IAAE,KAAK,EAAE,yBAAyB,CAAC,gBAAgB,CAAA;CAAE,GACrD;IAAE,KAAK,EAAE,yBAAyB,CAAC,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAC/D;IAAE,KAAK,EAAE,yBAAyB,CAAC,MAAM,CAAA;CAAE,CAC9C,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,8BAA8B,GACpC,oBAAoB,CActB"}

package/dist/esm/core/execution/execution-dirty-markers.utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"execution-dirty-markers.utils.js","sourceRoot":"","sources":["~~../../../../../~~src/core/execution/execution-dirty-markers.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,GAG1B,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,+BAA+B,CAC7C,QAA+C,EAC/C,KAAgC;IAEhC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,IAAI,GAA0C,EAAE,CAAC;IACvD,KAAK,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1D,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;YAC3B,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IAC1B,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AACnC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kCAAkC,CAChD,QAA+C,EAC/C,UAAyB;IAEzB,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,IAAI,GAA0C,EAAE,CAAC;IACvD,KAAK,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1D,IACE,MAAM,CAAC,KAAK,KAAK,yBAAyB,CAAC,UAAU;eAClD,MAAM,CAAC,MAAM,KAAK,UAAU,EAC/B,CAAC;YACD,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IAC1B,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AACnC,CAAC;AAmBD,MAAM,UAAU,yBAAyB,CACvC,KAAqC;IAErC,MAAM,UAAU,GAAG;QACjB,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,GAAG,EAAE;QACtC,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC;IACF,IAAI,KAA2B,CAAC;IAChC,IAAI,KAAK,CAAC,KAAK,KAAK,yBAAyB,CAAC,UAAU,EAAE,CAAC;QACzD,KAAK,GAAG,EAAE,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;IACtE,CAAC;SAAM,CAAC;QACN,KAAK,GAAG,EAAE,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC;IACD,+BAA+B,CAAC,KAAK,CAAC,CAAC;IACvC,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import {\n assertExecutionDirtyMarkerShape,\n ExecutionDirtyMarkerScope,\n type ExecutionDirtyMarker,\n type ExecutionRuntimeState,\n} from './ExecutionRuntimeContext';\n\n/*\n Drop every dirty marker whose `scope` matches `scope`. Used on\n * embedded-content transitions (open replace or close) to honor the\n * dirty-state contract's auto-cleanup invariant — the publisher for those\n * markers is, by definition, gone once the slot changes.\n \n Returns the same reference when no marker matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n \n See the `saas.frontend.execution-view.dirty-state-contract` anchor in\n * `ExecutionRuntimeContext.tsx` for the full contract.\n /\nexport function pruneDirtyMarkersForScopeChange(\n previous: ExecutionRuntimeState['dirtyMarkers'],\n scope: ExecutionDirtyMarkerScope,\n): ExecutionRuntimeState['dirtyMarkers'] {\n let mutated = false;\n const next: ExecutionRuntimeState['dirtyMarkers'] = {};\n for (const [markerId, marker] of Object.entries(previous)) {\n if (marker.scope === scope) {\n mutated = true;\n continue;\n }\n next[markerId] = marker;\n }\n return mutated ? next : previous;\n}\n\n/\n Drop `LOCAL_PANE`-scoped markers whose `paneId` does not match the\n * currently-active `nextPaneId` (`null` when the pane closes). `CUSTOM`-\n * and `EMBEDDED_CONTENT`-scoped markers are untouched; only the pane tier\n * is auto-cleaned here.\n \n Returns the same reference when no marker matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n /\nexport function pruneDirtyMarkersForPaneTransition(\n previous: ExecutionRuntimeState['dirtyMarkers'],\n nextPaneId: string \| null,\n): ExecutionRuntimeState['dirtyMarkers'] {\n let mutated = false;\n const next: ExecutionRuntimeState['dirtyMarkers'] = {};\n for (const [markerId, marker] of Object.entries(previous)) {\n if (\n marker.scope === ExecutionDirtyMarkerScope.LOCAL_PANE\n && marker.paneId !== nextPaneId\n ) {\n mutated = true;\n continue;\n }\n next[markerId] = marker;\n }\n return mutated ? next : previous;\n}\n\n/\n Convenience test helper shared between unit tests and callers that want to\n * stamp a marker without authoring `markedAt` inline.\n \n Discriminated input enforces \"`paneId` is required for `LOCAL_PANE`\n * markers\" at compile time and runtime (`assertExecutionDirtyMarkerShape`).\n */\nexport type BuildExecutionDirtyMarkerInput = {\n markerId: string;\n markedAt?: number;\n label?: string;\n} & (\n \| { scope: ExecutionDirtyMarkerScope.EMBEDDED_CONTENT }\n \| { scope: ExecutionDirtyMarkerScope.LOCAL_PANE; paneId: string }\n \| { scope: ExecutionDirtyMarkerScope.CUSTOM }\n);\n\nexport function buildExecutionDirtyMarker(\n input: BuildExecutionDirtyMarkerInput,\n): ExecutionDirtyMarker {\n const baseFields = {\n markerId: input.markerId,\n markedAt: input.markedAt ?? Date.now(),\n label: input.label,\n };\n let built: ExecutionDirtyMarker;\n if (input.scope === ExecutionDirtyMarkerScope.LOCAL_PANE) {\n built = { ...baseFields, scope: input.scope, paneId: input.paneId };\n } else {\n built = { ...baseFields, scope: input.scope };\n }\n assertExecutionDirtyMarkerShape(built);\n return built;\n}\n"]}
1	+ {"version":3,"file":"execution-dirty-markers.utils.js","sourceRoot":"","sources":["../../../../src/core/execution/execution-dirty-markers.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,+BAA+B,EAC/B,yBAAyB,GAG1B,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,+BAA+B,CAC7C,QAA+C,EAC/C,KAAgC;IAEhC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,IAAI,GAA0C,EAAE,CAAC;IACvD,KAAK,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1D,IAAI,MAAM,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;YAC3B,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IAC1B,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AACnC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,kCAAkC,CAChD,QAA+C,EAC/C,UAAyB;IAEzB,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,MAAM,IAAI,GAA0C,EAAE,CAAC;IACvD,KAAK,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC1D,IACE,MAAM,CAAC,KAAK,KAAK,yBAAyB,CAAC,UAAU;eAClD,MAAM,CAAC,MAAM,KAAK,UAAU,EAC/B,CAAC;YACD,OAAO,GAAG,IAAI,CAAC;YACf,SAAS;QACX,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC;IAC1B,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC;AACnC,CAAC;AAmBD,MAAM,UAAU,yBAAyB,CACvC,KAAqC;IAErC,MAAM,UAAU,GAAG;QACjB,QAAQ,EAAE,KAAK,CAAC,QAAQ;QACxB,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,IAAI,CAAC,GAAG,EAAE;QACtC,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC;IACF,IAAI,KAA2B,CAAC;IAChC,IAAI,KAAK,CAAC,KAAK,KAAK,yBAAyB,CAAC,UAAU,EAAE,CAAC;QACzD,KAAK,GAAG,EAAE,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC;IACtE,CAAC;SAAM,CAAC;QACN,KAAK,GAAG,EAAE,GAAG,UAAU,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;IAChD,CAAC;IACD,+BAA+B,CAAC,KAAK,CAAC,CAAC;IACvC,OAAO,KAAK,CAAC;AACf,CAAC","sourcesContent":["import {\n assertExecutionDirtyMarkerShape,\n ExecutionDirtyMarkerScope,\n type ExecutionDirtyMarker,\n type ExecutionRuntimeState,\n} from './ExecutionRuntimeContext';\n\n/*\n Drop every dirty marker whose `scope` matches `scope`. Used on\n * embedded-content transitions (open replace or close) to honor the\n * dirty-state contract's auto-cleanup invariant — the publisher for those\n * markers is, by definition, gone once the slot changes.\n \n Returns the same reference when no marker matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n \n See the `saas.frontend.execution-view.dirty-state-contract` anchor in\n * `ExecutionRuntimeContext.tsx` for the full contract.\n /\nexport function pruneDirtyMarkersForScopeChange(\n previous: ExecutionRuntimeState['dirtyMarkers'],\n scope: ExecutionDirtyMarkerScope,\n): ExecutionRuntimeState['dirtyMarkers'] {\n let mutated = false;\n const next: ExecutionRuntimeState['dirtyMarkers'] = {};\n for (const [markerId, marker] of Object.entries(previous)) {\n if (marker.scope === scope) {\n mutated = true;\n continue;\n }\n next[markerId] = marker;\n }\n return mutated ? next : previous;\n}\n\n/\n Drop `LOCAL_PANE`-scoped markers whose `paneId` does not match the\n * currently-active `nextPaneId` (`null` when the pane closes). `CUSTOM`-\n * and `EMBEDDED_CONTENT`-scoped markers are untouched; only the pane tier\n * is auto-cleaned here.\n \n Returns the same reference when no marker matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n /\nexport function pruneDirtyMarkersForPaneTransition(\n previous: ExecutionRuntimeState['dirtyMarkers'],\n nextPaneId: string \| null,\n): ExecutionRuntimeState['dirtyMarkers'] {\n let mutated = false;\n const next: ExecutionRuntimeState['dirtyMarkers'] = {};\n for (const [markerId, marker] of Object.entries(previous)) {\n if (\n marker.scope === ExecutionDirtyMarkerScope.LOCAL_PANE\n && marker.paneId !== nextPaneId\n ) {\n mutated = true;\n continue;\n }\n next[markerId] = marker;\n }\n return mutated ? next : previous;\n}\n\n/\n Convenience test helper shared between unit tests and callers that want to\n * stamp a marker without authoring `markedAt` inline.\n \n Discriminated input enforces \"`paneId` is required for `LOCAL_PANE`\n * markers\" at compile time and runtime (`assertExecutionDirtyMarkerShape`).\n */\nexport type BuildExecutionDirtyMarkerInput = {\n markerId: string;\n markedAt?: number;\n label?: string;\n} & (\n \| { scope: ExecutionDirtyMarkerScope.EMBEDDED_CONTENT }\n \| { scope: ExecutionDirtyMarkerScope.LOCAL_PANE; paneId: string }\n \| { scope: ExecutionDirtyMarkerScope.CUSTOM }\n);\n\nexport function buildExecutionDirtyMarker(\n input: BuildExecutionDirtyMarkerInput,\n): ExecutionDirtyMarker {\n const baseFields = {\n markerId: input.markerId,\n markedAt: input.markedAt ?? Date.now(),\n label: input.label,\n };\n let built: ExecutionDirtyMarker;\n if (input.scope === ExecutionDirtyMarkerScope.LOCAL_PANE) {\n built = { ...baseFields, scope: input.scope, paneId: input.paneId };\n } else {\n built = { ...baseFields, scope: input.scope };\n }\n assertExecutionDirtyMarkerShape(built);\n return built;\n}\n"]}

package/dist/esm/core/execution/execution-failure-handling.utils.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"execution-failure-handling.utils.d.ts","sourceRoot":"","sources":["~~../../../../../~~src/core/execution/execution-failure-handling.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,0BAA0B,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,EAChD,KAAK,EAAE,0BAA0B,GAChC,qBAAqB,CAAC,eAAe,CAAC,CAWxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,EAChD,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,qBAAqB,CAAC,eAAe,CAAC,CAcxC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMjE;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,+BAA+B,GAAG;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,GAAG,CACA;IAAE,KAAK,CAAC,EAAE,0BAA0B,CAAC,MAAM,CAAA;CAAE,GAC7C;IAAE,KAAK,EAAE,0BAA0B,CAAC,gBAAgB,CAAA;CAAE,GACtD;IAAE,KAAK,EAAE,0BAA0B,CAAC,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,KAAK,EAAE,0BAA0B,CAAC,sBAAsB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CACpF,CAAC;AAEF,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,+BAA+B,GACrC,qBAAqB,CAiCvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,EAChD,WAAW,EAAE,MAAM,GAClB,qBAAqB,CAAC,eAAe,CAAC,CAcxC"}
1	+ {"version":3,"file":"execution-failure-handling.utils.d.ts","sourceRoot":"","sources":["../../../../src/core/execution/execution-failure-handling.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,0BAA0B,EAC1B,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC3B,MAAM,2BAA2B,CAAC;AAEnC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,EAChD,KAAK,EAAE,0BAA0B,GAChC,qBAAqB,CAAC,eAAe,CAAC,CAWxC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,EAChD,UAAU,EAAE,MAAM,GAAG,IAAI,GACxB,qBAAqB,CAAC,eAAe,CAAC,CAcxC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAMjE;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,+BAA+B,GAAG;IAC5C,gBAAgB,EAAE,MAAM,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC,GAAG,CACA;IAAE,KAAK,CAAC,EAAE,0BAA0B,CAAC,MAAM,CAAA;CAAE,GAC7C;IAAE,KAAK,EAAE,0BAA0B,CAAC,gBAAgB,CAAA;CAAE,GACtD;IAAE,KAAK,EAAE,0BAA0B,CAAC,UAAU,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,KAAK,EAAE,0BAA0B,CAAC,sBAAsB,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CACpF,CAAC;AAEF,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,+BAA+B,GACrC,qBAAqB,CAiCvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,qBAAqB,CAAC,eAAe,CAAC,EAChD,WAAW,EAAE,MAAM,GAClB,qBAAqB,CAAC,eAAe,CAAC,CAcxC"}

package/dist/esm/core/execution/execution-failure-handling.utils.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"execution-failure-handling.utils.js","sourceRoot":"","sources":["../../../../../src/core/execution/execution-failure-handling.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n assertExecutionFailedActionShape,\n ExecutionFailedActionScope,\n type ExecutionFailedAction,\n type ExecutionRuntimeState,\n} from './ExecutionRuntimeContext';\n\n/*\n Drop every captured failure whose `scope` matches `scope`. Used on\n * embedded-content transitions (open replace or close) to honor the\n * failure-handling contract's auto-cleanup invariant — the publisher for\n * those failures is, by definition, gone once the slot changes.\n \n Mirrors `pruneDirtyMarkersForScopeChange` exactly so consumers reason about\n * dirty markers and failed actions with the same scope vocabulary.\n \n Returns the same reference when no entry matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n \n See the `saas.frontend.execution-view.failure-handling-contract` anchor in\n * `ExecutionRuntimeContext.tsx` for the full contract.\n /\nexport function pruneFailedActionsForScopeChange(\n previous: ExecutionRuntimeState['failedActions'],\n scope: ExecutionFailedActionScope,\n): ExecutionRuntimeState['failedActions'] {\n let mutated = false;\n const next: ExecutionRuntimeState['failedActions'] = {};\n for (const [failureRuntimeId, failedAction] of Object.entries(previous)) {\n if (failedAction.scope === scope) {\n mutated = true;\n continue;\n }\n next[failureRuntimeId] = failedAction;\n }\n return mutated ? next : previous;\n}\n\n/\n Drop `LOCAL_PANE`-scoped failures whose `paneId` does not match the\n * currently-active `nextPaneId` (`null` when the pane closes). `CUSTOM`- and\n * `EMBEDDED_CONTENT`-scoped failures are untouched; only the pane tier is\n * auto-cleaned here.\n \n Mirrors `pruneDirtyMarkersForPaneTransition` exactly. The discriminated\n * union on `ExecutionFailedAction` guarantees that any `LOCAL_PANE` entry\n * carries a `paneId`, so the comparison is meaningful — there is no\n * \"missing paneId silently falls through\" failure mode.\n \n Returns the same reference when no entry matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n /\nexport function pruneFailedActionsForPaneTransition(\n previous: ExecutionRuntimeState['failedActions'],\n nextPaneId: string \| null,\n): ExecutionRuntimeState['failedActions'] {\n let mutated = false;\n const next: ExecutionRuntimeState['failedActions'] = {};\n for (const [failureRuntimeId, failedAction] of Object.entries(previous)) {\n if (\n failedAction.scope === ExecutionFailedActionScope.LOCAL_PANE\n && failedAction.paneId !== nextPaneId\n ) {\n mutated = true;\n continue;\n }\n next[failureRuntimeId] = failedAction;\n }\n return mutated ? next : previous;\n}\n\n/\n Detects whether the rejected error carries the `wildoError` marker that\n * `wildo-http-client.handleHttpError(...)` attaches to every HTTP-layer\n * failure. The marker means an upstream layer *already classified and\n processed** this error (built a `WildoError_Frontend`, applied the\n * configured per-status behavior, conditionally emitted `ERROR_OCCURED`\n * based on the request's `silent` flag and the per-status `emitEvent`\n * policy).\n \n The execution shell uses this to decide whether to re-bridge the error\n * via `errorManagement.handleError(...)`: when the marker is present, the\n * shell defers to that upstream processing instead of re-emitting. That\n * decision honors a consumer-requested silence even when no event was\n * actually emitted — the shell does not paper over intentional silence by\n * re-emitting on its own.\n \n The duck-type check requires `wildoError` to be a non-null object so a\n * plain `{ wildoError: 'string' }` value cannot accidentally trigger the\n * deferral path.\n /\nexport function isErrorMarkedByHttpClient(error: unknown): boolean {\n if (!error \|\| typeof error !== 'object') {\n return false;\n }\n const candidate = error as { wildoError?: unknown };\n return typeof candidate.wildoError === 'object' && candidate.wildoError !== null;\n}\n\n/\n Convenience helper for tests and `execution.errors.capture(...)` callers\n * that want to stamp a failed-action entry without authoring `capturedAt`\n * inline. Defaults `scope` to `CUSTOM`, `markedByHttpClient` to the result\n * of `isErrorMarkedByHttpClient(error)`, and `bridgedByExecutionShell` to\n * `false` so consumer captures are explicit about whether they pre-bridged.\n \n Discriminated input enforces \"`paneId` is required for `LOCAL_PANE`\n * entries\" at compile time and runtime (`assertExecutionFailedActionShape`).\n /\nexport type BuildExecutionFailedActionInput = {\n failureRuntimeId: string;\n error: unknown;\n originatingActionRuntimeId?: string;\n operationPathKey?: string;\n resourceType?: string;\n operationId?: string;\n capturedAt?: number;\n startedAt?: number;\n label?: string;\n markedByHttpClient?: boolean;\n bridgedByExecutionShell?: boolean;\n} & (\n \| { scope?: ExecutionFailedActionScope.CUSTOM }\n \| { scope: ExecutionFailedActionScope.EMBEDDED_CONTENT }\n \| { scope: ExecutionFailedActionScope.LOCAL_PANE; paneId: string }\n \| { scope: ExecutionFailedActionScope.PARTICIPATION_PREFETCH; prefetchKey: string }\n);\n\nexport function buildExecutionFailedAction(\n input: BuildExecutionFailedActionInput,\n): ExecutionFailedAction {\n const markedByHttpClient = input.markedByHttpClient ?? isErrorMarkedByHttpClient(input.error);\n const bridgedByExecutionShell = input.bridgedByExecutionShell ?? false;\n const baseFields = {\n failureRuntimeId: input.failureRuntimeId,\n error: input.error,\n originatingActionRuntimeId: input.originatingActionRuntimeId,\n operationPathKey: input.operationPathKey,\n resourceType: input.resourceType,\n operationId: input.operationId,\n capturedAt: input.capturedAt ?? Date.now(),\n startedAt: input.startedAt,\n label: input.label,\n markedByHttpClient,\n bridgedByExecutionShell,\n };\n // Narrow on the discriminant `input.scope` itself rather than a hoisted\n // copy, so TypeScript flows the union narrowing into each branch and\n // `input.paneId` / `input.prefetchKey` resolve without a cast. Mirrors\n // `buildExecutionDirtyMarker` exactly — same job, same idiom, no escape\n // hatch into `as`.\n let built: ExecutionFailedAction;\n if (input.scope === ExecutionFailedActionScope.LOCAL_PANE) {\n built = { ...baseFields, scope: input.scope, paneId: input.paneId };\n } else if (input.scope === ExecutionFailedActionScope.EMBEDDED_CONTENT) {\n built = { ...baseFields, scope: input.scope };\n } else if (input.scope === ExecutionFailedActionScope.PARTICIPATION_PREFETCH) {\n built = { ...baseFields, scope: input.scope, prefetchKey: input.prefetchKey };\n } else {\n built = { ...baseFields, scope: ExecutionFailedActionScope.CUSTOM };\n }\n assertExecutionFailedActionShape(built);\n return built;\n}\n\n/\n Drop `PARTICIPATION_PREFETCH`-scoped failures whose `prefetchKey` matches\n * the just-settled prefetch unit. Other scopes are untouched.\n \n Called by the Slice K hooks (`useExecutionParticipationPrefetch` /\n * `useExecutionParticipationDataPrefetch`) on a successful settle, so a\n * stale failure indicator from a previous attempt clears the moment the\n * next attempt succeeds — no consumer plumbing required.\n \n Returns the same reference when no entry matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n \n See the `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the producer-side contract this helper serves, and the\n * `saas.frontend.execution-view.failure-handling-contract` anchor for the\n * scope-vocabulary it slots into.\n */\nexport function pruneFailedActionsForPrefetchSettlement(\n previous: ExecutionRuntimeState['failedActions'],\n prefetchKey: string,\n): ExecutionRuntimeState['failedActions'] {\n let mutated = false;\n const next: ExecutionRuntimeState['failedActions'] = {};\n for (const [failureRuntimeId, failedAction] of Object.entries(previous)) {\n if (\n failedAction.scope === ExecutionFailedActionScope.PARTICIPATION_PREFETCH\n && failedAction.prefetchKey === prefetchKey\n ) {\n mutated = true;\n continue;\n }\n next[failureRuntimeId] = failedAction;\n }\n return mutated ? next : previous;\n}\n"]}
1	+ {"version":3,"file":"execution-failure-handling.utils.js","sourceRoot":"","sources":["../../../../src/core/execution/execution-failure-handling.utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n assertExecutionFailedActionShape,\n ExecutionFailedActionScope,\n type ExecutionFailedAction,\n type ExecutionRuntimeState,\n} from './ExecutionRuntimeContext';\n\n/*\n Drop every captured failure whose `scope` matches `scope`. Used on\n * embedded-content transitions (open replace or close) to honor the\n * failure-handling contract's auto-cleanup invariant — the publisher for\n * those failures is, by definition, gone once the slot changes.\n \n Mirrors `pruneDirtyMarkersForScopeChange` exactly so consumers reason about\n * dirty markers and failed actions with the same scope vocabulary.\n \n Returns the same reference when no entry matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n \n See the `saas.frontend.execution-view.failure-handling-contract` anchor in\n * `ExecutionRuntimeContext.tsx` for the full contract.\n /\nexport function pruneFailedActionsForScopeChange(\n previous: ExecutionRuntimeState['failedActions'],\n scope: ExecutionFailedActionScope,\n): ExecutionRuntimeState['failedActions'] {\n let mutated = false;\n const next: ExecutionRuntimeState['failedActions'] = {};\n for (const [failureRuntimeId, failedAction] of Object.entries(previous)) {\n if (failedAction.scope === scope) {\n mutated = true;\n continue;\n }\n next[failureRuntimeId] = failedAction;\n }\n return mutated ? next : previous;\n}\n\n/\n Drop `LOCAL_PANE`-scoped failures whose `paneId` does not match the\n * currently-active `nextPaneId` (`null` when the pane closes). `CUSTOM`- and\n * `EMBEDDED_CONTENT`-scoped failures are untouched; only the pane tier is\n * auto-cleaned here.\n \n Mirrors `pruneDirtyMarkersForPaneTransition` exactly. The discriminated\n * union on `ExecutionFailedAction` guarantees that any `LOCAL_PANE` entry\n * carries a `paneId`, so the comparison is meaningful — there is no\n * \"missing paneId silently falls through\" failure mode.\n \n Returns the same reference when no entry matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n /\nexport function pruneFailedActionsForPaneTransition(\n previous: ExecutionRuntimeState['failedActions'],\n nextPaneId: string \| null,\n): ExecutionRuntimeState['failedActions'] {\n let mutated = false;\n const next: ExecutionRuntimeState['failedActions'] = {};\n for (const [failureRuntimeId, failedAction] of Object.entries(previous)) {\n if (\n failedAction.scope === ExecutionFailedActionScope.LOCAL_PANE\n && failedAction.paneId !== nextPaneId\n ) {\n mutated = true;\n continue;\n }\n next[failureRuntimeId] = failedAction;\n }\n return mutated ? next : previous;\n}\n\n/\n Detects whether the rejected error carries the `wildoError` marker that\n * `wildo-http-client.handleHttpError(...)` attaches to every HTTP-layer\n * failure. The marker means an upstream layer *already classified and\n processed** this error (built a `WildoError_Frontend`, applied the\n * configured per-status behavior, conditionally emitted `ERROR_OCCURED`\n * based on the request's `silent` flag and the per-status `emitEvent`\n * policy).\n \n The execution shell uses this to decide whether to re-bridge the error\n * via `errorManagement.handleError(...)`: when the marker is present, the\n * shell defers to that upstream processing instead of re-emitting. That\n * decision honors a consumer-requested silence even when no event was\n * actually emitted — the shell does not paper over intentional silence by\n * re-emitting on its own.\n \n The duck-type check requires `wildoError` to be a non-null object so a\n * plain `{ wildoError: 'string' }` value cannot accidentally trigger the\n * deferral path.\n /\nexport function isErrorMarkedByHttpClient(error: unknown): boolean {\n if (!error \|\| typeof error !== 'object') {\n return false;\n }\n const candidate = error as { wildoError?: unknown };\n return typeof candidate.wildoError === 'object' && candidate.wildoError !== null;\n}\n\n/\n Convenience helper for tests and `execution.errors.capture(...)` callers\n * that want to stamp a failed-action entry without authoring `capturedAt`\n * inline. Defaults `scope` to `CUSTOM`, `markedByHttpClient` to the result\n * of `isErrorMarkedByHttpClient(error)`, and `bridgedByExecutionShell` to\n * `false` so consumer captures are explicit about whether they pre-bridged.\n \n Discriminated input enforces \"`paneId` is required for `LOCAL_PANE`\n * entries\" at compile time and runtime (`assertExecutionFailedActionShape`).\n /\nexport type BuildExecutionFailedActionInput = {\n failureRuntimeId: string;\n error: unknown;\n originatingActionRuntimeId?: string;\n operationPathKey?: string;\n resourceType?: string;\n operationId?: string;\n capturedAt?: number;\n startedAt?: number;\n label?: string;\n markedByHttpClient?: boolean;\n bridgedByExecutionShell?: boolean;\n} & (\n \| { scope?: ExecutionFailedActionScope.CUSTOM }\n \| { scope: ExecutionFailedActionScope.EMBEDDED_CONTENT }\n \| { scope: ExecutionFailedActionScope.LOCAL_PANE; paneId: string }\n \| { scope: ExecutionFailedActionScope.PARTICIPATION_PREFETCH; prefetchKey: string }\n);\n\nexport function buildExecutionFailedAction(\n input: BuildExecutionFailedActionInput,\n): ExecutionFailedAction {\n const markedByHttpClient = input.markedByHttpClient ?? isErrorMarkedByHttpClient(input.error);\n const bridgedByExecutionShell = input.bridgedByExecutionShell ?? false;\n const baseFields = {\n failureRuntimeId: input.failureRuntimeId,\n error: input.error,\n originatingActionRuntimeId: input.originatingActionRuntimeId,\n operationPathKey: input.operationPathKey,\n resourceType: input.resourceType,\n operationId: input.operationId,\n capturedAt: input.capturedAt ?? Date.now(),\n startedAt: input.startedAt,\n label: input.label,\n markedByHttpClient,\n bridgedByExecutionShell,\n };\n // Narrow on the discriminant `input.scope` itself rather than a hoisted\n // copy, so TypeScript flows the union narrowing into each branch and\n // `input.paneId` / `input.prefetchKey` resolve without a cast. Mirrors\n // `buildExecutionDirtyMarker` exactly — same job, same idiom, no escape\n // hatch into `as`.\n let built: ExecutionFailedAction;\n if (input.scope === ExecutionFailedActionScope.LOCAL_PANE) {\n built = { ...baseFields, scope: input.scope, paneId: input.paneId };\n } else if (input.scope === ExecutionFailedActionScope.EMBEDDED_CONTENT) {\n built = { ...baseFields, scope: input.scope };\n } else if (input.scope === ExecutionFailedActionScope.PARTICIPATION_PREFETCH) {\n built = { ...baseFields, scope: input.scope, prefetchKey: input.prefetchKey };\n } else {\n built = { ...baseFields, scope: ExecutionFailedActionScope.CUSTOM };\n }\n assertExecutionFailedActionShape(built);\n return built;\n}\n\n/\n Drop `PARTICIPATION_PREFETCH`-scoped failures whose `prefetchKey` matches\n * the just-settled prefetch unit. Other scopes are untouched.\n \n Called by the Slice K hooks (`useExecutionParticipationPrefetch` /\n * `useExecutionParticipationDataPrefetch`) on a successful settle, so a\n * stale failure indicator from a previous attempt clears the moment the\n * next attempt succeeds — no consumer plumbing required.\n \n Returns the same reference when no entry matches, so React state setters\n * can short-circuit and avoid redundant re-renders.\n \n See the `loading-aggregation.participation-prefetch.shell-data-hydrator`\n * sub-anchor for the producer-side contract this helper serves, and the\n * `saas.frontend.execution-view.failure-handling-contract` anchor for the\n * scope-vocabulary it slots into.\n */\nexport function pruneFailedActionsForPrefetchSettlement(\n previous: ExecutionRuntimeState['failedActions'],\n prefetchKey: string,\n): ExecutionRuntimeState['failedActions'] {\n let mutated = false;\n const next: ExecutionRuntimeState['failedActions'] = {};\n for (const [failureRuntimeId, failedAction] of Object.entries(previous)) {\n if (\n failedAction.scope === ExecutionFailedActionScope.PARTICIPATION_PREFETCH\n && failedAction.prefetchKey === prefetchKey\n ) {\n mutated = true;\n continue;\n }\n next[failureRuntimeId] = failedAction;\n }\n return mutated ? next : previous;\n}\n"]}

package/dist/esm/core/execution/execution-outcome-emission.utils.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"execution-outcome-emission.utils.d.ts","sourceRoot":"","sources":["~~../../../../../~~src/core/execution/execution-outcome-emission.utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC3B,MAAM,yDAAyD,CAAC;AAcjE,OAAO,KAAK,EACV,gCAAgC,EAChC,uCAAuC,EACvC,gCAAgC,EAChC,yBAAyB,EAC1B,MAAM,+DAA+D,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,WAAW,qCAAqC;IACpD,UAAU,CAAC,EAAE,SAAS,uCAAuC,EAAE,CAAC;CACjE;AAED,KAAK,MAAM,GAAG,CAAC,CAAC,SAAS,cAAc,EACrC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAC9B,IAAI,CAAC;AAEV,MAAM,WAAW,kCAAkC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,gCAAgC,GAAG,qCAAqC,CAAC;IAC1F,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,uCAAuC,CAAC;IACnD,eAAe,EAAE,gCAAgC,CAAC;IAClD;;;;OAIG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,kCAAkC,GACzC,IAAI,CAwIN"}
1	+ {"version":3,"file":"execution-outcome-emission.utils.d.ts","sourceRoot":"","sources":["../../../../src/core/execution/execution-outcome-emission.utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,EAC3B,MAAM,yDAAyD,CAAC;AAcjE,OAAO,KAAK,EACV,gCAAgC,EAChC,uCAAuC,EACvC,gCAAgC,EAChC,yBAAyB,EAC1B,MAAM,+DAA+D,CAAC;AAEvE;;;;;;GAMG;AACH,MAAM,WAAW,qCAAqC;IACpD,UAAU,CAAC,EAAE,SAAS,uCAAuC,EAAE,CAAC;CACjE;AAED,KAAK,MAAM,GAAG,CAAC,CAAC,SAAS,cAAc,EACrC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,qBAAqB,CAAC,CAAC,CAAC,KAC9B,IAAI,CAAC;AAEV,MAAM,WAAW,kCAAkC;IACjD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,gCAAgC,GAAG,qCAAqC,CAAC;IAC1F,QAAQ,CAAC,EAAE,yBAAyB,CAAC;IACrC,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,uCAAuC,CAAC;IACnD,eAAe,EAAE,gCAAgC,CAAC;IAClD;;;;OAIG;IACH,oBAAoB,EAAE,OAAO,CAAC;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,kCAAkC,GACzC,IAAI,CAwIN"}