markswift 0.0.0-stage → 2.0.0

package/dist/types/model/values.d.ts

@@ -0,0 +1,125 @@
+/** IR value types: what the parsers in css/ produce and the emitters consume. No parsing here. */
+import type { SvgNode } from "./semantic.ts";
+/** sRGB color, channels 0..1 (wide-gamut inputs are gamut-clipped). */
+export interface Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+/**
+ * Every CSS `<blend-mode>` keyword (`mix-blend-mode`, `background-blend-mode`). Each one is a
+ * separable or non-separable blend function the CSS compositing spec takes verbatim from the
+ * PDF blend model, which is also what CoreGraphics — and therefore SwiftUI's `BlendMode` —
+ * implements, so the set maps one to one onto the platform.
+ */
+export declare const BLEND_MODES: {
+    readonly normal: true;
+    readonly multiply: true;
+    readonly screen: true;
+    readonly overlay: true;
+    readonly darken: true;
+    readonly lighten: true;
+    readonly "color-dodge": true;
+    readonly "color-burn": true;
+    readonly "hard-light": true;
+    readonly "soft-light": true;
+    readonly difference: true;
+    readonly exclusion: true;
+    readonly hue: true;
+    readonly saturation: true;
+    readonly color: true;
+    readonly luminosity: true;
+    readonly "plus-lighter": true;
+    readonly "plus-darker": true;
+};
+export type BlendMode = keyof typeof BLEND_MODES;
+export interface GradientStop {
+    color: Color;
+    /** 0..1 along the gradient line, undefined = evenly distributed. */
+    pos?: number;
+    /** Absolute px along the gradient line; `resolvePaint` turns it into `pos` once the box is known. */
+    px?: number;
+}
+/** Px from the node's border-box edge to a fill's painting area (top, right, bottom, left). */
+export type PaintInset = {
+    inset?: [number, number, number, number];
+    /** `background-blend-mode` for this layer, against the layers below it. Absent = `normal`. */
+    blend?: BlendMode;
+};
+/**
+ * One `background-image` layer (or a solid `background-color`). Gradient variants carry
+ * `repeating: true` for `repeating-*-gradient`; `center` is a 0..1 fraction of the box;
+ * `space` is the colour space of an explicit `in <space>` clause. A linear `corner`
+ * (`to right top` = [1, -1]) keeps the square-box `angle` until `resolvePaint` knows the box.
+ * Image layers carry the resolved `background-size`/`position`/`repeat` (px, box-relative)
+ * when the producer knows the box; absent = fill the box. `inset` (any fill) is set for
+ * `background-clip: padding-box | content-box`.
+ */
+export type Paint = ({
+    kind: "solid";
+    color: Color;
+} & PaintInset) | ({
+    kind: "linear";
+    angle: number;
+    corner?: [x: 1 | -1, y: 1 | -1];
+    stops: GradientStop[];
+    repeating?: true;
+    space?: string;
+} & PaintInset) | ({
+    kind: "radial";
+    stops: GradientStop[];
+    center: [number, number];
+    ellipse: boolean;
+    repeating?: true;
+    space?: string;
+} & PaintInset) | ({
+    kind: "conic";
+    stops: GradientStop[];
+    from: number;
+    center: [number, number];
+    repeating?: true;
+    space?: string;
+} & PaintInset) | ({
+    kind: "image";
+    url: string;
+    size?: BackgroundSize;
+    position?: [number, number];
+    repeat?: BackgroundRepeat;
+    /** A `data:image/svg+xml` source, parsed during analysis. */
+    vector?: SvgNode;
+} & PaintInset) | {
+    kind: "unsupported";
+    raw: string;
+};
+/** `background-repeat` per layer; `space`/`round` collapse to `repeat`. */
+export type BackgroundRepeat = "no-repeat" | "repeat" | "repeat-x" | "repeat-y";
+/** Resolved `background-size` layer: explicit px box or the `cover`/`contain` keywords. */
+export type BackgroundSize = {
+    w: number;
+    h: number;
+} | "cover" | "contain";
+export interface Shadow {
+    color: Color;
+    x: number;
+    y: number;
+    blur: number;
+    spread: number;
+    inset: boolean;
+}
+/**
+ * 2D affine transform decomposed as `translate(tx, ty) · rotate(rotate) · skewX(skewX) ·
+ * skewY(skewY) · scale(scaleX, scaleY)`. Angles in degrees; `skewX`/`skewY` are present
+ * only when the matrix has shear (a pure Y shear reports `skewY`, any other shear `skewX`).
+ * `flattened` marks a 3D matrix reduced to its x/y projection (depth and perspective lost).
+ */
+export interface Transform2D {
+    rotate: number;
+    scaleX: number;
+    scaleY: number;
+    tx: number;
+    ty: number;
+    skewX?: number;
+    skewY?: number;
+    flattened?: true;
+}

