markswift 0.0.0-stage → 2.0.0

package/dist/types/analysis/bands.d.ts

@@ -0,0 +1,53 @@
+import type { LayoutCondition } from "../model/layout.ts";
+import type { BandEdge } from "../model/semantic.ts";
+/** Narrowest width a band covers: thresholds at or below it never switch a phone layout. */
+export declare const BAND_MIN = 320;
+/** Most captures one conversion makes. */
+export declare const BAND_CAP = 6;
+export declare const DEFAULT_BAND_DEVICES: ReadonlyArray<{
+    width: number;
+    height: number;
+}>;
+export interface BandPlan {
+    /** CSS viewport edges, ascending; `edges.length === captures.length - 1`. */
+    edges: BandEdge[];
+    /** One per band, ascending; the band's lowest capture, which represents it. */
+    captures: Array<{
+        width: number;
+        height: number;
+    }>;
+    /** Container queries: one more capture per band at its upper bound (the band capture's height), lowest bands first;
+     * then, lowest bands first, a band other than band 0 and `first`'s is captured at its lower bound instead and its
+     * device capture moves here; while captures + extra stay ≤ BAND_CAP. `[]` without container queries. */
+    extra: Array<{
+        width: number;
+        height: number;
+    }>;
+    /** Probe width per band (used only when the band's capture needs a probe). */
+    probes: Array<number | undefined>;
+    /** Thresholds not reconstructed, as warning messages. */
+    notes: string[];
+}
+/** Tailwind's default breakpoints by `min-width` px. */
+export declare const TAILWIND_BANDS: Record<number, string>;
+/** Tailwind's container scale (`@md`, …) by `min-width` px. */
+export declare const TAILWIND_CONTAINER_BANDS: Record<number, string>;
+/** One name per band: band 0 `""`, band `k` its lower CSS edge — a Tailwind default name, else `w<capture width>`.
+ * `prefix` (`cq_`): container bands, named from Tailwind's container scale. */
+export declare function bandNames(cssEdges: BandEdge[], prefix?: string): string[];
+/** A width `@container` query attributed to a host node: the conversion reconstructs it at that host. */
+export declare function isContainerQuery(c: LayoutCondition): boolean;
+/** Edges ascending by capture width, `min-width` first on ties; one edge per capture width. */
+export declare function uniqueEdges(all: BandEdge[]): BandEdge[];
+/** Band edges from the `media` width conditions, one capture and probe width per band (+ `extra`, container queries). */
+export declare function planBands(conditions: LayoutCondition[], options: {
+    first: {
+        width: number;
+        height: number;
+    };
+    devices: ReadonlyArray<{
+        width: number;
+        height: number;
+    }>;
+    max: number;
+}): BandPlan;

package/dist/types/analysis/breakpoints.d.ts

@@ -0,0 +1,22 @@
+import type { LayoutDoc } from "../model/layout.ts";
+import { type BandEdge, type ConversionWarning, type SemNode, type Screen } from "../model/semantic.ts";
+/** Root-proposal edges of a set of band captures (and each capture's band), or the reason the root does not follow
+ * the viewport. Every band holds a capture, ascending by width; more than one only on pages with container queries
+ * (the planner's `extra`). */
+export declare function bandEdges(docs: LayoutDoc[]): {
+    edges: BandEdge[];
+    cssEdges: BandEdge[];
+    bands: number[];
+} | {
+    warning: string;
+};
+/**
+ * Compose per-capture screens into one root with holders and query containers; undefined when no element differs
+ * between captures and nothing is reported (the root is band 0's when only warnings are). `bands`: each capture's
+ * viewport band (ascending; default one capture per band). A band's lowest
+ * capture represents it; the others are container-query captures, seen only by the query containers inside.
+ */
+export declare function mergeBands(docs: LayoutDoc[], screens: Screen[], bands?: number[]): {
+    root: SemNode;
+    warnings: ConversionWarning[];
+} | undefined;

