@octane-xplat/ui 0.9.0 → 0.11.0

package/types/generated/datetime.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Portable date/time core shared by Calendar and the date/time inputs.
+ *
+ * Values are ISO strings, never `Date` — `YYYY-MM-DD`, `HH:MM[:SS]`, and
+ * `YYYY-MM-DDTHH:MM[:SS]` carry calendar/wall-clock intent across web,
+ * NativeScript, and serialization boundaries. `Date` appears only where the
+ * platform contract needs one: `dateConstraints` callbacks and Calendar's
+ * single-mode `onChange` second argument.
+ *
+ * Locale display goes through `Intl.DateTimeFormat` (V8 on Android, JSC on
+ * iOS/macOS — all provide it) with a fixed English fallback so formatting
+ * never throws on a runtime with a reduced ICU.
+ */
+import type { DateRange, DayOfWeek, DayOfWeekName, ISODateString, ISODateTimeString, ISOTimeString } from './props.js';
+/** The runtime's best-effort display locale — device locale on native,
+ *  runtime locale on web; falls back to 'en' when Intl is reduced. */
+export declare function resolveLocale(locale?: string): string;
+export interface PlainDate {
+    readonly year: number;
+    readonly month: number;
+    readonly day: number;
+}
+export declare function daysInMonth(year: number, month: number): number;
+export declare function plainDateCreate(year: number, month: number, day: number): PlainDate | null;
+export declare function plainDateFromDate(d: Date): PlainDate;
+/** Local midnight — the only `Date` conversion; DST shifts cannot move the
+ *  calendar day because the day is read back from the same local zone. */
+export declare function plainDateToDate(pd: PlainDate): Date;
+export declare function plainDateToday(): PlainDate;
+export declare function plainDateFromISO(iso: string): PlainDate | null;
+export declare function plainDateToISO(pd: PlainDate): ISODateString;
+export declare function plainDateAddDays(pd: PlainDate, days: number): PlainDate;
+/** Month arithmetic clamps to the target month's last day
+ *  (Jan 31 + 1mo → Feb 28/29) instead of rolling into the next month. */
+export declare function plainDateAddMonths(pd: PlainDate, months: number): PlainDate;
+export declare function plainDateAddYears(pd: PlainDate, years: number): PlainDate;
+/** Whole-day difference `a − b`; UTC epoch math makes it DST-free. */
+export declare function plainDateDiffDays(a: PlainDate, b: PlainDate): number;
+export declare function plainDateCompare(a: PlainDate, b: PlainDate): number;
+export declare function plainDateIsBefore(a: PlainDate, b: PlainDate): boolean;
+export declare function plainDateIsAfter(a: PlainDate, b: PlainDate): boolean;
+export declare function plainDateIsEqual(a: PlainDate, b: PlainDate): boolean;
+export declare function plainDateSetStartOfWeek(pd: PlainDate, weekStartsOn: number): PlainDate;
+/** ISO-8601 week number. */
+export declare function plainDateGetWeekNumber(pd: PlainDate): number;
+export declare function normalizeDayOfWeek(value: DayOfWeek | DayOfWeekName | undefined): DayOfWeek;
+export type ShortWeekdayNames = readonly [string, string, string, string, string, string, string];
+export declare function getStandaloneShortWeekdayNames(locale: string): ShortWeekdayNames;
+export type DateFormatOptions = Intl.DateTimeFormatOptions;
+export declare const DATE_FORMAT_WITH_WEEKDAY: DateFormatOptions;
+export declare const DATE_FORMAT_SHORT_WITH_WEEKDAY: DateFormatOptions;
+export declare const DATE_FORMAT_LONG: DateFormatOptions;
+export declare const DATE_FORMAT_MONTH_YEAR: DateFormatOptions;
+export declare const DATE_FORMAT_SHORT: DateFormatOptions;
+export declare const DATE_FORMAT_SHORT_WITH_YEAR: DateFormatOptions;
+export declare function plainDateFormat(pd: PlainDate, options: DateFormatOptions, locale?: string): string;
+export declare function formatMonthYear(year: number, month: number, locale?: string): string;
+/** The shared date-format vocabulary Astryx exposes on `format`:
+ *  `date` "Mar 21, 2026" · `date_long` "March 21, 2026" ·
+ *  `date_weekday` "Wed, Mar 21, 2026" · `system_date` ISO `2026-03-21`. */
+export type SharedDateFormat = 'date' | 'date_long' | 'date_weekday' | 'system_date';
+export type DateInputFormat = SharedDateFormat | ((iso: ISODateString) => string);
+export declare function formatSharedDate(pd: PlainDate, format: SharedDateFormat, locale?: string): string;
+export declare function formatDateValue(iso: ISODateString, format: DateInputFormat | undefined, locale?: string): string;
+/** "Jan 25 – Feb 2" / "Jan 25 – Feb 2, 2026" style trigger text. */
+export declare function formatRangeDisplay(range: DateRange | null | undefined, locale?: string): string;
+export declare function isLocaleDayFirst(locale?: string): boolean;
+/** Parses typed input into a PlainDate — `YYYY-MM-DD`, English month-name
+ *  forms ("March 5", "5 March 2026"), and numeric `M/D/YY` or `D/M/YY`
+ *  (ambiguity resolved by the locale's day/month order). Returns null for
+ *  unparseable or out-of-range input. */
+export declare function parseDateInput(input: string, locale?: string): PlainDate | null;
+export interface ParsedTime {
+    readonly hour: number;
+    readonly minute: number;
+    readonly second: number;
+}
+/** Validate + normalize an `HH:MM[:SS]` string. Returns null when invalid. */
+export declare function parseISOTime(time: string): ParsedTime | null;
+export declare function formatISOTime(time: ParsedTime, includeSeconds?: boolean): ISOTimeString;
+export declare function formatDisplayTime12h(time: ISOTimeString, includeSeconds?: boolean): string;
+export declare function formatDisplayTime24h(time: ISOTimeString, includeSeconds?: boolean): string;
+/** Typed time input: accepts "2:30 PM", "14:30", "1430", "2pm", "143000"
+ *  and ISO `HH:MM[:SS]`; returns a normalized ISOTimeString or null. */
+export declare function parseTimeInput(input: string, includeSeconds?: boolean): ISOTimeString | null;
+export declare function compareTime(a: ISOTimeString, b: ISOTimeString): number;
+export declare function isTimeInRange(time: ISOTimeString, min?: ISOTimeString, max?: ISOTimeString): boolean;
+export declare function clampTime(time: ISOTimeString, min?: ISOTimeString, max?: ISOTimeString): ISOTimeString;
+/** Step a time by whole minutes, wrapping around midnight. */
+export declare function adjustTime(time: ISOTimeString, deltaMinutes: number, includeSeconds?: boolean): ISOTimeString;
+export declare function splitDateTime(dt: ISODateTimeString | undefined): {
+    date?: ISODateString;
+    time?: ISOTimeString;
+};
+export declare function combineDateTime(date?: ISODateString, time?: ISOTimeString): ISODateTimeString | undefined;
+export declare function currentISOTime(includeSeconds?: boolean): ISOTimeString;
+/** Which surface collects the value. `text-input` is TimeInput-only. */
+export type ResolvedInputSurface = 'typed' | 'popover' | 'sheet' | 'native';
+/** Map the deprecated `nativePicker` vocabulary onto `presentation`
+ *  (`touch` → adaptive-native, `always` → native, `never` → the Astryx
+ *  surface: bottom-sheet for pickers, text-input for TimeInput). */
+export declare function presentationFromNativePicker(nativePicker: 'touch' | 'always' | 'never' | undefined, kind: 'date' | 'time' | 'datetime'): import('./props.js').InputPresentation | undefined;
+/** `presentation` wins over the deprecated `nativePicker`. */
+export declare function effectivePresentation(presentation: string | undefined, nativePicker: 'touch' | 'always' | 'never' | undefined, kind: 'date' | 'time' | 'datetime'): import('./props.js').InputPresentation;
+/**
+ * Resolve a presentation + pointer coarseness to a concrete surface.
+ * On native targets pass `isCoarsePointer = true`; `native` there is
+ * remapped by each component leaf (the OS-authentic pickers live in the
+ * `@octane-xplat/date-picker` leaf — ui-internal `native` resolves to the
+ * self-drawn `sheet` surface).
+ */
+export declare function resolveInputSurface(effective: import('./props.js').InputPresentation, isCoarsePointer: boolean): ResolvedInputSurface;
+/** Localized wall-clock display; ISO time remains zone-free and parsing bounded. */
+export declare function formatLocalizedTime(time: ISOTimeString, hasSeconds: boolean, hourFormat: '12h' | '24h', locale: string): string;

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

