markswift 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,17 @@
+import type { SemNode, TextNode } from "../model/semantic.ts";
+import type { EmitContext, EmitMode } from "./context.ts";
+/**
+ * App: the line-box surplus the analysis moved into one edge's padding (text off its box's centre,
+ * `lineBoxGrowth.padded`). Emitted as a `minHeight` floor of the measured box aligned away from
+ * that edge instead, so growing text absorbs it like CSS does rather than adding it on top.
+ */
+export declare function surplusFloor(n: SemNode, ctx: Pick<EmitContext, "mode">): TextNode["lineBoxGrowth"];
+/**
+ * App: how far a floored box's captured content overflows its content box, [top, bottom] — an icon taller than
+ * its badge, a line box taller than an `h-5` minus padding. CSS paints that overflow without growing the box;
+ * the padding gives it back (`boxModifiers`), so the floor grows only by what native text adds.
+ */
+export declare function floorOverflow(n: SemNode, ctx: EmitContext): [number, number];
+export declare function frameModifier(n: SemNode, ctx: EmitContext): string[];
+/** Where a node sits inside its fill frame: follows its own alignment semantics. */
+export declare function fillAlignment(n: SemNode, mode: EmitMode): string;

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

@@ -0,0 +1,25 @@
+import type { Paint } from "../model/values.ts";
+import type { SemNode, ImageNode, TextRun } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+type ImagePaint = Extract<Paint, {
+    kind: "image";
+}>;
+/**
+ * An image sized and placed like a CSS background layer: a box-filling `Color.clear` carries
+ * the image as an overlay so cover/contain overflow is aligned to the box and clipped by the
+ * caller. Vector sources are scaled here (cover/contain/explicit size against the viewBox);
+ * raster ones let SwiftUI scale. Repeats tile through `MarkswiftTile` whenever the tile size is
+ * known (vector viewBox, explicit size, or an embedded raster's header size resolved by the
+ * analysis); a remote raster at its unknown intrinsic size uses `.tile`.
+ * `undefined` when the source cannot be shown (noted on the node).
+ */
+export declare function imageLayer(p: ImagePaint, n: SemNode, prop: string, ctx: EmitContext): string[] | undefined;
+/** A generated image inside text (`TextRun.image`) as a view at its CSS size; `undefined` (noted) when it has no pixels. */
+export declare function inlineImageView(img: NonNullable<TextRun["image"]>, n: SemNode, ctx: EmitContext): string[] | undefined;
+/**
+ * `<img>`: the source at the IR's content mode. A source that cannot produce pixels falls back to
+ * the alt text in the measured box, where the browser draws it too; `alt` is also the
+ * accessibility label, and `alt=""` marks the image decorative.
+ */
+export declare function imageNodeExpr(n: ImageNode, ctx: EmitContext): string[];
+export {};

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

@@ -0,0 +1,5 @@
+import type { BandEdge, StackNode, GridNode } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+export declare function containerExpr(n: StackNode | GridNode, ctx: EmitContext): string[];
+/** `MarkswiftBands(edges: […])`: inclusive edges are `.atLeast`, exclusive (`max-width`) ones `.above`. */
+export declare function bandsOpen(edges: BandEdge[]): string;

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

@@ -0,0 +1,4 @@
+/** Emit measured content coordinates before the owning node's padding and paint. */
+import type { GridNode, StackNode } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+export declare function measuredLayoutExpr(n: GridNode | StackNode, ctx: EmitContext): string[];

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

