@octane-xplat/ui 0.9.0 → 0.10.0

package/types/generated/indicators.d.ts

@@ -0,0 +1,23 @@
+import type { IndicatorComponent, IndicatorMap, IndicatorName, IndicatorRegistry } from './props.js';
+import { CheckboxIndicator } from './CheckboxIndicator.js';
+import { CheckIndicator } from './CheckIndicator.js';
+import { RadioIndicator } from './RadioIndicator.js';
+/** Class applied by a host whose hover/focus should drive descendant
+ *  indicators' chrome (Astryx's `indicatorScope` marker). Structural CSS
+ *  hangs off it, e.g. `.vx-indicator-scope:hover .vx-ind-checkbox`. */
+export declare const indicatorScope = "vx-indicator-scope";
+/** Core visuals for the three indicator names. */
+export declare const defaultIndicators: {
+    [N in IndicatorName]: IndicatorComponent<IndicatorMap[N]>;
+};
+export declare function registerIndicator<N extends IndicatorName>(name: N, component: IndicatorComponent<IndicatorMap[N]>): void;
+export declare function registerIndicators(registry: IndicatorRegistry): void;
+/** Resolve an indicator by name: override → built-in. Augmented names
+ *  (module-augmented `IndicatorMap` keys with no built-in) resolve to
+ *  `undefined` until registered. */
+export declare function getIndicator<N extends IndicatorName>(name: N): IndicatorComponent<IndicatorMap[N]> | undefined;
+/** `useIndicator` — same resolution as `getIndicator`. Not a reactive hook
+ *  here (there is no theme source to subscribe to); the name stays for API
+ *  parity with Astryx so host components read `useIndicator('checkbox')`. */
+export declare function useIndicator<N extends IndicatorName>(name: N): IndicatorComponent<IndicatorMap[N]> | undefined;
+export { CheckboxIndicator, CheckIndicator, RadioIndicator };

package/types/generated/input-group-context.d.ts

@@ -0,0 +1,16 @@
+import type { InputGroupSize } from './props.js';
+/** What a grouped control needs from its `InputGroup`: membership (so it
+ *  drops its own borders/radii into the group's shared surface) plus the
+ *  group's size and disabled state. Label/description/status ids come via
+ *  the FieldContext the group's Field provides — no duplication. */
+export interface InputGroupContextValue {
+    isDisabled?: boolean;
+    size?: InputGroupSize;
+}
+export declare const InputGroupContext: import("octane").Context<InputGroupContextValue | null>;
+export declare const InputGroupProvider: any;
+/** True (with group state) when the control renders inside an InputGroup's
+ *  surface — the control should flatten its own border/radius/background. */
+export declare function useInputGroup(): (InputGroupContextValue & {
+    inInputGroup: boolean;
+}) | null;

package/types/generated/ios/SideDrawer.ios.d.ts

@@ -1,10 +1,4 @@
-import { Drawer as NSDrawer } from '@nativescript-community/ui-drawer';
 import type { DrawerProps, PlatformWidgetProps } from '../props.js';
-declare module '@nativescript-community/octane/intrinsics' {
-    interface NativeScriptElements {
-        drawer: Attributes<typeof NSDrawer>;
-    }
-}
 /**  SideDrawer — ui-drawer host. `main`/`drawer` are slot props wired via the
  *  driver's hostSlot mechanism (parentView[slot] = view → mainContent /
  *  leftDrawer); `open` drives the imperative open()/close(). Slot hosts are

package/types/generated/ios/UITableView.ios.d.ts

@@ -1,14 +1,14 @@
-import type { ListProps, PlatformWidgetProps } from "../props.js";
+import type { PlatformListProps, PlatformWidgetProps } from "../props.js";
 /**  UITableView — the platform recycling list (UIKit UITableView via
  *  NativeScript `listview`). `items` is a plain array, ItemsSource, or
  *  ObservableArray — the driver binds `items[index]` into the recycled
  *  cell's root and skips rebinds whose row, item, and renderer are
  *  unchanged. Cell identity = the recycled host view, not the item.
- *  The shared `ui` export has no List — compose ScrollView + mapped
- *  children there.
+ *  The shared `List` is a fully rendered content list, not an OS-backed
+ *  recycled collection. Use `VirtualList` for portable windowing.
  *
  *  `refreshing`/`onRefresh`/`refreshThreshold` enable pull-to-refresh:
  *  the indicator is self-drawn (vx-spinner), the pull rides UITableView's
  *  own bounce, and the docked phase holds via contentInset — the same
  *  mechanics UIRefreshControl uses, without its OS spinner. */