@@ -0,0 +1,14 @@
+/** Dialog-internal wiring: the header's title becomes the dialog's
+ *  accessible name (web `aria-labelledby`) and the modal autofocus target.
+ *  Scoped to the dialog subtree — on native this context lives inside the
+ *  overlay root, which is still a single Octane root, so context works. */
+export interface DialogContextValue {
+    /** Id the DialogHeader title should stamp on itself. */
+    titleId: string;
+    /** False while `isInline` — title carries no autofocus/label duties. */
+    isModal: boolean;
+}
+export declare const DialogContext: import("octane").Context<DialogContextValue | null>;
+/** JSX-provider form — the universal renderer's context is a callable
+ *  rather than a `.Provider` member (same aliasing as FieldProvider). */
+export declare const DialogProvider: any;

package/types/generated/escape-props.d.ts

@@ -17,4 +17,5 @@ export declare function nativeAccessibilityState(state?: {
     disabled?: boolean;
     selected?: boolean;
     checked?: boolean;
+    pressed?: boolean;
 }): string | undefined;

package/types/generated/escape-props.macos.d.ts

@@ -0,0 +1,5 @@
+/** AppKit doesn't have NativeScript's attached-property bridge. Platform
+ * escape bags are therefore intentionally ignored by this experimental leaf. */
+export declare function applyEscapeProps(_view: unknown, _props: unknown): void;
+export declare function nativeAccessibilityRole(role: unknown): unknown;
+export declare function nativeAccessibilityState(state: unknown): unknown;

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