package/dist/types/analysis/class-hints.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Colour names a design put in a class list — the utility-framework counterpart of
+ * `var(--token)` in an inline style. Pure and input-agnostic: a page with no colour
+ * utilities yields nothing, so the inference pass can always ask.
+ */
+/**
+ * Token-hint channel for the emit pass: the *semantic* part of a node's colour utilities, in
+ * the same `Style.tokens` list that carries CSS custom-property names, qualified by the utility
+ * that painted it (`bg-card` → `bg:card`, `text-muted-foreground` → `text:muted-foreground`,
+ * `from-sky-500` → `from:sky-500`). The qualifier is what lets the token pass match a name to
+ * the slot its utility paints — one node's `bg-white text-black` are two names for two slots,
+ * not two candidates for either — and `tokens.ts` camelizes the name (`Palette.sky500`).
+ * A custom-property name never contains `:`, so the two kinds cannot collide.
+ *
+ * Every variant (`dark:`, `hover:`, `md:`, `focus:`) is dropped. `hover:`/`md:` name states the
+ * static capture never sees; a `dark:` utility names the *dark* value of the slot, and one hint
+ * list per node cannot say which theme a hint belongs to, so using it would name the light colour
+ * after its dark counterpart (`text-slate-500 dark:text-slate-400` → `slate400`). Arbitrary
+ * values (`bg-[#0f172a]`) carry no name and are dropped.
+ */
+export declare function classColorHints(attrs: Record<string, string>): string[];

package/dist/types/analysis/context.d.ts

@@ -0,0 +1,49 @@
+/** Shared inference data contracts. No runtime dependencies. */
+import { type LayoutNode, type Rect } from "../model/layout.ts";
+import { type LabelIndex } from "./controls.ts";
+import { type SemNode, type Axis, type CrossAlign, type TextRun } from "../model/semantic.ts";
+import { type BundledFamilies } from "../model/fonts.ts";
+import { type TableSlots } from "./table.ts";
+/** A text run: one text node and the element whose computed style it inherits. */
+export interface SourceTextRun {
+    node: LayoutNode;
+    styleOf: LayoutNode;
+}
+export interface AnalyzedChild {
+    node: LayoutNode;
+    sem: SemNode;
+}
+export interface InferOptions {
+    /** Fonts packaged for this conversion; omitted families use system fallback. */
+    bundledFamilies?: BundledFamilies;
+}
+export interface InferenceContext {
+    bundledFamilies: BundledFamilies;
+    /** Capture root; lets SVG `<use>` resolve sprites elsewhere in the document. */
+    root: LayoutNode;
+    /** `position: fixed` descendants collected for hoisting onto the screen root. */
+    fixed: LayoutNode[];
+    parent?: LayoutNode;
+    parentAxis?: Axis;
+    parentDisplay?: string;
+    parentAlign?: CrossAlign;
+    /** Nearest ancestor with `background-clip: text`: its gradient is the glyph fill of block descendants' text. */
+    textClip?: LayoutNode;
+    /** Capture viewport in root coordinates (see LayoutDoc.viewport). */
+    viewport?: Rect;
+    /** `<label>` ↔ control pairs of the capture; absent in hand-built contexts. */
+    labels?: LabelIndex;
+    /** The rows box `captionOutside` split off an admitted table, and its slots: `build` lays it out as the table. */
+    table?: {
+        rows: LayoutNode;
+        slots: TableSlots;
+    };
+}
+/** A run under construction: the emitted run plus, per character, its index in the raw text node. */
+export interface MeasuredTextRun {
+    run: TextRun;
+    node: LayoutNode;
+    /** The element whose computed style the run inherits — `host` itself for its own text nodes. */
+    styleOf: LayoutNode;
+    src: number[];
+}

package/dist/types/analysis/controls.d.ts