package/dist/types/model/version.d.ts

@@ -0,0 +1,4 @@
+/** Markswift package version: `--version`, generated-file headers and output manifests. */
+export declare const VERSION: string;
+/** First words of every generated file's header comment. */
+export declare const GENERATED_BY: string;

package/dist/types/swift/borders.d.ts

@@ -0,0 +1,13 @@
+import type { SemNode } from "../model/semantic.ts";
+import type { ColorCtx } from "./context.ts";
+/**
+ * Per-edge borders. An edge whose two corners are both square is a bar aligned to that edge —
+ * the cheapest thing that is also exact. An edge that runs into a rounded corner is not: CSS
+ * curves the border itself around the corner and hands it over to the neighbouring side at the
+ * line from the border-box corner to the padding-box corner, so an edge whose neighbour has no
+ * border keeps the whole arc. Clipping a straight bar to the box shape instead *deletes* that
+ * arc — and with it the only thing separating two `input-otp` slots. Those edges are emitted as
+ * `MarkswiftBorderSides`, which builds exactly that region; one expression per colour/style/width
+ * group, so at most four per node however large the design gets.
+ */
+export declare function borderSideModifiers(n: SemNode, ctx: ColorCtx): string[];

package/dist/types/swift/components.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Repeated siblings → one nested subview plus a static data array iterated with `ForEach` (app
+ * mode). The emitter is the equality test: every node is emitted once with a placeholder line per
+ * child it asks `ctx.renderNode` for, and siblings whose emitted Swift differs only in design
+ * literals (strings, colours, shapes, control state/action names) form a run. The subview is the
+ * first member's own emitted code with the differing literals read from its row, so the pixels are
+ * the unrolled view's by construction. Names come from the markup (`componentNames`).
+ */
+import type { GridNode, Screen, SemNode, StackNode, TextRun } from "../model/semantic.ts";
+import type { ControlMembers, EmitContext, EmitOptions } from "./context.ts";
+/**
+ * What a slot column becomes. `field`: a `Row` field; `literal`: kept as emitted; `binding`/`pass`:
+ * the screen's state/action handed through; `collapse`: per-row actions as one `(Row) -> Void`;
+ * `move`: per-row pressed/focused state declared in the subview; `counter`: a list marker derived
+ * from the row's `ordinal`.
+ */
+type Role = "field" | "literal" | "binding" | "pass" | "collapse" | "move" | "counter";
+type Counter = Omit<NonNullable<TextRun["counter"]>, "value">;
+/** A counter-marker column of a row type: the shared counter, and each run's first value and step. */
+interface CounterColumn {
+    counter: Counter;
+    ords: Map<Run, {
+        first: number;
+        step: number;
+    }>;
+}
+interface Run {
+    /** The stack or grid holding the members. */
+    parent: StackNode | GridNode;
+    /** The run's members, in order. */
+    members: SemNode[];
+    /**
+     * Per slot column (DFS order over a member): marker, each member's value and slot node, and the
+     * first member's text before the slot on its line (a colour's role).
+     */
+    columns: Array<{
+        marker: string;
+        values: string[];
+        nodes: SemNode[];
+        at: string;
+    }>;
+    /**
+     * First column whose value vector equals this one's (`$` stripped): columns sharing one field or
+     * parameter. Design-literal columns are classed and given their role over every run of the type.
+     */
+    cls: number[];
+    roles: Role[];
+    forEach: boolean;
+    /** Runs with equal signatures share one row type and subview. */
+    sig: string;
+}
+export interface Extraction {
+    /** Lines for a run member or an annotated text, undefined for any other node. */
+    call(node: SemNode): string[] | undefined;
+    /** Every node inside a run member (all members). */
+    absorbed: Set<SemNode>;
+    /** The screen's members replacing `ctx.control.members`, in declaration (= `init` parameter) order. */
+    members: ScreenMember[];
+    /** Screen `@State` renamed to its annotated field: old → new, applied to the screen body. */
+    rename: Record<string, string>;
+    /** `extension <View> { … }` body lines; empty without runs. */
+    extension: string[];
+    /** One `#Preview` per extracted subview. */
+    previews: string[];
+}
+/** Names of one row type: `<base>`, `<base>View`, its closure variable, fields and pass-through bindings by column. */
+interface TypeNames {
+    type: string;
+    view: string;
+    row: string;
+    fields: Map<number, string>;
+    pass: Map<number, string>;
+    /** The subview's row-index parameter of a counter marker (`ordinal`). */
+    ordinal?: string;
+}
+/**
+ * Every name extraction mints, from the markup (`nameHint`, `field`) and nearby headings; never from
+ * paths. Types/arrays share one record with the screen's own members; fields are per type.
+ */
+export declare function componentNames(screen: Screen, viewName: string, ctx: EmitContext, types: Array<{
+    run: Run;
+    group: Run[];
+    fieldCols: number[];
+    counter?: CounterColumn;
+}>, runType: number[], screenFields: SemNode[]): {
+    types: TypeNames[];
+    data: string[];
+    fields: Map<SemNode, string>;
+    actions: Map<Run, Map<number, string>>;
+};
+/** An `init` parameter of the screen: a stored property with its design default (`state`: seeds a private `@State`). */
+export interface Param {
+    name: string;
+    type: string;
+    value: string;
+    state?: true;
+}
+/** A screen member: leading lines (docs, private decls), then the stored property behind `param`, if any. */
+export interface ScreenMember {
+    decl: string[];
+    param?: Param;
+}
+/** `public ` for a generated library's API, nothing for app output. */
+export declare const access: (v: EmitOptions["visibility"]) => "" | "public ";
+/** A control member as a screen member: an action callback is an `init` parameter, an open state an `init`-seeded `@State`. */
+export declare function asMember(m: ControlMembers["members"][number]): ScreenMember;
+/**
+ * Repeated sibling elements of an app-mode screen as nested row types, data arrays and subviews,
+ * plus the screen's `data-markswift-field` texts and controls as `init` parameters; undefined when
+ * the screen has neither. Strict equality: optional children, variants and `:last-child` edges
+ * break a run (post-1.0 "loose extraction"); grids and measured, wrapping or distributed stacks get
+ * the shared subview called once per member (`Self.<array>[i]`, not a parameter) instead of a `ForEach`.
+ */
+export declare function extractComponents(screen: Screen, ctx: EmitContext, viewName: string, opts: Pick<EmitOptions, "visibility" | "registerFonts">): Extraction | undefined;
+export {};

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