-export declare function UITableView(props: PlatformWidgetProps<ListProps>): unknown;
+export declare function UITableView(props: PlatformWidgetProps<PlatformListProps>): unknown;

package/types/generated/ios/index.d.ts

@@ -11,4 +11,4 @@ export { LiquidGlass } from './LiquidGlass.ios.js';
 export { LiquidGlassContainer } from './LiquidGlassContainer.ios.js';
 export { Icon } from './icon.ios.js';
 export { modifier } from '../modifier-factories.js';
-export type { SwitchProps, SliderProps, ActivityIndicatorProps, ListProps, TabsProps, ModalProps, ModalOpenOptions, ModalOpenResult, OpenModal, DrawerProps, LiquidGlassProps, LiquidGlassContainerProps, GlassConfig, NativeModifier, NativeModifierValue, PlatformIconChoice, PlatformTabSpec, PlatformTabsProps, PlatformWidgetProps, RefreshProps, } from '../props.js';
+export type { SwitchProps, SliderProps, ActivityIndicatorProps, PlatformListProps as ListProps, ListVisibleItem, ListViewabilityChange, ListViewabilityInfo, ListViewabilityConfig, PlatformListHandle, TabsProps, ModalProps, ModalOpenOptions, ModalOpenResult, OpenModal, DrawerProps, LiquidGlassProps, LiquidGlassContainerProps, GlassConfig, NativeModifier, NativeModifierValue, PlatformIconChoice, PlatformTabSpec, PlatformTabsProps, PlatformWidgetProps, RefreshProps, } from '../props.js';

package/types/generated/is-renderable.d.ts

@@ -0,0 +1,3 @@
+/** `cond && <Icon />` keeps booleans out of the layout — mirror of Astryx's
+ *  isRenderable: null/undefined/false are empty; everything else renders. */
+export declare function isRenderable(value: unknown): boolean;

package/types/generated/{keyboard-inset.mobile.d.ts → keyboard-inset.d.ts}

@@ -2,7 +2,7 @@
  *  iOS: a shared UIKeyboardWillChangeFrame observer tracks the inset and
  *  translateY shifts the host — reliable on popup views regardless of how
  *  the RootLayout passes margins through. The current inset is applied at
- *  bind time so hosts opened over an already-visible keyboard still lift.
+ *  attachment time so hosts opened over an already-visible keyboard still lift.
  *  Android: when the window runs `adjustResize` (KeyboardAvoiding sets it)
  *  the RootLayout resizes and the host follows on its own; otherwise the
  *  decor view's IME inset supplies the lift. Returns an unbind that

package/types/generated/keyboard-inset.web.d.ts

@@ -0,0 +1,2 @@
+/** The browser viewport handles the software keyboard without moving sheets. */
+export declare function bindBottomInsetToKeyboard(_host: unknown): () => void;

package/types/generated/layer-dismissal.d.ts

@@ -0,0 +1,15 @@
+export declare const LayerDepthContext: import("octane").Context<number>;
+export declare const LayerDepthProvider: any;
+/**  Internal depth is passed explicitly into separately mounted native roots. */
+export declare function useLayerDismissal(options: {
+    active: boolean;
+    dismiss(): void;
+    behavior?: 'close' | 'block';
+    contains?(target: any): boolean;
+    isPresent?(): boolean;
+    restoreFocus?: boolean;
+    getFocusTarget?(): any;
+}): {
+    depth: number;
+    shouldClose: (retiring?: boolean) => boolean;
+};

package/types/generated/layer-keys.d.ts

@@ -0,0 +1 @@
+export declare function captureLayerFocus(getTarget?: () => any): () => void;

package/types/generated/layer-keys.web.d.ts

@@ -0,0 +1 @@
+export declare function captureLayerFocus(getTarget?: () => any): () => void;

package/types/generated/layer-position.web.d.ts

@@ -0,0 +1,4 @@
+/** Own only this layer's token. Other layers and consumer edits survive release. */
+export declare function ownAnchorName(element: HTMLElement, name: string): () => void;
+/** Let the browser resolve rem/em/var/calc rather than treating them as px. */
+export declare function resolveCSSLayerOffset(offset: number | string, anchor: HTMLElement): number;

package/types/generated/layer-stack.d.ts