@@ -0,0 +1,38 @@
+import type { FieldControlProps } from './props.js';
+export interface FieldContextValue extends FieldControlProps {
+    controlId?: string;
+    labelId?: string;
+    descriptionId?: string;
+    statusId?: string;
+}
+export declare const FieldContext: import("octane").Context<FieldContextValue | null>;
+export declare const FieldProvider: any;
+export interface ResolvedFieldControlProps extends FieldControlProps {
+    id?: string;
+    fieldLabel?: string;
+    ariaLabel?: string;
+    ariaLabelledBy?: string;
+    ariaDescribedBy?: string;
+    accessibilityHint?: string;
+    /** True when the control renders inside an `InputGroup`'s surface —
+     *  it should drop its own border/radius/background chrome. */
+    inInputGroup?: boolean;
+}
+/** Resolve wrapper defaults and the accessibility links for a field control. */
+export declare function useFieldControlProps<T extends FieldControlProps & {
+    id?: string;
+    accessibilityLabel?: string;
+    accessibilityHint?: string;
+    web?: Record<string, any>;
+}>(props: T): T & ResolvedFieldControlProps;
+/** Resolve field-control props and report whether a surrounding Field owns
+ *  the label, so third-party controls can compose with Field without nesting. */
+export declare function useFieldControl<T extends FieldControlProps & {
+    id?: string;
+    accessibilityLabel?: string;
+    accessibilityHint?: string;
+    web?: Record<string, any>;
+}>(props: T): {
+    props: T & ResolvedFieldControlProps;
+    inField: boolean;
+};

package/types/generated/form-layout-context.d.ts

@@ -0,0 +1,11 @@
+import type { FormLayoutDirection, FormOptionality } from './props.js';
+export interface FormLayoutContextValue {
+    direction: FormLayoutDirection;
+    defaultOptionality?: FormOptionality;
+}
+/** Layered arrangement context: `Field`/`FormField` switches to a
+ *  horizontal-labels render under `direction === 'horizontal-labels'`, and
+ *  `useFieldControlProps` resolves `aria-required` from
+ *  `defaultOptionality`. Nested FormLayouts shadow the outer value. */
+export declare const FormLayoutContext: import("octane").Context<FormLayoutContextValue>;
+export declare const FormLayoutProvider: any;

package/types/generated/hash-image.d.ts

@@ -0,0 +1,13 @@
+/** Placeholder-hash decoders shared by the Image leaves: `blurhash:` and
+ *  `thumbhash:` URIs decode to a PNG in pure JS so a placeholder is a real
+ *  image on every platform — ImageSource.fromBase64Sync on native, a
+ *  data:image/png URL on web. Decode sizes stay small (~32px); the view's
+ *  own fit/stretch scales the result, same as the final image.
+ *
+ *  blurhash decode is a port of the Wolt reference decoder (MIT);
+ *  thumbHashToRGBA and rgbaToPng are ports of Evan Wallace's thumbhash.js
+ *  (MIT), with the data-URL/btoa tail replaced by byte output so this file
+ *  carries no DOM or platform APIs. */
+export declare function isHashPlaceholder(src: string): boolean;
+/** `blurhash:<hash>` / `thumbhash:<base64>` → PNG bytes as base64, or null. */
+export declare function hashToPngBase64(src: string): string | null;

package/types/generated/hosted-unsupported.macos.d.ts

@@ -0,0 +1 @@
+export declare function CameraView(_props: any): unknown;

package/types/generated/image-content-binding.d.ts