@@ -0,0 +1,30 @@
+import type { SemNode, Overlay } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+export declare function modifiers(n: SemNode, ctx: EmitContext): string[];
+/**
+ * A node's view: its core lines plus modifiers. An element the design made activatable
+ * (`SemBase.action` on a non-control) becomes a Button whose label is the painted box — the box is
+ * the hit and press area — with placement and accessibility outside, like a native button. One that
+ * contains another control keeps its view and gains a tap gesture instead.
+ */
+export declare function decorate(n: SemNode, core: string[], ctx: EmitContext): string[];
+/** App: a pass-through overlay (`pointer-events: none`), after the Button/tap gesture, so nothing inside answers a tap. */
+export declare function hitTestingModifier(n: SemNode, ctx: EmitContext): string[];
+/**
+ * The node's box: padding, frame, paint, borders, shadows, overlays, effects. A pressable control emits these inside its label, so they are its hit and press area.
+ * A node with a pressed/focused look paints the union style of `pairStyle`, its colours as ternaries; app output
+ * animates them with their CSS transitions: one `MarkswiftStateAnimation` at the end when every field shares its
+ * timing, else one after each field's paint (the nearest one wins for what it wraps).
+ * App: a scroll box's padding scrolls with its content (layout.ts); everything else here belongs to its ScrollView.
+ */
+export declare function boxModifiers(n: SemNode, ctx: EmitContext): string[];
+/** The box's padding. App: a padded line-box surplus is a `minHeight` floor instead (`surplusFloor`); content CSS let
+ * overflow the floored box gives its overflow back (`floorOverflow`). */
+export declare function paddingModifiers(n: SemNode, ctx: EmitContext): string[];
+/**
+ * Where the finished box sits and what it is: transform, self-alignment, visibility, a `<label>`'s
+ * tap, accessibility. Nothing that paints or sizes the box: a button's box modifiers go inside its
+ * label, and these stay outside it.
+ */
+export declare function placementModifiers(n: SemNode, ctx: EmitContext): string[];
+export declare function overlayModifier(o: Overlay, mode: "background" | "overlay", ctx: EmitContext): string[];

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

@@ -0,0 +1,20 @@
+/** IR `Motion` → the `MarkswiftAnimation` modifier (runtime/motion.swift). App output only. */
+import type { Easing, KeyframeMotion, Motion, SemNode, StateField, StateTransition, TransitionSpec } from "../model/semantic.ts";
+import type { EmitMode } from "./context.ts";
+/** App output plays the node's animations; `motion.base` names the channels the modifier drives. */
+export declare const animated: (n: SemNode, mode: EmitMode) => boolean;
+export declare function easeExpr(e: Easing): string;
+/** `MarkswiftTiming(…)` in seconds; defaults omitted. */
+export declare function timingExpr(k: KeyframeMotion): string;
+/** `.modifier(MarkswiftAnimation(…))`: `reduced` only when it differs, `base` only for non-identity channels, `anchor` only off-centre. */
+export declare function animationModifier(motion: Motion): string;
+/** A transition's SwiftUI `Animation` (`nil` = jump): bezier as `.timingCurve`, steps()/linear() via `MarkswiftEasing`. */
+export declare function animationExpr(spec?: TransitionSpec): string;
+/** `.modifier(MarkswiftStateAnimation(…))` for one paint field of a pressed/focused look. */
+export declare function stateAnimation(cond: string, t: StateTransition | undefined, field: StateField): string;
+/** The `Animation` of the longest exit among a layer's roots (what closing it waits for); undefined when none exits. */
+export declare function longestExit(roots: SemNode[]): string | undefined;
+/** `.transition(…)` of a layer root (066): in-flow content's reveal and/or an overlay root's exit; none when neither. */
+export declare function transitionModifiers(n: SemNode): string[];
+/** An in-flow layer's toggle: `state.toggle()` inside the reveal's close or open curve, when it has one. */
+export declare function revealToggle(state: string, reveal: Motion["reveal"]): string;

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

@@ -0,0 +1,4 @@
+import type { SemNode } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+/** Lines for a node: container → property reference; leaf → inline expression (with modifiers); holder → band chain. */
+export declare function refOf(n: SemNode, ctx: EmitContext): string[];

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

@@ -0,0 +1,22 @@
+import type { BlendMode, Paint } from "../model/values.ts";
+import type { Style, SemNode } from "../model/semantic.ts";
+import type { ColorCtx, EmitContext } from "./context.ts";
+export declare function shapeExpr(st: Style, w: number, h: number): string;
+/** A CSS paint as a SwiftUI style. `ctx`/`id` resolve its colours; see `colorExpr`. */
+export declare function paintExpr(p: Paint, w: number, h: number, ctx: ColorCtx, id?: string): string;
+/**
+ * One background layer: shape styles go through `.background(_:in:)`, images through a clipped
+ * view. `background-clip: padding-box | content-box` (`Paint.inset`) pads the painted shape
+ * inside the box; the corner radius shrinks with it, close to how Chrome insets the corners.
+ */
+export declare function fillModifier(p: Paint, n: SemNode, shape: string, ctx: EmitContext): string[];
+export declare function swiftBlend(mode: BlendMode): string | undefined;
+/**
+ * Background layers where at least one carries a `background-blend-mode`. A chain of
+ * `.background` modifiers gives each layer its own compositing group, so a blend would reach
+ * past the sibling layers to whatever is behind the node; CSS blends strictly within the
+ * node's own background. One `ZStack` (bottom-most first, as the IR stores them) inside a
+ * single `.background`, with the blend on the upper layer and a `.compositingGroup()` around
+ * the result, is that scope exactly.
+ */
+export declare function blendedFillModifier(fills: Paint[], n: SemNode, shape: string, ctx: EmitContext): string[];

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