@@ -0,0 +1,26 @@
+/** Portable dismissal ownership. Entries outlive close requests: only the
+ * declaring owner decides when a controlled layer stops participating. */
+export interface LayerEntry {
+    token: object;
+    depth: number;
+    behavior: 'close' | 'block';
+    dismiss(): void;
+    contains?(target: any): boolean;
+    isPresent?(): boolean;
+}
+export interface LayerKeyEvent {
+    key: string;
+    isComposing?: boolean;
+    keyCode?: number;
+    defaultPrevented?: boolean;
+    preventDefault(): void;
+}
+export declare function configureLayerKeys(bind: () => () => void): void;
+export declare function setLayerComposing(value: boolean): void;
+export declare function isTopLayer(token: object, retiring?: boolean): boolean;
+export declare function layerContains(target: any): boolean;
+export declare function shouldCloseLayer(token: object, retiring?: boolean): boolean;
+/** Claim before invoking user code, so synchronous unmount cannot give the
+ * same event to the next layer. IME Escape suppresses platform close watchers. */
+export declare function dispatchLayerKey(event: LayerKeyEvent): void;
+export declare function registerLayer(entry: LayerEntry): () => void;

package/types/generated/list-context.d.ts

@@ -0,0 +1,13 @@
+import type { ListDensity, ListMarkerStyle } from './props.js';
+export interface ListContextValue {
+    density: ListDensity;
+    hasDividers: boolean;
+    listStyle: ListMarkerStyle;
+    edgeCompensation?: 'inline';
+    /** Starting index for 'decimal' lists (the web leaf uses a CSS counter;
+     *  native renders numbered labels directly). */
+    start?: number;
+}
+export declare const ListContext: import("octane").Context<ListContextValue | null>;
+export declare const ListProvider: any;
+export declare function useListContext(): ListContextValue;

package/types/generated/list-focus.web.d.ts

@@ -0,0 +1,26 @@
+/**  Options for the web roving-tabindex helper shared by Toolbar, TabList
+ *  and NavHeadingMenu — the Astryx `useListFocus` equivalent scoped to what
+ *  these components need. */
+export interface ListFocusOptions {
+    /**  CSS selector matching the focusable stops. */
+    itemSelector: string;
+    /**  Arrow axis — 'both' accepts vertical arrows too. */
+    orientation?: 'horizontal' | 'vertical' | 'both';
+    /**  Own the single Tab stop: exactly one enabled item keeps tabIndex 0. */
+    hasRovingTabIndex?: boolean;
+    /**  Called when Escape is pressed inside the container. */
+    onEscape?: () => void;
+}
+/**  Roving tabindex + arrow/Home/End navigation for a strip of stops.
+ *  Web-only — pointer platforms have no composite-widget keyboard model. */
+export declare function useListFocus<T extends HTMLElement = HTMLElement>(options: ListFocusOptions): {
+    listRef: {
+        current: T | null;
+    };
+    handleKeyDown: (e: KeyboardEvent) => void;
+    handleFocus: (e: FocusEvent) => void;
+    focusItem: (item: HTMLElement | null) => void;
+    focusAt: (index: number) => void;
+    focusFirst: () => void;
+    focusLast: () => void;
+};

package/types/generated/list-viewability-core.d.ts

@@ -0,0 +1,13 @@
+import type { ListViewabilityConfig, ListViewabilityInfo } from './props.js';
+export interface VisibleListRow {
+    index: number;
+    visiblePercent: number;
+}
+/** Tracks logical rows after each platform observer measures actual viewport
+ *  intersections. A native cell can be reused; index plus current item is the
+ *  identity exposed to callers. */
+export declare function createListViewabilityTracker<T>(): {
+    update: (rows: readonly VisibleListRow[], items: readonly T[], config: ListViewabilityConfig | undefined, callback: ((info: ListViewabilityInfo<T>) => void) | undefined) => void;
+    reset: () => void;
+    dispose: () => void;
+};

package/types/generated/list-viewability-observer.android.d.ts

@@ -0,0 +1,8 @@
+import type { ListViewabilityConfig } from './props.js';
+import type { VisibleListRow } from './list-viewability-core.js';
+import { type ListVisibilityObserver } from './list-viewability-runtime.js';
+export declare function observeListViewability(list: any, getState: () => {
+    items: readonly any[];
+    config?: ListViewabilityConfig;
+    update: (rows: readonly VisibleListRow[], items: readonly any[], config?: ListViewabilityConfig) => void;
+}, reset: () => void): ListVisibilityObserver;

package/types/generated/list-viewability-observer.ios.d.ts

@@ -0,0 +1,8 @@
+import type { ListViewabilityConfig } from './props.js';
+import type { VisibleListRow } from './list-viewability-core.js';
+import { type ListVisibilityObserver } from './list-viewability-runtime.js';
+export declare function observeListViewability(list: any, getState: () => {
+    items: readonly any[];
+    config?: ListViewabilityConfig;
+    update: (rows: readonly VisibleListRow[], items: readonly any[], config?: ListViewabilityConfig) => void;
+}, reset: () => void): ListVisibilityObserver;