@@ -0,0 +1,64 @@
+import type { ImageContentFit, ImageContentPositionObject, ImageSourceLike } from './props.js';
+export interface ImageContentEnv {
+    /** Platform gate for the intrinsic-size unit conversion — the leaf
+     *  supplies it so this module stays free of '@nativescript/core'. */
+    isAndroid: boolean;
+    /** Device pixel ratio for the L8 pixel-count target. */
+    screenScale: () => number;
+    /** Src write seam — the sized-decode binding (image-sizing.ts) owns WHEN
+     *  a source lands on the view: first-layout gate, decode dims, resize
+     *  reload. `stretchForDecode` overrides the view's stretch for those
+     *  gates on the computed path, whose inner image draws stretch='fill'
+     *  under a different semantic fit ('none' needs the full-resolution
+     *  source to find the natural size). */
+    issue: (view: any, source: any, stretchForDecode?: string) => void;
+}
+export interface ImageContentUpdate {
+    /** The resolved single source (string or ImageSource), null when
+     *  `sources` carries the request. */
+    source: any;
+    /** Resolution-qualified sources (L8) — the binding defers selection
+     *  until a real layout exists, picks the closest pixel count, then
+     *  hands the winner to `issue`. */
+    sources: readonly ImageSourceLike[] | null;
+    /** Resolved CSS fit/position for the computed path. */
+    fit: ImageContentFit;
+    position: ImageContentPositionObject;
+    /** True when the image view lives in a clip host and is laid out by the
+     *  binding (width/height/left/top in dips) — needed for 'none',
+     *  'scale-down', and non-center positions no platform scaleType has. */
+    computed: boolean;
+}
+/** Measure → compute → apply for Image's content contract (study L7).
+ *  NS's stock widget owns its draw path — the widgets ImageView computes
+ *  its own matrix in onDraw and honors only the four stretch scaleTypes —
+ *  so the drawable-level matrix expo-image uses is engine internals. What
+ *  the leaf can own is the view-level equivalent: measure the box
+ *  (`layoutChanged` → `getActualSize`, dips), compute the content rect
+ *  with the same math as object-fit/object-position, and lay out the
+ *  inner <image stretch="fill"> to that rect inside a clipped host. One
+ *  code path produces identical rects on iOS and Android.
+ *
+ *  This binding never writes `src` itself — it resolves WHICH source the
+ *  view should load and hands it to `env.issue`, the sized-decode binding
+ *  (study L1). That seam composes both contracts: the L8 array pick waits
+ *  on the same first real layout the decode gate needs, and the computed
+ *  path passes the semantic fit as the decode gate so 'none' still
+ *  decodes at source resolution while 'fill' would have been
+ *  view-sampled.
+ *
+ *  Before the bitmap's intrinsic size is known the computed path sizes
+ *  the inner image to the host box: a real rect is what lets the decode
+ *  gate's first-layout check pass, and the placeholder is the CSS 'fill'
+ *  answer until imageSourceChange refines it.
+ *
+ *  `update` re-runs on every render (ref identity churn); all writes are
+ *  idempotent. Null refs on detach are ignored — a dead listener is a
+ *  self-contained cycle GC collects with the view. */
+export declare function createImageContentBinding(env: ImageContentEnv): {
+    /** (Re)bind views + intent. `sizeView` is the measured box (the image
+     *  itself on the stretch path, the clip host on the computed path);
+     *  `imageView` is the <image> that draws. */
+    update(nextSizeView: any, nextImageView: any, next: ImageContentUpdate): void;
+    dispose(): void;
+};

package/types/generated/image-content.d.ts

@@ -0,0 +1,56 @@
+import type { ImageContentFit, ImageContentPosition, ImageContentPositionObject, ImageContentPositionValue, ImageSourceLike } from './props.js';
+/** Shared `contentFit`/`contentPosition` + multi-source math for `Image` —
+ *  pure functions used by every leaf (docs/notes/expo-image-study.md L7/L8).
+ *  Semantics mirror CSS `object-fit`/`object-position`, which is also
+ *  expo-image's contract: the leaves compute the drawn-content rect
+ *  themselves instead of delegating to platform scaleType/contentMode,
+ *  so all platforms get the same answer.
+ *
+ *  The default fit is 'cover' everywhere (the expo/RN default). Today's
+ *  platform defaults disagree — web <img> is 'fill' and NS stretch is
+ *  'aspectFit' — so an un-propped Image was silently divergent. */
+export declare const DEFAULT_CONTENT_FIT: ImageContentFit;
+export declare function resolveContentFit(fit?: ImageContentFit): ImageContentFit;
+export declare function resolveContentPosition(position?: ImageContentPosition): ImageContentPositionObject;
+/** Offset of the drawn content's start edge inside the view along one axis.
+ *  expo-image `calcTranslation`: percentages run over the free space
+ *  (view − content), absolute dips measure from the named edge, and the
+ *  reverse edge (right/bottom) counts back from the far side. */
+export declare function contentAxisOffset(viewSize: number, contentSize: number, start: ImageContentPositionValue | undefined, end: ImageContentPositionValue | undefined): number;
+export declare function isCenteredContentPosition(position: ImageContentPositionObject): boolean;
+/** The rect the bitmap occupies inside the view box, in the same units the
+ *  caller measures with (native: dips; web: CSS px via object-fit anyway —
+ *  only the native leaf calls this). Every length unit is dips except the
+ *  intrinsic size, which the leaf must supply in dips too. */
+export declare function contentRect(fit: ImageContentFit, position: ImageContentPositionObject, viewWidth: number, viewHeight: number, imageWidth: number, imageHeight: number): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/** True when no platform stretch/scaleType can express the request and the
+ *  leaf must measure + lay out the image itself: 'none' (iOS maps NS
+ *  stretch='none' to TopLeft, not CSS centered), 'scale-down' (needs the
+ *  intrinsic-vs-view compare), or any non-center position. 'fill' is
+ *  exempt — its rect is always the whole box, so position can't matter. */
+export declare function needsContentRect(fit: ImageContentFit, position: ImageContentPositionObject): boolean;
+/** NS `stretch` for the fast path — only reached for fits the platform
+ *  vocabulary expresses identically (contain/cover/fill centered). */
+export declare function contentFitToStretch(fit: ImageContentFit): 'aspectFit' | 'aspectFill' | 'fill';
+/** L8 — expo `getBestSource`: the source whose declared pixel count
+ *  (`width·height·scale²`, dips × density) is closest to the view's pixel
+ *  count. Needs a real measured size; one source or no size picks nothing
+ *  to decide. Unsized sources score worst and are skipped when any sized
+ *  candidate exists. */
+export declare function bestImageSource(sources: readonly ImageSourceLike[], viewWidth: number, viewHeight: number, screenScale: number): ImageSourceLike | null;
+/** Browser `object-position` for a resolved position — mirrors expo-image
+ *  web's `getObjectPositionFromContentPositionObject`. */
+export declare function objectPositionCSSValue(position: ImageContentPositionObject): string;
+/** Browser `srcset` candidates for a source array: `w` descriptors (real
+ *  file px = width·scale) when every source is sized, `x` descriptors when
+ *  every source only carries density. `src` falls back to the largest
+ *  declared pixel count — guaranteed coverage where srcset is ignored. */
+export declare function imageSrcSet(sources: readonly ImageSourceLike[]): {
+    src: string;
+    srcSet?: string;
+};