@@ -0,0 +1,184 @@
+import type { Color } from "../model/values.ts";
+import type { Confidence, Diagnostic, Screen, SemNode, StateField, StateTransition, Style } from "../model/semantic.ts";
+import type { FontMetrics } from "../model/fonts.ts";
+export interface SwiftOutput {
+    /** <Name>View.generated.swift */
+    view: string;
+    /** Shapes referenced by this screen: name → Swift struct source. */
+    shapes: Record<string, string>;
+    /** Raster files referenced by this screen: bundle path (`Images/<hash>.<ext>`) → bytes. */
+    images: Record<string, Uint8Array>;
+    /** Nodes whose confidence is not `mapped`, with what each lost. */
+    report: Array<{
+        id: string;
+        kind: string;
+        confidence: Confidence;
+        diagnostics: Diagnostic[];
+    }>;
+    /** App mode: layer id (in-flow or presentation) → its `init` label; absent when nothing opens. */
+    openStates?: Record<string, string>;
+}
+/**
+ * `fidelity` reproduces the measured browser layout for pixel verification: clipped fixed root
+ * frame, text pinned to its measured line box, geometry-derived cross alignment. `app` is what
+ * ships to Xcode: ScrollView, native text metrics, alignment from the IR.
+ */
+export type EmitMode = "app" | "fidelity";
+export interface EmitOptions {
+    /** Packaged metrics for this conversion, keyed by lowercase CSS family. */
+    fontMetrics?: FontMetrics;
+    mode: EmitMode;
+    /** Design tokens of the run, bound to this screen; absent = every colour stays a literal. */
+    tokens?: ScreenTokens;
+    /** The light screen of a light/dark pair: the view must look right in both colour schemes. */
+    adaptive?: boolean;
+    /** Repeated-sibling extraction (app mode). `false` only for the pixel-identity check; default on. */
+    extract?: boolean;
+    /** `public` for a generated library (plan 033's `build`); `convert` stays internal. Default `internal`. */
+    visibility?: "internal" | "public";
+    /** Previews call `BundledFonts.register()` first: the library package bundles fonts (plan 033's `build`). */
+    registerFonts?: boolean;
+    /** Command the view header names for regeneration. Default `convert`. */
+    regenerate?: "convert" | "build";
+}
+/** Everything the recursive emitters need; built once per screen. */
+export interface EmitContext extends ColorCtx {
+    /** Recursive child lines; supplied by the screen emitter. */
+    renderNode: (node: SemNode) => string[];
+    fontMetrics: FontMetrics;
+    /** Container node → Swift property name. */
+    nameOf: Map<SemNode, string>;
+    /**
+     * Items of native rows, grids and content-sized containers: CSS sizes them no narrower than
+     * their content (`min-width: auto` of flex/grid items, shrink-to-fit), so their fill frames
+     * may grow to it. Every other fill-width box takes its container's width; see `frameModifier`.
+     */
+    contentMinWidth: Set<SemNode>;
+    /**
+     * App mode: children whose size a runtime Layout allocates (MarkswiftTracks cells, MarkswiftFlexRow items).
+     * "width": accept the proposed width; "both": also the proposed height (grid stretch); "height": a justified grid
+     * cell (MarkswiftTracks) takes the proposed height and fits its content's width.
+     */
+    allocated: Map<SemNode, "width" | "height" | "both">;
+    /** Breakpoint screens: containers whose subtree holds a band holder, emitted as `func v_x(_ band: Int)`. */
+    bandParam: Set<SemNode>;
+    /** Breakpoint screens: the app-mode scrolling root that hosts `MarkswiftBands` inside its `ScrollView`. */
+    bandsInside?: SemNode;
+    /** Shape structs referenced so far, name → source. */
+    shapes: Record<string, string>;
+    /** Raster files referenced so far, path → bytes. */
+    images: Record<string, Uint8Array>;
+    screen: Screen;
+    mode: EmitMode;
+    /** `@State` names and action callbacks of this screen's controls. */
+    control: ControlMembers;
+    /** This screen's colour → token lookup; see `colorExpr`. */
+    tokens?: ScreenTokens;
+    adaptive?: boolean;
+}
+/**
+ * Resolves a colour one node paints to a design-token name. Implemented by `tokens/extract.ts`
+ * (`screenTokens`), which binds the screen and theme being emitted; declared here so the
+ * emitters depend on the lookup and not on the extractor.
+ */
+export interface ScreenTokens {
+    /** Token for the colour `id` paints (at `slot`, when the call site knows it), or undefined when the colour must stay a literal. */
+    name(c: Color, id: string | undefined, slot?: string): string | undefined;
+    /** True when the colour `id` paints is opaque in every theme this view renders (a semantic token checks its dark value too). */
+    opaque(c: Color, id: string | undefined): boolean;
+}
+/** How one node paints in an interaction state, on top of its resting look (`states.ts` `pairStyle`). */
+export interface StatePaint {
+    /** The owner's member name (`isSavePressed`, `isEmailFocused`): the ternaries' condition. */
+    cond: string;
+    /** The style the box is emitted with: rest geometry plus anything only the state paints. */
+    style: Style;
+    /** Keyed by `colorArgs(c)` of the colour the emitter will be asked for, or by a run slot `run<i>`. */
+    colors: Map<string, {
+        rest: Color;
+        state: Color;
+    }>;
+    opacity?: {
+        rest: number;
+        state: number;
+    };
+    scale?: {
+        rest: [number, number];
+        state: [number, number];
+    };
+    /** The fields the look changes. */
+    fields: StateField[];
+    /** Pressed/focused: the look's CSS transitions (absent field = jump). */
+    transitions?: StateTransition;
+}
+/**
+ * The part of an emitter's context a colour or a font needs. `EmitContext` and `ControlDeps` both
+ * satisfy it.
+ */
+export interface ColorCtx {
+    /** Absent when the run emits no token file, or for a node whose colours are all literals. */
+    tokens?: ScreenTokens;
+    /** Which output is being written; `fontExpr` emits a different font expression per mode. */
+    mode: EmitMode;
+    /** App mode: `@ScaledMetric` font sizes used so far, property name → declaration; emitted once per view. */
+    scaledFonts?: Map<string, string>;
+    /** Node id → its interaction-state paint; `colorExpr` turns a paired colour into a ternary. */
+    statePaint?: Map<string, StatePaint>;
+}
+/** The view-level members a screen's controls need, in emission order. */
+export interface ControlMembers {
+    /** `@State` / callback declarations to put before `var body`. Empty when the screen has none. */
+    decls: string[];
+    /**
+     * Every member in emission order; `value` = design state (`@State private`), `action` =
+     * `on<Name>` callback, `ephemeral` = UI state such as pressed/focused (plan 029), `open` = a
+     * layer's shown state (in-flow or drawn presentation), an `init`-seeded `@State` (`seed`). `decls` is
+     * `members.flatMap(m => m.decl)`.
+     */
+    members: Array<{
+        name: string;
+        kind: "value" | "action" | "ephemeral" | "open";
+        type: string;
+        decl: string[];
+        seed?: string;
+    }>;
+    stateOf: Map<SemNode, string>;
+    /** `Action.key` → callback member. */
+    actionOf: Map<string, string>;
+    /** Toggle/radio id (native or ARIA toggle), or app-mode text field id → the Swift statement a tap on its `<label>` runs. */
+    activate: Map<string, string>;
+    /** Grouped radio → its tag in the group's `String` selection (its `stateOf` name). */
+    radioTag: Map<SemNode, string>;
+    /**
+     * ARIA toggle drawn as a Button (`role=checkbox|switch|radio…`) → the statements its tap runs
+     * (change the state, then the action), the condition `.isSelected` follows, and the one
+     * `aria-checked="mixed"` follows (`Bool?` state, `nil` = mixed).
+     */
+    toggleOf: Map<SemNode, {
+        tap: string[];
+        on: string;
+        mixed?: string;
+    }>;
+    /** A trigger Button of a layer → its shown state and what its tap runs (in-flow: toggle; presentation: set true; then
+     * the action). Long-press presentation triggers have none. */
+    openOf: Map<SemNode, {
+        state: string;
+        tap: string[];
+    }>;
+    /** Layer id → its shown state (in-flow: the `if` around content with that `shownBy`; presentation: the binding). */
+    openStates: Map<string, string>;
+    /** A presentation's own closing button → what its tap runs (its action, then the state goes false). */
+    closeOf: Map<SemNode, string[]>;
+    /** Presentation layer id → its `on<Layer>Dismissed` callback (Escape or an outside tap closed it). */
+    dismissedOf: Map<string, string>;
+    /** Native menu toggle/radio item id → its `@State` member (plan 061). */
+    menuState: Map<string, string>;
+    /** Single-run TextNode id → the member its text shows (a Radix select's value follows its Picker). */
+    textState: Map<string, string>;
+    /** Node id → its interaction-state paint (pressed under the nearest Button, focused on a text field). */
+    statePaint: Map<string, StatePaint>;
+    /** Pressable owner → its `@MarkswiftPressed` member. */
+    pressOf: Map<SemNode, string>;
+    /** Text field → its `@MarkswiftFocused` member. */
+    focusOf: Map<SemNode, string>;
+}