package/types/generated/list-viewability-runtime.d.ts

@@ -0,0 +1,37 @@
+import type { ListViewabilityConfig, ListViewabilityInfo } from './props.js';
+import type { VisibleListRow } from './list-viewability-core.js';
+export interface PlatformListRuntime<T = any> {
+    list: {
+        current: any;
+    };
+    items: {
+        current: T[];
+    };
+    config: {
+        current?: ListViewabilityConfig;
+    };
+    onChange: {
+        current?: (info: ListViewabilityInfo<T>) => void;
+    };
+}
+/** NativeScript's public list methods silently ignore unmounted targets; the
+ *  shared handle also treats invalid indices as safe no-ops on both OSes. */
+export declare function scrollListToIndex(list: any, index: number | undefined, itemsLength: number, animated?: boolean): boolean;
+/** Applies an initial index once per list and requested target. Invalid or
+ *  not-yet-available targets remain eligible when the list's data arrives. */
+export declare function createInitialListScrollRestorer(): {
+    tryScroll(list: any, target: number | undefined, itemsLength: number): boolean;
+};
+export interface ListVisibilityState<T = any> {
+    items: readonly T[];
+    config?: ListViewabilityConfig;
+    update: (rows: readonly VisibleListRow[], items: readonly T[], config?: ListViewabilityConfig) => void;
+}
+export interface ListVisibilityObserver {
+    refresh(): void;
+    dispose(): void;
+}
+/** Keeps native peer observation aligned with NativeScript's View lifecycle.
+ *  Effects may run before `loaded`; the lifecycle listener attaches later and
+ *  handles peer replacement without replacing NativeScript's own delegates. */
+export declare function observeLoadedListPeer<T>(list: any, getPeer: () => T | null | undefined, attach: (peer: T) => ListVisibilityObserver, reset: () => void): ListVisibilityObserver;

package/types/generated/markdown-parse.d.ts

@@ -0,0 +1,28 @@
+import type { MdDoc, MdInline, MdNode } from './props.js';
+/** Parse Markdown source into the renderer's block AST. */
+export declare function parseMdNodes(source: string): MdNode[];
+/** Parse Markdown source into a `Markdown`-renderable doc — the runtime
+ *  counterpart of the codegen's baked `MdDoc`. */
+export declare function parseMdDoc(source: string): MdDoc;
+/** Same parse as `parseMdNodes` plus per-node list continuation keys.
+ *  Internal — the incremental parser needs marks to merge loose lists split
+ *  across its settled/delta seam. */
+export declare function parseMdNodesMarked(source: string): {
+    nodes: MdNode[];
+    listMarks: (string | undefined)[];
+};
+/** Flatten inline nodes to their visible text — the runtime counterpart of
+ *  codegen's `inlineText` (link labels drop nested formatting). */
+export declare function mdInlineText(nodes: MdInline[]): string;
+/** Rendered length of an inline run — `mdInlineText` without allocating. */
+export declare function mdInlineLen(nodes: MdInline[]): number;
+/** Unicode letter-or-number test for the intraword `_` rule. Unicode
+ *  property escapes (`\\p{L}`, `\\p{N}`) need Unicode tables — a regex
+ *  literal on an engine without them throws SyntaxError at parse time and
+ *  poisons the whole bundle (this is how NativeScript's embedded V8
+ *  ships). check-native-dist scans emitted comments too, so keep the
+ *  double-backslash spelling here. Build the pattern dynamically instead:
+ *  general categories where full Unicode exists, the spec-required minimal
+ *  property set otherwise, ASCII as a last resort. */
+export declare const WORD_CHAR: RegExp;
+export declare function parseMdInline(text: string): MdInline[];

package/types/generated/markdown-stream.d.ts