@@ -0,0 +1,97 @@
+/**
+ * HTML controls → `ControlNode`. Tag plus attributes decide *what* the element is; the measured
+ * box, padding and paint still come from the generic inference pass, so a control looks exactly
+ * like the box it replaced and only gains its interactive core.
+ *
+ * Nothing here reads geometry: `input[type=range]` is a slider however the design paints it.
+ */
+import type { LayoutNode } from "../model/layout.ts";
+import type { Color } from "../model/values.ts";
+import { type Action, type ControlKind, type ControlNode, type Diagnostic, type FontSpec, type PickerOption, type SemBase, type SemNode } from "../model/semantic.ts";
+/** An element's own action: its `onclick`, else the submit handler of its form, else a member of its own. */
+export declare function elementAction(n: LayoutNode, caption: string, form?: LayoutNode): Action;
+/** `<form onsubmit>`: what its submit buttons and Return in its fields run. */
+export declare function submitAction(form: LayoutNode): Action | undefined;
+/** An `<a href>` the app must resolve itself (fragment, relative path); undefined for an absolute URL. */
+export declare function linkAction(a: LayoutNode): Action | undefined;
+/**
+ * The action of an element the design makes activatable without being a control (`<div role=button
+ * onclick>`, `<li onclick>`). It stays the view it is — same layout — and the emitter wraps it in a
+ * Button; one that contains another control gets a tap gesture instead.
+ */
+export declare function activatableAction(n: LayoutNode): Action | undefined;
+/** `controlOf`'s answer: which control an element is, with the attribute state the design shows. */
+export interface ControlSpec {
+    control: ControlKind;
+    value?: string;
+    swatch?: Color;
+    placeholder?: string;
+    promptColor?: Color;
+    inputType?: ControlNode["inputType"];
+    autofill?: string;
+    inputMode?: string;
+    enterKey?: string;
+    checked?: boolean;
+    group?: string;
+    form?: string;
+    disabled?: boolean;
+    range?: {
+        min: number;
+        max: number;
+        step?: number;
+    };
+    level?: ControlNode["level"];
+    options?: PickerOption[];
+    href?: string;
+    action?: Action;
+    expanded?: boolean;
+    files?: ControlNode["files"];
+    dateKind?: ControlNode["dateKind"];
+    /** Losses to record on the node (a link with no runtime destination, an unsupported input type). */
+    diagnostics: Diagnostic[];
+}
+/**
+ * The control this element is, or `undefined` when it is an ordinary box. Attribute-only: the
+ * caller supplies the measured base and the built children; `labels` adds what the element's
+ * surroundings decide (its form owner, a `<fieldset disabled>` around it).
+ */
+export declare function controlOf(n: LayoutNode, labels?: LabelIndex): ControlSpec | undefined;
+/** A control's laid-out surroundings, as the generic container path produced them. */
+export interface ControlParts {
+    /** The box the generic path would have painted: frame, padding, style, diagnostics. */
+    base: SemBase;
+    /** Element children, in document order, already built. */
+    children: Array<{
+        node: LayoutNode;
+        sem: SemNode;
+    }>;
+    /** The element's own text, one node per run group. */
+    texts: SemNode[];
+    /** Font and colour of the element's own text, for the value the control draws itself. */
+    font?: FontSpec;
+    color?: Color;
+    /** Computed `appearance` and `accent-color` of the element. */
+    appearance?: string;
+    accent?: Color;
+}
+/**
+ * The control node: `spec`'s attribute state on `parts.base`'s measured box. Children become
+ * `content` in measured order (a `<summary>` becomes the disclosure's `label` instead).
+ */
+export declare function buildControl(spec: ControlSpec, parts: ControlParts): ControlNode;
+/** `<label>` ↔ control (HTML: `for` names an element id; otherwise the first control inside). */
+export interface LabelIndex {
+    /** Control element → its label's text (the label's text content without the control's own). */
+    text: Map<LayoutNode, string>;
+    /** Label element → the enabled toggle/radio (native, or an ARIA toggle role) a tap on the label changes, or text field it focuses. */
+    activates: Map<LayoutNode, LayoutNode>;
+    /** `<input>`/`<button>` → its form owner (HTML: the `<form>` its `@form` names, else its nearest ancestor `<form>`). */
+    forms: Map<LayoutNode, LayoutNode>;
+    /** Form controls a `<fieldset disabled>` disables (everything in it but its first `<legend>`). */
+    disabled: Set<LayoutNode>;
+    /** First element per DOM `id`. */
+    byId: Map<string, LayoutNode>;
+    /** `role=radio` element → the id of its nearest `role=radiogroup` ancestor. */
+    radioGroups: Map<LayoutNode, string>;
+}
+export declare function labelIndex(root: LayoutNode): LabelIndex;

package/dist/types/analysis/flex-row.d.ts

@@ -0,0 +1,14 @@
+/** Authored flex rows the runtime `MarkswiftFlexRow` reproduces, admitted only when they reproduce the capture. */
+import type { LayoutNode } from "../model/layout.ts";
+import type { FlexItem, FlexRow } from "../model/semantic.ts";
+/**
+ * Item widths for a content width, mirroring MarkswiftFlexRow.widths (runtime/flex-row.swift): CSS's flex freeze
+ * loop (css-flexbox §9.7) with min/max clamps, shrink weighted by the inner basis and factor sums below 1.
+ * `bases`: each item's px basis (the px part for a percentage basis, resolved here against `width`).
+ */
+export declare function solveFlexRow(items: FlexItem[], bases: number[], width: number, gap: number): number[];
+/**
+ * The admitted row, or undefined. Pure on the captured LayoutNode, memoised. `atProbe` skips the candidate gate
+ * (step 5): a probe capture verifies the solver, and at another width the native HStack may suffice (unshrunk items).
+ */
+export declare function admitFlexRow(n: LayoutNode, atProbe?: boolean): FlexRow | undefined;

package/dist/types/analysis/flex-sizing.d.ts