package/dist/types/swift/control-state.d.ts

@@ -0,0 +1,19 @@
+import type { ControlNode, MenuItem, SemNode } from "../model/semantic.ts";
+import type { ControlMembers, EmitMode } from "./context.ts";
+/**
+ * Every control's state property and every distinct action callback for one screen. Names come
+ * from the node ids, so regenerating an unchanged design produces the same members. `byId`
+ * (breakpoint screens): one element is a node per band alternative; its first node owns the
+ * value, toggle, pressed and focused members, every other node of that element reuses them.
+ */
+export declare function controlMembers(root: SemNode, mode: EmitMode, byId?: boolean): ControlMembers;
+/** A menu's items with its sections opened, in order. */
+export declare const flatItems: (items: MenuItem[]) => MenuItem[];
+/** The control's value as a number, clamped into its range (the range's start when it has none). */
+export declare function numericValue(n: ControlNode): number;
+/**
+ * An `<input type=date|time|datetime-local|month|week>` value as the wall-clock date the design
+ * wrote (`Date.markswift`, runtime/controls.swift). HTML sanitises an invalid value to empty, and
+ * an empty field has no date to show, so both start at `.now`.
+ */
+export declare function dateSeed(value: string | undefined): string;

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

@@ -0,0 +1,62 @@
+/**
+ * `ControlNode` → SwiftUI. The node's box (fill, border, radius, padding, frame) is painted by
+ * the shared modifier chain in `modifiers.ts`; this file emits only the interactive core that goes
+ * inside it, plus the view members that core needs: one `@State` per stateful control and one
+ * callback property per distinct `onclick` handler.
+ *
+ * Mode difference — live controls. `app` emits the real thing (`TextField`, `Slider`, `Picker`,
+ * …) in the CSS look: text fields are `.plain` (the CSS box is their chrome), `<select>` is a
+ * `Menu` labelled by its selection over an inline `Picker`. `ImageRenderer`, which the verifier
+ * draws with, cannot rasterise UIKit-backed controls and paints a yellow placeholder instead, so
+ * `fidelity` emits what the browser painted: the field's text, the slider's track, the picker's
+ * selection. Everything that is pure SwiftUI (`Button`, `Toggle` with a drawn style,
+ * `ProgressView`/`Gauge` with a drawn style, `DisclosureGroup` with `MarkswiftDisclosureStyle`)
+ * is identical in both modes.
+ */
+import type { Theme } from "../model/layout.ts";
+import type { FontMetrics } from "../model/fonts.ts";
+import type { ControlNode, MenuItem, MenuSpec, SemNode } from "../model/semantic.ts";
+import type { ColorCtx, ControlMembers, EmitMode, ScreenTokens } from "./context.ts";
+/** What the emitter must be able to do with a control's children and label. */
+export interface ControlDeps extends ColorCtx {
+    /** Emits a child node the way the surrounding view would (containers → their property). */
+    child: (n: SemNode) => string[];
+    /** Control → `@State` property name; built by `controlMembers`. */
+    stateOf: Map<SemNode, string>;
+    /** `Action.key` → callback member; built by `controlMembers`. */
+    actionOf: Map<string, string>;
+    /** Grouped radio → its tag in the group's selection; built by `controlMembers`. */
+    radioTag: Map<SemNode, string>;
+    mode: EmitMode;
+    /** The screen's colour scheme (`adaptive`: both): `<progress>`/`<meter>`/`<input type=range>` are painted by the browser, whose palette follows it. */
+    theme: Theme | "adaptive";
+    /** This screen's colour → token lookup, and the control node its colours belong to. */
+    tokens?: ScreenTokens;
+    id?: string;
+    /** The node's box modifiers, emitted inside a pressable control's label. */
+    box?: string[];
+    /** Pressable owner → its `@MarkswiftPressed` member; built by `controlMembers`. */
+    pressOf?: Map<SemNode, string>;
+    /** ARIA toggle Button → what its tap runs; built by `controlMembers`. */
+    toggleOf?: ControlMembers["toggleOf"];
+    /** Layer trigger → what its tap runs; built by `controlMembers`. */
+    openOf?: ControlMembers["openOf"];
+    /** A presentation's closing button → what its tap runs; built by `controlMembers`. */
+    closeOf?: ControlMembers["closeOf"];
+    /** Native menu toggle/radio item → its `@State` member; built by `controlMembers`. */
+    menuState?: ControlMembers["menuState"];
+    /** Text field → its `@MarkswiftFocused` member; built by `controlMembers`. */
+    focusOf?: Map<SemNode, string>;
+    /** Packaged face metrics: a field in a bundled face spaces its lines from that face's natural line. */
+    fontMetrics?: FontMetrics;
+}
+/** Editable text controls: their own text is laid out in the CSS line box. */
+export declare const FIELDS: Record<string, true>;
+export declare function controlExpr(n: ControlNode, deps: ControlDeps): string[];
+/**
+ * A captured menu's items as native menu content (plan 061): buttons on the screen's action members, checkbox items as
+ * Toggles, a radio run as an inline Picker, separators, labelled sections.
+ */
+export declare function menuExpr(items: MenuItem[], deps: Pick<ControlDeps, "actionOf" | "menuState">): string[];
+/** A menu trigger: its Button's label and style around a native `Menu` of the captured items. */
+export declare function menuButton(menu: MenuSpec, label: string[], buttonStyle: string, deps: Pick<ControlDeps, "actionOf" | "menuState">): string[];