@@ -0,0 +1,61 @@
+import type { MdNode } from './props.js';
+/** Mutable cache for `parseMarkdownIncremental`. Create per logical doc
+ *  (e.g. per message) — a state reused for a wholesale different input
+ *  resets itself, but holding one state per stream is cheaper. */
+export interface MarkdownIncrementalState {
+    /** Last input seen — identical input returns the same output array. */
+    input: string;
+    /** Immutable source prefix: every parsed block here is final. */
+    settledSource: string;
+    /** Blocks parsed from `settledSource`, shared by reference across calls. */
+    settled: MdNode[];
+    /** List continuation key per settled node (loose-list seam merging). */
+    marks: (string | undefined)[];
+    /** Last returned node array (identity reuse for identical input). */
+    output: MdNode[];
+}
+export declare function createMarkdownIncrementalState(): MarkdownIncrementalState;
+/**
+ * Strip trailing incomplete inline syntax from the last line so half-typed
+ * constructs don't render as literal markup: an unclosed `[`/`![` (link or
+ * image), a trailing unclosed backtick run, and unpaired `*`/`_` emphasis
+ * markers. Mid-line unclosed emphasis is auto-closed instead of trimmed, so
+ * `**partial` renders bold immediately rather than flashing raw asterisks.
+ */
+export declare function trimStreamingArtifacts(input: string): string;
+/**
+ * Parse one cumulative snapshot of a streaming Markdown doc. Settled
+ * blocks (everything before the last safe blank line) parse once and are
+ * shared by reference between calls; only the open tail reparses. Incomplete
+ * trailing constructs are withheld or auto-closed, so intermediate output
+ * shows no raw markup — and once the input stops growing, the result equals
+ * `parseMdNodes` on the final text.
+ *
+ * Non-append input (a different doc, an edit) resets the cache and
+ * reparses whole.
+ */
+export declare function parseMarkdownIncremental(input: string, state: MarkdownIncrementalState): MdNode[];
+/** One piece of a text run split at stream boundaries. `key` is stable for
+ *  the segment's lifetime so the fade span mounts once; `fading` marks
+ *  segments that arrived after the oldest tracked boundary. */
+export interface MdTextSegment {
+    key: string;
+    text: string;
+    fading: boolean;
+}
+/**
+ * Push the previous rendered length onto the boundary ring when output grew.
+ * The ring caps at `maxSpans`; evicted boundaries merge into settled text.
+ */
+export declare function computeBoundaries(prevBoundaries: number[], prevRenderedLen: number, maxSpans: number): number[];
+/**
+ * Split one text run at the stream boundaries it crosses. Returns null when
+ * the whole run is settled (no splitting needed). Segment keys never change
+ * once created — `settled-{nodeKey}` for pre-boundary text and
+ * `fade-{nodeKey}-b{offset}` per boundary span — so a fading span stays
+ * mounted until it merges into the settled segment.
+ */
+export declare function computeSegments(content: string, startOffset: number, boundaries: number[], nodeKey: string | number): MdTextSegment[] | null;
+/** Total rendered text length of a node list — the cursor metric fade
+ *  boundaries are computed against. */
+export declare function markdownTextLength(nodes: MdNode[]): number;

package/types/generated/menu-context.d.ts

@@ -0,0 +1,6 @@
+import type { MenuContextValue, MenuRadioGroupProps } from './props.js';
+export declare const DropdownMenuContext: import("octane").Context<MenuContextValue | null>;
+export declare const MenuProvider: any;
+export declare function useDropdownMenuContext(): MenuContextValue | null;
+export declare const MenuRadioContext: import("octane").Context<MenuRadioGroupProps | null>;
+export declare const MenuRadioProvider: any;

package/types/generated/metadata-list-context.d.ts

@@ -0,0 +1,9 @@
+/** Resolved layout config a MetadataListItem reads to decide between the
+ *  inline (label+value grid cells) and stacked (one wrapper per item) shape. */
+export interface MetadataListContextValue {
+    labelPosition: 'start' | 'top';
+    labelWidth?: number | string;
+    orientation: 'vertical' | 'horizontal';
+}
+export declare const MetadataListContext: import("octane").Context<MetadataListContextValue | null>;
+export declare const MetadataListProvider: any;

package/types/generated/modal-focus.web.d.ts

@@ -1,3 +1,4 @@
+import './layer-keys.web.js';
 /** Own keyboard focus only for a modal body portal. Inert preserves the
  * background's state while hiding it from both focus and the browser AX tree. */
-export declare function isolateModalFocus(layer: HTMLElement, panel: HTMLElement, dismiss: () => void): () => void;
+export declare function isolateModalFocus(layer: HTMLElement, panel: HTMLElement, dismiss: () => void, depth?: number): () => void;

package/types/generated/native/index.d.ts

@@ -1,3 +1,3 @@
-export { rootLayoutFor, topRootLayout, findInRootLayouts } from '../root-layout.mobile.js';
+export { rootLayoutFor, topRootLayout, findInRootLayouts } from '../root-layout.js';
 export { layoutsForRoute } from '../route.js';
-export { sheetHost } from '../sheet-service.js';
+export { bottomSheetHost } from '../bottom-sheet-service.js';