@@ -0,0 +1,5 @@
+import type { LayoutNode } from "../model/layout.ts";
+import { type Axis, type Size, type Diagnostic } from "../model/semantic.ts";
+import type { InferenceContext } from "./context.ts";
+/** Native stacks can share equal leftover space, but cannot reproduce arbitrary CSS allocation. */
+export declare function flexGrowthSize(n: LayoutNode, axis: Axis, ctx: InferenceContext, diagnostics: Diagnostic[]): Size | undefined;

package/dist/types/analysis/flow-layout.d.ts

@@ -0,0 +1,18 @@
+/** Flow, float, stack and grid layout inference. */
+import { type SemBase, type CrossAlign, type Distribution, type StackNode, type Axis } from "../model/semantic.ts";
+import { type AnalyzedChild } from "./context.ts";
+/**
+ * Stack geometry from measured child frames: spacing per adjacent pair (uniform when equal),
+ * and the leading offset the base's padding does not explain. A float's neighbour overlaps its
+ * box (the browser shortens line boxes instead of the block), so the gap is the float's margin;
+ * a negative `margin-top` really does overlap, and negative spacing reproduces it.
+ */
+export declare function stackOf(base: SemBase, axis: Axis, all: AnalyzedChild[], align: CrossAlign, distribution: Distribution, flex?: boolean): StackNode;
+/**
+ * Measured lines: items overlapping vertically (by more than half the shorter box) and clear of
+ * each other horizontally share a line. Boxes that overlap on both axes are not a line but a
+ * negative margin — except around a float, whose neighbour's box overlaps it while its ink does
+ * not (the browser shortens the line boxes, not the block). Lines run top→bottom, items in a
+ * line left→right.
+ */
+export declare function linesOf(all: AnalyzedChild[]): AnalyzedChild[][];

package/dist/types/analysis/generated.d.ts

@@ -0,0 +1,16 @@
+/** Generated content (`::before`/`::after`/`::marker`): inline images, counters, alt text, undrawn images. */
+import { type LayoutNode } from "../model/layout.ts";
+import { type TextRun } from "../model/semantic.ts";
+/** Content-bearing pseudo-elements (not `::backdrop` and other boxes without `content`). */
+export declare const PSEUDO: Readonly<Record<string, true>>;
+/** An `img` child of a pseudo whose bytes were captured (`data:`): it rides in the pseudo's text as an image run. */
+export declare function inlineImage(parent: LayoutNode, k: LayoutNode): boolean;
+/** The alt text of a pseudo's generated image: `content: url(…) / "alt"`, else `""` (decorative); undefined off a pseudo. */
+export declare function generatedAlt(p: LayoutNode | undefined): string | undefined;
+/** A pseudo that names more `url()` images than the browser laid out: the diagnostic reporting the loss. */
+export declare function undrawnImages(p: LayoutNode): {
+    feature: "content" | "list-style-image";
+    message: string;
+} | undefined;
+/** The counter a pseudo printed as `text` (a counter `list-style-type` marker, `content: counter()`), if regenerable. */
+export declare function counterOf(el: LayoutNode, text: string): TextRun["counter"];

package/dist/types/analysis/geometry.d.ts

@@ -0,0 +1,50 @@
+/** Measured box geometry and reusable inset calculations. */
+import { type LayoutNode, type Rect } from "../model/layout.ts";
+import { type SemNode, type Axis } from "../model/semantic.ts";
+/** Rendered at all: a `display: none` box is collapsed away by the browser, so we drop it too. */
+export declare function renders(n: LayoutNode): boolean;
+/**
+ * Does this box lie entirely left of the content box that starts at `x`? A
+ * `list-style-position: outside` marker does: it hangs in the parent's padding and takes no
+ * part in the flow, so the text column keeps its own width and wrapped lines stay aligned
+ * under the first one. `stackOf` drops such a child; `buildOverlays` draws it where it was.
+ */
+export declare function hangsLeading(box: Rect, x: number): boolean;
+/** Any descendant that fills its width — such a subtree stays greedy inside a hugging container. */
+export declare function fillsWidthInside(n: SemNode): boolean;
+/** Taken out of normal flow to one side, with the line boxes beside it shortened. */
+export declare function floating(n: LayoutNode): boolean;
+/** Positioned out of normal flow (`absolute`/`fixed`): placed as an overlay, never laid out by its parent. */
+export declare function outOfFlow(n: LayoutNode): boolean;
+/**
+ * Used offset of a `position: relative` box from its Typed-OM insets (046; the snapshot's computed `top` reports a `%`
+ * against an auto-height block as px Chrome never applies). `top` beats `bottom`; `left` beats `right` unless the
+ * containing block (`cb`, the DOM parent) is rtl. `%` resolves against `cb`'s content box; a `%` top/bottom against an
+ * indefinite height is `auto`, so the other side applies (`top:10%; bottom:5px` → −5, as Chrome). `[0, 0]` for every
+ * other box. `losses` are diagnostic messages.
+ */
+export declare function relativeOffset(n: LayoutNode, cb: LayoutNode | undefined): {
+    offset: [number, number];
+    losses: string[];
+};
+/** A computed `display` that lays out its children as a flex container (`flex`, `inline-flex`). */
+export declare function isFlex(display: string | undefined): boolean;
+/** The axis `n` stacks its children on: horizontal only for a row-direction flex container. */
+export declare function mainAxis(n: LayoutNode): Axis;
+/**
+ * Tops of the measured line boxes under `el`. DOMSnapshot reports inline *fragments* — Blink
+ * splits one at every collapsed source newline — so fragments that share a top edge are one
+ * line; the same grouping `markLineBreaks` uses to place the forced breaks.
+ */
+export declare function lineTops(el: LayoutNode): number[];
+export declare const EDGES: readonly ["top", "right", "bottom", "left"];
+export type EdgeName = (typeof EDGES)[number];
+/** Border width of one edge; 0 when its style paints nothing. */
+export declare function edgeWidth(s: Record<string, string>, edge: EdgeName): number;
+/**
+ * Padding + border per edge (top, right, bottom, left): the distance from the box edge to its content.
+ * Rows and row groups have none: CSS ignores their padding, a collapsed border lies inside the cells' boxes
+ * and a separated one is not drawn.
+ */
+export declare function insetsOf(s: Record<string, string>): [number, number, number, number];
+export declare function unionRect(a: Rect, b: Rect): Rect;