package/dist/types/swift/diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { type SemNode, type DiagnosticLevel } from "../model/semantic.ts";
+/** Records an emit-time loss on the node and regrades it; idempotent because both modes emit the same tree. */
+export declare function note(n: SemNode, level: DiagnosticLevel, feature: string, message: string): void;

package/dist/types/swift/effects.d.ts

@@ -0,0 +1,23 @@
+import type { Paint, Transform2D } from "../model/values.ts";
+import type { SemNode, Filter, ClipShape } from "../model/semantic.ts";
+import type { ColorCtx, EmitContext } from "./context.ts";
+/**
+ * Skew has no SwiftUI modifier, so a sheared transform is emitted whole: the `Transform2D`
+ * composition `translate · rotate · skewX · skewY · scale`, conjugated by the CSS
+ * transform-origin (`T(o) · M · T(−o)`, `o` relative to the node's top-left, default centre)
+ * because `.transformEffect` is applied about the view's own origin. CGAffineTransform's
+ * `(a, b, c, d, tx, ty)` is the CSS `matrix()` layout, so the components map 1:1.
+ */
+export declare function affineModifier(t: Transform2D & {
+    origin?: [number, number];
+}, w: number, h: number): string;
+/** One CSS `filter` function → SwiftUI modifier(s); lossy cases are noted on the node. */
+export declare function filterModifier(f: Filter, n: SemNode, ctx: ColorCtx): string[];
+/**
+ * `clip-path` basic shapes. Circle/ellipse are placed with `.size().offset()` in measured px
+ * (a centred full circle is just `Circle()`); inset masks with a padded rounded rectangle so it
+ * follows the box; polygons become a generated `Shape` in fractions of the measured box.
+ */
+export declare function clipPathModifier(c: ClipShape, n: SemNode, ctx: EmitContext): string;
+/** `mask-image`: the paint's alpha masks the node (gradients directly, images as a layer). */
+export declare function maskModifier(p: Paint, n: SemNode, ctx: EmitContext): string[];