@@ -0,0 +1,6 @@
+/**
+ * `MarkswiftRuntime.swift`. `controls.swift` opens with `import UniformTypeIdentifiers`, which
+ * Swift accepts anywhere at file scope, so every part is appended at top level. `core.swift` keeps a
+ * version-free header; the shipped runtime names the version that generated it.
+ */
+export declare const SWIFT_RUNTIME: string;

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

@@ -0,0 +1,7 @@
+/** CSS box shadows paint the box silhouette, independently of its children and other shadows. */
+import type { SemNode } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+/** Outer shadows sit behind the border box; their interior stays clear even with no fill. */
+export declare function outerShadowModifiers(n: SemNode, ctx: EmitContext): string[];
+/** Inset shadows are below content and above fills, clipped to the inner border edge. */
+export declare function insetShadowModifiers(n: SemNode, ctx: EmitContext): string[];

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

@@ -0,0 +1,3 @@
+import type { SemNode, StateStyle } from "../model/semantic.ts";
+import type { StatePaint } from "./context.ts";
+export declare function pairStyle(n: SemNode, state: StateStyle, cond: string, kind: "pressed" | "focused" | "open"): StatePaint;

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

@@ -0,0 +1,14 @@
+/**
+ * SvgNode → SwiftUI: one `Shape` struct per unique (path, viewBox), layered fills/strokes
+ * in a ZStack (gradients, dash arrays, clips and masks are per-layer modifiers); progress
+ * rings become trimmed `Circle`s; `<text>` runs are `Text`s positioned where the browser
+ * laid them out.
+ */
+import type { SvgNode } from "../model/semantic.ts";
+import type { ColorCtx } from "./context.ts";
+/**
+ * Expression lines for an SVG node; registers any new Shape structs in `shapes` (name → source).
+ * `id` is the node the colours belong to, for the token lookup: an `<svg>` node of the IR. An
+ * SVG inlined through an `<img>` has no enumerated colours, so it passes none and stays literal.
+ */
+export declare function svgExpr(n: SvgNode, shapes: Record<string, string>, ctx: ColorCtx, id?: string): string[];

package/dist/types/swift/text-box.d.ts

@@ -0,0 +1,12 @@
+/** Alignment shared by native text and its surrounding CSS size constraints. */
+import type { TextNode } from "../model/semantic.ts";
+/**
+ * Natural line height of a system face, as a multiple of `font-size`: the height SwiftUI gives
+ * one `Text` line before `.lineSpacing`. Measured on the verifier's simulator, it equals
+ * `CTFontGetAscent + CTFontGetDescent + CTFontGetLeading` at every size from 10 to 60 pt, for
+ * every weight and all four `Font.Design` values: Apple keeps the system faces metric-compatible
+ * with SF Pro's `hhea` (1950 + 494) / 2048.
+ */
+export declare const SYSTEM_LINE_HEIGHT = 1.193359;
+export declare function clipsFirstLine(n: TextNode): boolean;
+export declare function textBoxAlignment(n: TextNode, top?: boolean): string;

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

@@ -0,0 +1,3 @@
+import type { TextNode } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+export declare function textExpr(n: TextNode, ctx: EmitContext): string[];

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