package/dist/types/analysis/grid-tracks.d.ts

@@ -0,0 +1,44 @@
+/** Authored grid tracks the runtime `MarkswiftTracks` reproduces, admitted only when they reproduce the capture. */
+import type { LayoutNode } from "../model/layout.ts";
+import type { GridPlacement, GridRowTrack, GridTemplate } from "../model/semantic.ts";
+/**
+ * Column widths for a content width, mirroring MarkswiftTracks.columns (runtime/tracks.swift). fr tracks follow CSS's
+ * "find the size of an fr": an fr sum below 1 leaves space unused, and a track whose `minmax(<px>, fr)` floor exceeds
+ * its share freezes at the floor while the rest share again.
+ */
+export declare function solveTracks(t: GridTemplate, width: number, gap: number, count: number, autoWidths: number[]): number[];
+/**
+ * Row heights, mirroring MarkswiftTracks.rowHeights (runtime/tracks.swift). CSS grid §12.5 for heights (an item's min-
+ * and max-content heights are equal): a spanning item's missing height goes equally to its spanned auto rows that no
+ * item has sized yet, else equally to all its spanned auto rows; same-span items take the max per row, smaller first.
+ */
+export declare function solveRows(rows: GridRowTrack[], autoRow: GridRowTrack, gap: number, items: Array<{
+    row: number;
+    span: number;
+    height: number;
+}>): number[];
+type Span = {
+    start?: number;
+    span: number;
+};
+/**
+ * CSS grid §8.5 auto-placement, `grid-auto-flow: row` (sparse), in a grid of `k` explicit columns: items with both
+ * lines first, then items locked to a row, then the rest behind a cursor. Each item's 1-based [column, row] start, or
+ * undefined when an item needs an implicit column or two items with both lines overlap.
+ */
+export declare function placeItems(k: number, items: Array<{
+    col: Span;
+    row: Span;
+}>): Array<[number, number]> | undefined;
+/**
+ * The authored template, rows and every item's placement when the solvers reproduce every captured cell within 1px;
+ * else undefined.
+ */
+export declare function admitTracks(n: LayoutNode): {
+    template: GridTemplate;
+    stretch: boolean;
+    rows?: GridRowTrack[];
+    autoRow?: GridRowTrack;
+    placements: GridPlacement[];
+} | undefined;
+export {};

package/dist/types/analysis/grid.d.ts

@@ -0,0 +1,5 @@
+/** Native-grid admission is proven from resolved tracks and captured cell geometry. */
+import type { LayoutNode } from "../model/layout.ts";
+import { type GridNode, type SemBase } from "../model/semantic.ts";
+import type { AnalyzedChild } from "./context.ts";
+export declare function buildGrid(n: LayoutNode, base: SemBase, all: AnalyzedChild[]): GridNode;

package/dist/types/analysis/infer.d.ts