package/dist/types/swift/emit.d.ts

@@ -0,0 +1,6 @@
+/** Assemble a screen from cohesive Swift emission modules. */
+import type { Screen } from "../model/semantic.ts";
+import type { EmitOptions, SwiftOutput } from "./context.ts";
+export type { EmitMode, EmitOptions, SwiftOutput } from "./context.ts";
+export { SWIFT_RUNTIME } from "./runtime.ts";
+export declare function emitSwift(screen: Screen, viewName: string, opts: EmitOptions): SwiftOutput;

package/dist/types/swift/format.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Swift source helpers shared by the emitters (views, SVG shapes, harness registry).
+ */
+import type { Color } from "../model/values.ts";
+import type { FontSpec } from "../model/semantic.ts";
+import type { ColorCtx } from "./context.ts";
+/** `Color.markswift(r, g, b[, a])` argument list; alpha omitted when opaque. */
+export declare function colorArgs(c: Color): string;
+/**
+ * The one place a colour becomes Swift: `Palette.surfaceRaised` when this node's colour is a
+ * token of the screen, else the literal `Color.markswift(…)`.
+ *
+ * `id` is the node painting the colour; the lookup is (screen, theme, node, colour value)
+ * because most call sites paint a colour without knowing which named slot of the node it is.
+ * Those that do (text runs) pass `slot` (`run2`, `run2.dec`), which still resolves when one
+ * light colour is two tokens on the node. Omitting `id` — an SVG inlined through an `<img>`, a
+ * control's own value — yields the literal: a colour the extractor never enumerated cannot
+ * claim a token.
+ *
+ * A colour the node's pressed/focused look changes (`ctx.statePaint`, `states.ts`) becomes
+ * `(isSavePressed ? state : rest)`, each side resolved the same way.
+ */
+export declare function colorExpr(c: Color, ctx: ColorCtx, id?: string, slot?: string): string;
+/** Swift `Double` literal: 3 decimals, always with a fraction so type inference stays `Double`. */
+export declare function num(v: number): string;
+/**
+ * Swift string literal. Swift accepts only `\0 \\ \t \n \r \" \' \u{…}` escapes and no lone
+ * surrogates, so JSON escaping (`\b`, `\f`, `\u000b`, `\ud800`) does not compile. Control
+ * characters (C0, DEL, C1) and U+2028/U+2029 become `\u{hex}`; a lone surrogate becomes U+FFFD.
+ */
+export declare function str(s: string): string;
+export declare function indent(lines: string[], n: number): string[];
+/** `HorizontalAlignment` of a start/center/end value (anything else is the leading edge). */
+export declare function horizontalAlignment(a: string | undefined): string;
+/** `VerticalAlignment` of a start/center/end value (anything else is the top edge). */
+export declare function verticalAlignment(a: string | undefined): string;
+/** `Alignment` combining a horizontal and a vertical start/center/end value. */
+export declare function alignment(h: string | undefined, v: string | undefined): string;
+/** Dash array of a CSS `dashed` (3w on, 2w off) or `dotted` (round dots 2w apart) line. */
+export declare function dashPattern(style: "dashed" | "dotted", width: number): string;
+/** `StrokeStyle` for a CSS line style; styles other than dashed/dotted stroke solid. */
+export declare function strokeStyle(width: number, style: string): string;
+/** `EdgeInsets` of CSS-ordered (top, right, bottom, left) insets. */
+export declare function edgeInsets([top, right, bottom, left]: readonly number[]): string;
+/** A DOM id or design string as the body of a Swift identifier (may be empty). */
+export declare function identifier(s: string): string;
+/** `base` the first time, then `base_r2`, `base_r3`, … — counted in `seen`. */
+export declare function uniqueName(base: string, seen: Record<string, number>): string;
+/** Design words → PascalCase ASCII (`openMenu` → `OpenMenu`, `save-btn` → `SaveBtn`, `Gönder` → `Gonder`); at most 4 words, "" when none survive. */
+export declare function pascalWords(s: string): string;
+/**
+ * K1 member name: `prefix + PascalCase(words) + suffix` (`fallback` when no word survives); repeats become `…2`, `…3`.
+ * Without a prefix the name starts lower-case (`item title` → `itemTitle`). Registered in `seen`.
+ */
+export declare function memberName(prefix: string, words: string, seen: Record<string, number>, fallback: string, suffix?: string): string;
+/**
+ * Registers a `Shape` struct once under `name`; `body` gives the lines of `path(in:)`.
+ * `nonisolated`: Shape's requirements are nonisolated; under a MainActor default-isolation
+ * build (SE-0466) an unannotated struct would fail to conform in Swift 6 mode.
+ */
+export declare function shapeStruct(name: string, shapes: Record<string, string>, body: () => string[]): string;
+/** The `Font.TextStyle` whose default size is nearest `size`: what an app-mode font scales with. */
+export declare function nearestTextStyle(size: number): string;
+/**
+ * A system font's point size. App mode names an `@ScaledMetric` property (registered in
+ * `ctx.scaledFonts`, declared once per view) so the text follows Dynamic Type; fidelity, and
+ * `fixed` text placed in absolute coordinates, keep the literal.
+ */
+export declare function fontSizeExpr(f: FontSpec, ctx: ColorCtx, fixed?: boolean): string;
+/**
+ * Swift `Font` expression for a run's font. A system family is its design plus the nearest
+ * named weight in both modes, sized by `fontSizeExpr`, plus `.width(…)` (SF's nearest width
+ * instance, `SF_WIDTH`) for a captured `font-stretch`; a bundled family differs by mode:
+ *
+ * - **app** — `.custom(family, size:, relativeTo:)` plus an explicit `.weight(…)`: the shipped
+ *   app must scale with Dynamic Type, and the weight is stated rather than inherited because a
+ *   variable file's default instance is whatever its `fvar` says (Bricolage Grotesque defaults
+ *   to 800, not 400).
+ * - **fidelity** — `.markswiftVariable(family, size:, weight:, opsz:)`: the variable axes the browser
+ *   actually rendered, so an SSIM against the reference measures the design and not a weight
+ *   quantisation. Nothing in this mode is shipped. A family without a `wght` axis is a set of
+ *   static faces: a variation request would land on its default (regular) face, so the named
+ *   weight selects the face instead, at a fixed size.
+ * - **captured axes, both modes** — a bundled family with `axes` (`font-variation-settings` tags,
+ *   or `font-stretch` as `wdth`, beyond wght/opsz) is `.markswiftVariable(…, axes:)` in app mode
+ *   too, sized by `fontSizeExpr` so Dynamic Type still applies: the shipped app sets the
+ *   variation at runtime (docs/decisions.md "Fonts", 2.0).
+ */
+export declare function fontExpr(f: FontSpec, ctx: ColorCtx, fixed?: boolean): string;
+/** FNV-1a 32-bit, hex — stable names for generated shapes. */
+export declare function hash(s: string): string;