@@ -0,0 +1,26 @@
+import type { ColorToken, PaletteMap, TokenSet } from "./types.ts";
+import type { Color } from "../../model/values.ts";
+import type { ConversionWarning } from "../../model/semantic.ts";
+/**
+ * `<View>+Tokens.swift`: one `static let` per token in `extension <View> { enum Palette }`, so
+ * two views never collide and a token can never shadow SwiftUI's `Color.primary`. Static tokens
+ * emit a single colour; semantic tokens emit the pair via the runtime's
+ * `Color.markswift(light:dark:)`. `adaptive` says whether the set was paired from a light and a
+ * dark capture, which the header states. Without `owner` the palette is module-level: one
+ * `Palette` shared by every view of a generated library (`markswift build`). A `palette` map
+ * replaces a matched token's value with the app's own Swift colour expression, verbatim.
+ */
+export declare function emitDesignTokens(set: TokenSet, owner: string | undefined, options?: {
+    adaptive?: boolean;
+    visibility?: "internal" | "public";
+    palette?: PaletteMap;
+}): string;
+/** `#rrggbb`, plus `aa` when not opaque; lowercase. */
+export declare function tokenHex(c: Color): string;
+/** The map entry that replaces `t`'s value; the first of {@link paletteKeys} present wins. */
+export declare function paletteEntry(t: ColorToken, map: PaletteMap): {
+    key: string;
+    swift: string;
+} | undefined;
+/** Unmapped tokens (with the key each could use) and map keys that matched no token; `[]` when the map is exact. */
+export declare function paletteWarnings(set: TokenSet, map: PaletteMap): ConversionWarning[];

package/dist/types/swift/tokens/extract.d.ts

@@ -0,0 +1,21 @@
+import type { Screen } from "../../model/semantic.ts";
+import type { ScreenTokens } from "../context.ts";
+import type { TokenSet } from "./types.ts";
+/**
+ * Reduce every screen of a run — both themes — to a token set.
+ *
+ * A slot whose light and dark colours differ becomes a semantic token — even when it is the
+ * only slot painting that pair, so an adaptive view never keeps a light literal for it; a colour
+ * identical in both themes and used at two or more slots becomes a static token; a single-use
+ * identical colour stays inline. Names come from the CSS custom property the IR recorded when one can be
+ * attributed unambiguously, otherwise from role and colour (`fillBlue`, `textPrimary`), with a
+ * numeric suffix on collision. Deterministic: the same screens produce the same names.
+ */
+export declare function extractTokens(screens: Screen[]): TokenSet;
+/**
+ * The token lookup for one screen: binds the screen group and theme, so the emitters ask only
+ * "which token does this node's colour name here?". A miss — an unenumerated colour, or one
+ * two tokens claim on the same node — leaves the literal in place. A call site that names the
+ * slot gets that slot's token only. A breakpoint view passes its band screens' bases, lowest band first.
+ */
+export declare function screenTokens(set: TokenSet, screen: Screen, bases?: string[]): ScreenTokens;

package/dist/types/swift/tokens/naming.d.ts

@@ -0,0 +1,22 @@
+import type { Color } from "../../model/values.ts";
+import type { Usage } from "./types.ts";
+/** `surface-raised` → `surfaceRaised`; always a valid, non-keyword Swift member name. */
+export declare function camelize(name: string): string;
+/**
+ * Human-ish colour label: hue name when the colour reads as coloured, grey-ramp tone when it
+ * reads as neutral. "Coloured" is HSV saturation, not raw chroma — a near-black `#0B0F14` has
+ * a blue hue on paper and none to the eye, and a slate `#8A93A0` is a grey in a design system.
+ */
+export declare function tone(c: Color): string;
+/**
+ * Assign token hints to colour groups. `Style.tokens` is a per-node *set*. A role-qualified
+ * class hint (`bg:white`, `from:sky-500`) names the slots of its utility ({@link HINT_SLOTS}),
+ * and only when they paint one colour on that node. A custom property is subtler — the IR knows
+ * a node referenced `var(--card)` but not which slot it painted. A colour custom property is by
+ * definition constant, so the slot it names is the one that resolves to a single colour across
+ * every node referencing the property, on most of those nodes: `--muted` is one colour at `run0`
+ * everywhere it appears, while `--fd` (a font family) sits on nodes whose text runs are five
+ * different colours and so names nothing. Hints without a consistent slot are dropped rather
+ * than guessed, and so is a colour two names claim equally.
+ */
+export declare function assignHints(groups: Map<string, Usage[]>): Map<string, string>;

package/dist/types/swift/tokens/slots.d.ts