@@ -0,0 +1,18 @@
+/** Layout tree traversal and semantic node dispatch. */
+import { type LayoutDoc, type LayoutNode } from "../model/layout.ts";
+import { type Screen, type SemNode, type Overlay } from "../model/semantic.ts";
+import { type InferOptions } from "./context.ts";
+export declare function inferScreen(doc: LayoutDoc, name: string, options?: InferOptions): Screen;
+/**
+ * A node outside the captured tree (an in-flow layer's content, `layers.ts`) built as a child of `parent`. Fixed
+ * descendants are not hoisted: `fixed` counts the ones left out.
+ */
+export declare function buildDetached(node: LayoutNode, parent: LayoutNode, doc: LayoutDoc, options?: InferOptions): {
+    sem: SemNode;
+    fixed: number;
+};
+/**
+ * A presented layer's roots (`layers.ts`) as root overlays, built like the screen's own fixed nodes (fixed
+ * descendants drained into further roots); every one is `fixed`.
+ */
+export declare function layerOverlays(doc: LayoutDoc, nodes: LayoutNode[], options?: InferOptions): Overlay[];

package/dist/types/analysis/invisible.d.ts

@@ -0,0 +1,6 @@
+/** Paint that is invisible at rest and can never become visible is wasted render work: drop it from the IR. */
+import { type SemNode } from "../model/semantic.ts";
+/** Removes invisible overlays; an invisible in-flow node keeps its space but draws nothing. Never touches `n` itself. */
+export declare function dropInvisible(n: SemNode): void;
+/** Keeps `hitTesting: false` where it changes a tap: on overlays (they paint over siblings), outermost only. */
+export declare function pruneHitTesting(n: SemNode, overlay?: boolean, inside?: boolean): void;

package/dist/types/analysis/layers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * App mode: closed in-flow layers (`<details>`, collapsibles, accordion items) become content behind the screen's state;
+ * dialogs, sheets, popovers and hover cards become drawn presentations (plan 060, D-PRESENT); menus and listboxes
+ * become the trigger's native `Menu` (plan 061, D-MENUS).
+ */
+import { type LayoutDoc } from "../model/layout.ts";
+import { type Screen } from "../model/semantic.ts";
+import { type InferOptions } from "./context.ts";
+/**
+ * Each `inflow` layer of `doc`: a `<details>` gets the content and `opens`; anything else inserts the content into its
+ * plain parent stack after its rest predecessor (`shownBy`), and the trigger Button `opens` it. A menu or listbox layer
+ * becomes its trigger's native menu (`menu`); each other layer that is not a tooltip (062) becomes a drawn presentation
+ * on the root (`present`). Skips are reported.
+ */
+export declare function applyLayers(screen: Screen, doc: LayoutDoc, options?: InferOptions): void;

package/dist/types/analysis/measured-layout.d.ts

@@ -0,0 +1,6 @@
+/** A shared coordinate contract for captured grid and wrapping fallbacks. */
+import type { MeasuredLayout, SemBase, SemNode } from "../model/semantic.ts";
+import type { AnalyzedChild } from "./context.ts";
+/** Captured fallbacks stack their children in global paint order (z-index), not DOM order. */
+export declare function paintOrder(items: AnalyzedChild[]): AnalyzedChild[];
+export declare function measuredLayoutOf(base: SemBase, children: SemNode[]): MeasuredLayout;

package/dist/types/analysis/motion.d.ts

@@ -0,0 +1,29 @@
+/** CSS `@keyframes` animations captured by `browser/motion.ts` → IR `Motion` (D-MOTION), with per-node diagnostics. */
+import type { Anim, LayoutNode } from "../model/layout.ts";
+import { type Diagnostic, type Motion, type SemBase, type SemNode, type Style } from "../model/semantic.ts";
+/**
+ * Captured pressed/focused transitions → per paint field timing, only for fields the node's look changes. `reduced`
+ * is the author's reduce lists, else D-MOTION's fallback: movement (`transform`) jumps, fades keep their timing.
+ */
+export declare function transitionsOf(n: LayoutNode, states: SemBase["states"], diagnostics: Diagnostic[]): Motion["transitions"];
+/** LayoutNode.motion → IR motion + per-node diagnostics. Undefined when nothing is mapped. Inference is mode-independent. */
+export declare function motionOf(n: LayoutNode, style: Style, diagnostics: Diagnostic[]): Motion | undefined;
+/**
+ * In-flow layer content (066): `height` keyframes from 0 to the node's own height (or `auto`) open it, the reverse
+ * closes it; their timing becomes `reveal`, and the lists come back without `height`. Other shapes are reported.
+ */
+export declare function revealOf(n: LayoutNode, diagnostics: Diagnostic[]): {
+    reveal?: NonNullable<Motion["reveal"]>;
+    enter: Anim[];
+    exit: Anim[];
+};
+/**
+ * A layer root's captured enter and exit (066), after its placement is decided (`analysis/layers.ts`): the enter joins
+ * `animations` (the root is inserted when its layer opens, so it plays on appear) with D-MOTION's fallback under Reduce
+ * Motion (movement removed, opacity kept); the first exit becomes `exit`, exact for two keyframes starting at the
+ * settled look, else played first → last (reported).
+ */
+export declare function layerMotionOf(n: LayoutNode, sem: SemNode, lists: {
+    enter: Anim[];
+    exit: Anim[];
+}): void;

