@wildo-ai/saas-frontend-lib 1.1.5 → 1.1.6

package/dist/esm/core/navigation/navigation-clean-break.frontend.utils.js

@@ -35,8 +35,27 @@ export function emitOverlayBreakoutCleanup(emit, source) {
  */
 export function emitFreshStartNavigationCleanup(emit, source) {
     NavigationUtils.beginTransaction(source);
-    emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.SECONDARY });
-    emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.COMPANION });
+    /*
+     * ─── A PERSISTENT pane survives this too, and the contract is what says so ──────────────────────
+     *
+     * `TransitionConfig.persistent` promises "the split zone persists when the source zone's content
+     * changes", and the shape it exists for is a reference kept open WHILE YOU MOVE AROUND — a thread,
+     * a terminal, a doc. Moving around is sidebar navigation, and every sidebar click is a fresh start,
+     * so clearing unconditionally here left the mechanism working only for drill-ins inside one
+     * primary destination. `persistent` only ever targets COMPANION, so the clear it could not survive
+     * was the one it most needed to.
+     *
+     * `preservePersistent` is carried on the payload and read by the reducer, which is the only place
+     * that can see whether the zone's top entry is persistent — this module emits, it does not read
+     * state. A PROMOTE is the same answer: it breaks out of the structural flow, and a reference panel
+     * is not part of that flow.
+     *
+     * What still closes a persistent pane: its own dismiss control, `goBack` in that zone, and a
+     * direct `CLEAR_ZONE`. Persistence means "do not close me because something else changed", never
+     * "I cannot be closed".
+     */
+    emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.SECONDARY, preservePersistent: true });
+    emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.COMPANION, preservePersistent: true });
     emit(FrontendEvents.NAVIGATION_CLOSE, { zone: NavigationZone.OVERLAY });
 }
 /**

package/dist/esm/core/navigation/navigation-clean-break.frontend.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"navigation-clean-break.frontend.utils.js","sourceRoot":"","sources":["../../../../../src/core/navigation/navigation-clean-break.frontend.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yDAAyD,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAYtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAA+C,EAC/C,MAAuC;IAEvC,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,cAAc,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,+BAA+B,CAC7C,IAA+C,EAC/C,MAAkC;IAElC,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,cAAc,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,kBAAkB,CAAC,SAAS,EAAE,CAAC,CAAC;IACnF,IAAI,CAAC,cAAc,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,kBAAkB,CAAC,SAAS,EAAE,CAAC,CAAC;IACnF,IAAI,CAAC,cAAc,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B,CAAC,MAI1C;IACC,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,GAAG,GAAG,EAAE,GAAG,MAAM,CAAC;IAExD,0BAA0B,CAAC;QACzB,IAAI;QACJ,cAAc;QACd,IAAI,EAAE,QAAQ;QACd,MAAM,EAAE,iBAAiB;KAC1B,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CAAC,MAK1C;IACC,MAAM,EACJ,IAAI,EACJ,cAAc,EACd,IAAI,EACJ,MAAM,GAAG,iBAAiB,GAC3B,GAAG,MAAM,CAAC;IAEX,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,cAAc,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,kBAAkB,CAAC,OAAO,EAAE,CAAC,CAAC;IACjF,+BAA+B,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAC;IAC9D,cAAc,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["import { FrontendEvents } from '~wildo-frontend-lib/core/events/events.frontend.schemas';\nimport { NavigationZoneName } from '@wildo-ai/saas-models';\nimport { NavigationUtils } from './navigation.utils';\nimport { NavigationZone } from './navigation.schemas';\n\nexport type FreshStartNavigationSource =\n  | 'app_level_navigation'\n  | 'promote_navigation';\n\nexport type OverlayBreakoutNavigationSource = 'overlay_breakout_navigation';\n\nexport type StrongResetNavigationSource =\n  | 'home_navigation'\n  | 'path_navigation';\n\n/**\n * Close the overlay when content it launched lands in a STRUCTURAL zone.\n *\n * An overlay is a floating layer over the layout, and the layout underneath is inert while it is\n * open. So content that starts inside the overlay and is placed in PRIMARY / SECONDARY / COMPANION\n * has left the overlay behind: the person asked for that content, and what they get is the overlay\n * they were already looking at, with the thing they asked for rendered beneath its own backdrop.\n *\n * Measured 2026-09-22 on the Wonder Todos todo READ overlay (#1511). Clicking the overlay's own\n * `Edit` action moved the URL from `…/todos` to `…/todos/<id>` and put `input[name=\"title\"]` in the\n * document — while the dialog count stayed at ONE and that dialog did not contain the form. Every\n * click on it was intercepted by `[data-slot=dialog-overlay]`, so the edit form was unreachable\n * until the overlay was dismissed by hand.\n *\n * This is NOT {@link emitFreshStartNavigationCleanup}: breaking out of an overlay says nothing\n * about the SECONDARY and COMPANION zones of the page underneath, which are the context the person\n * is returning to. Only the overlay closes.\n *\n * PROMOTE is excluded by the caller because it already performs the stronger reset.\n */\nexport function emitOverlayBreakoutCleanup(\n  emit: (event: string, payload: unknown) => void,\n  source: OverlayBreakoutNavigationSource,\n): void {\n  NavigationUtils.beginTransaction(source);\n  emit(FrontendEvents.NAVIGATION_CLOSE, { zone: NavigationZone.OVERLAY });\n}\n\n/**\n * Clear every non-primary surface that should not survive a fresh-start navigation.\n *\n * App-level and PROMOTE navigations both intentionally break out of the current\n * structural flow. The reset must therefore stay centralized so secondary,\n * companion, and overlay cleanup cannot drift apart between call sites.\n */\nexport function emitFreshStartNavigationCleanup(\n  emit: (event: string, payload: unknown) => void,\n  source: FreshStartNavigationSource,\n): void {\n  NavigationUtils.beginTransaction(source);\n  emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.SECONDARY });\n  emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.COMPANION });\n  emit(FrontendEvents.NAVIGATION_CLOSE, { zone: NavigationZone.OVERLAY });\n}\n\n/**\n * Home/error recovery is a stronger reset than generic app-level replacement:\n * there is no controller-managed PRIMARY replacement entry to overwrite the\n * current root content, so PRIMARY must be cleared explicitly before routing to\n * the engine home path.\n */\nexport function navigateHomeWithFreshStart(params: {\n  emit: (event: string, payload: unknown) => void;\n  routerNavigate: (path: string, options?: { replace?: boolean }) => void;\n  homePath?: string;\n}): void {\n  const { emit, routerNavigate, homePath = '/' } = params;\n\n  navigatePathWithFreshStart({\n    emit,\n    routerNavigate,\n    path: homePath,\n    source: 'home_navigation',\n  });\n}\n\n/**\n * Some shell-owned recovery paths need a stronger reset before routing to a\n * concrete URL. They do not go through controller-owned PRIMARY replacement, so\n * PRIMARY must be cleared explicitly before React Router changes location.\n */\nexport function navigatePathWithFreshStart(params: {\n  emit: (event: string, payload: unknown) => void;\n  routerNavigate: (path: string, options?: { replace?: boolean }) => void;\n  path: string;\n  source?: StrongResetNavigationSource;\n}): void {\n  const {\n    emit,\n    routerNavigate,\n    path,\n    source = 'path_navigation',\n  } = params;\n\n  NavigationUtils.beginTransaction(source);\n  emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.PRIMARY });\n  emitFreshStartNavigationCleanup(emit, 'app_level_navigation');\n  routerNavigate(path, { replace: true });\n}\n"]}
+{"version":3,"file":"navigation-clean-break.frontend.utils.js","sourceRoot":"","sources":["../../../../../src/core/navigation/navigation-clean-break.frontend.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,yDAAyD,CAAC;AACzF,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAYtD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,0BAA0B,CACxC,IAA+C,EAC/C,MAAuC;IAEvC,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,cAAc,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,+BAA+B,CAC7C,IAA+C,EAC/C,MAAkC;IAElC,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACzC;;;;;;;;;;;;;;;;;;OAkBG;IACH,IAAI,CAAC,cAAc,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7G,IAAI,CAAC,cAAc,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,kBAAkB,CAAC,SAAS,EAAE,kBAAkB,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7G,IAAI,CAAC,cAAc,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,cAAc,CAAC,OAAO,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,0BAA0B,CAAC,MAI1C;IACC,MAAM,EAAE,IAAI,EAAE,cAAc,EAAE,QAAQ,GAAG,GAAG,EAAE,GAAG,MAAM,CAAC;IAExD,0BAA0B,CAAC;QACzB,IAAI;QACJ,cAAc;QACd,IAAI,EAAE,QAAQ;QACd,MAAM,EAAE,iBAAiB;KAC1B,CAAC,CAAC;AACL,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,0BAA0B,CAAC,MAK1C;IACC,MAAM,EACJ,IAAI,EACJ,cAAc,EACd,IAAI,EACJ,MAAM,GAAG,iBAAiB,GAC3B,GAAG,MAAM,CAAC;IAEX,eAAe,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACzC,IAAI,CAAC,cAAc,CAAC,qBAAqB,EAAE,EAAE,IAAI,EAAE,kBAAkB,CAAC,OAAO,EAAE,CAAC,CAAC;IACjF,+BAA+B,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAC;IAC9D,cAAc,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;AAC1C,CAAC","sourcesContent":["import { FrontendEvents } from '~wildo-frontend-lib/core/events/events.frontend.schemas';\nimport { NavigationZoneName } from '@wildo-ai/saas-models';\nimport { NavigationUtils } from './navigation.utils';\nimport { NavigationZone } from './navigation.schemas';\n\nexport type FreshStartNavigationSource =\n  | 'app_level_navigation'\n  | 'promote_navigation';\n\nexport type OverlayBreakoutNavigationSource = 'overlay_breakout_navigation';\n\nexport type StrongResetNavigationSource =\n  | 'home_navigation'\n  | 'path_navigation';\n\n/**\n * Close the overlay when content it launched lands in a STRUCTURAL zone.\n *\n * An overlay is a floating layer over the layout, and the layout underneath is inert while it is\n * open. So content that starts inside the overlay and is placed in PRIMARY / SECONDARY / COMPANION\n * has left the overlay behind: the person asked for that content, and what they get is the overlay\n * they were already looking at, with the thing they asked for rendered beneath its own backdrop.\n *\n * Measured 2026-09-22 on the Wonder Todos todo READ overlay (#1511). Clicking the overlay's own\n * `Edit` action moved the URL from `…/todos` to `…/todos/<id>` and put `input[name=\"title\"]` in the\n * document — while the dialog count stayed at ONE and that dialog did not contain the form. Every\n * click on it was intercepted by `[data-slot=dialog-overlay]`, so the edit form was unreachable\n * until the overlay was dismissed by hand.\n *\n * This is NOT {@link emitFreshStartNavigationCleanup}: breaking out of an overlay says nothing\n * about the SECONDARY and COMPANION zones of the page underneath, which are the context the person\n * is returning to. Only the overlay closes.\n *\n * PROMOTE is excluded by the caller because it already performs the stronger reset.\n */\nexport function emitOverlayBreakoutCleanup(\n  emit: (event: string, payload: unknown) => void,\n  source: OverlayBreakoutNavigationSource,\n): void {\n  NavigationUtils.beginTransaction(source);\n  emit(FrontendEvents.NAVIGATION_CLOSE, { zone: NavigationZone.OVERLAY });\n}\n\n/**\n * Clear every non-primary surface that should not survive a fresh-start navigation.\n *\n * App-level and PROMOTE navigations both intentionally break out of the current\n * structural flow. The reset must therefore stay centralized so secondary,\n * companion, and overlay cleanup cannot drift apart between call sites.\n */\nexport function emitFreshStartNavigationCleanup(\n  emit: (event: string, payload: unknown) => void,\n  source: FreshStartNavigationSource,\n): void {\n  NavigationUtils.beginTransaction(source);\n  /*\n   * ─── A PERSISTENT pane survives this too, and the contract is what says so ──────────────────────\n   *\n   * `TransitionConfig.persistent` promises \"the split zone persists when the source zone's content\n   * changes\", and the shape it exists for is a reference kept open WHILE YOU MOVE AROUND — a thread,\n   * a terminal, a doc. Moving around is sidebar navigation, and every sidebar click is a fresh start,\n   * so clearing unconditionally here left the mechanism working only for drill-ins inside one\n   * primary destination. `persistent` only ever targets COMPANION, so the clear it could not survive\n   * was the one it most needed to.\n   *\n   * `preservePersistent` is carried on the payload and read by the reducer, which is the only place\n   * that can see whether the zone's top entry is persistent — this module emits, it does not read\n   * state. A PROMOTE is the same answer: it breaks out of the structural flow, and a reference panel\n   * is not part of that flow.\n   *\n   * What still closes a persistent pane: its own dismiss control, `goBack` in that zone, and a\n   * direct `CLEAR_ZONE`. Persistence means \"do not close me because something else changed\", never\n   * \"I cannot be closed\".\n   */\n  emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.SECONDARY, preservePersistent: true });\n  emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.COMPANION, preservePersistent: true });\n  emit(FrontendEvents.NAVIGATION_CLOSE, { zone: NavigationZone.OVERLAY });\n}\n\n/**\n * Home/error recovery is a stronger reset than generic app-level replacement:\n * there is no controller-managed PRIMARY replacement entry to overwrite the\n * current root content, so PRIMARY must be cleared explicitly before routing to\n * the engine home path.\n */\nexport function navigateHomeWithFreshStart(params: {\n  emit: (event: string, payload: unknown) => void;\n  routerNavigate: (path: string, options?: { replace?: boolean }) => void;\n  homePath?: string;\n}): void {\n  const { emit, routerNavigate, homePath = '/' } = params;\n\n  navigatePathWithFreshStart({\n    emit,\n    routerNavigate,\n    path: homePath,\n    source: 'home_navigation',\n  });\n}\n\n/**\n * Some shell-owned recovery paths need a stronger reset before routing to a\n * concrete URL. They do not go through controller-owned PRIMARY replacement, so\n * PRIMARY must be cleared explicitly before React Router changes location.\n */\nexport function navigatePathWithFreshStart(params: {\n  emit: (event: string, payload: unknown) => void;\n  routerNavigate: (path: string, options?: { replace?: boolean }) => void;\n  path: string;\n  source?: StrongResetNavigationSource;\n}): void {\n  const {\n    emit,\n    routerNavigate,\n    path,\n    source = 'path_navigation',\n  } = params;\n\n  NavigationUtils.beginTransaction(source);\n  emit(FrontendEvents.NAVIGATION_CLEAR_ZONE, { zone: NavigationZoneName.PRIMARY });\n  emitFreshStartNavigationCleanup(emit, 'app_level_navigation');\n  routerNavigate(path, { replace: true });\n}\n"]}

package/dist/esm/core/navigation/navigation-controller-internals.d.ts

@@ -0,0 +1,71 @@
+/**
+ * The two things every layer of the navigation controller needs, and neither of which belongs to any
+ * one of them: the debug channel, and the one function that writes the browser URL.
+ *
+ * Extracted 2026-09-25 when `useNavigationController.ts` was split — 2,322 lines holding click
+ * resolution, URL reconciliation, the ancestor cascade, clean breaks, dismiss and the emit bridge in
+ * one module. Measured across the seam, the ROUTER-SYNC half used exactly THREE symbols from the
+ * controller half (`logDebug` and the two cascade functions), which is what made the split cheap
+ * enough to be worth doing at all.
+ *
+ * ## The debug type name is DELIBERATELY still `useNavigationController`
+ *
+ * `logger.debugByType` keys on this string, and it is what an operator or a test types to turn the
+ * channel on (`setDebugTypeLogging('useNavigationController', true)`). Giving each split module its
+ * own name would be finer-grained and would silently stop every existing toggle from reaching the
+ * router-sync logs — a split is not the moment to change what a diagnostic switch covers.
+ */
+import type { useNavigate } from 'react-router-dom';
+import { ResourceOperationFrontendSurface } from '@wildo-ai/saas-models';
+export declare const logDebug: (message: string, context?: Record<string, unknown>) => void;
+/**
+ * Update the browser URL via React Router's navigate function, so React Router's
+ * `useLocation` hook updates. Everything derived from `useLocation` depends on
+ * this: deep-link shareability, back-button state, and the sidebar's
+ * most-specific-active highlight (`useSidebarBehavior` reads `useLocation`).
+ *
+ * ORDERING (why the transaction): the URL→state reconstruction hooks
+ * (`useRouterSync`, `useViewRouterSync`, `useEnginePageRouterSync`,
+ * `useSettingsHubOverlaySync`) observe `location` changes and rebuild zone state
+ * from the URL — UNLESS the target zone already owns the URL, OR a navigation
+ * transaction is active. A controller-driven navigation emits the zone-state
+ * entry (event bus → `setState`) and THEN changes the URL; if the URL change is
+ * observed before that state has committed, those hooks would re-derive stale
+ * content (the race the old code papered over). We therefore open (or extend) a
+ * navigation transaction so they skip during the commit window and re-validate
+ * via their transaction-aware retry once state has committed — by then the
+ * emitted entry owns the URL, so they no-op. This mirrors
+ * `navigatePathWithFreshStart` / `emitFreshStartNavigationCleanup`, which already
+ * pair `beginTransaction` with a synchronous `routerNavigate`.
+ *
+ * NOT PAINT-GATED (why not requestAnimationFrame): rAF callbacks are throttled to
+ * ~0fps in occluded / backgrounded / throttled tabs, so a deferred
+ * `routerNavigate` could be stranded indefinitely — zone content (event bus →
+ * state) swaps instantly while the URL, sidebar highlight, and back-button state
+ * lag until the tab is refocused (reproduced live: composite-view content visible
+ * while `location.pathname` stayed stale for 8+ seconds, converging only on tab
+ * activation). The transaction guard fills the ordering role rAF was standing in
+ * for, without the paint dependency.
+ */
+/**
+ * Only a resource operation DECLARED `ADDRESSABLE` owns a browser URL.
+ *
+ * The URL builders are surface-blind — `resolveResourceUrl` happily produces a
+ * pattern URL for any URL-bearing variant, including EMBEDDED (notAddressable)
+ * ones — but `AppRouter` registers routes for ADDRESSABLE operations only, so
+ * writing such a URL to the browser strands refresh / deep-link on the router
+ * 404 (seen live 2026-08-19: a breadcrumb click on the EMBEDDED organizations
+ * READ rewrote the URL to `/organizations/:id`, a route that does not exist).
+ * EMBEDDED content navigates as pure zone/overlay content instead.
+ *
+ * An `undefined` surface (synthetic/legacy operation objects that never passed
+ * through the registry's Step-2.5 posture resolution) keeps the historical
+ * URL-writing behavior — only an EXPLICIT non-addressable declaration opts out.
+ */
+export declare function resourceOperationOwnsBrowserUrl(operation: {
+    operationFrontendConfig?: {
+        surface?: ResourceOperationFrontendSurface;
+    };
+} | undefined): boolean;
+export declare function updateBrowserUrl(routerNavigate: ReturnType<typeof useNavigate>, urlPath: string, replace?: boolean): void;
+//# sourceMappingURL=navigation-controller-internals.d.ts.map

package/dist/esm/core/navigation/navigation-controller-internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-controller-internals.d.ts","sourceRoot":"","sources":["../../../../../src/core/navigation/navigation-controller-internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAOzE,eAAO,MAAM,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAoD,CAAC;AAGpI;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE;IAAE,uBAAuB,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,gCAAgC,CAAA;KAAE,CAAA;CAAE,GAAG,SAAS,GAClG,OAAO,CAIT;AAED,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,EAC9C,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,OAAe,GACvB,IAAI,CAUN"}

package/dist/esm/core/navigation/navigation-controller-internals.js

@@ -0,0 +1,84 @@
+/**
+ * The two things every layer of the navigation controller needs, and neither of which belongs to any
+ * one of them: the debug channel, and the one function that writes the browser URL.
+ *
+ * Extracted 2026-09-25 when `useNavigationController.ts` was split — 2,322 lines holding click
+ * resolution, URL reconciliation, the ancestor cascade, clean breaks, dismiss and the emit bridge in
+ * one module. Measured across the seam, the ROUTER-SYNC half used exactly THREE symbols from the
+ * controller half (`logDebug` and the two cascade functions), which is what made the split cheap
+ * enough to be worth doing at all.
+ *
+ * ## The debug type name is DELIBERATELY still `useNavigationController`
+ *
+ * `logger.debugByType` keys on this string, and it is what an operator or a test types to turn the
+ * channel on (`setDebugTypeLogging('useNavigationController', true)`). Giving each split module its
+ * own name would be finer-grained and would silently stop every existing toggle from reaching the
+ * router-sync logs — a split is not the moment to change what a diagnostic switch covers.
+ */
+import { ResourceOperationFrontendSurface } from '@wildo-ai/saas-models';
+import { LoggerFrontendService } from '../../core/monitoring/logger.frontend.service.js';
+import { NavigationUtils } from './navigation.utils.js';
+const logger = LoggerFrontendService.getLogger();
+export const logDebug = logger.debugByType('useNavigationController');
+logger.setDebugTypeLogging('useNavigationController', false);
+/**
+ * Update the browser URL via React Router's navigate function, so React Router's
+ * `useLocation` hook updates. Everything derived from `useLocation` depends on
+ * this: deep-link shareability, back-button state, and the sidebar's
+ * most-specific-active highlight (`useSidebarBehavior` reads `useLocation`).
+ *
+ * ORDERING (why the transaction): the URL→state reconstruction hooks
+ * (`useRouterSync`, `useViewRouterSync`, `useEnginePageRouterSync`,
+ * `useSettingsHubOverlaySync`) observe `location` changes and rebuild zone state
+ * from the URL — UNLESS the target zone already owns the URL, OR a navigation
+ * transaction is active. A controller-driven navigation emits the zone-state
+ * entry (event bus → `setState`) and THEN changes the URL; if the URL change is
+ * observed before that state has committed, those hooks would re-derive stale
+ * content (the race the old code papered over). We therefore open (or extend) a
+ * navigation transaction so they skip during the commit window and re-validate
+ * via their transaction-aware retry once state has committed — by then the
+ * emitted entry owns the URL, so they no-op. This mirrors
+ * `navigatePathWithFreshStart` / `emitFreshStartNavigationCleanup`, which already
+ * pair `beginTransaction` with a synchronous `routerNavigate`.
+ *
+ * NOT PAINT-GATED (why not requestAnimationFrame): rAF callbacks are throttled to
+ * ~0fps in occluded / backgrounded / throttled tabs, so a deferred
+ * `routerNavigate` could be stranded indefinitely — zone content (event bus →
+ * state) swaps instantly while the URL, sidebar highlight, and back-button state
+ * lag until the tab is refocused (reproduced live: composite-view content visible
+ * while `location.pathname` stayed stale for 8+ seconds, converging only on tab
+ * activation). The transaction guard fills the ordering role rAF was standing in
+ * for, without the paint dependency.
+ */
+/**
+ * Only a resource operation DECLARED `ADDRESSABLE` owns a browser URL.
+ *
+ * The URL builders are surface-blind — `resolveResourceUrl` happily produces a
+ * pattern URL for any URL-bearing variant, including EMBEDDED (notAddressable)
+ * ones — but `AppRouter` registers routes for ADDRESSABLE operations only, so
+ * writing such a URL to the browser strands refresh / deep-link on the router
+ * 404 (seen live 2026-08-19: a breadcrumb click on the EMBEDDED organizations
+ * READ rewrote the URL to `/organizations/:id`, a route that does not exist).
+ * EMBEDDED content navigates as pure zone/overlay content instead.
+ *
+ * An `undefined` surface (synthetic/legacy operation objects that never passed
+ * through the registry's Step-2.5 posture resolution) keeps the historical
+ * URL-writing behavior — only an EXPLICIT non-addressable declaration opts out.
+ */
+export function resourceOperationOwnsBrowserUrl(operation) {
+    const surface = operation?.operationFrontendConfig?.surface;
+    return surface !== ResourceOperationFrontendSurface.EMBEDDED
+        && surface !== ResourceOperationFrontendSurface.API_ONLY;
+}
+export function updateBrowserUrl(routerNavigate, urlPath, replace = false) {
+    // Preserve an in-flight transaction's source label (e.g. 'app_level_navigation'
+    // opened by the APP_LEVEL clean break in navigate()) — only open a fresh window
+    // when none is active (zone-level drill, goBack, non-app-level cascade). The
+    // transaction auto-commits on setTimeout(0), after React has committed the
+    // preceding zone-state emit.
+    if (!NavigationUtils.isInTransaction()) {
+        NavigationUtils.beginTransaction('controller_url_update');
+    }
+    routerNavigate(urlPath, { replace });
+}
+//# sourceMappingURL=navigation-controller-internals.js.map

package/dist/esm/core/navigation/navigation-controller-internals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-controller-internals.js","sourceRoot":"","sources":["../../../../../src/core/navigation/navigation-controller-internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,EAAE,gCAAgC,EAAE,MAAM,uBAAuB,CAAC;AAEzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,6DAA6D,CAAC;AACpG,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,MAAM,GAAG,qBAAqB,CAAC,SAAS,EAAE,CAAC;AAEjD,MAAM,CAAC,MAAM,QAAQ,GAAiE,MAAM,CAAC,WAAW,CAAC,yBAAyB,CAAC,CAAC;AACpI,MAAM,CAAC,mBAAmB,CAAC,yBAAyB,EAAE,KAAK,CAAC,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,+BAA+B,CAC7C,SAAmG;IAEnG,MAAM,OAAO,GAAG,SAAS,EAAE,uBAAuB,EAAE,OAAO,CAAC;IAC5D,OAAO,OAAO,KAAK,gCAAgC,CAAC,QAAQ;WACvD,OAAO,KAAK,gCAAgC,CAAC,QAAQ,CAAC;AAC7D,CAAC;AAED,MAAM,UAAU,gBAAgB,CAC9B,cAA8C,EAC9C,OAAe,EACf,UAAmB,KAAK;IAExB,gFAAgF;IAChF,gFAAgF;IAChF,6EAA6E;IAC7E,2EAA2E;IAC3E,6BAA6B;IAC7B,IAAI,CAAC,eAAe,CAAC,eAAe,EAAE,EAAE,CAAC;QACvC,eAAe,CAAC,gBAAgB,CAAC,uBAAuB,CAAC,CAAC;IAC5D,CAAC;IACD,cAAc,CAAC,OAAO,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;AACvC,CAAC","sourcesContent":["/**\n * The two things every layer of the navigation controller needs, and neither of which belongs to any\n * one of them: the debug channel, and the one function that writes the browser URL.\n *\n * Extracted 2026-09-25 when `useNavigationController.ts` was split — 2,322 lines holding click\n * resolution, URL reconciliation, the ancestor cascade, clean breaks, dismiss and the emit bridge in\n * one module. Measured across the seam, the ROUTER-SYNC half used exactly THREE symbols from the\n * controller half (`logDebug` and the two cascade functions), which is what made the split cheap\n * enough to be worth doing at all.\n *\n * ## The debug type name is DELIBERATELY still `useNavigationController`\n *\n * `logger.debugByType` keys on this string, and it is what an operator or a test types to turn the\n * channel on (`setDebugTypeLogging('useNavigationController', true)`). Giving each split module its\n * own name would be finer-grained and would silently stop every existing toggle from reaching the\n * router-sync logs — a split is not the moment to change what a diagnostic switch covers.\n */\n\nimport type { useNavigate } from 'react-router-dom';\n\nimport { ResourceOperationFrontendSurface } from '@wildo-ai/saas-models';\n\nimport { LoggerFrontendService } from '~wildo-frontend-lib/core/monitoring/logger.frontend.service';\nimport { NavigationUtils } from './navigation.utils';\n\nconst logger = LoggerFrontendService.getLogger();\n\nexport const logDebug: (message: string, context?: Record<string, unknown>) => void = logger.debugByType('useNavigationController');\nlogger.setDebugTypeLogging('useNavigationController', false);\n\n/**\n * Update the browser URL via React Router's navigate function, so React Router's\n * `useLocation` hook updates. Everything derived from `useLocation` depends on\n * this: deep-link shareability, back-button state, and the sidebar's\n * most-specific-active highlight (`useSidebarBehavior` reads `useLocation`).\n *\n * ORDERING (why the transaction): the URL→state reconstruction hooks\n * (`useRouterSync`, `useViewRouterSync`, `useEnginePageRouterSync`,\n * `useSettingsHubOverlaySync`) observe `location` changes and rebuild zone state\n * from the URL — UNLESS the target zone already owns the URL, OR a navigation\n * transaction is active. A controller-driven navigation emits the zone-state\n * entry (event bus → `setState`) and THEN changes the URL; if the URL change is\n * observed before that state has committed, those hooks would re-derive stale\n * content (the race the old code papered over). We therefore open (or extend) a\n * navigation transaction so they skip during the commit window and re-validate\n * via their transaction-aware retry once state has committed — by then the\n * emitted entry owns the URL, so they no-op. This mirrors\n * `navigatePathWithFreshStart` / `emitFreshStartNavigationCleanup`, which already\n * pair `beginTransaction` with a synchronous `routerNavigate`.\n *\n * NOT PAINT-GATED (why not requestAnimationFrame): rAF callbacks are throttled to\n * ~0fps in occluded / backgrounded / throttled tabs, so a deferred\n * `routerNavigate` could be stranded indefinitely — zone content (event bus →\n * state) swaps instantly while the URL, sidebar highlight, and back-button state\n * lag until the tab is refocused (reproduced live: composite-view content visible\n * while `location.pathname` stayed stale for 8+ seconds, converging only on tab\n * activation). The transaction guard fills the ordering role rAF was standing in\n * for, without the paint dependency.\n */\n/**\n * Only a resource operation DECLARED `ADDRESSABLE` owns a browser URL.\n *\n * The URL builders are surface-blind — `resolveResourceUrl` happily produces a\n * pattern URL for any URL-bearing variant, including EMBEDDED (notAddressable)\n * ones — but `AppRouter` registers routes for ADDRESSABLE operations only, so\n * writing such a URL to the browser strands refresh / deep-link on the router\n * 404 (seen live 2026-08-19: a breadcrumb click on the EMBEDDED organizations\n * READ rewrote the URL to `/organizations/:id`, a route that does not exist).\n * EMBEDDED content navigates as pure zone/overlay content instead.\n *\n * An `undefined` surface (synthetic/legacy operation objects that never passed\n * through the registry's Step-2.5 posture resolution) keeps the historical\n * URL-writing behavior — only an EXPLICIT non-addressable declaration opts out.\n */\nexport function resourceOperationOwnsBrowserUrl(\n  operation: { operationFrontendConfig?: { surface?: ResourceOperationFrontendSurface } } | undefined,\n): boolean {\n  const surface = operation?.operationFrontendConfig?.surface;\n  return surface !== ResourceOperationFrontendSurface.EMBEDDED\n    && surface !== ResourceOperationFrontendSurface.API_ONLY;\n}\n\nexport function updateBrowserUrl(\n  routerNavigate: ReturnType<typeof useNavigate>,\n  urlPath: string,\n  replace: boolean = false\n): void {\n  // Preserve an in-flight transaction's source label (e.g. 'app_level_navigation'\n  // opened by the APP_LEVEL clean break in navigate()) — only open a fresh window\n  // when none is active (zone-level drill, goBack, non-app-level cascade). The\n  // transaction auto-commits on setTimeout(0), after React has committed the\n  // preceding zone-state emit.\n  if (!NavigationUtils.isInTransaction()) {\n    NavigationUtils.beginTransaction('controller_url_update');\n  }\n  routerNavigate(urlPath, { replace });\n}\n\n"]}

package/dist/esm/core/navigation/navigation-policy-resolver.service.d.ts

@@ -19,9 +19,49 @@
  *
  * @see _code_archive/docs-archive/navigation/navigation-v3-reflection.md
  */
-import { type NavigationLayout, type ViewportDiscriminated } from '@wildo-ai/saas-models';
+import { ResponsiveCollapseMode, type NavigationLayout, type ZoneConfig, type ViewportDiscriminated } from '@wildo-ai/saas-models';
 import { ViewportBreakpoint } from '@wildo-ai/zod-decorators';
 import { type NavigationResolutionContext, type NavigationResolutionResult } from './navigation.schemas';
+/**
+ * WHICH collapse a structural zone is under at this viewport, or `undefined` for none.
+ *
+ * Exported rather than private to the resolver because THREE parties need the answer and none may
+ * re-derive it: the resolver places a CLICK's content, `useResponsiveZoneMigration` moves content
+ * ALREADY sitting in a zone the viewport has just taken away, and a test pins both. The predicate
+ * half (`zoneIsCollapsedAtViewport`) was extracted for exactly this reason on 2026-09-25; this is
+ * the mode half, and leaving it private would let the migration disagree with the placement about
+ * whether a collapsed pane becomes a page or a sheet — the two halves of one declaration, answered
+ * by two functions.
+ *
+ * Callers own the zone-identity guard, because it is a question about WHICH zone rather than about
+ * the viewport.
+ *
+ * ## An UNDECLARED collapse defaults to PUSH, and that is a decision
+ *
+ * `NavigationContentAreas` renders a single zone below the mobile breakpoint — secondary and
+ * companion are not shown at all. So on a phone a zone with no `responsiveCollapse` is not "left
+ * alone": content routed there is placed into a zone that does not render, and the user sees
+ * nothing happen. That is what an undeclared collapse meant before #411, for every application, and
+ * it is not a behaviour anyone would choose deliberately.
+ *
+ * PUSH rather than OVERLAY because it is the conservative half of the vocabulary: the content
+ * appears in primary in context, and BACK pops to what was there before — no dismissal affordance
+ * to get wrong, and no modality over a phone-sized viewport. An application that wants the sheet
+ * declares `OVERLAY` and gets it.
+ *
+ * The alternative — return `undefined` and let the content vanish — was rejected because it is the
+ * silent degradation #411 exists to remove, and because "the zone declared nothing" is not a reason
+ * to lose a user's navigation.
+ *
+ * A viewport-discriminated declaration naming no mode for THIS breakpoint is a gap in the
+ * declaration, not a statement that the zone renders — it still would not — so it takes the same
+ * default.
+ */
+export declare function resolveZoneCollapseMode(params: {
+    zoneConfig: ZoneConfig | undefined;
+    viewport: ViewportBreakpoint | undefined;
+    contentAreaWidth?: number;
+}): ResponsiveCollapseMode | undefined;
 /**
  * Resolve a `ViewportDiscriminated<T>` value for the current viewport.
  *
@@ -41,6 +81,18 @@ export declare class NavigationPolicyResolver {
      * @returns What the controller should do: target zone, transition, appearance, collapse state.
      */
     resolve(context: NavigationResolutionContext, layout: NavigationLayout): NavigationResolutionResult;
+    /**
+     * The overlay an `INPLACE` transition becomes when the surface has no element-level host.
+     *
+     * A DOOR on the resolver rather than a re-resolution in the controller, because the controller's
+     * way of asking — injecting a synthetic `operationOverrides: [{ transition: OVERLAY }]` — had to
+     * lie twice to get an answer: it reported the outcome as an authored override, and it discarded
+     * the operation's REAL override along with the `appearance` and `overlayBehavior` on it. Here the
+     * context is untouched, so both are read exactly as they would be for any other overlay.
+     *
+     * The tier that answered `INPLACE` is preserved. What the degradation adds is an adjustment.
+     */
+    degradeInPlaceToOverlay(context: NavigationResolutionContext, layout: NavigationLayout, original: NavigationResolutionResult): NavigationResolutionResult;
     private resolveTransition;
     /**
      * Step 1: Check per-resource operation overrides.
@@ -65,7 +117,29 @@ export declare class NavigationPolicyResolver {
     private getTransitionBySemanticKey;
     /**
      * Step 4: Get the transition map from the appropriate source config.
-     * Three distinct branches based on source type.
+     *
+     * ## An OVERLAY source falls back to the zone it is LANDING IN
+     *
+     * `fromOverlay` is the app's statement about leaving an overlay, and it wins. What it does NOT
+     * mean is that an app which declared nothing there has declared nothing at all: an overlay is not
+     * a structural zone, so `getStructuralSourceZone` already answers PRIMARY for it — a structural
+     * navigation out of an overlay IS a primary navigation. Reading a different map for the VERB than
+     * for the ZONE is how the two came to disagree.
+     *
+     * Measured on the workbench, 2026-09-25. Its layout declares `zones.primary.transitions.read =
+     * SPLIT` and no `fromOverlay` at all. Clicking an aspect popup's `family` backlink — an
+     * ADDRESSABLE artifact — found no overlay map, fell through to the framework fallback `PUSH`, and
+     * landed in PRIMARY: the artifact took the WHOLE PAGE, replacing the artifact list it should have
+     * opened beside. The application had said what a READ does on the page; the resolver did not ask.
+     *
+     * Wonder CRM is the control and is untouched: it declares `fromOverlay.read = PUSH` deliberately
+     * ("ADDRESSABLE targets legitimately leave the overlay and become the page"), that map answers,
+     * and the fallback never runs. The fallback also covers the gap INSIDE a declared map — one that
+     * names READ says nothing about LIST, and that gap used to take the framework default too.
+     *
+     * APP_LEVEL is deliberately NOT given the same fallback. A menubar click is a layout RESET with
+     * its own meaning, and an app that declares no `appLevel` map has not thereby asked for primary's
+     * drill-in verbs — it has asked for the framework default, which is what it gets.
      */
     private getSourceTransitions;
     /**
@@ -91,6 +165,16 @@ export declare class NavigationPolicyResolver {
      * Falls back to overlay if no adjacent zone is declared in config.
      */
     private resolveSplitTarget;
+    /**
+     * Did a split into `zone` OPEN a pane or REPLACE what was in one?
+     *
+     * The same question `resolveSplitTarget`'s secondary branch answers inline by construction — it
+     * only reaches companion when secondary is taken — but the two branches that target companion
+     * DIRECTLY (a persistent split, and a layout declaring companion without secondary) choose the
+     * zone before asking, so they ask here. Reading `zoneOccupancy` is what keeps both answers derived
+     * from one input rather than from two nearly-identical inline conditions.
+     */
+    private splitOutcomeFor;
     /**
      * Derive visual appearance from zone config, resolved for the current viewport.
      * Only overlay and split transitions have meaningful appearance.

package/dist/esm/core/navigation/navigation-policy-resolver.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigation-policy-resolver.service.d.ts","sourceRoot":"","sources":["../../../../../src/core/navigation/navigation-policy-resolver.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAQL,KAAK,gBAAgB,EAKrB,KAAK,qBAAqB,EAC3B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAGL,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAChC,MAAM,sBAAsB,CAAC;AAkB9B;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAC5C,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAG,SAAS,EAC3C,QAAQ,EAAE,kBAAkB,GAC3B,CAAC,GAAG,SAAS,CAUf;AAiDD,qBAAa,wBAAwB;IAEnC;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,EAAE,2BAA2B,EAAE,MAAM,EAAE,gBAAgB,GAAG,0BAA0B;IAwKnG,OAAO,CAAC,iBAAiB;IA6EzB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAavB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;IA0BxB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAO/B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAkC1B;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IA+BxB;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAY9B,6DAA6D;IAC7D,OAAO,CAAC,mBAAmB;IAkB3B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;CA8E5B;AAED,sDAAsD;AACtD,eAAO,MAAM,wBAAwB,0BAAiC,CAAC"}
+{"version":3,"file":"navigation-policy-resolver.service.d.ts","sourceRoot":"","sources":["../../../../../src/core/navigation/navigation-policy-resolver.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAIL,sBAAsB,EAMtB,KAAK,gBAAgB,EAIrB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC3B,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAKL,KAAK,2BAA2B,EAChC,KAAK,0BAA0B,EAChC,MAAM,sBAAsB,CAAC;AAkB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,UAAU,EAAE,UAAU,GAAG,SAAS,CAAC;IACnC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACzC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,GAAG,sBAAsB,GAAG,SAAS,CAKrC;AAED;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAC5C,KAAK,EAAE,qBAAqB,CAAC,CAAC,CAAC,GAAG,SAAS,EAC3C,QAAQ,EAAE,kBAAkB,GAC3B,CAAC,GAAG,SAAS,CAUf;AAsDD,qBAAa,wBAAwB;IAEnC;;;;;;OAMG;IACH,OAAO,CAAC,OAAO,EAAE,2BAA2B,EAAE,MAAM,EAAE,gBAAgB,GAAG,0BAA0B;IA0NnG;;;;;;;;;;OAUG;IACH,uBAAuB,CACrB,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE,gBAAgB,EACxB,QAAQ,EAAE,0BAA0B,GACnC,0BAA0B;IAoB7B,OAAO,CAAC,iBAAiB;IA0FzB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAa/B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAavB;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,OAAO,CAAC,oBAAoB;IAsB5B;;;;;;;;;OASG;IACH,OAAO,CAAC,gBAAgB;IA0BxB;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAO/B;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IAmC1B;;;;;;;;OAQG;IACH,OAAO,CAAC,eAAe;IAavB;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAiCxB;;;;;;OAMG;IACH,OAAO,CAAC,sBAAsB;IAY9B,6DAA6D;IAC7D,OAAO,CAAC,mBAAmB;IA6B3B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,mBAAmB;CAoB5B;AAED,sDAAsD;AACtD,eAAO,MAAM,wBAAwB,0BAAiC,CAAC"}