@@ -0,0 +1,18 @@
+import type { Screen } from "../../model/semantic.ts";
+import type { Usage } from "./types.ts";
+/** `home-light` + theme `light` → `home`; a name without the suffix is its own base. */
+export declare function screenBase(screen: Screen): string;
+/**
+ * Pair the themes slot by slot. Screens are grouped by {@link screenBase}; inside a group the
+ * light screen drives document order and the dark screen supplies the second value. Only the
+ * light screen is emitted, so a slot the dark screen alone paints makes no usage at all; a light
+ * slot without a dark counterpart stays unpaired — it can still make a static token, never a
+ * semantic one. {@link themeDrift} reports both.
+ */
+export declare function pairUsages(screens: Screen[]): Usage[];
+/**
+ * Node ids where the dark screen differs from the light one in more than colour: a node or a
+ * colour slot present in one theme only, or a frame that moved or resized by more than 0.5px.
+ * An adaptive view is the light layout with paired colours, so these keep their light values.
+ */
+export declare function themeDrift(light: Screen, dark: Screen): string[];

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

@@ -0,0 +1,77 @@
+import type { Color } from "../../model/values.ts";
+import type { Theme } from "../../model/layout.ts";
+/** What a colour paints; drives the fallback name and the token-hint consistency check. */
+export type TokenRole = "canvas" | "fill" | "border" | "text" | "shadow" | "icon";
+/** One extracted colour token. `light === dark` for `kind: "static"`. */
+export interface ColorToken {
+    name: string;
+    kind: "semantic" | "static";
+    light: Color;
+    dark: Color;
+    /** Dominant role of its usages — the fallback name is derived from it. */
+    role: TokenRole;
+    /** CSS custom property the name came from, when the IR carried a usable hint. */
+    hint?: string;
+    /** Node ids that paint with this token, in document order, deduplicated. */
+    uses: string[];
+    /** Colour slots this token covers (a light/dark pair counts once). */
+    slots: number;
+}
+/**
+ * App colours for captured tokens. Keys: a CSS custom property (`--primary`), a hex colour for a
+ * static token (`#e2e8f0`, `#e2e8f080`), or `#light/#dark` for an adaptive one. Values: a Swift
+ * `Color` expression (`Color.accentColor`, `Color("Card")`), emitted verbatim.
+ */
+export type PaletteMap = Readonly<Record<string, string>>;
+/**
+ * Where the view emitter resolves a literal: `base\0theme\0nodeId\0r,g,b,a` → token name, and
+ * the same key plus `\0slot` for call sites that know the slot.
+ *
+ * Most call sites that paint a colour do not know which named slot of the node they are
+ * painting (a `.shadow(color:)` line only has the `Shadow`), so the key is the colour value
+ * the node paints in the theme being emitted. Keyed per node, because one value can be two
+ * tokens in one screen — the same light colour with two different dark counterparts. A key
+ * two tokens claim is absent from the index: ambiguity keeps the literal instead of guessing
+ * the other theme; only the slot-qualified key resolves it.
+ */
+export type TokenIndex = Map<string, string>;
+/** Result of {@link extractTokens}. */
+export interface TokenSet {
+    /** Tokens in first-use order: semantic and static interleaved as the design uses them. */
+    tokens: ColorToken[];
+    /** Colour slots left inline: single-use colours that are identical in both themes. */
+    inlineSlots: number;
+    /** Resolution table for the emitters; see {@link screenTokens}. */
+    index: TokenIndex;
+}
+/** A single colour slot of one node in one theme. */
+export interface Slot {
+    /** Stable within a node: `fill0`, `border.top`, `run1.dec`, `path3.stroke`. */
+    key: string;
+    role: TokenRole;
+    color: Color;
+    /**
+     * Which CSS gradient stop a gradient slot is — what a `from-`/`via-`/`to-` utility names:
+     * the first, the last, and the middle one only when it is the only middle one.
+     */
+    stop?: "from" | "via" | "to";
+}
+/** A colour slot after pairing the two themes. */
+export interface Usage {
+    /** Screen group ({@link screenBase}) this slot belongs to. */
+    base: string;
+    /** Theme whose screen supplied {@link Usage.light} — a dark-only group has no light screen. */
+    theme: Theme;
+    nodeId: string;
+    slot: string;
+    role: TokenRole;
+    light: Color;
+    /** Unset when the node/slot exists in one theme only. */
+    dark?: Color;
+    /** Token hints of the node: custom-property names and role-qualified class hints. */
+    hints: string[];
+    /** {@link Slot.stop} */
+    stop?: "from" | "via" | "to";
+    /** Document-order index of the first theme that carried this slot. */
+    order: number;
+}

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