package/dist/types/analysis/naming.d.ts

@@ -0,0 +1,6 @@
+/** Name hints from an element's own markup: what generated Swift names (components, fields) may use. */
+import type { SemBase } from "../model/semantic.ts";
+/** First of `data-markswift-component`, `id`, `data-slot`, `aria-label`, first non-utility class, tag noun. */
+export declare function nameHintOf(tag: string, attrs: Record<string, string>): SemBase["nameHint"];
+/** Trimmed `data-markswift-field`; undefined when absent or empty. */
+export declare function fieldOf(attrs: Record<string, string>): string | undefined;

package/dist/types/analysis/node-base.d.ts

@@ -0,0 +1,13 @@
+/** Semantic node base construction and confidence classification. */
+import { type SemNode, type SemBase } from "../model/semantic.ts";
+import { type LayoutNode } from "../model/layout.ts";
+import { type InferenceContext } from "./context.ts";
+export declare function finish<T extends SemNode>(node: T): T;
+export declare function withBase<T extends Partial<SemNode>>(n: LayoutNode, ctx: InferenceContext, extra: T): SemNode;
+/**
+ * The element and every rendered element below it compute `pointer-events: none` (an `auto` descendant stays
+ * hittable in CSS). `pointer-events` inherits: a child with no key and no children (046's synthetic pseudo `img`,
+ * `styles: {}`) passes under a `none` parent.
+ */
+export declare function passesTaps(n: LayoutNode): boolean;
+export declare function makeBase(n: LayoutNode, ctx: InferenceContext, declared: Record<string, string>): SemBase;

package/dist/types/analysis/size-constraints.d.ts

@@ -0,0 +1,5 @@
+/** Normalize browser-computed CSS constraints to the semantic border-box contract. */
+import type { LayoutNode } from "../model/layout.ts";
+import { type SizeConstraints, type Diagnostic } from "../model/semantic.ts";
+import type { InferenceContext } from "./context.ts";
+export declare function constraintsOf(n: LayoutNode, declared: Record<string, string>, ctx: InferenceContext, diagnostics: Diagnostic[]): SizeConstraints;

package/dist/types/analysis/sizing.d.ts

@@ -0,0 +1,24 @@
+/** Intrinsic versus fixed sizing inferred from measured content. */
+import { type LayoutNode } from "../model/layout.ts";
+import { type Size, type SizeConstraints, type Diagnostic } from "../model/semantic.ts";
+import { type InferenceContext } from "./context.ts";
+/**
+ * The box's bottom inset as the browser left it: its own padding, plus the last in-flow child's
+ * bottom margin when a padded box keeps it from collapsing through. A hugging box has nowhere
+ * else to put that gap — a stack's spacing only lives between children — so it becomes inset.
+ * Only for boxes whose children are all elements: text-node boxes are glyph areas, and their
+ * line-box slack would masquerade as a margin. Capped at padding + that margin: any further
+ * slack is placement (min-height, flex alignment), never padding.
+ */
+export declare function trailingInset(n: LayoutNode, height: Size, padBottom: number): number;
+/**
+ * Cascaded preferred width/height retain fixed-size intent; older captures use inline styles.
+ * Otherwise geometry tells: parent content box → fill, own content → hug, other sizes →
+ * measured pixels. Flex allocation and constraints share the same border-box contract.
+ */
+export declare function sizeOf(n: LayoutNode, d: Record<string, string>, ctx: InferenceContext, diagnostics: Diagnostic[]): SizeConstraints & {
+    width: Size;
+    height: Size;
+    selfAlign?: "start" | "center" | "end";
+    selfAlignV?: "start" | "center" | "end";
+};

package/dist/types/analysis/style-background.d.ts