package/types/generated/native-color.d.ts

@@ -0,0 +1,2 @@
+/** Fallback for targets without the NativeScript mobile color class. */
+export declare const nativeColor: (value: string) => any;

package/types/generated/native-color.mobile.d.ts

@@ -0,0 +1,4 @@
+/**  @jsxImportSource @nativescript-community/octane */
+import { Color } from '@nativescript/core';
+/**  Construct a NativeScript color for dynamic style values. */
+export declare const nativeColor: (value: string) => Color;

package/types/generated/nav-contexts.d.ts

@@ -0,0 +1,49 @@
+import type { AppShellMobileContextValue, NavHeadingCloseContextValue, NavHeadingMenuContextValue, NavHeadingMenuSize, SideNavCollapseState, SideNavRenderMode, TabListContextValue, TopNavRenderMode, TopNavSlot, ToolbarSize } from './props.js';
+export declare const AppShellMobileContext: import("octane").Context<AppShellMobileContextValue>;
+export declare function useAppShellMobile(): AppShellMobileContextValue;
+/** AppShell sets this so TopNav can switch between the full bar, the
+ *  reduced mobile bar, and drawer rendering below the breakpoint. */
+export declare const TopNavRenderContext: import("octane").Context<TopNavRenderMode>;
+export declare function useTopNavRenderMode(): TopNavRenderMode;
+/** Which TopNav slot an item renders in — items use it for slot-specific
+ *  styling (e.g. drawer layouts stretch items full width). */
+export declare const TopNavSlotContext: import("octane").Context<TopNavSlot>;
+export declare function useTopNavSlot(): TopNavSlot;
+/** Extra drawer content AppShell hands to TopNav's drawer render — the
+ *  SideNav's items travel this way when the drawer is combined. */
+export declare const TopNavMobileContentContext: import("octane").Context<any>;
+export declare function useTopNavMobileContent(): any;
+/** AppShell sets this so SideNav can switch between the full sidebar, the
+ *  horizontal topbar, and the two drawer renderings. */
+export declare const SideNavRenderContext: import("octane").Context<SideNavRenderMode>;
+export declare function useSideNavRenderMode(): SideNavRenderMode;
+/** SideNav collapse state shared with collapse buttons and items. */
+export declare const SideNavCollapseContext: import("octane").Context<SideNavCollapseState | null>;
+export declare function useSideNavCollapse(): SideNavCollapseState | null;
+/** TabList → Tab/TabMenu selection contract. Throws when read outside a
+ *  TabList, matching upstream. */
+export declare const TabListContext: import("octane").Context<TabListContextValue | null>;
+export declare function useTabListContext(): TabListContextValue;
+/** Heading-popover close callback — NavHeadingMenu reads it to dismiss the
+ *  popover on item selection and Escape. */
+export declare const NavHeadingCloseContext: import("octane").Context<NavHeadingCloseContextValue | null>;
+export declare function useNavHeadingCloseContext(): NavHeadingCloseContextValue | null;
+/** NavHeadingMenu → its items: size + the close callback. */
+export declare const NavHeadingMenuContext: import("octane").Context<NavHeadingMenuContextValue | null>;
+export declare function useNavHeadingMenuContext(): NavHeadingMenuContextValue | null;
+export type { NavHeadingMenuSize };
+/** Toolbar → family children that want the resolved size. This is the
+ *  local seam standing in for Astryx's SizeContext until the shared size
+ *  context lands with the forms/layout task. */
+export declare const ToolbarSizeContext: import("octane").Context<import("./props.js").NavElementSize | null>;
+export declare function useToolbarSize(): ToolbarSize | null;
+export declare const AppShellMobileProvider: any;
+export declare const SideNavRenderProvider: any;
+export declare const TopNavRenderProvider: any;
+export declare const TopNavSlotProvider: any;
+export declare const TopNavMobileContentProvider: any;
+export declare const SideNavCollapseProvider: any;
+export declare const NavHeadingCloseProvider: any;
+export declare const NavHeadingMenuProvider: any;
+export declare const TabListProvider: any;
+export declare const ToolbarSizeProvider: any;

package/types/generated/nav-href.d.ts

@@ -0,0 +1 @@
+export declare function followHref(href: string): void;

package/types/generated/nav-href.web.d.ts

@@ -0,0 +1,4 @@
+/** Web fallback for programmatic href activation (non-anchor surfaces such
+ *  as menu items rendered as buttons). Anchors navigate natively, so this
+ *  path is only for elements that asked to handle activation themselves. */
+export declare function followHref(href: string): void;