@@ -0,0 +1,6 @@
+/** Design-token API: extraction and Swift serialization have independent modules. */
+export type { TokenRole, ColorToken, TokenIndex, TokenSet, PaletteMap } from "./tokens/types.ts";
+export { pairUsages, screenBase, themeDrift } from "./tokens/slots.ts";
+export { camelize } from "./tokens/naming.ts";
+export { extractTokens, screenTokens } from "./tokens/extract.ts";
+export { emitDesignTokens, paletteWarnings, tokenHex } from "./tokens/emit.ts";

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

@@ -0,0 +1,2 @@
+import type { SemNode } from "../model/semantic.ts";
+export declare const visit: (n: SemNode, fn: (n: SemNode) => void) => void;

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

@@ -0,0 +1,4 @@
+/** Native row reflow; unsupported flex rules use measured placement. */
+import type { StackNode } from "../model/semantic.ts";
+import type { EmitContext } from "./context.ts";
+export declare function wrappingExpr(n: StackNode, ctx: EmitContext): string[];

package/package.json

@@ -1,6 +1,68 @@
 {
   "name": "markswift",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/raelsei/markswift.git"
+  },
+  "type": "module",
+  "bin": {
+    "markswift": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && bun build src/cli.ts src/index.ts src/compiler/index.ts --target=node --packages=external --splitting --outdir dist && tsc -p tsconfig.build.json",
+    "prepack": "bun run build",
+    "typecheck": "tsc --noEmit -p .",
+    "lint": "biome ci .",
+    "format": "biome format --write .",
+    "test": "bun test tests/unit tests/architecture tests/integration tests/conformance playground/tests",
+    "quality": "bun run tools/quality.ts",
+    "pilot": "bun run tests/conformance/pilot-run.ts",
+    "test:browser": "MARKSWIFT_BROWSER_TESTS=1 bun test --timeout 60000 tests/integration tests/conformance",
+    "test:native": "MARKSWIFT_SWIFT_TESTS=1 bun test --timeout 60000 tests/integration/swift.test.ts tests/unit/swift/wrapping.test.ts tests/unit/swift/tracks.test.ts tests/unit/swift/table.test.ts tests/unit/swift/counter.test.ts tests/integration/generated-content.test.ts tests/unit/swift/flex-row.test.ts tests/unit/swift/measured-layout.test.ts tests/unit/swift/line-height.test.ts tests/unit/swift/tooltips.test.ts tests/unit/swift/disclosure.test.ts tests/unit/swift/presentation.test.ts tests/unit/swift/menus.test.ts tests/unit/swift/bands.test.ts tests/unit/swift/bands-emit.test.ts tests/unit/swift/motion-runtime.test.ts tests/unit/swift/overlay-motion.test.ts tests/integration/motion-timing.test.ts tests/conformance/pilot-run.test.ts tests/integration/perf.test.ts",
+    "test:unit": "bun test tests/unit",
+    "test:architecture": "bun test tests/architecture",
+    "test:conformance": "bun test tests/conformance",
+    "test:ios-behaviour": "bun run tools/verify/ios-behaviour.ts"
+  },
+  "dependencies": {
+    "domhandler": "^5.0.3",
+    "htmlparser2": "^9.1.0",
+    "playwright-core": "^1.63.0",
+    "svgpath": "^2.6.0",
+    "zod": "^4.1.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.15",
+    "@types/bun": "^1.4.1",
+    "@types/pngjs": "^6.0.5",
+    "pixelmatch": "^7.1.0",
+    "pngjs": "^7.0.0",
+    "sharp": "0.34.5",
+    "ssim.js": "^3.5.0",
+    "typescript": "^5.9.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./compiler": {
+      "types": "./dist/types/compiler/index.d.ts",
+      "default": "./dist/compiler/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/types/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20",
+    "bun": ">=1.4.2"
+  },
+  "description": "Measured HTML and CSS to native SwiftUI components"
+}