@@ -0,0 +1,24 @@
+/** Computed background paint and text-clipped gradients. */
+import type { LayoutNode, Rect } from "../model/layout.ts";
+import { type Diagnostic } from "../model/semantic.ts";
+import type { Paint } from "../model/values.ts";
+/** `background-clip: text`: the element's gradient paints the glyphs of every text run below it. */
+export declare function clipsText(el: LayoutNode): boolean;
+/**
+ * `background-clip: text` — the box's first gradient layer becomes the glyph fill of `run`
+ * (a text-node box inside `el`), re-expressed over that box since native text fills span the
+ * glyph run while the browser painted across the whole element. Text builders attach it to
+ * the run; `styleOf` drops the box fills in return.
+ */
+export declare function textPaintOf(el: LayoutNode, run: Rect): Paint | undefined;
+/**
+ * `url()` layer `i` of `background-*` / `mask-*` → image paint with its size, top-left
+ * position and repeat resolved in px. The position needs the drawn size: explicit
+ * `background-size`, the natural size (a data: svg's width/height, an embedded raster's
+ * header; a viewBox-only svg has just a ratio and fits the positioning area, per CSS), or the
+ * cover/contain scaling of that; unknown (remote files) → only a `0% 0%` position is certain.
+ * A data: svg is parsed here into the paint's `vector`; one that cannot be drawn is reported
+ * to `diagnostics`.
+ */
+export declare function imagePaint(url: string, s: Record<string, string>, prop: "background" | "mask", i: number, w: number, h: number, diagnostics: Diagnostic[]): Paint;
+export declare function backgroundFills(s: Record<string, string>, w: number, h: number, diagnostics: Diagnostic[]): Paint[];

package/dist/types/analysis/style-border.d.ts

@@ -0,0 +1,7 @@
+/** CSS border geometry and Chrome's 3D edge shading. */
+import { type Style, type Diagnostic } from "../model/semantic.ts";
+/** The 1px themed edge Chrome paints instead of `s`'s computed border, when it draws its theme. */
+export declare function themedBorder(tag: string, s: Record<string, string>): Partial<Style> | undefined;
+/** The fill and edge Chrome's theme paints while the button is pressed. */
+export declare function themedPressed(tag: string, s: Record<string, string>): Partial<Style> | undefined;
+export declare function borderStyle(s: Record<string, string>, w: number, h: number, diagnostics: Diagnostic[]): Partial<Style>;

package/dist/types/analysis/style-effects.d.ts

@@ -0,0 +1,4 @@
+/** Visual effects, clipping, visibility and design-token hints. */
+import type { LayoutNode } from "../model/layout.ts";
+import { type Style, type Diagnostic } from "../model/semantic.ts";
+export declare function applyEffects(n: LayoutNode, style: Style, diagnostics: Diagnostic[]): void;

package/dist/types/analysis/style.d.ts

@@ -0,0 +1,9 @@
+/** Computed visual styles and paint inference. */
+import { type LayoutNode } from "../model/layout.ts";
+import { type Style, type Diagnostic, type SemBase } from "../model/semantic.ts";
+export declare function styleOf(n: LayoutNode, diagnostics: Diagnostic[]): Style;
+/**
+ * `n.states` → paint deltas against the resting `rest`, by running `styleOf` on the state's computed
+ * values. A theme-painted button is pressed in Chrome's pressed theme, which no computed style shows.
+ */
+export declare function stateStylesOf(n: LayoutNode, rest: Style): SemBase["states"];

package/dist/types/analysis/svg/attributes.d.ts

@@ -0,0 +1,10 @@
+/** SVG presentation attributes, inherited values and references. */
+import { type LayoutNode } from "../../model/layout.ts";
+import { type SvgScope, type SvgContext } from "./context.ts";
+export declare function inherit(parent: Record<string, string>, own: Record<string, string>): Record<string, string>;
+/** Presentation value: computed style first, attribute fallback; inside a `<use>` instance `currentColor` follows the use element. */
+export declare function styleProp(c: LayoutNode, attrs: Record<string, string>, k: string, scope: SvgScope): string | undefined;
+/** `url(#id)` target from an attribute or the inline `style` (non-whitelisted properties such as `clip-path`/`mask`). */
+export declare function reference(c: LayoutNode, attrs: Record<string, string>, k: string, ctx: SvgContext): LayoutNode | undefined;
+export declare function parseDash(s: string | undefined): number[];
+export declare function num(s: string | undefined, def?: number): number;

package/dist/types/analysis/svg/build.d.ts

@@ -0,0 +1,6 @@
+/** Build semantic SVG nodes from measured layout trees. */
+import { type LayoutNode } from "../../model/layout.ts";
+import { type SemBase, type SvgNode } from "../../model/semantic.ts";
+import { type BundledFamilies } from "../../model/fonts.ts";
+/** Build the SvgNode for `n` on top of an already-measured `base` (frame, style, padding). `doc` is the document root used to resolve `#id` references. */
+export declare function buildSvg(n: LayoutNode, base: SemBase, doc?: LayoutNode, bundledFamilies?: BundledFamilies): SvgNode;