Nexamas.UI

A strongly-typed resource class, for looking up localized strings, etc.

Returns the cached ResourceManager instance used by this class.

Overrides the current thread's CurrentUICulture property for all resource lookups using this strongly typed resource class.

Defines how the ImageViewer chrome is presented around the media stage. AutoHide keeps the image dominant and reveals commands during interaction; Pinned reserves a stable command strip; Hidden suppresses command chrome.

Defines how the image bitmap is fitted inside the owned viewport. Cover preserves the historical media-preview behavior; Contain is used by proof/review surfaces that must show the complete PNG without cropping.

Friend-only viewport math for MASImageViewer. It keeps fitting, displayed bounds, pan limits, and cursor anchored zoom in one deterministic place so the visual shell does not own transform arithmetic.

Historical compatibility marker for the former centralized component registry file.

Built-in architecture descriptors are now split by owner family and aggregated through MASArchitectureProviderManifest. This class intentionally no longer implements IMASComponentRegistrationProvider, so it cannot become a second registration hotspot.

Historical compatibility marker for the former centralized component relation provider.

Built-in relation declarations are now split by ownership family and aggregated through MASArchitectureProviderManifest. This class intentionally no longer implements IMASComponentRelationProvider.

Architecture relation declarations for FloatRuntime dialog contracts and their shared PanelShell chrome surface. Legacy GroupBox-backed FloatPanel relations were intentionally removed. Generic floating panels now use MASPanelShellFloatHost through the ShowPanelShell gateway.

Architecture relation declarations for file/navigation composite component ownership.

Architecture relation declarations for Media components hosted by the shared PanelShell chrome.

Architecture relation declarations for menu/dropdown component ownership.

MASMenuButton is intentionally declared as an external WinForms trigger because it is not a registered MAS architectural component. The registered MAS endpoint remains the DropDownMenu float contract owned by ArchitectureSystem/FloatRuntime.

Architecture relation declarations for the Phase-1 product-size controls.

These declarations intentionally describe system-level readiness relations only. They are not a visual-child inventory and they do not claim that source-projection, persistence, or virtualization engines are registered architectural components. Friend-only readiness gates consume this provider to distinguish "registered/addable" from "registered/addable/relation-covered" product controls.

Built-in architecture descriptors owned by the Rendering family.

Reserved built-in architecture descriptor provider for ThemeSystem-owned architectural components.

Theme facts are currently validated through MASThemeContractRegistry and NexamasUIContractRegistry, not through concrete IMASArchitecturalComponent descriptors owned by ThemeSystem. This provider intentionally returns no descriptors while remaining in the explicit manifest so the empty scope is documented and cannot be confused with a missing registration path.

Built-in architecture descriptors owned by the Composition family.

Built-in architecture descriptors owned by the FloatRuntime family. Legacy GroupBox-backed panel float contracts were intentionally removed. Generic application panels are now represented by the PanelShell-backed ShowPanelShell gateway and the MASPanelShellFloatHost registration.

Built-in architecture descriptors owned by the TextInput family.

Built-in architecture descriptors owned by the Controls family.

Built-in architecture descriptors owned by the Media component family.

Official Nexamas UI split button: a primary MAS action surface plus a dedicated dropdown affordance. Menu content is always hosted through MASDropDownMenuBuilder and FloatRuntime; the control does not create a parallel popup/menu renderer.

Friend-owned segmentation policy for MASSplitButton. It centralizes RTL segment geometry, keyboard segment movement, normalized values, and activation rules while preserving the single DropDownMenu/FloatRuntime route.

Friend-owned command, text, enum, and enabled-state policy for MASButton. The public control remains the only consumer API; this class keeps runtime safety and premium interaction semantics out of the visual/control partials.

Public button personality contract used by MASButton and button theme resolution. Uses the MAS-prefixed public naming convention required by the canonical SDK surface.

Internal immutable button rendering/action specification used by MAS-owned composite surfaces such as MessageBox and PanelShell command rows. Consumer applications configure buttons through MASButton or application facades; they should not construct renderer/layout specs directly.

Provides semantic button surface adaptation rules. Architectural Law: - Surface policies may adapt semantic interaction states. - They must not erase local component material identity. - Visual tuning remains the responsibility of renderers.

Shared internal resize interaction policy for Nexamas UI surfaces that expose column or pane resize affordances. It keeps drag math deterministic, DPI-safe, bounded, and lightweight so controls do not duplicate fragile pointer logic.

Small reusable horizontal drag-resize state machine. It owns only pointer math and stability thresholds; each control remains responsible for model updates, rendering, and public events.

Public sort direction used by MASDataView and MASDataGrid. The enum is intentionally small so consumer code does not depend on internal comparer, filter, or virtualization details.

Public selection mode for MASDataGrid. Selection remains index-based and independent from realized visual rows.

Controls when MASDataGrid prepares and displays the fixed summary footer. Automatic protects large-data loading by skipping eager summaries beyond SummaryAutoPreparationRowLimit. Always opts into full summary preparation, and Disabled hides the footer completely.

Public column descriptor for MASDataGrid. It describes stable data identity, header text, width policy, and editing flags; rendering, resize hit testing, and layout slots remain Nexamas UI-owned internals.

Optional value type hint used by MASDataView sorting and MASDataGrid text formatting. TypeCode.Empty keeps automatic inference from the row values so existing consumers do not need to configure a type for basic grids.

Internal notification payload used by MASDataView to distinguish visual-only column edits from projection-changing and summary-affecting edits.

Public row data container for MASDataView. Values are addressed by column key so sorting, filtering, clipboard, and editing can operate without depending on realized visual cells.

Friend-only row change payload consumed by MASDataView to distinguish value changes from visual modified-state changes. This prevents visual-only row updates from forcing large filter/sort projection rebuilds.

Public non-visual data model for MASDataGrid. It owns columns, logical rows, filtering, sorting, and visible-row projection while rendering, input routing, scrolling, and virtualization remain owned by MASDataGrid and Nexamas UI systems.

Defers expensive projection refresh notifications while a consumer adds or changes many rows/columns. The projection stays lazy and is rebuilt once when the scope is disposed, preventing large-data setup from becoming O(n²).

Adds many already-created rows under one refresh notification. This is the preferred loading path for large tables because projection, summary, and visual invalidation are coalesced at scope exit.

Creates and adds many value rows under one refresh notification. Each Object() entry maps to the current column set exactly like AddRow(ParamArray values), but without per-row Changed storms.

Replaces the complete row set under one refresh notification. Existing row event handlers are detached before the replacement is attached, so reloads avoid stale subscriptions and O(n²) refresh work.

Replaces the complete row set from value arrays under one refresh notification.

Reference-only membership comparer used by MASDataView to keep duplicate-instance checks O(1) without changing the public equality semantics of row or column models.

Friend-only culture snapshot for MASDataView projection, filtering, sorting, grouping, summaries, clipboard, and cell text formatting. It prevents DataGrid/DataView from reading CultureInfo.CurrentCulture opportunistically while a cached projection is still considered fresh.

Friend-only row identity index owned by MASDataView. It keeps source-row and visible-row lookups out of renderer/selection loops so selection preservation after large sort/filter changes does not scan the entire visible projection repeatedly.

Friend-only stable visible-row comparer used by MASDataView projection. It captures the sort column once per projection rebuild so large typed sorts do not repeatedly resolve column metadata during List.Sort comparisons.

Renderer-facing summary facts for one DataGrid footer cell. Summary calculation stays in MASDataView-owned internals; the renderer only consumes these immutable facts.

Immutable footer summary row facts aligned to the DataGrid column indexes. It is intentionally Friend-only so DataGrid can gain commercial summary visuals without introducing a premature public summary API.

Immutable DataView-owned summary footer snapshot. Rendering may read this object, but only MASDataView prepares it from the current visible-projection revision so aggregation never happens inside the DataGrid render pass.

Friend-only owner for DataGrid summary preparation admission. Projection refresh may be rebuilt by MASDataView, but full summary aggregation is admitted only through this policy so large-data refresh cannot accidentally become an eager aggregation path.

DataView-owned cache for summary footer snapshots. The cache is invalidated by MASDataView data/filter/sort/column changes and rebuilt by DataView refresh ownership before rendering reads it.

Friend-only typed summary calculator for MASDataView visible rows. It owns count/sum/average/min/max facts before the renderer paints the fixed footer row; no summary math is performed inside MASDataGridRenderer.

Internal filter operator set used by MASDataView projection. It intentionally stays Friend so filter syntax can evolve without expanding the public DataGrid API surface before a dedicated filter UI/API design pass.

Friend-only parsed filter token. A token may search all visible columns or a single column resolved by key.

Immutable internal projection plan for MASDataView filtering. It is built from the existing FilterText public entry point.

Friend-only precomputed filter context used by MASDataView projection. It is built once per projection rebuild so 10k/100k-row filtering does not allocate a visible-column list or perform column-key scans for every row.

Friend-only parser for MASDataView.FilterText. It keeps advanced filter syntax behind the existing official entry point. Supported forms include free text, quoted free text, column:value, column=value, column!=value, column>value, column>=value, column<value, and column<=value.

Friend-only typed filter evaluator used by MASDataView projection. It owns matching semantics while rows and columns stay passive data descriptors.

Internal delimiter contract for DataGrid clipboard/export text generation. It intentionally stays Friend so the public DataGrid API does not grow a separate export subsystem before a dedicated product API pass.

Internal value selection mode for DataGrid clipboard/export text generation.

Friend-only profile for deterministic DataGrid clipboard/export text generation. Profiles are consumed by MASDataGrid and test/proof paths only; public consumers continue to use the existing CopySelectionText() route.

Friend-only DataGrid clipboard/export text builder. It centralizes range normalization, value-mode handling, header inclusion, and TSV/CSV escaping so MASDataGrid does not grow scattered clipboard formatting logic.

Friend-only DataView grouping bucket. It records grouped projection facts for menu/export/proof paths without exposing a second public data model and without adding renderer-owned grouping logic.

Immutable Friend-only snapshot of the current MASDataView grouping projection. It is evidence/read-model state only; filtering, sorting, rendering, virtualization, and selection ownership stay in their existing DataGrid systems.

Friend-only grouped projection builder for MASDataView. It reorders the already filtered/sorted visible row index list by group key while preserving the existing in-group order, so grouping remains a DataView projection concern and does not create renderer, virtualization, or row-wrapper paths.

Public immutable cell address used by MASDataGrid events and editing APIs. It identifies logical visible-row and column indexes without exposing visual realization containers.

Event payload for committed DataGrid cell edits. The payload reports logical facts only and does not expose renderer or editor internals.

Renderer-facing immutable facts for a DataGrid inline edit session. It intentionally carries text/caret/validation facts only; it does not expose the editing controller or cell mutation services to rendering.

Internal validation result for a DataGrid inline edit commit. It is intentionally renderer/control-facing only so validation feedback can harden the editing workflow without expanding the public DataGrid API surface.

Internal inline edit session for MASDataGrid cells. It reuses the official MAS text-input controller for text mutation, caret movement, selection, undo, and redo while keeping all DataGrid editing visuals and lifetime DataGrid-owned.

Immutable column layout result used by MASDataGrid rendering and hit testing. It carries the realized viewport-owned column set plus full logical bounds so off-screen selected columns can be scrolled into view without forcing render paths to scan every column.

Immutable realized-column plan for MASDataGrid. It is produced from the horizontal viewport and keeps header, cell, footer, resize, and hit-test paths on the same viewport-owned column set instead of letting each path scan every column independently.

Internal column viewport cache for MASDataGrid. It owns DPI-normalized column metrics, cumulative offsets, and realized-column selection so wide grids reuse a stable column index instead of recomputing full geometry during every render, mouse move, resize hit-test, and footer/header paint pass.

Resolves DataGrid column rectangles from the public column width policy. The engine is internal and side-effect free so column geometry stays owned by Nexamas UI layout/rendering rather than by consumer code. Runtime DataGrid instances use MASDataGridColumnViewportCache so wide-column layouts are cached and realized through the horizontal viewport.

Internal horizontal viewport coordinator for MASDataGrid wide-column scenarios. It consumes the shared MAS ScrollModel for offset clamping while leaving visual scrollbar painting and vertical row virtualization to the existing MAS scroll and virtualization systems.

Internal policy that decides when the DataGrid may protect a leading column while the rest of the grid moves through the horizontal viewport. The policy deliberately stays Friend-only so pinning remains a MAS-owned wide-grid behavior until a future public contract is intentionally designed.

Internal coordinator from MASDataGrid row facts to the shared MASVirtualizedItemsSystem. This is not a shortcut layer over a broken system; it is the official consumer coordinator that keeps DataGrid from owning a private virtualization engine.

Severity for DataGrid foundation readiness findings.

Internal readiness finding for Phase 3 DataGrid. Findings use stable codes so the harness and commercial gate can detect drift without parsing human text.

Friend-only counters for DataView conversion failures. The grid keeps fail-closed filtering, sorting, and summary behavior, but malformed typed values become inspectable readiness diagnostics instead of silent data loss or unexplained summaries.

Internal readiness report for MASDataGrid Phase 3. It records data-shape, measurement, virtualization, and verification readiness without exposing internal gate machinery as public SDK API.

Premium readiness gate for MASDataGrid/MASDataView. The gate proves that the control has a real data model, valid row metrics, valid column policy, and a healthy shared virtualization dependency before it is considered a commercial SDK surface.

Final internal commercial runtime closure status for MASDataGrid.

Immutable internal final-closure manifest for MASDataGrid commercial runtime readiness.

This contract does not create controls, render, mutate scroll state, execute captures, run performance scenarios, allocate bitmap resources, or expose a public telemetry API. It only records closure facts over an already-built MASDataGridReadinessReport plus static ownership evidence from RenderVerification and Virtualization catalogs.

Friend-only immutable visual facts for a resolved DataGrid cell. This keeps empty/null/read-only/modified/typed presentation decisions inside Nexamas UI rendering ownership without expanding the SDK DataGrid API surface.

Internal renderer for MASDataGrid. It paints deterministic header, grid lines, selected rows/cells, and typography-backed text from resolved DataView facts; it does not sort, filter, scroll, edit, or own virtualization.

Per-call paint owner for hot DataGrid cell rendering paths. It avoids per-cell SKPaint allocation while keeping mutable paint state local to the render call.

Supplies DataGrid-owned scenario facts to the central MASRenderVerificationTargetCatalog. This class does not create targets and is not consumed directly by Showcase or runners; the Render Verification catalog remains the only owner of target grouping and execution identity.

Public SDK DataGrid control for tabular data presentation. The control exposes a compact product API for columns, rows, sorting, filtering, selection, clipboard, and edit commits while its rendering, scrolling, layout, and virtualization integration remain Nexamas UI-owned internals.

Binds the root-owned runtime services used by the internal DataGrid column-menu surface. The services remain Friend-only and keep DataGrid away from root-host/application facades.

Controls whether the fixed summary footer is prepared automatically, forced for all row counts, or hidden. Automatic is the commercial-safe default for large data sets.

Maximum source-row count for eager summary preparation when SummaryFooterMode is Automatic. Values below zero are normalized to zero, which disables eager preparation in Automatic mode.

Resolves the footer drawing rect after ScrollRailPolicy has produced the row content rect. The footer aligns to the row content lane and intentionally excludes the vertical scroll rail.

Internal deterministic-scene/layout helper used by Nexamas UI-owned hosts. It mirrors the existing component fluent pattern while keeping raw BoundsLogical setter non-public.

Begins a coalesced DataGrid update. Dispose the returned scope after adding/changing many rows or columns so projection, summary, and rendering invalidation happen once.

Adds many rows with one DataView change notification. Prefer this over repeated AddRow calls when loading large tables.

Creates and adds many value rows with one DataView change notification.

Replaces the complete row set with one DataView change notification. This is the safest public gateway for initial or large reloads.

Replaces the complete row set from value arrays with one DataView change notification.

Updates the horizontal wide-column viewport during a render pass without requesting a nested invalidation. The same render pass consumes the new/clamped offset immediately when resolving the column layout, so a second frame request here would only create render/layout churn.

Marks the DataGrid render/layout phase as active for scroll-adapter invalidation requests. Scroll metric changes discovered while rendering are consumed by the current frame and must not recursively request another frame through the host invalidation route.

Official DataGrid scroll-adapter invalidation bridge. Input/scroll interactions outside render still invalidate normally, while scroll metric invalidations raised from inside Render are coalesced because the current render pass already consumed the updated metrics.

Internal responsive layout plan for MASDataGrid. The plan keeps the grid tied to the official runtime size profile and the available bounds without changing the DataGrid data/view model or introducing a second layout system.

Public two-slot color selection control. The exposed contract is limited to primary/secondary colors, active slot, optional apply toggle, and high-level editing events; HSV state, layout, rendering, hit testing, and toggle composition remain internal Nexamas UI implementation details.

Updates both public color slots as one atomic color-picker operation and raises at most one ColorChanged event. This avoids leaking intermediate primary/secondary states to consumers.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-owned geometry policy for the circular premium ColorPicker composition. The public MASColorPicker API stays stable while the element is rebuilt around one coherent color-selection center: hue wheel, saturation/value disc, Primary and Secondary role arcs, and a compact apply-preview toggle. No legacy preview stack or duplicated role-card layout is produced here.

Friend-owned premium composition policy for MASColorPicker. It keeps the public color-picker contract unchanged while centralizing product-facing labels, circular role identity, compact text sizing, and contrast decisions.

Defines MessageBox content metrics only. Panel chrome, header, close button, outer padding, and corner geometry are owned by MASPanelShell. The shell uses a preferred size for short messages and may grow internally up to the configured maximum height before delegating overflow to the MAS Scroll stack.

Public progress tone/state contract used by MASProgressBar.VisualState and fluent state helpers. It is intentionally small and stable so external projects do not need access to renderer or theme internals.

Internal layout authority for MASCheckBox. It keeps checkbox geometry, text fitting, preferred size, and pointer-hit width in one MAS-owned place so renderers and controls do not calculate parallel selection layouts.

MAS-owned checkbox renderer. It is intentionally Friend: external applications configure MASCheckBox only, while this painter consumes the internal architecture contract, layout helper, and theme selection model.

Public MAS checkbox control. External projects configure semantic state through Text, Checked, CheckedChanged, and the fluent creation helpers; painting, layout measuring, hit testing, and theme resolution remain Nexamas UI-owned internals.

Creates a new MAS checkbox using the standard SDK entry pattern.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-owned selection and interaction policy for MASCheckBox. The public checkbox remains a compact Boolean choice control while text normalization, toggle eligibility, keyboard semantics, cancel behavior, and hit geometry stay MAS-owned and reusable by renderer/gate evidence without adding public API.

Public Nexamas UI single-selection dropdown input. The control owns selection, keyboard behavior, and the public item mutation gateway; its dropdown float content remains an internal FloatRuntime detail.

Raised when the effective selected index/text changes through the public selection gateway. Handler exceptions are contained at the Nexamas UI boundary and routed to diagnostics.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Performs the final internal geometry guard before the ComboBox dropdown enters FloatRuntime. The popup must always stay a compact explicit-bounds float and must never fall back to the full host surface because of invalid or inverted layout data.

Replaces the combo-box items through the supported mutation gateway. The dropdown is closed before mutation so no open float keeps stale layout/selection state.

Appends items through the supported mutation gateway. Direct mutation of the item store is intentionally not exposed to consumers.

Clears all items and closes any owned dropdown float.

Read-only view of the current item text. Consumers must mutate the collection through SetItems, AddItems, or ClearItems so layout, selection, and dropdown ownership remain synchronized.

Number of items currently owned by the combo-box item store.

Gets or sets the selected item index. Invalid indexes normalize to -1.

Accepts the root-owned runtime services used for internal dropdown hosting. This is an internal framework contract; external projects continue to use MASComboBox only.

Internal responsive layout facts for MASComboBox field and popup geometry. This keeps field chrome, dropdown gap, popup height, and popup row metrics tied to the central runtime size profile instead of raw token*dpi sizing.

Friend-only evidence for MASComboBox round-02 refinement. The manifest records that ComboBox stays on the official FloatRuntime + ListPopup route while hardening dropdown lifecycle, item-store mutation, keyboard traversal/search, selection sync, and compact popup geometry without exposing a native combo wrapper or public list API.

Official Nexamas UI month-view calendar surface. It complements DatePicker and DateRangePicker by displaying a navigable month grid with selection, culture-aware weekday order, RTL-aware navigation, date-range disablement, today/selected states, and MAS-owned premium surface drawing. Agenda storage, recurrence, reminders, provider sync, and scheduler engines remain outside it.

Friend-owned policy for MASCalendarView. It centralizes date normalization, culture-aware month/week labels, range clamping, RTL detection, theme color resolution, and explicit non-goals for agenda/scheduler ownership.

Friend-only readiness status for the MASCalendarView public month-view control.

Friend-only evidence for MASCalendarView. It proves that the public element is a governed month-view control and not a scheduler, agenda store, reminder service, external provider bridge, or DatePicker popup wrapper.

Public Nexamas UI date input control. The visible control is an input-like popup trigger; the calendar grid is MAS-owned internal float content so DatePicker does not create a second public Calendar API surface.

Raised when the effective selected date changes through the official DatePicker gateway. Handler exceptions are contained at the Nexamas UI boundary.

Internal MAS-owned month calendar hosted by MASDatePicker's FloatRuntime popup. It deliberately remains Friend so Nexamas UI does not expose a parallel Calendar product API before a separate standalone Calendar stage is approved.

Friend-only evidence for MASDatePicker round-01 refinement. The manifest records that date selection stays on the official trigger + Friend calendar view + FloatRuntime route, with culture parsing/formatting and keyboard/range policy owned by the DatePicker itself.

Official Nexamas UI date-range input composed from the existing MASDatePicker controls. It does not create a second calendar, popup, or FloatRuntime path; each endpoint uses the owned DatePicker calendar route and this control owns only range validation and same-surface endpoint layout.

Raised after the effective start or end date changes through the official range gateway. Handler exceptions are contained at the Nexamas UI boundary.

Friend-only evidence for MASDateRangePicker round-02 refinement. The manifest records that the range control remains a narrow composite over two official MASDatePicker endpoints, while owning only range normalization, endpoint constraint sync, keyboard reset/boundary behavior, culture range text, and clear/reset policy.

Public Nexamas UI time input control. The visible control is an input-like popup trigger; the stepper clock surface is MAS-owned internal float content so TimePicker does not expose a second public clock or scheduler API surface.

Raised when the effective selected time changes through the official TimePicker gateway. Handler exceptions are contained at the Nexamas UI boundary.

Internal MAS-owned compact clock stepper hosted by MASTimePicker's FloatRuntime popup. It remains Friend so Nexamas UI does not expose a standalone Clock product API.

Friend-owned culture clock-format policy for MASTimePicker. The public TimePicker remains API-stable; 12/24-hour behavior is inferred from the active culture so the product layer does not duplicate localization/time-format decisions in controls.

Friend-only evidence for MASTimePicker round-01 refinement. The manifest records that time selection stays on the official trigger + Friend clock view + FloatRuntime route, with culture-aware 12/24-hour formatting/parsing and keyboard/step/range policy owned by the TimePicker itself.

Public MAS radio-button control. External applications use this control directly for exclusive choices, while grouping, painting, hit testing, and peer synchronization remain Nexamas UI-owned internals.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-owned policy for MASRadioButton grouping and keyboard semantics. It keeps group normalization, peer matching, exclusive-choice navigation, and select/cancel keyboard rules out of the public control surface while preserving the existing public GroupName / Checked compatibility contract.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-only numeric policy for MASNumericTextBox. The shared MASInputBoxSkiaBase remains the owner of editing, IME, selection, clipboard, validation visuals, layout, and rendering. This policy owns numeric text hygiene, culture-aware separator resolution, parse normalization, invalid-number protection, and keyboard-step intent.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-only policy for MASPasswordTextBox. The shared MASInputBoxSkiaBase remains the owner of editing, IME, selection, validation visuals, layout, rendering, and paste normalization. This policy owns only password-specific assignment hygiene, reveal lifecycle, visibility glyph state, and clipboard-export safety rules.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-only path policy for MASPathTextBox. MASInputBoxSkiaBase remains the owner of editing, IME, selection, clipboard, validation visuals, layout, text rendering, and ellipsis. This policy owns only path text hygiene, slash preference, invalid-character checks, browse intent, and official MAS icon choices.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Raised when the user or application commits the current effective search text. Suggestions and recent searches remain owned by MASSearchTextBox; DataGrid projection remains owned by MASDataGrid/MASDataView.

Friend-only policy for the SearchTextBox gateway. The control keeps the official MASInputBoxSkiaBase edit surface and the existing SearchBoxSystem state. This policy owns search-specific text hygiene, keyboard intent, suggestion-popup limits, and official float owner naming only.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-only text policy for the multiline text-box gateway. The shared MASInputBoxSkiaBase remains the owner of editing, IME, selection, clipboard, validation visuals, scrolling, layout, and rendering. This policy owns only multiline assignment hygiene and fluent input rules.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-only text policy for the single-line MASTextBox gateway. The shared MASInputBoxSkiaBase still owns editing, IME, selection, validation visuals, clipboard and rendering; this policy owns only TextBox-specific assignment normalization and fluent input hygiene.

Public MAS toggle-switch control. External projects configure semantic state through Text, Checked, CheckedChanged, and fluent helpers; track, thumb, input-hit geometry, and rendering remain Nexamas UI-owned internals.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-only interaction authority for MASToggleSwitch. It keeps toggle input, keyboard state decisions, lifecycle cancellation, and text normalization out of the public control surface so the visual control remains a small gateway.

Internal layout authority for MASToggleSwitch. It owns track/thumb geometry, label fitting, preferred size, and pointer-hit width so rendering and input share one deterministic switch contract.

MAS-owned toggle-switch renderer. It remains Friend so public projects never depend on track/thumb drawing details, shader allocation, or internal interaction overlay rules.

Internal context-menu coordinator for root-host integrations. Public SDK code must use MASApplicationWindow.Services.ContextMenus.

Defines a logical MAS control region that can open a context menu. Runtime pointer positions are converted from SK surface pixels to this logical coordinate space by MASContextMenuCoordinator before hit-testing.

Ordered logical context-menu scope collection. Resolution is last-added wins, matching visual z-order expectations for overlapping Skia controls.

Friend-only evidence that the legacy menu/context-menu family has been premium-aligned without replacing the established public menu DSL or Application facade routes.

Dedicated popup service for MASMenuBar dropdowns. It reuses the shared menu model and FloatRuntime lifetime, but owns a separate float key, owner key, content class and renderer so shell navigation styling cannot leak into context menus, split buttons, data-grid menus or general menu buttons.

Renderer dedicated to MASMenuBar dropdowns. It intentionally does not use DropDownMenuRenderer / IMASMenuTheme.ItemSurface so the shell navigation popup can consume MASMenuBarPaletteTheme without changing context menus, split buttons, data-grid menus, command-overflow menus, or MASMenuButton.

Maps MASMenuBarPaletteTheme colors into the generic MAS interaction palette bridge. It owns color mapping only; state legality, strength, geometry, and drawing remain owned by MASInteractionResolver and MASSurfaceInteractionRing.

Creates a normalized menu model from the public DSL tree. The normalization is intentionally model-owned so all menu consumers share one production contract regardless of how the tree was built.

Public MAS DropDownMenu DSL node kind used by MASDropDownMenuNode and internal menu runtime components.

Creates a render-ready immutable copy used by MASDropDownMenuModel. This keeps the public DSL tolerant while preventing leading, trailing, duplicate separators and empty submenus from leaking into production UI.

Internal layout and hit-testing engine for dropdown/context menus. It owns pixel-space panel placement, submenu bridge geometry, and the bounded scrolling contract used when a menu contains more rows than the viewport can safely show.

Internal responsive metric adapter for dropdown/context menu floating surfaces. The existing menu controller and renderer intentionally share one metric DPI so render, hit-testing, scroll and submenu bridges remain geometrically identical.

Visual state for an item displayed by . The enum describes presentation only; workflow execution, audit storage, history persistence, and live event streams remain application-owned or system-owned outside the control.

Official Nexamas UI visual timeline surface for activity logs, order history, audit trails, workflow progress, and business event summaries. It renders application-owned items with premium Nexamas UI material, typography, focus, keyboard, pointer, and RTL behavior. Activity persistence, audit storage, workflow execution, schedulers, and live feeds remain outside this visual control.

Friend-owned visual and interaction policy for MASTimeline. It centralizes item text hygiene, state normalization, selected-index clamping, compact row planning, keyboard selection direction, RTL detection, and large-list ceiling facts while keeping audit persistence, workflow engines, schedulers, live feeds, and history services outside the control.

Friend-only readiness evidence for the visual Timeline control. The manifest records that Timeline is a premium display surface only and does not own audit persistence, workflow engines, schedulers, live feeds, notification queues, or history services.

Public Nexamas UI avatar surface for compact person/team identity visuals. It owns only initials, color, selected/focus/presence rendering. People directories, image loading, account lookup, online-presence transport, and contact persistence stay with the host application or existing Nexamas UI systems.

Friend-owned identity visual policy for MASAvatar. It centralizes display-name hygiene, Unicode-safe initials, deterministic fallback colors, presence tone mapping, and RTL/presence geometry without introducing an image loader, people directory, or public presence service.

Friend-only layout and interaction policy for MASAvatarGroup. It owns visible avatar count normalization, compact overlap geometry, overflow counter planning, display-first selected-index semantics, RTL ordering, hit-test rectangles, pressed/keyboard active-layer math, and keyboard selection math. People lookup, tooltip/callout previews, and presence transport remain outside the group.

Friend-owned policy for AvatarGroup overflow presentation. It turns the +N chip into an actionable people-summary popover without introducing a people directory, profile editor, image store, or application-owned navigation route.

Internal FloatRuntime content for AvatarGroup overflow. It is a compact people summary only: selecting a row invokes the owning AvatarGroup callback while profile navigation, account editing, image upload, persistence, and permission decisions stay with the host application.

Public Nexamas UI avatar group surface for compact team/user clusters. It renders application-provided avatars with overlap and overflow count only; people lookup, presence transport, image acquisition, invitations, and security identity remain outside this visual control.

Friend-only release evidence for the avatar visual control. Identity directories, contact lookup, image transport, image loading, and presence services intentionally remain outside the control surface.

Friend-only readiness evidence for MASAvatarGroup refinement. The group remains a compact display-first identity visual surface with an official +N overflow popover; people directories, contact lookup, presence transport, thumbnail loading, tooltip previews, and collaboration services remain outside the control.

Public Nexamas UI tag input / token box surface for labels, filters, skills, recipients, and categories. It owns the premium same-surface token UI only; suggestions, validation, lookup, persistence, search execution, and DataGrid/DataView filtering remain owned by existing Nexamas UI systems or by the consumer.

Internal responsive layout facts for the tag-input chip wrap surface. The control is small, but it still owns non-trivial inner layout: surface padding, chip height/width, row gaps, remove affordance, pending-chip bounds, and tiny clipping. Those metrics must come from the central runtime size profile so render, measurement, and hit-testing stay aligned.

Friend-owned readiness policy for MASTagInput interaction boundaries. Text entry remains owned by the control, while full-container pointer focus rings are suppressed; chip hover/pressed/selected state is the visible state.

Friend-only evidence for the official MASTagInput control. The manifest proves that the token box is a same-surface premium control and not a public suggestion engine, filter service, validation subsystem, persistence store, or native WinForms wrapper.

Official Nexamas UI slider input for bounded numeric selection. It owns the premium track/thumb/tick/value-label visual route only. Binding, validation, filtering, persistence, analytics, and domain-specific range semantics remain outside this control.

Friend-owned range/value policy for MASSlider. It centralizes normalization, step snapping, keyboard increments, tick density, and culture-aware value text so the visual control does not duplicate numeric policy inside rendering/input code.

Resolved geometry for the reusable Media content regions inside the shared PanelShell. The outer shell, shadow, frame, and radius remain owned by PanelShell; Media owns the inner chrome layout.

Official Media content layout resolver. The outer PanelShell owns shell, shadow, radius, and frame; this resolver only partitions the shell content into Media regions. It is intentionally responsive: chrome is compressed before any region is hidden, and emergency layouts preserve a usable viewport instead of letting fixed rails collide.

Shared Media toolbar geometry resolver. It owns title, floating strip, and command lane sizing so controls only provide actions and labels.

Shared Media viewport geometry resolver. It owns the stage inset, content window, and safe frame band used by image/video/document viewports.

Resolved geometry for a Media footer band.

Shared Media footer geometry resolver for file/status/zoom regions. The footer degrades progressively: metadata, zoom, menu, then icon are dropped before the whole footer is removed by the container resolver.

Normalized text payload for the reusable Media footer information line.

Reusable Media footer metadata resolver. Media controls provide title/subtitle and optional dimensions; this resolver derives stable title text, file extension, existing file size, and dimension metadata without depending on ImageViewer.

Immutable component-side media visual style resolved from ThemeSystem. This is the bridge consumed by ImageViewer, AudioPlayer, VideoPlayer, and future media controls.

Reviewed image export formats for MASImageViewer. File picking, storage policy, overwrite prompts, and long-running export workflows remain application-owned.

Official Nexamas UI premium image viewing control. It owns same-surface image viewing, zoom, pan, rotate, flip, reset, and transformed export behavior. Image loading, file picking, metadata extraction, thumbnail catalogs, galleries, storage prompts, and background export jobs remain outside this visual control.

Shared media command glyphs. This list is intentionally action-neutral so future media components can reuse the chrome without referencing MASImageViewer actions.

Reusable media button command description supplied by the owning media element. It intentionally carries only an opaque action id, presentation text, grouping, and a shared glyph kind. The owner keeps the real command enum and execution logic.

Resolved sizing profile for a horizontal reusable MediaButton strip.

Reusable horizontal MediaButton strip layout. Owners provide command specs and the available lane; this resolver decides tile profile, spacing, compact fallback, RTL/floating alignment, and returns render-ready button models.

Generic reusable media command button model. Media elements own their action semantics; the reusable media button layer only carries an opaque action id, text, bounds, layout mode, grouping metadata, and a shared glyph kind.

Interaction state supplied by the owning media element. The reusable chrome does not track pointer capture or command availability by itself.

Fully resolved colors for one media button draw pass.

Resolved icon and label metrics for a non-compact media action tile.

Pure layout math for reusable media buttons. It contains no drawing and no ImageViewer-specific command logic.

Resolves button colors from the active media visual style and interaction state.

Draws only the physical button surface: shadow, body, rim, border, and highlight.

Draws shared media glyphs. It is isolated from labels, surfaces, and element actions.

Draws only media button content: icon and optional label.

Generic rectangular hit testing for media command buttons. Owners decide whether the returned action id is currently enabled or executable.

Reusable media command button renderer. It composes layout, palette resolution, surface painting, and content painting without owning interaction state.

Friend-owned ImageViewer visual and transformation policy. It centralizes text hygiene, zoom normalization, right-angle rotation normalization, safe export quality, keyboard navigation, and format mapping while keeping file picking, storage prompts, galleries, thumbnails, metadata services, and background jobs outside the control.

Single ImageViewer surface policy. The ImageViewer consumes one official slot profile and maps semantic regions to independent Surface Material bindings. Rendering code must ask this policy instead of hard-coding broad material ids inside the control.

Phase-3 contract gate for ImageViewer surface architecture. The gate verifies that the ImageViewer no longer relies on one broad root material for all chrome, that every visual region resolves through the official Surface Material profile/composition path, and that legacy media painter routes are absent from the compiled assembly.

Friend-only readiness facts for the official ImageViewer control. This manifest documents that the control owns visual viewing, transform commands, and synchronous transformed export while file picking, metadata, galleries, storage prompts, and background work remain outside.

Official Nexamas UI premium file intake drop-zone. It owns the visual selection surface, accepted-file list, extension validation, browse intent event, keyboard activation, and readiness evidence. OS drag/drop plumbing, FilePicker dialogs, upload transport, storage, scanning, thumbnails, and background transfer remain owned by the host application or existing Nexamas UI systems.

Friend-owned policy for MASFileDropZone. It centralizes text hygiene, extension normalization, host boundary rules, and theme color resolution so the public control remains a narrow visual intake surface.

Friend-only readiness status for the MASFileDropZone public visual control.

Friend-only evidence manifest for MASFileDropZone. It proves the element is an official Nexamas UI visual intake surface without owning picker dialogs, OS drag/drop plumbing, upload transport, storage, thumbnails, scanning, or background transfer.

Official Nexamas UI two-list transfer surface. It owns visual list-pair composition, source/target item movement, selection, keyboard transfer, RTL visual order, and readiness evidence. It intentionally does not own data binding, permissions, persistence, remote providers, drag/drop runtimes, or virtualization; those remain with the host or existing Nexamas UI systems.

Render-only responsive layout facts for MASTransferList. It converts the official runtime size profile and available bounds into two-pane or stacked visual geometry without introducing a parallel size system.

Friend-owned policy for MASTransferList. It centralizes item hygiene, bounded item counts, list-selection math, RTL visual order, and explicit architecture boundaries so the control does not become a binder, provider, permission engine, drag/drop runtime, or virtualization subsystem.

Friend-only readiness evidence for the TransferList element. It records that this stage owns a visual transfer surface only; binding, permissions, persistence, drag/drop, providers, and virtualization remain outside it.

Public semantic field kinds for the MASDataForm visual form surface. The values describe presentation intent only; binding, validation, persistence, and editor ownership remain outside the DataForm control.

Public visual state for MASDataForm field rows. The state is display-only and does not introduce a validation engine, rule registry, binder, or persistence route.

Public lightweight authoring helper for MASDataForm. It collects display field definitions only and deliberately does not own binding, reflection, validation rules, persistence, or editor creation.

Friend-owned normalization and semantic policy for MASFormBuilder/MASDataForm field rows. The policy keeps the public builder small and fluent while preventing label/value/helper, required, state, and field-kind rules from being duplicated inside the builder and the visual DataForm control.

Official Nexamas UI visual data-form surface for business forms, settings panels, profile screens, filter summaries, and admin editors. It displays application-owned field definitions with premium Nexamas UI layout/material/typography, while binding, validation rules, persistence, reflection, editor creation, and submit policy stay owned by existing Nexamas UI systems or by the host application.

Render-only responsive layout facts for MASDataForm. Field editing/binding remains outside the control; this plan owns only inner visual layout decisions.

Friend-only evidence that MASFormBuilder remains the single lightweight fluent construction route for MASDataForm display fields. It records the Round 04 split of field normalization/semantics into a dedicated Friend policy instead of growing a public binder, validator, reflection scanner, editor factory, or duplicate DSL.

Friend-only evidence for the official MASDataForm / MASFormBuilder surface. The manifest proves that the form is a premium visual field surface and not a public binder, validator, reflection scanner, persistence layer, editor factory, or native WinForms wrapper.

Friend-only readiness evidence for the official MASMenuBar control. The manifest proves that the menu bar is a top-level application command surface over the existing DropDownMenu / FloatRuntime route, not a new popup, ToolStrip, MenuStrip, command catalog, or shell system.

Official Nexamas UI menu bar control. It presents top-level application menus while delegating command model construction to MASDropDownMenuBuilder and popup lifetime to the shell-owned MASMenuBarDropDown route. The dropdown renderer is intentionally isolated from the general DropDownMenu/ContextMenu renderer so MenuBar palette changes cannot leak into non-shell menus.

Public Nexamas UI breadcrumb navigation control for product pages, settings, dashboards, and admin surfaces. It is a same-surface navigation indicator and selection trigger only; page navigation decisions, trail lifetime, menus, floating overlays, and command execution stay owned by their existing Nexamas UI systems.

Friend-owned path policy for MASBreadcrumb. It owns segment hygiene, separator safety, max-segment limits, selected-index clamping, overflow/collapse facts, RTL order facts, and same-surface navigation boundaries without opening a router, history stack, menu, popup, command executor, adapter, wrapper, or parallel navigation path.

Friend-only readiness evidence for MASBreadcrumb. It proves the control is a same-surface breadcrumb indicator/selector, not a router, history stack, menu, command executor, popup route, or navigation service.

Public Nexamas UI pagination control for business lists, search results, reports, and data surfaces. It owns only the same-surface page navigation UI and PageChanged notification; data loading, query projection, virtualization, DataGrid/DataView integration, and persistence remain owned by the consumer or by existing Nexamas UI data systems.

Friend-owned navigation policy for MASPagination. It centralizes page-count clamping, current-page clamping, odd page-window policy, visible-page planning, keyboard movement, RTL label selection, and same-surface data-pager boundaries without adding a data source, query service, virtualization owner, router, popup, wrapper, or adapter.

Friend-only readiness evidence for MASPagination. It proves the control is a same-surface page navigation visual and not a data pager, query engine, router, virtualization owner, popup, adapter, wrapper, or parallel data-navigation system.

Stable command ids emitted by the FileExplorer item context menu. Keeping ids centralized prevents string drift between menu construction and command execution.

Internal FileExplorer bridge event for showing a folder/background context menu. The request is bound to the current folder at execution time, not to a visual item.

Internal FileExplorer bridge event for showing an item context menu. The selected MASFileExplorerItem is captured at request time so the menu command executes against the item that was right-clicked, even if selection changes later.

Raised when FileExplorer inline rename cannot commit a new name. The root/service layer may decide how to present the warning to the user.

Event arguments raised when MASFileExplorerView activates a file-system item.

This is the public result gateway for activation. It exposes the selected MASFileExplorerItem without exposing the internal tree/list coordinator, context-menu, or Float runtime wiring.

Gets the activated explorer item using the stable public explorer item model.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Opens the native Windows Properties sheet for an existing file-system item. This helper is intentionally isolated from FileExplorer view logic so Shell interop remains behind one small boundary and callers do not depend on raw ShellExecuteEx details.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Records the virtualization composition contract for MASFileExplorerView. The explorer is not allowed to invent its own item-range, extent, hit-test, or ensure-visible engine; it composes the official MASTreeView and MASListView consumers.

Raised when the FileExplorer view-mode button is clicked. The control does not open overlays/popups by itself; consumers can use this request to open the future Float UI and call SetViewMode/WithViewMode.

Set to True when an external menu/float handled the request. If it remains False, MASFileExplorerView applies its default lightweight behavior: cycling to the next view mode.

Pure Skia file-system browser control.

MASFileBrowser is intentionally independent from FilePicker, Overlay, and Float. It only displays file-system entries, manages selection, and raises browser-level events. Ownership rules: - It does not open or close any host. - It does not know about modal state, shield state, overlay state, or float state. - It does not produce MASFilePickerResult. - The owner decides what to do with ItemActivated and SelectionChanged.

Creates a new MAS file browser using the standard SDK entry pattern.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Defines what entries a MASFileBrowser is allowed to select.

This policy belongs to the browser level, not to FilePicker, Overlay, or Float. FilePicker may configure this policy, but the browser must remain independent.

Command identifiers used by the FilePicker item/background context menus.

These identifiers intentionally mirror the FileExplorer verbs, but stay FilePicker-owned so the picker can keep its own command policy without depending on the FileExplorer feature.

Raised by MASFilePickerControl when the user requests a context menu over browser empty space.

Browser-level inline rename commit request mapped from MASListView to a FileSystemEntry. The owner may cancel the commit and provide an error message; MASListView will keep the inline editor open when cancellation is requested.

Raised when FilePicker inline rename fails after the browser editor asks for commit.

Raised by MASFilePickerControl when the user requests a context menu for a concrete browser item. The picker owns the item mapping; the host/float layer owns popup presentation.

Coordinates FilePicker behavior independently from any host.

FilePickerController owns FilePicker behavior only. It does not know about Overlay. It does not know about Float. It does not close any host. It does not manage modal/shield ownership. The controller produces MASFilePickerResult and raises Accepted/Cancelled. The external host decides what to do with those events.

FilePicker behavior policy.

This is not passed to MASFileBrowser. MASFileBrowser receives MASFileBrowserSelectionPolicy only.

Event arguments raised when a file picker produces a result.

This class is host-independent. It does not know about Overlay, Float, dialogs, closing behavior, or UI ownership.

Registers a fluent callback that receives the primary selected path only.

Registers a fluent callback that receives a snapshot of all selected paths.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Gets the primary selected path without exposing the internal FileSystemEntry model.

Gets a snapshot of the current selected paths without exposing browser internals.

Immutable-by-convention layout data produced by MASFilePickerLayoutBuilder.

This structure is host-neutral. It does not know about Overlay, Float, modal ownership, closing behavior, or input policy. All rectangles are expressed in physical pixels. The owner is responsible for converting rectangles to logical bounds when assigning child controls.

Reserved for compatibility with older layout/rendering code. The current FilePicker shell owns the visible header, so this is normally Empty.

Builds pixel-space layout rectangles for MASFilePickerControl.

This builder is intentionally host-neutral. It does not know about Overlay. It does not know about Float. It does not own focus, input, closing, modal behavior, or shield behavior. Input: - boundsPx must be physical pixels. - dpi is normalized through PixelSnap.SafeDpi. Output: - All returned rectangles are physical pixels.

Draws lightweight decorative content for MASFilePickerControl.

This renderer is host-neutral. It does not know about Overlay. It does not know about Float. It does not own input, focus, close behavior, modal behavior, or shield behavior. All layout rectangles are expected to be physical pixels.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Public SDK list control for compact single-selection text lists. Rendering, row metrics, scrollbar behavior, hit testing, and theme contracts remain Nexamas UI-owned internals.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Internal responsive layout facts for MASListBox row, padding, virtualization, and hit-testing metrics.

Public SDK collection control for list, details, tile, and large-icon views. Consumers configure items, columns, selection, and icon resolution through this gateway; renderers, scroll state, hit testing, and inline editing infrastructure remain internal.

Public SDK column model used by MASListView details mode. Runtime layout and rendering remain owned by the parent list view.

Public data item used by MASListView. It carries semantic item state only; visual layout and rendering remain owned by MASListView.

Carries a ListView empty-space context-menu request produced by a secondary pointer button. Coordinates are expressed in root-surface pixels so popup/menu owners can anchor a Float without re-projecting child-local coordinates.

Carries a ListView item context-menu request produced by a secondary pointer button. Coordinates are expressed in root-surface pixels so popup/menu owners can anchor a Float without re-projecting child-local coordinates.

Raised when MASListView inline label editing asks its owner to commit a new item name. The owner may cancel the commit and provide an error message; the editor will stay open.

Internal responsive layout facts for MASListView render, virtualization, and hit-testing. Keeps row/header/tile metrics tied to the central runtime size profile instead of raw token*dpi sizing.

Internal MASListView-specific virtualization coordinator. It adapts the shared MASVirtualizedItemsController to the ListView/List/Details/Tiles vertical item surface and to the LargeIcon grouped tile-grid projection while preserving MASListView ownership of rendering, column layout, selection, icons, and Skia scroll application.

Immutable visible-row descriptor for MASListView LargeIcon mode. One descriptor represents either one group header row or one tile row that can contain several actual ListView items.

Synchronizes the highlighted row after keyboard selection changes in the owning MASComboBox. Keyboard input remains owned by MASComboBox; the float content only mirrors visual state.

Requests repaint through the owned Float session. The dropdown creates the shared MAS scroll adapter before the session is attached, so this method is intentionally safe as a no-op until FloatRuntime has attached the active session.

Architecture marker contract for the dropdown-list float opened by controls such as MASComboBox. This is the graph/registry endpoint, not the runtime float content implementation.

Public configuration gateway for the MAS top bar. Consumer code may configure title, logo, menu model, and window command events; render, input routing, invalidation, native-window dragging, and FloatRuntime binding remain internal host plumbing owned by MASApplicationWindow/MASSkiaRootHost.

Friend-owned chrome policy for MASTopBarComponent. It owns title/material hygiene, DPI and menu-input bounds normalization, standard window-command mapping, and the boundary between the public top-bar gateway and native window adapter plumbing.

Friend-only readiness evidence for MASTopBarComponent. It proves app chrome, menu float routing, window-command mapping, native-window adapter boundaries, and render-cache ownership remain internal without opening a public chrome renderer.

Internal native WinForms adapter used by the built-in top bar to perform window actions.

This is implementation plumbing for MASTopBarComponent. SDK code must use the official MASApplicationWindow.Shell/top-bar entry points instead of constructing native-window adapters.

Public data node used by MASTreeView. Node mutation is routed back to the owning tree when attached so visual state, selection normalization, and scroll layout stay synchronized.

Public SDK tree control for hierarchical navigation. Consumers work with MASTreeNode roots and selection events; renderer, layout flattening, scroll state, and hit-testing remain internal.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Internal responsive layout facts for MASTreeView rows, padding, virtualization and hit rectangles.

Public root-node collection exposed by MASTreeView. Mutation methods route through the owning tree so selection, scroll, and visual state remain synchronized.

Internal MASTreeView-specific virtualization coordinator. It adapts the shared MASVirtualizedItemsController to the hierarchical visible-node projection while preserving MASTreeView ownership of tree nodes, expansion state, selection, rendering, input, and the Skia scroll adapter.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Adds a premium command action to the official MAS toolbar/command-bar surface. The action is represented by a MASButton so it inherits Nexamas UI button theming, tooltip, focus, command, size, and icon behavior instead of using an ad-hoc renderer.

Adds an official split command to the MAS command-bar surface. The primary action stays button-like while menu choices are provided by MASDropDownMenuBuilder and displayed through the existing DropDownMenu FloatRuntime route.

Friend-owned premium profile for the existing MASToolbar CommandBar route. It centralizes the command-bar density, item geometry, surface material, and readiness facts without creating a public MASCommandBar wrapper.

Friend-owned evidence manifest proving that CommandBar remains an upgraded MASToolbar route instead of becoming a duplicate public control, service, wrapper, adapter, bridge, or router.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Immutable public data contract for . The visual renderer, pointer handling, animation, and material identity remain Nexamas UI-owned internals.

Paints the segmented control with component-specific material identity. Contracts and interaction resolver are used for state legality and semantic overlays only; the selected indicator, track lighting, rim, and label hierarchy remain local visual DNA.

Public immutable data contract for . Consumers provide semantic identity, display text, count, glyph family, and accent only; rendering, hit-testing, scrolling, and icon catalog mapping remain Nexamas UI-owned internals.

Semantic icon family used by . The concrete SVG catalog mapping is internal.

Internal list-only layout engine for . It intentionally does not reserve title or segmented-control rectangles; those are independent public controls.

Friend-only premium policy for MASTabControl. It owns the visual and geometry refinements for the existing tab renderer route: rail padding, compact overflow navigation, tab chip density, whole-chip selection, rim hierarchy, viewport fades, and scroll-step feel. It intentionally does not introduce a new renderer, service, native TabControl, wrapper, adapter, or public API.

Public SDK tile surface control for virtualized icon, bitmap, and text tile collections.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Adds a bitmap-backed tile and transfers bitmap disposal to the tile item when requested.

Adds a bitmap-backed tile with an explicit bitmap disposer.

Adds a provider-backed tile and transfers resolved provider-snapshot disposal to the tile item when requested.

Adds a provider-backed tile with an explicit disposer for resolved provider snapshots.

Creates a tile item from a bitmap and optionally transfers native bitmap ownership to the tile item.

The default MASTileBox bitmap contract remains borrowed. Pass only when the tile item should dispose the bitmap when the item/control is disposed or when owned item resources are released during replacement/clearing.

Creates a tile item from a bitmap and an explicit ownership disposer.

Passing Nothing keeps the bitmap borrowed. Passing a disposer makes the tile item responsible for releasing the bitmap through that disposer.

Creates a provider-backed tile item and optionally transfers ownership of resolved provider snapshots to the tile item.

The default provider contract remains borrowed. Use ownership only when the provider returns a fresh bitmap that no external cache will dispose.

Creates a provider-backed tile item with an explicit snapshot disposer.

Passing Nothing keeps resolved provider bitmaps borrowed. Passing a disposer makes the tile item release the previous owned provider snapshot before a new one is installed and when the item/control is disposed.

Returns the currently resolved drawable bitmap for external compatibility.

This method never transfers bitmap ownership to the caller. MASTileBox rendering does not call this method. Provider-backed items are resolved into a render snapshot when the item enters or refreshes the tile collection, so paint can read already prepared facts without invoking provider code.

Internal responsive layout facts for MASTileBox grid metrics, virtualization, and hit-testing.

Classifies who owns the native bitmap referenced by a tile render snapshot.

The default tile bitmap contract is borrowed. Owned values exist for the explicit TileBox ownership/disposer API and record that the MASTileItem, not the renderer, is responsible for releasing the native bitmap.

Immutable renderer-facing tile bitmap fact produced outside the tile draw loop.

A snapshot never transfers ownership to the renderer. It records whether the bitmap is borrowed or item-owned so paint can read prepared facts without invoking providers or deciding lifecycle policy.

Resolves tile item runtime state into render specs without owning the tile's artistic identity. The central interaction system normalizes and validates state legality; this resolver may keep tile-specific material tuning such as lift, surface adaptation, and icon motion.

Friend-only sizing and text tokens for the official MASDateRangePicker. The public control remains a narrow composition gateway over MASDatePicker endpoints.

Architecture marker contract for internal list row rendering surfaces. It gives row renderers an official contract without making row visuals user-facing controls.

Architecture marker contract for internal tree row rendering surfaces. It is a contract endpoint, not a tree input or selection engine.

Architecture marker contract for internal tile item surfaces. It lets tile rendering consume declared roles instead of inferring them locally.

Optional validation state used by the renderer to draw a non-invasive validation indicator. The default is None and keeps existing visuals unchanged.

Optional validation message reserved for tooltips, forms, and future validation UI. The base renderer does not draw message text to avoid layout surprises.

Enables or disables the lightweight validation underline/dot.

Clears validation visuals and message.

Sets validation state and optional validation message in one operation.

Optional font profile used by text rendering. Set to Nothing to restore the default profile.

Optional absolute text font size in DIP. Set to 0 to use theme typography size.

Enables sharper text painting for this input. True by default. Disable only if a specific font looks better without snapping/hinting.

Simple external API: preferred default font family for this input.

Optional syntax highlighter. Rendering uses it only when SyntaxHighlightingEnabled=True.

Enables optional syntax-colored rendering. Default is False.

Returns the preferred logical size for Composition Auto layout. The answer is the same desired size produced by the official MASSize intrinsic contract.

Returns the minimum logical size for Composition layout constraints through the same MASSize intrinsic contract.

Converts a Composition measurement context into the MASSize context used by the intrinsic contract. This prevents text input controls from owning a second measurement path.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Semantic surface facade for calm flat premium shells. Orchestrates ShadowSystem ambient elevation and the woven-slate texture/body painter. Suitable for command bars, flat panels, quiet containers, and similar surfaces.

Window-level helper for applying DWM/classic shadow behavior to a WinForms host. This is host integration logic, but still generic and reusable across any external project.

Render-only responsive layout facts for MASCalendarView. It translates the official runtime size profile and current bounds into inner month-grid chrome.

Public Nexamas UI chart control for small business dashboards and reports. The control exposes a compact SDK surface while chart semantics remain owned by the Chart / Visualization System foundation.

Public Nexamas UI property grid control for developer tools, settings screens, and future designers. It inspects an object or accepts manual property rows, renders them as categorized MAS rows, and commits simple edits through MAS-owned property conversion.

Friend-owned renderer for MASPropertyGrid rows, categories, and value cells.

Evidence manifest proving MASPropertyGrid is a real MAS control over the PropertyGrid foundation.

Official Nexamas UI premium responsive app-layout visual surface. It owns app chrome slot presentation, responsive breakpoint geometry, RTL-aware layout, and readiness evidence. Routing, PageHost ownership, child-content hosting, persistence, native shell composition, wrappers, adapters, bridges, and mouse-click outer focus rings remain outside this control.

Public immutable app-layout visual snapshot. It captures the responsive slot labels/text and visibility choices owned by MASAppLayout, while routing, PageHost state, child controls, native shell integration, and external storage remain outside the control.

Friend-owned policy for MASAppLayout. It centralizes text hygiene, responsive breakpoint selection, RTL detection, theme color resolution, and explicit ownership boundaries. It deliberately does not own routing, PageHost state, public/native child hosting, persistence, native shell composition, or mouse-click focus rings. Friend-only slot hosting is governed separately.

Friend-only readiness evidence for MASAppLayout. It records that the control is a premium responsive app-layout visual surface with layout snapshot/restore evidence, while router, PageHost, child-content hosting, native shell, and external storage ownership remain outside this control.

Friend-only proof that MASAppLayout can snapshot and restore its owned visual slot labels/text and visibility choices without claiming routing, PageHost, child-host, native shell, or external storage ownership.

Friend-owned visual constants for MASAppLayout. These tokens keep the public control focused on app-layout intent and avoid styling overrides or a parallel shell/layout system.

Public value object used by MASFilterBuilder to describe a visual filter rule. It is intentionally query-agnostic: no SQL, LINQ, OData, provider, binding, or DataGrid execution path is encoded here.

Render-only responsive layout facts for MASFilterBuilder. It keeps rule/query ownership outside the control and centralizes inner chrome/list sizing.

Friend-owned policy for MASFilterBuilder. It centralizes rule text hygiene, operator captions, bounded rule counts, selection math, RTL detection, and explicit boundaries so the control does not become a query executor, SQL/LINQ translator, data binder, provider, validation engine, or DataGrid wrapper.

Friend-only readiness evidence for the FilterBuilder element. It records that this stage owns visual filter-rule composition only; query execution, SQL/LINQ translation, OData/provider sync, validation engines, data binding, and DataGrid ownership remain outside the control.

Official Nexamas UI dashboard metric card surface. It owns compact metric presentation, value/subtitle/trend text, semantic tone, optional inline sparkline display, RTL-aware composition, and MAS-owned premium drawing. Metric storage, analytics collection, telemetry refresh, chart engines, dashboard layout, provider sync, and live data polling remain outside it.

Render-only responsive layout facts for MASMetricCard. The metric card keeps its public size contract in MASSizeResolver; this plan owns inner chrome, sparkline, subtitle, and trend visibility decisions.

Friend-owned policy for MASMetricCard. It centralizes display text hygiene, tone normalization, compact layout decisions, sparkline sample normalization, and explicit boundaries so the card does not become a metric store, analytics collector, telemetry pipe, live-refresh loop, chart engine, or dashboard composition system.

Friend-only readiness evidence for the MetricCard element. It records that this stage owns a compact dashboard metric visual only; metric storage, analytics collection, telemetry refresh, chart engines, provider sync, and dashboard composition remain outside the control.

Official Nexamas UI visual rating surface. It owns bounded rating display, pointer/keyboard value selection, half-step policy, readonly presentation, RTL-aware hit testing, and MAS-owned premium drawing. Review storage, analytics, feedback submission, moderation, persistence, recommendation models, and domain scoring remain outside this control.

Render-only responsive layout facts for MASRating. It keeps the public rating size contract in MASSizeResolver while adapting header, value text, star pitch, and hit rectangles to the runtime size profile and available bounds.

Friend-owned policy for MASRating. It centralizes value normalization, half-step rounding, bounded maximums, RTL math, and explicit architecture boundaries so the control does not become a review store, analytics pipe, feedback service, persistence layer, recommendation model, or moderation path.

Friend-only readiness evidence for the Rating element. It records that this stage owns a visual rating surface only; review storage, analytics, feedback submission, moderation, persistence, and recommendation scoring remain outside the control.

Render-only responsive layout facts for MASKanbanBoard. The board keeps its public size contract in MASSizeResolver, while this plan translates the current runtime size profile and available bounds into inner chrome/card decisions for drawing and hit geometry.

Friend-only immutable drop decision snapshot for MASKanbanBoard. It gives the production gates a deterministic way to prove legal targets, rejected-drop reasons, requested-index normalization, and source-detach intent without introducing a public workflow or task-provider API.

Friend-only Kanban board-window snapshot. It proves the control can keep a large stable source projection while exposing only a bounded realized column and card window to rendering/input diagnostics. It is not a task store, not a workflow engine, not an external virtualizer, and not a public binding API.

Public immutable Kanban board snapshot. It captures visual board order, card payloads, selected keys, and viewport state only; it deliberately does not own task persistence, workflow engines, remote providers, background synchronization, or OS drag/drop runtime state.

Public immutable column entry used by MASKanbanBoardSnapshot.

Public immutable card entry used by MASKanbanBoardSnapshot.

Friend-owned policy for MASKanbanBoard. It centralizes text hygiene, identifier hygiene, selection clamping, visible-column/card windows, RTL direction, theme color resolution, and architectural boundary facts.

Friend-only readiness evidence for MASKanbanBoard. It records that this stage owns visual workflow-board composition, source projection, visual board snapshot, and bounded card reorder interactions only; task persistence, workflow engines, remote providers, OS drag/drop runtimes, background synchronization, and DataGrid/ListView wrappers remain outside the control.

Friend-only governance probe for MASKanbanBoard source projection. It proves stable source records can build columns/cards, update incrementally through IMASItemsSource changes, and detach cleanly when a manual board mutation occurs.

Friend-only proof that MASKanbanBoard can snapshot/restore visual board layout and card order without becoming task storage, workflow runtime, or external provider infrastructure.

Friend-only proof that KanbanBoard's source projection can hold a large board while the realized drawing/input diagnostics remain bounded to a small board window. The gate intentionally avoids timing assertions because execution hosts vary; it verifies capacity, stable-key access, scrolling, and selection retention.

Friend-only proof for KanbanBoard WIP/drop-rule behavior. It verifies that legal targets are accepted, illegal drops produce deterministic feedback, target indexes are normalized, and keyboard/public move paths use the same bounded board model without exposing a workflow engine.

Friend-only proof for KanbanBoard write-back policy. Public/manual card moves intentionally detach from projected sources instead of mutating external data, keeping task persistence, workflow providers, and background sync outside the control while preserving visual move behavior.

Public view modes owned by MASAgendaView. The modes control only visual range presentation and navigation; recurrence, booking storage, reminders, and external calendar providers remain outside the control.

Official Nexamas UI day-agenda visual surface. It owns product-readable single-day event presentation, selection, keyboard navigation, RTL-aware layout, and day navigation. Recurrence, reminders, booking storage, external calendar providers, scheduler engines, and provider synchronization remain outside it.

Friend-only visual time-window result for AgendaView. The control consumes concrete event timestamps and projects them into a bounded visual day/minute surface; recurrence expansion and external time-zone conversion stay upstream.

Friend-only policy snapshot for AgendaView recurrence/time-zone ownership.

Friend-owned temporal policy for AgendaView. It deliberately defines the production boundary as a concrete-timestamp visual projection, not a calendar recurrence engine or external time-zone provider.

Friend-only event edit result for AgendaView move/resize proof paths.

One realized agenda event in a bounded visible-range diagnostic window. It is not a public calendar model and intentionally does not expose recurrence, time-zone conversion, reminders, or provider metadata.

Friend-only Agenda visible-range window snapshot. It proves MASAgendaView can hold a larger source projection while diagnostics realize a bounded subset of the active day/week/month range. It is not a scheduler, recurrence engine, provider adapter, or production marketing promotion.

Render-only responsive layout facts for MASAgendaView. The agenda keeps its public size contract in MASSizeResolver; this plan owns inner header/body/footer decisions.

Friend-owned policy for MASAgendaView. It centralizes text hygiene, date and hour normalization, visible-event windows, RTL detection, theme color resolution, and explicit architecture boundary facts for agenda ownership.

Friend-only readiness status for the MASAgendaView public day-agenda visual surface.

Friend-only readiness evidence for MASAgendaView. It proves that this element is a visual agenda surface and not a calendar provider, recurrence engine, reminder transport, booking database, or scheduler engine.

Friend-only governance probe for the single-day Agenda overlap layout. It proves that timed events are placed by their minute range, overlapping events are split into lanes, and the deterministic now-provider path can drive day navigation.

Friend-only governance probe for MASAgendaView range foundations. It proves that AddEvent preserves event days, week/month ranges derive stable cells, range navigation changes by the active view mode, and day view filtering keeps the timed layout scoped to the selected day.

Governance proof that MASAgendaView can project a larger internal agenda source while keeping day/week/month diagnostics bounded to a visible-range window. This gate deliberately avoids recurrence, time-zone engines, reminder transports, external providers, and public adapter commitments.

Friend-only proof for AgendaView temporal ownership. AgendaView consumes concrete timestamps and projects them deterministically into visual day/minute windows; recurrence expansion and time-zone databases stay outside the control.

Friend-only proof for AgendaView event move/resize contracts. It validates bounded visual event edits, selection retention, rejected edits, and explicit source-detach semantics without opening public calendar/provider APIs.

Official Nexamas UI hierarchy-with-columns visual surface. It owns product-readable tree-row and column presentation, selection, expand/collapse interaction, keyboard navigation, RTL-aware layout, and readiness evidence. Row storage, binding engines, external providers, DataGrid/TreeView wrapper composition, virtualization engines, adapters, bridges, and background synchronization remain outside this control.

Friend-only TreeGrid row-window snapshot. It proves the control can keep a large stable source projection while exposing only a bounded realized row window to rendering/input diagnostics. It is not a storage provider, not an external virtualizer, and not a public binding API.

Friend-only TreeGrid source descriptor. It lets internal data-source adapters feed stable hierarchical rows into MASTreeGrid without exposing a public binding engine or depending on WinForms TreeView/DataGrid wrappers.

Render-only responsive layout facts for MASTreeGrid. The public intrinsic size contract remains in MASSizeResolver; this plan translates the current runtime size profile and available bounds into inner grid chrome decisions.

Friend-owned policy for MASTreeGrid. It centralizes text and key hygiene, row projection limits, visible-row windowing, RTL detection, theme colors, and architectural boundary facts so the public control remains a visual hierarchy-with-columns surface rather than a data/storage/binding service.

Friend-only readiness status for the MASTreeGrid public hierarchy-with-columns visual surface.

Friend-only readiness evidence for MASTreeGrid. It proves that the public TreeGrid remains a MAS-owned visual hierarchy/column surface and not a storage provider, binding engine, or wrapper over TreeView/DataGrid.

Friend-only governance probe for the TreeGrid source-projection path. It does not render, mutate global registries, or expose binding APIs; it proves that the new stable-keyed source path can build a parent/child tree and preserve viewport access.

Friend-only governance probe for TreeGrid sort/filter projection. It proves level-aware sorting, ancestor-preserving filtering, and source re-projection without creating public binding gateways or wrapper dependencies.

Friend-only governance probe for TreeGrid row editing contracts. It proves begin/update/commit/cancel lifecycle, label/value mutation, keyboard-friendly selected-row editing, and source-projection detachment for manual edits without pretending that IMASItemsSource has write-back support yet.

Friend-only proof that TreeGrid's source projection can hold a larger row set while the realized drawing/input window remains bounded to the viewport. The gate intentionally avoids timing assertions because execution hosts vary; it verifies capacity, stable-key access, scrolling, and selection retention.

Official Nexamas UI premium cross-tab summary surface. It owns visual pivot row/column presentation, totals, selection, keyboard navigation, RTL-aware layout, and readiness evidence. Query execution, OLAP/Excel engines, external providers, persistence, chart coupling, DataGrid wrapper composition, adapters, bridges, and background refresh remain outside this control.

Render-only responsive layout facts for MASPivotTable. The table's intrinsic measurement remains owned by MASSizeResolver; this plan owns only inner chrome, row, and column presentation decisions for the current bounds.

One realized PivotTable matrix-cell coordinate inside a bounded diagnostic window. This is friend-only evidence for rendering/input coverage; it is not an export cell, not an external data adapter, and not a public matrix API.

Friend-only PivotTable matrix-window snapshot. It proves the control can keep a large row/column pivot projection while rendering and input diagnostics realize only a bounded cell window. It does not run a query engine, does not export all cells, and does not promote the control beyond CompactPreview.

Friend-owned policy for MASPivotTable. It centralizes text/key hygiene, numeric formatting, totals-window limits, RTL detection, theme colors, and architectural boundary facts so the public control remains a visual cross-tab summary surface rather than a BI/query/storage engine.

Friend-only readiness status for the MASPivotTable public cross-tab visual surface.

Friend-only readiness evidence for MASPivotTable. It records that this stage adds a visual cross-tab summary component while keeping BI/query, Excel/OLAP, storage, providers, and DataGrid wrapper paths outside the control.

Friend-only proof that MASPivotTable can project a stable-keyed source into row/column groups, aggregate values, keep drilldown evidence, expose an export snapshot, and refresh when the source changes.

Friend-only proof that MASPivotTable can retain a large pivot matrix projection while diagnostics for rendering/input expose only a bounded row/column cell window. The gate avoids timing assertions and does not call export snapshot so it does not prove full export performance or production readiness.

Friend-only proof that PivotTable owns a deterministic multi-level grouping policy by composing row and column hierarchy paths before projection. This keeps OLAP/query engines and public source adapters outside the control.

Friend-only proof that PivotTable export ownership stops at deterministic snapshot-to-text writer policy. It does not open file, Excel, clipboard, PDF, storage, or provider paths.

Official Nexamas UI visual content-carousel surface. It owns product-readable carousel item composition, same-surface previous/next navigation, selection, keyboard navigation, RTL-aware layout, and readiness evidence. Galleries, image loading, slide decks, onboarding engines, content providers, auto-rotation clocks, local/parallel transition schedulers, wrappers, adapters, and native controls remain outside it. Official MASMotionSystem timelines are the only allowed motion route.

Render-only responsive layout facts for MASContentCarousel. The carousel keeps intrinsic measurement in MASSizeResolver while this plan owns internal header, stage, side-card, navigation, and indicator posture for current bounds.

Friend-owned policy for MASContentCarousel. It centralizes content text hygiene, key hygiene, selection/index clamping, RTL detection, theme color resolution, and boundary evidence. It deliberately does not own galleries, image loading, slide decks, onboarding flows, content providers, auto-rotation clocks, or transition engines.

Friend-only readiness evidence for MASContentCarousel. It records that this stage owns visual carousel composition, same-surface navigation, selection, RTL layout, and keyboard/pointer interaction only. Galleries, image loading, slide decks, onboarding flows, content providers, auto-rotation clocks, and local/parallel transition schedulers remain outside the control; official MASMotionSystem timelines are allowed.

Official Nexamas UI premium same-surface navigation rail. It owns visual rail item presentation, selection, keyboard navigation, RTL-aware layout, and MAS surface/typography routing. Application routing, PageHost state, drawer/shell replacement, content hosting, native menus, wrappers, adapters, and pointer-click outer focus rings remain outside this control.

Render-only responsive layout facts for MASNavigationRail. It keeps the public size contract in MASSizeResolver while adapting rail chrome, label/badge visibility, row density, and item hit rectangles to runtime size profile.

Friend-owned policy for MASNavigationRail. It centralizes item text/key hygiene, selection bounds, RTL detection, theme color resolution, and explicit boundaries. It deliberately does not own route catalogs, page-host state, drawer replacement, content hosting, native menu composition, or pointer-focus ring drawing.

Friend-only readiness evidence for MASNavigationRail. It records that this stage owns only the visual same-surface rail, item selection, keyboard/pointer interaction, RTL layout, and official MAS surface routing. App route catalogs, PageHost ownership, drawer replacement, content hosting, native menus, and mouse-click outer focus rings remain outside this control.

Official Nexamas UI premium dashboard widget grid. It owns visual widget card presentation, responsive mosaic placement, selection, keyboard movement, RTL-aware layout, and MAS surface/typography routing. Data refresh, analytics collection, chart engines, storage, providers, shell layout, wrappers, adapters, and pointer-click outer focus rings remain outside this control.

Public immutable dashboard widget layout snapshot. It captures the visual widget order, text payload, spans, selected key, and viewport position, but deliberately does not own chart engines, refresh providers, external storage, or shell layout.

Public immutable widget entry used by MASDashboardGridLayoutSnapshot.

Friend-only DashboardGrid widget-window snapshot. It proves the control can retain a large widget layout while rendering/input diagnostics realize only a bounded widget window. It is not child hosting, not a data-refresh provider, not external storage, and not a public dashboard virtualization API.

Friend-only provider refresh record for DashboardGrid. It is a bounded product-control contract used by gates and internal adapters; it is not a public provider API, not a chart engine, and not external storage.

Friend-only refresh snapshot. It captures the last provider-driven widget replacement, selected-key preservation, revision, and error/loading states.

Friend-only policy snapshot for DashboardGrid provider exposure. It closes the production gap by making the current boundary explicit: DashboardGrid owns an internal provider-refresh projection contract, but it does not expose a public provider adapter, external storage bridge, or shell refresh loop.

Friend-only keyboard/a11y threshold snapshot for DashboardGrid widget resize. It proves bounded span changes, hosted-widget state, readable resize text, and bounded realized widget-window behavior without opening a public keyboard API.

Friend-only slot labels for product-control hosted-content contracts. These values are diagnostic ownership labels, not public routing/page-host API.

Immutable Friend-only hosted-content slot snapshot. It records ownership, lifecycle generation, visibility, and placement facts without exposing child controls or creating a public host/shell API.

Friend-only snapshot for a product control's hosted-content contract. It is an evidence object used by gates and does not expose hosted controls.

Friend-only helper for product-control hosted-content placement. It uses the official MASControlBase child registration/layout placement path and avoids any native panel, Showcase workaround, router, or wrapper ownership.

Central Friend-only factory for route/shell ownership boundary snapshots. It keeps the policy explicit: product controls may expose host-facing boundary evidence, but they must not silently become routers, page hosts, public adapter providers, or native shells.

Friend-only snapshot that proves a control's route/shell boundary is explicit. The snapshot is intentionally descriptive: it records what the control does not own, and whether it exposes enough host-facing state for a higher-level application shell to coordinate routing, focus, persistence, or announcements without moving that ownership into the control.

Friend-only labels for route/shell ownership boundary evidence. These are diagnostic governance labels only; they do not expose a public router, page-host adapter, or native shell integration surface.

Friend-only host-adoption proof snapshot. It proves that an application host can consume a control-owned boundary snapshot and layout/interaction state without moving router, PageHost, native shell, public adapter, persistence, or announcement ownership into the control.

Friend-only policy that builds host-adoption proofs from existing boundary, hosted-content, layout, and interaction snapshots. It is not a Router, not a PageHost, not a native shell adapter, and not a public API surface.

Friend-only release-sample adoption snapshot. It proves that an actual host sample can consume the boundary/adoption snapshots for AppLayout or SplitView while keeping routing, native shell, PageHost, public adapters, and storage outside the product control.

Render-only responsive layout facts for MASDashboardGrid. It keeps the public size contract in MASSizeResolver while adapting header/footer chrome, cell density, columns, spans, and widget details to the runtime size profile.

Friend-owned policy for MASDashboardGrid. It centralizes text/key hygiene, selection bounds, span normalization, RTL detection, theme color resolution, and explicit boundaries. It deliberately does not own data refresh, metric collection, chart engines, responsive shell layout, storage, or providers.

Friend-only readiness evidence for MASDashboardGrid. It records that this surface is a visual dashboard widget grid with layout snapshot/reorder/resize evidence, while data refresh, chart engines, external storage, providers, and shell-layout ownership remain outside this control.

Friend-only proof that MASDashboardGrid can snapshot and restore widget layout, reorder widgets, and persist span changes without becoming chart, data-refresh, provider, shell-layout, or external storage infrastructure.

Friend-only proof that MASDashboardGrid can retain and restore a large widget layout while diagnostics expose only a bounded realized widget window. The gate deliberately does not prove child hosting, data refresh, chart engines, provider contracts, external storage, or production readiness.

Official Nexamas UI premium master/detail visual surface. It owns master item presentation, detail preview presentation, selection, keyboard movement, RTL-aware split geometry, and MAS surface/typography routing. Data binding, routing, storage, providers, inspector services, wrappers, adapters, bridges, and pointer-click outer focus rings remain outside this control.

Render-only responsive layout facts for MASMasterDetailView. The public size contract remains owned by MASSizeResolver; this plan translates the official runtime size profile and current bounds into inner split/stacked drawing facts.

Public immutable MasterDetailView snapshot. It captures the retained visual master/detail items, selected item key, and master viewport only; it deliberately does not own application routing, object inspection, data providers, storage, or command execution.

Public immutable item entry used by MASMasterDetailViewSnapshot.

Friend-only state snapshot for MasterDetailView empty/error presentation. This is visual-state governance only; it is not routing, provider ownership, object inspection, or public data binding.

Friend-only immutable snapshot of the realized master-item window. It is used by governance gates to prove large master lists stay bounded by the visible viewport instead of treating every projected item as realized UI.

Friend-owned policy for MASMasterDetailView. It centralizes text/key hygiene, selection bounds, RTL detection, detail line shaping, theme color resolution, and explicit boundaries. It deliberately does not own data binding, object inspection, routing, storage, providers, or services.

Friend-only readiness evidence for MASMasterDetailView. It records that this surface is a visual master/detail surface only and does not become a binding, object-inspection, routing, storage, provider, or application-flow subsystem.

Friend-only governance probe for MASMasterDetailView source projection. It proves stable source records can build master/detail items, update through IMASItemsSource changes, preserve selection when keys survive, and detach on manual mutation.

Friend-only governance probe for MASMasterDetailView retained view snapshot. It proves visual items, selection, and master viewport can be exported/restored without introducing storage, router, provider, or object inspector ownership.

Official Nexamas UI premium chart legend surface. It owns legend item presentation, color swatches, item selection, keyboard movement, mouse selection, RTL-aware layout, and MAS Theme/Surface/Typography/ SizeLayout routing. Chart rendering, chart data preparation, analytics, queries, external providers, storage, chart coupling, wrappers, adapters, bridges, and background refresh remain outside this control.

Render-only responsive layout facts for MASChartLegend. The legend keeps its public size contract in MASSizeResolver; this plan owns internal header, rows, footer, value column, and value-bar decisions.

Friend-owned policy for MASChartLegend. It centralizes key/text hygiene, item bounds, selection visibility, RTL detection, swatch color fallback, theme color resolution, and explicit non-goals. It does not own chart rendering, chart data, analytics, queries, providers, storage, or services.

Friend-only readiness evidence for MASChartLegend. It records that the control is an official Nexamas UI visual legend surface and not a chart renderer, analytics engine, provider, storage path, or mouse-click focus ring source.

Official Nexamas UI premium split-surface visual component. It owns visual left/content/right pane presentation, bounded divider resizing, collapsed pane states, keyboard ratio movement, RTL-aware split geometry, and MAS surface / typography routing. Dock engines, child-content hosting, shell routing, persistence, native panel wrappers, and pointer-click outer focus rings remain outside this control.

Public immutable split-view layout snapshot. It captures visual pane text, bounded ratios, and collapse state without becoming a dock engine, child host, native panel wrapper, shell router, or external storage service.

Friend-only snapshot of the keyboard splitter state. It proves that keyboard resizing has an owned focus target, bounded ratios, deterministic increments, and explicit collapsed-state semantics without becoming a shell integration or native panel system.

Friend-owned policy for MASSplitView. It centralizes pane text hygiene, bounded ratio math, RTL detection, theme color resolution, and explicit ownership boundaries. It deliberately does not own public/native child hosting, dock layout, shell routing, persistence, native panel composition, or mouse-click focus rings. Friend-only pane hosting is governed separately.

Friend-only readiness evidence for MASSplitView. It records that the control is a premium split-surface visual component with bounded ratio/collapse snapshot restore evidence, while dock engine, shell router, child-content host, external storage, and native panel wrapper remain outside this control.

Friend-only proof that MASSplitView can snapshot and restore bounded ratios, pane text, and collapse state without becoming a dock engine, shell router, child host, native panel wrapper, or external storage system.

Friend-owned visual constants for MASSplitView. These tokens intentionally remain internal so the public control stays focused on pane authoring and visual resize intent, not styling overrides or a parallel layout system.

Official Nexamas UI premium applied-filter summary surface. It owns visual filter-chip presentation, saved-view context, counts, RTL-aware layout, and MAS surface/typography routing. Query execution, SQL/LINQ/OData translation, provider synchronization, saved-view storage, DataGrid ownership, wrappers, adapters, and mouse-click outer focus rings remain outside this visual component.

Responsive layout facts for MASAppliedFiltersBar header, chip rows, saved-view pill, clear action, footer, and close hit rectangles.

Friend-owned presentation policy for MASAppliedFiltersBar. It centralizes filter-chip text hygiene, saved-view labels, summary text, RTL detection, color resolution, and ownership boundaries. Query execution, filter parsing, provider synchronization, saved-view persistence, and DataGrid ownership stay outside the visual component.

Friend-only readiness evidence for MASAppliedFiltersBar. It records that the control is an official MAS visual surface while query execution, provider sync, saved-view persistence, DataGrid ownership, and mouse-click outer focus rings remain outside the element.

Explicit static manifest for built-in Nexamas UI architecture providers.

This file is generated/maintained beside the concrete component system rather than in ArchitectureSystem. MASComponentRegistry and MASComponentGraphBuilder consume this manifest as their primary path; reflection discovery is retained only as a diagnostic fallback for tests or external/internal extension experiments.

MAS ARCHITECTURE CONTRACT SYSTEM - QUERY LAW. Read-only query facade over the registered architecture catalog. This class is for inspection, filtering, reports, and tooling only. Architectural law: - No runtime rendering should consume this instead of MASArchitectureRuntime. - No effective descriptor, no provider fallback, no inherited contract. - Query is allowed to observe the catalog, not redefine it.

Resolves runtime capabilities from explicit architectural roles. Capabilities are gates for runtime systems and should not be inferred from renderer implementation details.

Resolves the capability set for one descriptor.

MAS ARCHITECTURE CONTRACT SYSTEM - RESOLVED CONTRACT LAW. Represents the final runtime-consumed contract for a component. Renderers, painters, layout engines, and interaction systems should consume this resolved object rather than re-deciding architectural roles locally. Architectural law: - Built from a registered MASComponentDescriptor. - No hidden provider inheritance. - No ad-hoc fallback identity. - No renderer-specific visual decisions. - The resolved contract is the boundary between architecture and rendering.

Resolves component types into the single runtime-consumed contract object. Resolution is direct-only from MASComponentRegistry. No provider fallback, no inherited contract, no effective descriptor.

MAS ARCHITECTURE CONTRACT SYSTEM - DIAGNOSTICS LAYER. Writes a human-readable startup report for the architecture contract system. This layer is read-only: it validates, resolves, explains, and writes diagnostics, but it never changes descriptors, contracts, render profiles, or runtime state. Recommended startup usage: MASArchitectureDiagnostics.WriteStartupReport() Default output: {AppDomain.CurrentDomain.BaseDirectory}\Diagnostics\MASArchitectureDiagnostics.log

Builds the diagnostics report as text without touching the file system. Use this for tests, debug windows, or custom logging sinks.

Writes the diagnostics report to disk and returns the created file path. If directoryPath is Nothing or empty, the default Diagnostics folder beside the EXE is used.

Safe write path for application startup. It returns False instead of throwing if the log path is not writable or diagnostics generation fails.

Declares legal focus contracts for MAS runtime components. This registry validates focus eligibility only. It does not move focus, draw focus rings, or read live keyboard/pointer state.

Contract-driven focus authority for MAS runtime components. FocusRole is the authority. ControlsLayer, overlays, and renderers may consume this resolver, but must not invent focus eligibility locally.

Friend-owned focus-visual policy for large composite content controls. Composite controls still need normal pointer focus so their internal hover, pressed, captured, selected, and keyboard states keep working after a click. The only visual that is suppressed is the broad outer ring around the whole surface; active inner rows, cards, chips, days, stars, toolbar buttons, or viewport actions remain responsible for visible interaction feedback.

MAS ARCHITECTURE CONTRACT SYSTEM - PARTICIPATION MARKER. Marker contract for components that participate in the MAS architecture runtime. Implementing this interface means the type is expected to have an official MASComponentDescriptor in MASComponentRegistry, unless it is an abstract base type or a deliberately internal helper excluded by validator rules. Architectural law: - A concrete architectural component without a registered contract is invalid. - Runtime services may use this interface to resolve the component contract.

Validates interaction contracts against legacy interaction profile coverage. This registry does not build visual overlays. It only declares whether a SurfaceFamily and InteractionRole pair is legal for runtime consumption.

Returns whether the surface family has an interaction profile in the visual interaction engine.

Returns whether the declared interaction role is legal for the given family. Passive and None are always legal because they do not require interaction visuals.

Returns whether a runtime MAS interaction state is legal for the declared interaction role. This prevents renderers from drawing hover/pressed/focus states not declared by the contract.

Maps a MAS runtime state to the MAS visual interaction state. Unsupported visual states return Normal and must be filtered by the caller.

Returns whether a MAS state has a visual overlay representation in the visual interaction engine.

Central authority for interaction state legality, normalization, and semantic overlay creation. Architectural Law: - Components must not invent independent interaction state systems. - Raw local flags must be normalized here before producing interaction overlays. - Renderers may apply local artistic tuning after normalization. - This resolver governs semantic interaction rules only; it must not erase component-specific visual personality.

Official bridge for components that need MAS interaction geometry, intensity, legality, and rendering with a component-scoped interaction color source.

Resolves the render-layer profile declared by an architectural descriptor. This resolver is descriptive only. It must not make renderer-local material, radius, shadow, color, or state decisions.

MAS ARCHITECTURE CONTRACT SYSTEM - RUNTIME LAW. Central runtime authority for architectural governance. This is the official entry point for resolving component contracts at runtime. Architectural law: - MASComponentRegistry is the single source of truth for component identity. - Runtime consumers must resolve contracts through this facade. - Unregistered components are illegal and must fail early. - Resolved contracts must be runtime-consumable. - This runtime governs legality, identity, validation, and consumability only. - It must not become a universal renderer or erase component-specific visual personality. Preferred runtime path: Component Type -> MASArchitectureRuntime -> MASResolvedComponentContract. Construction law: MASControlBase construction may perform non-throwing contract probing only. Strict failures belong to runtime admission/bootstrap paths, not lightweight object construction.

Development/test switch that makes MASControlBase construction fail immediately when the non-throwing construction probe cannot resolve a valid architecture contract. Normal runtime mode keeps construction permissive and fails at ControlsLayer admission.

Non-throwing construction-time contract probe.

This intentionally does not run full global architecture validation. It lets controls be instantiated during incremental development, designers, and local tests while preserving strict validation at admission/bootstrap boundaries.

Strict admission gate for controls/components entering a runtime-owned tree.

Strictly validates a live component instance and returns the resolved contract. Preferred call site: runtime admission/bootstrap path, not MASControlBase construction.

Strictly validates a component type and returns the resolved contract. Missing registry entries are errors, never implicit Generic fallbacks.

Non-throwing validation path for diagnostics and runtime debug tooling.

Creates a validated render scope for a generic renderer. Renderer code should prefer this over ad-hoc contract checks.

Creates a validated render scope for a component-specific renderer.

Generic helper for component-specific renderers.

Writes the architecture startup diagnostics report to disk. This is a convenience facade over MASArchitectureDiagnostics.

Attempts to write the architecture startup diagnostics report without throwing.

Complex file-system/browser style floating content. Example: MASFileExplorer hosted through MASFloatRuntime.

MAS ARCHITECTURE CONTRACT SYSTEM - CATALOG/REPORTING ADAPTER. Read-only reporting facade over registered descriptors. New runtime consumption must not use this class to bypass MASArchitectureRuntime. Use MASArchitectureQuery for inspection and MASArchitectureRuntime for runtime contracts.

MAS ARCHITECTURE CONTRACT SYSTEM - CATALOG/REPORTING ADAPTER. Read-only reporting facade over registered descriptors. New runtime consumption must not use this class to bypass MASArchitectureRuntime. Use MASArchitectureQuery for inspection and MASArchitectureRuntime for runtime contracts.

MAS ARCHITECTURE CONTRACT SYSTEM - SNAPSHOT LAW. Immutable read-only copy of a descriptor for reports/tooling. This is not a replacement for MASResolvedComponentContract in runtime rendering.

MAS ARCHITECTURE CONTRACT SYSTEM - DESCRIPTOR LAW. Represents the raw registered identity of one MAS component. This object is a declaration, not a renderer and not a resolver. Architectural law: - The descriptor states what the component is. - It must not contain drawing code. - It must not contain local theme fallbacks. - It must not contain provider inheritance or hidden substitutions. - Renderers must consume a resolved contract, not invent roles locally. Runtime hosting law: - OverlayRole declares legacy Overlay-hosted identity. - FloatRole declares MASFloatRuntime-hosted identity. - A component must not declare both OverlayRole and FloatRole. - MASComponentDescriptor does not own Overlay lifecycle. - MASComponentDescriptor does not own Float lifecycle.

Provides concrete component descriptors to the MAS architecture registry.

Implementations must live with the owning component/system area, not inside ArchitectureSystem. This keeps ArchitectureSystem as the authority that validates and aggregates contracts without importing concrete component namespaces.

MAS ARCHITECTURE CONTRACT SYSTEM - REGISTRY AUTHORITY. ArchitectureSystem owns descriptor aggregation, duplicate detection, and stable runtime lookup. Concrete components own their own descriptor declarations through IMASComponentRegistrationProvider implementations discovered in this assembly. Architectural law: - ArchitectureSystem must not import concrete component, rendering, WinForms, or float implementation namespaces merely to register them. - Concrete registration belongs beside the owning component/system. - Missing or duplicated ComponentType entries are still strict validation errors.

Returns all registered architecture descriptors in deterministic order.

MAS ARCHITECTURE CONTRACT SYSTEM - CONSUMPTION GUARD LAW. Startup guard for registered contract consumability. Registration alone is not enough; a contract must be safe to consume by runtime rendering, input, overlay, focus, shadow, and material systems. Architectural law: - Registered descriptors must be consumable before the platform starts. - Hidden fallbacks, missing render layers, invalid input/focus contracts, and illegal overlay declarations must fail early. - This guard validates architecture; it must not judge visual taste or erase component-specific rendering identity. - Do not bypass this guard to make a broken component run. Fix the contract.

Validates every registered descriptor and throws before the platform starts if consumption is unsafe.

Validates a single descriptor against runtime-consumption requirements without throwing.

Enforces the overlay admission rule. Overlay roles are allowed only for OverlayContent or explicitly declared overlay surface providers.

Central cache for descriptor lookup. Only directly registered descriptors are valid. No provider inheritance, no effective descriptor, no fallback.

Declares the material roles supported by the architecture contract system. Every value in MASMaterialRole except None must be intentionally supported here.

Declares supported radius families for architecture descriptors. It is a contract support registry, not a place for renderer-local radius math.

Validates that theme resources required by architecture descriptors are available. It protects theme consumption and must not make visual fallback choices.

Maps architecture typography roles to supported theme typography styles. Text renderers should consume these roles rather than choosing fonts ad hoc.

Architecture marker contract for ContextMenu Float hosting.

This type is not the actual rendered menu content. It does not own lifecycle. It represents the architectural identity of MAS.ContextMenu.

Architecture marker contract for DropDownMenu Float hosting.

This type is not the actual rendered menu content. It does not own lifecycle. It represents the architectural identity of MAS.DropDownMenu.

Architecture marker contract for MASFileExplorer when hosted by MASFloatRuntime. This is a marker only: - It is not visual content. - It does not render. - It does not route input. - It does not own lifecycle. Runtime usage remains: MASFloatRuntime.Show(MASFloatRequest)

Architecture marker contract for FilePicker Float hosting.

This type is not a runtime service. It does not call MASFloatRuntime.Show. It does not own MASFloatHandle. It does not close, replace, queue, or dismiss Float instances. Purpose: - Declares that FilePicker is hosted through MASFloatRuntime. - Replaces the old MASFilePickerOverlayContent architecture identity. - Preserves ArchitectureSystem visibility for FilePicker hosting.

Architecture marker contract for MessageBox Float hosting.

This type is not a runtime service. It does not call MASFloatRuntime.Show. It does not own MASFloatHandle. It does not close, replace, queue, or dismiss Float instances. Purpose: - Declares that MessageBox is hosted through MASFloatRuntime. - Replaces the old MessageBoxOverlayContent architecture identity. - Preserves ArchitectureSystem visibility for MessageBox hosting.

Architecture marker contract for Toast Float hosting.

Toast is hosted through MASFloatRuntime. It is not OverlayContent. It does not own global overlay lifecycle. It does not block input.

Architecture marker contract for MASPopover callout Float hosting.

The contract represents the MAS.Popover FloatRuntime route only. It is not rendered content, a popup service, an overlay adapter, or a public runtime API.

Architecture marker contract for MASDrawer FloatRuntime hosting.

The contract represents the MAS.Drawer FloatRuntime route only. It is not rendered content, a popup service, an overlay adapter, or a public runtime API.

Architecture marker contract for Tooltip Float hosting.

Tooltip is hosted through MASFloatRuntime as passive fullscreen Float content. It is not OverlayContent, does not accept input, does not own focus, and does not participate in global overlay lifecycle.

Records non-fatal provider discovery events such as reflection fallback usage and loader failures. This keeps architectural coverage issues visible without turning the explicit manifest path back into silent assembly scanning.

Immutable component graph split into registered component relations, external-trigger relations, and declared relations with missing endpoints. Normal graph queries intentionally return only registered component-to-component edges.

Declared registered-component relations that could not be admitted because at least one required architecture endpoint is missing from the registry.

Relations from non-architecture actors into registered architecture contracts. These are reported separately so external triggers do not pollute the normal graph.

Provides concrete component relation declarations to the architecture graph builder.

Implementations belong beside the concrete owner systems. ArchitectureSystem validates endpoints and builds the graph without importing concrete component namespaces. Providers must declare architecture-level ownership, hosting, opens, or uses relations only. They must not try to mirror every visual child, layout node, renderer part, or private implementation detail inside a composite control.

Raw relation declaration supplied by an owning component/system.

Normal declarations require both endpoints to be registered architectural components. External declarations are reserved for deliberate outside triggers whose target is a registered architectural component, such as a WinForms trigger opening an owned MAS float contract. Registered MAS sources must use Create(...), not CreateExternal(...).

Builds the documented architecture relation graph from provider-owned endpoint declarations. Runtime implementation classes must not be imported by ArchitectureSystem when an owning component/provider can declare the relation instead.

Adds a normal architecture relation only when both endpoints are registered components. Missing endpoints are recorded instead of being silently dropped.

Adds an external-trigger relation only when the source stays outside the registered MAS architecture catalog and the target is a registered architecture component.

Produces a readable graph report: normal relations first, external-trigger relations second, and broken endpoint declarations last.

Represents a documented relation from an external actor that is not an ArchitectureSystem component into a registered architecture component. The source type is intentionally not required to be registered; the target remains a real architecture contract endpoint. Example: a WinForms trigger opening a MAS float contract.

MAS ARCHITECTURE CONTRACT SYSTEM - RENDERER CONSUMPTION LAW. Marker contract for renderers that explicitly receive and retain a resolved architectural contract instead of making local visual-role decisions. Architectural law: - A renderer may have component-specific drawing personality. - A renderer must not invent component identity, theme roles, radius roles, shadow roles, input roles, focus roles, or render-layer requirements. - Those decisions come from MASResolvedComponentContract.

The resolved contract consumed by this renderer. This property must never return Nothing after renderer construction.

MAS ARCHITECTURE CONTRACT SYSTEM - RENDER SCOPE LAW. Small immutable object used by renderers to carry the renderer name and the resolved component contract together. This gives renderer code one explicit object to validate at the boundary before drawing. Architectural law: - Renderers must consume MASResolvedComponentContract explicitly. - Component-specific renderers should validate the expected component type. - Required render layers must be enforced through MASRendererContractGuard. - This scope does not draw UI and does not choose colors.

MAS ARCHITECTURE CONTRACT SYSTEM - RENDERER GUARD LAW. Validates that renderers consume a resolved architecture contract before drawing. This is the bridge between the Architecture layer and concrete renderer implementations. Architectural law: - Renderers must receive MASResolvedComponentContract explicitly. - Renderers must validate the contract once at construction or at render entry. - Renderers must not silently draw with missing contracts. - Required render layers must be declared and checked here. - This guard does not draw UI and does not choose colors. It only enforces contract-consumption safety.

Validates a renderer-owned contract without enforcing a specific component type. Use this for generic internal renderers that legitimately draw more than one component.

Validates that a renderer is consuming the expected component contract. Use this for component-specific renderers such as ButtonRenderer, TreeRenderer, etc.

Generic overload for component-specific renderers.

Ensures that a resolved contract exposes one required render layer.

Ensures that a resolved contract exposes at least one layer from a valid group. This is useful for renderers that can draw equivalent visual paths such as Border or PremiumBorder.

Produces a compact diagnostic text for renderer logs and exceptions.

Declares which shadow roles are valid for which architectural surface families. This registry validates the contract only. It does not choose shadow strength. Shadow strength is owned by MASShadowResolver through MASShadowRole.

Returns whether the given role/family pair is legal. None is always legal. Generic cannot carry a real shadow.

Resolves runtime shadow specifications from MAS shadow contracts. ShadowRole and SurfaceFamily from MASResolvedComponentContract are the authority. This class is the official ShadowSystem resolver from architecture contracts to MAS shadow specs.

MAS ARCHITECTURE CONTRACT SYSTEM - DEBUG REPORTING. Produces readable architecture reports for diagnostics, startup logs, and future developer tools. This class does not define laws; it only exposes current runtime contract status in a human-readable form.

MAS ARCHITECTURE CONTRACT SYSTEM - RUNTIME ENFORCEMENT GUARD. This guard is the preferred fail-fast entry point for live component instances. It is intentionally small and strict: a concrete architectural component must be registered, resolvable, and consumable before it is allowed to participate in rendering, input, overlay, focus, or layout flows. Architectural law: - No component instance without a registered descriptor. - No runtime usage without a resolved consumable contract. - No silent fallback to Generic when the component type is missing from the registry. - MASControlBase construction must not hard-fail on global registry/bootstrap state. - Runtime admission/bootstrap paths should call ValidateComponent(Me) once the instance is entering a framework-owned tree or service boundary.

Validates a live architectural component instance and returns its resolved contract. Use this when the instance is admitted into a framework-owned runtime tree or service boundary.

Validates a component type and returns its resolved contract. This is the strict path: missing registration is an error, not a fallback.

Attempts to validate a live component instance without throwing. The error message is suitable for diagnostics, startup reports, or debug overlays.

Attempts to validate a component type without throwing.

Validates that a resolved contract can actually be consumed by runtime systems. This method is intentionally public inside the assembly so renderers and hosts can assert contract integrity at boundaries without duplicating rules.

MAS ARCHITECTURE CONTRACT SYSTEM - VALIDATION LAW. Primary validation authority for the MAS architecture contract system. All structural contract rules should live here or in delegated validators, not in renderers. Architectural law: - Validation describes what is legal. - Guard layers decide when to throw. - Renderers do not validate architecture by inventing fallbacks.

Validates the full registered architecture catalog and returns structured issues.

MAS-owned compact icon button used by internal toolbars, preview chrome, file navigation, toast close affordances, and other platform surfaces. It is intentionally Friend; consumer applications should use MASButton or higher-level service/facade APIs instead of creating glyph buttons.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-owned interaction and value policy for GlyphButton. GlyphButton is an internal MAS affordance, so pointer, focus, keyboard, icon, and state normalization remain here instead of leaking public surface or duplicating rules in each consumer toolbar.

Contract-driven MAS button control. Public API lives on the control itself. MASUI may create this control, but must not be the only way to configure it.

Creates a new MAS button using the standard SDK entry pattern.

Gets or sets the visual personality contract used by the shared MAS button theme. Unknown enum values are normalized instead of being allowed to leak into renderer policy code.

Gets or sets the action intent used by the button renderer. Invalid enum values are normalized to MASButtonIntent.Default to keep the product surface deterministic.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Public placement intent for MASPopover/MASCallout. The runtime may flip the final pixel bounds to keep the callout inside the available MAS surface.

Friend-only visual policy for MASCallout Round 18 refinement. It centralizes title/body text hygiene, fallback copy, placement normalization, arrow intent, wrapped shaped-text line planning, RTL detection, and the action boundary while keeping MASCallout a lightweight visual surface.

Friend-only readiness evidence for MASCallout Round 18 refinement. Callout remains a visual title/body surface; actions, lifecycle, focus, and float placement stay outside the control and route through the official application / FloatRuntime path.

Official Nexamas UI callout surface. It owns only the visual content body; floating lifecycle and placement are owned by MASPopover through FloatRuntime.

Friend-only placement/dismissal policy for MASPopover Round 18 refinement. It owns anchor sanitization, anchored/free-point geometry, collision flipping, pixel clamping, focus-scope/dismiss evidence, and the no-parallel-overlay rule. FloatRuntime remains the lifecycle owner.

Friend-only readiness evidence for MASPopover Round 18 refinement. Popover is the public request gateway only; hosted content, placement geometry, focus, dismissal, and cleanup remain policy/FloatRuntime-owned implementation facts.

Official Nexamas UI popover gateway. It owns only the callout request state and delegates all floating lifecycle, conflict policy, outside dismissal, focus, and animation to MASFloatRuntime.

Public MAS-prefixed label text role contract used by MASLabel theme color resolution.

Creates a new MAS label using the standard SDK entry pattern.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Public layout contract that decides where an imported MASLabel is placed relative to MASProgressBar. The progress bar never creates a native label; callers may attach a normal MASLabel instance and let this control arrange it as part of the progress component.

Advanced progress-track recommendation presets. The official element-size API is MASSize through WithSize/WithDefaultSize/WithCompactSize/WithLargeSize; these presets only preserve the progress renderer's historical recommended-bounds helpers and are Default-derived.

Public frame contract for MASProgressBar. None preserves the raw track-only renderer. ContainedField remains available for callers that explicitly want the progress renderer to draw a themed container surface around the track.

MAS progress bar with optional MASLabel composition support. The control owns progress rendering, while any text remains a real MASLabel child control supplied by the caller.

Re-applies the current internal layout for the progress track and imported MASLabel. This is useful after the caller changes MASLabel properties that influence text presentation.

Returns the logical rectangle currently reserved for the painted progress track inside BoundsLogical.

Returns the recommended logical size for this instance, including the active label placement when a label is attached.

Returns the Nexamas UI recommended logical size for a progress bar preset.

Strongly typed MASProgressBar entry into the shared MASSize API. This stores the same size intent as every MASControlBase element and only mirrors Compact/Default/Large into the advanced recommended-track preset so legacy recommended bounds remain coherent.

Mirrors the shared MASSize gateway into the progress bar's advanced recommendation preset. This keeps inherited WithCompactSize/WithDefaultSize/WithLargeSize coherent without adding duplicate public concrete preset aliases on MASProgressBar.

Keeps the imported label in the progress-bar-owned child slot. This method is intentionally called from state/bounds transitions only, never from Render. Render must stay side-effect free; otherwise a label placement update can request a host repaint while the layered window is already painting, creating a Render/Invalidate loop.

Optional MASLabel supplied by the application. The progress bar imports and arranges this MASLabel as a child; it does not create a System.Windows.Forms.Label or any parallel text renderer.

Decides whether the imported MASLabel is placed above, below, beside, or inside the progress track.

Logical spacing between the progress track and an outside label. Ignored for None and InsideCenter.

Optional logical label slot size. For Top/Bottom this is label height; for Left/Right this is label width. A value of 0 keeps the Nexamas UI recommended label extent.

When enabled, the progress bar sets the imported MASLabel alignment to match its assigned slot. Disable it when the external project wants to fully control MASLabel text alignment.

Advanced progress-track recommendation preset used by RecommendedSize. Public element sizing should use WithSize(MASSize) and the shared MASSize fluent helpers.

Controls whether MASProgressBar paints only the progress track or also paints a themed container field. The default is None so MASProgressBar stays a pure progress-track control. Operation-level containers are owned by MASOperationProgressBox.

Surface material key used by the automatically drawn progress container. The default is MASSurfaceMaterialIds.PlatformDefault so the container consumes the platform surface material, while the inner progress track and fill continue to use IMASProgressTheme.

Border strength used by the themed progress container material. ThemeDefault delegates to surface theme chrome.

Surface strength used by the themed progress container material. ThemeDefault delegates to surface theme chrome.

Friend-only progress value and presentation policy for MASProgressBar. It owns determinate range normalization, percent/value text, state tone normalization, label-placement safety, frame/material defaults, and the no-clock rendering boundary. Rendering remains owned by ProgressBarRenderer and operation lifetime remains outside the progress element.

Friend-only readiness evidence for MASProgressBar Round 16 refinement. The control remains a determinate visual progress element; progress ownership, timers, async work, local/parallel indeterminate animation clocks, and service lifetimes stay outside the element.

A single official MAS operation progress composition. It owns a themed PlatformDefault surface container and internally arranges a title MASLabel, one MASProgressBar, and a status MASLabel. Callers update the operation state through this control rather than manually building panel + label + progress layouts in forms.

Surface material used by the outer operation container. The default is PlatformDefault. The inner progress bar keeps its own IMASProgressTheme pipeline.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Arranges the internal child controls only when the operation box geometry or text state changes. It must not be called from Render; child placement mutates layout-owned bounds and can request host invalidation, which would create repaint loops in layered startup/dialog surfaces.

Friend-only operation progress composition policy. It owns title/status text hygiene, percent text handoff, child slot geometry, compact fallback layout, and the boundary that keeps operation lifetime, cancellation, actions, async work, and progress services outside MASOperationProgressBox.

Friend-only readiness evidence for MASOperationProgressBox Round 16 refinement. The composite owns child construction/layout and percent text synchronization only; cancellation, action slots, async progress lifetime, task ownership, and services remain outside the visual composition.

Internal pointer-state tracker for toast hover/press/hit-test behavior. It consumes renderer-owned layout information and does not expose interaction internals to SDK consumers.

Owns toast runtime state, queue promotion and lifetime progression. This type is intentionally internal so external projects interact only through the toast service/control gateway.

Public toast tone contract used by MASToastOptions and toast theme resolution. Uses the MAS-prefixed public naming convention required by the canonical SDK surface.

Public toast placement contract used by the toast host when arranging floating messages.

Public options bag and fluent builder for showing a toast through the Nexamas UI toast gateway. The runtime copies and normalizes these values before the toast is owned internally.

Optional short title rendered above the message.

Main toast message text.

Semantic visual tone used for the accent and lifetime indicator.

Toast lifetime in milliseconds. Use 0 for a persistent toast.

Whether the toast renders and responds to the close button.

Optional action button text rendered as the larger in-toast action row.

Optional callback executed by the toast host when the action button is activated.

Optional callback that enables the compact undo glyph beside the close button.

Whether a timed toast displays its remaining lifetime indicator.

Optional Surface Treatment material key. Auto preserves the current toast panel visual.

Enables the compact undo glyph rendered beside the close button. The glyph is hidden unless a callback is supplied.

Disables the compact undo glyph for this toast.

Public event payload emitted by the toast gateway for lifecycle notifications.

Internal hit-test target used by the toast interaction tracker.

Internal hit-test result for pointer routing inside a toast.

Internal immutable-at-boundary runtime record for a visible or queued toast.

Optional short title rendered above the message.

Main toast message text.

Semantic visual tone used for the accent and lifetime indicator.

Optional action button text rendered as the larger in-toast action row.

Optional callback executed by the toast host when the action button is activated.

Optional callback executed when the compact undo glyph is activated.

Friend-only readiness evidence for MASToast Round 17 refinement. Toast remains owned by the application/FloatRuntime route; item layout, renderer state, queue promotion, continuous lifetime progression, and callback dispatch are not public SDK models.

Friend-only policy for the Round 17 toast refinement. It centralizes toast text hygiene, tone normalization, duration and queue limits, continuous lifetime progression, RTL text detection, and the FloatRuntime/service boundary. Public SDK code still enters only through the application toast facade.

Optional public contract for MAS controls that expose tooltip text to the root-owned tooltip service. The tooltip runtime itself remains internal; applications register through MASApplicationWindow.Services.Tooltips.

Gets the current tooltip text for this control. Empty text means no tooltip is shown.

Internal passive visual used by the root-owned tooltip Float content. Public SDK code registers tooltip targets through MASApplicationWindow.Services.Tooltips.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Internal tooltip runtime coordinator owned by the root tooltip service. Public SDK code must enter through MASApplicationWindow.Services.Tooltips instead of this coordinator.

Internal tooltip layout engine. It keeps tooltip geometry bounded to the active viewport, wraps long text deterministically, and limits tooltip copy to a compact product-safe size.

Internal renderer for the root-owned tooltip visual. It is intentionally not part of the public SDK surface.

Friend-only readiness evidence for MASTooltip Round 17 refinement. Tooltip remains a root/FloatRuntime-owned helper; placement, delay, wrapping, motion, provider callbacks, and renderer details stay internal.

Friend-only visual/lifecycle policy for MASTooltip Round 17 refinement. It owns tooltip text hygiene, delay/grace clamping, hover-rect inflation, radius/text choices, RTL text detection, and the public-boundary rule that tooltip content stays owned by the application tooltip facade and FloatRuntime path.

Public Nexamas UI feedback control for field-level validation text. It is a visual message element only: validation rules remain owned by FormValidationSystem and inline input indicators remain owned by TextInput controls.

Friend-only presentation policy for MASValidationMessage. Rule execution remains owned by FormValidationSystem and inline validation indicators remain owned by TextInput controls. This policy owns only product-facing message hygiene, semantic icon/tone mapping, wrapping, and readiness facts.

Public Nexamas UI compact status badge. It is a visual feedback control only: notification queues, toast lifetime, list/data adornment ownership, and validation policy remain owned by their existing Nexamas UI systems.

Friend-owned visual policy for MASBadge. It keeps text hygiene, number overflow, tone colors, text contrast, dot geometry, and disabled-state decisions inside the badge surface without opening a public badge service or variant API.

Friend-only readiness evidence for MASBadge refinement. Badge remains a lightweight display surface; notification delivery, counters, validation engines, and toast queues remain owned by their existing Nexamas UI systems.

Public Nexamas UI in-page status banner. It is a visual feedback control only: toast lifetime, notification queues, dialog/message box routing, and validation execution remain owned by their existing Nexamas UI systems.

Friend-only presentation policy for MASStatusBanner. It owns product-facing text hygiene, tone normalization, semantic icon selection, wrapping/ellipsis, RTL text alignment, and theme color resolution. Toast lifetime, notification queues, dialogs, validation execution, and command services remain outside it.

Friend-only readiness evidence for MASStatusBanner refinement. The banner remains visual-only in-page feedback; toast lifetime, notification queues, dialogs, validation execution, and command routing stay with their official systems.

Official Nexamas UI in-surface notification panel. It presents application-owned notification summaries using the existing feedback tone language. Toast lifetime, push delivery, background queues, unread persistence, and notification services remain owned by applications or existing Nexamas UI feedback systems.

Raised after notification rows are added, removed, cleared, or read state changes.

Friend-owned content and row policy for MASNotificationPanel. The policy centralizes title/message/action hygiene, tone normalization, visible-row limits, read-state facts, RTL detection, and service-free notification boundaries without adding a delivery queue, persistence layer, push service, adapter, wrapper, or parallel notification route.

Friend-only readiness evidence for MASNotificationPanel. It proves the panel is a same-surface notification summary and not a notification queue, push service, persistence owner, virtualized list owner, or parallel toast route.

Public Nexamas UI empty-state control for product surfaces, dashboards, lists, and data regions that have no content to display. It is visual-only: page layout, DataGrid/ListView adapters, search execution, file-system state, actions, loading handoff, and notification queues remain owned by their existing Nexamas UI systems.

Friend-only content and illustration policy for MASEmptyState. It owns empty-state text hygiene, fallback copy, wrapped text lines, compact text placement, RTL text detection, theme color resolution, and the official MASIconKind illustration choice. Data/search/file/list adapters, page state machines, action commands, and loading handoff remain owned by their existing Nexamas UI systems.

Friend-only readiness evidence for MASEmptyState refinement. EmptyState remains a visual feedback surface; search execution, data adapters, page state machines, primary/secondary action commands, and loading handoff remain owned elsewhere.

Public Nexamas UI loading skeleton for premium visual loading placeholders. It is visual-only: data loading, progress lifetime, virtualization ownership, render verification execution, and future motion clocks remain owned by their existing Nexamas UI systems.

Friend-only visual policy for MASLoadingSkeleton. It owns row/line normalization, variant geometry, deterministic line widths, theme color resolution, and the stable reduced-motion rendering contract. Data loading, progress lifetime, clock-based activity, motion clocks, virtualization, and render/performance runners remain outside the control.

Friend-only readiness evidence for MASLoadingSkeleton refinement. The control stays visual-only; data loading, clock-based activity, local/parallel animation clocks, progress lifetime, virtualization, render verification execution, and performance runners remain outside the element.

Internal context-menu factory for RootHost integrations. Public SDK code must use MASApplicationWindow.Services.ContextMenus.

Official Nexamas UI command palette surface. It filters and invokes commands through CommandActionSystem / MASCommandRegistry and deliberately does not create a second command catalog, global keyboard hook, popup service, command scanner, telemetry stream, or task queue.

Raised after the current selected command changes.

Raised after a command is executed through the official CommandActionSystem route.

Raised after command rows are added, removed, or replaced.

Internal responsive layout facts for the command palette popup surface. Keeps the floating palette chrome, search field, row metrics, and viewport capacity tied to Runtime SizeProfile + SizeIntent + AvailableBounds.

Official Nexamas UI drawer gateway. It owns request state only and delegates docking, lifecycle, outside dismissal, Escape handling, focus, and motion to MASFloatRuntime. Visual content is hosted by MASSidePanel.

Friend-owned float policy for MASDrawer. It owns drawer title, side, width, owner-key and docked FloatRuntime presentation decisions while keeping visual content in MASSidePanel and avoiding popup/flyout/overlay services or native forms.

Friend-owned visual surface policy for MASSidePanel. It owns drawer-panel title hygiene, content insets, close-button geometry, relative child placement hygiene, and the separation between side-panel rendering and MASDrawer/FloatRuntime lifecycle.

Friend-only readiness evidence for MASDrawer. It proves drawer requests remain an application/FloatRuntime gateway over MASSidePanel without owning a native form, popup/flyout service, overlay service, or parallel drawer route.

Friend-only readiness evidence for MASSidePanel. It proves drawer-panel visual ownership, header/content slot policy, close affordance geometry, and separation from native panels and FloatRuntime lifecycle ownership.

Official Nexamas UI side-panel surface. It is the visual drawer body only: Float lifecycle, docking, outside-dismiss, keyboard-dismiss, focus, and motion are owned by MASDrawer through MASFloatRuntime.

Narrow public side vocabulary for the official MASDrawer surface.

Public layout direction for the official MASStepper / MASWizard progress surface.

Narrow public state vocabulary for a step in MASStepper / MASWizard.

Official Nexamas UI step-progress control. It owns only ordered step state and visual progress rendering. Wizard page/content orchestration is owned by MASWizard so the stepper can also be used independently in forms and flows.

Raised after the current step changes through SetCurrentStep, MoveNext, or MovePrevious.

Official Nexamas UI wizard container. It composes the official MASStepper for progress state and hosts one MAS child-content surface per step. Navigation is exposed as narrow MoveNext/MovePrevious/SetCurrentStep commands so applications may bind their own official MAS buttons or command bars without another action path.

Raised after the wizard current step changes through the official MASStepper route.

Friend-only readiness evidence for MASWizard. It proves the wizard is a guided MAS child-content container composed with MASStepper and not a public page model, workflow engine, action/cancel service, validation owner, or native host wrapper.

Friend-only readiness evidence for MASStepper. It proves the control owns visual ordered-step state and keyboard traversal only; workflow, validation, page hosting, scheduling, timers, and flow services stay outside the element.

Friend-owned flow-boundary policy for MASWizard. It proves that wizard navigation composes the official MASStepper route and MAS child-content slots without opening public page objects, a workflow service, validation engine, action/cancel service, hidden Form/UserControl host, timer, task, or parallel guided-flow path.

Friend-owned flow policy for MASStepper. It centralizes title/description hygiene, orientation/state normalization, current-index clamping, enabled-step traversal, keyboard navigation, RTL direction facts, and connector/render-state decisions while keeping workflow engines, validation sessions, page hosts, schedulers, timers, and parallel flow services outside the visual step-progress control.

Official Nexamas UI accordion container. It orchestrates multiple MASExpander sections through one policy surface and deliberately reuses MASExpander for disclosure rendering, child hosting, keyboard behavior, and collapse semantics.

Raised after any child MASExpander section changes expanded state through the accordion policy.

When false, expanding one section collapses the other sections. When true, multiple sections may remain open.

Friend-only readiness evidence for MASAccordion. It proves accordion orchestration reuses MASExpander and owns section layout/single-open policy only, not a duplicate disclosure renderer, registry, local animation clock, native Panel, or parallel container path.

Friend-owned section policy for MASAccordion. It centralizes section title hygiene, allow-multiple normalization, single-open enforcement facts, section-count limits, and section-layout boundaries while deliberately reusing MASExpander for disclosure rendering and child hosting instead of introducing a second header/content path.

Official Nexamas UI expandable in-page container. It owns only the disclosure surface and routed child content; Accordion orchestration remains a later element and must build on this control instead of duplicating collapse logic.

Raised after the expanded/collapsed state changes through the official Expander gateway.

Friend-only readiness evidence for MASExpander. It proves disclosure rendering, keyboard behavior, RTL header layout, and child slot hygiene are control-owned while accordion orchestration, local/parallel animation clocks, native panels, and wrapper paths stay absent.

Friend-owned disclosure policy for MASExpander. It owns title hygiene, RTL header layout facts, keyboard expand/collapse semantics, child bounds hygiene, header hit geometry, and no-local-clock disclosure boundaries while keeping section orchestration in MASAccordion and avoiding any native Panel/UserControl wrapper path. Official MASMotionSystem consumption is the only permitted future disclosure motion route.

Public MAS-prefixed group box surface source contract used by MASGroupBox.

Public MAS-prefixed group box border recipe contract used by MASGroupBox.

Public MAS-prefixed group box border strength contract used by MASGroupBox.

Public MAS-prefixed title plate strength contract used by MASGroupBox.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Friend-owned surface policy for MASGroupBox. It centralizes title hygiene, surface/material normalization, title-plate lift bounds, header/content geometry, child slot bounds, and the surface-only boundary without opening a wrapper or a second container surface route.

Friend-only readiness evidence for MASGroupBox. It proves premium surface, material/frame, title-plate, and child-slot decisions are controlled by Nexamas UI policies while native GroupBox/Panel wrappers and parallel surface routes remain absent.

Public standalone title-and-divider control. It exposes only title text and divider visibility; the decorative text embossing and separator rendering stay inside Nexamas.UI.Rendering.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Public standalone segmented switch control. Consumers own the segment model through while Nexamas UI keeps rendering, animation, hit-testing, and material semantics internal.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Selection-change payload for .

Public Nexamas UI selector-list control. Consumers provide immutable data and observe category selection through stable properties/events; title/header and segmented switching are separate controls.

Indicates whether the selector list draws its own containing card surface. Disable this when the list is intentionally composed inside a product-owned parent card.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Root-owned FloatRuntime content for the internal tooltip visual. Passive visual content only: no pointer input, no keyboard input, no focus, no overlay.

Internal Tooltip service backed by MASFloatRuntime. It owns only the tooltip Float request/handle and delegates visual behavior to MASTooltipFloatContent. It does not use OverlayService.

Internal contract for controls that need root-owned runtime services while keeping those services out of the public SDK surface.

Implementers must treat the supplied services as a non-owning host context. They must not store or expose raw root-host objects, and they must close any owned runtime surface before accepting a new context or a Nothing context.

Binds or clears the current host runtime services for this control. Passing Nothing detaches the control from host runtime services.

Provides the preferred initial focus target for a Skia control container.

This is not modal-specific. Blocking and modal focus ownership belong to MASFloatRuntime plus the root host input coordinator.

Contract implemented by controls that can receive routed text-input integration messages from the host layer, including Win32 IME composition messages.

The host and controls layer must only route messages through this interface. They must not mutate text state, selection, caret, composition, or undo state directly.

Processes a routed Win32 IME message for the focused text-input control.

Window handle that received the original Win32 message. Win32 message id. Native WPARAM value. Native LPARAM value. True when the message was consumed by the text-input pipeline; otherwise False.

Compatibility bridge for older controls that exposed WinForms overlay controls.

The active Framework bridge is IMASWinFormsNativeControlHost in Nexamas.UI.Host. Float surfaces are owned by MASFloatRuntime; normal controls must not manage float/overlay lifetimes or global input routing directly.

Gets compatibility native controls that an older host may place above the Skia surface.

Updates compatibility native-control bounds and visibility for the current host/layout context.

Current theme/layout context. The WinForms Skia host control.

Base class for all Nexamas UI visual controls. Architectural Law: - Every visual control must be registered in MASComponentRegistry. - Construction performs only a non-throwing architecture contract probe. - Strict architecture validation happens when the control is admitted into a runtime-owned tree. - Controls must not invent independent interaction, material, shadow, radius, typography, or semantic theme systems outside the MAS architecture layer. - Visual identity and artistic tuning are allowed locally, but architectural governance must remain centralized.

Resolved architecture contract for this control instance. This member is intentionally Friend so the internal framework can inspect it without leaking MASResolvedComponentContract through the public API surface.

Advanced diagnostic-only construction probe for MAS architecture registration. Normal SDK consumers should use MASApplication.Diagnostics.GetSnapshot for runtime diagnostics; application behavior must not branch on this construction detail.

Phase-11 API-06: this property remains public only as an advanced visibility shim for custom control authors. The detailed validation state and resolved contract stay Friend.

Advanced diagnostic-only architecture validation message for custom control authors. It is not a stable application-state contract; use MASApplication.Diagnostics.GetSnapshot for the official public diagnostics facade.

Phase-11 API-06: this message is hidden from normal designers/IntelliSense and does not expose MASResolvedComponentContract or MASControlArchitectureValidationState.

Current MASSize intent for this control. The actual logical size is resolved by MASSize System.

Unified public size-intent gateway for MAS controls. It stores intent only; measure/layout engines resolve actual dimensions.

Fluent alias for the official MASSize intent gateway. This method intentionally lives on MASControlBase so every MAS visual element exposes the same size API surface. It stores intent only; MASSizeResolver derives Compact/Large/etc. from the element's Default facts.

Restores the element to the MASSize Default intent. Other public size helpers must remain aliases to MASSize so controls never create per-element preset systems.

Internal extension point for controls that need to mirror the shared MASSize intent into legacy advanced recommendation state without redeclaring duplicate public size aliases.

Applies layout-owned bounds and clip in one framework-internal mutation without issuing per-control invalidations. The Composition applier performs one host invalidate after the whole placement batch, while preserving BoundsChanged/OnBoundsChanged semantics for controls whose logical bounds actually changed.

Marks controls produced by MAS-owned convenience recipes so retained Composition can dispose them when the recipe no longer places them. Caller-supplied controls keep the default False value and remain consumer-owned/detach-only.

Creates a slot for direct/local placement using the best live Theme/Profile/DPI context available. Composition fallback placements use this gateway when they only have final bounds.

Returns the current slot-owned content rectangle in logical/DIP coordinates. This is the internal gateway controls should prefer over recalculating content geometry from BoundsLogical.

Returns the current slot-owned content rectangle in physical pixels. Composite controls use this to place internal children from the official ContentBounds role instead of recalculating a separate content rectangle from raw outer bounds.

Returns the current slot-owned Float anchor rectangle in physical pixels. Popup and Float consumers must use this before falling back to legacy/local bounds.

Builds the best live MASSize/MASLayout context available to direct/local placement paths. This keeps advanced child placement from silently using default Theme/Profile/DPI facts.

Stores and propagates the internal host runtime-services context for this control subtree.

Rebinds the invalidation route for a control subtree that is already attached to the same ThemeHost. Delegate instances created with AddressOf are not reference-stable across repeated retained-layout application passes, so same-host attach must be idempotent while different-host attach remains illegal.

Internal inheritance gateway for controls whose own sizing facts changed without a TextChanged event. This keeps size-affecting state changes on the same retained layout refresh channel as Text/SizeIntent/Theme.

Invalidates the lazily-created local layout slot when a size-affecting control fact changes. Retained layout will replace it with a fresh slot during the next pass; direct/local consumers will recreate it from the current Theme/Profile/DPI context through LastLayoutSlotInternal.

Internal construction-time architecture probe state for a MASControlBase instance.

Controls can still be instantiated without throwing in normal runtime mode, but their architecture state is explicit and ControlsLayer remains the strict admission boundary. Development/test mode can make probe failures fail-fast during construction.

Owns the normal Skia controls tree, focus chain, pointer capture, and local control routing.

ControlsLayer deliberately excludes FloatRuntime, TopBar, and global modal ownership. The root input coordinator decides whether events may reach this layer.

Removes and disposes a control that is owned by this layer or by an upstream retained-layout owner. The normal Remove path intentionally remains detach-only for consumer-owned controls.

Clears and disposes controls owned by this layer. Direct Clear remains detach-only; this path is reserved for owned lifecycle boundaries such as window/root-host disposal.

Begins a root controls update batch. Mutations still happen immediately, but visual invalidation is deferred until the outermost EndUpdateInternal call. This keeps direct-layout consumers fast without hiding state changes or creating a second controls pipeline.

Completes a root controls update batch and emits one visual invalidation if any control requested it.

Requests one host visual update through the same batching and invalidation path used by controls. This is used by application-level direct layout helpers after internal placement changes.

Monotonic visual-state version used by host input routing to distinguish a real hover/state transition from a pure pointer move. This keeps movement responsive without repainting the full Skia surface for every WM_MOUSEMOVE.

Binds root-owned runtime services to all controls in this layer without exposing those services through the public control API.

Invalidates cached layout slots for every control owned by this layer. This is used by the root host when Theme/Profile/DPI or retained size facts change, so direct/local controls cannot keep slot facts generated under an older integration context.

Strictly validates a control subtree at the controlled runtime admission boundary. Construction stays lightweight; entering a ControlsLayer remains fail-fast.

Central policy for the direct ControlsLayer scalability contract.

ControlsLayer is a retained direct-control tree. It deliberately keeps all direct controls attached so focus, input, native interop, layout slots, and consumer-owned control identity remain stable. Large repeated data surfaces must use the MASVirtualizedItemsSystem-backed data/list owners instead of trying to turn ControlsLayer into a second virtualizer.

Immutable report for the retained ControlsLayer scalability contract.

Host-independent verification for the direct ControlsLayer scalability contract. This audit does not allocate UI controls and does not introduce a virtualized ControlsLayer path; it proves that the retained layer's thresholds and guidance are stable and point large repeated surfaces to the official MASVirtualizedItemsSystem-backed data/list owners.

Owns attach/detach and focus-request callback propagation for a ControlsLayer subtree.

Propagates root-owned runtime services through a MASControlBase subtree.

Routes keyboard, text, and Win32 IME messages along the focused control chain.

Owns hot/hover control transitions for a ControlsLayer.

Performs z-ordered pointer hit-testing for a ControlsLayer control tree.

Owns keyboard-focus chain transitions for a ControlsLayer without owning the layer itself.

Internal, root-owned runtime service context supplied to normal Skia controls.

This is the supported internal gateway for controls that need popup/float or surface-size services. It prevents individual controls from depending on MASSkiaRootHost, Application facades, or public FloatRuntime exposure.

Resolves the current root-owned FloatRuntime, if the host is still alive.

Resolves the current host surface size in physical pixels.

Requests the owning root to re-run the retained MASSize/MASLayout session because a control fact that can affect measurement changed. This is an internal gateway; controls do not know Application layout sessions or root-host internals directly.

Resolves the host-scoped Motion frame clock that owns this control subtree. Detached controls return Nothing and must not fall back to a process-global animation clock.

Records that a control-owned asynchronous UI mutation was intentionally dropped instead of being posted through a stale fallback dispatcher. This keeps detach/re-attach completion semantics inside the root-owned dispatcher contract.

Posts work to the owning host UI dispatcher. Returns False when the control is detached or the host is no longer able to marshal work; callers must not fall back to background execution.

Owns pointer capture transitions for a ControlsLayer.

Advanced WinForms UserControl base for standalone MAS Skia-backed controls.

This base hosts its own surface and ThemeHost. It is not the MASApplicationWindow root Framework host and must not own FloatRuntime or application-level input routing.

Current MASSize intent for WinForms-hosted MAS controls. When the concrete control exposes IMASIntrinsicSizeContract, SetSize applies the resolved Default-derived size to the native UserControl bounds immediately.

Internal SKControl surface that forwards paint events to MASWinControlBase.

The nested surface is intentionally thin: it does not own theme, input, or runtime state.

Defines whether a MASFormValidationSummary is only a passive information surface or an actively navigable summary where row focus/selection feedback is meaningful.

Official Nexamas UI premium form-validation summary surface. It owns visual summary presentation, semantic message rows, counts, RTL-aware layout, and MAS surface / typography routing. Validation rules, binding, submit flow, persistence, native validation hosts, and mouse-click outer focus rings remain outside this control.

Friend-owned presentation policy for MASFormValidationSummary. It centralizes text hygiene, count summaries, semantic tone colors, RTL detection, and hard ownership boundaries. Validation rule execution, binding, submit orchestration, storage, native native validation-host routes, and form engines remain outside.

Friend-only readiness evidence for MASFormValidationSummary. It records that the public control is a product-facing summary visual and not a rule evaluator, binding engine, submit owner, persistence path, or native native validation-host route.

Friend-only painter for premium flat action tiles used by Nexamas UI-owned tool surfaces. It is intentionally internal: controls may reuse the drawing policy without creating a public MASFlatButton API or a parallel button route.

Draws the outer operation-progress container only. Text and the actual progress bar remain real MASLabel and MASProgressBar children owned by MASOperationProgressBox. Radius and shadow are resolved from the MASProgressBar architecture contract so the container follows the same corner and elevation source as the inner progress control.

Internal renderer for toast floating surfaces. Keeps measurement, arrangement and drawing in one owned implementation so the public toast API stays small while the visual contract remains consistent with Nexamas UI surface rendering.

Resolves the visual gap between adjacent compact glyph buttons.

Resolves the protected text-to-command gap before the compact glyph group.

Reserves the exact right-side width occupied by the compact glyph-button group.

Resolves the single compact glyph button size used by both Undo and Close.

Draws Toast compact glyph commands through one shared renderer path.

Canonical Visual-system responsibility areas. This is intentionally Friend-only so Visual ownership stays governed inside Nexamas UI and does not become a public extension surface.

Final Visual ownership status. Ready means the area has a dedicated owner, does not depend on the retired Theme rendering paths, and preserves current visuals.

One immutable ownership row for the Visual lockdown audit. It stores responsibility evidence only; it does not inspect files, draw, or mutate runtime state.

Aggregate Visual ownership report used by gates/readiness code to prove that material, shadow, frame/chrome, effects, interaction, and component chrome no longer share a retired Theme rendering owner.

Final Visual ownership audit. It composes existing Surface evidence with the newly-separated Visual owners and deliberately avoids any visual mutation.

Commercial governance evidence for Friend-only material-region composition. It confirms that premium element authors can compose Root/Header/Footer/Toolbar/Viewport from multiple official materials without opening new user-facing API or bypassing the Surface gateway.

Commercial closure manifest for the Visual system ownership refactor. It summarizes the existing Visual ownership lockdown report without drawing, loading themes, touching controls, or changing runtime visuals.

Evidence-only report for the final Visual folder hygiene pass. It records the intended commercial folder contract: component chrome owns contracts/policy/painting, Surface owns material/frame/chrome/runtime, and Interaction visual feedback stays out of Visual material folders.

Final Visual folder hygiene evidence. This does not draw or inspect the file system at runtime; the PowerShell gate validates the physical paths. The audit keeps the intended folder contract visible inside the product source so future rounds do not reintroduce Action/Painting, Input/Painting, or Chip/Painting micro-roots.

Status for the component-surface material adoption closure. It covers broad component surfaces only; interactive item internals remain owned by ComponentChrome/Interaction.

Friend-only evidence report for the first broad component-surface adoption pass. It proves that common card-like surfaces and explicit public surface consumers are routed through the official Surface Material runtime without creating element-named materials or moving interactive internals into the material system.

First broad component-surface material adoption audit. It intentionally names only broad surfaces, cards, shells, bars, and containers; rows, glyphs, buttons, list items, input fields, and interaction overlays remain outside the Material system.

Status for the component shadow-ownership adoption pass.

Friend-only evidence report for component affordance shadows that were moved to ShadowSystem without changing their visual recipes.

Verifies that small component-owned shadow recipes introduced during visual refinement are now routed through ShadowSystem while preserving their original geometry and alpha. This deliberately does not pull surfaces or materials into ShadowSystem.

Status for the final component-wide surface material coverage closure.

Friend-only evidence that component-owned broad surfaces use the same Surface/Material route through semantic gateways. It deliberately excludes glyphs, charts, progress fills, row selection, hover, pressed, focus, and similar interaction chrome from Material scope.

Final component-wide coverage audit for Nexamas UI broad surface materials. The source test suite enforces the same rule with a real source scan: Component code may use the semantic component gateway, primitives, or frame painter, but must not know low-level consumer-kind/slot/role/runtime-material plumbing. Interactive control bodies may consume material through the gateway; hover/pressed/selection overlays stay in Interaction.

Status for the broad-surface material switch readiness closure.

Friend-only evidence that broad Nexamas UI surfaces can be switched from one internal material/profile selection point while the default state remains visually inert.

Final broad-surface switch-readiness audit. It proves the "one button" internal material switch is centralized and that the default switch state is inert, so current visuals are not changed until Theme Studio or Showcase deliberately selects another profile/material.

Internal final status for the Visual material-migration closure pass.

Final Friend-only report proving that the retired Theme rendering material folder has been fully absorbed into the proper Visual owners: Surface material body, Surface frame/chrome, Shadow, Effects, Interaction, ComponentChrome, primitives, and the Theme boundary. It is evidence-only and never draws or changes visuals.

Final material-migration closure audit. It composes existing Visual/Surface evidence and verifies that material is now only a material-body owner while shadow, frame, chrome, effects, interaction and component chrome have their own final owners.

Draws premium card frame/border chrome for elevated card surfaces.

The surface body is drawn by the material fill painter. This class owns only frame concerns.

Internal fluent builder used by Nexamas UI-owned PanelShell gateways. It intentionally does not form part of the external SDK surface.

Internal immutable header contract for PanelShell chrome. Public applications select intent through Application-level gateways; this object stays inside Nexamas UI so renderer geometry and hit-state details do not leak.

Internal value-safety boundary for the PanelShell model. It keeps invalid enum, padding, and geometry values from reaching the renderer while preserving the public Application gateways as the only supported consumption path.

Immutable internal padding contract for PanelShell content geometry. A negative side means: resolve that side from the current PanelShell density tokens.

Shared shadow painter for PanelShell chrome. The renderer owns no shadow constants; shadow shape/strength comes from MASShadowResolver + MASShadowHierarchyProfiles through the PanelShell contract.

Internal layout result produced by MASPanelShellRenderer. External projects receive only stable Application-layer geometry results; this raw result stays internal.

Internal immutable render contract for PanelShell. It is consumed only by Nexamas UI-owned chrome gateways and renderers; external projects must use Application-level surfaces rather than constructing shell geometry.

Studio Porcelain media shell material. The shell is the physical body of the media viewer: calm neutral porcelain, subtle depth, and a restrained theme accent signature.

Media chrome material retained for registry compatibility. ImageViewer now uses the dedicated MediaToolbarGlass and MediaFooterChrome rails for toolbar/footer separation.

Semi-transparent toolbar glass for media surfaces. It keeps the command rail light and lets the frosted viewer body show through with restrained opacity.

Dedicated theme-native command rail for media viewers. The material is authored as a command surface, not a generic glass/card: its colors are resolved from the active surface theme palette while its geometry adds a restrained media-specific accent seam.

Grounded footer chrome for media surfaces. This rail intentionally sits a step deeper than the top command strip so metadata and zoom state feel anchored to the shell.

Studio Porcelain media stage material. The stage is a neutral recessed gallery well behind the bitmap so the image stays dominant and empty margins never become a second card.

Flat attached shell-navigation material for MASMenuBar. It is registered as a Surface Material so MenuBar chrome can resolve through the official material gateway while keeping its color palette owned by ThemeSystem.

Internal reusable surface-material contract owned by Nexamas UI visual rendering. A material draws only the visual skin of a surface. It must not own component layout, header chrome, interaction routing, focus handling, or popup lifetime.

Material-owned painter for the reusable body/lift portion of framed surfaces. It intentionally preserves the previous framed-surface body output byte-for-byte in formula and inputs while moving the surface body responsibility out of Frame painting. Frame painting remains responsible only for frame/border composition.

Platform default material body. It draws only the themed surface fill and subtle internal wash. Outer visual composition is handled by its owning systems.

Rendering context passed to reusable surface materials. It carries platform theme data, the consolidated reusable surface theme profile, target geometry, visual state, surface role, opacity, and strength levels. It deliberately does not expose PanelShell-specific theme contracts.

Public reusable surface strength scale used by controls that consume the shared MAS surface material system. It intentionally lives outside PanelShell so standalone controls can tune material surface and border weight without leaking dialog/container implementation concepts into their API.

Canonical identifiers for reusable surface-frame profiles. The current platform frame corresponds to the frame visible on PanelShell-hosted dialogs, FilePicker, FileExplorer, MessageBox, and floating PanelShell surfaces. Material-specific frame ids are planning identifiers inside the existing VisualSurfaceFrame; they do not create a second frame registry or repaint runtime frames by themselves.

General chrome/header profile for surfaces that have title/header affordances. Current component chrome can feed this profile through ThemeSystem SurfaceChrome, but materials do not depend on component-specific theme contracts.

General surface-frame color profile for platform frame/border/depth decisions. This preserves the existing FrameSurface visual values while giving the reusable visual layer a name that is not owned by a single component.

General surface-material color profile consumed by reusable materials. It is intentionally not tied to PanelShell; current platform profiles are resolved from existing theme families without changing their visual values.

Consolidated reusable surface theme profile. It separates the general reusable visual source from component-specific themes: VisualSurfaceMaterial consumes Material, VisualSurfaceFrame consumes Frame, and chrome renderers may consume Chrome during later migration passes.

Resolves the platform surface visual theme from the current ThemeContext. VisualSurface consumes the ThemeSystem-owned FrameSurface and SurfaceChrome families only; it must not read PanelShell-specific theme contracts.

Resolves the shared card visual palette used by card surface fill and card frame rendering.

The palette contains color inputs only. Elevation/shadow is deliberately resolved by ShadowSystem.

Reusable low-level painter for titled surface header chrome. It paints only the header material band, gloss, and separator. Component shells keep ownership of layout, title strings, icon kind, hit-testing, and buttons.

Resolves reusable header chrome colors from MASSurfaceThemeProfile.Chrome and, when a non-default material is used, applies the same material-derived header treatment that the previous PanelShell header painter used.

Resolved immutable chrome plan for a titled surface header. The plan contains colors only; component-specific layout, title text, icon kind, and close-button behavior remain owned by the consuming component shell.

Reusable chrome rendering context for titled platform surfaces. It carries the consolidated surface theme profile and the material identity needed to derive header/separator chrome without letting component renderers read component-specific theme contracts directly.

Canonical identifiers for reusable surface chrome profiles. Chrome is the reusable visual band/header layer; it does not own component layout.

A named reusable composition of material, frame, chrome, and role. It answers the consumer-level question: "which complete platform surface look should I use?"

Describes which reusable visual subsystems participate in a surface visual style. The type is declarative only; it does not draw and does not wrap any older API.

The current platform dialog surface visible on FilePicker, FileExplorer, MessageBox, PanelShellFloat, and PanelShell-hosted selection dialogs.

Single catalog for reusable platform surface visual styles. It does not draw; it resolves a style key into the canonical material/frame/chrome composition.

Returns the built-in surface visual styles for architecture validation. Runtime consumers still resolve by key; validators use this to ensure every style role has a legal architectural SurfaceFamily before startup.

Maps SurfaceVisualStyle roles back to architecture SurfaceFamily coverage. This is validation-only glue: rendering still consumes MASSurfaceRole and materials directly through the Surface Visual System.

Declares how strongly a surface treatment may consume ThemeSystem colors. This policy is consumed by resolver/evidence paths and does not repaint existing controls.

Stable Surface Treatment consumer buckets. This enum intentionally contains only broad surfaces, chrome, panels, cards, and containers. Interactive controls, list rows, tile items, and data-grid internals stay outside this system.

Single source of truth for Surface Treatment consumer scope. The catalog intentionally contains only broad surfaces, chrome, panels, cards, and containers. Interactive controls do not become Surface Treatment consumer enum members; their broad body surfaces may borrow the semantic component gateway, while hover/pressed/selection, list rows, tile items, and data-grid internals remain interaction/component chrome.

Internal evidence row for one approved public surface-material gateway member. It records public API truth only; it does not resolve materials, draw, create controls, or expose registries.

Friend-only manifest that turns the limited public SurfaceMaterial/WithSurfaceMaterial API into a protected Nexamas UI contract. The manifest records which public members are allowed. It does not expose a material registry, renderer, frame painter, proof API, or runtime shortcut.

Classifies the current state of a surface-treatment consumer. The status records ownership only; it does not alter rendering behavior.

VisualSurface policy profile for a material treatment. It pairs the material with a recommended frame and a theme-influence policy without introducing a second frame system or changing existing drawing.

Compatibility projection over the canonical Surface Material Registry. The registry owns material identity, default frame pairing, theme influence, variant, and designer visibility; this catalog remains only so existing Surface Treatment evidence can consume profiles.

One current visual-surface consumer recorded by the treatment inventory. This object is evidence only: it does not draw, resolve layout, or change state.

Current visual-surface treatment inventory report. It is intentionally static evidence and must not instantiate controls or render bitmaps.

Builds the first-pass inventory of current surface-treatment ownership. This inventory deliberately records current facts; it does not migrate consumers, draw controls, resolve layout, run RenderVerification, or create public API. Interactive control surfaces are intentionally outside the Surface Treatment scope.

Outcome of a VisualSurface policy resolution. The status validates default/override safety without drawing or changing consumer behavior.

Internal request for resolving a complete surface treatment. It is not a public element API and does not mutate a control.

Result of resolving a consumer surface slot into a complete treatment. This is evidence/resolution data only; it does not paint, allocate controls, or alter runtime paths.

Friend-only VisualSurface policy resolver for surface-treatment consumption. It resolves material, recommended frame, strength, and theme influence from the policy/catalog root. It does not read Governance evidence builders, draw, allocate controls, run RenderVerification, or mutate any consumer.

Evidence report for the default-resolution and compatibility-validation pass. It validates resolver behavior without making the resolver an active paint path for legacy consumers. Runtime surface visual application makes official surface overrides ready; migration-required rows are retained only as a compatibility status for future staged surfaces.

Builds static validation evidence for the Surface Treatment resolver. This pass keeps the resolver scoped to broad surfaces, chrome, panels, and containers; interactive controls are outside this system.

Current-visual capture state for Surface Treatment consumer buckets. This is governance evidence only; it does not activate a renderer path.

One current-visual capture record for a Surface Treatment consumer bucket. The entry captures the current default treatment and migration boundary; it does not draw.

Report for low-risk current-visual capture evidence. The report verifies default treatment preservation before any renderer migration occurs.

Captures current default surface-treatment evidence for low-risk consumers only. This builder does not wire renderers, instantiate controls, run captures, or migrate interactive controls.

Evidence that material selection can be routed by generic surface slots/profiles without element-specific material identities.

Verifies that Surface Designer and Theme Studio consume the canonical Surface Material registry, slot profiles, and generic slots instead of maintaining a second catalog.

Source-level report proving that Surface Designer sees the same material/profile/slot system that runtime surfaces use. It carries counts only and never exposes registries.

Readiness flags for the Surface Material Designer integration layer.

Evidence that broad surface consumers use the material slot route instead of bypassing generic slot/profile resolution when applying explicit material keys.

Final source-level evidence that the Surface Material system is commercially ready as an internal owner: canonical materials, frame pairing, generic slot routing, designer projection, and runtime application all agree without exposing a public API or creating element-owned names.

Final integrity audit for the Surface Material system. It composes the already-existing routing, adoption, designer, and scope-boundary audits, then adds strict material/frame identity checks. It does not draw, scan files, expose APIs, or mutate registries.

Status values for the first runtime alignment of already low-risk VisualSurface consumers. This does not approve low-risk surface/chrome/container consumers.

Evidence row proving whether a consumer is allowed to use the low-risk runtime surface visual route.

Report for the first low-risk runtime alignment pass. It proves only material-key resolution moved through the governance route; frame repaint remains deferred.

Friend-only material-name normalizer used by the Surface Treatment runtime route. It accepts concise material keys and legacy material.* ids, then returns canonical surface.material.* ids. Legacy native aliases become canonical native variants, not separate identities.

Friend-only authoring regions for composing premium component surfaces from multiple official Surface Materials. These are semantic component regions, not public API and not material identities.

Declares where a component region gets its material. InheritApplication keeps the region participating in the application/global material route. AuthoredMaterial is a Friend-only component-author decision and stays official because it still resolves via the Surface Material registry and gateway.

Friend-only immutable material binding for one component region. It stores only an official material key and a source policy; it never stores colors, paints, element names, or drawing recipes.

Friend-only authoring map used by complex Nexamas UI components to compose one visual control from multiple official Surface Materials. This is not public customization API: it is for Nexamas UI element authors to route Root/Header/Footer/Toolbar/Viewport through the single official Surface Material gateway without hard-coding paints.

Material-body resolver used only by the Surface Visual runtime compositor. It never draws a complete surface, frame, chrome, or shadow; callers outside Surface/Runtime must go through so visual output stays composed by the official owners.

Runtime compositor for official broad surfaces. It composes material body and frame through their owning systems; shadow remains owned by the caller's architecture contract.

Component-facing semantic gateway for Nexamas UI broad surface materials. Components are allowed to ask for a Card, Toolbar, Background, Popup, Toast, Progress, or Panel surface; only this Visual/Surface owner translates that request into consumer-kind, slot, role, frame-strength, and runtime switch routing details.

Builds evidence for the first low-risk runtime material alignment. This validates resolver use for PanelShell, Application chrome, and Progress only.

Governance status for material-specific frame pairing inside the existing VisualSurfaceFrame. These statuses do not repaint runtime controls.

Evidence row for a material-to-frame pairing decision. The row is planning metadata only; frame painters and renderers remain unchanged.

Report describing planned material-specific frame pairings. It verifies that frame ids live in VisualSurfaceFrame and that Level1-Level6 remains the only strength model.

Builds the first planned pairing between existing materials and material-specific frame ids. This remains governance/planning only: it does not build frame specs, call frame painters, or rewire renderers.

Governance status for proving that material/frame pairings can later become runtime proof without repainting existing frames or migrating interactive controls.

Evidence row for a future frame-runtime proof plan. It combines a consumer slot, a material profile, and an existing VisualSurfaceFrame frame id while explicitly keeping runtime frame repaint deferred.

Report proving that the material/frame pairing plan can be used for later runtime proof by already captured low-risk consumers for already captured low-risk surface consumers.

Builds the governance plan for later proving material-specific frames at runtime. The builder consumes existing evidence reports only and does not create controls, render, or change frame output.

Visual state supplied to surface materials. It is intentionally component-neutral.

Identifies the broad surface role requesting visual treatment. This belongs to the Surface system, not the Material registry: materials stay generic and receive the role only as context for safe intensity adjustments.

Generic surface composition slots used by complex Nexamas UI elements when they ask the Surface Material system for a material. These are not element names: different controls can map internal header, toolbar, footer, body, viewport, or overlay regions to them.

Surface-owned slot catalog. It converts generic composition slots into broad surface roles and labels without introducing element-specific material identities.

Central mapping from broad surface material consumers to generic surface slots. This keeps slot adoption out of element names: consumers are broad runtime buckets, while slots remain generic surface regions such as root, header, toolbar, or floating.

Native CrystalIce surface material. It is a first-class registered material variant, not a registry escape path. The recipe preserves its own crystal palette while still participating in frame, shadow, and policy resolution.

Native WarmPaper surface material. It remains inside the official material registry, but preserves its own paper palette instead of being recolored into a generic theme fill.

Internal bridge for MASControlBase roots that render a MASPanelShell and want the common Float host to provide header drag/close behavior.

Internal visual contract for MAS dialog-like surfaces hosted by MASPanelShell. The options are intentionally content-neutral: FilePicker, FileExplorer, MessageBox, and SelectionDialog supply different content, while public projects stay on MASApplication gateway APIs instead of this raw shell recipe.

Complete reusable surface visual style used by this dialog host. PlatformDialogFrame is the canonical FilePicker/FileExplorer/MessageBox/PanelShellFloat look.

Optional material override. Leave Auto to use the material declared by SurfaceVisualStyleKey.

Single reusable MASPanelShell dialog host recipe. It builds, measures, and draws the common shell used by dialog-like components. The hosted content remains owned by the feature; the shell/top-bar contract stays here.

Architecture marker contract for the reusable PanelShell dialog chrome surface. It is the rendered chrome contract used by MessageBox, FilePicker, FileExplorer, and generic PanelShellFloat hosts; hosted feature content remains owned by the feature and must not invent a second outer shadow or radius source.

Minimal theme-provided input shape used by ShadowSystem to build an idle layered shadow spec.

Official single-pass shadow specification owned by MASSystem/Visual/Shadow. Materials and component painters consume this contract; they do not define shadow payloads.

Official layered shadow specification owned by MASSystem/Visual/Shadow.

Official card shadow specification owned by MASSystem/Visual/Shadow.

Internal content insertion host for reusable PanelShell floats. Nexamas UI owns shell chrome, official sections, footer, clipping, and scrolling; high-level public gateways decide which controls are inserted through this host.

Logical bounds of the official content section relative to the PanelShell content root. Most callers can ignore this and use the contentBounds argument supplied to ContentBuilder.

Reusable FloatRuntime root that hosts arbitrary feature controls inside MASPanelShell. It mirrors the FilePicker/FileExplorer pattern: the shell is rendered by MASPanelShellDialogHost, while the FloatRuntime owns lifecycle and input. Fixed controls remain anchored in the content area; scrollable controls are clipped to a dedicated body viewport driven by the official ScrollFactory/SkiaScrollAdapter.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Strongly typed entry into the shared MASSize intent API. This method keeps fluent chains on the concrete element while delegating all sizing decisions to MASControlBase/MASSize.

Broad visual category for a reusable surface material. Categories describe material families, not concrete controls or component names.

Canonical definition for one registered surface material. The registry owns these definitions so material identity, drawing, frame pairing, theme influence, and designer availability are not split across parallel catalogs.

Differentiates theme-adaptive material recipes from native recipes that preserve their own material palette inside the official registry.

Canonical profile identifiers for assigning official materials across generic surface slots. Profiles are not element identities; they are reusable material distributions.

One generic slot-to-material assignment inside a surface material profile. It references official material ids only and never stores element names.

Reusable material distribution for generic surface slots. A profile lets a complex element apply one named material personality to Root/Header/Body/Footer/etc. without inventing element-specific material ids.

Canonical registry for generic surface material slot profiles. It is intentionally separate from element controls: profiles describe material distribution, not component identity.

Resolved route from a generic surface slot/profile request to the canonical material, frame, role, and strength that the Surface runtime can consume.

Friend-only runtime switch for broad Nexamas UI surface materials. Runtime selection is render-scope owned, not process-global: a RootHost pushes its own material while it paints, so two MAS windows can render different Auto surfaces without leaking state into each other. Explicit material overrides still bypass this switch and stay owned by their component.

Clears only the current thread's ambient compatibility override. It intentionally does not mutate any process-global state because runtime material selection belongs to the painting host/scope that owns the surface being rendered.

Compatibility entry for internal callers that still select a material outside a render scope. New host/application code must use BeginMaterialScope or component-owned explicit material properties so selection remains isolated.

Compatibility entry for internal callers that still select a material outside a render scope. New host/application code must use BeginMaterialScope or component-owned explicit material properties so selection remains isolated.

Official internal route for applying surface materials by generic slot/profile. Complex elements use this route to say "Header uses CrystalIce" or "apply PremiumGlass profile" without creating element-owned material names or drawing recipes.

Extracted responsibility slice for MASAcrylicEffectPainter. Kept partial to preserve the binary/public surface while reducing hotspot size.

Calm crystal-ice material renderer. Previously consumed by crystal-ice surface consumers through the shared visual primitives path. Visual output is intentionally preserved 1:1; this refactor only extracts and renames the material layer away from element-oriented naming.

Internal ownership roles for interactive component chrome. These roles are generic chrome responsibilities, not surface material identities and not element names.

Centralizes the boundary between Surface Visual and Component Chrome. Surface Visual owns app/panel/card/stage surfaces; Component Chrome owns interactive control skins. The helpers are intentionally small because the concrete component renderers still own layout, text, icons, and hit-testing.

Premium elevated surface fill renderer. Owns only the card surface body and internal surface light/shade effects. Outer visual composition responsibilities are handled outside this material fill.

Cool dialog shell surface renderer (MASGlassPrime – Flat Polished Edition). نسخة زجاجية فلات، مصقولة، باردة جداً.

Woven Slate texture/body painter - flat polished cold glass - premium woven micro-texture - elegant top sheen and inner glass wash - refined edge fade, center bloom, and quiet lower anchor - ambient shadow is orchestrated by ShadowSystem semantic facades

Soft capsule / chip component chrome renderer. Component Chrome owns compact capsule skins; Surface Material remains generic and never registers chip-specific materials.

Soft chrome-like interactive component chrome renderer for action/bar skins. Component Chrome owns this painter; Surface Material remains responsible only for reusable surface bodies and does not know action-specific chrome.

Ambient, non-component shadow profiles owned by ShadowSystem. These profiles are used only by semantic surface facades that do not have an architecture contract.

Draws a direct blurred rounded-rect shadow for chrome/effect layers that do not need cached geometry. This keeps blur ownership in ShadowSystem instead of component chrome or material painters.

Draws a non-blurred rounded-rect shadow while preserving the caller-provided geometry and color exactly. Use for tiny component affordance shadows that are visually authored as flat translucent offsets but must still be owned by ShadowSystem.

Draws a non-blurred rectangular shadow strip while preserving exact geometry. Intended for separators such as pinned-column depth hints that are visually flat but still belong to ShadowSystem instead of data renderers.

Draws a non-blurred oval shadow for compact icon badges while preserving the exact caller-supplied bounds and color.

Owns the visual resources used by MASVisualPrimitivesPainter.

MASVisualPrimitivesPainter remains the public primitive drawing facade for controls, while this collaborator owns visual resource lifetime. Resource ownership is separate from primitive routing and visual recipe code.

Internal status for the Surface Treatment surface-only scope boundary.

Friend-only evidence report proving that Surface Treatment remains scoped to broad surfaces, chrome, panels, cards, and containers. Interactive controls remain outside this system.

Builds the surface-only scope boundary evidence. This audit does not draw, create controls, run capture scenes, resolve layout, or expose public API.

Final evidence status for the VisualSurface consumer/proof alignment chain.

Friend-only final report proving that all Surface Treatment evidence layers read consumer scope from MASSurfaceTreatmentConsumerCatalog instead of owning competing consumer lists.

Builds the final VisualSurface consumer/proof alignment evidence. This audit reads already-built reports only; it does not draw, instantiate controls, run captures, mutate registries, create public API, or alter runtime surface visual behavior.

Public button intent contract used by MASButton, MessageBox actions, toast actions, and float-panel actions. Uses the MAS-prefixed public naming convention required by the canonical SDK surface.

Global one-time runtime bootstrap for Nexamas.UI.

The bootstrap is intentionally split into two gates: - Core initialization is safe for lightweight ThemeHost snapshots and does not write diagnostics files or register project icon catalogs. - Full initialization is owned by real runtime hosts and may perform validation, diagnostics/report generation, and icon catalog registration.

Initializes only the minimum global state needed to create theme snapshots. This method must stay free from disk writes, icon catalog side effects, and global architecture validation.

Initializes the full Nexamas UI runtime for an actual host/application. Full bootstrap is the controlled admission path for global architecture validation.

Internal mutable runtime bootstrap settings, configured by MASApplication before the first host is created.

Immutable runtime view of the active theme, DPI scale, typography, and theme stamp.

ThemeContext is the official read path for rendering and controls. It must not mutate theme data, perform layout, route input, or own control state.

Runtime owner of the active theme snapshot for a rendering host.

ThemeHost resolves the current theme with DPI and typography into a ThemeContext. Consumers should read theme data through ThemeContext instead of ThemeManager.

Raised when the host snapshot is no longer safe to consume and the owning host should repaint.

Raised after the active ThemeContext/DPI/typography snapshot is rebuilt. Host runtime-environment owners use this to convert observed DPI/font snapshot changes into a retained layout refresh instead of discovering stale caches only during rendering.

Marks the per-host snapshot stale without fabricating a new surface/DPI context.

Base implementation for immutable application themes. Provides validated composition of identity, foundation, and family theme layers.

Concrete theme classes should only compose factories and must not introduce rendering, layout, input, or runtime behavior.

Public root contract for selecting and identifying a Nexamas UI application theme. The SDK-facing contract intentionally exposes only stable identity facts; deep foundation, family, and component recipe contracts are internal Nexamas UI implementation details consumed by controls through Friend theme contracts.

Public consumers observe and select a registered theme by identity. Nexamas UI owns registration and how that identity is decomposed into button, input, surface, scroll, menu, and other visual recipes. Arbitrary public IMASAppTheme registration is intentionally closed before v1. This identity-only public contract preserves selection and diagnostics while keeping custom recipe registration behind Nexamas UI-owned Friend seams until a complete public theme-builder contract is ready for v1.

Gets the stable theme identifier used by registries, windows, and Theme Studio snapshots.

Gets the human-readable display name shown in selectors and diagnostics.

Gets the immutable version stamp of the theme definition.

Internal access gateway from the public theme identity contract into Nexamas UI-owned deep theme composition contracts.

Public consumers receive as a stable theme identity and selection contract. Controls, renderers, Theme Studio, and commercial gates use this Friend gateway to consume foundation and family recipes without exposing the full recipe graph as SDK public API.

Builds the two-layer immutable theme composition from foundation and family factories.

Foundation is created first. Families are then derived from the completed foundation. This preserves a single composition path for all concrete application themes.

Global registry and current-theme selector for Nexamas UI application themes.

ThemeManager owns registration and current theme selection only. It does not know about DPI, typography, rendering, controls, layout, or runtime snapshots.

Central validation authority for theme identity, foundation, family completeness, and visual safety rules such as contrast, alpha, and surface differentiation.

Validation should fail loudly. ThemeValidator must not silently repair invalid themes or provide fallback colors.

Builds the neutral SurfaceChrome theme family from existing signature theme facts. This is the single ThemeSystem translation point from current PanelShell chrome recipes into a surface/chrome/container vocabulary.

Neutral surface chrome theme contract consumed by VisualSurface. It is owned by ThemeSystem so VisualSurface does not read PanelShell-specific theme contracts while still preserving the current platform chrome values.

Immutable ThemeSystem-owned surface chrome palette.

Visual effect colors for PanelShell chrome: glow, sheen, wash, scrim, and focus. This is not an OverlayRuntime/FloatRuntime host contract.

Factory contract for deriving all family theme contracts from a completed foundation.

Family factories translate foundation primitives into component-family themes. They must return a complete, immutable, non-null family bundle.

Immutable implementation of the brand color contract.

Stores validated brand colors only. It does not resolve usage, contrast, rendering, or component-specific behavior.

Defines the brand color contract for a theme.

Brand colors represent identity and accent usage. They are immutable foundation values and must not encode rendering or state behavior.

Defines theme-provided interaction colors for common visual states.

This contract owns colors only. Strength, geometry, behavior, and rendering are resolved outside the theme by interaction profiles and render helpers.

Immutable implementation of interaction color states.

Stores state colors for normal and danger interaction variants plus disabled fill. It must not decide active state, geometry, strength, or rendering.

Describes one optional interaction visual layer, such as a fill or ring color.

Disabled layers must be ignored by resolvers. Enabled layers must provide a visible color.

Describes the fill and ring layers available for one interaction state.

This structure is theme data only. It does not determine whether the state is active.

Factory contract for building the complete immutable foundation layer of a theme.

Foundation factories create global design primitives only. They must not build family themes, render visuals, or rely on mutable runtime state.

Defines neutral surfaces, borders, and metallic tones used across the theme.

Neutral values are foundational visual primitives and must remain immutable.

Immutable implementation of neutral surface, border, and metallic color tokens.

Defines semantic colors such as success, warning, danger, info, disabled, focus, selection, and navigation accent.

Semantic colors describe meaning, not behavior. They must not decide validation, input flow, or component state.

Immutable implementation of semantic theme colors.

Immutable implementation of foundation surface color tokens. This is a token container only; it does not render acrylic/effects.

Immutable implementation of the theme foundation bundle. Stores the complete set of foundational visual contracts for one theme.

This class is a data container only. It validates required sections and exposes read-only foundation contracts without rendering or resolving control state.

Defines text colors for normal, secondary, muted, disabled, inverse, and brand-surface text usage.

Text colors must remain visually safe and are validated for minimum alpha and contrast through theme validation.

Immutable implementation of the text color contract.

Immutable custom interaction color source for components that need MAS interaction geometry, strength, and rendering with component-owned palette colors.

This is a color adapter only. It does not own interaction state, geometry, intensity, or painting. Those remain owned by MASInteractionResolver, MASVisualInteractionScenarios, and MASSurfaceInteractionRing.

Defines all family-specific theme contracts derived from the foundation layer.

Family themes adapt foundation values to component families such as inputs, buttons, menus, overlays, lists, and messages. They must not render or manage state.

Defines immutable foundation surface color tokens including gradient stops, material wash, border tokens, shadow seed, and background tint.

This contract does not draw effects, surfaces, frames, or shadows. Visual execution belongs to MASSystem/Visual.

Defines the foundational visual tokens of a theme. Includes brand, neutral, semantic, text, interaction, surface, and background contracts.

Foundation values are global design primitives. They must remain immutable and must not depend on controls, layout, rendering, or runtime state.

Stable identity and registration metadata for an application theme.

Concrete immutable MASSignature application theme. Composes a foundation factory with the MASSignature family factory.

Concrete theme classes are composition roots only. They must not contain rendering, layout, input, or runtime logic.

Concrete immutable MASSignature application theme. Composes a foundation factory with the MASSignature family factory.

Concrete theme classes are composition roots only. They must not contain rendering, layout, input, or runtime logic.

Concrete immutable MASSignature application theme. Composes a foundation factory with the MASSignature family factory.

Concrete theme classes are composition roots only. They must not contain rendering, layout, input, or runtime logic.

Single palette authority for one concrete theme recipe. Provides color and surface primitives used to build the foundation layer.

ThemeColors is not an application theme and not a runtime context. It owns palette values only and must not contain rendering, geometry, strength, or state logic.

Utility methods for deriving perceptually constrained colors for theme recipes.

This class may assist palette construction, but it must not own theme identity, runtime state, rendering logic, or component behavior.

Friend-owned premium alignment policy for the legacy WinForms MASMenuButton trigger. It keeps visual state, menu-open eligibility, RTL text geometry, and color decisions out of the public compatibility control while preserving MASApplicationWindow.Shell as the official ownership route for RootHost and DropDownMenuPopupService.

Compatibility-only WinForms bridge trigger for MAS dropdown menus. Public consumers should normally obtain or bind instances through MASApplicationWindow.Shell so the RootHost and popup service stay owned by the MAS application facade.

Phase-11 API-04: MASMenuButton is intentionally isolated in Nexamas.UI.WinForms as an advanced compatibility surface. It is not a beginner/core SDK control path, does not expose RootHost publicly, and should not be expanded as a parallel UI layer.

Applies the same MASSize intent vocabulary used by Skia controls to this WinForms toolbox trigger. The trigger keeps explicit pixel WithSize(width, height) for advanced interop, but named sizes are always resolved from the MASSize default-size contract instead of a local preset table.

Optional internal extension for providers that can observe cancellation during expensive enumeration. Existing IFileSystemProvider consumers remain source-compatible, while FilePicker/FileExplorer can avoid UI-thread stalls.

Defines the behavior mode of MAS file picker components.

This enum is host-neutral. It does not imply Overlay, Float, modal ownership, or closing behavior.

Defines the configuration used to create a file picker experience.

MASFilePickerOptions is pure data. It does not know about Overlay. It does not know about Float. It does not close anything. It does not own modal/shield behavior. A host may use these options to configure a MASFilePickerControl, but host lifetime remains outside this class.

Creates normalized options for opening one or more files. This is the public SDK entry point; FilePickerOptionsFactory is now an internal implementation helper.

Creates normalized options for saving a file.

Creates normalized options for selecting a single folder.

Creates normalized options for selecting multiple folders.

Creates normalized options for selecting one or more drives.

Creates normalized options for selecting folders and drives.

Creates normalized options for selecting file-system targets by kind.

Internal implementation helper behind MASFilePickerOptions factory methods. Public SDK code should use MASFilePickerOptions.OpenFile/SaveFile/FolderPicker/etc.

This factory is host-neutral. It does not know about Overlay, Float, controls, or UI host lifetime.

Represents the result produced by a file picker action.

MASFilePickerResult is pure data. It does not know about Overlay. It does not know about Float. It does not close anything. It does not own UI lifetime. Accepted=True means the picker produced one or more valid selected paths.

Architecture marker contract for internal scroll bar surfaces. Scroll behavior remains outside ArchitectureSystem; this type only supplies contract identity.

Internal, host-independent repeat clock for scrollbar arrow hold gestures. This is a behavioral repeat clock for input hold semantics, not a visual Motion owner. It deliberately does not read Control.MouseButtons and does not use System.Windows.Forms.Timer. The clock runs from a Threading.Timer and marshals each repeat pulse through the root-owned UI dispatcher when one is supplied. When an official dispatcher is supplied it is authoritative: a rejected post stops the clock instead of falling back to a captured SynchronizationContext that may belong to a detached host. Only adapter instances created without an official dispatcher use the captured context as a legacy host-independent fallback. Repeat callbacks are treated as an input boundary: callback failures stop the clock and are reported through the diagnostics channel instead of escaping from the timer/dispatcher callback. The interval is intentionally close to a 60 Hz frame cadence, while the controller owns the actual velocity curve.

Internal Skia scrollbar adapter shared by MAS controls and popup content. The adapter owns viewport/content metrics, drag/wheel routing, DPI refresh, and invalidation coalescing; consumer applications must use the owning controls/services instead of constructing scroll infrastructure directly.

Resolves interaction fill/ring colors and strengths from theme data plus Visual interaction profiles. It does not draw and does not mutate theme state.

Builds semantic interaction overlay specifications. Architectural Law: - Contract-based Build is the preferred path for registered components. - Kind/family helpers are only for virtual parts, legacy adapters, or internal sub-surfaces that do not have their own registered component identity. - This class defines interaction language only; it must not become a universal visual template or override component-specific material DNA.

Builds a MAS interaction overlay from official interaction profiles while using a component-scoped interaction color source instead of Foundation.Interaction.

Legacy/virtual helper. Use only for internal sub-parts that have no registered component identity. Registered components must use contract-based Build.

Legacy/virtual helper. Use only when a real MASResolvedComponentContract is not available. Registered components must prefer contract-based Build.

Internal borderless Skia Form host for MASPanelShell-based dialogs. The Form owns only native/layered-window mechanics and input routing; public projects must reach PanelShell through MASApplication gateway surfaces.

Official beginner entry point for MAS-powered applications. MASApplication owns application-level lifetime and creates MASApplicationWindow instances; it does not replace MASSkiaRootHost, it owns it through MASApplicationWindow.

Official public, read-only diagnostics gateway for SDK consumers.

The gateway exposes safe immutable snapshots only. It does not expose runtime fault internals, source paths, source lines, or mutable diagnostics channels.

Configures Nexamas UI runtime startup and diagnostics behavior. Call this before creating the first MAS window.

This is the official SDK-safe, process-wide diagnostics entry point. It does not expose RootHost, MASExceptionSilencer, or the internal runtime options object; it only projects the reviewed switches that a packed consumer may need for production diagnostics or fail-fast development sessions. Configuration is frozen while any MAS window is alive so one host cannot silently change diagnostics/startup policy for another live host in the same process.

Official application-level size profile facade used by settings pages to switch Compact/Default/Comfortable/Large/Touch profiles.

Official public Output facade for readiness, chart-foundation, report-preview, and render-backed visual-capture exports.

Internal Output gateway used by certification gates to prove the public facade remains Application-owned.

Creates a MASApplicationWindow for one WinForms owner in a single call and owns the created MASApplication lifetime until the owner form closes. Use this for small demos and simple external applications that need the official MAS runtime without manually storing the MASApplication object. Larger multi-window applications can still use Create()/CreateWindow() to share one application lifetime.

Official public, read-only diagnostics gateway for SDK consumers.

This facade deliberately exposes safe summaries only. It does not expose MASRuntimeFaultRecord, MASRuntimeFaultChannel, source file paths, source line numbers, or any mutable diagnostics internals.

Captures a read-only snapshot of retained MAS runtime faults and diagnostics switches.

Maximum number of most-recent retained faults to project into the public snapshot. The value is clamped between 0 and 256.

Safe public projection of one retained MAS runtime fault.

This summary intentionally omits internal source file paths, source line numbers, mutable channel details, and Friend-owned enum types.

Public read-only diagnostics snapshot for SDK consumers.

Counts are derived from the currently retained in-process fault window. Long-running retention counters are intentionally separate from this safe gateway and are governed by the fault-storm retention gate.

Application-level runtime startup and diagnostics options.

The defaults favor responsive first-window startup: strict validation remains enabled, while expensive report generation and disk diagnostics are opt-in. Configure these options before creating the first MASApplicationWindow.

Development/test option. When enabled, MASControlBase construction throws immediately if the architecture contract probe cannot resolve the control type. Production/default mode keeps construction permissive and fails at ControlsLayer admission.

Beginner-facing application-level facade for the MAS runtime size profile. This is the public settings-page gateway; it delegates to the single MASSize runtime owner and does not introduce a second sizing, density, or layout system.

Public event data for MAS application theme changes exposed by MASApplication.Theme.

Beginner-facing application-level theme facade. This is the official global entry point for listing, registering, and selecting MAS themes. Window repaint/snapshot refresh remains owned by each MASApplicationWindow/ThemeHost.

Raised when the current MAS application theme changes through MASApplication.Theme or any window theme facade.

Raised with old/new theme data when the current MAS application theme changes.

Internal notification raised only when Nexamas UI-owned theme registration occurs. Public custom-theme registration is intentionally closed before v1; consumers select registered themes by id.

Internal registration seam for Nexamas UI-owned themes only. Public SDK consumers select already registered themes by id; arbitrary IMASAppTheme registration is closed before v1.

Describes why an owned MAS Application settings surface requested closure.

Public options used when Nexamas UI builds its owned application settings page. The options describe content and behavior only. Page spacing, padding, chrome offset, and max-width are owned by MASApplicationSettingsLayoutPolicy so public consumers do not configure owned Settings geometry with raw numbers.

Internal chrome reservation used only by MAS-owned borderless settings sessions. This is not public SDK geometry customization.

Internal Application-settings layout policy. It centralizes the owned Settings page spacing, padding, chrome reservation, max-content width, and compact-row choices so Application pages consume MASLayout vocabulary instead of public raw-number options.

Immutable result returned after an owned MAS Application settings page is applied to a window.

Official Nexamas UI Application settings page builder for a MASApplicationWindow. The page owns only Application-level settings UI. It never calculates control sizes, never writes bounds, and never introduces a parallel layout or sizing system.

MAS-owned borderless settings window session. It uses MASApplicationWindow, MAS TopBar, MAS chrome, and MAS Application settings page content; no consumer WinForms title bar is required.

Brings the owned MAS settings window to the front without creating a consumer WinForms settings form.

Official MASApplicationWindow settings facade. It exposes owned Application settings surfaces without exposing sizing internals, layout nodes, or direct bounds APIs to consumers.

Official Application settings section for the runtime MAS size profile. The section owns only pending UI state. It applies and persists the profile only when Apply is pressed.

Describes how a theme facade applies theme changes.

Theme selection is shared by the whole MAS application process. All ThemeHost instances observe ThemeManager.Current and refresh their snapshots after the global current theme changes.

Beginner-facing owner of one MAS window host. It hides normal RootHost ownership while keeping the technical host available as AdvancedRootHost.

Advanced compatibility access. New beginner code should prefer the typed facades on this class.

Official same-window Application page host. Use it when an application should keep one MAS shell and swap workspace content through LayoutApplicationSurface instead of opening new Forms or maintaining hidden page panels.

Official size profile facade for this MAS window. Profile selection is global; the window refresh hook is local.

Official Application settings facade for this MAS window.

Official native window chrome facade for this MAS window. Use this instead of consuming MASDwmShadowHost / MASDwmShadow directly.

Official host-window presentation facade for size, placement, restore, and user preferences. It does not arrange child controls; use Screen/Layout/Page for content layout.

Friend-only application facade used by MAS-owned public gateways that must marshal lifecycle-sensitive UI construction back to the RootHost dispatcher without exposing the RootHost or any WinForms control to SDK consumers.

Public handle returned by MASApplicationWindow.Services.Progress. It updates one root-owned MASOperationProgressBox float and closes it through FloatRuntime ownership.

Official MASApplicationWindow facade for compact floating operation progress. The facade hosts the real MASOperationProgressBox inside the root FloatRuntime directly; it does not create a PanelShell dialog, a local overlay, or a hand-drawn progress surface.

Official window-chrome facade for one MASApplicationWindow. It owns native shadow / rounded-corner integration without exposing MASDwmShadowHost, MASDwmShadow, NativeMethods, or raw Win32 constants to external projects.

Enables the standard MAS rounded borderless-window chrome. This is the SDK path that replaces direct MASDwmShadowHost usage.

Enables native chrome integration using explicit options.

Re-applies the current native chrome attributes. Useful after handle recreation.

Detaches MAS-owned native chrome hooks from the owner form.

Product-grade standalone WinForms window chrome facade. Use this for MAS-owned lightweight Form surfaces that are not MASApplicationWindow instances, such as startup/preflight layered dialogs. It keeps MASDwmShadowHost, MASDwmShadow, and raw Win32 details internal to MAS.

Attaches MAS window chrome to a standalone WinForms form and returns an owned lifetime handle. Dispose the returned value when the form is disposed if you want deterministic cleanup.

Applies MAS window chrome to a standalone form without exposing native internals. This convenience method attaches a self-cleaning chrome lifetime to the form.

Internal shared implementation for MAS window chrome facades. Keeps native DWM shadow integration centralized so public facades do not duplicate host logic.

Internal native hit-test owner for MAS borderless WinForms hosts. It gives FormBorderStyle.None windows normal OS resize behavior without requiring external demos or applications to copy WndProc code, and without creating a second rendering/chrome system.

Options for MASApplicationWindow.Chrome. This is the public, product-grade replacement for consuming raw MASDwmShadowHost / MASDwmShadow internals.

Shadow and rounded-corner mode used for the owning WinForms window.

Optional delay before applying native chrome attributes. Normally 0.

Optional non-client pulse for hosts that need a frame refresh after DWM attributes are applied.

Enables native edge/corner resize hit-testing for borderless WinForms hosts that use MAS chrome. This keeps custom TopBar windows resizable without forcing external apps to implement WndProc hacks.

Native hit-test thickness in pixels used by the internal borderless resize controller.

Conservative chrome settings for lightweight layered startup/preflight forms. It avoids aggressive DWM frame extension and leaves the layered surface in charge of transparency.

Public shadow mode used by MASApplicationWindow.Chrome. It intentionally hides raw DWM implementation details from SDK code.

Main-window DWM shadow where supported, with classic fallback.

Classic class shadow only. Useful on older Windows builds.

Stable rounded-corner shadow path for borderless MAS windows. This avoids exposing MASDwmShadow / MASDwmShadowHost directly.

Official window geometry surface for DPI and viewport conversions. This class does not create any runtime; it delegates to the owning MASSkiaRootHost.

Returns the usable surface viewport in physical pixels. The optional top inset is expressed in logical units and converted by the RootHost.

Converts logical bounds to physical-pixel bounds using the owning window DPI. Use this before passing anchor rectangles to float/popup APIs that explicitly require *Px.

Converts physical-pixel bounds back to logical bounds using the owning window DPI.

Intent-revealing alias for LogicalToPx when preparing popup/menu/float anchors.

Returns the control's layout-owned outer bounds in logical/DIP units. This is a geometry gateway over MASLayoutSlot; consumers do not read slots directly.

Returns the control's layout-owned visual bounds in logical/DIP units. Use this for rendering adorners whose visuals must include overflow facts.

Returns the control's layout-owned content bounds in logical/DIP units. Use this when placing owned content inside a surface/control.

Returns the control's layout-owned hit-test bounds in logical/DIP units.

Returns the control's layout-owned focus-ring bounds in logical/DIP units.

Returns the control's layout-owned float-anchor bounds in logical/DIP units. Use this for popup/dropdown/tooltip anchors instead of BoundsLogical.

Returns the control's layout-owned outer bounds in physical pixels.

Returns the control's layout-owned visual bounds in physical pixels.

Returns the control's layout-owned content bounds in physical pixels.

Returns the control's layout-owned hit-test bounds in physical pixels.

Returns the control's layout-owned focus-ring bounds in physical pixels.

Returns the control's layout-owned float-anchor bounds in physical pixels. This is the safest gateway for FloatRuntime and popup anchor rectangles.

Intent-revealing alias for ControlFloatAnchorBoundsPx.

Returns True only when the surface viewport can be safely used for placement.

Official rendering context exposed by MASApplicationWindow.Rendering events. It gives application code the information needed for custom drawing without exposing ThemeHost/ThemeContext as the beginner entry point.

Public semantic alignment vocabulary for action groups. Consumers choose where the group lives inside its available layout slot; MASLayout resolves the final logical bounds.

Public action-group layout builder used through MASApplicationLayoutPageBuilder.ActionGroup(...). It gives application screens an official way to declare button/action rows with equal item sizing, semantic spacing, and start/center/end placement without hard-coded widths or x coordinates.

Uses the official MASLayout semantic spacing vocabulary between actions.

Alias for Spacing(...), useful when the action group is read as a row of buttons.

Uses semantic padding around the action group instead of raw logical numbers.

Makes all actions use the largest measured item width. This is the default for ActionGroup.

Makes all actions use the largest measured width and height in the group.

Restores per-action intrinsic sizing for cases where equal action buttons are not desired.

Adds an action control. The default intent keeps the action intrinsic while the group may equalize item width through MASLayout, not through control.Width assignments.

Public semantic direction for filter bars. A filter bar can be a wrapping toolbar row, a single command-bar row, or a vertical sidebar/footer stack while still resolving through MASLayout.

Public semantic placement choices for filter bars and form rows. Consumers describe intent; MASLayout resolves the final logical bounds without x/y/width assignments.

Official semantic filter-bar builder for search boxes, combo boxes, toggles, checkboxes, and compact filter fields. It is not a helper and not a second layout engine: it converts filter intent into MASLayout stack/flow nodes and keeps normal screens away from manual bounds.

Uses a wrapping filter row. This is the default for command bars and wide content areas.

Uses one horizontal row. Prefer this for compact command-bar filters that should not wrap.

Uses a vertical filter stack. Prefer this for SidebarFooter or inspector filter sections.

Uses semantic spacing between filter fields.

Alias for Gap(...), useful when reading the filter bar as a row/stack.

Uses semantic padding around the filter bar.

Makes all filter entries use the largest measured width.

Makes all filter entries use the largest measured width and height.

Restores intrinsic per-field sizing.

Stretches filter entries across the cross axis. In vertical sidebars this makes fields fill width.

Keeps filter entries at intrinsic cross-axis size.

Centers filter entries on the cross axis.

Adds one filter control. Use MASSize.FillWidth only when the field should consume the available slot.

Adds one full-width filter control, useful for sidebar search boxes or combo boxes.

Adds the official premium SearchBox field to this FilterBar through the existing MASSearchTextBox route. The field remains a normal MAS control; FilterBar owns only semantic placement, not DataGrid filtering.

Adds the official premium ComboBox field to this FilterBar through the existing MASComboBox route. Selection remains owned by MASComboBox and any query/projection remains owned by the host application.

Adds the official premium DatePicker field to this FilterBar through the existing MASDatePicker route. Date selection remains owned by MASDatePicker and is not converted into a hidden DataGrid adapter.

Adds a subtle official MASButton action intended for clearing visible filter fields. The supplied action owns the application reset behavior; FilterBar does not mutate data sources.

Adds a primary official MASButton action intended for applying or refreshing visible filters. The supplied action owns the query/update behavior; FilterBar remains a semantic surface only.

Adds a label+input form row inside the filter bar.

Adds a custom form row inside the filter bar.

Official semantic form-row builder for label/control pairs and compact settings rows. FormRow is built from MASLayout stacks and MASSize intents; it never assigns control.Width, control.Left, or direct bounds.

Adds a row label or caption with intrinsic sizing.

Adds the input/control side of the row.

Adds any control to the row when it is not specifically a label or input.

Public semantic tile-size vocabulary for Gallery layouts. Consumers choose a product intent; Nexamas UI resolves the final logical tile width/height from the active MASSizeProfile.

Public semantic horizontal alignment choices for galleries whose capped tile columns do not fill the whole content workspace. The layout remains slot-based, not coordinate-based.

Official semantic gallery builder for tile/icon/card collections. It is not a helper and not a product-specific engine: it converts Gallery intent into the native MASLayout TileGrid primitive, preserving MASSize profiles, semantic spacing, equal tile sizing, and responsive column wrapping.

Uses a semantic tile size. This is the preferred SDK path for icon galleries, preview grids, and card collections because it remains density/profile aware.

Advanced explicit tile-size escape hatch. Prefer TileSize(MASApplicationGalleryTileSize) in normal application code so size profiles remain the primary tuning surface.

Sets the preferred minimum number of columns when the workspace has enough width. Narrow hosts may still resolve to fewer columns to avoid clipping.

Caps the responsive gallery column count. Use this when a content area should not stretch into an unreadably wide row of tiny meaning units.

Uses an exact semantic column count when the workspace width allows it, without consumer x/y coordinates.

Lets the gallery use as many columns as fit the available workspace.

Adds one tile control. The tile receives a stable Gallery slot; the control itself does not receive Width/Height assignments from consumer code.

Adds several tile controls in insertion/navigation order.

Internal semantic gallery tile-size resolver. Base values stay inside Nexamas UI and are later scaled by MASSizeProfile; external projects should not hard-code these DIP numbers.

Platform-owned page layout presets for application surfaces that reserve the standard MAS TopBar and then arrange content through MASSize/MASLayout. External projects choose intent; Nexamas UI owns the actual padding, spacing, content width, and active-size-profile scaling.

Semantic surface-size presets for application and presentation areas that need more vertical room than a single button or input without consumers applying raw MASSize.OffsetHeight values locally. Consumers choose semantic intent through builders; Nexamas UI owns the numeric metrics through internal policy.

Resolved application page layout profile. Values are already resolved for the current runtime size profile and may be consumed by lower-level composition code that cannot use MASApplicationLayoutPageBuilder directly. This is not public SDK state; consumers select page intent through MASApplicationLayoutPageBuilder and MASPresentationPage instead of reading resolved padding/width numbers.

Internal Application layout policy. This is not a second layout system; it resolves official MASApplication page presets into MASLayout values so product surfaces do not carry local TopBar heights, page padding numbers, or content width formulas. External projects use MASApplicationLayoutPageBuilder, MASPresentationPage, and MASApplicationWindowShell instead of this resolver.

Official same-window Application page host. It keeps one MASApplicationWindow shell alive and swaps only the workspace content through LayoutApplicationSurface, using MAS TreeView navigation, MASLayout/Size tokens, and Application-owned page metadata instead of top-level-window navigation or retained inactive page panels.

Registers a same-window page. The build action is cached by the page host after its first use, so pages should describe their MAS controls through MASApplicationLayoutPageBuilder instead of top-level-window navigation, manual bounds, or retained inactive panels.

Shows or hides the official MASBreadcrumb path trail in the PageHost workspace. The trail is rendered by MASBreadcrumb and navigates only to already registered MASApplicationWindow.Pages routes, so consuming applications do not need a secondary breadcrumb renderer, router, or manual page-position label.

Sets the first segment shown by the PageHost MASBreadcrumb path trail. Blank values fall back to the neutral "Pages" segment.

MASApplicationWindow.Pages internal immutable page record. It is not public API: consumers register pages through MASApplicationPageHost so ApplicationSystem remains the single owner of same-window navigation state.

Beginner-facing controls API for one MASApplicationWindow. This class does not create a controls layer; it delegates to the single root-owned ControlsLayer instance. It is also the official Application-level creation gateway for direct Skia controls: each Create/Add method returns the real MAS control type and then hosts it through the same root-owned ControlsLayer, without duplicate control ownership, adapters, shadow registries, or parallel runtimes.

Detaches a control from this window. This is intentionally detach-only: it does not dispose the control, so callers can reuse or dispose it explicitly according to their own ownership model. Use RemoveAndDispose when the window should remove and dispose the control in one lifecycle step.

Detaches all direct controls from this window. This is intentionally detach-only and does not dispose controls. Use ClearAndDisposeCreatedControls to dispose controls created by the Add* factories.

Removes and disposes a single control through the window controls lifecycle boundary. This is the explicit destructive counterpart to Remove, which remains detach-only.

Removes and disposes controls that were created and hosted by this facade through Add* factories. Manually added controls remain consumer-owned and are not disposed by this method.

Runs a group of control additions, state changes, and direct placements as one visual update. This is the preferred performance gateway for external screens that create or place many MAS controls without using the Composition layout system.

Applies an official MASSize/MASLayout page plan to direct MAS controls hosted by this window. This is the beginner-facing replacement for normal consumer x/y/w/h math in external product and sample pages. The build action is retained and reapplied when the host surface is measured again, so resize uses the same page intent instead of stale manual bounds.

Applies an official multi-region MASLayout recipe to direct MAS controls hosted by this window. Consumers describe product regions and content intent; MASLayout still produces the final slots.

Raised after a retained Application layout refresh fails without throwing to the host resize/theme path. Read the LastLayoutRefreshFailure* properties for the developer-visible failure snapshot.

Indicates whether the retained Application layout facade has a recorded refresh failure snapshot. A later successful retained layout pass clears this flag.

Official retained-layout surface that last failed, such as LayoutPage or LayoutApplicationSurface.

Runtime reason that triggered the last retained-layout refresh failure.

Internal refresh stage that produced the last retained-layout failure, without exposing layout engine objects.

Diagnostic code for the last retained-layout refresh failure.

Developer-facing message for the last retained-layout refresh failure.

Additional detail for the last retained-layout refresh failure.

Exception type for the last retained-layout refresh failure, or an empty string for non-exception diagnostics.

UTC time when the last retained-layout refresh failure snapshot was recorded.

Applies the official semantic application-surface MASLayout recipe to direct MAS controls hosted by this window. This is the preferred full-screen API for command bars, navigation/side regions, true workspaces, inspectors, and footers. It computes regions from intent and still uses the canonical MASLayout engine for slots.

Keeps layout-session replacement atomic: a failed new LayoutPage/LayoutRegions/LayoutApplicationSurface recipe must not dispose the previously valid retained session or its resize/profile hooks.

Clears any retained Application layout session, regardless of whether it came from LayoutPage, LayoutRegions, or LayoutApplicationSurface. The name is intentionally broad so future maintenance does not treat workspace/region cleanup as a page-only path.

Centralizes the transition from retained Application layout ownership back to direct consumer mutation. Remove/Clear/Place must pass through this gate so session hooks, application-surface background cleanup, and layout-hosted control ownership are released consistently without duplicating tiny cleanup paths.

Opens a retained Application layout build-admission scope. Controls added through the public Add/AddControl helpers while LayoutPage, LayoutRegions, or LayoutApplicationSurface is building its official recipe are admitted as layout-hosted controls, so the next successful recipe can remove them when they are no longer desired. This keeps same-window page navigation from stacking stale page controls while direct Add outside retained layout remains consumer-owned.

Records a control admitted during a retained Application layout recipe. A control that was already hosted before the recipe remains consumer-owned unless it was already layout-hosted; newly admitted controls are marked so ReconcileLayoutHostedControlsInternal can dispose of stale workspace/page content on the next successful layout pass.

Reconciles the controls that were hosted by the retained Application layout gateway itself. Controls that were already in the layer before a layout recipe remain consumer-owned and are not removed when a later recipe omits them; controls first admitted by LayoutPage/LayoutRegions/LayoutApplicationSurface are removed when they are no longer desired by the successful next recipe.

Removes controls admitted by retained Application layout sessions when the user leaves the retained layout path through Clear/Remove/Place. Manually hosted controls remain in the layer.

Direct Add/AddControl calls are consumer-owned admissions. If the same control had previously been admitted by a retained Application layout recipe, this removes only the retained-layout ownership mark while leaving the control itself and any active retained layout session untouched.

Applies a MASLayout plan through the owning controls gateway and reports whether geometry changed. This core is deliberately private: retained Application layout sessions must enter through TryApplySizeLayoutPlanInternal so diagnostics can block invalid recipes before geometry mutates. Engines only produce facts; this facade remains the only direct-control Application owner allowed to mutate layout slots.

Applies an Application-level MASLayout plan only after its diagnostic bag is known to be clean. LayoutPage/LayoutRegions/LayoutApplicationSurface use this owner gate so duplicate controls or invalid semantic-region plans fail without partially mutating previously valid control geometry.

Blocks retained Application layout recipes when the engine fails to produce a plan. A missing plan must be treated as a diagnostic failure so callers do not reconcile hosted controls or replace a previously valid retained session after a no-output pass.

Blocks explicit-region and application-surface recipes when an individual region fails to produce a MASLayout plan. Region-level no-output passes must be diagnostic failures; otherwise controls collected from that region could be hosted without a corresponding layout slot.

Places a direct MAS control through the official controls gateway. Unlike assigning BoundsLogical from consumer code, this uses the framework's layout-owned placement path and participates in PerformUpdate batching, so resize/layout passes emit at most one host invalidation.

Places a direct MAS control using logical x/y/width/height values through the official controls gateway.

Adds a direct Skia MAS control to this window and returns the same typed instance for fluent consumer code. Use this when the control was created manually or by a Create* method on this facade.

Public consumer gateway for the standard full-width application MainMenuBar. The menu bar is attached to the shell-owned chrome slot below the TopBar; it is not admitted into the page/direct controls layer even though it follows the Controls.Add* factory naming used by normal MAS components.

Gives focus to a MAS control through the owning window controls layer.

Intent-revealing alias for Focus.

Advanced compatibility access to the existing root-owned controls layer. Prefer Add/Remove/Clear and the Create*/Add* gateways for new code.

Beginner-facing context menu API for one MASApplicationWindow. It keeps context-menu registration under window.Services instead of exposing RootHost wiring.

Registers a right-click context menu scope using a logical-space region.

Internal access to the root-backed coordinator for MAS-owned integrations.

Beginner-facing input API for one MASApplicationWindow. It exposes intent-level input settings and notifications without exposing the raw RootHost input coordinator.

Pre-route observation notification. Handlers cannot mark the pointer event handled or suppress MAS routing. Use MAS controls, commands, or official routing participants for behavior; this event is diagnostics/telemetry only.

Pre-route observation notification. Handlers cannot mark the pointer event handled or suppress MAS routing. Use MAS controls, commands, or official routing participants for behavior; this event is diagnostics/telemetry only.

Pre-route observation notification. Handlers cannot mark the pointer event handled or suppress MAS routing. Use MAS controls, commands, or official routing participants for behavior; this event is diagnostics/telemetry only.

Pre-route observation notification. Handlers cannot mark the wheel event handled or suppress MAS routing/page fallback. Use MAS controls or official routing participants for behavior; this event is diagnostics/telemetry only.

Enables WinForms mouse capture while dragging the MAS top bar.

Enables the smarter MAS top bar move path used by the root input coordinator.

True when the owning window has a top-bar input region attached.

True when native WinForms/SKGLControl input handlers are attached automatically.

Attaches native WinForms/SKGLControl input handlers. Use this after creating a window with autoHookPointerInput:=False.

Detaches native WinForms/SKGLControl input handlers while leaving manual routing methods available internally.

Releases any pointer capture owned by the window input router.

Synchronizes the input hot-state from the current OS cursor position. Useful after native focus or mouse transitions.

Advanced compatibility access to the raw RootHost input coordinator. Prefer MASApplicationWindow.Input settings/events/methods for normal SDK code.

Official rendering hook surface for one MASApplicationWindow. It subscribes to the existing root-host render events and does not create a parallel renderer.

Draws behind the ControlsLayer. Handlers may draw on the provided SKCanvas, but must not own host lifetime, input, overlays, or DPI state.

Draws after controls and before overlay preparation. Use for lightweight adorners only.

Draws immediately before overlay/float content. Do not use this as a backdoor to OverlayManager or FloatRuntime ownership.

Draws after overlay/float content. Use sparingly for diagnostics or final visual adorners.

Draws a standard MAS card surface using the official MAS rendering facade. This keeps card painters internal while allowing application code to draw MAS-consistent chrome.

Draws the official command-region background when requested by the caller. The public choice is only visible/hidden; Nexamas UI owns the internal visual and paints the same default card surface used by application-surface regions, not a command-specific SurfaceVisualStyle.

Draws a SurfaceVisualStyle-owned application surface inside caller-owned bounds. This is the official advanced rendering gateway for application regions that already have a correct MASLayout slot and only need Nexamas UI-owned material/frame/chrome personality. It must not be used to compute layout or replace semantic application-surface APIs.

Beginner-facing toast facade for one MASApplicationWindow. It hides the float-backed toast runtime and exposes only intent-level toast operations.

Public SDK result for showing a toast and ensuring the toast host surface is available.

Public handle for a tooltip registration created through MASApplicationWindow services. Disposing the handle unregisters the target from the real root-owned MASTooltips service.

Beginner-facing tooltip API for one MASApplicationWindow. This class does not create a tooltip runtime; it delegates to the single root-owned MASTooltips instance.

Internal pixel-space tooltip target hook for MAS-owned surfaces.

Internal dynamic pixel-space tooltip target hook for MAS-owned surfaces.

Registers a tooltip target for a MAS control using its layout-owned float-anchor bounds converted by the root host. The control must provide tooltip text, for example MASButton.Tooltip.

Internal custom-rectangle tooltip hook. Public consumers register the MAS control itself.

Advanced compatibility access to the existing root-owned service. Prefer Register/Remove/Clear for new code.

Application-level backdrop/protection mode for modal dialog and panel flows.

Public SDK shield options for Application-owned dialog/panel flows. Internally translated to MASFloatShieldOptions without exposing FloatRuntime as SDK surface.

Application-level reason for protecting a dialog or panel from accidental dismissal.

Application-level policy for showing dialogs/panels through MASApplicationWindow. This is the public SDK contract. FloatRuntime policies remain internal.

Internal command description used by the owned PanelShell execution path. Public SDK consumers must use high-level dialog gateways such as MASSelectionPanelOptions instead of composing command bars directly.

Internal alignment contract for PanelShell edge sections such as Toolbar and Footer. Start maps to the left edge in the current left-to-right Nexamas UI shell layout.

Internal command section used by Nexamas UI-owned PanelShell surfaces. Public callers choose actions through high-level gateway options; button order, sizing, edge inset, gap, and alignment remain owned by Nexamas.UI.

Enables or disables this command section without clearing its actions.

Horizontal placement of the command group inside the section.

Reserved section height in pixels before DPI conversion.

Default width for generated MASButton actions.

Default visual height for generated MASButton actions.

Horizontal gap between generated action buttons.

Distance from the aligned outer edge before the action group starts.

Gap reserved between this section and the content body. For Toolbar this is the gap below; for Footer this is the gap above.

Applies an owned Nexamas UI action-group metric preset. This keeps generated PanelShell command sections aligned with MAS ActionGroup decisions without exposing raw button geometry to public SDK consumers.

Internal themed inner frame for Nexamas UI-owned PanelShell content bodies. It can frame either the whole body or only the internally defined scrollable viewport. Public SDK callers do not own shell chrome, frame offsets, scrollbar gutters, or PanelShell group-box styling directly.

Enables the inner themed content frame. Disabled by default so normal panels stay flat.

Optional floating title drawn by the underlying MASGroupBox renderer. Empty titles produce a simple border/frame without reserving title height unless ReserveHeaderWhenEmpty is explicitly enabled.

Defines which part of the official content body receives the inner frame. ContentBody frames the whole body and gives ContentBuilder the inner size. ScrollableArea frames only the later SetScrollableArea(...) viewport so callers can keep descriptions, counters, or helper text outside the visual group.

Internal PanelShell body section. Padding and scrollbar placement are owned here so gateway builders do not duplicate shell chrome offsets or manual scrollbar gutters.

Optional themed inner GroupBox surface for caller content. When enabled, ContentBuilder receives the inner frame content bounds.

Safe distance between the scrollbar track right edge and the shell content edge. Lower values move the scrollbar closer to the edge without touching the chrome.

Internal options for showing Nexamas UI-owned content inside the reusable MASPanelShell FloatRuntime surface. This low-level contract intentionally remains inside the assembly. Public SDK consumers must use high-level gateways such as ShowSelectionPanel so Skia geometry, content hosts, command bars, and scroll placement do not leak outside Nexamas.UI.

Applies an owned PanelShell surface-size preset. Public SDK consumers never set these pixel metrics directly; high-level application gateways pick semantic presets.

Official top command section for tool/action buttons above the content body.

Official body section for caller-owned feature controls and body scroll placement.

Official bottom command section for dialog actions.

Internal layout policy for Nexamas UI-owned PanelShell surfaces. High-level surfaces such as SelectionPanel choose semantic presets here instead of scattering button widths, gaps, frame padding, and preset bounds through request builders.

Internal result object produced by the owned PanelShell command path. Public SDK consumers receive dedicated gateway results such as MASSelectionPanelResult instead of this low-level command result.

Public item contract consumed by MASSelectionPanelOptions. It intentionally carries semantic selection data only; no MASCheckBox, SKRect, ContentHost, or PanelShell layout concepts are exposed.

Stable value returned in MASSelectionPanelResult.SelectedKeys when this item is selected.

User-facing text shown in the selection panel.

Optional secondary data owned by the consuming application. Nexamas UI does not inspect this value.

Initial selected state.

Marks the item as part of the built-in Recommended command.

High-level item layout recipe for public selection panels. Nexamas UI owns the concrete row, column, and scrollbar geometry.

Nexamas UI-owned internal contract for showing checklist/single-choice content inside a MAS PanelShell-backed dialog. This type describes selection intent only; Nexamas UI owns the underlying PanelShell, toolbar, footer, scrolling, and item layout.

Result returned by the public MAS selection panel gateway. It exposes selected keys/items directly so consumers never need to inspect generated controls or PanelShell command identifiers.

Defines how many items the public MAS selection panel may return. The selection mode is part of the SDK contract and does not expose the underlying PanelShell controls used to render the choice surface.

High-level size recipes for public selection panels. Consumers choose intent-sized dialogs instead of manually calculating PanelShell pixel bounds, max sizes, or viewport ratios.

Public SDK close reason used by application-level surfaces. FloatRuntime close reasons remain an internal implementation detail.

Public SDK lifecycle snapshot for an application surface handle.

Public SDK-level outcome for a request that attempts to show an application surface.

Public application-level result returned by MessageBox-style dialog surfaces.

MessageBox rendering and FloatRuntime completion are internal Nexamas UI details. External consumers receive this stable public enum through MASApplicationResult.Value when using MASApplicationWindow.Services.Dialogs.

Public SDK completion status for an application surface result.

Public SDK completion result for application-level surfaces.

Public SDK handle for a dialog, picker, explorer, panel, or another application-owned surface. It intentionally hides the internal FloatRuntime handle.

Public SDK result for showing a dialog, panel, toast host, file surface, or other Float-backed application surface.

This type preserves the precise FloatRuntime outcome without exposing internal FloatRuntime result classes. Compatibility APIs still return MASApplicationSurfaceHandle, but *Ex APIs return this object so callers can distinguish Opened, Queued, Reused, and Rejected outcomes without treating Nothing as an ambiguous signal.

Public SDK event data delivered after an application surface closes.

Public SDK event data delivered after an application surface opens.

Public SDK options for showing the application file explorer surface.

Shows the PanelShell header close button. The FileExplorer toolbar does not own a close button.

Public SDK result payload for an accepted application file explorer surface.

Message/dialog facade for one MASApplicationWindow. This class is the public application-level entry point for dialog surfaces. Legacy GroupBox-backed ShowPanel APIs and the former low-level public ShowPanelShell composition API are intentionally not part of the SDK surface. Nexamas UI-owned features may use internal high-level gateways such as ShowSelectionPanel.

Shows a high-level checklist/single-choice selection panel without exposing PanelShell geometry, generated controls, or Skia layout primitives to SDK consumers.

Shows a high-level checklist/single-choice selection panel and returns the standard Application surface show result. PanelShell remains the internal renderer.

Internal gateway for Nexamas UI-owned feature content inside the reusable MASPanelShell FloatRuntime surface. External SDK callers must use the public dialog gateways or Nexamas UI-owned internal feature gateways as appropriate.

Internal gateway for Nexamas UI-owned feature content inside the reusable MASPanelShell FloatRuntime surface. It accepts the low-level PanelShell options produced by internal builders only.

Beginner-facing file explorer facade for MASApplicationWindow.Services. Keeps file-explorer float mechanics behind the application entry surface.

Advanced compatibility access to the underlying RootHost-backed file explorer service. Prefer the methods on MASApplicationWindow.Services.FileExplorer for normal SDK code.

Hosted file picker facade for MASApplicationWindow.Services. Keeps raw/unhosted file picker creation behind the application entry surface; SDK consumers use Show* hosted routes or control factories.

Returns whether a file-picker surface handle is still open through this window service.

Closes a file-picker surface previously returned by a Show* method.

Closes only file-picker surfaces whose owner key is currently owned by this service.

Advanced compatibility access to the underlying RootHost-backed file picker service. Prefer the methods on MASApplicationWindow.Services.FilePicker for normal SDK code.

Beginner-facing service facade for one MASApplicationWindow. It reuses the existing RootHost-backed service implementations and does not create parallel runtimes.

Official floating operation-progress facade for one MAS application window. It hosts MASOperationProgressBox inside the root-owned FloatRuntime without creating a PanelShell dialog.

Advanced compatibility access to the underlying RootHost-backed file explorer service. Prefer MASApplicationWindow.Services.FileExplorer for normal SDK code.

Advanced compatibility access to the underlying RootHost-backed file picker service. Prefer MASApplicationWindow.Services.FilePicker for normal SDK code.

Advanced compatibility access to the root-owned Float runtime for framework extensions. Prefer the typed window service and shell facades for normal SDK code.

Internal translation from the Friend-owned MASSelectionPanelOptions contract to the existing PanelShell float implementation. This is the official high-level API builder that keeps PanelShell geometry and generated controls internal.

Internal runtime state for the public selection panel gateway. It owns the generated checkbox controls so external SDK consumers receive only MASSelectionPanelResult values and never depend on PanelShell internals.

Public immutable item exposed by the official MASApplication surface-material gateway. The key is the only value applications should pass back to the gateway when switching broad surfaces; Showcase and product hosts must not maintain a parallel material list.

Official public entry point for selecting Nexamas UI broad surface materials from an application. It exposes the selectable catalog from the platform-owned material registry and creates application scopes that apply one material through Nexamas UI gateways only.

Friend-only compatibility reset for tests and internal host cleanup. Public consumers select material through CreateScope/Apply and do not own runtime-switch lifetime.

Official public application-scope switch for Nexamas UI broad surface materials. It is the single public entry used by Showcase and product hosts: callers register the broad-surface owners they host, then call Apply once with a material key obtained from MASApplicationSurfaceMaterialGateway. The scope delegates to Nexamas UI-owned public surface gateways and the owning window render scope; it never draws or owns material recipes.

Beginner-facing theme facade exposed from one MASApplicationWindow. The facade is window-owned for convenience, but theme selection is application-global. ThemeManager/ThemeHost remain internal implementation details behind this stable facade.

Advanced compatibility access to the per-window ThemeHost snapshot owner. Beginner SDK code should prefer this facade's Current/TryUse/Use methods.

Nexamas UI currently uses one global application theme selection. This property makes the scope explicit so window-level access does not imply independent per-window themes.

True because this facade changes ThemeManager.Current for the whole application process.

Attempts to apply the theme globally for the application process, then refreshes this window immediately. Other windows refresh through the shared ThemeManager change notification observed by their ThemeHost.

Applies the theme globally for the application process.

Explicitly named alias for TryUse. Prefer this in multi-window code to make global scope obvious.

Explicitly named alias for Use. Prefer this in multi-window code to make global scope obvious.

Internal registration seam for Nexamas UI-owned themes only. Public SDK consumers select already registered themes by id; arbitrary IMASAppTheme registration is closed before v1.

Marks this window's ThemeHost snapshot stale and requests a repaint.

Window-facing size profile facade. The selected profile is process-wide by design, matching the global application theme model, but this facade gives each window an explicit refresh hook and a convenient API.

Shell facade for one MASApplicationWindow. It delegates technical application-chrome binding to MASSkiaRootHost while keeping TopBar/MainMenuBar placement owned by MASApplication layout policy.

Returns the standard application MainMenuBar attached through this shell, or Nothing when the window uses only a TopBar/custom chrome.

Returns the official MAS application TopBar height for the active size profile. Application code should use this value when reserving content below a standard TopBar instead of carrying a local title-bar height.

Returns the official MAS application MainMenuBar height for the active size profile. The height belongs to MASSize/MASApplication chrome policy, not to page-local constants.

Returns the content start for windows that only reserve the standard MAS TopBar. Use StandardContentTopLogical for normal application pages because it also accounts for an attached standard MainMenuBar.

Returns the official content start below the standard MAS application chrome. It includes TopBar, an attached standard MainMenuBar when present, and the MASApplication-owned breathing gap below application chrome.

Returns the standard TopBar rectangle for the attached root host and active size profile. Consumers that draw their own top-bar pass should use this instead of constructing a rectangle from local height constants.

Returns the standard MainMenuBar rectangle directly below the standard TopBar. This is the host-owned full-width application chrome slot, not a page-content row.

Creates and attaches a standard MAS TopBar using the canonical MASSize/MASLayout application-chrome height. This is the preferred SDK gateway for normal windows; advanced callers may still use AttachTopBar when they own a custom shell rectangle.

Internal implementation for the public Controls.AddMenuBar gateway. The shell places the menu directly below the standard TopBar and updates page/application-surface content reservations through MASApplicationLayoutPolicy.

Creates a WinForms MAS menu button and binds it to this application window shell. This is the beginner-facing menu trigger entry point; callers should not pass RootHost manually.

Binds an existing MASMenuButton to this application window shell. This keeps menu buttons under the Single Entry Law: window.Shell owns RootHost wiring.

Shows a dropdown menu through the application shell without exposing DropDownMenuPopupService. The anchor rectangle must be in MAS surface physical pixels. Internal pixel-space menu hook. Public consumers use ShowDropDownMenuForControl or CreateMenuButton/BindMenuButton instead.

Shows a MASMenuBar-owned dropdown through the dedicated shell-navigation popup route. This protects the general DropDownMenu/ContextMenu renderer from MenuBar palette changes.

Internal logical-space menu hook for MAS-owned shell surfaces. The shell performs the official logical-to-pixel conversion before delegating to the pixel-space hook.

Shows a dropdown menu anchored to an existing MAS control's layout-owned float anchor. This is the safest public menu path for direct controls added through MASApplicationWindow.Controls.

Internal shell service creation hook. SDK code must use CreateMenuButton, BindMenuButton, or ShowDropDownMenuForControl.

Public semantic side-region width vocabulary for LayoutApplicationSurface. Consumers choose intent; Nexamas UI resolves the final logical width from the active runtime size profile and viewport.

Public semantic command/footer height vocabulary for LayoutApplicationSurface. The enum keeps normal screens away from fixed pixel heights while still allowing compact or spacious command areas.

Public command-bar placement policy for application surfaces. Auto keeps command bars in the main work area when a navigation side region exists, so navigation surfaces can remain full height while the command surface becomes the true host for the action row.

Public footer placement policy for application surfaces. FullApplicationSurfaceBottom preserves the historical global footer. MainAreaBottom keeps navigation/sidebar regions full height while placing the footer under the main work area and inspector.

Public application-surface rhythm presets. A rhythm is not an application-specific skin and not a second layout engine: it selects official MASLayout spacing tokens for the distances between page regions so applications can choose compact, normal, or airy interfaces without writing local Left/Top/Width/Height or raw gap values.

Public beginner-facing application-surface layout builder. It is not a second layout engine: each semantic region is converted into an official MASApplicationLayoutPageBuilder and arranged by MASLayout. Use it for real application screens with command bars, navigation/side regions, true workspace/content areas, inspectors, and footers instead of assigning Region/Bounds/Left/Top values.

Uses the official MASLayout semantic spacing vocabulary for every distance between application-surface regions. More specific gaps can be overridden afterwards through CommandBodyGap, BodyFooterGap, ColumnGap, or SidebarFooterGap.

Applies a complete Nexamas UI application-surface rhythm preset. This is the preferred way to make a whole application surface compact, comfortable, or spacious without scattering manual gaps.

Sets the semantic vertical distance between the command bar and the body area.

Sets the semantic vertical distance between the body area and the footer.

Sets the semantic horizontal distance between sidebar, content, and inspector columns.

Sets the semantic vertical distance between the sidebar main region and its sidebar footer.

Uses semantic outer application-surface padding from MASLayout instead of raw logical numbers.

Shows or hides the official command-region background. Consumers only choose whether a background exists; Nexamas UI owns the internal visual source and currently paints the background with the borderless/default card surface used by application-surface regions.

Sets the minimum logical/DIP true workspace/content area width preserved before optional side panels are compressed. This is a layout policy, not direct control sizing.

Shows or hides official Nexamas UI-owned card backgrounds for application surface regions such as Sidebar, Content, Inspector, and Footer. The consuming application only requests application-surface region surfaces; Nexamas UI owns the visual style, render pass, DPI conversion, and cleanup lifecycle.

Reserves the standard MAS application chrome area before application-surface regions are computed. Consumers pass the official Shell facade instead of carrying local TopBar/MainMenuBar heights, Y offsets, or title/menu-bar constants.

Alias for ReserveStandardTopBar(...), useful when an application surface is read as the content surface below the MAS application chrome. When the shell owns a standard MainMenuBar, the reserved inset includes it automatically.

Selects where the command bar lives in an application surface. Auto places it over the main work area when a sidebar exists, otherwise it remains a full-width application-surface row.

Places the command bar above the whole application surface, including the sidebar.

Places the command bar at the top of the main work area beside the sidebar.

Selects where the footer lives in an application surface. The default keeps existing global-footers unchanged; MainAreaBottom is for applications whose left navigation must remain a full-height navigation rail while footer tools belong to the main work area.

Places the footer at the bottom of the whole application surface, including side regions.

Places the footer under the main work area so navigation/sidebar regions keep their full height.

Adds the official navigation/left-side region. This is semantic page composition, not manual coordinate layout; the final width is resolved from MASSize/MASLayout tokens.

Adds the true application workspace/main-content region. This is the region where document, canvas, icon-library, editor, or data work actually happens; it is not the full form.

Retained Application layout session for application surfaces. It computes application-surface regions from semantic intent, then delegates each region to the existing MASLayout engine; no controls are placed directly and no second engine owns measurement or arrangement.

Returns whether disposing an application-surface session removes renderer-owned background facts and therefore must trigger a repaint even if the next layout plan keeps identical control geometry. This is an internal visual-state cleanup contract, not SDK API.

Public beginner-facing page layout builder for direct MAS controls hosted by MASApplicationWindow.Controls. It exposes intent-only page/section/grid/flow language and hides MASLayoutNode, measure passes, arrange passes, slots, DPI conversion, and batch Apply details from consumers.

Applies an official MASApplication page preset below the standard MAS TopBar. This is the preferred path for application pages that should not carry local top-bar heights, page padding numbers, or content-width formulas.

Uses the official MASLayout semantic spacing vocabulary. This is the preferred SDK path for normal consumers; it remains density-aware when the layout is built.

Uses semantic padding from the MASLayout spacing vocabulary instead of raw logical numbers.

Internal Nexamas UI-owned page padding hook. It lets owned Application pages consume centralized MASLayout policy tokens without exposing layout insets as beginner API.

ApplicationSystem-owned hook used by MASApplicationWindow.Pages to make the hosted workspace vertically scrollable through the official MAS ScrollSystem. It is Friend so external demo code cannot create a parallel scroll route or attach scrollbars locally.

Nexamas UI-owned full-width entry that lets the hosted control keep owning its runtime MASSize intent. Use this for retained pages whose collection surfaces need to shrink/grow from their current read-model facts without rebuilding a page-local parallel sizing path.

Creates an official semantic action group. Use it for OK/Cancel/Apply rows, command-bar button groups, and any action row that needs equal item sizing or start/center/end placement without manual button widths or coordinates.

Builds an official semantic action group inline and returns the page builder for fluent page recipes.

Creates an official semantic filter bar for search fields, combo boxes, toggles, checkboxes, and compact filter controls without manual positions or field widths.

Builds an official semantic filter bar inline and returns the page builder for fluent recipes.

Creates an official semantic form row for label/input pairs and compact settings rows.

Builds an official semantic form row inline and returns the page builder for fluent recipes.

Creates an official semantic gallery for icon, tile, preview, and card collections. Gallery uses MASLayout TileGrid internally, so consumers avoid x/y math, manual tile sizes, and ad-hoc wrap calculations.

Builds an official semantic gallery inline and returns the page builder for fluent recipes.

Creates an official narrative/surface split pane. Use it when a page needs explanatory text in a left pane and a real MAS control surface in the right pane, without local widths, manual coordinates, or demo-owned layout helpers.

Builds an official narrative/surface split pane inline and returns the page builder for fluent page recipes.

Nexamas UI-owned composition hook used by MASApplicationWindow.Pages to include a cached page recipe inside the current workspace without top-level-window navigation or duplicating controls on every resize. It remains Friend so public consumers keep using the normal page builder verbs.

Public grid builder used only through MASApplicationLayoutPageBuilder.Grid(...). It describes intent and never exposes slots, measure passes, or arrange details.

Makes every item in this grid use the largest measured item width, without hard-coded pixel widths.

Makes every item in this grid use the largest measured width and height from the group.

Restores per-control intrinsic item sizing for this grid.

Public flow builder used only through MASApplicationLayoutPageBuilder.Flow().

Makes every item in this flow use the largest measured item width, preserving wrapping behavior.

Makes every item in this flow use the largest measured width and height from the group.

Restores per-control intrinsic item sizing for this flow.

Public stack builder for advanced page regions that still consume the official MASLayout engine.

Makes every item in this stack use the largest measured item width, without hard-coded widths.

Makes every item in this stack use the largest measured width and height from the group.

Restores per-control intrinsic item sizing for this stack.

Public split-pane builder used only through MASApplicationLayoutPageBuilder.SplitPane(). It composes one left narrative stack and one right surface stack through the native MASLayout grid/stack primitives, so consumers get a stable page pattern without manual widths, coordinates, or a separate showcase layout helper.

Adds one control to the narrative pane. The Add* naming avoids ambiguity with product-domain variables named Narrative/Surface and keeps the SplitPane API explicit as a layout builder rather than a Controls collection indexer.

Adds one control to the surface pane. Surfaces remain MASLayout entries; this method does not create a parallel sizing or rendering path.

Adds an official surface grid inside the right pane. This is still built from MASApplicationLayoutGridBuilder and MASLayout; it only prevents product pages from inventing local widths when a narrative pane must sit beside two related collection/data surfaces.

Retained Application layout session for a whole-window page recipe. It rebuilds the intent tree on resize/profile changes, but repaints only when the produced slots differ.

Advanced explicit-region layout recipe for direct MAS controls hosted by MASApplicationWindow.Controls. Prefer LayoutApplicationSurface, LayoutPage, ActionGroup, FilterBar, FormRow, and Gallery vocabulary for normal screens. Use explicit regions only when a product owns a precomputed logical region contract that still must flow through MASLayout.

Retained Application layout session for explicit logical regions. Region math remains an advanced placement primitive, while every region still resolves through MASLayout.

ApplicationSystem-owned workspace scroll coordinator used by MASApplicationWindow.Pages. It consumes the official MAS ScrollSystem adapter and Size/Layout facts; it does not create a Showcase-owned scrollbar, a WinForms panel, hidden pages, or a second layout engine.

Read-only structural proof that Application owns direct control admission, retained layout-session replacement, and framework-internal geometry mutation through one controls facade path.

This audit deliberately uses reflection over already-compiled Nexamas UI types. It does not scan source files, run captures, create controls, open windows, allocate bitmaps, mutate layout state, or introduce a second ownership registry. Its only job is to keep Phase 0/1 closure facts executable inside the existing Certification/Quality graph.

Friend-owned runtime route behind the public MASApplication.Output product facade.

This gateway keeps Chart/Report builders and Render Verification capture internals governed while allowing the public facade to export deliberate SDK output artifacts. Product-evidence-bundle generation is isolated behind Friend release-evidence routes. Unsupported future routes such as PDF and OS printing are declared but not falsely claimed.

Immutable, Application-owned output readiness facts used by certification gates and product dashboards.

Public, Application-owned Output facade for Nexamas UI SDK consumers. It exposes deliberate SDK output operations while release-evidence bundle generation remains governed outside the beginner facade.

Returns public Output product readiness facts and declared capabilities.

Returns all current Output capabilities, including supported and deliberately not-available routes.

Returns the formal Output capability catalog used by SDK consumers, dashboards, bundles, and gates.

Returns True only when the requested artifact/format is currently supported by the public Output facade.

Returns the stable directory-target file name for a supported artifact/format, or an empty string when unavailable.

Exports one supported SDK Output artifact to memory, a direct file target, or a directory target with a stable product file name. Release-evidence bundles are intentionally not exported through this beginner facade.

Convenience route for exporting the formal Output capability catalog.

Convenience route for exporting Output readiness facts.

Convenience route for exporting Chart/Visualization foundation facts.

Convenience route for exporting Report/Print preview facts.

Convenience route for exporting an official Render Verification visual-capture scenario as PNG.

Internal release-evidence route retained for Nexamas UI gates. Product evidence bundle generation is deliberately not part of the beginner MASApplication.Output SDK surface.

Internal release-evidence route retained for Nexamas UI gates. Product evidence bundle generation is deliberately not part of the beginner MASApplication.Output SDK surface.

Public SDK context passed to Application-owned layered scene rendering. This intentionally avoids exposing the layered runtime host.

Advanced bridge for MAS renderers that still consume ThemeContext. Do not use this in normal application code.

Internal Application-layer facade for drawing MASPanelShell chrome inside Nexamas UI-owned layered scenes. It keeps raw PanelShell render contracts inside the assembly while exposing only stable high-level gateways such as SelectionPanel and StartupShell services to external projects.

Public Application-level layout result for drawing a MAS PanelShell inside a layered scene. It intentionally exposes only stable geometry needed by application hosts: base, header, content, and close-button rectangles in physical pixels.

Public SDK facade for lightweight layered WinForms scenes. This is the stable Application-level replacement for direct MASLayeredSceneHost usage.

Official MAS host for lightweight layered WinForms scenes such as startup/preflight screens. It owns ThemeHost, ControlsLayer, input routing, and UpdateLayeredWindow presentation internally.

Win32 constants that are safe for MAS layered-window hosts to use from Form.CreateParams.

Internal Win32 bridge used by MAS layered-window presentation. Kept inside MAS so external applications do not own layered-window mechanics.

Internal presenter that renders Skia content into a Win32 layered Form. Application code uses MASApplication.CreateLayeredSceneHost / MASApplicationLayeredSceneHost instead of owning this machinery.

Public Application-level options for the startup layered shell. This object configures the real MASPanelShell chrome used by startup/lightweight layered dialogs without exposing internal renderer/runtime details to applications.

Complete reusable surface visual style used by the startup shell. The default matches the platform dialog frame used by PanelShell-hosted surfaces.

Optional material override. Leave Auto to use the material declared by SurfaceVisualStyleKey.

Public Application-level startup shell controller. It owns the official startup shell chrome path: MASApplicationLayeredSceneContext -> MASApplicationPanelShellChrome -> MASPanelShell. It also owns header drag behavior using the public PanelShell chrome result, so consumer forms do not duplicate PanelShell hit-test logic.

Measures the startup shell content rectangle without drawing and without relying on the previous frame result. Startup hosts use this before applying composition layout so content controls are arranged inside the real PanelShell content slot rather than duplicating chrome/header padding.

Application service for showing MASFileExplorerView through MASFloatRuntime. This class is not an Overlay service. It does not own global/current Float lifecycle. It does not keep a current handle. It does not close "whatever is open". Responsibilities: - Build FileExplorer Float requests. - Show FileExplorer Float requests. - Provide convenient Computer/custom-explorer entry points. - Bridge FileExplorer internal ViewModeRequested into a child Float menu. Lifecycle ownership remains inside MASFloatRuntime.

Internal path for creating a default computer float request. SDK code should call ShowComputer instead.

Internal path for creating a raw file-explorer float request. SDK code should call Show/ShowComputer instead.

Internal path for wrapping an existing explorer view in a float request.

Returns whether the supplied Float handle still represents an open file-explorer surface. This is a handle-scoped query; the service never assumes ownership of unrelated floats.

Closes the supplied file-explorer Float handle through the Float runtime. The close is handle-scoped and never closes an arbitrary current/global surface.

Closes file-explorer floats owned by this service owner key only when this service has tracked the owner key as active. This preserves owner-safe close semantics for the public facade.

Wires an explorer view to the Float session that hosts it. The wiring is intentionally kept inside the service because the service creates the content/session boundary and owns the FileExplorer-specific child Float menus.

Shows a parent-scoped warning when an inline rename operation fails inside the file explorer.

Application service for creating configured MASFilePickerControl instances.

Beginner path: - Use OpenFile, SaveFile, PickFolder, PickTargets, or the Show* helpers exposed through window.Services.FilePicker. Advanced path: - Raw MASFloatRequest creation/showing is an internal implementation detail. - Normal application code must not build raw file picker float requests directly. Ownership: - Created MASFilePickerControl instances are owned by the caller when using Create/OpenFile/SaveFile/Pick*. - Float-backed Show* helpers keep MASFloatRuntime owned by the RootHost.

Internal compatibility path for showing a prebuilt float request. SDK code should prefer ShowOpenFile/ShowSaveFile or Create/OpenFile/SaveFile/Pick*. The request is normalized and owner-tracked so this service can close only floats that it currently owns.

Internal result-bearing path for showing a prebuilt file-picker float request. This preserves Opened/Queued/Reused/Rejected outcomes for the public *Ex facade without exposing FloatRuntime types.

Public vocabulary for application-window presentation scale. It describes the user's preferred window experience, not child-control layout or pixel bounds.

Public startup placement intent for a MAS application window. The final safe bounds are still validated by Nexamas UI against the active screen work area.

Immutable presentation profile for a host application window. It does not arrange child controls; it only describes the outer window scale that Nexamas UI should plan safely.

Options for applying a MAS window presentation profile. Consumers express preference and persistence intent; Nexamas UI still owns final safe bounds and refresh.

Creates options for a user-customizable window. The supplied key identifies this logical window, not a pixel layout, and is stored under Nexamas UI runtime settings for the current application.

Creates options for a deterministic startup placement without durable user state.

Durable host-window presentation snapshot. This is a storage contract only; it is validated before every restore and never used as raw unchecked bounds.

Internal durable store for MAS host-window presentation preferences. It shares MASRuntimeSettingsPathResolver with size-profile persistence and never arranges controls.

Internal planner for host-window presentation bounds. It is not a layout engine: it only plans Form bounds/state from profile, screen work area, and validated user state.

Official presentation facade for one lightweight layered MAS scene. It shares the MAS window presentation profiles, planner, and runtime store used by MASApplicationWindow, but does not arrange child controls; composition layout remains owned by MASComposition/MASLayout.

Applies a small utility presentation for lightweight layered scenes such as startup/preflight windows.

Official presentation facade for one MAS application window. It owns Form size, placement, window state, and durable user preference restore/save. It deliberately does not arrange child controls; child layout remains owned by MASSize/MASLayout/MASScreen.

Applies a small utility presentation for lightweight support windows without durable user restore.

Applies a standard balanced application-window presentation without durable user restore.

Applies a compact application-window presentation without durable user restore.

Applies a spacious application-window presentation without durable user restore.

Applies a productive application-window presentation without durable user restore.

Applies a larger immersive application-window presentation without durable user restore.

Applies a profile and enables safe durable user restore/save for this logical window key.

Saves the current presentation state for the active persistence key, if one is configured.

Saves the current presentation state for an explicit logical window key.

Draws the official Undo icon with compact-button visual weight.

Creates the official MAS undo return curve centerline. The curve is factory-owned so Toast and every other consumer receive the same optical glyph source; button surfaces must never compensate it with local padding.

Creates the official MAS undo arrow head used with . The head is filled while the return curve is stroked, producing the same readable undo language as a filled symbol without overpowering compact close glyphs.

Breadcrumb-owned geometry and opacity constants. Theme, material, typography, focus, localization direction, radius, and shadow ownership remain centralized in Nexamas UI architecture/theme systems.

MASCommandPalette-owned density constants. Command metadata, execution, and can-execute state remain owned by CommandActionSystem through MASCommandRegistry.

CalendarView-owned visual and sizing constants. The control owns only a premium month-view surface; agenda storage, recurrence, scheduling engines, reminders, and external calendar providers remain outside this element.

DatePicker-owned visual and layout constants. These values describe only DatePicker chrome and calendar popup density; shared material, radius, shadow, theme, and motion decisions remain owned by MAS architecture systems.

Timeline-owned visual constants. Activity storage, audit trails, workflow engines, schedulers, live feeds, persistence, and notification delivery stay outside the visual timeline control.

Slider-owned visual constants. Numeric ranges, binding, filtering, persistence, validation rules, and live data semantics remain application-owned or owned by their existing Nexamas UI systems.

Family-level Media container geometry tokens shared by ImageViewer, VideoPlayer, document previewers, and future media surfaces. PanelShell owns the outer surface, shadow, frame, and radius; these tokens size the Media host and content region.

Responsive Media layout breakpoints. Above these limits every region is rendered at the full premium density; below them, the shared Media layout resolver progressively compresses chrome before it hides non-essential regions.

Keeps the shared PanelShell surface inside the ImageViewer host bounds so its frame, antialiased rounded corners, and shadow are not forced against the host edge.

Content padding requested from PanelShell before MediaToolbar/Viewport/Footer layout.

Inner preview frame inset. The frame is deliberately owned by the Media container, because it groups the viewport stage and footer into one visual preview block without changing older non-media material contracts.

Vertical gap between pinned Media toolbar chrome and the combined preview frame. This keeps title/actions outside the image/footer frame while the preview block remains visually grouped.

Extra bottom breathing room between the outer PanelShell border and the combined preview frame/footer block.

Keeps stage and footer drawing inside the combined preview frame so its own subtle border remains visible around both regions.

Explicit outline used to keep the image/footer preview frame visually readable as an inner block that starts below the toolbar chrome.

Internal divider between the image stage and the footer rail. The divider is owned by the combined PreviewFrame so the image and footer read as one card, not as two independent rectangles.

Reusable Media command button geometry tokens. These values belong to the MediaButton family, not to ImageViewer or to the generic toolbar chrome.

Reusable Media toolbar geometry tokens. The toolbar is a family-level chrome region, not an ImageViewer-owned layout island.

Moves pinned media action tiles slightly lower inside the taller toolbar so they sit like preview actions rather than top-edge tool buttons. Floating toolbars keep their compact centered geometry.

Reusable Media viewport geometry tokens. The viewport owns content-window insets, safe clipping, and the neutral stage frame used by image and video surfaces.

Reusable Media footer geometry tokens shared by image, video, and future previewers.

ImageViewer-owned behavior and content tokens only. Shared Media geometry lives in the dedicated Media family token classes.

FileDropZone-owned visual and sizing constants. OS drag/drop plumbing, FilePicker dialogs, upload transport, storage, thumbnails, scanning, and background transfer remain outside the visual intake control.

TransferList-owned visual and sizing constants. Data binding, permission models, remote membership providers, persistence, virtualization, and drag/drop ownership remain outside the visual transfer control.

DataForm-owned geometry and opacity constants. Actual field editing, binding, validation, persistence, and data-source ownership stay outside this visual surface.

Drawer-owned density constants. Material, radius, shadow, typography, theme, focus, and FloatRuntime lifecycle stay resolved through existing MAS systems.

Friend-owned sizing and drawing tokens for MASStepper and MASWizard. Theme, material, shadow, radius, typography, focus, and layout contracts are resolved through the existing MAS architecture and surface systems.

Friend-owned sizing and drawing tokens for MASNotificationPanel. Delivery, queueing, persistence, actions, theme, material, radius, shadow, typography, and layout ownership remain in existing Nexamas UI systems.

TimePicker-owned visual and layout constants. These values describe only TimePicker chrome and compact clock popup density; shared material, radius, shadow, theme, and motion decisions remain owned by MAS architecture systems.

Internal visual and interaction constants for MASDataGrid. These tokens keep DataGrid painting and hit-testing facts centralized inside the component token layer instead of scattering renderer-specific magic numbers through the control.

Callout-owned density constants. Material, radius, shadow, typography, theme color, motion, and float lifecycle are resolved through existing Nexamas UI systems.

Pagination-owned geometry and opacity constants. Data paging, query state, collection ownership, virtualization, and data-view projection remain owned by their existing Nexamas UI systems and consumers.

Central logical-size tokens for MASOperationProgressBox. The box is a single operation-progress composition: title, MASProgressBar, and status label inside a themed PlatformDefault surface container. These tokens keep its spacing away from caller code.

Outer surface visual overflow reserved by the MASSize intrinsic contract.

Central logical-size tokens for MASProgressBar. These values define the SDK-recommended sizes and label slots without leaking layout magic numbers into controls.

Logical inner padding used when MASProgressBar draws its own themed container field. The renderer and layout both consume this token so the track, label placement, and container stay aligned.

Central logical-size tokens for MASSelectorItemControl and its internal SelectorItem list surface. The control may expose advanced tuning, but its default measurement contract comes from this file only.

Avatar-owned geometry and opacity constants. Identity/profile data, contact lookup, presence transport, people directory ownership, and notification delivery remain outside the visual avatar surface.

TagInput-owned geometry and opacity constants. Tag persistence, suggestions, validation policy, search/filter execution, and contact/email resolution remain owned by consumers or existing Nexamas UI systems.

Canonical title/header sizing and title-separator rendering tokens used by MASTitle. These values keep title/header controls aligned with MASSize while preserving the existing MAS visual signature.

ValidationMessage-owned density constants. Semantic colors, typography, radius, layout, and validation rule execution remain owned by their existing Nexamas UI systems.

Badge-owned density constants. Tone colors, typography, radius, and chip material remain resolved through Nexamas UI theme, typography, radius, and rendering systems.

StatusBanner-owned density constants. Semantic tones, card surface material, typography, radius, and layout measurement remain resolved through existing Nexamas UI theme, rendering, and size systems.

EmptyState-owned density constants. Page composition, data adapters, action routing, card material, typography, radius, and theme colors remain resolved through existing Nexamas UI systems.

LoadingSkeleton-owned geometry and opacity constants. Material, frame, radius, shadow, typography, theme, layout, and future motion ownership remain resolved through the existing Nexamas UI systems rather than a control-local service.

Canonical MAS toolbar sizing tokens. Generic reusable toolbars must consume these tokens instead of carrying local width, gap, inset, or item-height numbers. Rendering-specific values stay in the owning renderer; these values describe the intrinsic size contract exposed to MASSize/MASLayout.

Central typography provider for the theme. - Caches SKPaint instances per (MASTextStyle, Color). - Lazily initializes and caches Segoe UI typefaces. - Provides stable baseline computation using SKFont metrics.

Returns a caller-owned SKPaint clone for the given text style and color. Public callers may mutate or dispose the returned paint without affecting the internal typography cache or any subsequent MAS render pass.

Returns the internal cached shared paint. The caller must never dispose or mutate it. This is Friend-only so product rendering paths can stay allocation-bounded while the public GetPaint API remains mutation/disposal isolated.

Returns baseline Y for vertically centered text in rect. Uses SKFont metrics (more stable across SkiaSharp versions).

Ensures regular / semibold / bold typefaces are initialized and cached. Must be called under _gate lock.

Returns a cached Segoe UI typeface for the given weight. Must be called under _gate lock.

SSOT-V2 Interaction intensity authority only. Owns: - Fill/ring visibility strength - Which interaction layers are enabled Does NOT own: - Colors - Accent policy - Tier mapping

FilterBuilder-owned visual and sizing constants. Query execution, SQL/LINQ/OData translation, data binding, provider sync, validation engines, and DataGrid ownership remain outside the visual filter composition surface.

MetricCard-owned visual and sizing constants. Metric storage, analytics, telemetry collection, live refresh, chart engines, and dashboard composition remain outside the visual metric card control.

Rating-owned visual and sizing constants. Review storage, analytics, feedback submission, moderation, persistence, and recommendation scoring remain outside the visual rating control.

KanbanBoard-owned visual and sizing constants. Task persistence, workflow engines, remote providers, drag/drop runtimes, background synchronization, and DataGrid/ListView wrappers remain outside the visual board surface.

AgendaView-owned visual and sizing constants. Recurrence engines, reminder transport, external calendar providers, booking storage, and scheduler engines remain outside the visual agenda surface.

TreeGrid-owned visual and sizing constants. Hierarchical row projection, column presentation, selection, and expand/collapse affordances belong to MASTreeGrid; storage, binding engines, external providers, and DataGrid / TreeView wrapper paths remain outside the control.

PivotTable-owned visual and sizing constants. Cross-tab row/column presentation, totals, selection, and same-surface navigation belong to MASPivotTable; query engines, OLAP engines, Excel engines, providers, storage, and DataGrid wrapper paths remain outside the control.

ContentCarousel-owned visual and sizing constants. Galleries, image loading, slide decks, onboarding engines, content providers, auto-rotation clocks, and local/parallel transition schedulers remain outside the visual carousel surface; official MASMotionSystem timelines remain the only allowed motion route.

NavigationRail-owned visual and sizing constants. Route catalogs, page-host ownership, drawer replacement, content hosting, native menus, and outer pointer-focus rings remain outside the rail surface.

DashboardGrid-owned sizing and visual constants. It is a dashboard widget composition surface only; analytics refresh, chart engines, layout services, storage, and external providers remain outside the control.

MasterDetailView-owned sizing and visual constants. It is a master/detail visual surface only; data binding, object inspection, routing, storage, providers, and services remain outside the control.

ChartLegend-owned sizing and visual constants. The legend owns swatch/key presentation only; chart rendering, chart data preparation, queries, analytics engines, and provider synchronization remain outside the visual control.

FormValidationSummary-owned sizing and visual constants. Validation rule execution, binding, submit orchestration, storage, and native validation-host native routes remain outside the visual control.

AppliedFiltersBar-owned sizing and visual constants. Filter parsing, query execution, provider synchronization, saved-view persistence, and DataGrid ownership remain outside the visual component.

Classifies the operational severity of an exception that a framework boundary decided to absorb.

Documents why an exception is allowed to be absorbed at a runtime boundary.

This is intentionally orthogonal to severity. A rendering fallback can be recoverable, while a lifecycle transition can be critical. Keeping the category explicit makes audit reports readable and prevents future empty Catch blocks from becoming invisible again.

Centralized sink for framework exceptions that are intentionally absorbed at UI/runtime boundaries.

Swallowing is no longer silent by default. Every absorbed exception is traced once with context, severity, file, and line. Disk logging is an explicit full-runtime setting so lightweight objects such as ThemeHost do not create file-system side effects merely by being constructed.

Enables release diagnostics file writes. Full runtime bootstrap turns this on. Lightweight/theme-only construction leaves it off.

Development switch that converts swallowed framework exceptions into fail-fast throws. This can be enabled by tests or diagnostics sessions to catch invalid silent paths.

Development switch that throws only for lifecycle-breaking swallowed exceptions.

When enabled, repeated swallowed exceptions emit periodic trace lines instead of being completely hidden after the first occurrence.

Internal structured diagnostics channel for swallowed MAS runtime faults.

This channel is intentionally Friend-owned. It is the single in-process place where swallowed boundary exceptions become structured records, recent snapshots, and testable events. The channel does not call MASExceptionSilencer when its own diagnostic event subscribers fail, because doing so would recursively create swallowed diagnostics faults.

Friend-only retention telemetry for the runtime fault channel.

The channel keeps a bounded recent window for memory safety. This snapshot preserves the commercial SDK contract that a long fault storm cannot make older swallowed faults disappear without a visible retained-window overflow counter.

Friend-only snapshot of the release diagnostics disk-log retention policy.

Event payload for the internal runtime fault channel.

Immutable diagnostic record emitted whenever Nexamas UI intentionally absorbs an exception at an owned runtime/UI boundary.

The record is Friend-owned so diagnostics remain an internal SDK contract until a deliberately designed public diagnostics gateway is approved. It gives tests, gates, and internal tooling structured facts instead of relying on Debug/Trace text.

Friend-only snapshot of the current runtime-fault strictness switches.

This is diagnostic state only. It does not open a public telemetry or exception policy API. Developer tooling and gates can read the current switches without mutating the runtime.

Friend-only disposable strict-mode scope for diagnostics sessions and gates.

The scope restores the previous MASExceptionSilencer switches on Dispose so tests and internal developer panels can temporarily enable fail-fast behavior without leaking global diagnostic state into the host application.

Read-only developer-panel snapshot for the official runtime fault channel.

The snapshot summarizes already-owned MASRuntimeFaultChannel records. It does not walk controls, render UI, write logs, create timers, or expose public telemetry.

Friend-only runtime fault developer panel foundation.

The builder is intentionally read-only. It converts the official fault channel and strictness switches into a snapshot consumable by internal tools and gates. It does not create a public diagnostics gateway or add any host-side telemetry obligations.

Lightweight opt-in frame/input diagnostics for Nexamas UI host surfaces.

Enabled only when the environment variable NEXAMAS_UI_FRAME_DIAGNOSTICS is set to 1/true/yes. MASPerformanceSystem owns the aggregate counters; this module only prints opt-in trace output and routes timing facts into the official Friend-only performance snapshot boundary.

Architecture marker contract for the FileExplorer ViewMode child float menu. This is a marker only: - It is not the actual rendered menu content. - It does not own lifecycle. - It represents the architectural identity of MAS.FileExplorer.ViewModeMenu.

Options used by MASFileExplorerFloatRequestBuilder. This class is request-building data only. It does not own lifecycle.

Shows the PanelShell header close button. The FileExplorer toolbar does not own a close button.

When True, double click / activation accepts the explorer float with MASFileExplorerFloatResult. When False, activation remains a normal explorer event for the caller.

Gives the caller a final chance to customize the explorer before the request is shown. Example: add roots, set view mode, attach handlers, customize layout.

Builds MASFloatRequest instances for MASFileExplorerView. This builder is lifecycle-neutral: - It does not call MASFloatRuntime.Show. - It does not close global/current floats. - It does not depend on legacy Overlay. - It does not own runtime lifecycle.

Final accepted result payload for FileExplorer Float. Delivered only through MASFloatClosedEventArgs.Result.Value after the float is closed.

Builds FileExplorer context menus as standard MAS ContextMenu Floats. This builder owns menu construction only. File-system actions remain owned by MASFileExplorerView, while float lifetime and routing remain owned by MASFloatRuntime.

Builds the FileExplorer view-mode menu as a standard MAS DropDown/Context menu Float. This class intentionally does not render menu rows by hand. The visual and input contract is delegated to DropDownMenuFloatContent / DropDownMenuRenderer so the FileExplorer toolbar uses the same menu system as the rest of Nexamas.UI.

Builds FilePicker browser context menus as standard MAS ContextMenu Floats.

This builder owns menu construction and popup request creation only. It deliberately does not execute file-system commands; MASFilePickerControl remains the command owner because only the picker knows its current mode, selection policy, and refresh/navigation behavior.

Builds MASFloatRequest instances for MASFilePickerControl.

This builder is lifecycle-neutral. It does not call MASFloatRuntime.Show. It does not close floats. It does not keep current/global state. It does not depend on legacy Overlay. It does not create wrappers or launchers. Responsibilities: - Create MASFilePickerControl. - Host it inside MASFloatControlsContent. - Bridge FilePicker Accepted/Cancelled events to IMASFloatSession. - Build a MASFloatRequest using MASFloatKeys.FilePicker. Result delivery: - MASFilePickerResult is passed to IMASFloatSession.Accept(result). - External consumers must read the final result from MASFloatRequest.OnClosed. - OnClosed is delivered only after the Float reaches Closed by MASFloatRuntime.

Builds FloatRuntime requests for the reusable MASPanelShell surface. This builder is the official generic PanelShell-backed float gateway. It owns section layout for Toolbar, Content, and Footer so caller code does not manually position common shell actions or scrollbar gutters.

Requests repaint of the owning Float host without changing bounds, result, close state, or ownership. Continuous interaction systems such as the shared MAS Scroll adapter use this route when their internal timer advances visual state after the original pointer event.

Posts control-owned asynchronous work through the root-owned UI dispatcher for this Float session. Detached, stale, or hostless sessions return False and must not fall back to a captured context.

Contains internal lifecycle open/close mechanics separated from the public coordinator entry contract.

Compatibility show path. It preserves the historical MASFloatHandle return contract. Use ShowEx when the caller must distinguish Opened, Queued, Reused, and Rejected.

Precise show path that reports policy outcome without using Nothing as an ambiguous signal. Queued requests return Status=Queued and no handle because a handle is created only when promoted.

Explicit result object returned by the precise Float show path.

A queued Float intentionally has no handle yet because the handle is created only when the queued request is promoted to an active session. Callers can therefore distinguish Queued from Rejected/Opened without treating Nothing as an ambiguous lifecycle signal.

Describes the outcome of a MASFloatRuntime Show request without requiring callers to infer meaning from a Nothing handle.

Creates the dedicated descriptor for MASMenuBar-owned shell navigation dropdowns. It stays separate from the general DropDownMenu key so MenuBar popup styling and outside-click pass-through policy cannot leak into other menu surfaces.

Creates the dedicated descriptor for ComboBox-owned dropdown-list popups. A dropdown list receives its compact pixel bounds from MASComboBox itself, so its default presentation is explicit-bounds rather than the fullscreen overlay default used by general menu content.

Creates the dedicated descriptor for DatePicker-owned calendar popups. The popup receives compact explicit bounds from MASDatePicker and hosts only MAS-owned calendar controls through FloatRuntime.

Creates the dedicated descriptor for TimePicker-owned compact clock popups. The popup receives compact explicit bounds from MASTimePicker and hosts MAS-owned clock-stepper content without a WinForms DateTimePicker wrapper.

Final internal closure status for FloatRuntime commercial overlay governance.

Immutable internal final-closure manifest for FloatRuntime commercial overlay governance.

This contract does not open floats, create controls, route input, render, schedule transitions, mutate host state, allocate bitmap resources, or expose a public telemetry API. It records only registry, lifecycle-policy, presentation-profile, and ownership-boundary facts from an already bootstrapped FloatRuntime registry.

Public lifecycle snapshot exposed by MASFloatHandle.State. This is a stable SDK-facing view; runtime transition mechanics stay internal.

Captures the already-selected outside-pointer target so close remains handle-specific.

Finds the top open Float that owns outside-pointer behavior at the given point. This is required for transient child menus: when a popup is visually above a parent Float, pointer move/up/wheel outside the popup must not leak to the parent, and pointer down outside the popup must give CloseOnOutsidePointer a chance before the parent receives the click.

Finds the top pointer-eligible record at a point using layer first, then host/render order.

Finds the top pointer-eligible record for outside-pointer decisions without a hit point.

Finds the top modal-blocking pointer record even when the pointer is over the dim/empty area. This keeps modal floats owning hover, wheel and button-up outside their visual bounds.

Finds the keyboard target, preferring the focus owner before top-record fallback.

Finds the text-input target, preferring the focus owner before top-record fallback.

Compares routing priority: higher layer wins; same-layer ties follow host/render order.

Returns the hosted record index used as the same-layer routing tie-breaker.

Carries FloatRuntime pointer-move ownership separately from visual mutation.

A Float can legitimately own/swallow a pointer move without requiring a new Skia frame. This contract prevents hover-stable menus and list popups from invalidating the whole host for every WM_MOUSEMOVE while preserving modal/input ownership semantics.

Optional Float content contract for precise pointer-move invalidation.

Existing Float content can continue implementing IMASFloatRoutedInputContent only. Content that implements this interface promises to return True only when pointer movement changed a rendered visual state such as hover row, scrollbar hover/drag, submenu path, or close affordance state.

Advanced extension registry for MAS Float descriptors. It is Friend-only runtime infrastructure; normal SDK code should use typed window facades.

Advanced extension registry for custom Float descriptors. Normal application code should prefer MASApplicationWindow.Services and MASApplicationWindow.Shell.

Registers the built-in MAS Float descriptors into this runtime. RootHost calls this during composition; external callers should only use it for advanced host scenarios.

Shows a raw Float request through the advanced runtime facade. Prefer typed window facades such as Services.Dialogs, Services.Toasts, Services.Tooltips, and Shell menus.

Phase 1 Apply engine. This is the only Composition class allowed to mutate ControlsLayer and BoundsLogical.

Detaches every control currently owned by this applier from the supplied target. This is the only safe teardown path because global ownership must not be cleared until the ControlsLayer detach/dispose operation has actually succeeded.

Target-aware disposal for retained Composition owners. It preserves ownership records when detach fails, preventing a false release that would hide leaked/attached controls.

Root-shutdown-only quarantine release for composition ownership. Normal disposal must keep global owners when detach fails, because the control may still be attached to a live host. During root shutdown, however, the host and ControlsLayer are being destroyed; retaining _globalOwners would leak the applier/control pair and block later diagnostic probes. This method never hides the original detach failure: it appends an explicit diagnostic and then clears only ownership records that belong to this applier.

Official Apply target for Phase 1. It exposes ControlsLayer, viewport, ThemeContext, and invalidation without giving Layout ownership of RootHost.

Assembly-internal compatibility layout measurement contract for controls that still expose a logical preferred/minimum size to Composition. MASSize intrinsic facts are the primary measurement source; Composition may consult this participant only as a guarded fallback. This contract is intentionally Friend-only; external consumers must use MASSize/MASLayout public gateways, not this fallback surface. Implementations must not mutate BoundsLogical, ControlsLayer, host, theme, input, scroll, overlay state, or retained layout state.

Returns the preferred logical size for Composition Auto/Preferred fallback measurement. The implementation must be side-effect free and must remain consistent with the control's IMASIntrinsicSizeContract.

Returns the minimum logical size for Composition fallback min/clamp logic. The implementation must be side-effect free and must remain consistent with the control's IMASIntrinsicSizeContract.

Cross-axis alignment used by simple Phase 1 layouts.

Visibility participation rule for a layout item.

Dock slot used by MASDockLayoutNode.

Semantic root-screen region role used by MASScreen region recipes. It describes application layout intent only; exact sizing and placement remain owned by MASLayout.

Diagnostic severity emitted by the Composition/Layout system.

Logical-unit thickness used for padding and margins. It owns values only and performs no DPI conversion. Invalid values are preserved so layout diagnostics can report them, while layout math must use sanitized accessors from MASLayoutNodeBase.

Internal root-screen layout policy tokens. These values are owned by Nexamas UI so external projects do not hard-code region widths, gutters, or screen partition formulas.

Neutral structural height from the button and application-chrome contracts. It is intentionally not returned directly as the Default Command slot height; the final Default contract is rebased below so the previous Compact visual height becomes the new Default source value.

Command regions are application workspace chrome, not another TopBar. The default command slot therefore uses the platform Compact height scale as its source baseline, then all runtime profiles continue moving through MASSizeProfile. This keeps the rebalanced height centralized in Nexamas UI instead of forcing consumers to compensate with local bounds.

Command action buttons are wider than normal dialog buttons but must not expand until they consume the whole command region. The ratio is owned here so product screens request a semantic command action row instead of assigning local widths.

Command actions need a slightly taller presence than the base button contract in app workspaces. Height still flows through MASSizeProfile so Compact, Default, Comfortable, Large, and TouchFriendly remain coherent.

Minimum readable width for command actions before the row must move trailing actions into overflow. The ratio is intentionally tied to the same button token family as normal command action width so all size profiles remain coherent.

Compact overflow action width. The overflow button is a real command participant, but it uses the base button width rather than the wider command-action width.

Base distance between command actions. The value is intentionally owned by the command-action contract so consumers never simulate breathing room through local margins or manual button bounds.

Semantic application command-action row. It owns the production behavior expected from a command region: preferred sizing, proportional shrink, hard in-slot clipping safety, and a host-presented overflow entry when visible actions no longer fit at their minimum readable width.

Internal host-bound presentation gateway for semantic CommandActions overflow. Composition owns the overflow decision, while the active host owns how an overflow menu is presented. This keeps command rows from leaking outside their slot without making product screens wire DropDownMenuPopupService or RootHost directly.

Internal/advanced Composition layout-node contract. It is a retained recipe node over the canonical MASSize/MASLayout facts: Measure calculates desired logical size and Arrange produces placements. Implementations must not mutate controls, apply bounds, own SizeLayout tokens, or become a second native layout engine.

Central control measurer for Composition Auto/Preferred sizing. It first consumes MASSize intrinsic facts, then uses IMASLayoutParticipant only as a compatibility fallback, and finally falls back to the diagnostic intrinsic registry. It never mutates controls, ControlsLayer, host, theme, input, scroll, overlay state, or retained layout state.

Final Arrange output. It owns placement data only. It does not apply to ControlsLayer or mutate controls.

Context for Measure. It carries available logical size and diagnostics only. It must not mutate ControlsLayer, BoundsLogical, host, or theme state.

Context for Arrange. It carries final logical bounds and diagnostics only. It must not attach, detach, render, route input, or mutate scroll/runtime state. Host-level adapters may provide read-only runtime values, such as a scroll offset resolver, so layout nodes do not reach into global host/runtime state directly.

Lifetime policy for controls that appear in retained Composition placements. Borrowed controls are detached only; MAS-owned recipe controls are disposed when removed.

Internal layout item connecting a control or nested node to size and alignment policy. It describes intent only; it does not mutate ControlsLayer or BoundsLogical.

Base for Phase 1 layout nodes. Owns child layout descriptions and shared math only; it never applies placements.

A single final logical placement for a MASControlBase instance. Produced by Arrange and consumed by Apply only.

Compatibility-only raw-bounds placement constructor. Official retained Composition layout paths must preserve slot facts through the Friend slot-bearing constructor or through MASLayoutPlacement.WithClipLogical. Raw construction rebuilds a slot from outer bounds and therefore cannot be the canonical path for content/hit/focus/anchor facts. Raw MASLayoutPlacement construction is compatibility-only; the marker is documentation-only so test harness builds that treat warnings as errors remain clean.

Compatibility-only raw-bounds placement constructor with clip metadata. Official retained Composition layout paths must preserve MASLayoutSlot facts through the Friend constructor or WithClipLogical rather than rebuilding from raw outer bounds. Raw MASLayoutPlacement construction is compatibility-only; the marker is documentation-only so test harness builds that treat warnings as errors remain clean.

Creates the same placement with a different clipping rectangle while preserving the already-arranged MASLayoutSlot facts. Scroll and viewport decorators must use this instead of reconstructing a placement from outer bounds, otherwise content/hit/focus facts and navigation order can be recomputed or lost during clipping.

Arrange-produced scroll metadata for a Composition scroll region. It is placement data only: the layout node reports that a region needs MAS Scroll integration, while MASCompositionHostRuntime applies the request after Arrange and before ControlsLayer Apply.

Developer-facing diagnostic emitted by Build/Measure/Arrange/Apply. It owns diagnostic data only and never mutates layout or controls.

Collects diagnostics for a single layout operation. It is passed through contexts and does not own host/control state.

Severity for deterministic Composition runtime stress verification. Errors block the certification gate; warnings preserve commercial evidence without changing runtime paths.

Runtime stress surfaces covered by the Composition proof. These recipes are deliberately non-visual and host-independent so they can run inside the existing certification system.

Immutable finding emitted by the Composition runtime stress audit.

Immutable report for deterministic Composition runtime stress verification.

Host-independent runtime stress verification for Composition hardening. It does not create a parallel layout path: it drives the official MASCompositionScrollState, the official MAS Scroll adapter factory, and the retained-scroll scalability policy used by MASVerticalScrollLayoutNode.

Event payload emitted after a host-level Composition apply attempt. It carries success state and a snapshot of diagnostics for UI/status display.

Per-root-host Composition runtime. It is the official host-level bridge from layout descriptions to Measure/Arrange/Apply. It owns only the MASLayoutApplier for one MASSkiaRootHost and does not render, route input, own Theme state, open overlays, or replace ControlsLayer.

Low-level layout facade scoped to this host.

Page recipe facade scoped to this host.

Screen recipe facade scoped to this host.

Stores and immediately applies a stable layout node. Use SetLayoutFactory when the node must be rebuilt on resize.

Stores a layout factory and optionally applies it immediately. The root host calls RebuildCurrent from its normal rebuild path, so resize/theme invalidation can rebuild the layout safely.

Rebuilds the currently stored layout factory and applies the result. No-op when no factory is registered.

Applies one layout node once without storing it as the current layout factory.

Removes controls owned by this composition runtime from the host ControlsLayer.

Re-arranges the last successfully built layout without invoking the page factory or re-running Measure. This path is used only for Composition scroll interactions where geometry is already measured and only the runtime scroll offset changed. Resize, theme changes, and explicit page updates still use RebuildCurrent.

Blocks Composition apply before ControlsLayer mutation whenever Measure/Arrange produced an error or no arrange result. This gives Composition the same fail-before-mutate ownership guarantee as Application retained layout.

Routes root-host wheel input to active Composition scroll regions. Returns True only when a Composition scroll offset changed and the current layout was re-arranged.

Host-scoped Layout facade. It creates low-level layout nodes and can apply them through the owning MASCompositionHostRuntime.

Host-scoped Page facade. It creates MASPage recipes and can apply them through the owning MASCompositionHostRuntime.

Host-scoped nested page recipe for title/description/content/action regions that are already layout nodes. This is the Application-window gateway equivalent of MASPage.VerticalNodes and keeps external consumers on window.Page instead of calling the static page recipe directly.

Starts one host-owned layout-factory build pass. Text recipe labels created through this facade are then keyed by stable call order or explicit row/section keys, so rebuild-heavy pages do not allocate new MASLabel instances on every resize/scroll refresh.

Completes the current host-owned layout-factory build pass and releases stale generated labels that no longer belong to the page recipe. Existing live labels remain normal controls and stay owned by the composition applier.

Releases host-generated text recipe labels when the owning composition runtime is cleared.

Host-scoped Screen facade. It creates MASScreen recipes and can apply them through the owning MASCompositionHostRuntime.

Host-scoped dock recipe for screen regions that are already layout nodes. This is the Application-window gateway equivalent of MASScreen.DockNodes and keeps external consumers on window.Screen instead of calling the static screen recipe directly.

Phase 1 dock layout node. Consumes Top/Bottom/Left/Right/Center item slots and produces placements only.

Native Nexamas UI root-screen region layout node. It consumes semantic MASScreenRegion declarations and arranges them through MASLayout without exposing manual coordinates, project-specific window names, or consumer-owned measurement formulas.

The node is intentionally conservative: edge regions keep intrinsic size, the Content region fills the protected remaining area, and side regions are internally budgeted so they cannot accidentally consume the whole screen when their content reports a large preferred width. This is not a parallel layout system; it is a specialized MASLayout node for root application regions.

Keeps semantic command content optically centered inside the slot owned by the root region layout. The reserved region height remains unchanged, so Content still starts after the official Command slot; only the child row/control is placed at the slot center instead of inheriting a top-edge bias.

Phase 1 horizontal layout node. Measure calculates row desired size. Arrange produces final placements only.

Phase 1 vertical layout node. Measure calculates stacked desired size. Arrange produces final placements only.

Phase 2.4B vertical scroll layout adapter for Page/Form recipes. It does not render, host controls, virtualize controls, or own Core input routing. It only arranges its content with the latest known vertical logical offset and reports scroll metadata in the Arrange result. The host runtime applies that metadata to the official MAS Scroll stack after Arrange, preserving the Build/Measure/Arrange/Apply contract. Keep off-screen controls attached and clipped so ownership, focus, and scroll-state remain stable; this node only emits a scalability warning when a large non-virtualized scroll surface is detected.

Lightweight layout-only spacer used by value templates when empty/filler space is needed. It produces no placements, owns no controls, renders nothing, and does not mutate host/core state.

Friend-owned Phase 1 facade for creating layout descriptions after final public API lockdown. This class is the low-level Nexamas UI-owned entry point: it creates items and nodes only. It does not attach controls, mutate BoundsLogical, open overlays, own scroll runtime, or own Theme/Host state.

Creates a layout item for a MAS MASControlBase instance.

Creates a layout item for a MAS-owned recipe control that Composition may dispose when removed. Caller-supplied controls must use Item instead and remain borrowed/detach-only.

Creates a dock layout item for a MAS MASControlBase instance.

Creates a layout item for a nested layout node.

Creates a dock layout item for a nested layout node.

Convenience policy shortcut for MASSizePolicy.Auto.

Convenience policy shortcut for MASSizePolicy.Fill.

Convenience policy shortcut for MASSizePolicy.Fixed.

Convenience policy shortcut for MASSizePolicy.Range.

Creates a layout-only spacer node. It produces no placements and owns no controls.

Creates a vertical layout node from explicit layout items.

Creates a horizontal layout node from explicit layout items.

Creates a dock layout node from explicit dock items.

Public details-row description for Phase 2.5 value templates. A details row describes a read-oriented label/value pair with optional supporting description. It owns no rendering, validation, data binding, input routing, overlay lifecycle, scroll runtime, Theme state, or Host lifecycle.

Public details-section description for Phase 2.5 value templates. A details section groups a title, optional description, and read-oriented details rows. It owns no rendering, validation, data binding, input routing, overlay lifecycle, scroll runtime, Theme state, or Host lifecycle.

Public form-field description for Page.Form field rows. It describes a label/control pair only. It does not render, validate, bind data, own TextInput, or mutate ControlsLayer/BoundsLogical.

Public form-section description for Page.Form recipes. A section groups a title, optional description, and official form fields into one layout item. It owns no rendering, validation, data binding, input routing, overlay lifecycle, scroll runtime, Theme state, or Host lifecycle.

Public settings-row description for Phase 2.5 value templates. A settings row describes a label/description area and a value/editor control. It owns no rendering, validation, binding, input routing, overlay lifecycle, scroll runtime, Theme state, or Host lifecycle.

Public settings-section description for Phase 2.5 value templates. It groups rows under an optional title and description. It creates layout descriptions only and does not render, validate, bind data, own input routing, own scroll runtime, own Theme state, or own Host lifecycle.

Internal control-factory layer used by MASPage template recipes.

MASPage is a public composition facade. When a convenience recipe accepts text instead of caller-provided controls, this factory creates the small MASLabel controls required by that recipe. Keeping label construction here makes the responsibility explicit: MASPage describes page templates; this factory owns the control instances generated for text-based recipes.

Friend-owned page-template facade after final public API lockdown. A Page is a reusable content region. It primarily creates layout descriptions. Convenience text recipes may create small MASLabel controls through MASPageLabelRecipeFactory, but MASPage still does not own host lifecycle, ControlsLayer, rendering, overlay, scroll runtime, input routing, DPI pipeline, or Theme state.

Creates a simple form page from explicit field items. Phase 1 treats a form as a vertical layout recipe; it is not a designer, validator, or data-binding engine.

Creates a form page from official form field rows. This recipe builds Label + Field rows using Horizontal layout; TextInput remains owned by its own control system.

Creates a form page from official form sections and an optional composed actions row. This is a Page/Form recipe only; it does not render, validate, bind data, or own input/overlay/scroll systems.

Creates an official form section from existing label controls and fields.

Creates an official form section from title/description text. The generated labels are normal MASLabel controls and keep rendering responsibility inside Core controls.

Creates an official Label + Field row specification for Page.Form. Phase 2 defaults to Auto height through the central control measurer unless an explicit policy is passed.

Creates an official Label + Field row specification from label text. Prefer the MASControlBase overload when the label instance must be reused across rebuilds.

Creates a horizontal actions row for form/page actions such as Cancel + Save. It returns a composed layout node, not a control, so it can contain multiple buttons without giving Layout rendering ownership.

Creates a horizontal actions row from an ordered list of action controls.

Creates a simple action item aligned to the end of a vertical page/form.

Creates a neutral editor page template from form sections. EditorPage is a semantic Page/Form recipe for editing an existing entity; it does not validate, bind data, track dirty state, navigate, open overlays, own input routing, own scroll runtime, own Theme state, or own Host lifecycle.

Creates a neutral editor page template from direct form fields. This overload keeps EditorPage useful for small edit screens without forcing a section model.

Creates a neutral settings page template from settings sections. SettingsPage is a value template above Page/Form primitives; it does not render, validate, bind data, navigate, open overlays, own input routing, own scroll runtime, own Theme state, or own Host lifecycle.

Creates a neutral settings section from existing controls.

Creates a neutral settings section from title/description text. Generated labels are normal MASLabel controls, so rendering remains inside Core controls.

Creates a neutral setting row from existing controls.

Creates a neutral setting row from label/description text. Prefer the MASControlBase overload when controls must be reused across rebuilds.

Creates a neutral read-oriented details page template from details sections. DetailsPage is a value template above layout primitives; it does not render, validate, bind data, navigate, open overlays, own input routing, own scroll runtime, own Theme state, or own Host lifecycle.

Creates a neutral details section from existing controls.

Creates a neutral details section from title/description text. Generated labels are normal MASLabel controls, so rendering remains inside Core controls.

Creates a neutral details row from existing controls.

Creates a neutral details row from label/value/description text. Prefer the MASControlBase overload when controls must be reused across rebuilds.

Creates a neutral empty-state page template. EmptyStatePage is layout-only: it places existing controls and optional actions, but does not render, navigate, own overlay/input/scroll runtime, Theme state, or Host lifecycle.

Creates a neutral empty-state page template from text. Generated labels are normal MASLabel controls, so rendering remains inside Core controls.

Creates a neutral wizard step page. WizardPage presents one step only; the host application owns navigation state and Back/Next behavior. It does not create a navigation runtime, open overlays, own input routing, own scroll runtime, own Theme state, or own Host lifecycle.

Creates a neutral wizard step page with a single control as content.

Creates the standard wizard navigation actions row. The application still owns each button action.

Creates the standard selection-dialog content page recipe. The result is layout-only and does not draw a form, Windows chrome, top bar, shell border, or overlay. Use this facade route for selection-dialog pages; the concrete selection-dialog recipe remains internal.

Internal template builder used by the section-based Page templates. It centralizes title/description/actions chrome, padding policy, max width, and optional scroll wrapping so public templates remain semantic recipes instead of separate layout runtimes.

Advanced/precise vertical page entry point when each child already has its own MASLayoutItem policy.

Creates a common vertical page: title, description, fill content, and actions area. Phase 2 uses Auto for natural header/action regions; content remains Fill by default.

Same as Vertical, but accepts nested layout nodes for content/actions-heavy pages. Use this when a region is itself composed from multiple controls.

Internal selection-dialog content page recipe for MAS Composition. This type creates layout descriptions only. It does not create a Form, draw Windows chrome, draw a top bar, open overlays, own focus/input routing, own Theme state, or render borders. The outer dialog shell should be owned by the Application/PanelShell layer so it can use the same MASPanelShell header/chrome path used by MessageBox, FilePicker, and FileExplorer.

Creates a selection-dialog content page from existing controls and nested layout nodes. Header title/description are optional because the outer MASPanelShell header may already own the dialog title.

Creates a selection-dialog content page from title and description text. Generated labels are ordinary MASLabel controls; rendering remains owned by the label system.

Wraps a single content control as a fill layout node suitable for the Content slot.

Creates the standard selection-toolbar row. The row is layout-only and is intended for actions such as Recommended, Select All, and Unselect.

Creates the standard footer actions row for selection dialogs. The caller still owns button click handlers and final dialog results.

Creates the standard footer actions row from an ordered set of action controls.

Public semantic root-screen region description. A region describes where a control or nested layout node belongs by role, not by manual coordinates. MASScreen consumes these descriptions and converts them into native MASLayout dock items.

Creates a semantic region from a MAS control. Width/height policies remain optional intent, not manual bounds.

Creates a semantic region from a nested MAS layout node.

Public Phase 1 screen facade. A Screen describes a root composition and does not replace MASSkiaRootHost, ControlsLayer, ThemeHost, rendering, input routing, overlay, scroll runtime, or the host lifecycle.

Advanced/precise dock screen entry point when each region already has a MASLayoutItem.

Creates a root screen layout from semantic regions. Consumers describe roles such as Header, Navigation, Content, Inspector, and Footer; MASLayout owns the final slots and sizes. Region defaults are Auto except Content, which fills the remaining center area.

Creates a smart semantic screen-region layout node. Unlike raw Dock(...), this node owns the root screen policy inside Nexamas UI: edge regions are content-sized, Content remains protected, and consuming projects do not provide manual coordinates.

Creates the official command-action row used by application Command regions. Nexamas UI owns action preferred width, minimum width, height, spacing, background padding, proportional shrink, and overflow into More when the row can no longer fit safely inside its semantic Command slot.

Returns the official command-background padding used by CommandActions(...). Renderers that draw a command background should consume this gateway so visual background bounds and reserved layout padding stay identical.

Resolves the official visual card bounds for an application Command row. The command actions remain centered inside the visual card and the trailing edge can align with the following workspace row, allowing app shells to draw the card from semantic layout facts instead of expanding a button union with local numbers.

Creates a common application screen using semantic region roles instead of manual coordinates. This recipe is intentionally generic: it does not know about any consuming product or feature name.

Creates a smart common application screen using semantic roles instead of manual coordinates. This is the preferred route for product windows that want Nexamas UI to own root-region sizing and content protection.

Creates a common application screen using nested MAS layout nodes as regions.

Creates a smart common application screen from nested MAS layout nodes.

Creates a dock screen from common MASControlBase root regions. Edge regions default to intrinsic Auto size and Content fills the center. Consumers pass Fixed/Range/Fill policies only when they intentionally want that behavior.

Creates a dock screen from nested layout nodes. Use this for screens whose top bar, sidebar, or content are themselves composed layouts.

Common app shell: optional top bar, optional left sidebar, and required/optional content region. It is only a dock recipe and does not create a navigation system.

Common content shell with optional top and bottom bars around a center content region.

Central policy for retained Composition scroll scalability diagnostics. This policy deliberately does not virtualize, detach, hide, or recycle controls. It only defines the commercial boundary of MASVerticalScrollLayoutNode: retained scroll is for finite page/form content; large repeated item surfaces must be owned by Data/Virtualization components such as DataGrid/ListView.

Host-level bridge from Composition scroll requests to the official MAS Skia scroll stack. This class is deliberately not a Layout node and not a replacement Scroll runtime. It stores only per-host adapter records needed to connect MASLayoutScrollRequest output to SkiaScrollAdapter input, and delegates geometry, arrows, track, thumb drag, wheel behavior, and painting to the MAS Scroll subsystem. Layout reports scroll requests; the host runtime applies them after Arrange. The records are instance-owned to prevent cross-window/host scroll contamination.

Creates a Composition-owned scroll state store. The optional update callback is used only by the official shared MAS scroll adapter when its own auto-repeat timer advances offset after the original pointer event; layout still owns measurement, arrangement, and apply.

Describes how a layout-axis value is resolved during Measure/Arrange. This enum is physically owned by SizeLayoutSystem/Policy with MASSizePolicy; the public namespace remains Nexamas.UI.Composition because the MASComposition DSL exposes it.

Strong layout-axis size policy owned by MASSize/MASLayout. Owns layout-axis sizing intent only. It does not read controls, mutate bounds, or depend on host state. The source file lives under SizeLayoutSystem/Policy so the canonical owner is visible; the public namespace stays Nexamas.UI.Composition because the existing MASComposition DSL exposes this contract. Invalid raw values are preserved so diagnostics can report them; resolution methods sanitize for layout math.

Diagnostic severity emitted by MASSize and MASLayout engines.

Immutable diagnostic emitted by a size or layout pass.

Diagnostic collector for one measure/arrange pass. It has no logging side effects.

Final source-contract audit status for MASSize/MASLayout lockdown. The audit is a permanent manifest of the places where numeric size/layout facts are allowed to live. It does not read source files at runtime and it does not create a second layout path.

Final source-contract audit surface. These categories separate official token ownership, engine-owned geometry math, consumer-facing builders, and compatibility escape hatches.

Immutable source-contract audit item. It names one area, its owner, and the lockdown policy that keeps manual Width/Height/Bounds/Padding/Spacing usage from spreading back into consumers.

Immutable final source-contract audit report for Group 10. A clean report means that remaining numeric sizing and bounds are either token-owned, engine-owned, or explicitly compatibility-gated instead of being normal application/page/control consumption paths.

Group 10 source-contract lockdown manifest. It records the approved ownership map after Groups 1-9 moved control, surface, composition-page, workspace, and internal Application surface sizes into permanent MASSize/MASLayout tokens and contracts.

Phase 6E migration status for MASSize/MASLayout control participation.

Contract surfaces that can be owned by a Nexamas UI control or internal visual surface.

Immutable line item returned by the final control migration audit.

Immutable result for the Phase 6E final migration audit.

Permanent Phase 6E auditor. It does not read source files and does not create a second layout system; it validates that known Nexamas UI controls expose the expected MASSize/MASLayout contracts or are explicitly runtime-owned internals.

Cleanup status for MASSize/MASLayout weak-path lockdown. These states keep deliberate compatibility routes visible without allowing them to become normal geometry ownership again.

Weak path category tracked by the cleanup audit. The categories are intentionally operational: they name the route that could bypass the official slot/size facts.

Immutable weak-path audit line item. A clean item either points to the official owner or records a compatibility route that is guarded, diagnostic, and not the preferred runtime path.

Immutable cleanup report for weak MASSize/MASLayout paths. The report is kept separate from the final migration manifest so cleanup can evolve without weakening the already-closed public API contract.

Permanent weak-path cleanup audit. It does not introduce a second layout system; it records which remaining escape paths are allowed, which official owner guards them, and which paths must stay diagnostic-only until they can be removed safely.

Lockdown status for source/runtime bypass audit items. The audit records whether a formerly risky path is closed, owned by the layout engine, deliberately limited to compatibility, or still pending review.

Source/runtime bypass category tracked after weak-path cleanup. Categories are named after the concrete way a consumer could skip MASSize/MASLayout slot facts.

Immutable source/runtime bypass audit item. This class is diagnostic only; it does not own layout math and does not create a parallel path. Runtime ownership remains in MASLayoutSlotFactory, MASLayoutSlotBoundsResolver, MASControlBase, and RootHost.

Immutable report for the source/runtime bypass lockdown pass. A closed report means the known bypass classes are either closed, engine-owned, or compatibility-only and can be protected by the SDK test harness source scanners.

Permanent source/runtime bypass audit for MASSize/MASLayout. It names the known bypass shapes and records the official owner that blocks them. The actual checks are performed by the SDK harness so this report stays a stable internal ownership map.

Phase 7 lockdown finding severity for MASSize/MASLayout sellability checks.

Phase 7 audit surface. The auditor validates API exposure, migration status, and SDK documentation readiness.

Immutable Phase 7 lockdown audit finding.

Immutable Phase 7 lockdown audit report. This is internal validation data only; it does not become a consumer-facing SDK API.

Permanent Phase 7 lockdown auditor for MASSize/MASLayout. It verifies that the consumer-facing API remains small, engine details remain internal, and Phase 6 migration remains closed. It does not read source files and does not create any layout/runtime path.

Severity for the MASSize/MASLayout behavioral lockdown audit. The audit is intentionally internal: it records the permanent behavior gates that must stay protected after the composition/layout stabilization passes.

Immutable behavioral lockdown finding. Findings are diagnostic facts only; they do not create a runtime layout path and they do not mutate controls.

Immutable result for the behavioral lockdown audit. It is consumed by the SDK harness to ensure the behavioral gates remain explicitly tracked.

Internal behavioral lockdown auditor for the stabilized Size/Layout and Composition lifecycle. This audit is deliberately not a layout engine, not a public SDK API, and not a replacement for the runtime tests. It is a small diagnostic registry of the behavior gates that must remain covered by the SDK harness and source-contract suite.

Lockdown status for component-level responsive layout consumption. Locked means the component owns a responsive plan/profile path. ProofOnly means the component is atomic, surface-layout-owned, or delegates layout to an already locked child.

Component family tracked by the responsive layout consumption audit.

Immutable line item describing one component's responsive-layout ownership.

Immutable report for the responsive layout consumption audit.

Permanent responsive-layout consumption audit for component renderers. This manifest now covers every public intrinsic-size component in Component/*, not only the recent large controls. Complex components must consume MASResponsiveLayoutProfile or a LayoutPlan. Atomic components are locked as bounded intrinsic controls so the gate does not force a meaningless per-control LayoutPlan onto buttons, badges, labels, etc.

Size/Layout-owned surface geometry roles. This vocabulary intentionally stays independent from VisualSurface/Rendering roles so layout can resolve content and visual-overflow insets without owning material, frame, chrome, renderer, or proof policy.

Internal status for the SizeLayout surface-boundary hardening evidence.

Immutable evidence that SizeLayout surface geometry is resolved through a SizeLayout-owned role vocabulary rather than a Rendering/SurfaceVisual role.

Builds evidence for the SizeLayout/SurfaceVisual boundary. It validates already-owned layout facts only; it does not inspect source files, draw, create controls, resolve materials, execute render verification, or mutate runtime state.

Immutable snapshot of the Nexamas UI systems that are allowed to influence size and layout. This is a contract surface, not a renderer or compatibility path.

Creates integration snapshots for layout/size contexts from official Nexamas UI systems.

Density resolver for live layout density facts that are not owned by MASSizeProfile.

Official DPI resolver for logical/DIP layout contexts.

Text measurement contract used by size/layout. Typography remains the source of font facts.

Immutable text measurement request. All sizes are logical/DIP.

Immutable text measurement result. It contains no paint references.

Official gateway for text measurement. It centralizes Skia/Typography text facts for future control migration.

Default Typography-backed text measurement contract.

Surface inset facts consumed by layout slots. It does not draw and does not resolve materials by itself.

Surface contract resolver for content/visual/focus insets. Surface rendering remains owned by Rendering.

Float/overlay surfaces whose size facts must be known by MASSize/MASLayout before they are handed to FloatRuntime. This is not an overlay implementation and does not replace FloatRuntime; it only describes logical/DIP sizing contracts.

Internal contract for FloatRuntime content and hosted overlay controls that can expose their desired logical size to the MASSize/MASLayout system.

Central resolver for canonical Float/Overlay surface sizes. The numbers here are permanent product metrics derived from existing Nexamas UI popup/dialog behavior; individual Float consumers should not duplicate them locally when reporting size facts.

Operational resolver for Float content that implements IMASFloatSurfaceSizeContract. Float request builders use this gateway so implemented surface contracts are consumed before falling back to built-in kind defaults or local geometry builders.

Surface families that expose content/visual/focus geometry to MASSize and MASLayout. The enum describes product-owned surface geometry only; it does not create a rendering system.

Immutable feature flags used when a complex surface changes intrinsic height because an owned visual region is enabled. These flags stay internal so consumers continue to describe intent rather than calculating panel/card geometry by hand.

Internal surface-size contract for complex controls whose visible shell, content inset, focus allowance, and shadow allowance must be understood by layout as one truth.

Canonical resolver for complex MAS surfaces. It centralizes surface metrics that were historically scattered across render/layout code, while rendering remains owned by the existing VisualSurface, VisualSurfaceMaterial, Card, PanelShell, and editor components.

Internal primary-axis allocation record shared by MASLayout and Composition consumers. It keeps margin, minimum, preferred, and fill-weight facts together so stack-style layouts use one deterministic allocation policy instead of drifting into local sizing math.

Shared stack-axis allocator. It gives every participant a deterministic share of the available primary axis: minimum first, fixed/auto growth toward preferred size second, then Fill by weight. When the container is too small, it compresses proportionally inside the host bounds instead of allowing earlier children to consume all space and push later children outside the layout surface. The allocator clones allocation facts before assignment, so callers never observe hidden mutations on their own planning lists.

MASLayout-owned stack geometry resolver shared by native MASLayout stacks and Composition stack nodes. It owns only deterministic axis geometry: main-axis offset and cross-axis placement. It does not measure controls, allocate children, apply slots, host controls, route input, or render. Composition may describe pages, regions, workspace, hosting, and scroll orchestration, but low-level stack geometry must pass through this boundary so Native Stack and Composition Stack cannot drift into separate layout engines.

Internal role vocabulary for selecting one semantic rectangle from a MASLayoutSlot. This enum deliberately remains internal: SDK consumers use MASApplicationWindow.Geometry methods instead of reading MASLayoutSlot directly.

Optional internal contract for controls that need focus or Float-anchor rectangles that differ from the default hit/outer slot facts. This is not a public API and does not create a second layout system: MASLayoutSlotFactory remains the only owner that may merge these semantic facts into the final MASLayoutSlot.

Internal optional semantic-rectangle override container used by MASLayoutSlotFactory. Missing values preserve the default slot facts exactly.

Internal semantic-bounds policies for controls whose focus or popup anchor rectangles should describe the painted/control surface rather than the expanded touch-hit area. The policy is consumed only by IMASLayoutSemanticBoundsProvider implementations and merged only by MASLayoutSlotFactory, keeping semantic geometry inside MASLayout.

Canonical bounds resolver for layout-owned control geometry. It prevents runtime consumers from guessing with BoundsLogical when the correct fact is VisualBounds, ContentBounds, HitBounds, FocusBounds, or FloatAnchorBounds.

Canonical factory for producing a full MASLayoutSlot from an explicit outer rectangle. It is used by advanced/direct placement paths so manual logical bounds still keep the same visual/content/hit/focus/float-anchor facts as native MASLayout arrange.

Creates a fallback slot from an outer rectangle. This is the only sanctioned non-control slot fallback path; all callers outside MASLayoutSlot itself must use this factory boundary instead of constructing MASLayoutSlot directly.

Creates a full slot from a measured MASSize result. Native arrange and Composition child arrange use this overload so every final placement enters the same slot factory boundary instead of constructing slot facts directly from outer bounds or size results.

Read-only context for MASLayout engines. Bounds are logical/DIP.

Single source of truth for a laid-out control's logical geometry.

Immutable layout plan containing final slots and desired content size.

Node tree consumed by the Phase 2 engines. It describes intent only.

Compatibility snapshot for legacy internal callers. Hot layout engines must use ChildCount/GetChild so repeated measure/arrange passes do not allocate cloned arrays for immutable node children.

Small internal builder surface for MASLayout engines and semantic page APIs.

Owns the read-only measurement pass for native MASLayout nodes. The engine is intentionally side-effect free: it does not host controls, mutate bounds, request invalidation, or decide visual clipping. Measurement must mirror arrange budgets, especially margins, so FillWidth and constrained layouts cannot silently exceed their host.

Enables a short-lived measurement cache for one arrange pass only. The cache is deliberately not kept across passes so text, theme, profile, or DPI invalidation cannot reuse stale facts.

Allocation-free key for the one-pass measurement caches. It replaces the older string concatenation key so hot layout measurement can reuse facts without creating short-lived culture-formatted key strings on every child measurement.

Owns the arrange pass and produces immutable slot facts. It never applies controls directly; Application/Composition owners consume the plan in one batch.

Native split-pane layout used by Presentation/Application pages when explanatory narrative must sit beside a real data/list surface. It is part of MASLayout, not a Showcase helper: the narrative pane receives a bounded official width and the surface pane receives the remaining width. Narrow hosts collapse to a vertical stack so content is not clipped by a forced two-column row.

Native grid layout used by the Application layout gateway. The grid owns only cell budgeting and delegates child facts back to MASLayout/MASSize; row compression uses the shared axis allocator so narrow/short hosts do not hide later rows.

Small internal facade over the native MASLayout measurement/arrange engines. Production retained layout owners are expected to enter through Arrange so measurement and slot construction stay in one lifecycle; Measure remains Friend-only for diagnostics, tests, and carefully-owned internal callers that need a read-only size probe.

Official whole-platform size profile used by settings pages and application layout. It is not a second sizing system: every profile normalizes back into MASSizeContext and MASSizeResolver.

Immutable size profile snapshot. Public consumers choose a profile; MASSize/MASLayout consume its normalized scales.

Logical inset vocabulary used by size results and layout slots.

Advanced numeric adjustment attached to a MASSize intent.

Stable public size intent object for MAS controls.

Read-only logical context used by MASSize System.

Resolved intrinsic size contract output for a MAS control. Constructor-level normalization is intentional: every control contract, fallback, and surface contract receives the same invariant that DesiredSize is finite and MinSize/MaxSize cannot contradict it.

Official intrinsic measurement contract.

Advanced contract for controls whose scrollable content size is different from their viewport size. It reports logical/DIP content facts only; the Scroll System remains the owner of scrolling behavior.

Official resolver for turning measured intrinsic facts plus intent/density into final logical size facts.

Single canonical registry for fallback intrinsic sizes. Composition consumes this instead of local magic sizes.

Internal responsive rendering bands consumed by component layout-plan resolvers. The bands do not replace MASSize/MASLayout; they translate the current profile, size intent, and available bounds into a predictable drawing posture.

Logical/DIP breakpoints used by the shared responsive layout resolver. Components may provide stricter thresholds, but they must still consume the same profile object so profile, intent, and available bounds remain centralized.

Immutable responsive drawing facts for component renderers. This object is the bridge between the official MASSize/MASLayout profile and the component's inner layout plan. It deliberately carries no mutable control state and owns no measurement policy.

Shared resolver that turns the official runtime size profile, control size intent, and available bounds into component-rendering scale facts. Component-specific resolvers should consume this instead of multiplying tokens by DPI directly.

Canonical default-size contracts for the core interactive component roles used by MASSize/MASLayout. Component token files may describe painting details, but the base logical size of common controls must originate here so Default, Compact, Comfortable, Large, and TouchFriendly profiles move together.

Canonical size/layout metrics for MAS-owned application surfaces. These metrics belong to the Size/Layout system so application builders and PanelShell-hosted pages describe surface intent instead of carrying local numbers.

Canonical MASSize/MASLayout tokens for the public MASApplication layout-language consumers. These values keep LayoutPage, Workspace, and Gallery builders from becoming independent size sources while preserving their beginner-facing semantic vocabulary.

Canonical Size/Layout-owned metrics for native MAS application window presentation. The Application presentation planner consumes these tokens so host-window sizing, minimum visibility, and work-area guard rules stay in the MASSize/MASLayout layer instead of living as a separate Application/Presentation size source.

Canonical DIP metrics for FloatRuntime surfaces as exposed to MASSize/MASLayout. These values are product-owned sizing contracts; individual float consumers must not duplicate popup, dialog, picker, or toast dimensions locally.

Canonical DIP metrics for complex MAS surfaces measured through MASSize/MASLayout. Surface renderers and builders consume these contracts indirectly through MASSurfaceLayoutSizeResolver instead of carrying private desired/min dimensions.

Canonical MASSize/MASLayout tokens for high-level composition sections. Form, settings, and details sections must consume these values instead of inventing local section padding, margin, or spacing numbers.

Canonical MASSize/MASLayout tokens for high-level composition pages, rows, and selection-dialog content pages. These values keep page recipes semantic and prevent public composition templates from becoming a second source of hard-coded size, padding, margin, or spacing rules.

Canonical internal measurement helpers for MAS controls that participate in MASSize. This class is part of the Size/Layout system itself: it prevents every control from inventing its own hit-area, visual-overflow, and context-normalization rules.

Normalizes a possibly missing size context to the platform's unbounded intrinsic-measure context.

Standard visual overflow used by regular painted controls such as buttons, selectors, toggles, and segmented controls.

Standard visual overflow used by input-field controls whose chrome extends slightly beyond their content slot.

Computes the canonical touch-hit overflow for a control whose whole visual box is clickable.

Computes canonical touch-hit overflow for controls that may grow horizontally but still need vertical comfort.

Resolves a possibly missing or unusable available size for intrinsic viewport-based controls.

Resolves one available logical length, keeping infinity only when the caller explicitly allows unbounded growth.

Returns a stable viewport length from available size, fallback, minimum, and maximum limits.

Returns the standard visual overflow for scrollable collection surfaces.

Sanitizes a logical size length for contract math. Infinity and negative values are never valid in control-local metrics.

Clamps a logical size length to a safe inclusive range.

Resolves the canonical desired size for MAS text-input controls. Text boxes, search boxes, password boxes, numeric boxes, and multiline text boxes must all ask MASSize for this policy instead of repeating InputTokens math locally.

Resolves the canonical minimum size for MAS text-input controls.

Resolves the canonical content inset for MAS text-input controls, including left icons and right-side adornment reservations.

Computes the horizontal text width available for selection controls that have a glyph, an optional label gap, and right-side text padding.

Resolves the label text width that may be handed to the text-measure gateway after padding is reserved. Unbounded labels remain unbounded instead of falling into a local fallback width.

Resolves a label desired size from already-measured text facts and logical padding facts.

Resolves the canonical intrinsic desired size for standalone title/header controls.

Resolves the canonical intrinsic minimum size for standalone title/header controls.

Resolves the title/header content inset used by MASLayout slot contracts.

Resolves MASTooltip desired size from text-measure facts. Tooltip runtime still owns placement; MASSize owns the compact panel minimum, maximum, padding, and available-width clamp.

Resolves MASTooltip minimum size through the shared tooltip panel contract.

Returns MASTooltip content inset contract.

Resolves the canonical desired size for single-glyph choice controls such as checkbox, radio button, and toggle switch. The control supplies text facts; MASSize owns glyph/text/gap/minimum/available-width policy.

Resolves the canonical minimum size for single-glyph choice controls. Text-bearing controls reserve only the platform minimum label width, not the full measured label width.

Resolves the canonical preferred-size override for MASButton. Preferred hints are still allowed, but they are normalized through MASSize so the button control does not maintain a second default-size path.

Resolves MASButton's intrinsic desired size from measured text and icon facts. The control supplies facts; MASSize owns the final content/default/minimum policy.

Resolves MASButton's canonical minimum size. Custom minimum hints can only raise the platform minimum.

Returns the content inset contract shared by MASButton measurement and layout slot facts.

Resolves GlyphButton's canonical square side. Glyph buttons are compact MAS-owned affordances; the control supplies intent and MASSize owns the side/minimum/inset policy.

Resolves GlyphButton's minimum touchable visual square.

Returns GlyphButton's canonical content inset.

Returns GlyphButton's canonical visual overflow inset.

Resolves MASSegmentedControl's profile-neutral height. The active size profile may scale the final result later through MASSizeResolver, so intrinsic control policy keeps this value neutral before intent resolution.

Resolves MASSegmentedControl's desired size from segment text facts. The control measures labels; MASSize owns default width, segment padding, profile-height floor, and text safety padding.

Resolves MASSegmentedControl's minimum size. The segment control may be wider because of labels, but its clamp floor remains owned by MASSize.

Returns MASSegmentedControl's content inset contract for layout slot facts.

Resolves MASMenuBar's profile-neutral height. The standard application MainMenuBar height belongs to MASSize, while MASSizeResolver may scale the final measured result for the active runtime profile.

Resolves MASComboBox's desired input-trigger size from selected/item text facts. The control measures text; MASSize owns chrome, icon reservation, default width, and height policy.

Resolves MASComboBox's minimum input-trigger size through the shared input contract.

Returns MASComboBox's content inset contract, including the right-side chevron reservation.

Resolves the dropdown float width for MASComboBox from anchor width and measured item text facts. Height stays owned by ListPopupLayout; width policy is part of the combo-box intrinsic sizing contract so the popup cannot invent a second local chrome formula.

Resolves the WinForms MASMenuButton toolbox trigger default size. MASMenuButton is a public WinForms wrapper rather than a MASControlBase surface, but its design-time/default dimensions still belong to the MASSize contract.

Resolves the WinForms MASMenuButton minimum clamp used by fluent sizing APIs.

Returns the WinForms MASMenuButton content padding as a MASSize-owned fact.

Applies the menu-button width clamp used by MASMenuButton.WithSize and internal bounds wiring.

Applies the menu-button height clamp used by MASMenuButton.WithSize and internal bounds wiring.

Resolves MASSelectorItemControl's desired size from item-count and measured label-width facts. MASSelectorItemControl measures labels; MASSize owns visible row policy, structural chrome, available-width clamping, and default/minimum floors.

Resolves MASSelectorItemControl's minimum size. Runtime row tuning is treated as a fact; the min-width and min-height floors remain MASSize-owned selector policy.

Returns MASSelectorItemControl's content inset contract.

Returns MASSelectorItemControl's visual overflow contract; only self-surfaced selector lists report chrome overflow.

Resolves MASTabControl's empty-state width. This keeps the no-tab fallback out of the control body.

Resolves MASTabControl's horizontal outer padding contribution.

Resolves one MASTabControl item width from measured text facts.

Resolves MASTabControl's item gap contribution.

Resolves MASTabControl's desired size from accumulated item-width facts.

Resolves MASTabControl's minimum size.

Returns MASTabControl's content inset contract.

Returns MASTabControl's visual overflow contract.

Returns MASTabControl's hit-overflow contract. Tabs keep a compact visual strip, but MASSize still owns the extra pointer comfort instead of letting the control invent a local hit-area expansion.

Resolves canonical toolbar content inset from the current toolbar metric profile.

Resolves a toolbar item height while respecting the MAS toolbar minimum item height contract.

Resolves MASToolbar's desired size from item facts. The toolbar counts visible entries; MASSize owns padding, gap, default empty width, fill minimum, and item-height policy.

Resolves MASToolbar's minimum size from fill-item minimums and shared toolbar chrome facts.

Resolves the canonical separator size for toolbar composition.

Resolves the canonical toolbar separator minimum size.

Resolves the canonical toolbar separator maximum size.

Resolves the canonical spacer size for toolbar composition.

Resolves the canonical toolbar spacer minimum size.

Resolves MASPathDisplayBox desired size from measured text facts.

Resolves MASPathDisplayBox minimum size.

Resolves MASPathDisplayBox maximum size.

Resolves MASPathDisplayBox content inset.

Resolves MASPathDisplayBox visual overflow inset.

Resolves MASTileBox's desired viewport size. The tile box supplies item count; MASSize owns the fallback width, visible-row policy, viewport clamp, and row/header allowance.

Resolves MASTileBox's minimum size.

Returns MASTileBox's content inset contract.

Returns MASTileBox's surface visual overflow contract.

Resolves MASListBox visible-row count from item facts. ListBox supplies count; MASSize owns empty/min/max visible-row policy for intrinsic collection surfaces.

Resolves MASListBox desired size from measured scroll-content and text-width facts.

Resolves MASListBox minimum size through shared collection-surface floors.

Returns the standard content inset for scrollable collection surfaces.

Resolves MASListView's preferred viewport height from item/header facts.

Resolves MASListView's intrinsic viewport from available width and preferred-height facts.

Resolves MASListView's desired size from viewport and scroll-content facts.

Resolves MASListView's minimum size through shared collection-surface floors.

Resolves the text-mode content width for MASListView from viewport and measured text facts.

Resolves MASTreeView's intrinsic viewport from available width, visible-row count, and row-height facts.

Resolves MASTreeView's desired size from viewport and scroll-content facts.

Resolves MASTreeView's minimum size through shared collection-surface floors.

Returns MASTreeView's content inset contract.

Resolves the internal MASFileBrowser desired surface from its child list measurement and scroll-content facts. The browser owns navigation and selection state only; MASSize owns the viewport floor and bounded available-width clamp.

Resolves MASFileBrowser's minimum viewport surface. FilePicker and FileExplorer may wrap it, but the browser's own floor stays a MASSize fact.

Returns MASFileBrowser's collection-surface content inset contract.

Resolves the internal FileExplorer splitter desired size. The splitter is vertically elastic, but the grip width and fallback height remain token-owned MASSize facts.

Resolves the internal FileExplorer splitter minimum grip size.

Returns FileExplorer splitter touch comfort as a MASSize fact rather than a controller-local hit expansion.

Normalizes MASDataGrid row/header extents through the shared size contract.

Resolves MASDataGrid visible row count for intrinsic measurement. The grid supplies its current view count; MASSize owns the min/max viewport policy.

Resolves MASDataGrid desired width from accumulated visible-column facts.

Resolves MASDataGrid intrinsic desired size from column width, header height, row height, and view-row facts.

Resolves MASDataGrid minimum size. The minimum is Default-derived and independent of local grid state.

Resolves MASDataGrid scroll-content size from owned column and row facts.

Resolves MASProgressBar's desired logical size from track, frame, and imported-label facts.

Resolves MASProgressBar's minimum logical size. The track thickness and width minimums are owned by MASSize.

Returns the progress content inset produced by the optional contained-field frame.

Resolves MASOperationProgressBox desired size from available-size facts. The operation box supplies no local formula; MASSize owns the default width, minimum width floor, and bounded-width clamp.

Resolves MASOperationProgressBox minimum size through the shared operation-progress composition contract.

Returns MASOperationProgressBox content inset contract.

Returns MASOperationProgressBox outer surface visual overflow contract.

Public semantic spacing vocabulary for MASLayout consumers. Use these values for normal page, workspace, grid, flow, stack, gap, and padding decisions instead of writing raw logical numbers in application code. Numeric overloads remain available for advanced engine-level escape hatches, but this vocabulary is the preferred SDK surface.

Internal resolver for MASLayout semantic spacing tokens. It owns the base DIP values and applies the active MASSizeProfile gap scale at build time, keeping spacing decisions inside MASSize/MASLayout instead of in external projects.

Small internal numeric guard shared by public layout builders and token resolvers.

Internal durable store for the MAS runtime size profile. It stores only the selected profile kind and never participates in measurement or layout calculation.

Public event payload emitted when the application runtime size profile changes. The payload is immutable so settings pages, demos, and advanced diagnostics can react without reading internals.

Single runtime owner for the process-wide MAS size profile. It is not a second sizing engine: all consumers must still enter MASSize/MASLayout through MASSizeLayoutIntegrationContext. This service only provides the current profile snapshot and change signal.

Severity for the element-level Size/Layout closure audit.

Element-level closure finding. Findings are read-only evidence and never mutate layout state.

Immutable report for registry-to-size/layout closure. This report is intentionally evidence-only: it does not construct components, run captures, calculate layouts, or introduce a second component list.

Phase-2 closure audit for registered visual elements. It proves that the component registry, intrinsic-size contract, Composition fallback contract, and responsive consumption manifest all describe the same element universe without creating a parallel registry or layout path.

Severity for the render/hit-bounds closure audit. Errors block Phase 3; warnings keep monitored geometry facts visible without inventing another rendering or input route.

Classification for the official Measure -> LayoutSlot -> Render -> HitTest proof.

Immutable finding emitted by MASRenderHitBoundsClosureAudit.

Immutable report for the Phase 3 render/hit-bounds closure proof.

Phase 3 closure audit for render-time layout consistency and hit-testing consistency. It does not create a new layout, render, or input system. Instead it proves that the existing MASControlBase/ControlsLayer/MASLayoutSlot route is the single geometry chain.

Severity for the Size/Layout runtime verification audit. Errors block commercial quality; warnings keep evidence visible without creating a second layout path.

Runtime verification surfaces covered by the Size/Layout Quality gate.

Immutable finding emitted by the Size/Layout runtime verification audit.

Immutable report for read-only Size/Layout runtime verification. It validates resolver, profile, DPI, bounds, tiny-mode, and hit/visual overflow invariants without allocating UI controls, rendering, scheduling frames, or mutating the runtime profile service.

Read-only runtime verification for the official Size/Layout chain. This audit deliberately uses the same resolver/contract objects consumed by components and composes the existing responsive, bypass, weak-path, source-contract, migration, surface-boundary, and behavioral lockdown audits into a blocking Quality gate.

Internal proof-state for one certification proof scope. It deliberately separates a gate-backed source proof from runtime/package/consumer proofs so a lightweight report cannot be mistaken for full release evidence.

Immutable internal proof matrix that keeps Source, Runtime, Package, and Consumer certification semantics separate. This prevents the lightweight Quality Orchestrator from producing wording that looks like a full SDK release certificate.

Internal product-certification state used by the Nexamas UI Certification Center.

Immutable internal row for one certified Nexamas UI governance area.

This contract is not a public telemetry API and does not execute gates, read scripts, inspect files, run captures, create controls, or query runtime systems. It records the already-owned closure evidence names that the Certification Center may display.

Immutable internal certification manifest for the official Nexamas UI commercial evidence surface.

This manifest aggregates already-owned closure facts. It does not execute platform gates, read report files, inspect source files, execute render verification captures, create controls, schedule frames, query telemetry, allocate bitmaps, or mutate platform state.

Internal SDK release-readiness state for the commercial public-contract freeze.

Immutable internal manifest proving that the SDK release surface is frozen and package-ready.

This manifest records already-owned release facts only. It does not inspect source files, execute PowerShell gates, run SDK tests, build packages, create controls, render, query telemetry, or mutate platform state.

Internal project-wide final architecture closure state.

Immutable internal manifest proving the current Nexamas UI architecture is closed against dead paths.

This manifest records already-owned architecture facts only. It does not inspect source files, execute gates, read reports, create controls, run captures, run performance scenarios, render, allocate bitmaps, expose telemetry, or mutate platform state.

Internal host gateway for the Nexamas UI-owned Certification Center surface.

Nexamas UI internal demos use AttachCenter to display the ready Nexamas UI-owned page. Manifest creation remains Friend-only; this gateway does not expose public telemetry, run gates, scan source files, or duplicate Performance/RenderVerification/Virtualization/DataGrid/FloatRuntime ownership.

Attaches the official Nexamas UI-owned Certification Center to a MASApplicationWindow. External hosts receive a ready page and never read manifests, gate scripts, or certification internals.

Attaches the official Nexamas UI-owned Certification Center content to an existing Application page-builder scope such as MASApplicationWindow.Pages. The host supplies only the current MASApplicationWindow and MASApplicationLayoutPageBuilder; Nexamas UI still owns the manifest, product-readable rows, refresh behavior, MAS controls, and page layout.

Nexamas UI-owned internal certification center surface.

The center consumes NexamasUICertification.CreateManifest only. It does not run gates, read gate scripts, read markdown reports, execute captures, create diagnostics scanners, or let demo code own certification logic.

Immutable coverage evidence row for one registered component descriptor.

Describes how a registered architectural component is covered by the MAS quality evidence graph.

Official internal coverage map between MASComponentRegistry descriptors and Quality/RenderVerification evidence.

This map deliberately consumes existing registries instead of maintaining a parallel component list. Every descriptor must resolve to a direct render scenario, a family render scenario, or a named contract/system proof. Unclassified descriptors are blocking quality gaps.

Immutable aggregate for component-to-quality-evidence coverage.

Severity for the final dead-path / parallel-path source tree closure audit.

Immutable finding emitted by the dead-path closure audit.

Immutable report for project-root dead-path / parallel-path closure.

File-system proof that the source tree has no unowned active VB source, missing declared assets, duplicate project includes, or root-level generated-output paths masquerading as product source.

This audit does not delete files, rewrite project items, execute build tools, capture render output, or create a second source registry. It only verifies that the existing project file remains the single active source owner.

File-system gate for the commercial Nexamas UI quality/product tree. It verifies that project-declared assets and the canonical quality runner assets exist before a release can claim certification evidence.

Immutable result produced by a single Quality Orchestrator gate.

A gate result is evidence metadata only. It does not expose public telemetry, mutable probes, render captures, diagnostics streams, or raw file-system scanners outside Nexamas.UI.

Internal execution status for one Quality Orchestrator gate.

Central internal orchestrator for lightweight Nexamas UI quality gates.

The orchestrator intentionally runs only read-only, deterministic, non-visual gates. It does not capture screenshots, approve baselines, allocate UI controls, schedule frames, mutate diagnostics, or expose public telemetry. Heavy CI/build/runtime probes remain owned by tools/quality and eng/ci scripts.

Immutable aggregate report produced by the Quality Orchestrator.

This report is the central internal truth surface for lightweight certification gates. It records gate outcomes and summary facts only; it does not expose runtime telemetry or mutable proof state.

Verifies that the Certification Manifest is closed against the Quality Orchestrator gate graph.

This audit is intentionally read-only and manifest-only. It does not execute build scripts, read reports, capture render baselines, allocate UI controls, or inspect external files. Its only job is to prevent Certification from silently ignoring a Quality Orchestrator gate or accepting duplicate manifest ownership keys.

Immutable result for Certification Manifest / Quality Orchestrator closure validation.

Internal governance state for consumer adapter exposure. This is not a public API promise; it records whether a product control's source/provider adapter surface is intentionally kept behind Friend gates or approved for a future public contract.

Friend-only adapter policy row for one product control. It deliberately separates internal source/projection proof from public adapter readiness so large-control previews cannot accidentally expose unstable binding shapes.

Central friend-only policy for product-control adapter exposure. It keeps the internal source/projection work done for previews from becoming accidental public API before write-back, validation, batching, docs, and measured stress evidence exist.

Verifies that preview product controls have an explicit adapter exposure policy and that no internal source/provider prototype is accidentally treated as a public production contract.

Production promotion requirements used by the friend-only governance gate. These values are diagnostic labels, not public API feature switches.

Friend-only rule row that declares the minimum evidence required before a product control may move from CompactPreview toward ProductionReady marketing.

Central rule manifest for moving product-size controls beyond CompactPreview. It keeps promotion criteria in one place instead of scattering production decisions through individual controls or Showcase code.

Friend-only production-promotion guard. It allows CompactPreview controls to remain governed previews, but blocks any ProductionReady marketing unless the central readiness matrix, adapter policy, and rule manifest agree.

Runtime proof that hostile or faulty render stages cannot leak SKCanvas clip/matrix state into later host stages. This protects Controls, Composition, and FloatRuntime from accidental translate/scale/clip contamination by a previous render callback.

Runtime proof that ControlsLayer render clipping matches hit-test clipping for a retained control subtree. A parent-owned clip must constrain the parent body, direct children, and owned child-layer rendering so the SDK never exposes visible-but-not-interactive pixels.

Runtime proof that DPI/theme snapshots, WinForms Font/RTL events, and explicit culture observations are owned by the host runtime-environment coordinator and turn into retained layout refresh requests.

Phase-4 runtime proof expansion for Application-level live environment changes and stress-only contracts. This gate deliberately reuses the official host runtime-environment coordinator, Localization runtime coordinator, Motion/Float runtime gates, dispatcher async gate, and retained ControlsLayer scalability policy. It does not introduce a parallel layout, input, cache, or virtualization path.

Phase-5 DPI/TextInput paint lifecycle proof.

DPI-01: text-input render/hit-test/caret paths use a control-owned paint cache instead of leaking a new SKPaint clone per call. DPI-02: public MASTypography.GetPaint returns a caller-owned clone while the internal shared paint remains Friend-only and isolated from mutation/disposal.

Phase-6 proof for DPI-05 and DPI-06. It verifies that paragraph measurement, wrap segmentation, render paragraph layout, and ellipsis fitting are routed through the shaped measurement gateway.

Phase-7 proof for DPI-03 and DPI-04. Verifies that repeated HarfBuzz drawing uses the owned drawable-run/blob cache and that system-font fallback drawing is bounded by the official bitmap/measure caches instead of allocating a new GDI bitmap on every draw.

Phase-8 proof for DPI-07 / DPI-08 / DPI-09 and DPI-R01..DPI-R05. Keeps multiline/caret/DPI/cache/diagnostics proof on the official text, layout, DPI, theme, and diagnostics routes.

Proves LOC-04: Localization owns a runtime culture/RTL coordinator that announces mutations to the host runtime-environment coordinator, which in turn requests retained layout refresh/invalidation.

Proves LOC-05: Localization snapshot readiness is not treated as public AttachPage lifecycle proof, and render-verification snapshot scenes are not advertised as RealControl evidence unless they are backed by the public MASLocalizationRtl.AttachPage route.

Proves LOC-06: unsupported or invalid RTL runtime-culture resolution does not fall back to LTR silently.

Runtime proof that the host surface base clear is theme-aware across the Skia render clear, WinForms transient background, and GL resize priming policy. The gate intentionally checks the dark built-in theme so a hard-coded white clear cannot satisfy the contract.

Proves that persistent render-stage failures remain visible to the runtime fault channel. Log/trace output may be rate-limited, but structured fault records and occurrence counters must advance on every repeated render failure.

Runtime/source-shape proof that control-owned async completions and scroll-repeat pulses use the root-owned UI dispatcher contract. The legacy captured SynchronizationContext path may exist only for host-independent direct clock construction; when an official dispatcher is supplied, rejection must stop the clock instead of falling back to a stale captured context after detach/re-attach. Repeat callback failures must stop at the input boundary and report diagnostics instead of escaping from the dispatcher/timer callback.

Runtime-structure proof that FrameScheduler / HostRuntime native surface access is guarded by dispatcher ownership boundaries and no longer falls back to direct WinForms calls after BeginInvoke rejection.

Behavioral proof that FloatRuntime owns and shuts down active transition runners at host dispose.

Runtime proof for MASDataGrid/MASDataView large-data summary ownership. Projection refresh may rebuild visible rows, but expensive summary aggregation is controlled only by the DataGrid summary policy and must be explicit for large data.

Runtime proof for the DataGrid single-row mutation contract. AddRow remains part of the public SDK surface for small interactive changes, but repeated AddRow use outside BeginUpdate/DeferRefresh must be visible as a readiness diagnostic, while bulk/coalesced loading paths must stay quiet and notification-bounded.

Runtime proof that malformed typed DataGrid values remain fail-closed but visible as readiness diagnostics. The grid must not throw to SDK consumers and must not silently hide parsing/conversion failures.

Proves DataGrid/DataView consume the official MASRuntimeEnvironmentStamp for culture/RTL and invalidate projection and summary facts through the DataView-owned path instead of reading CurrentCulture directly from filter/sort/format paths.

Regression proof for the runtime-environment stamp overflow failure that previously surfaced as broad render faults. It exercises long culture keys, RTL/LTR switches, deterministic SameAs behavior, and virtualization conversion without relying on unchecked Integer hash arithmetic or ad-hoc per-control cache keys.

Regression proof that DataView projection, filter parsing, grouping, sorting, summary formatting, and cell text formatting are invalidated from the official MASRuntimeEnvironmentStamp when the active culture/RTL facts change at runtime.

CPU-render regression proof for the culture/RTL path that previously produced broad MAS render-fault placeholders. The gate renders representative text and DataGrid controls under live thread-culture switches without creating a parallel renderer.

Friend-only proof that DataGrid exposes a single official accessibility semantics snapshot for grid, columns, rows, cells, active selection/focus, and sort state without adding public SDK surface or renderer-side semantic paths.

Static lifecycle proof for MASApplicationSurfaceMaterialScope. The scope may outlive a hosted surface during application teardown, so it must not retain MASApplicationWindow or registered controls through direct strong fields or strong lists.

Governance proof for the public SurfaceMaterial gateway manifest. This gate closes the old stale-count gap by requiring the manifest's expected count, normalized entry count, ready gateway count, required-member coverage, duplicate detection, and real public reflection surface to agree with each other.

Reflection-based SDK surface review for DataGrid/DataView before long-term API freeze. It proves that rows/columns remain externally read-only, mutation occurs through intentional methods, event contracts stay standard .NET events, runtime reset switches do not leak into DataGrid, and UI-thread work is tied to official control runtime services.

Phase-12 residual proof for DataGrid/DataView/Surface review items DG-R01..DG-R04. It keeps the fixes inside existing Nexamas UI-owned gateways: surface material scope lifecycle, DataGrid/DataView public API boundary, event reentrancy guards, and 100k DataView projection/summary pressure.

Phase-13 residual diagnostics/quality proof for DIAG-R01..DIAG-R04.

The gate targets SDK-launch blockers: retained fault windows must summarize overflow, process-wide strictness switches must be scope-restored, release disk logs must rotate, and release evidence must distinguish GATE-CERTIFIED from DECLARED-ONLY routes.

Proves Phase-14 / LOC-R01..LOC-R04 residual Localization/RTL SDK readiness: UI layout direction is separated from content text direction, catalog preview rendering is bounded, keyboard/accessibility semantics are explicit, and runtime RTL mutations officially rebase input geometry.

Phase-15 residual proof for VIRT-R01..VIRT-R06. The probes target SDK-launch blockers in the shared virtualization foundation: huge-offset precision, fractional-DPI invalidation, explicit large-summary pressure, fast-scroll plan pressure, tile-grid fallback hit-test visibility, and off-window accessibility navigation over realized-only rendering.

Friend-only governance gate for runtime fault developer visibility and strict mode.

This gate does not require an empty runtime fault channel. Existing faults are valid diagnostic evidence. The gate proves that faults can be summarized through the official channel and that strict swallowed-exception mode can be enabled and restored safely.

Commercial-readiness proof that runtime catch-site diagnostics are not limited to synthetic record formatting. The gate exercises the real MASExceptionSilencer boundary helpers used by render, input, and lifecycle catch sites and proves that each path reaches the retained runtime-fault channel with the expected severity/category classification.

The whole-repository source-contract gate in Run-NexamasUITestSuite.ps1 guards the static catch-site classification policy. This runtime gate proves the live channel semantics for the three catch-site families that were previously represented only by synthetic records.

Commercial-readiness proof that failures inside the diagnostics machinery itself do not escape only through Debug/Trace and do not recursively re-enter failing subscribers.

The gate exercises the real diagnostics subscriber boundary and the release diagnostics write-failure path. Both failures must be retained in the official runtime-fault channel and visible through the public MASApplication.Diagnostics snapshot.

Commercial-readiness proof for the public diagnostics snapshot gateway.

The gate proves that SDK consumers can read structured diagnostics through MASApplication.Diagnostics without receiving Friend-owned runtime fault records, mutable channels, or source-location details.

Friend-only gate that proves MAS time/motion ownership is centralized enough for deterministic diagnostics without turning every approved host/input timer into a false production blocker.

Friend-only documentation/sample evidence row for product controls. This is a governance claim, not a runtime documentation reader and not a public API.

Central friend-only manifest that states where product-control documentation, consumer-safe sample notes, and evidence-pack boundaries live. The manifest records both CompactPreview documentation boundaries and targeted ProductionReady documentation boundaries.

Verifies that the eight product controls have an explicit documentation, sample, and evidence-pack declaration before any ProductionReady promotion rule may treat documentation as complete.

Commercial-readiness evidence gate for measured product-control runtime benchmark coverage. It proves the official proof paths are measurable and complete, without enforcing marketing performance thresholds.

Commercial-readiness evidence gate for product-control benchmark baseline capture and threshold policy. It applies internal guardrails to the official measured-runtime proof paths without creating public performance claims.

Friend-only quality evidence certification labels used by release reports and gates.

DECLARED-ONLY means the evidence route is documented but not independently executed by a gate. GATE-CERTIFIED means a source/runtime/performance gate executes the proof and can fail the release.

Release-freeze evidence declaration for the product-controls CompactPreview closure pack. It records documentation routes and evidence keys without reading files or exposing public APIs.

Central release-freeze evidence manifest for the product-controls hardening plan.

Release-freeze evidence lockdown gate for the product-controls CompactPreview closure pack. It validates declared evidence routes and stage boundaries without opening production APIs.

Immutable closure snapshot for the product-controls hardening plan. This snapshot verifies promotion-aware governance across CompactPreview and ProductionReady control boundaries.

Final commercial-readiness closure gate for the product-controls hardening plan. This gate is promotion-aware: preview controls must keep blockers, while ProductionReady controls must pass the declared promotion gates.

Friend-only evidence row for product-control keyboard and accessibility stress coverage. This is not an OS accessibility provider and not a public automation contract; it proves that each CompactPreview product control has a governed focus/keyboard expectation, a stressable navigation/state path, and a product-readable state summary.

Aggregate report for friend-only product-control keyboard/accessibility stress evidence.

Friend-only gate for product-control keyboard and accessibility stress evidence. It avoids public API expansion and does not claim screen-reader/provider completion. The proof uses each control's official selection/state operations, architecture keyboard/focus contract, and product-readable SummaryText/LayoutModeText surfaces.

Friend-only runtime hardening proof for root input/focus fixes that must hold for SDK consumers. The gate deliberately avoids WinForms handles and rendering; it exercises the official internal control focus/capture services with synthetic controls so external hook faults cannot leave stale capture, half-committed focus state, or DPI-dependent pointer target drift.

Runtime proof that Motion frame consumers are isolated by their owning host clock.

The probes intentionally avoid creating WinForms windows. They exercise the same internal host-scoped clock objects that MASSkiaFrameScheduler owns, plus the MASControlRuntimeServices binding used by attached controls to resolve their scheduler-owned clock.

Runtime pressure proof that host-scoped Motion clocks advance only their own consumers at 1k/10k scale and never create global per-paint pressure across hosts.

Runtime proof for live reduced-motion policy mutation while a Motion runner is active. Active runners keep their immutable plan; newly created plans immediately honor the new policy, and host-clock registration remains balanced.

Runtime proof that Theme/DPI/RTL/Culture mutations during an active Motion runner travel through the host runtime-environment coordinator and do not detach, cross-advance, or corrupt the active host clock.

Diagnostic category for control-specific production gaps. These values are governance labels only and do not expose public feature switches.

Closure state for a production gap. Planned and InProgress are valid for CompactPreview controls, but ProductionReady controls may only keep Closed gaps with evidence references.

Friend-only row describing a concrete control-specific gap that must be closed before ProductionReady marketing is allowed.

Central manifest for the remaining control-specific production gaps. This is intentionally separate from the readiness matrix so that CompactPreview controls can carry explicit, auditable blockers without pretending those blockers are already closed.

Friend-only gate for the remaining control-specific ProductionReady gaps. It passes for CompactPreview when gaps are explicit and owned, but it blocks ProductionReady for a control until that control's gaps are closed with evidence keys.

Friend-only proof that the Phase-1 hosting gaps were closed through real MASControlBase RegisterChild/UnregisterChild lifecycles inside the product controls, not through Showcase wrappers or native-panel shortcuts.

Friend-only proof for Targeted Closure Phase 2. It closes DashboardGrid's internal provider-refresh evidence path and MasterDetailView's empty/error visual-state foundation without exposing public adapters or promoting either control to ProductionReady.

Friend-only proof for Targeted Closure Phase 3. It closes MasterDetailView's bounded master-item virtualization evidence and SplitView's keyboard splitter contract without exposing public adapters, creating wrappers, or promoting either control to ProductionReady.

Friend-only proof for Targeted Closure Phase 4. It closes the remaining route/shell-boundary gaps for AppLayout, MasterDetailView, and SplitView by proving that each control exposes explicit host-facing boundary evidence without becoming a router, page host, public adapter, or native shell.

Friend-only closure gate for Targeted Closure Phase 5. It closes the DashboardGrid public-provider-adapter policy gap and the AppLayout/SplitView host-adoption proof gaps without creating a router, native shell, public adapter, or external provider surface.

Friend-only closure gate for Targeted Closure Phase 6. It closes DashboardGrid keyboard/a11y resize thresholds and AppLayout/SplitView real host-adoption sample evidence without opening public APIs, building a router, or moving native shell/page-host ownership into product controls.

One product-control readiness row. This deliberately separates architecture registration from commercial readiness so a component can be addable/renderable without being marketed as a full production system.

Friend-only commercial readiness matrix for the product-size controls called out by Phase 0. It is intentionally diagnostic: it does not create controls, mutate the registry, render scenes, or expose public feature switches.

One friend-only commercial readiness finding. The finding is intentionally small and data-only so the readiness gate can be consumed by certification tooling without exposing diagnostics or mutable runtime state as public API.

Aggregated friend-only commercial readiness report for the Phase-1 product-control hardening work. It separates preview-governance health from production marketing readiness so compact controls can remain addable without being over-sold.

Aggregate friend-only gate for the product-size controls that were hardened in Phase 1. The gate does not render, create public APIs, or write files. It proves that the declared matrix, targeted production promotions, and the dedicated component probes agree with each other.

Friend-only architecture relation coverage probe for the Phase-1 product control set.

The gate verifies declared component-graph coverage only. It does not promote a preview control to production and it does not treat relation coverage as virtualization or performance evidence.

Advanced helper that loads and renders embedded Skottie/Lottie animations on a Skia canvas.

This type is rendering utility infrastructure only. It does not own host invalidation, global timing, input routing, or ThemeContext state.

Internal base for wrappers that bind a single Skia MASControlBase instance to a ThemeHost.

The binder owns attach/detach lifetime for the wrapped control only. It must not own global host routing, FloatRuntime ownership, or independent theme resolution.

Owns the per-root-host Framework services and disposes them in host lifecycle order.

This is raw host-composition infrastructure. SDK code should use MASApplicationWindow facades such as Controls, Services, Shell, Theme, Rendering, Geometry, and Input instead of consuming this service bag directly. It remains Friend-only core composition infrastructure behind MASApplicationWindow. It is not a public SDK entry point.

Optional bridge contract for Skia controls that expose owned native WinForms controls.

Implementers remain hosted by Framework; consumers must not register native controls directly.

Host-owned bridge for Composition pointer routing.

The input routing pipeline owns global ordering, while this bridge owns the Composition router delegates and capture lifetime. Keeping this state out of the coordinator prevents Composition scroll behavior from becoming hidden root-input state.

Host-owned bridge for ApplicationSystem workspace scroll routing. It stores only delegates for the currently active MASApplicationWindow.Pages layout session and leaves scroll behavior to that owner.

Host-owned bridge between root input and the FloatRuntime.

The coordinator decides Float priority. This bridge owns FloatRuntime context lookup, safe routing calls, and modal/pointer ownership checks so the root input coordinator does not need to know FloatRuntime internals.

Host-owned input bridge for the standard application MainMenuBar chrome slot. The menu bar stays a normal MASControlBase for rendering and command behavior, while RootHost/Shell own its full-width placement below the TopBar.

Contract implemented by every host-level input owner that participates in root routing.

Participants own their own hit-testing, capture, keyboard, and pointer state. The root coordinator only feeds native input into the routing pipeline; it does not encode per-system routing policy.

Stable priority order for host input participants. Lower numeric values are routed before higher values.

Result returned by an input participant for one routed input event.

The coordinator/pipeline interprets these flags generically. Participants do not call each other directly, which keeps ownership local to the system that handled the input.

Declarative routing capabilities for an input participant.

The pipeline reads capabilities instead of hard-coding concrete participant names. Values may be dynamic when a participant owns capture, modal input, or hover state. WheelFallbackOnly marks host/page scroll participants that must run only after hovered controls have declined the same wheel event, while captured/modal participants still keep first refusal.

Participant that owns host-level Composition scroll routing and capture. Free wheel input is a fallback after hovered controls; captured Composition scroll still keeps first refusal.

Participant that routes MASApplicationWindow.Pages workspace-scroll input as the host/page wheel fallback. Scrollbar drag/capture still keeps first refusal; free wheel input waits until hovered controls decline it.

Participant that owns background controls-layer pointer, keyboard, text, and IME routing.

Participant that gives FloatRuntime first refusal over pointer, keyboard, text, and IME input.

No-op base implementation for host input participants.

Ordered participant pipeline for one root host input stream.

This is the architectural owner of routing order. The root coordinator is only the native WinForms/SKGLControl entrypoint; per-system behavior lives in participants.

Normalized pointer event payload used by the host input routing pipeline. XPx/YPx are raw SKGLControl client coordinates from WinForms input. Participants that hit-test logical control bounds must convert through MASThemeContext.Dpi before comparing with surface-pixel rectangles. Composition participants may convert to logical coordinates through the host viewport coordinator instead.

Participant that owns TopBar hit-testing, hover, and capture routing.

Input participant for the host-owned MainMenuBar chrome slot. It runs after TopBar and before application content so menu-strip pixels never leak to pages.

Native input entrypoint for one SKGLControl-backed MAS root host.

This type hooks WinForms events, raises host-level pointer notifications, and forwards normalized input to the participant routing pipeline. It intentionally does not encode FloatRuntime, TopBar, Composition, or ControlsLayer routing policy.

True when this coordinator has attached WinForms/SKGLControl input handlers.

Attaches a host-owned Composition scroll router without making Layout part of the normal control input pipeline.

Attaches a host-owned ApplicationSystem workspace-scroll router.

Attaches this coordinator to the native SKGLControl input stream. Used by MASApplication.CreateWindow(autoHookPointerInput:=True).

Detaches native input hooks while keeping the coordinator usable for explicit/manual routing calls.

Used by root-level services such as tooltips to avoid reacting to background controls while a modal float owns the pointer surface.

Used by root-level services such as tooltips to avoid reacting to background controls while any interactive or outside-swallowing Float owns the pointer surface.

NativeWindow transport hook used by the root input coordinator for Win32 messages.

The sink only forwards messages to the supplied handler. It must not contain text, focus, modal, or ControlsLayer policy.

Owns the root-host top-bar attachment lifecycle for one MAS host.

MASSkiaRootHost remains the composition root, but this coordinator owns the mutable top-bar binding details: request-invalidate subscription, window attach/detach, ThemeContext provider, FloatRuntime handoff, and input-router registration. Keeping that lifecycle here prevents the root host from becoming the implementation owner of TopBar behavior.

Owns the root-host lifecycle for the standard application MainMenuBar chrome slot. Placement is supplied by MASApplicationWindowShell; MASMenuBar remains a reusable control and does not discover the window, TopBar, or screen size by itself.

Builds the per-host Framework service graph behind MASSkiaRootHost.

This builder centralizes the low-level construction order for ThemeHost, ControlsLayer, WinForms/native-control sync, runtime invalidation, and root input. MASSkiaRootHost owns the resulting composition, but it no longer embeds the detailed Controls/Theme/Input construction recipe directly.

MAS-owned SKGLControl surface used by the root host.

SKGLControl is a native OpenGL child window. During WinForms resize/maximize the operating system may expose the OpenGL back buffer before the next Skia frame is presented. MAS owns the whole surface and always paints a complete frame, so this control suppresses native erase and primes the GL back buffer with the same base clear color used by the render driver whenever the native child surface is resized or recreated.

Clears and swaps the native OpenGL back buffer immediately during a resize turn. This is not an alternate MAS renderer; it is a host-owned transient buffer guard for the short window between native child-surface resize and the next Skia frame.

Owns the WinForms surface attachment for one MAS root host.

MASSkiaRootHost coordinates host subsystems, but the native SKGLControl lifecycle is kept here: creation, adding/removing from the owner form, z-ordering, coordinate conversion, and disposal. This keeps window-level native-control glue out of the root host's architectural responsibilities.

Owns root-host ThemeHost runtime wiring for one MAS surface.

The ThemeHost itself remains the theme snapshot authority. This coordinator owns only host-specific wiring: invalidation subscription, DPI/context refresh for Composition, and safe DPI retrieval. The root host delegates to this type instead of embedding theme refresh policy directly.

Ensures that Composition measure/arrange reads a fresh ThemeContext/DPI snapshot before Apply.

Resolves the real per-monitor Windows scale from Control.DeviceDpi. In a PerMonitorV2-aware process both WinForms client dimensions and the OpenGL framebuffer are already expressed in device pixels, so their ratio is normally 1.0 and must not be used as the operating-system DPI scale.

Host-owned runtime environment observer for one MAS Skia surface.

ThemeHost remains the owner of theme/DPI snapshots; Localization remains the owner of culture facts; RootHost remains the owner of retained layout refresh and invalidation. This coordinator joins those facts at the host boundary so runtime DPI, Font, RTL, and culture changes trigger the same retained layout refresh path as theme and size-profile changes, without creating a parallel renderer or cache path.

Centralizes host viewport and coordinate conversion helpers.

RootHost exposes these methods for compatibility, but the calculation policy lives here so that Composition, FloatRuntime, dialogs, and application facades all read the same host-scoped viewport.

Owns host-scoped Composition runtime wiring for one MASSkiaRootHost.

Composition remains its own system. This coordinator binds it to host input, rendering, rebuild, and public facades without forcing MASSkiaRootHost to store pointer routing policy or Composition runtime lifecycle details directly.

Owns the host-scoped FloatRuntime instance and its root input binding.

The root host remains the compatibility access point for FloatRuntimeCore. This coordinator owns the mutable runtime lifecycle: creation, default descriptor registration, input attachment, invalidation subscription, and available-bounds refresh.

Owns the root-host render pipeline composition for one SK surface.

MASSkiaHostRenderDriver still owns low-level PaintSurface mechanics. This coordinator owns the host render stages: controls, Composition scroll indicators, FloatRuntime overlay rendering, surface-size reporting, and render-stage events. RootHost delegates rendering through this type.

Owns root SKGLControl event wiring and setup lifecycle.

The root host should not own PaintSurface/Resize/PreviewKeyDown handler wiring directly. This coordinator keeps native event hookup, input-key preview policy, and first setup/rebuild in one host-scoped lifecycle owner.

Advanced composition root for one WinForms/SKGLControl backed MAS host.

Beginner SDK code should enter through MASApplication/MASApplicationWindow. The root host wires Framework services together and delegates architecture, float, and theme rules to their owning systems instead of mutating their internal state directly.

Advanced compatibility access to the hosted SKGLControl. Beginner SDK code must use MASApplicationWindow facades instead of owning or reading this control directly.

Per-host Composition runtime. It owns layout Apply/Detach for this host only.

Shortcut to the per-host Layout facade. Creates layout nodes and can apply them to this host.

Shortcut to the per-host Page facade. Creates page recipes and can apply them to this host.

Shortcut to the per-host Screen facade. Creates screen recipes and can apply them to this host.

Binds ApplicationSystem-owned workspace scroll input to the host routing pipeline without exposing raw input ownership to Showcase or individual pages.

Presents semantic CommandActions overflow through the host-owned dropdown service. The command layout decides which actions overflow; the root host alone owns popup creation, anchoring, and command invocation so product screens never wire these details manually.

Ensures that Composition measure/arrange reads a fresh ThemeContext/DPI snapshot before Apply. This keeps layout from being calculated from a stale or missing host surface context.

Converts a screen point to the hosted MAS surface client pixel coordinate space without exposing SKGLControl.

Canonical retained MASSize/MASLayout refresh entry used by profile, theme, and control fact changes. Application sessions still listen to SizeLayoutRefreshRequested, while Composition is rebuilt here because it does not subscribe to that event. This keeps all retained owners on one host-owned lifecycle without introducing a second Composition refresh path.

Presents one already-requested frame on the owned Skia surface without pumping arbitrary WinForms messages. This is intentionally Friend-only root-host plumbing for MAS-owned transient surfaces such as operation progress: it invalidates the SK surface through the official frame scheduler and then asks only that surface to process its pending paint. It does not run arbitrary message pumping, form-wide refresh, or any external layout/dispatcher path.

Advanced raw viewport and rectangle helper utilities for host-level integrations.

Normal SDK code should prefer MASApplicationWindow.Geometry for window and DPI conversions. This type remains public for advanced extensions and low-level geometry helpers that do not have a one-to-one facade replacement.

Single host-owned policy for the opaque base color used by the Skia render clear, WinForms native background, and OpenGL resize priming. This prevents transient white frames when a dark/custom MAS theme is active while keeping the render driver as the only visual owner of the surface.

Host-owned SKCanvas state guard for render-pipeline stages. Render stages may translate, scale, or clip while drawing, but those mutations must never leak into later stages. The guard restores the host canvas state even when a stage throws.

Central render-failure diagnostics bridge for host rendering stages.

The render driver may rate-limit visual/log presentation through MASExceptionSilencer, but it must not suppress repeated publication to the runtime fault channel. Repeated render failures are therefore forwarded on every occurrence so diagnostics counters and developer tooling can distinguish a transient fault from a persistent failing stage.

General render driver for a single SKGLControl host. Responsibilities: - obtain reliable surface pixel size from canvas clip bounds - ensure ThemeHost DPI/context from WinForms DeviceDpi with a legacy surface-ratio fallback - optionally sync input state before rendering - run render pipeline callbacks in strict order: 1) before-content 2) content 3) after-content

This is raw render-pipeline infrastructure. SDK code should use MASApplicationWindow.Rendering, which exposes MASApplicationRenderContext and hides ThemeContext/SKGLControl plumbing.

Resolves the actual monitor scale from the hosted WinForms control. The surface/control pixel ratio remains only a fallback for legacy or offscreen hosts where DeviceDpi is not available yet.

Internal handle for a tooltip registration created through the root-owned MASTooltips service. Disposing the handle unregisters the target without exposing the internal coordinator implementation.

WinForms-facing adapter around the normal Skia ControlsLayer.

This bridge must remain host integration code only; global float and modal routing belongs to MASSkiaRootInputCoordinator and MASFloatRuntime.

Synchronizes optional native WinForms controls exposed by Skia controls.

The bridge is isolated so normal Framework rendering and input do not depend on native controls.

Internal WinForms focus helper used when Framework must move native focus back to the host surface.

This utility only manipulates WinForms focus/capture. It must not decide MAS control focus ownership, FloatRuntime policy, or text-input routing.

Per-SKGLControl frame scheduler that owns the transition from many logical invalidation requests to a bounded number of native surface invalidations.

The scheduler deliberately stays below the public SDK. Controls, FloatRuntime, TopBar, and application facades may request a visual update, but only this host-scoped scheduler decides when to post a dispatcher turn and when a native SKGLControl.Invalidate is still pending. This prevents a pointer-move flood from producing many queued native invalidations before PaintSurface has had a chance to present the already requested frame.

Requests a rendered frame. Normal requests are coalesced behind one dispatcher post and one pending native surface invalidation. Immediate requests may bypass the dispatcher post only when the caller is already on the owning UI thread; off-thread requests are posted or dropped safely.

Marks that PaintSurface is currently presenting a frame. Requests made from render callbacks are kept for the next frame instead of posting recursively from inside the current paint.

Completes the native surface frame. Only now may a previously pending native invalidate be considered consumed, which is the critical difference from the old BeginInvoke-only coalescing.

General runtime infrastructure for a single Skia host surface. Responsibilities: - host-owned frame scheduling and coalesced invalidation - immediate invalidation during capture/drag without native invalidate flooding - resize pulse - rebuild trigger when client size changes

This is Framework runtime plumbing, not the normal SDK entry point. Application code should use MASApplicationWindow.Refresh together with the Rendering and Geometry facades. This type remains Friend-only host runtime plumbing behind MASApplicationWindow.

Owns TopBar input state for one SKGLControl-backed root host.

MASSkiaInputRoutingPipeline owns ordering. This bridge owns TopBar hit testing, hover/capture state, pixel rect conversion, and TopBar pointer dispatch. Keeping these responsibilities outside the coordinator makes the remaining input pipeline easier to reason about and test in isolation.

Coordinates root-host float service creation and request construction.

MASSkiaRootHost remains the host identity required by existing request builders, but message-box, file-explorer, toast, and dropdown float service construction is centralized here. This reduces RootHost service-orchestration responsibilities while preserving existing public and Friend compatibility methods on the host.

Immutable diagnostic snapshot of the current MAS time source. This is Friend-only evidence, not a public clock API.

Central Friend-owned time provider for MAS internals. It keeps wall-clock, interaction ticks, and high-resolution visual timestamps behind one official gateway so product controls do not need to read DateTime/Environment/Stopwatch directly when deterministic diagnostics are required.

Deterministic diagnostic override for the Friend-only MAS time provider.

Official Friend-owned visual/frame clock helpers. The class does not schedule frames; scheduling remains owned by the host frame scheduler and Motion frame clock.

Official Friend-owned interaction timing helper for double-click windows, caret blinking, typing merge windows, keyboard-search reset windows, and other input semantics that should not create visual frame ownership.

Friend-only timing ownership declaration used by the commercial readiness gate.

Central Friend-only manifest that declares who owns time, visual frame timing, interaction timing, and the few approved timer exceptions.

Owns pointer-selection gesture state for MAS text-input controls.

This class does not mutate text. It tracks hover, press, drag-selection, double-click memory, and cancellation state. The owning control remains responsible for translating hit-test points into text indexes and applying those indexes through MASTextInputController.

Owns renderer and painter instances used by MASInputBoxSkiaBase.

Rendering resources are long-lived collaborators with disposal requirements. Keeping them behind this aggregate prevents the public control base from directly owning every painter/renderer object and keeps disposal centralized.

Owns the mutable SKPaint clone used by text-input render, hit-test, and caret paths.

DPI-01 contract: MASTypography may create short-lived public clones, but a text input must not allocate an undisposed native SKPaint clone on every render, hit-test, or caret blink. This cache keeps one control-owned mutable clone, replaces it only when the effective paint signature changes, and disposes the previous clone deterministically.

Owns Win32 IME bridging and IME candidate-position resolution for MAS text-input controls.

The visual control supplies the current layout primitives, while this collaborator owns the IME bridge call, command dispatch boundary, and caret-based candidate anchor calculation. This keeps MASInputBoxSkiaBase from depending directly on Win32 IME message translation policy.

Owns multiline mode, wrapping, and vertical scroll state for MAS text-input controls.

Multiline mode affects input commands, layout snapshot construction, viewport clamping, and rendering. This collaborator centralizes the mode/scroll state so MASInputBoxSkiaBase does not store low-level multiline viewport fields directly. The owning control still performs layout because it owns ThemeContext and paint creation.

Owns keyboard, text, and IME composition command dispatch for MAS text-input controls.

This collaborator wraps MASTextInputPipeline so MASInputBoxSkiaBase no longer owns the editing pipeline directly. The control still supplies the short-lived MASTextInputContext because that context is made of UI callbacks.

Owns clipboard behavior for MAS text-input controls.

MASInputBoxSkiaBase exposes the public ClipboardService property, but this collaborator owns copy, cut, and paste semantics so that clipboard access, read-only checks, MaxLength capacity checks, and input normalization are not embedded in the visual control base class.

Short-lived bridge object created by the UI layer for exactly one text-input operation.

This context exposes only the services needed by MASTextInputPipeline. It must not be stored, cached, or reused across input events.

Gets or sets the controller that owns command execution and state mutation.

Gets or sets whether the owning control is enabled.

Gets or sets whether the owning control currently has keyboard focus.

Gets or sets whether editing operations should be blocked while navigation/copy remain allowed.

Gets or sets the callback used by the pipeline to request keyboard focus from the UI layer.

Gets or sets the callback that returns remaining text capacity after MaxLength rules.

Gets or sets the callback that applies control-specific input filtering and normalization.

Gets or sets the callback that copies the current selection.

Gets or sets the callback that cuts the current selection.

Gets or sets the callback that pastes current clipboard text.

Gets or sets the callback used for visual caret navigation such as Left/Right in RTL-aware text.

Optional IME hook for beginning a composition session.

Optional IME hook for updating an active composition session.

Optional IME hook for committing composition text into the document.

Optional IME hook for cancelling the active composition session.

Requests keyboard focus when the control does not already have it.

Returns remaining capacity using the UI-provided capacity callback.

Normalizes incoming text through the owning control's filter.

Immutable snapshot of the text-input document state used by undo/redo and command history.

This object is data only. It must not perform editing, layout, rendering, or UI invalidation.

Gets the captured raw text.

Gets the captured caret index in raw text coordinates.

Gets the captured selection start in raw text coordinates.

Gets the captured selection length.

Gets the captured selection anchor. A value of -1 means no active anchor.

Gets the captured horizontal scroll offset in pixels.

Creates a new immutable text-input state snapshot.

Compares this snapshot with another snapshot using text, caret, selection, and scroll state.

Optional syntax-colored renderer for multiline text snapshots. It keeps selection and caret behavior compatible with MASTextMultilineRenderer.

Optional syntax highlighter contract. Implementations must be pure: no state mutation, no UI access, no controller access.

Small built-in highlighter useful for logs/code-like snippets. It recognizes keywords, numbers, quoted strings, and line comments. The scanner is line-aware so comments do not accidentally color the rest of a multiline document.

Describes the preferred font families used by MAS text input controls. This object is intentionally UI-level and optional. It only chooses a preferred typeface for the control. MASShapedText remains responsible for glyph fallback when the selected family does not contain a requested character.

Arabic profile optimized for modern UI text. Good default for forms and controls.

Arabic profile optimized for comfortable reading and longer Arabic text. Uses common Naskh-style fallbacks when installed.

Arabic profile optimized for classic Windows Arabic fonts. Useful when Noto fonts are not installed.

Latin profile optimized for modern Windows UI text.

Latin profile optimized for longer reading text.

Monospace profile suitable for code, logs, JSON, SQL, and syntax highlighting.

Optional renderer for syntax-colored single-line text. It keeps the original selection/caret rendering by delegating first to MASTextInputRenderer when highlighting is not safe/applicable.

Describes the optional validation visual state of a text input control.

Owns MAS text-input layout snapshot caching for MASInputBoxSkiaBase.

This collaborator keeps cache invalidation/versioning, paint signatures, multiline paragraph layout, and caret-layout synchronization out of the public input control base class. The control remains responsible for public API and events; this class is responsible only for producing a current, reusable layout snapshot.

Stores validation presentation state for MASInputBoxSkiaBase.

Validation message/state/indicator are visual concerns used by the input renderer and higher-level form systems. Keeping them in a small value-owning collaborator prevents MASInputBoxSkiaBase from owning validation storage and rendering policy directly while preserving the existing public properties.

Owned text metric gateway shared by MASSize/MASLayout and TextInput geometry. Width is resolved through MASShapedText so measuring follows the same HarfBuzz, RTL, and system-font fallback decisions used by rendering. Vertical metrics are resolved through SKFont.Metrics instead of obsolete SKPaint metric APIs.

Short-lived text-width measurement session for layout/rendering code that measures the same text candidates repeatedly while wrapping or fitting copy. The session does not own the SKPaint and must not be kept after the active layout/render pass.

Official shaped text measurement gateway shared by wrapping, ellipsis fitting, size-layout measurement, and the multiline paragraph renderer. Contract: - Width decisions use MASShapedText, never raw SKPaint.MeasureText or simple font width. - Wrap segments are reusable by render layout and measurement layout so DPI-05 has one paragraph/wrap decision source. - Ellipsis fitting uses the same shaped width path so DPI-06 cannot drift for Arabic, CJK, emoji, or mixed-script text.

Abstract clipboard service used by MAS text input components.

Text-input core classes depend on this abstraction instead of WinForms directly. Implementations may use WinForms, a test clipboard, or another platform clipboard.

Returns True when the clipboard currently contains text that can be pasted.

Reads clipboard text. Implementations should return an empty string when no text is available.

Writes text to the clipboard. Null values should be treated as an empty string by implementations.

Single internal resolver for Nexamas UI runtime setting files. It is storage-only: it never participates in sizing, layout, rendering, or window placement decisions.

Immutable internal stamp for cache freshness across MAS runtime environment facts that change layout or measurement. It centralizes Theme, DPI, density, font, localization, RTL, and text-direction revisions so render/layout caches do not keep stale snapshots after the active environment changes.

Friend-only builder for the official MAS runtime environment stamp. Controls and internal systems use this builder instead of inventing private Theme/DPI/Font/Localization/RTL cache keys.

Internal support state used by the Nexamas UI compatibility matrix.

Immutable Friend-only row in the Nexamas UI supported-runtime compatibility matrix.

Friend-only report describing the supported Nexamas UI runtime envelope.

This report is descriptive evidence only. It does not probe the host machine, mutate DPI, mutate culture, create controls, draw, run captures, or select runtime behavior.

Builds the official internal Nexamas UI compatibility matrix used by gates, docs, and release proof.

Internal performance-budget category used by runtime diagnostics, frame-pressure accounting, and commercial gates.

Immutable internal runtime budget contract for a measured Nexamas UI performance path.

Internal cache-pressure bucket used by MASPerformanceSystem. It identifies only MAS-owned cache families; it is not a public telemetry contract and it does not move cache ownership away from the runtime systems.

Internal runtime-consumer bucket used by MASPerformanceSystem to separate heavy-control pressure from host scheduler pressure. It is a Friend-only diagnostic contract, not a public telemetry API.

Immutable Friend-only runtime performance snapshot. It captures aggregate facts only; it does not expose telemetry publicly and it does not move rendering, scrolling, cache, or async ownership into PerformanceSystem.

Internal scenario categories used by the Performance budget matrix. The values describe runtime pressure scenarios, not UI controls or render owners.

Internal PASS/WARNING/FAIL verdict for a measured performance scenario.

Immutable internal budget row for a runtime performance scenario.

Immutable internal delta snapshot captured around a performance scenario.

Immutable internal result produced by the Performance scenario harness.

Central internal budget matrix for measured runtime scenarios. The matrix is intentionally conservative and is not a renderer, scheduler, optimizer, or public telemetry API.

Internal scenario harness that measures MASPerformanceSystem snapshot deltas around caller-owned runtime work.

The harness does not create controls, schedule frames, draw, run background work, or optimize anything. It only captures before/after snapshots from MASPerformanceSystem and evaluates them through the official budget matrix.

Official internal baseline benchmark rows captured before new commercial feature work.

Immutable measured baseline row for one official Nexamas UI performance benchmark scenario.

Immutable collection of measured baseline benchmark rows for regression comparison.

Internal decision states for comparing an already-captured current benchmark report against an accepted baseline report.

Friend-only tolerance policy for baseline-to-current performance regression comparison.

The policy is evidence-only. It does not execute benchmarks, sample frames, inspect controls, or mutate runtime state.

Immutable comparison row for one official baseline benchmark kind.

Immutable performance-regression decision comparing current measurements against an accepted baseline report.

Compares two already-built baseline benchmark reports without executing benchmark work.

This comparator is the official PerformanceSystem-owned regression decision route. It does not create controls, render, capture, switch themes, read source files, invoke external scripts, or introduce a parallel benchmark engine.

Friend-only product-control benchmark identities used by the commercial readiness evidence pack. These are not public API switches and do not imply ProductionReady status.

Immutable measured runtime row for one product-control proof path. The row captures elapsed time and managed-memory delta only; it does not set production thresholds.

Immutable benchmark report for the eight governed product controls. It proves measured evidence exists without converting preview controls into ProductionReady controls.

Measures the official proof paths for the eight product-size controls. The runner reuses existing component gates instead of creating a parallel benchmark engine.

Friend-only evaluation status for product-control benchmark baseline/threshold policy. These values are diagnostics for readiness evidence, not public performance claims.

Immutable guardrail row for one product-control benchmark proof path. The values are internal readiness thresholds for supported benchmark capture, not public SLA numbers.

Immutable comparison between one measured runtime benchmark and its internal baseline threshold policy row.

Central internal benchmark baseline/threshold policy for the eight product-size controls. Thresholds are deliberately governance guardrails for proof-path capture; they are not public performance promises.

Immutable report for measured benchmark baseline capture and threshold-policy comparison.

Friend-only benchmark baseline capture and threshold policy evaluator for product controls. The policy consumes the official measured-runtime benchmark report and applies internal guardrails.

Internal status for a measured performance-remediation decision. The values are evidence states, not public SDK telemetry labels.

Immutable internal contract for targeted performance remediation. It prevents performance fixes from being recorded as vague cleanups by requiring measured scenario pressure, a root cause, an owner system, and proof before/after facts whenever a remediation is required.

This contract is not a public telemetry API. It does not execute fixes, mutate controls, render, schedule frames, or own cache behavior. It only describes the evidence required before a measured performance fix is accepted.

Internal release-certification status for the performance evidence manifest.

Immutable internal manifest certifying the complete performance release evidence chain.

This contract is not a public telemetry API. It does not capture scenes, run scenario harnesses, create controls, render, schedule frames, or mutate caches. It only records the final release certification facts derived from an already-built commercial-readiness decision.

Final internal closure state for the complete Nexamas UI performance governance chain.

Immutable internal closure manifest for the fully wired performance evidence chain.

This contract is not a public telemetry API. It does not execute proof scenes, run scenario harnesses, create controls, render, schedule frames, mutate caches, or inspect UI. It only records the final dead-path/governance closure facts derived from an already-built release-certification manifest.

Internal commercial-readiness status for the performance evidence chain.

Immutable internal decision summarizing whether the measured performance proof baseline is commercially usable.

This class is not a public telemetry API and does not execute scenarios, render, schedule frames, inspect controls, or own cache behavior. It only records the final governance decision derived from baseline evidence facts.

Friend-only runtime performance system for Nexamas UI budgets, counters, and observability snapshots.

This class does not schedule frames, render controls, optimize caches, or execute asynchronous work. Those responsibilities remain with their owning systems. MASPerformanceSystem is the single MAS-owned place where lightweight performance facts are recorded so diagnostics and gates do not become hidden performance owners.

Severity for the Performance/Diagnostics orchestration audit.

Performance/Diagnostics proof surfaces covered by the Quality orchestrator.

Immutable finding emitted by the Performance/Diagnostics orchestration audit.

Immutable report for the read-only PerformanceSystem and Diagnostics Dashboard orchestration proof.

Read-only Quality audit that validates the relationship between PerformanceSystem and the Diagnostics Dashboard. It does not mutate global counters, run benchmarks, render, schedule frames, create controls, or expose public telemetry.

Internal surface vocabulary used by the unified Command / Action System foundation.

Result status returned by the single command invocation route.

Immutable keyboard gesture owned by the Command / Action System foundation.

Immutable context passed to command handlers from button, menu, shortcut, toolbar, and future command surfaces.

Immutable command catalog row safe for audits, future CommandBar, and future CommandPalette.

Internal command definition. One definition may be presented by button, menu, shortcut, toolbar, CommandBar, or CommandPalette.

Immutable result returned by the Command / Action System single execution route.

Immutable evidence that one command is presented by one supported surface through the registry route.

Immutable audit snapshot for registered commands and their presentation bindings.

Unified internal registry that owns command definitions and binds them to button, menu, shortcut, toolbar, and future CommandBar / CommandPalette surfaces from one route.

The registry does not render UI, create forms, scan controls, record telemetry, or replace existing controls. Existing surfaces opt in by binding to this registry, then all invocation flows through TryExecute.

Internal lifecycle state for a command surface binding managed by the Command / Action System.

Immutable lifecycle evidence for a command binding route.

Internal weak lease used to detach command-owned Button and Toolbar surface hooks without adding public API.

Immutable lifecycle snapshot proving command bindings use weak routes and releasable Button/Toolbar hooks.

Friend-owned readiness vocabulary for the CommandPalette control route.

Evidence-only manifest proving MASCommandPalette consumes MASCommandRegistry as the single command catalog and execution route. It does not render, scan controls, install shortcuts, open a global hook, or execute commands.

Internal metric vocabulary shown by the read-only diagnostics dashboard foundation.

Read-only layout facts supplied by the owning layout/application surface.

The diagnostics dashboard does not scan controls, walk visual trees, mutate layout, or create UI. Layout owners may pass already-known counts through this contract so the dashboard can display them.

Internal baseline-awareness state used by the read-only diagnostics dashboard.

Immutable read-only summary of an already-built Baseline Performance Benchmark report.

This contract does not execute benchmarks or compare current measurements. It only projects the existing PerformanceSystem-owned baseline report into dashboard rows for engineering visibility.

Immutable metric row for the read-only diagnostics dashboard foundation.

Immutable read-only dashboard snapshot that joins existing render, layout, element, and virtualization facts.

Read-only diagnostics dashboard foundation builder.

This builder only joins existing MASPerformanceSystem, layout-owner, and VirtualizationSystem facts. It does not record counters, execute benchmarks, walk controls, create forms, render, allocate bitmaps, schedule frames, mutate UI, or expose a public telemetry API.

Internal host gateway for the Nexamas UI-owned Diagnostics Dashboard surface.

This gateway exposes a ready read-only page to Nexamas UI-owned surfaces only. It does not expose counters, mutable telemetry, benchmark execution, snapshot contracts, or a public diagnostics API. Runtime metrics remain owned by PerformanceSystem, VirtualizationSystem, and layout/application owners.

Attaches the official Nexamas UI-owned Diagnostics Dashboard to a MASApplicationWindow. External hosts receive a ready page and never read diagnostics contracts or invent telemetry rows.

Attaches the official Nexamas UI-owned Diagnostics Dashboard content to an existing Application page-builder scope such as MASApplicationWindow.Pages. The host supplies only the current MASApplicationWindow and MASApplicationLayoutPageBuilder; Nexamas UI still owns metric aggregation, product-readable rows, refresh behavior, MAS controls, and page layout.

Nexamas UI-owned internal Diagnostics Dashboard display surface.

The page consumes MASDiagnosticsDashboardBuilder only. It does not record counters, run benchmarks, query controls, walk visual trees, read files, create a telemetry API, or let demo code own diagnostics logic.

Internal contribution vocabulary accepted by the small Plugin / Module System foundation.

Readiness state for a module-registry snapshot.

Immutable description of one contribution offered by a module.

The contribution is metadata only. Pages, commands, settings sections, themes, and tools remain owned by their existing MAS systems; this row only records the official route that owns the contribution.

Immutable internal module descriptor for Nexamas UI-owned module registration.

Immutable evidence snapshot for the small Plugin / Module System foundation.

Small internal module registry for Nexamas UI extension metadata.

This registry does not load assemblies, scan folders, create pages, draw UI, mutate themes, own settings UI, or execute commands directly. Command contributions are registered into the official MASCommandRegistry route.

Internal normalized data-source change vocabulary shared by future item, hierarchy, matrix, agenda, and board adapters. It is evidence-only at this stage and does not expose a public binding engine surface.

Immutable internal record describing one normalized source mutation. Controls can consume this later without depending on collection-specific event args.

Friend-only list adapter that normalizes arbitrary enumerable data into stable-keyed snapshots and incremental mutation records. Heavy controls can later consume this through official binding gateways instead of owning ad-hoc provider paths.

Friend-only field definition for projecting stable-keyed agenda events from an IMASItemsSource snapshot. It deliberately covers event identity, title, start/end timestamps, and optional details only; recurrence, time-zone conversion, external calendar providers, and reminder transports remain outside MASAgendaView.

Friend-only dictionary-backed agenda event source record used by governance gates and future internal adapters. It avoids reflection-heavy test fixtures while keeping the public MASAgendaView API unchanged.

Friend-only field definition for projecting a stable-keyed IMASItemsSource snapshot into MASKanbanBoard columns and cards. It deliberately describes data shape only; workflow persistence, task engines, remote providers, and background sync remain outside the visual board.

Friend-only dictionary-backed source record used by governance gates and internal adapters to feed a Kanban source without reflection or external workflow/task providers.

Friend-only field mapping used by MASMasterDetailView source projection. It maps a stable keyed items-source snapshot into visual master/detail item fields without introducing object inspection, routing, storage, or application provider ownership into the control.

Friend-only dictionary-backed source record used by governance gates and internal adapters to feed MASMasterDetailView without reflection-only tests or external object-inspector ownership.

Friend-only aggregate modes used by product controls that project an IMASItemsSource into a compact pivot matrix. It is intentionally small and deterministic; OLAP/query engines remain outside Nexamas UI controls.

Stable field definition for building a compact pivot projection from an IMASItemsSource snapshot. The definition names one row field, one column field, one optional numeric value field, and the aggregate to apply.

Friend-only dictionary-backed source record used by gates and internal adapters to feed a pivot source without reflection or external providers.

Friend-only immutable multi-level pivot grouping path. It normalizes group segments into deterministic display labels and stable keys without adding query, OLAP, Excel, storage, or provider ownership to PivotTable.

Friend-only drilldown entry mapping one source item to the projected pivot cell that consumed it. The original item is preserved for diagnostics and future export adapters without exposing a query engine.

Friend-only immutable cell in a compact pivot export snapshot.

Friend-only immutable snapshot of the visible pivot matrix. It is an export model, not an Excel/PDF writer.

Friend-only options for deterministic text export from a PivotTable export snapshot. This is intentionally a writer policy over an in-memory string, not a file, Excel, PDF, clipboard, or storage lifecycle.

Friend-only deterministic delimited-text writer for MASPivotExportSnapshot. It writes to memory only so product controls do not own files, dialogs, clipboard, Excel, PDF, or persistence boundaries.

Internal vocabulary for the first simple ViewModel binding foundation.

Simple binding direction policy for the first Nexamas UI ViewModel binding foundation.

Immutable status vocabulary used by ViewModel binding snapshots and gates.

Internal lifecycle vocabulary for binding session ownership, command release, loop guard, and cache evidence.

Immutable evidence row for one lifecycle fact in a ViewModel binding session.

Internal weak command lease connecting ViewModel command members to CommandActionSystem without keeping the ViewModel alive after disposal.

Immutable snapshot proving binding sessions have disposal, unsubscribe, weak-command, loop-guard, and reflection-cache evidence.

Delegate-owned target endpoint for simple Text, Enabled, Selection, and List bindings.

This endpoint deliberately receives delegates instead of wrapping controls. The owning control/application surface remains responsible for its properties, invalidation, layout refresh, and rendering behavior.

Immutable evidence for one ViewModel member bound to one UI-owned target endpoint.

Immutable evidence for one ViewModel command member registered through CommandActionSystem.

Immutable snapshot proving simple application binding coverage without scanning controls or rendering UI.

Reflection-backed ViewModel source for simple property and command member binding.

The source is intentionally small: property paths are read/written on demand, reflection lookups are cached per session, and INotifyPropertyChanged is observed only to refresh already-registered endpoints. It does not walk UI trees or create controls.

Small internal ViewModel binding session for Text, Enabled, Selection, Lists, and Commands.

The session owns binding records, ViewModel notification subscription, reentrant update guards, command leases, and lifecycle evidence only. It does not create controls, render UI, scan forms, schedule frames, mutate layout policy, or replace CommandActionSystem.

Public artifact families supported by the Nexamas UI Output product facade.

Public output encoding formats known by the Nexamas UI Output facade. Unsupported formats are reported explicitly instead of being silently claimed.

Destination kind requested for an output artifact.

Final status of one public Output facade operation.

Stable failure reason returned by MASOutputResult when an export cannot be completed.

Public support status for one Output capability.

Public destination descriptor for Nexamas UI output artifacts.

Directory path used when Kind is Directory. Empty for memory targets.

Creates a directory target. Nexamas UI generates a stable product file name for the requested artifact/format.

Public options applied to one Output operation.

Optional Render Verification scenario id used by visual-capture output. Empty means the official default product visual-capture scenario is used.

Optional MAS theme id override for visual-capture output. Empty means the scenario's own theme is preserved.

Image encoder quality, normalized to the 0-100 range.

Public immutable request for one Nexamas UI Output export operation.

Public capability fact exposed by the Nexamas UI Output facade.

Public immutable catalog of Output capabilities exposed by MASApplication.Output. Release-evidence bundle capabilities are only present when the internal release-evidence pipeline requests the full catalog.

Public immutable SDK-output readiness facts for the Nexamas UI Output facade.

Public immutable result returned by every Nexamas UI Output export operation.

Binary artifact payload for image-like Output operations. A defensive copy is returned.

Friend runtime behind the public Nexamas UI Output facade. It consumes the existing Chart/Visualization, Report/Print, and Render Verification foundations without exposing their internal model types.

Severity for the Phase 5 Output product route closure audit.

Immutable finding emitted by the Output product route audit.

Immutable report for Application-owned Output product closure.

Product closure audit for Output. It proves that Chart/Visualization, Report/Print, and Render Verification foundations are consumed through one Application-owned public facade, while internal builders/capture hosts remain governed and unsupported routes such as PDF/print are reported honestly.

Small first-stage chart vocabulary for dashboard and report foundations.

Readiness state for one chart definition or one visualization foundation snapshot.

Deterministic chart render-plan primitive kind. These are facts for a renderer, not drawing commands.

Immutable business data point consumed by the chart foundation.

Immutable chart series. It is data only and does not own rendering, controls, or data querying.

Immutable chart definition for the initial dashboard/report chart foundation.

Deterministic chart layout viewport. It is independent from controls and render hosts.

Immutable chart primitive generated by the foundation render-plan builder.

Immutable render-plan facts for one chart definition.

Immutable readiness evidence for the Chart / Visualization System foundation.

Builds deterministic chart render-plan facts for the initial Chart / Visualization System foundation.

This builder does not draw, create controls, query databases, virtualize items, execute capture/performance runners, or register a public chart API. It converts already-supplied dashboard data into geometry facts for MAS-owned renderers.

Internal value vocabulary understood by the MASPropertyGrid foundation and renderer.

Internal edit result returned by property value commits.

Internal normalized property row. It may be manually supplied or bound to a public CLR property.

Reflection boundary for MASPropertyGrid object inspection. It reads public instance properties only.

Internal read snapshot used by governance and tests without touching a live control tree.

Foundation builder for object inspection and deterministic sample facts.

Friend-owned filter token for the advanced SearchBox route. The token stores DataView-compatible filter text only; DataGrid/DataView remain the owners of parsing and projection.

Friend-owned advanced SearchBox state for suggestions, MRU recent searches, and DataView-compatible filters. The state does not render UI, does not own DataGrid projection, and does not create binding sessions.

Friend-owned readiness manifest proving that MASSearchTextBox Advanced extends the official SearchBox, DataBinding, and DataGrid routes without creating a parallel search subsystem.

Internal report/print foundation readiness state.

Printable report page orientation facts.

Primitive printable report element vocabulary used by the first-stage print preview plan.

Immutable printable page settings expressed in device-independent pixels.

Table report column definition for deterministic print layout.

Immutable printable table row values.

Simple table report model for invoices, inventory lists, registers, and business logs.

Internal report document model for printable business reports.

The document owns report title, header/footer text, paragraphs, and table-report content only. It does not query data sources, bind controls, render UI, open a print dialog, or export PDF.

Deterministic printable element fact used by preview and future printer/PDF consumers.

One deterministic printable page in a report preview snapshot.

Preview-ready report print plan produced without invoking OS printing or exporting files.

Builds deterministic report page and print-preview facts for simple printable business reports.

The builder does not call native printer classes, printer dialogs, preview controls, PDF exporters, file output, Skia drawing, DataGrid rendering, or third-party reporting libraries. It only converts supplied report content into page facts.

Internal field vocabulary for the first Form / Validation foundation.

Internal validation and submit state vocabulary for a form session.

Supported first-stage validation rule vocabulary.

One internal rule attached to a form field. Rules read values supplied by DataBinding-owned targets.

Immutable validation message shown by validation summaries.

Internal field state for validation, dirty tracking, and summary generation.

Immutable validation summary for one form session.

Immutable result for one submit attempt.

Internal form session that combines DataBinding-owned field values with CommandActionSystem submit state.

The session does not create controls, scan forms, render validation UI, own toolbar buttons, or create a second command engine. It reads values from supplied DataBinding targets, pushes two-way values through MASViewModelBinder, and registers submit through MASCommandRegistry.

Internal readiness state for a foundation-system inventory row.

Immutable internal row describing one protected foundation system and its commercial evidence chain.

Immutable internal report for the six current Nexamas UI foundation systems before deeper hardening stages.

Builds the current internal foundation-system inventory from already-owned governance facts.

This audit is evidence-only. It does not read source files, run gates, create controls, render, benchmark, capture images, allocate Skia objects, mutate UI, expose telemetry, or open public API.

Friend-only state for the foundation public API, exception, and documentation drift hardening manifest.

Immutable row for one active drift boundary in the foundation hardening chain.

Friend-only manifest proving that public API counts, exception audit counters, and active documents are synchronized.

Evidence-only: this report does not read source files, execute gates, start processes, inspect assemblies, render, benchmark, capture images, allocate graphics resources, mutate UI, or expose public telemetry.

Builds the public API, exception, and active-documentation drift manifest from already-owned baseline facts.

This audit is evidence-only. It does not scan files, run gates, inspect assemblies, render, benchmark, capture images, create controls, mutate UI, open public API, or create a parallel public-surface system.

Friend-only status for the final commercial closure of the foundation hardening sequence.

Immutable row for one protected foundation-hardening stage in the final commercial closure manifest.

Friend-only final commercial closure manifest for the foundation hardening chain.

Evidence-only: this report does not read files, execute gates, start processes, inspect assemblies, render, benchmark, capture images, create controls, mutate UI, allocate graphics resources, or expose public telemetry.

Builds the final commercial closure manifest for the completed foundation hardening sequence.

This audit consumes already-built foundation governance facts. It does not scan files, run gates, start processes, render, benchmark, capture images, create controls, mutate UI, expose telemetry, or open public API.

Friend-only status for Phase 4 system-to-control flow closure evidence.

Immutable evidence row proving that a product system flows through real controls without wrappers or parallel routes.

Friend-only Phase 4 closure manifest for official system flow through controls.

Builds the Phase 4 evidence manifest proving that controls consume official systems instead of isolated local paths.

This audit creates only lightweight in-memory contracts and control instances needed by existing Friend systems. It does not scan files, run gates, start external work, schedule callbacks, render, benchmark, show Float windows, or expose public API.

Friend-only closure states for the recent Business/Data and professional UI systems before new UI controls are added.

Single Friend-only integration row for a recently added Business/Data or professional UI system.

Evidence-only: this entry does not render, create controls, run gates, benchmark, print, export, mutate UI, expose telemetry, or open public API.

Final integration-closure report for recently added Business/Data and professional UI systems.

Evidence-only: the report does not read files, run processes, create controls, render, benchmark, print, export, mutate UI, expose telemetry, or open public API.

Builds the integration closure report for recent Business/Data and professional UI systems.

This audit consumes already-built owner-system readiness facts and the official ArchitectureSystem component contracts. It does not render, create controls, execute gates, benchmark, print, export, mutate UI, expose telemetry, or open public API.

Describes the semantic purpose of a motion token. Purpose values are product-level animation contracts, not renderer details.

Stable identifiers for the built-in Nexamas UI motion tokens. Consumers request these tokens instead of hard-coding durations.

Built-in easing curves owned by MASMotionSystem. The values intentionally mirror product motion language, not a renderer library.

Runtime policy for reducing motion without changing caller code. Foundation v1 is explicit and process-owned.

Lifecycle state of a deterministic MAS motion timeline. Timelines are advanced by official callers; they do not own random timers.

Immutable public description of one motion token. It exposes duration/easing intent while keeping scheduling and invalidation internal.

Immutable transition plan produced by the motion gateway. It stores numeric interpolation facts without owning drawing or timers.

Snapshot of a timeline at a deterministic point in time. Renderers consume these facts without owning easing math.

Internal catalog for built-in product motion tokens. It is the single source of default durations/easing for Nexamas UI controls.

Deterministic easing evaluator for MASMotionSystem. It has no renderer, timer, or host dependency.

Small deterministic timing helper used by MASMotionSystem timelines. It intentionally does not schedule frames or own timers.

Deterministic timeline for a single transition. It advances only when an official caller supplies elapsed time; it never creates timers.

Official Friend-owned gateway for Nexamas UI motion tokens, easing evaluation, reduced-motion policy, and deterministic timelines after final public API lockdown.

Evaluates the Motion foundation through the official Motion gateway without exposing the concrete readiness gate.

Internal host-scoped Motion clock registry driven by one owning frame scheduler.

Consumers register a small frame callback and an invalidate callback against the clock that belongs to their owning host. The clock owns no WinForms timers, background threads, or dispatcher loops; it is advanced only by its matching MASSkiaFrameScheduler after that host completes a native PaintSurface cycle.

Advances only this host clock's registered Motion consumers once from its owning frame scheduler.

True when at least one consumer remains alive and has requested another rendered frame.

Internal scheduler-backed runner for one MASMotionTimeline.

The runner is the official runtime execution layer between a deterministic MASMotionTimeline and a visual consumer. It owns no timer, thread, renderer, or public API. It registers with MASMotionFrameClock, which is advanced only from MASSkiaFrameScheduler after a rendered frame completes.

Internal integration category for Nexamas UI surfaces that should consume motion through MASMotionSystem.

Describes the concrete proof level behind a motion consumer binding. Declared contracts are useful for product inventory, but runtime-proven bindings must be backed by the official MASMotionFrameClock route.

Type-linked integration binding proving that a Nexamas UI consumer belongs to the shared motion system boundary.

Internal catalog of current Nexamas UI motion consumers. It separates historical/type-linked consumers from consumers that are now driven by the official MASMotionFrameClock.

Diagnostic finding emitted by the motion integration gate.

Motion integration report proving that current animation-heavy surfaces are bound to MASMotionSystem.

Integration gate for Motion. It keeps the product type-linked inventory and separates it from runtime-proven consumers that are backed by MASMotionFrameClock or MASMotionTimelineRunner.

Readiness finding for MASMotionSystem foundation checks.

Public readiness report for MASMotionSystem. It is safe for harnesses and future diagnostics without exposing internals.

Official readiness gate for Phase 4. It verifies tokens, deterministic timelines, reduced-motion policy, and integration bindings.

Public contract facts for the Phase 5 Theme Studio / Surface Designer foundation.

The version belongs to the design-inspection contract, not to package versioning. It lets gates, tests, and future Showcase pages confirm they are using the expected Theme Studio snapshot model without reading internal implementation details.

Immutable theme entry projected by Theme Studio from the official MAS theme registry.

The entry deliberately exposes product-safe facts only: identity, current selection, and the number of foundation/family groups available for inspection. It does not expose ThemeManager, ThemeHost, factories, mutable theme objects, or renderer internals.

Product-safe description of one reusable surface material available to Surface Designer.

This is a design-inspection DTO. It exposes material identity and theme-awareness only; frame, chrome, and shadow ownership are described by their own systems.

Product-safe description of one profile assignment from a generic slot to an official surface material. It lets Designer/Showcase display the slot matrix without exposing the mutable profile registry or renderer internals.

Product-safe description of a reusable surface material profile. A profile is a generic slot distribution, not an element-specific material identity.

Product-safe description of one generic surface material slot available to Surface Designer. Slots are reusable regions such as Root, Header, Toolbar, Viewport, or Floating; they are not element identities and must not become material ids.

Product-safe surface role entry used by Surface Designer state/role previews.

Surface roles remain internally owned by the reusable Surface Visual System. The designer exposes names and stable role values only, preventing consumers from depending on renderer-local enums or PanelShell implementation details.

Product-safe description of a reusable surface visual style composition.

Visual styles combine material, frame, chrome, and role. The entry describes that composition for designers and diagnostics without exposing MASSurfaceVisualStyle itself.

Immutable contrast-check result generated for one theme token pair.

Phase 5 records deterministic WCAG-style ratio facts for Theme Studio preview safety. It does not mutate themes and does not approve a design by hiding failures.

Immutable product snapshot consumed by Theme Studio, Surface Designer, gates, and future Showcase pages.

The snapshot is the official Phase 5 read model. It is intentionally descriptive: it never draws, edits, exports, registers themes, writes files, or exposes internal theme/rendering owners. UI surfaces can bind to it safely.

Internal Surface Designer catalog projection over the owned Surface Visual System.

This catalog is not a second registry. It reads canonical ids and definitions from the Surface Material Registry and converts them into product-safe DTOs.

Deterministic contrast analyzer used by Theme Studio snapshots.

The analyzer is classical math only. It has no AI/model dependency, does not mutate themes, and does not decide rendering. It emits inspection facts for designers.

Internal builder for the official Theme Studio snapshot.

The builder is the only Phase 5 code that reads ThemeManager and the reusable Surface Visual registries. That preserves clean ownership: UI and public SDK callers receive immutable design data, never internal theme/runtime/rendering objects.

Severity level for Theme Studio readiness findings.

Readiness finding for the Theme Studio / Surface Designer foundation.

Readiness report for Phase 5 Theme Studio / Surface Designer foundation.

The report is public because gates, diagnostics, and future Showcase pages need a safe readiness summary. It only exposes counts and findings, not internal registries.

Official readiness gate for Phase 5 Theme Studio / Surface Designer foundation.

The gate proves that Phase 5 consumes the existing Theme and Surface Visual systems through a small read-only snapshot, with no second theme registry or design-time renderer.

Official Friend-owned gateway for Phase 5 Theme Studio design inspection after final public API lockdown.

This class is the small Nexamas UI-owned entry point for reading Theme Studio data. It does not expose ThemeManager, ThemeHost, factories, Surface registries, or drawing APIs.

Creates an immutable snapshot of the current MAS themes, surface materials, roles, styles, and contrast facts.

Evaluates whether the Theme Studio / Surface Designer foundation is ready for commercial diagnostics.

Official Friend-owned gateway for Surface Designer catalog inspection after final public API lockdown.

Surface Designer is a read-only Phase 5 projection over the existing Surface Visual System. It is not a second material registry, a renderer wrapper, or a temporary design bridge.

Returns the owned Surface Visual material catalog without rebuilding the full Theme Studio snapshot.

Returns reusable material profiles for generic surface slots without exposing element-owned material names.

Returns generic surface slots so Designer/Showcase can assign materials to Root, Header, Toolbar, Viewport, Floating, and other regions without inventing element material names.

Returns the owned Surface Visual role matrix without rebuilding theme or contrast facts.

Returns reusable visual style compositions without rebuilding theme or contrast facts.

Defines how the render verification runner treats missing approved baseline images. CompareOnly is the CI-safe mode; CreateMissing is used only when intentionally seeding a baseline set.

Summarizes the public product-proof outcome for one render verification scenario. BaselineSeeded is intentionally separate from Passed: a newly created baseline is a review artifact, not an approved visual match.

Severity used by the render verification gate and runner. Errors block the phase gate; warnings document non-blocking readiness limitations.

Describes one deterministic screenshot-diff scenario: component identity, state, theme, DPI, and pixel size. The scenario is immutable after construction so baseline file names and CI reports stay stable over time.

Groups related render verification scenarios under one stable target, such as Buttons, Surfaces, or Lists. Targets are the unit consumed by gates and runners; they do not know how rendering is performed.

Captures a scenario into an SKBitmap that can be persisted and compared by the verification runner. Implementations must be deterministic: same scenario, same dimensions, same theme/state facts, same bitmap.

A stable diagnostic emitted by the render verification gate or runner. The code is intentionally machine-readable so future CI and Showcase diagnostics can group failures.

Readiness report produced before screenshot capture starts. It verifies that targets, scenarios, and baseline folders form a coherent render-verification contract.

Pixel comparison tolerance for screenshot diffs. ChannelTolerance absorbs tiny antialiasing differences while MaxDifferentPixelRatio controls whole-image drift.

Immutable result for one baseline/current bitmap comparison. It records exact pixel counts and the largest channel delta so failures are explainable from CI logs.

Owns deterministic pixel comparison for render verification. The comparer does not render controls and does not perform file IO; it only compares already-captured bitmaps.

Writes the PNG difference artifact for a render-verification result. The runner owns baseline/current persistence; this writer owns only the review diff asset used by CI and Showcase. Diff PNGs are written only for real visual failures so seeded or matched scenarios do not spend time decoding, looping over pixels, and encoding an artifact that the product UI intentionally does not show.

Owns the approved/current/diff folder contract for screenshot verification assets. The store is deliberately path-based and deterministic so CI, local machines, and future Showcase tooling share one layout.

Describes one persisted screenshot snapshot generated by the render verification runner. Hashes are computed from encoded PNG bytes so reports can detect accidental baseline replacement.

Execution options for screenshot verification. CI should use CompareOnly; baseline seeding may use CreateMissing after a deliberate visual approval decision.

Aggregate execution result for a render verification pass. It carries snapshots, diffs, and findings separately so callers can produce CI logs without re-reading files. Passed excludes seeded baselines; seeded artifacts are review evidence and surface through RequiresApproval.

Executes deterministic screenshot capture, persistence, and baseline comparison for render verification targets. The runner is capture-handler driven so controls, surfaces, and future gallery hosts can plug in without parallel systems.

Owns the single official Render Verification target catalog for Nexamas UI product snapshots. Component systems may contribute scenario facts through explicit internal contribution contracts, but only this catalog creates groups consumed by runners, gates, and product Showcase surfaces.

Creates the current product Showcase target matrix. The returned targets are the source of truth for generated baseline/current/diff PNG assets and must not be duplicated by feature-specific target lists.

Creates every target currently owned by Render Verification. At this stage the product Showcase matrix is the full live catalog; later coverage expansion must extend this method instead of adding parallel lists.

Shared Render Verification descriptor planner. It converts the architecture component registry into one stable per-descriptor PNG scenario while routing every proof through an existing registered Nexamas UI capture scene. Coverage reports consume this same planner so the catalog and the quality map cannot drift into parallel logic.

Resolves render-verification scenario theme keys into immutable theme instances without depending on the process-wide current theme at capture time.

Render Verification baselines must be repeatable across machines and Showcase runs. This resolver keeps scenario theme keys small and explicit, then binds them to registered Nexamas UI themes before ThemeHost creates the per-capture ThemeContext.

Returns whether a scenario theme key is part of the approved deterministic capture matrix.

Resolves a scenario theme key to a concrete registered Nexamas UI theme.

Per-scenario deterministic capture context used by Render Verification capture hosts.

The context owns the bitmap, canvas, ThemeHost, and ControlsLayer for one scenario. Scene builders may add real MAS controls to or draw owned chrome directly to . The host renders the layer once, then executes registered after-layer renderers such as tooltip floats or footer chrome.

Registers deterministic drawing that must occur after ControlsLayer rendered its real MAS controls.

Renders the real controls layer and then every deterministic after-layer renderer in registration order.

Transfers bitmap ownership to the caller. The context will still dispose canvas/layer/theme resources.

Single deterministic host used to capture Render Verification scenarios into bitmaps.

This host centralizes bitmap allocation, canvas lifetime, DPI/theme resolution, ControlsLayer creation, ThemeHost binding, and after-layer rendering. Product-specific capture classes only register scene content; they do not own ad-hoc ThemeHost or ControlsLayer construction paths.

Captures a scenario using a deterministic Nexamas UI ThemeHost/ControlsLayer context.

Deterministic registry that maps Render Verification component keys to owned capture scene builders.

The registry is intentionally internal. Gates use it to validate component-key coverage before capture, while product capture hosts use it to fail closed when an unregistered component key bypasses the gate.

Immutable single value displayed by the Render Verification system-inventory read model.

Facts keep the dashboard proof readable as KPI-style rows. They are produced by the same internal builder that owns the metric rows, so the page remains data-driven and does not invent visual-only numbers.

Immutable row displayed by the Render Verification system-inventory read model.

The metric is internal to Render Verification. It carries product proof facts gathered from official Nexamas UI gateways and does not expose registries, mutable collections, or implementation services.

Internal deterministic inventory snapshot displayed by the Render Verification dashboard as a read-model/DataGrid proof.

This snapshot is intentionally not public API. It is a product proof read-model for the dashboard: the values come from official Nexamas UI gateways and Render Verification contracts, then flow through MASDataView/MASDataGrid instead of being encoded as a PNG proof card.

Builds the official Render Verification system-inventory read-model snapshot.

The builder reads existing Nexamas UI product gateways and internal Render Verification ownership facts. It does not scan files, enumerate the machine, allocate renderer surfaces, or introduce a second catalog.

Final internal closure state for the Render Verification evidence-governance chain.

Internal status for Render Verification proof catch-up over VisualSurface runtime surface visual consumers.

One internal Render Verification proof row for a VisualSurface runtime surface visual consumer.

The row records catalog/registry/route-alignment only. It does not allocate bitmaps, draw, create controls, run baselines, expose diagnostics, or open public proof API.

Internal report proving that every current VisualSurface runtime/public material consumer has an official Render Verification scenario and registered capture scene.

This report is evidence-only. It does not run Render Verification, compare pixels, approve baselines, allocate Skia objects, or expose a public proof API.

Builds the current Render Verification proof catch-up report for VisualSurface material gateways.

The audit reads existing catalog/manifest facts only. It does not capture, compare, approve, allocate bitmaps, construct UI controls, scan the file system, or expose proof APIs.

Immutable internal manifest closing the Render Verification evidence-governance chain.

This contract does not capture screenshots, create baselines, compare pixels, construct controls, render scenes, run performance proof scenes, or expose public diagnostics. It records whether the already-owned Render Verification catalog, registry, policy, reports, and gates form a complete commercial evidence chain.

Deterministic in-memory file-system provider used only by Render Verification screenshot scenes. It prevents the Showcase snapshot pass from touching real drives, network shares, shell roots, or user folders.

Deterministic in-platform capture source for the render-verification Showcase gallery. It renders real Nexamas UI controls through the canonical ControlsLayer / ThemeHost path; shell chrome such as TopBar is rendered through the MAS TopBar component itself. The external Showcase receives only immutable PNG paths and comparison facts from the public gateway.

Immutable release-evidence progress facts raised while MASRenderVerification creates Showcase PNG assets. It reports real scenario completion from the runner, not a timer-simulated loading animation.

Immutable release-evidence entry for one render-verification product proof asset row. The entry exposes approved/current/diff image paths and safe bitmap loading helpers while keeping capture handlers, baseline stores, scenario objects, and comparison internals owned by Nexamas.UI. Passed means an approved baseline matched; BaselineSeeded means review is still required.

Loads a copy of the approved baseline bitmap for preview controls. The caller owns the returned bitmap.

Loads a copy of the current captured bitmap for preview controls. The caller owns the returned bitmap.

Loads a copy of the difference bitmap for preview controls. The caller owns the returned bitmap.

Release-evidence immutable snapshot used by dashboards, CI tools, and product demos to display the real render-verification asset set. It contains generated PNG paths and comparison facts, not internal runner objects. Seeded baselines are separated from passed entries so product UI cannot auto-approve new artifacts.

Nexamas UI-owned dashboard for the official Render Verification gateway. Consumers attach this page through MASRenderVerification.AttachDashboard. The page consumes only MASRenderVerification.CreateSnapshot and immutable read-model entries. Capture hosts, target catalogs, baseline mutation, diff rules, and scene routing remain Nexamas UI-owned internals.

Official release-evidence gateway for Render Verification product proof inspection and dashboard attachment.

The gateway intentionally exposes immutable product proof snapshots and a one-call dashboard attachment only. It does not expose capture handlers, runner execution, baseline-store mutation, or internal scenario contracts.

Returns the default persistent local folder used for generated Render Verification product proof PNG assets.

Generates approved/current/diff PNG assets and returns a product-facing immutable snapshot for dashboards, CI tools, and demos.

Attaches the official Nexamas UI-owned Render Verification dashboard to a MASApplicationWindow. Consumers receive a ready page and never build capture, catalog, diff, or PNG-preview UI themselves.

Attaches the official Nexamas UI-owned Render Verification dashboard content to an existing Application page-builder scope such as MASApplicationWindow.Pages. The host supplies only the current MASApplicationWindow and MASApplicationLayoutPageBuilder; Nexamas UI still owns snapshot generation, PNG persistence, preview surfaces, target identity, diff facts, and dashboard layout.

Internal execution seam used by Nexamas UI gates and the runtime harness to validate the same snapshot gateway contract with a controlled target subset. It is deliberately Friend-only: product consumers still receive only CreateSnapshot, AttachDashboard, and immutable snapshot entries.

Friend-only runtime proof scene identifiers for performance regression coverage.

These values describe proof-scene intent. They are not public SDK telemetry labels and they do not own controls, rendering, motion, scrolling, or async work.

Immutable binding between a performance proof scene, an official Render Verification scenario, and the PerformanceSystem scenario budget row used to evaluate the captured runtime pressure.

Immutable result for one Render Verification-backed performance proof scene.

Immutable report returned by the runtime performance proof runner.

Owns the official Render Verification-backed performance proof scene catalog.

The catalog reuses the existing Render Verification target catalog. It must not create a second render catalog, a second renderer, or a public performance telemetry surface.

Executes performance proof scenes by wrapping official Render Verification captures with PerformanceSystem scenario-budget evaluation.

This runner does not create a renderer, a scheduler, a control catalog, or a public telemetry API. It exercises the existing Render Verification capture source and sends before/after facts to the Performance scenario harness.

Immutable baseline-evidence row for one Render Verification-backed performance proof scene.

Immutable commercial baseline evidence report for runtime performance proof scenes.

Converts runtime proof-scene results into commercial baseline evidence and enforces the targeted-remediation decision contract for warnings and failures.

Baseline evidence does not run scenes, render, schedule frames, or expose telemetry. It only evaluates an already-produced MASPerformanceRuntimeProofReport against remediation evidence rules.

Converts a runtime proof baseline report into one final commercial-readiness governance decision.

This evidence layer does not capture Render Verification scenes, run the scenario harness, mutate controls, schedule frames, or expose telemetry. It only summarizes an already-built baseline report.

Converts a runtime proof baseline report into the final performance release certification manifest.

This evidence layer does not capture scenes, run scenario harnesses, create controls, schedule frames, render, or expose telemetry. It only builds the release manifest from already-available baseline evidence.

Readiness gate for the Nexamas UI render verification system. It validates target identity, scenario uniqueness, deterministic file names, capture-scene ownership, dimensions, DPI, theme keys, and baseline-store ownership before capture starts.

Blocking graph audit for RenderVerification coverage.

This audit closes the gap between a syntactically valid target catalog and a trustworthy coverage graph. It compares the official target catalog, registered capture scenes, and MASComponentRegistry coverage map, then reports exact MissingScenes / OrphanScenes / UnusedTargets / UnmappedComponents / MissingCatalogScenario failures.

Immutable finding emitted by the render-verification coverage graph audit.

Describes the exact render-verification coverage graph gap detected by the catalog audit.

Immutable report that compares RenderVerification targets/scenarios/capture scenes with component quality coverage.

Builds the descriptor-level read model used by the official Render Verification dashboard.

The builder does not introduce a second verification path. It joins the existing MASQualityComponentCoverageMap, MASRenderVerificationCoverageAudit, and MASRenderVerificationSnapshot so the dashboard can show every registered component descriptor and the exact proof route that currently covers it.

One descriptor-level Render Verification dashboard row built from existing Quality evidence.

Descriptor-level dashboard read model for Render Verification coverage.

Display state for one MASComponentRegistry descriptor inside the Render Verification dashboard.

This is a read-model state only. The actual evidence still comes from the existing component coverage map, Render Verification snapshot entries, and coverage graph audit.

Severity for the Render Verification element-coverage closure audit.

Immutable finding emitted by the Render Verification element-coverage closure audit.

Immutable report for dashboard-level element coverage closure.

Phase-6 closure audit for the Render Verification element coverage read model. It does not run screenshots or create a second catalog. It proves that the existing catalog, capture-scene registry, component coverage map, and dashboard row builder describe the same component universe before visual snapshots are trusted.

Central numeric guard for MASVirtualizedItemsSystem contracts. It prevents NaN/Infinity values from entering range planning, measurement-cache math, viewport facts, or scroll requests while keeping normalization inside the virtualization foundation instead of scattering ad-hoc checks through consumers.

Encodes virtualization control-size facts with fractional-DPI sensitivity. The value is still an Integer revision for the existing stamp pipeline, but the normalized input is quantized at 1/64 pixel rather than rounded to whole pixels.

Axis used by the MASVirtualizedItemsSystem. Phase 2 activates vertical planning first while keeping the contract explicit so horizontal and grid consumers can be added later without creating a second virtualization model.

Alignment used when a consumer asks the virtualization system to create a scroll-to-index request.

Declares how a virtualized item surface resolves item extents. The enum prevents MASVirtualizedItemsSystem consumers from being architecturally locked to a fixed-size-only model while still allowing estimated extents as the initial planning fact.

Inclusive realized index range. The range is a fact produced by the virtualization engine; it does not create controls, mutate items, or own selection state.

Logical one-dimensional viewport consumed by MASVirtualizedItemsSystem. Scroll adapters provide offset/extent facts; the virtualization system returns item plans and never scrolls a host directly. Single properties are retained for existing consumers, while Double facts are the internal planning source for huge extents.

Immutable construction options for a one-dimensional virtualized item controller. The options deliberately avoid any DataGrid/ListView-specific terminology so the system remains a reusable Nexamas UI service.

Realization request for one visible or overscanned item. It binds an item index to logical offset/extent and to the stable container lease that a future UI consumer can map to a visual container.

Immutable output of one virtualized realization pass. Consumers read this plan to realize, retain, or recycle visual containers; the plan itself does not touch WinForms controls and does not apply layout.

Scroll request produced by the virtualization system for a specific index. The owning scroll adapter decides how to apply the target offset, which keeps scrolling ownership outside the virtualization engine.

Cached one-dimensional measured item extent. This is a measurement fact only; layout slots and rendering remain owned by MASLayout and the future control consumer.

Owned measurement cache for virtualized item extents. It stores only deterministic item measurement facts and provides prefix-delta lookups so range planning can remain fast with large data sets and sparse measured overrides. Prefix math is performed in Double to avoid precision loss at very large scroll extents while preserving Single compatibility shims.

Internal lease pool for virtualized visual containers. The pool owns only numeric leases in Phase 2 so it stays UI-neutral; future controls can map lease ids to actual visual containers without changing the planning engine. Released lease ids are tracked defensively so a consumer bug cannot enqueue the same lease twice and later duplicate a visual container lease.

Selection mode supported by the virtualization foundation. Selection is index-based so it can survive realization and recycling without depending on currently visible visual containers.

Immutable index-based selection snapshot. It is independent from realized containers so selection remains stable while virtualization recycles off-screen visuals.

Stable reason recorded when virtualization-owned measurement facts are invalidated. The enum keeps cache invalidation explicit and auditable without letting item controls invent private cache reset flags.

Immutable environment stamp supplied by item-heavy controls when virtualization-owned measurements depend on theme, DPI, density, font, localization, RTL direction, collection revision, or control-size facts. The stamp keeps invalidation causes explicit and testable without letting each control invent private cache-reset booleans.

Official primitive stamp builder for virtualization consumers. It centralizes how Theme, DPI, Density, Font, Localization, RTL, collection, control-size, and viewport facts are converted into a MASVirtualizationEnvironmentStamp, so controls do not scatter direct constructor calls or private cache-reset booleans through rendering/input code.

Decision emitted by MASVirtualizationAutoInvalidationCoordinator. It records whether the measurement cache was invalidated and why, so consumers and tests can prove cache refreshes are automatic rather than manually scattered through controls.

Small owned coordinator that compares environment stamps and invalidates MASVirtualizedItemsController measurements when theme, DPI, density, font, localization, RTL, item collection, or control-size facts change. It does not subscribe to UI events and does not own scrolling; each control passes its official platform stamps through this single gateway.

Immutable internal diagnostic snapshot emitted by MASVirtualizedItemsController. It records the current virtualization facts needed by tests, gates, render verification diagnostics, and future showcase diagnostics while keeping all runtime ownership inside the virtualization foundation and its consumers.

Friend-only proof snapshot for fast-scroll planning allocation pressure. It does not expose memory counters to the public SDK; it records whether repeated viewport updates reused controller scratch structures and container leases within budget.

Friend-only diagnostic emitted when tile-grid hit testing must fall back from controller-owned row resolution to a calculated row. The diagnostic makes potential variable-extent mismatches visible instead of silently returning an item.

Severity for MASVirtualizedItemsSystem readiness findings.

Immutable readiness finding emitted before the virtualization controller is used.

Gate report for MASVirtualizedItemsSystem options. The report is diagnostic-only and does not allocate containers.

Stable diagnostic context names for virtualization-backed consumer boundary failures.

These names are Friend-owned so controls, gates, and runtime fault reports use the same vocabulary without exposing virtualization internals as public SDK API.

Stable diagnostic codes for TileBox/DropDown virtualization helper fallbacks.

These codes are Friend-owned and intentionally not public SDK API. They make helper fallback decisions retained, searchable, and testable instead of relying on an opaque swallowed exception line.

Immutable Friend-only report for the most recent virtualization consumer helper fallback.

Single Virtualization-owned diagnostic channel for helper fallbacks in TileBox/DropDown consumers.

Central helper for TileBox/DropDown virtualization consumer fallback boundaries.

The helper records a structured diagnostic code before delegating to MASExceptionSilencer, so normal builds keep fail-closed behavior while strict mode still throws from the official silencer path. This prevents silent helper fallback without creating another exception policy.

Result of the virtualization consumer diagnostics proof.

Proves that virtualization-backed controls report input/render fallback failures through stable runtime-fault diagnostics and that strict mode converts swallowed failures to test failures. The proof is synthetic by design: it validates the official diagnostic boundary without constructing UI controls or adding a parallel rendering/input path.

Internal ownership classification for data/projection work that exists beside render/window virtualization. The shared virtualization core remains a realization/windowing engine; source projection is either explicitly surface-owned or covered by a separate domain-specific proof.

Records the commercial contract boundary between virtualization and source projection for one large-data surface. A binding may admit that a surface-owned projection performs a full pass; that admission is intentional and prevents the shared virtualization proof from being misread as a data/projection scale proof.

Catalog that prevents the commercial virtualization proof from claiming data/projection scale by accident. DataGrid and TreeView deliberately keep their source projection outside the shared virtualization core: render/window realization is bounded by the virtualization consumers, while filter/sort/group/flattening remain surface-owned contracts that need their own gates before being marketed as projection-scale guarantees.

Report proving that source/data projection is not hidden inside the render virtualization commercial claim.

Commercial-scope gate for P1-2: render/window virtualization must not be presented as data/projection virtualization. This gate does not introduce a new projection engine. It records and enforces the current ownership truth: DataView and TreeView projection are surface-owned, explicit full-projection passes, separate from bounded render realization.

VIRT-04 runtime proof report. It separates source/data projection scale from render/window virtualization by recording 100k DataView filter/sort/group and 100k TreeView expand/flatten evidence without constructing a renderer, DataGrid, realization plan, viewport, or shared virtualization controller.

VIRT-04 runtime gate. It proves that source/data projection scale is an explicit surface-owned contract and not an accidental claim hidden inside render/window virtualization. The gate executes 100k MASDataView filter/sort/group and 100k MASTreeView expand/flatten paths without creating a renderer, MASDataGrid, viewport plan, or virtualization controller.

Internal accessibility contract for a virtualized consumer range. The binding proves that accessibility/navigation semantics keep logical item identity and total logical count even when the rendered plan is bounded to the realized window. It does not create UI Automation providers and does not expose virtualization as public API.

Accessibility virtual-range proof report. It proves that each official virtualized consumer can navigate to an off-screen logical item through the shared scroll bridge while keeping accessibility metadata tied to logical count, not merely to currently realized visuals.

Executed accessibility virtual-range proof for current shared-controller consumers. The gate verifies off-screen navigation by scroll-to-index and logical position metadata while preserving bounded realized snapshots. It deliberately does not create UI Automation providers and does not move accessibility ownership into the core virtualization engine.

Readiness gate for MASVirtualizedItemsSystem. It validates the reusable virtualization foundation before any consumer attempts realization, recycling, measurement-cache use, scroll-to-index, or selection integration.

Professional hardening gate for MASVirtualizedItemsSystem. It verifies benchmark coverage, variable-extent readiness, automatic invalidation contracts, and current heavy-consumer catalog metadata without expanding the public SDK surface.

Final commercial-lockdown proof for MASVirtualizedItemsSystem. The report joins the benchmark proof, integration proof, and professional readiness gate into one stable internal contract that can be consumed by gates, diagnostics, and SDK tests without exposing virtualization implementation details as public control API.

Final internal gate for MASVirtualizedItemsSystem commercial proof. The gate deliberately composes existing official virtualization proof sources instead of introducing a new execution path or a control-level public API.

Final internal closure state for Nexamas UI virtualization scale governance.

Immutable internal final-closure manifest for VirtualizationSystem commercial scale governance.

This contract does not create controls, mutate scroll adapters, render items, allocate visual containers, run benchmarks, or expose public telemetry. It only records closure facts over an already-built MASVirtualizationCommercialProofReport.

Immutable benchmark scenario for MASVirtualizedItemsSystem. Scenarios are deterministic and runtime-safe; they measure the virtualized planning contracts only and never allocate UI controls, Skia surfaces, files, or item containers.

Immutable result of one MASVirtualizedItemsSystem benchmark scenario. It stores correctness facts and elapsed ticks so commercial gates can prove bounded realization and cache behavior without enforcing machine-specific time thresholds.

Aggregated commercial proof from a MASVirtualization benchmark run. The summary avoids machine-specific timing thresholds while exposing stable facts that gates and diagnostics can use: scenario coverage, largest logical item set, bounded realization ratio, sparse measurement proof, scroll-to-index proof, resize proof, and environment invalidation proof.

Deterministic benchmark suite for MASVirtualizedItemsSystem. The suite validates 1k/10k/100k item counts, fast scroll, scroll-to-index, selection-range independence, resize planning, and automatic invalidation through the same controller contracts used by controls. It does not create UI, render, access files, or depend on wall-clock thresholds.

Gate that protects Phase 3 from starting while the virtualization foundation is disconnected from existing item surfaces. It does not activate virtualization inside those controls; it verifies that every current candidate is cataloged, type-linked, and keeps Scroll/Layout/Selection ownership outside the virtualization engine.

Executed behavior-proof result for the current virtualization consumer catalog. Unlike the metadata integration report, this report is produced only after the official shared-controller coordinators have planned large ranges, recycled leases, resolved scroll-to-index targets, evaluated hit/point mapping, and processed environment invalidation for each active consumer binding. It stays internal and does not expose virtualization as public SDK API.

Behavioral gate for the current virtualization consumer catalog. This is intentionally stricter than the metadata-only integration gate: every active shared-controller binding must execute the official coordinator path against a 100k-item scenario and prove bounded realization, sparse measurement, scroll-to-index correctness, point/hit mapping, lease recycling, and environment invalidation. Composed consumers are proven only through their official child consumer proofs.

Runtime proof report for VIRT-03. It proves MASListView's linear virtualization path keeps item-extent measurement bounded to the realized viewport window plus overscan even when 100k variable-height items are invalidated.

VIRT-03 runtime gate for MASListView. The gate executes the real MASListViewVirtualizationCoordinator with a 100k variable-height logical item source and fails if item-extent measurement escapes the realized viewport/overscan window during baseline, theme invalidation, DPI/layout invalidation, or deep-scroll invalidation passes.

Runtime proof report for VIRT-06. It proves TileBox tile-grid virtualization uses a single shared-controller planning pass per render-equivalent pass after scroll extent has already been resolved/clamped, instead of the old update-plan-update-plan pattern that could do duplicate work during one render.

VIRT-06 runtime gate for MASTileBox. The gate exercises the official tile-grid virtualization coordinator under 100k items and records a render-equivalent operation order: resolve virtual scroll extent, clamp/restore offset, then call PrepareGridPlan once. The source-contract suite separately locks the real MASTileBox.RenderCore method to that same order so the runtime proof cannot drift into a parallel implementation.

Runtime/source proof report for VIRT-08. It proves DataGrid scroll-adapter invalidation requests raised during render/layout are coalesced instead of forwarded to the host while normal scroll/input invalidations outside render still flow through the official invalidation route.

VIRT-08 gate for MASDataGrid. It verifies the real DataGrid scroll invalidation bridge does not forward render/layout-time scroll metric invalidations to the host, while preserving the normal outside-render invalidation route used by input and scroll interactions.

Internal lifecycle/dispatcher contract for a virtualization consumer. This is proof metadata for the current catalog: the actual source-contract gate verifies the matching control code routes scroll-repeat pulses through the official owner dispatcher and cancels repeat/drag state when the owner lifecycle is detached.

Executed lifecycle/dispatcher proof result for current virtualization consumers. It complements the behavior gate by proving that repeat clocks cannot keep running through stale dispatcher state after a control or float session detaches.

Central VIRT-02 gate for virtualization consumer dispatcher/lifecycle ownership. The gate keeps the policy attached to the current catalog instead of spreading one-off assumptions across controls: active controls must use either MASControlRuntimeServices or the Float session as their repeat dispatcher, and lifecycle loss must cancel the active scroll-repeat/drag state. Composed consumers are accepted only through their catalog child consumers.

Internal classification for large-data surfaces that either use the shared virtualization controller or own a domain-specific bounded window proof. This is governance metadata only.

Internal governance binding for one Nexamas UI surface that can face large data, large layouts, or virtual/windowed item realization. The binding creates a compile-time link to the real surface and, for domain-specific windowing surfaces, to the official proof gate that validates bounded behavior.

Central catalog for Nexamas UI large-data/windowing surfaces. It deliberately separates shared-controller virtualization from domain-specific bounded-window systems so commercial proof cannot claim virtualization readiness while TreeGrid, PivotTable, KanbanBoard, AgendaView, or DashboardGrid are outside governance.

Report produced by MASLargeDataWindowingGate. It is intentionally internal and records whether every cataloged large-data surface is either covered by the shared virtualization behavior proof or by its own official bounded-window proof.

Commercial-scale governance gate for large-data/windowing surfaces. This gate does not make domain-specific controls consume the shared virtualization controller. Instead, it requires every large surface to be cataloged and either covered by the shared-controller behavior proof or by an official bounded-window proof owned by that surface.

Coverage report proving that compiled domain-specific windowing gates are not allowed to live beside MASLargeDataWindowingCatalog without an official catalog route.

Compiled-assembly coverage gate for VIRT-05. It prevents domain-specific WindowingGate classes from becoming a parallel governance system by requiring every compiled Nexamas.UI.Components *WindowingGate to be represented by an official MASLargeDataWindowingCatalog proof route.

Official internal coordinator for fixed-linear item consumers such as MASListBox and popup lists. It routes item count, extent, realization range, hit testing, scroll-to-index, and auto-invalidation through MASVirtualizedItemsController while preserving consumer ownership of rendering, input state, selection, and scroll adapters.

Official internal coordinator for tile-grid item consumers. It virtualizes grid rows through the shared MASVirtualizedItemsController while preserving consumer ownership of Skia drawing, selection, hit-shape refinement, and scroll adapter application. The coordinator maps item indexes to row indexes so tiled controls do not maintain independent visible-row math.

Result of the current-control virtualization integration audit. It confirms that item-heavy Nexamas UI surfaces are known to the platform before DataGrid consumes the same foundation.

Catalog of current Nexamas UI item surfaces that must be considered before virtualization is widened. The catalog creates a real compile-time link from the virtualization foundation to existing item consumers without turning the foundation into a public control API and without activating virtualization inside every control prematurely.

Stable integration contract between MASVirtualizedItemsSystem and one current item-oriented Nexamas UI surface. The binding references the actual consumer type so rename/removal drift is caught at compile time, but it does not expose virtualization through the public API and does not force a visual behavior change.

Records how a current Nexamas UI item surface is connected to the virtualization foundation. Direct item surfaces can consume the shared controller themselves; composed surfaces must prove that their child controls own the active plans.

Describes the kind of Nexamas UI surface that can consume virtualized item planning. This is diagnostic metadata only; it does not create controls and does not make virtualization public consumer API.

Core controller for the MASVirtualizedItemsSystem. It owns item-range planning, measurement-cache lookup, numeric lease recycling, and scroll-to-index facts while staying independent from DataGrid, ListView, TreeView, WinForms controls, Skia rendering, and file I/O. Offset and total-extent calculations are routed through the measurement cache prefix index with Double precision so huge extents do not collapse into Single rounding while public-compatible Single facts remain available to existing internal consumers.

Version marker for the public Localization / RTL product-layer snapshot contract.

Current Phase 6 foundation snapshot contract version.

Describes the primary text direction expected by a culture profile.

Describes whether product layout should keep physical ordering or mirror semantic ordering.

Immutable public description of a supported product culture profile.

This entry contains culture, direction, mirroring, and formatting facts only. It is safe for external consumers, documentation, gates, and design tools to consume without accessing runtime internals.

Immutable sample of a localizable product string across the supported Phase 6 cultures.

Immutable preview of culture-aware number, currency, percent, and date formatting.

Describes text-expansion pressure for a localized string key.

Immutable Phase 6 product-layer snapshot for localization and RTL readiness. Public consumers read the collection facts; derived proof/count convenience members are Friend-owned.

The snapshot is descriptive only. It does not mutate controls, change thread culture, create UI, draw text, or perform file/resource IO. It gives future product and external consumer layers one official read model for culture, direction, formatting, and string expansion facts.

Official Friend-owned gateway for Phase 6 Localization / RTL product-layer inspection after final public API lockdown.

The gateway is intentionally small. It exposes immutable product facts only to Nexamas UI internals and keeps culture catalog, formatting preview, sample translations, and readiness logic internal to the system.

Creates an immutable snapshot containing supported cultures, direction facts, formatting previews, and string expansion samples.

Returns the Phase 6 supported product culture profiles.

Resolves a supported product culture profile. Unknown values fall back to the English profile.

Returns the current Friend-owned product string catalog. Runtime consumers use ResolveText instead of reading catalogs directly.

Resolves a product-owned localizable string through the official runtime text gateway. Unknown keys return the supplied fallback text, then the key, without throwing or mutating culture.

Resolves the current UI culture through the official Localization / RTL product-layer gateway.

Returns the current right-to-left fact through the Localization-owned runtime snapshot.

Returns the current Localization-owned runtime culture / RTL snapshot without opening a public API.

Returns retained Localization/RTL fallback diagnostics for internal proof gates and official diagnostics surfaces.

Clears Localization/RTL fallback diagnostics for deterministic internal proof gates only.

Synchronizes the Friend-owned runtime culture snapshot with the current thread culture without mutating thread culture.

Internal product-host entry for explicitly switching the MAS-owned runtime culture. This does not mutate Thread.CurrentCulture or Thread.CurrentUICulture.

Returns Localization runtime ownership to the ambient thread-culture observer.

Evaluates whether the Localization / RTL foundation is ready for product-owned consumption.

Official public host gateway for the Nexamas UI-owned Localization / RTL product surface.

This gateway exposes a ready read-only/product-preview page only. It does not expose localization snapshots, culture catalogs, string catalogs, readiness reports, thread-culture mutation, resource loading, or a public translation API. Localization facts remain owned by LocalizationSystem.

Attaches the official Nexamas UI-owned Localization / RTL page to a MASApplicationWindow. External hosts receive a ready product page and never read localization contracts or catalogs.

Attaches the official Nexamas UI-owned Localization / RTL content to an existing Application page-builder scope such as MASApplicationWindow.Pages. The host supplies only the current MASApplicationWindow and MASApplicationLayoutPageBuilder; Nexamas UI still owns culture facts, direction rows, formatting previews, expansion rows, controls, and page layout.

Nexamas UI-owned internal Localization / RTL display surface.

The page consumes MASLocalization.CreateSnapshot only. It does not mutate thread-culture state, load resources, rewrite controls, mirror the external host, create a translation engine, or let demo code own Localization / RTL logic.

Internal catalog of the first official product cultures supported by the Phase 6 foundation.

The catalog is intentionally small and deterministic. It is not a resource loader and does not replace application translations. It gives Nexamas UI a stable product contract for LTR, German, and Arabic/RTL demonstrations before external consumer surfaces consume localization facts.

Internal deterministic sample catalog for the Phase 6 localization product layer.

This is not an application-wide translation database. It owns only foundation samples that prove localizable string shape, German expansion pressure, Arabic RTL text, and product-surface readiness.

Immutable Friend-only snapshot of the Localization-owned runtime culture/RTL state.

CultureName is the normalized product culture name, while CultureKey is the UI/format key consumed by MASRuntimeEnvironmentStamp and DataView. No thread culture is mutated by this snapshot.

Friend-only event payload for runtime Localization/RTL mutations.

Localization-owned runtime environment coordinator. It is the single Friend-only owner that announces runtime culture/RTL changes to host runtime-environment coordinators. It deliberately does not expose a public translation API and deliberately does not mutate Thread.CurrentCulture or Thread.CurrentUICulture.

Internal contract result that keeps UI layout direction and content text direction as separate facts.

Logical keyboard intent used by RTL-aware controls without exposing a new public API surface.

Friend-owned Localization/RTL contract for residual review: UI layout mirroring is derived from product culture, while content text direction is resolved from the string itself. Keyboard navigation mirrors horizontal arrow semantics in mirrored UI layout, but tab order remains logical for accessibility.

Internal diagnostic codes emitted when Localization/RTL resolution cannot honor the requested runtime culture.

Immutable Friend-only report for Localization/RTL fallback diagnostics.

Single Localization-owned diagnostic channel for RTL/culture fallback decisions.

Unknown RTL cultures must not collapse to the English/LTR product profile without a retained reason. This channel keeps bounded internal counters and also publishes a safe structured record through the existing MAS runtime fault channel so application diagnostics can surface the fallback without exposing Localization internals or opening a public catalog API.

Internal formatter that builds deterministic culture preview samples for the Phase 6 snapshot.

Formatting is isolated here so Nexamas UI has a single product-layer owner for culture preview facts. The builder does not alter thread culture or application culture.

Internal builder for the official Phase 6 Localization / RTL product-layer snapshot.

Severity of a Localization / RTL readiness finding.

Immutable readiness finding emitted by the Phase 6 Localization / RTL gate.

Immutable readiness report for the Phase 6 Localization / RTL product layer.

Readiness gate for the Phase 6 Localization / RTL product-layer foundation.

The gate validates product-layer snapshot facts only. It does not mutate current culture, UI controls, layout engines, thread state, resource files, rendering, or MASLocalizationRtl.AttachPage lifecycle. Public page attach proof is owned by a separate attach-lifecycle gate.

Severity for the Phase 4 Localization / RTL runtime ownership closure audit.

Immutable finding emitted by the Localization / RTL runtime ownership audit.

Immutable report for Localization / RTL runtime ownership closure.

Phase 4 closure audit for Localization / RTL runtime ownership. It does not introduce a new resource system, public translation API, or thread-culture mutation path. It proves that the existing LocalizationSystem owns culture facts, runtime text lookup, RTL/mirroring facts, and the public host route boundary.

Public readiness summary for the Nexamas UI Presentation Page system. It reports only stable product facts and does not expose layout internals or page-builder state.

Official semantic body-surface intents for MASPresentation pages. These are page-slot intents, not element-size presets: controls still keep their own MASSize.Default/Compact/Large contract, while Presentation chooses the slot budget through MASApplication/MASSizeLayout.

Internal readiness gate for the Presentation Page system. It protects the system contract from drifting back into local page-specific title, spacing, or footer rules while keeping implementation details internal to Nexamas.UI.

Public Nexamas UI gateway for product-style presentation pages. It owns the shared title/divider, description, body, and footer-action page recipe while preserving existing MAS controls and MASApplication layout as the only layout engine.

Begins an official presentation page by applying the MASApplication page preset and returning a constrained recipe builder for header/body/footer layout.

Internal MAS-owned entry point for pages whose Application host has already applied a specialized page profile. This keeps Application-owned surfaces on the Presentation header/body/footer grammar without forcing them through the public standard TopBar preset.

Evaluates whether the Presentation Page system is available as an official Nexamas UI gateway. The report exposes product facts only.

Official Nexamas UI presentation-page recipe builder. It is not a new renderer and not a second controls API; it applies the product page contract to the existing MASApplication LayoutPage gateway so pages share one header/body/footer language while still supplying their own content controls.

Adds the official page header: MASTitle title with divider, then an optional description label with breathing room. Pages must not recreate this with a compressed Section(title, description) call.

Adds a body-section heading and optional instruction/description label below the page header using the same official spacing policy as other product pages.

Adds a full-width body control through the underlying official LayoutPage gateway.

Adds a full-width body control while preserving the control's own MASSize intent as the retained source of truth. MAS-owned dashboard pages use this for read-model driven surfaces that can collapse or cap their visible rows.

Adds a semantic full-width body surface. Use this for list/tree/grid/preview bodies instead of carrying local OffsetHeight numbers in product pages.

Adds the official single-list presentation slot.

Adds the official paired-collection presentation slot.

Adds the official tree presentation slot.

Adds the official tile-gallery presentation slot.

Adds the official data-grid presentation slot.

Adds an official narrative/surface row: explanatory MAS content in the left pane and a semantic Presentation surface in the right pane. This is the correct route for product/demo pages that need text beside a list/tree/grid without local widths or ad-hoc showcase helpers.

Adds an official narrative/surface row with an optional secondary proof/notes label stacked under the primary narrative text.

Adds an official text-left/default-control-right inspection surface. Use this for focused controls such as segmented controls, tabs, and selector items where the page must keep narrative text out of the header but must not promote those controls into list/tree/data surfaces or introduce demo-local widths.

Starts an internal narrative/control split for MAS-owned Application pages that need Application-specific surface sizing while still taking the narrative pane size intent from Presentation. Application code must use this gateway instead of calling MASPresentationPageMetrics directly.

Adds a body grid with semantic MASLayout spacing. The returned grid builder is still the official MASApplication grid builder, so consumers do not receive a parallel layout engine.

Adds a footer action group at the bottom of the page. Use this for page commands instead of placing buttons as arbitrary body rows.

Adds one full-width footer action for simple pages that expose a single primary command.

Internal size policy for Nexamas UI presentation pages. It centralizes the header, section-intro, and footer-action slots so product/demo pages do not repeat title heights, description breathing room, or bottom action sizing.