package/types/generated/outline-dom.d.ts

@@ -0,0 +1,8 @@
+import type { OutlineFromDOMOptions, OutlineItem } from './props.js';
+/**  `useOutlineFromDOM` — native form. The DOM API name is kept for API
+ *  parity; the argument is a `ref`/`ref`-style object holding the scroll
+ *  container's (or page's) root view. There is no mutation observation on
+ *  the NS view tree, so the outline is collected once after mount and again
+ *  whenever `containerRef.current` changes — use `useOutlineFromMarkdown`
+ *  (or pass `items` directly) when the heading set is dynamic. */
+export declare function useOutlineFromDOM(containerRef?: unknown, _options?: OutlineFromDOMOptions): OutlineItem[];

package/types/generated/outline-dom.web.d.ts

@@ -0,0 +1,8 @@
+import type { OutlineFromDOMOptions, OutlineItem } from './props.js';
+/**  Read the heading tree from a container (or the document) — each entry
+ *  carries the element's id (or a slug of its text) and its tag level. */
+export declare function outlineItemsFromDOM(container?: ParentNode | null, selector?: string): OutlineItem[];
+/**  `useOutlineFromDOM` — keeps the item list in sync with the container's
+ *  heading nodes via MutationObserver. The container may be a ref object
+ *  (`{current}`) or a DOM node. */
+export declare function useOutlineFromDOM(containerRef?: unknown, options?: OutlineFromDOMOptions): OutlineItem[];

package/types/generated/outline-hooks.d.ts

@@ -0,0 +1,9 @@
+import type { MdDoc } from './Markdown.js';
+import type { OutlineItem } from './props.js';
+/**  Heading outline items derived from Markdown source — one entry per ATX or
+ *  Setext heading, labelled by the inline text, id'd by the deduplicated
+ *  slug (same slugify/uniqueSlug contract as upstream). */
+export declare function useOutlineFromMarkdown(markdown: string): OutlineItem[];
+/**  Outline items from a baked `MdDoc` (the `xplat routes`/`Markdown` AST) —
+ *  the portable form of "outline the document I'm rendering". */
+export declare function useOutlineFromDoc(doc: MdDoc): OutlineItem[];

package/types/generated/outline-utils.d.ts

@@ -0,0 +1,36 @@
+import type { OutlineItem } from './props.js';
+export type { OutlineItem } from './props.js';
+import type { MdDoc } from './Markdown.js';
+/** Slug a heading label the same way upstream's parser does: lowercase,
+ *  quotes dropped, non-alphanumerics collapse to '-', edges trimmed. */
+export declare function slugify(value: string): string;
+/** Disambiguate repeated slugs with a numeric suffix (`setup`, `setup-1`, …).
+ *  Empty slugs fall back to `section`. The caller owns the counts map. */
+export declare function uniqueSlug(baseSlug: string, counts: Map<string, number>): string;
+/** Strip the inline constructs the local Markdown AST supports (code spans,
+ *  emphasis, links, images, escapes), leaving the visible text — matching
+ *  what `markdownAstText` produces upstream. */
+export declare function inlineMarkdownText(source: string): string;
+interface ParsedHeading {
+    label: string;
+    level: number;
+}
+/**
+ * Scan markdown source for headings. Not a general parser — it exists to
+ * produce outline labels that agree with what the Markdown component renders
+ * for the same source. Fenced code blocks (```/~~~) and 4-space-indented
+ * lines are never headings; Setext underlines promote the previous
+ * non-blank line.
+ */
+export declare function markdownHeadings(markdown: string): ParsedHeading[];
+/**
+ * Extract outline items from a Markdown string: heading text becomes the
+ * label, its slug (with per-document dedup) becomes the id. For
+ * `useOutlineFromMarkdown` parity on MdDoc-shaped data see
+ * {@link outlineFromDoc}.
+ */
+export declare function parseOutlineFromMarkdown(markdown: string): OutlineItem[];
+/** Outline items from a baked `MdDoc` (the AST `xplat routes` produces and
+ *  the `Markdown` component renders) — the portable equivalent of deriving
+ *  an outline from rendered markdown content. */
+export declare function outlineFromDoc(doc: MdDoc): OutlineItem[];

package/types/generated/outline-view-tree.d.ts

@@ -0,0 +1,7 @@
+import type { OutlineItem } from './props.js';
+export declare function outlineChildViews(view: any): Generator<any>;
+/** Depth-first heading collection — matches document order. */
+export declare function outlineItemsFromViewTree(root: any): OutlineItem[];
+/** Locate a view by `id` inside a subtree — used by Outline's native
+ *  activation to find the heading it should scroll to. */
+export declare function findViewById(root: any, id: string): any;