package/types/generated/image-sizing.d.ts

@@ -0,0 +1,37 @@
+/** View-sized decode for the native <image> leaf.
+ *
+ *  NS Android reads decodeWidth/decodeHeight only when `src` is written —
+ *  `srcProperty.setNative` → `_createImageSourceFromSrc` →
+ *  `imageView.setUri(value, decodeWidth, decodeHeight, …)` — and the
+ *  properties default to 0 → `Fetcher.calculateInSampleSize` maps
+ *  reqWidth ≤ 0 to the source dims → inSampleSize 1 → a full-resolution
+ *  decode (~48 MB ARGB_8888 per 12 MP photo; docs/notes/expo-image-study.md
+ *  L1). So the leaf holds `src` until the view's first real layout, writes
+ *  the decode dims in device pixels, then assigns src. A later resize
+ *  re-issues at the new size — the same reload expo-image runs from
+ *  onSizeChanged — under the same gate: 'fill'/'none' stretches keep the
+ *  existing decode because a resize can't change the ideal sample there
+ *  ('none' additionally never downsamples — its contract is source
+ *  pixels). iOS ignores the decode dims entirely; the deferred assignment
+ *  is behavior-identical there, so one path serves both platforms.
+ *
+ *  The ref callback re-fires on every render (identity change), so
+ *  `update` must be idempotent: same view + same src + same size is a
+ *  no-op. Null ref calls on detach are ignored by the leaf — re-attaching
+ *  the same view must not lose `applied`, or each render would re-issue
+ *  setUri. The dead-view listener left behind on real unmount is a
+ *  self-contained cycle the GC collects with the component record.
+ *
+ *  `afterIssue` runs right after every `src` write — including a same-src
+ *  resize re-issue mid-load, which fires no `isLoadingChange` (isLoading is
+ *  already true). The Image placeholder hooks this to re-apply its bitmap
+ *  after the write has nulled `imageSource` (L5, decision #103). */
+export declare function createSizedImageBinding(options?: {
+    afterIssue?: (view: any) => void;
+}): {
+    /** (Re)bind source → view; issues once the view reports a real layout.
+     *  `stretchForDecode` overrides view.stretch for the decode/reload
+     *  gates — see `issue`. */
+    update(next: any, source: any, stretchForDecode?: string): void;
+    dispose(): void;
+};

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