package/types/generated/overflow-math.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure overflow fit math for OverflowList — a 1:1 port of Astryx's
+ * computeOverflow (single-line greedy fit + bounded multi-row packing).
+ * No platform code; consumed by every leaf's measurement pass.
+ */
+export interface ComputeOverflowInput {
+    /** Measured widths of each item, in original order. */
+    widths: number[];
+    /** Gap between items, in px/dips. */
+    gap: number;
+    /** Width available to lay items out, in px/dips. */
+    availableWidth: number;
+    /** Measured width of the overflow indicator (0 if none). */
+    indicatorWidth: number;
+    /** Floor — always show at least this many items. */
+    minVisibleItems: number;
+    /** Ceiling — never show more than this many items. `undefined` = no cap. */
+    maxVisibleItems?: number;
+    /** Bounded multi-row: wrap items across up to this many rows, then
+     *  collapse the rest into the overflow indicator. `undefined`/`1` =
+     *  single line. */
+    maxRows?: number;
+    collapseFrom: 'start' | 'end';
+}
+export interface ComputeOverflowResult {
+    /** Number of items that should be rendered in the visible container. */
+    visibleCount: number;
+    /** Number of rows the visible items occupy (always 1 single-line). */
+    rows: number;
+}
+export declare function computeOverflow(input: ComputeOverflowInput): ComputeOverflowResult;

package/types/generated/overlay-lifetime.d.ts

@@ -0,0 +1,19 @@
+/** Own the resources of one independently mounted overlay. RootLayout emits
+ * closed before removing the host, so that notification must never reenter close. */
+type OverlayHost = {
+    on(eventName: string, listener: (...args: any[]) => void): void;
+    off(eventName: string, listener: (...args: any[]) => void): void;
+};
+type OverlayOwner = {
+    close(host: any): Promise<unknown>;
+    open(host: any, options?: any): Promise<unknown>;
+    removeChild(host: any): void;
+};
+export declare function createOverlayLifetime(owner: OverlayOwner, host: OverlayHost, root: {
+    unmount(): void;
+}, label: string, onFinish: (dismissed: boolean) => void): {
+    own(cleanup: () => void): void;
+    close(): void;
+    open(options?: any, afterOpen?: () => void | Promise<void>): void;
+};
+export {};

package/types/generated/popover-position.d.ts

@@ -1,4 +1,4 @@
-import type { PopoverPlacement } from './props.js';
+import type { LayerPlacement, PopoverAlignment, PopoverPlacement } from './props.js';
 export interface PopoverRect {
     left: number;
     top: number;
@@ -10,5 +10,19 @@ export interface PopoverPosition {
     top: number;
     placement: PopoverPlacement;
 }
-/** Place beside the anchor, flip once when the requested side overflows, then clamp. */
-export declare function positionPopover(anchor: PopoverRect, panel: Pick<PopoverRect, 'width' | 'height'>, viewport: PopoverRect, requested?: PopoverPlacement, gap?: number): PopoverPosition;
+/** Place beside the anchor, flip once when the requested side overflows,
+ *  then clamp. `alignment` positions along the cross axis — 'start' keeps
+ *  the panel's start edge flush with the anchor's (the historical
+ *  behavior), 'center' centers, 'end' aligns the end edges. */
+export declare function positionPopover(anchor: PopoverRect, panel: Pick<PopoverRect, 'width' | 'height'>, viewport: PopoverRect, requested?: PopoverPlacement, gap?: number, alignment?: PopoverAlignment): PopoverPosition;
+/** Resolve a `useLayer` placement — logical (`above`/`below`/`start`/`end`)
+ *  or physical — to a physical side for `positionPopover`. `rtl` mirrors the
+ *  logical inline sides. */
+export declare function resolveLayerSide(placement: LayerPlacement | PopoverPlacement | undefined, rtl?: boolean): PopoverPlacement;
+/** Normalize a `useLayer` render-prop offset to a dip clearance. A number is
+ *  taken as-is; native accepts numeric or px strings and rejects other CSS units. Defaults to flush (0). */
+export declare function layerOffset(offset: number | string | undefined): number;
+/** Horizontal cross-axis alignment follows the anchor's inline direction. */
+export declare function resolveLayerAlignment(alignment: PopoverAlignment | undefined, side: PopoverPlacement, rtl?: boolean): PopoverAlignment;
+/** Read the effective OS direction, with inherited author direction as a fallback. */
+export declare function nativeLayerRTL(view: any): boolean;