@@ -0,0 +1,196 @@
+export { View } from './View.macos.js';
+/** Vertical flow stack (Astryx `Stack` direction="vertical"). */
+export { VStack } from './VStack.macos.js';
+/** Horizontal flow stack (Astryx `Stack` direction="horizontal"). */
+export { HStack } from './HStack.macos.js';
+export { Grid, Stack, StackItem, Absolute, Spacer } from './layout.macos.js';
+export { Center } from './Center.macos.js';
+export { Section } from './Section.macos.js';
+export { AspectRatio } from './AspectRatio.macos.js';
+export { VisuallyHidden } from './VisuallyHidden.macos.js';
+export type { PanEvent, SwipeEvent, SetTranslate } from './props.js';
+export { setTranslate } from './translate.macos.js';
+export { Text, RichText, RichTextSpan } from './Text.macos.js';
+export { Pressable } from './Pressable.macos.js';
+export { Button, Switch, Slider, SegmentedControl, SearchInput } from './controls.macos.js';
+export { IconButton } from './IconButton.macos.js';
+export { ButtonGroup } from './ButtonGroup.macos.js';
+export { ToggleButton, ToggleButtonGroup } from './ToggleButton.macos.js';
+/** Self-drawn checkbox, exported under Astryx's component name. */
+export { Checkbox as CheckboxInput } from './controls.macos.js';
+/** Loading indicator, exported under Astryx's component name. */
+export { ActivityIndicator as Spinner } from './controls.macos.js';
+export { Collapsible } from './Collapsible.macos.js';
+export { Accordion } from './Accordion.macos.js';
+/** Single-choice option list, exported under Astryx's component name. */
+export { RadioGroup as RadioList } from './RadioGroup.macos.js';
+export { DropdownMenu } from './DropdownMenu.macos.js';
+export { MoreMenu } from './MoreMenu.macos.js';
+export { ContextMenu } from './ContextMenu.macos.js';
+export { Badge } from './Badge.macos.js';
+/** Visual separator between content sections, exported under Astryx's name. */
+export { Separator as Divider } from './Separator.macos.js';
+export { Skeleton } from './Skeleton.macos.js';
+export { Avatar } from './Avatar.macos.js';
+export { AvatarGroup } from './AvatarGroup.macos.js';
+/** Labeled control wrapper, exported under Astryx's component name. */
+export { FormField as Field } from './FormField.macos.js';
+export { useFieldControl } from './field-context.js';
+export { FieldGroup } from './FieldGroup.macos.js';
+/** Reusable labeled row, exported under Astryx's component name. */
+export { Item } from './Item.macos.js';
+export { List } from './List.macos.js';
+export { ListItem } from './ListItem.macos.js';
+export { FormLayout } from './FormLayout.macos.js';
+export { InputGroup, InputGroupText } from './InputGroup.macos.js';
+export { CheckboxIndicator } from './CheckboxIndicator.macos.js';
+export { CheckIndicator } from './CheckIndicator.macos.js';
+export { RadioIndicator } from './RadioIndicator.macos.js';
+export { defaultIndicators, getIndicator, registerIndicator, registerIndicators, useIndicator, indicatorScope, } from './indicators.js';
+export type { FieldControlProps, FieldStatus, FieldStatusType, AbsoluteProps, AspectRatioFit, AspectRatioProps, AspectRatioShape, CenterAxis, CenterProps, FormLayoutDirection, FormLayoutProps, FormOptionality, HStackProps, InputGroupProps, InputGroupSize, InputGroupTextProps, IndicatorComponent, IndicatorFamily, IndicatorFamilyMap, IndicatorMap, IndicatorName, IndicatorNameOfFamily, IndicatorPosition, IndicatorProps, IndicatorRegistry, IndicatorSize, IndicatorState, ListDensity, ListItemProps, ListMarkerStyle, ListProps, ListStyle, SectionDividerSide, SectionProps, SectionVariant, StackAlignment, StackCrossAlignment, StackDirection, StackItemCrossAlignSelf, StackItemProps, StackItemSize, StackMainAlignment, StackPaddingProps, StackProps, StackSizeProps, StackWrap, SpacingStep, VStackProps, VisuallyHiddenProps, } from './props.js';
+/** Bounded numeric entry, exported under Astryx's component name. */
+export { InputNumber as NumberInput } from './InputNumber.macos.js';
+export { PinInput } from './PinInput.macos.js';
+/** Option picker, exported under Astryx's component name. */
+export { Select as Selector } from './Select.macos.js';
+/** Multi-choice option picker, exported under Astryx's component name. */
+export { SelectMenu as MultiSelector } from './aliases.macos.js';
+export { BaseTypeahead, Typeahead } from './Typeahead.macos.js';
+export { TypeaheadItem } from './TypeaheadItem.macos.js';
+export { createStaticSource } from './typeahead-source.js';
+export { Token } from './Token.macos.js';
+export { Tokenizer } from './Tokenizer.macos.js';
+export { ComplexSelector } from './ComplexSelector.macos.js';
+export { Calendar } from './Calendar.macos.js';
+export { DateInput } from './DateInput.macos.js';
+export { TimeInput } from './TimeInput.macos.js';
+export { DateTimeInput } from './DateTimeInput.macos.js';
+export { DateRangeInput } from './DateRangeInput.macos.js';
+export { useCalendarDays, useCalendarConstraints, useCalendarNavigation } from './calendar-hooks.js';
+export { isSameDay, isDateInRange, getWeekNumber } from './calendar-core.js';
+export type { CalendarDay, CalendarMonthGrid } from './calendar-core.js';
+export type { UseCalendarDaysOptions, UseCalendarDaysReturn, UseCalendarConstraintsOptions, UseCalendarConstraintsReturn, UseCalendarNavigationOptions, UseCalendarNavigationReturn, } from './calendar-hooks.js';
+export { InputRating } from './InputRating.macos.js';
+/** Multi-choice checkbox list, exported under Astryx's component name. */
+export { CheckboxGroup as CheckboxList } from './CheckboxGroup.macos.js';
+/** Ancestor path trail, exported under Astryx's component name. */
+export { Breadcrumb as Breadcrumbs } from './Breadcrumb.macos.js';
+export { Pagination } from './Pagination.macos.js';
+export { Stepper } from './Stepper.macos.js';
+export { NavigationMenu } from './NavigationMenu.macos.js';
+export { AppShell } from './AppShell.macos.js';
+export { AppShellMobileContext } from './AppShell.macos.js';
+export { TopNav, TopNavHeading, TopNavItem, TopNavMenu, TopNavMegaMenu, TopNavMegaMenuItem, TopNavMegaMenuFeaturedCard, } from './TopNav.macos.js';
+export { TopNavRenderContext, useTopNavRenderMode } from './TopNav.macos.js';
+export { SideNav, SideNavSection, SideNavHeading, SideNavItem, SideNavCollapseButton, useSideNavCollapse, SideNavRenderContext, useSideNavRenderMode, } from './SideNav.macos.js';
+export { MobileNav, MobileNavToggle, useAppShellMobile } from './MobileNav.macos.js';
+export { NavIcon } from './NavIcon.macos.js';
+export { NavHeadingMenu, NavHeadingMenuItem } from './NavMenu.macos.js';
+export { NavHeadingMenuContext, NavHeadingCloseContext, useNavHeadingMenuContext, useNavHeadingCloseContext, } from './NavMenu.macos.js';
+export { TabList, Tab, TabMenu, useTabListContext } from './TabList.macos.js';
+export { Toolbar } from './Toolbar.macos.js';
+export { OverflowList } from './OverflowList.macos.js';
+export { useResizable } from './useResizable.macos.js';
+export { ResizeHandle } from './ResizeHandle.macos.js';
+export { pixel, percent } from './resize-math.js';
+export { CommandPalette } from './CommandPalette.macos.js';
+export { Table } from './Table.macos.js';
+export { Timeline } from './Timeline.macos.js';
+/** Expandable hierarchy, exported under Astryx's component name. */
+export { Tree as TreeList } from './Tree.macos.js';
+export { Alert } from './Alert.macos.js';
+export { Card } from './Card.macos.js';
+export { ClickableCard } from './ClickableCard.macos.js';
+export { SelectableCard } from './SelectableCard.macos.js';
+export { Chip } from './Chip.macos.js';
+export { Kbd } from './Kbd.macos.js';
+/** Empty-state block, exported under Astryx's component name. */
+export { Empty as EmptyState } from './Empty.macos.js';
+export { Banner } from './Banner.macos.js';
+export { User } from './User.macos.js';
+export { ProgressGroup } from './ProgressGroup.macos.js';
+export { Drawer } from './Drawer.macos.js';
+export { HoverCard } from './HoverCard.js';
+export { useHoverCard } from './use-hover-card.js';
+export { useLayer } from './use-layer.js';
+export { Tooltip } from './Tooltip.js';
+export { Markdown, MarkdownScreen } from './Markdown.js';
+export { parseMdDoc, parseMdNodes, mdInlineText } from './markdown-parse.js';
+export { createMarkdownIncrementalState, parseMarkdownIncremental, trimStreamingArtifacts, computeBoundaries, computeSegments, markdownTextLength, } from './markdown-stream.js';
+export type { MarkdownIncrementalState, MdTextSegment } from './markdown-stream.js';
+export { Link } from './Link.macos.js';
+export { NavLink } from './NavLink.macos.js';
+export { TextInput, TextArea } from './text-controls.macos.js';
+export { ScrollableArea } from './ScrollableArea.macos.js';
+export { useScrollableArea } from './use-scrollable-area.macos.js';
+export { VirtualList } from './VirtualList.macos.js';
+export { Image } from './Image.macos.js';
+export { PowerSearch, PowerSearchToken, PowerSearchFilterEditor } from './PowerSearch.macos.js';
+export { createPowerSearchConfig, usePowerSearchConfig, resolveOperatorLabel, } from './power-search-config.js';
+export { WebView } from './WebView.macos.js';
+export { CameraView } from './hosted-unsupported.macos.js';
+export { Overlay, Popover } from './surfaces.macos.js';
+export { Dialog, DialogHeader } from './Dialog.macos.js';
+export { AlertDialog } from './AlertDialog.macos.js';
+export { BottomSheet, BottomSheetSwitcher } from './BottomSheet.macos.js';
+export { Carousel } from './Carousel.macos.js';
+export { Lightbox } from './Lightbox.macos.js';
+export { useLightbox } from './use-lightbox.macos.js';
+export { Toast } from './Toast.macos.js';
+export { ToastViewport } from './toast-viewport.macos.js';
+export { showToast, useToast } from './toast-service.macos.js';
+export { useImperativeDialog } from './use-imperative-dialog.macos.js';
+export { useImperativeAlertDialog } from './use-imperative-alert-dialog.macos.js';
+export { useAnimation } from './anim.macos.js';
+export { useThemeScheme, getThemeScheme, setThemePreference, getThemePreference, themeSchemeClasses, onThemeSchemeChange, applyThemeClasses, } from './theme/theme-scheme.js';
+export { useColorScheme, getColorScheme } from './colorScheme.macos.js';
+export { styled } from './styled.macos.js';
+export { openWindow } from './windows.macos.js';
+export { Screen } from './Screen.macos.js';
+export { Tabs } from './Tabs.macos.js';
+export type { TabSpec } from './props.js';
+export { SafeArea } from './layout-shells.macos.js';
+export { KeyboardAvoiding } from './KeyboardAvoiding.macos.js';
+export type { KeyboardAvoidingProps } from './props.js';
+export { useSafeAreaInsets } from './safeAreaInsets.macos.js';
+export type { SafeAreaInsets } from './safeAreaInsets.macos.js';
+export { useMeasure } from './useMeasure.macos.js';
+export { Meter, Heading } from './macos-extras.macos.js';
+export { Icon } from './Icon.macos.js';
+export { registerIcon, registerIcons } from './icons.js';
+export type { IconGlyph } from './icons.js';
+export declare const isNative: true;
+export { registerStack, getStack, stackEntries } from './stacks.macos.js';
+export { pushRoute, popRoute, routeStacks, pushDeepLink, routeFor, currentRoute, currentModalRoute, canGoBack, useCanGoBack, useRoute, useModalRoute, redirect, addBackInterceptor, registerScreens, registerRoutes, addRoutes, screenFor, hrefFor, layoutsFor as layoutsForRoute, errorBoundaryFor, } from './route.macos.js';
+export { RouteBoundary } from './RouteBoundary.macos.js';
+export { deriveRouteManifest, defineRoutes, mergeRouteManifests } from './route-table.js';
+export { createStore } from './store.js';
+export type { Store, ReadableStore } from './store.js';
+export { useStore } from './useStore.macos.js';
+export { openBottomSheet, closeBottomSheet, bottomSheetHost } from './bottom-sheet-service.macos.js';
+export { Blockquote } from './Blockquote.macos.js';
+export { Code } from './Code.macos.js';
+export { CodeBlock } from './CodeBlock.macos.js';
+export { MetadataList } from './MetadataList.macos.js';
+export { MetadataListItem } from './MetadataListItem.macos.js';
+export { Thumbnail } from './Thumbnail.macos.js';
+export { ProgressBar } from './ProgressBar.macos.js';
+export { StatusDot } from './StatusDot.macos.js';
+export { Timestamp } from './Timestamp.macos.js';
+export { Timer } from './Timer.macos.js';
+export { Citation } from './Citation.macos.js';
+export { Outline } from './Outline.macos.js';
+export { useOutlineFromMarkdown, useOutlineFromDoc } from './outline-hooks.js';
+export { useOutlineFromDOM } from './outline-dom.macos.js';
+export { parseOutlineFromMarkdown, outlineFromDoc, markdownHeadings, inlineMarkdownText, slugify, uniqueSlug, } from './outline-utils.js';
+export { tokenize, tokenizeAsync, tokenizeStreaming, flatTokensToLines, SYNC_TOKENIZE_THRESHOLD, TOKEN_TYPES, syntaxTokenVar, syntaxTokenVarRef, } from './code-tokenizer.js';
+export type * from './props.js';
+export { ChatComposer, ChatComposerDrawer, ChatComposerInput, ChatComposerTokenElement, ChatDictationButton, ChatLayout, ChatLayoutScrollButton, ChatMessage, ChatMessageBubble, ChatMessageList, ChatMessageMetadata, ChatSendButton, ChatSystemMessage, ChatTokenizedText, ChatToolCalls, useChatComposerContext, useChatComposerTokens, useChatDictation, useChatLayoutContext, useChatNewMessages, useChatPasteAsToken, useChatStreamScroll, useSpeechRecognition, } from './index.shared.js';
+export { DropdownMenuItem, DropdownMenuDivider, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSubMenu, } from './MenuParts.macos.js';
+export { DropdownMenuItem as ContextMenuItem, DropdownMenuDivider as ContextMenuDivider, DropdownMenuCheckboxItem as ContextMenuCheckboxItem, DropdownMenuRadioGroup as ContextMenuRadioGroup, DropdownMenuRadioItem as ContextMenuRadioItem, DropdownMenuSubMenu as ContextMenuSubMenu, } from './MenuParts.macos.js';
+export { DropdownMenuItem as BreadcrumbMenuItem, DropdownMenuDivider as BreadcrumbMenuDivider, DropdownMenuCheckboxItem as BreadcrumbMenuCheckboxItem, DropdownMenuRadioGroup as BreadcrumbMenuRadioGroup, DropdownMenuRadioItem as BreadcrumbMenuRadioItem, DropdownMenuSubMenu as BreadcrumbMenuSubMenu, } from './MenuParts.macos.js';
+export { DropdownMenuContext, useDropdownMenuContext } from './menu-context.js';
+export type { MenuOption, MenuItemData, MenuActionData, MenuDividerData, MenuCheckboxData, MenuRadioOptionData, MenuRadioGroupData, MenuItemProps, MenuCheckboxItemProps, MenuRadioGroupProps, MenuRadioItemProps, MenuDividerProps, MenuSubMenuProps, MenuContextValue, } from './props.js';
+export type { MenuItemProps as DropdownMenuItemProps, MenuDividerProps as DropdownMenuDividerProps, MenuCheckboxItemProps as DropdownMenuCheckboxItemProps, MenuRadioGroupProps as DropdownMenuRadioGroupProps, MenuRadioItemProps as DropdownMenuRadioItemProps, MenuSubMenuProps as DropdownMenuSubMenuProps, } from './props.js';
+export type { MenuItemProps as ContextMenuItemProps, MenuDividerProps as ContextMenuDividerProps, MenuCheckboxItemProps as ContextMenuCheckboxItemProps, MenuRadioGroupProps as ContextMenuRadioGroupProps, MenuRadioItemProps as ContextMenuRadioItemProps, MenuSubMenuProps as ContextMenuSubMenuProps, } from './props.js';
+export type { MenuItemProps as BreadcrumbMenuItemProps, MenuDividerProps as BreadcrumbMenuDividerProps, MenuCheckboxItemProps as BreadcrumbMenuCheckboxItemProps, MenuRadioGroupProps as BreadcrumbMenuRadioGroupProps, MenuRadioItemProps as BreadcrumbMenuRadioItemProps, MenuSubMenuProps as BreadcrumbMenuSubMenuProps, } from './props.js';