markswift 0.0.0-stage → 2.0.0

package/dist/types/compiler/index.d.ts

@@ -0,0 +1,91 @@
+import { LayoutDoc } from "../model/layout.ts";
+import { type EmitMode, type SwiftOutput } from "../swift/emit.ts";
+import { type PaletteMap } from "../swift/tokens.ts";
+import type { FaceMetrics, BundledFamily } from "../model/fonts.ts";
+import type { ConversionWarning } from "../model/semantic.ts";
+export type { Diagnostic, DiagnosticLevel, Confidence, ConversionWarning } from "../model/semantic.ts";
+export interface CompileOptions {
+    /** Complete Swift type name, e.g. ProfileCard. ASCII identifiers starting with uppercase. */
+    name?: string;
+    mode?: EmitMode;
+    bundledFamilies?: Record<string, BundledFamily>;
+    fontMetrics?: Record<string, FaceMetrics>;
+    /**
+     * Dark capture of the same screen; `layout` must then be the light one. The view is emitted
+     * from the light layout and every colour that differs in dark becomes a `Color.markswift(light:dark:)` token.
+     */
+    dark?: LayoutDoc;
+    /**
+     * Capture of the same screen and theme at another viewport width. Admitted MarkswiftTracks/MarkswiftFlexRow nodes
+     * whose authored inputs do not reproduce the probe geometry within 1px fall back to pinned output with a diagnostic.
+     */
+    probe?: LayoutDoc;
+    /** Breakpoint conversion: captures of the same screen and theme at the other width bands, ascending by viewport
+     * width; `layout` is band 0. Their shared `conditions` define the band edges. A page with width `@container` queries
+     * may hold more than one capture per band (`BandPlan.extra`); the lowest of a band represents it. */
+    variants?: LayoutDoc[];
+    /** Dark captures of `variants`, same order; required when `dark` is set with `variants`. */
+    darkVariants?: LayoutDoc[];
+    /** Probe capture per variant (same order), as `probe` is for `layout`. */
+    variantProbes?: Array<LayoutDoc | undefined>;
+    /** @internal Pixel-identity check only: disables repeated-sibling extraction. */
+    extract?: boolean;
+    /** `public` for a generated library (plan 033's `build`); `convert` stays internal. Default `internal`. */
+    visibility?: "internal" | "public";
+    /** App colours for captured tokens (`--palette`); views keep referencing `Palette.x`. */
+    palette?: PaletteMap;
+}
+export interface CompileResult {
+    name: string;
+    code: string;
+    /** All Swift sources needed by this view, including shared runtime helpers. */
+    files: Record<string, string>;
+    diagnostics: SwiftOutput["report"];
+    /** Binary resources referenced by the generated Swift (relative bundle path → bytes), e.g. `Images/<hash>.png`. Add these resources to the iOS target. */
+    assets: Record<string, Uint8Array>;
+    /** Light/dark pairing limitations and palette-map gaps; empty for a single-theme compile without a map. */
+    warnings: ConversionWarning[];
+    /** App mode: layer id → the `init` label (`isMoreExpanded`, `isEditProfilePresented`) that shows it; absent when nothing opens. */
+    openStates?: Record<string, string>;
+}
+/** Compile a captured layout. Custom fonts must be packaged by the caller and passed explicitly. */
+export declare function compileLayout(layout: LayoutDoc, options?: CompileOptions): CompileResult;
+/** A runtime Layout (MarkswiftTracks, MarkswiftFlexRow) would reflow some node of `layout`: a probe capture can verify it. */
+export declare function needsProbe(layout: LayoutDoc): boolean;
+export { planBands, BAND_MIN, BAND_CAP, DEFAULT_BAND_DEVICES, type BandPlan } from "../analysis/bands.ts";
+export interface LibraryComponent {
+    name: string;
+    layout: LayoutDoc;
+    dark?: LayoutDoc;
+    /** Breakpoint component: captures at the other width bands, as `CompileOptions.variants`. */
+    variants?: LayoutDoc[];
+    /** Dark captures of `variants`, as `CompileOptions.darkVariants`. */
+    darkVariants?: LayoutDoc[];
+    mode?: EmitMode;
+}
+export interface LibraryOptions extends Pick<CompileOptions, "bundledFamilies" | "fontMetrics" | "palette"> {
+    /** Library (Swift module) name; must differ from every component name. */
+    library: string;
+    /** Add `BundledFonts.register()` to every preview (the package bundles fonts). */
+    registerFonts?: boolean;
+}
+export interface LibraryResult {
+    /** Module sources, relative to `Sources/<library>/`. */
+    files: Record<string, string>;
+    assets: Record<string, Uint8Array>;
+    /** Per-component compile warnings, each with `component` set to the component name; palette-map warnings are library-wide. */
+    warnings: ConversionWarning[];
+    diagnostics: Record<string, CompileResult["diagnostics"]>;
+}
+/** Library and component names of one build: valid Swift types, unique ignoring case, none named like the library. */
+export declare function validateLibrary(library: string, components: string[]): void;
+/**
+ * Compile many captured components into the sources of one Swift module: one token set over every
+ * screen, so one name per light/dark value pair, emitted as a module-level `public enum Palette`
+ * (`MarkswiftPalette.swift`); shapes deduplicated into `MarkswiftShapes.swift`; one runtime;
+ * public views. Views reference bare `Palette.x`/`MarkswiftShape_x`, which resolve to these.
+ */
+export declare function compileLayouts(components: LibraryComponent[], options: LibraryOptions): LibraryResult;
+export type { LayoutDoc } from "../model/layout.ts";
+export type { EmitMode } from "../swift/emit.ts";
+export type { PaletteMap } from "../swift/tokens.ts";

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

@@ -0,0 +1 @@
+export declare function validateName(name: string): void;

package/dist/types/css/background.d.ts

@@ -0,0 +1,16 @@
+import type { BackgroundRepeat, BackgroundSize } from "../model/values.ts";
+/** Computed `background-repeat` (first layer) → one of the four tile modes; `space`/`round` → `repeat`. */
+export declare function parseBackgroundRepeat(s: string | undefined): BackgroundRepeat | undefined;
+/**
+ * One `background-size` layer (first layer of a comma list) → px box, `cover`/`contain`,
+ * or undefined when it depends on the image's intrinsic size (`auto`) and `imgW`/`imgH`
+ * are not given. `auto` on one axis keeps the image aspect ratio.
+ */
+export declare function parseBackgroundSize(s: string | undefined, boxW: number, boxH: number, imgW?: number, imgH?: number): BackgroundSize | undefined;
+/**
+ * One `background-position` layer → `[x, y]` px offset of the image's top-left corner.
+ * Handles px, `%`, `calc()`, side keywords (`left center right top bottom`) and the
+ * 3/4-value `right 10px bottom 20px` form. Percentages and far-side offsets resolve
+ * against `box − image` when `imgW`/`imgH` are given, else against the box.
+ */
+export declare function parseBackgroundPosition(s: string | undefined, boxW: number, boxH: number, imgW?: number, imgH?: number): [number, number];

package/dist/types/css/blend.d.ts

@@ -0,0 +1,9 @@
+import { type BlendMode } from "../model/values.ts";
+/** One `<blend-mode>` keyword; `undefined` for anything outside the spec's list. */
+export declare function parseBlendMode(s: string | undefined): BlendMode | undefined;
+/**
+ * `background-blend-mode`: one keyword per background layer, in CSS layer order (top-most
+ * first), cycled by the caller when there are more layers than keywords. An unrecognised
+ * keyword yields `normal` so a layer is never silently dropped.
+ */
+export declare function parseBlendModes(s: string | undefined): BlendMode[];

package/dist/types/css/color.d.ts

@@ -0,0 +1,14 @@
+/** Pure color interpretation of browser-resolved CSS values. */
+import type { Color } from "../model/values.ts";
+export declare const TRANSPARENT: Color;
+/** CSS named colours. Computed styles never use them, but attribute-only SVG markup (data: images) does. */
+export declare const NAMED_COLORS: Record<string, string>;
+/**
+ * Any CSS color Chrome serialises: `transparent`, `#hex` (3/4/6/8), legacy and modern
+ * `rgb()/rgba()`, `hsl()/hsla()`, `hwb()`, `lab()/lch()`, `oklab()/oklch()`, and
+ * `color(<space> …)` for the CSS Color 4 predefined spaces. Non-sRGB inputs are converted
+ * through XYZ D65, clipped to the sRGB gamut and rounded to 4 decimals. Unknown → undefined.
+ */
+export declare function parseColor(s: string | undefined): Color | undefined;
+/** Hue component in degrees (`deg`, `rad`, `grad`, `turn`, bare number, `none`). */
+export declare function hue(t: string): number | undefined;

package/dist/types/css/counter.d.ts

@@ -0,0 +1,10 @@
+import type { CounterStyle } from "../model/semantic.ts";
+/** `list-style-type` / `counter()` styles whose text Markswift can regenerate; Chrome's `*-latin` print as `*-alpha`. */
+export declare const COUNTER_STYLES: Readonly<Record<string, CounterStyle>>;
+/** A counter value as Chrome prints it; alphabetic below 1 and roman outside 1…3999 fall back to decimal. Mirror: `markswiftCounter` (runtime/counter.swift). */
+export declare function counterText(value: number, style: CounterStyle): string;
+/** The counter value at the start of `text` (after `prefix`), and the rest; undefined unless `counterText` reproduces it. */
+export declare function parseCounter(text: string, style: CounterStyle, prefix?: string): {
+    value: number;
+    suffix: string;
+} | undefined;

package/dist/types/css/easing.d.ts

@@ -0,0 +1,4 @@
+/** CSS easing functions (css-easing-2) → IR `Easing`. */
+import type { Easing } from "../model/semantic.ts";
+/** `ease`, `cubic-bezier(…)`, `steps(…)`, `linear(…)` → IR; undefined when it is not a valid easing function. */
+export declare function parseEasing(s: string): Easing | undefined;

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

@@ -0,0 +1,18 @@
+/** Pure effects interpretation of browser-resolved CSS values. */
+import type { ClipShape, Filter } from "../model/semantic.ts";
+/**
+ * Computed `filter` list → ordered entries. Chrome serialises amounts as bare numbers
+ * (`grayscale(1)`), lengths in px and angles in deg. `url()` and unknown functions land
+ * in `unsupported` (raw text) so the caller can note them.
+ */
+export declare function parseFilters(s: string | undefined): {
+    filters: Filter[];
+    unsupported: string[];
+};
+/**
+ * Computed `clip-path` basic shape → px geometry inside a `w`×`h` box. Handles
+ * `circle(r at x y)`, `ellipse(rx ry at x y)`, `inset(t r b l round …)`, `polygon(…)`
+ * with px/%/`closest-side`/`farthest-side` and `at` keywords. `none`, `path()`, `url()`
+ * and reference boxes → undefined.
+ */
+export declare function parseClipPath(s: string | undefined, w: number, h: number): ClipShape | undefined;

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

@@ -0,0 +1,29 @@
+import type { GridRowTrack, GridTemplate } from "../model/semantic.ts";
+/** Browser-resolved grid tracks; authored repeat/fr/subgrid values remain unresolved. */
+export declare function resolvedGridTracks(value: string | undefined): number[] | undefined;
+/** Authored Typed-OM template → tracks; undefined for anything MarkswiftTracks cannot reproduce. */
+export declare function parseTrackTemplate(value: string | undefined): GridTemplate | undefined;
+/** Authored `grid-template-rows` / computed `grid-auto-rows` → rows MarkswiftTracks sizes; undefined otherwise. */
+export declare function parseRowTracks(value: string | undefined): GridRowTrack[] | undefined;
+export interface GridArea {
+    colStart: number;
+    colEnd: number;
+    rowStart: number;
+    rowEnd: number;
+}
+/** Computed `grid-template-areas` → each named area's 1-based lines and the areas' row/column counts; `none` → empty. */
+export declare function parseGridAreas(value: string | undefined): {
+    areas: Record<string, GridArea>;
+    rows: number;
+    columns: number;
+} | undefined;
+/**
+ * CSS grid §8.3 for one axis: computed start/end longhands → 1-based start line (absent = auto-placed) and span.
+ * `lines` = the explicit grid's line count on this axis (negative lines count back from it). Area names (also
+ * `<area>-start`/`<area>-end`) resolve through `areas`. Undefined for what MarkswiftTracks cannot place: named lines
+ * of the template, `span <name>`, `<n> <name>`, or a line before the grid's first.
+ */
+export declare function gridSpan(start: string | undefined, end: string | undefined, areas: Record<string, GridArea>, axis: "col" | "row", lines: number): {
+    start?: number;
+    span: number;
+} | undefined;

package/dist/types/css/index.d.ts

@@ -0,0 +1,15 @@
+/** Public CSS parser surface; implementations are grouped by CSS responsibility. Code outside css/ imports from here. */
+export { parseColor } from "./color.ts";
+export { px, parseDeclared, splitTop, resolveLength, round2 } from "./syntax.ts";
+export { parseBlendMode, parseBlendModes } from "./blend.ts";
+export { contentAlt, cssUrls, paintWithin, parseBackgroundImage, resolvePaint } from "./paint.ts";
+export { COUNTER_STYLES, counterText, parseCounter } from "./counter.ts";
+export { parseShadows } from "./shadows.ts";
+export { type TransformLoss, parseTransform, parseOrigin, cssTransform } from "./transforms.ts";
+export { parseFilters, parseClipPath } from "./effects.ts";
+export { parseBackgroundRepeat, parseBackgroundSize, parseBackgroundPosition } from "./background.ts";
+export { rasterSize } from "./raster.ts";
+export { fontWeight, fontFamilies, fontStretch, variationSettings } from "./typography.ts";
+export { parseRadiusXY } from "./radius.ts";
+export { type GridArea, gridSpan, parseGridAreas, parseRowTracks, parseTrackTemplate, resolvedGridTracks, } from "./grid.ts";
+export { type WidthQuery, widthQuery, passes, matchesWidth, captureWidth, bandOf } from "./media.ts";

package/dist/types/css/media.d.ts

@@ -0,0 +1,16 @@
+/** Width `@media`/`@container` conditions as band edges: the thresholds a breakpoint capture plans bands from. */
+import type { BandEdge } from "../model/semantic.ts";
+/** A pure width condition: `above` = lower limit (width must pass it), `below` = upper limit (width must not). */
+export interface WidthQuery {
+    above?: BandEdge;
+    below?: BandEdge;
+}
+/** Chrome's `conditionText` as a width condition; `undefined` when it is not one this parser reconstructs. */
+export declare function widthQuery(query: string): WidthQuery | undefined;
+/** `width` is past `edge`: `inclusive ? w >= px : w > px`. */
+export declare function passes(edge: BandEdge, width: number): boolean;
+export declare function matchesWidth(q: WidthQuery, width: number): boolean;
+/** First integer width past the edge. */
+export declare function captureWidth(edge: BandEdge): number;
+/** Band index of `width`: the number of (ascending) edges it passes. */
+export declare function bandOf(width: number, edges: BandEdge[]): number;

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

@@ -0,0 +1,33 @@
+import type { Paint } from "../model/values.ts";
+/**
+ * Re-express a gradient painted over `host` so that the same colours land on `sub` (both
+ * boxes in one coordinate space): linear stops are projected onto `sub`'s span of the
+ * gradient line and cut to 0..1; radial/conic centers move. Used for `background-clip:
+ * text`, where the browser paints across the block but the glyph run is what gets filled.
+ */
+export declare function paintWithin(p: Paint, host: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}, sub: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}): Paint;
+/** Computed `background-image` → paints, bottom-most first. `dropped` collects the parts a gradient could not read. */
+export declare function parseBackgroundImage(s: string | undefined, dropped?: string[]): Paint[];
+/** Every `url(…)` in a computed value, in order, unquoted and unescaped (`content`, `list-style-image`). */
+export declare function cssUrls(value: string | undefined): string[];
+/** The alternative text of a computed `content` (the quoted strings after a top-level ` / `, joined); undefined without one. */
+export declare function contentAlt(value: string | undefined): string | undefined;
+export declare function fraction(t: string): number | undefined;
+export declare const COLOR_TOKEN: string;
+/**
+ * Resolve a gradient's px stops against the box it paints: linear stops divide by the
+ * gradient-line length (`|w·sin θ| + |h·cos θ|`), radial stops by the farthest-corner
+ * distance from the center. Non-repeating stops clamp to 0..1; repeating ones keep their
+ * period so the consumer can tile. Paints without px stops are returned as-is.
+ */
+export declare function resolvePaint(p: Paint, w: number, h: number): Paint;

package/dist/types/css/radius.d.ts

@@ -0,0 +1,5 @@
+/**
+ * One `border-*-radius` corner → `[horizontal, vertical]` px. A single value applies to
+ * both axes; `%` resolves against `refW` (horizontal) / `refH` (vertical) as in CSS.
+ */
+export declare function parseRadiusXY(s: string | undefined, refW: number, refH: number): [number, number];

package/dist/types/css/raster.d.ts

@@ -0,0 +1,10 @@
+/** Natural size of an embedded raster from its header bytes; no image decoder. */
+/**
+ * A raster `data:` URL → its natural size in CSS px (one pixel each): PNG, GIF, JPEG (EXIF
+ * orientations 5–8 swap the axes, as Chrome's `image-orientation: from-image` draws them) and
+ * WebP (VP8, VP8L, VP8X). `undefined` for any other URL, format or a truncated header.
+ */
+export declare function rasterSize(url: string): {
+    w: number;
+    h: number;
+} | undefined;

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

@@ -0,0 +1,3 @@
+import type { Shadow } from "../model/values.ts";
+/** Computed `box-shadow`: `rgba(…) 0px 12px 34px 0px[, …][ inset]`. `dropped` collects the shadows it could not read. */
+export declare function parseShadows(s: string | undefined, dropped?: string[]): Shadow[];

package/dist/types/css/syntax.d.ts

@@ -0,0 +1,12 @@
+/** Pure syntax interpretation of browser-resolved CSS values. */
+export declare function px(s: string | undefined): number;
+/** Declared inline style → property map (lower-cased names, trimmed values). */
+export declare function parseDeclared(style: string | undefined): Record<string, string>;
+/** Split on `sep` at paren depth 0 (for comma-separated lists containing function calls). */
+export declare function splitTop(s: string, sep: string): string[];
+/**
+ * `<length-percentage>` → px against `ref`: `12px`, `50%`, `0`, or a linear
+ * `calc(100% - 10px)` mixing px and % terms. Unknown units → undefined.
+ */
+export declare function resolveLength(t: string, ref: number): number | undefined;
+export declare function round2(v: number): number;

package/dist/types/css/transforms.d.ts

@@ -0,0 +1,45 @@
+import type { Transform2D } from "../model/values.ts";
+/**
+ * Computed `transform: matrix(a, b, c, d, tx, ty)` or `matrix3d(…)` → rotation/scale/skew/
+ * translation (2 decimals). A 3D matrix keeps only its x/y affine part (orthographic
+ * flattening, the way a `rotateY(30deg)` looks squeezed) and is marked `flattened`.
+ */
+export declare function parseTransform(s: string | undefined): Transform2D | undefined;
+export interface TransformLoss {
+    level: "approximated" | "unmapped";
+    feature: "translate" | "rotate" | "transform" | "transform: matrix3d()";
+    message: string;
+}
+/** One `translate` component: `±Npx`/`±N%` terms, optionally in `calc(…)`; `%` of `ref`. */
+export declare function translateLength(t: string, ref: number): number | undefined;
+/**
+ * Animatable 2D channels of one transform value; `order` = its function kinds (`T`ranslate, `R`otate, `S`cale) in list
+ * order, runs merged. Identity functions (tw-animate's `rotate(0deg)`, `scale3d(1, 1, 1)`) compose nothing: no kind.
+ */
+export interface TransformChannels {
+    tx: number;
+    ty: number;
+    sx: number;
+    sy: number;
+    deg: number;
+    order: string;
+}
+/**
+ * A keyframe's `transform` / `translate` / `scale` / `rotate` value → channels (`w`/`h` = border box for `%`).
+ * Only translate*, scale*, rotate/rotateZ (z parts ignored: no perspective); anything else → undefined.
+ * A list is composed T·R·S only when `order` is a subsequence of `TRS` — the caller checks.
+ */
+export declare function transformChannels(property: "transform" | "translate" | "scale" | "rotate", value: string, w: number, h: number): TransformChannels | undefined;
+/**
+ * The element's whole 2D transform, composed the CSS Transforms 2 way:
+ * translate · rotate · scale · transform, all about one transform-origin.
+ * `w`/`h` = border box (the reference box for % translations). `losses` = what could not be represented.
+ */
+export declare function cssTransform(s: Record<string, string | undefined>, w: number, h: number): {
+    transform?: Omit<Transform2D, "flattened"> & {
+        origin?: [number, number];
+    };
+    losses: TransformLoss[];
+};
+/** `transform-origin: 17px 158px` → px pair. */
+export declare function parseOrigin(s: string | undefined): [number, number] | undefined;

package/dist/types/css/typography.d.ts

@@ -0,0 +1,8 @@
+/** Numeric font-weight from computed value (`700`, `bold`, `normal`). */
+export declare function fontWeight(s: string | undefined): number;
+/** First family in a computed font-family list, unquoted. */
+export declare function fontFamilies(s: string | undefined): string[];
+/** Computed `font-variation-settings` (`"GRAD" -20, "wght" 650`) → axis tag → value; `normal` → {}. */
+export declare function variationSettings(s: string | undefined): Record<string, number>;
+/** Computed `font-stretch` in % (Chrome serialises keywords as `75%`); 100 when absent or unparsable. */
+export declare function fontStretch(s: string | undefined): number;

package/dist/types/fonts/converter.d.ts

@@ -0,0 +1,16 @@
+export interface FontToolResult {
+    upem: number;
+    ascent: number;
+    descent: number;
+    lineGap: number;
+    useTypoMetrics: boolean;
+    axes: Record<string, [number, number]>;
+    converted: boolean;
+    renamed: boolean;
+    /** Rewritten sfnt bytes; absent when the input already registers under `family` as-is. */
+    bytes?: Uint8Array;
+}
+/** Decompress WOFF/WOFF2 and rewrite the name table so `family` resolves; a string is the failure reason. */
+export type FontConverter = (bytes: Uint8Array, family: string, subfamily: string, signal?: AbortSignal) => Promise<FontToolResult | string>;
+/** python3 + fontTools. The only temp files in font packaging live and die here. */
+export declare const pythonFontConverter: FontConverter;

package/dist/types/fonts/metadata.d.ts

@@ -0,0 +1,6 @@
+import type { BundledFamilies, FontMetrics } from "../model/fonts.ts";
+import type { FontPackage } from "./types.ts";
+/** Metrics captured by this package, isolated from all other conversions. */
+export declare function metricsForFonts(pkg: FontPackage): FontMetrics;
+/** Families of a package, in the shape the inference pass resolves `font-family` against. */
+export declare function bundledFamilies(pkg: FontPackage): BundledFamilies;

package/dist/types/fonts/package.d.ts

@@ -0,0 +1,12 @@
+import type { FontFace } from "../model/layout.ts";
+import type { FontPackage } from "./types.ts";
+import { type FontConverter } from "./converter.ts";
+/**
+ * Packages every bundleable face: faces + their captured bytes in, `Fonts/<file>` assets out.
+ *
+ * `sources` holds the capture's font bytes keyed by `src[].file`; `data:` sources carry their
+ * own. Faces are grouped by (family, style): within a group the Basic-Latin subset wins, the
+ * rest are reported. A face whose bytes cannot be read, or whose format iOS cannot load and
+ * `convert` cannot convert, is noted and left out of the package; no asset is shipped for it.
+ */
+export declare function packageFonts(faces: FontFace[], sources: ReadonlyMap<string, Uint8Array>, convert?: FontConverter, signal?: AbortSignal): Promise<FontPackage>;

package/dist/types/fonts/registration.d.ts

@@ -0,0 +1,13 @@
+import type { PackagedFace } from "./types.ts";
+/** `UIAppFonts` array for `Info.plist` — the app-target half of loading a bundled font. */
+export declare function plistFragment(files: string[]): string;
+/**
+ * `<View>+Fonts.swift`: the runtime half. `UIAppFonts` only works for a real app bundle, so the
+ * generated code registers the same files with CoreText — the mechanism the render harness
+ * already uses (`MarkswiftFonts.register`), reused rather than duplicated, so a generated view renders
+ * identically in the harness, in `#Preview` and in the app. Nested in the view type
+ * (`<View>.BundledFonts`) so several conversions coexist in one target. Without `owner` it is the
+ * module-level `public enum BundledFonts` of a generated library package (`markswift build`), which
+ * reads `Bundle.module` itself: a public default argument cannot name the internal `Bundle.module`.
+ */
+export declare function registrationSwift(faces: PackagedFace[], owner?: string): string;

package/dist/types/fonts/source.d.ts

@@ -0,0 +1,14 @@
+import type { FontFace } from "../model/layout.ts";
+/** Codepoints a face must cover to be the one worth bundling: Basic Latin. */
+export declare function coversLatin(range: string | undefined): boolean;
+/** Bytes behind one `src` entry: the `data:` URL itself, or the captured bytes keyed by `src.file`. */
+export declare function srcBytes(src: FontFace["src"][number], sources: ReadonlyMap<string, Uint8Array>): Uint8Array | undefined;
+/** OpenType weight class → the subfamily name a font file conventionally carries for it. */
+export declare const WEIGHT_SUBFAMILY: Record<number, string>;
+/**
+ * File stem for a packaged face, unique within one package case-insensitively (as `writeBundle` checks).
+ * `claimed` maps lower-cased stems already written to their CSS family. Returns `undefined` when this exact
+ * family already owns the stem: the same family+subfamily twice (italic and oblique, or a static 400 and a
+ * variable Regular) would register one PostScript name twice on iOS, so only the first can be bundled.
+ */
+export declare function fontFileStem(family: string, subfamily: string, claimed: ReadonlyMap<string, string>): string | undefined;

package/dist/types/fonts/types.d.ts

@@ -0,0 +1,28 @@
+import type { FaceMetrics } from "../model/fonts.ts";
+import type { ConversionWarning } from "../model/semantic.ts";
+/** A face bundled with the generated Swift; its bytes are `FontPackage.assets["Fonts/<file>"]`. */
+export interface PackagedFace {
+    /** CSS family name — what `font-family` declarations say and what the emitter emits. */
+    family: string;
+    /** File name under `Fonts/`. */
+    file: string;
+    style: "normal" | "italic" | "oblique";
+    /** `font-weight` range the face covers; `[400, 400]` for a static face. */
+    weight: [number, number];
+    /** Variation axis ranges, by tag (`wght`, `opsz`, `wdth`); empty for a static face. */
+    axes: Record<string, [number, number]>;
+    metrics: FaceMetrics;
+    /** Source format was WOFF/WOFF2 and the file was decompressed to sfnt. */
+    converted: boolean;
+    /** The name table was rewritten so the CSS family name resolves. */
+    renamed: boolean;
+}
+export interface FontPackage {
+    faces: PackagedFace[];
+    /** `Fonts/<file>` → bytes to ship; exactly one entry per packaged face. */
+    assets: Record<string, Uint8Array>;
+    /** `Info.plist` `UIAppFonts` fragment; empty when nothing was packaged. */
+    plist: string;
+    /** What the design asked for and did not get. */
+    notes: ConversionWarning[];
+}

package/dist/types/html/elements.d.ts

@@ -0,0 +1,8 @@
+import type { ElementPolicy } from "./types.ts";
+/** WHATWG element index, checked 2026-09-16, including SVG and MathML entry points.
+ * https://html.spec.whatwg.org/multipage/indices.html
+ * Browser-computed display/geometry decides layout; these policies decide exceptional semantics.
+ * "implemented" means a compiler path exists. CSS combinations, accessibility and behavior
+ * require their own tests and are not established by this registry.
+ */
+export declare const HTML_ELEMENTS: Readonly<Record<string, ElementPolicy>>;

package/dist/types/html/index.d.ts

@@ -0,0 +1,4 @@
+export { HTML_ELEMENTS } from "./elements.ts";
+export { INPUT_CONTROLS } from "./inputs.ts";
+export { classifyElement } from "./policy.ts";
+export type { ElementPolicy, ElementRoute, ElementSupport } from "./types.ts";

package/dist/types/html/inputs.d.ts

@@ -0,0 +1,4 @@
+import type { ControlKind } from "../model/semantic.ts";
+/** Attribute-specific native routing. The analyzer and capability policy share this table. */
+export declare const INPUT_CONTROLS: Readonly<Record<string, ControlKind>>;
+export declare const INPUT_PLACEHOLDERS: Readonly<Record<string, string>>;

package/dist/types/html/policy.d.ts

@@ -0,0 +1,3 @@
+import type { ElementPolicy } from "./types.ts";
+/** Pure attribute-based classification, also used before the analyzer merges inline text. */
+export declare function classifyElement(tag: string, attrs?: Record<string, string>): ElementPolicy;

package/dist/types/html/types.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic } from "../model/semantic.ts";
+/** Compiler strategies describe routing, not a promise of pixel-perfect or behavioral coverage. */
+export type ElementRoute = "flow" | "text" | "control" | "image" | "svg" | "line-break" | "metadata" | "placeholder";
+export type ElementSupport = "implemented" | "approximated" | "unsupported" | "nonvisual";
+export interface ElementPolicy {
+    readonly route: ElementRoute;
+    readonly support: ElementSupport;
+    /** An atomic element must reach inference instead of being swallowed by its parent's text. */
+    readonly atomic: boolean;
+    readonly known: boolean;
+    readonly diagnostic?: Diagnostic;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export { convert, convertHtml } from "./api/convert.ts";
+export type { HtmlSource, ConvertOptions, ConversionResult } from "./api/types.ts";
+export { buildLibrary } from "./api/build.ts";
+export type { BuildOptions, BuildComponent, BuildResult } from "./api/build.ts";
+export { compileLayout, compileLayouts } from "./compiler/index.ts";
+export type { CompileOptions, LibraryComponent, LibraryOptions, LibraryResult, CompileResult, LayoutDoc, EmitMode, PaletteMap, Diagnostic, DiagnosticLevel, Confidence, ConversionWarning, } from "./compiler/index.ts";
+export { HTML_ELEMENTS, INPUT_CONTROLS, classifyElement } from "./html/index.ts";
+export type { ElementPolicy, ElementRoute, ElementSupport } from "./html/index.ts";

package/dist/types/input/identity.d.ts

@@ -0,0 +1,3 @@
+import type { NodeIdentity } from "./types.ts";
+/** Stable names shared by all HTML inputs, independent of stylesheet origin. */
+export declare const htmlIdentity: NodeIdentity;

package/dist/types/input/mime.d.ts

@@ -0,0 +1 @@
+export declare function mimeType(path: string): string;

package/dist/types/input/root.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_ROOT = "[data-markswift-root], body:not(:has([data-markswift-root]))";

package/dist/types/input/server.d.ts

@@ -0,0 +1,11 @@
+export interface StaticServer {
+    /** `http://127.0.0.1:<port>` */
+    origin: string;
+    stop(): void;
+}
+/**
+ * Serve `rootDir` on an ephemeral port. Refused: a Host other than this server's own
+ * `127.0.0.1:<port>` (403, DNS rebinding), malformed percent-encoding (400), any dot-segment
+ * such as `.env` or `.git/` (404), and paths resolving outside the root (403).
+ */
+export declare function serveDir(rootDir: string): Promise<StaticServer>;

package/dist/types/input/source.d.ts

@@ -0,0 +1,9 @@
+import type { HtmlSource } from "./types.ts";
+export interface ResolvedSource {
+    html?: string;
+    url: string;
+    label: string;
+    close(): void;
+}
+/** Resolve source-relative assets and own any temporary HTTP serving for this source. */
+export declare function resolveSource(source: HtmlSource): Promise<ResolvedSource>;

package/dist/types/input/types.d.ts

@@ -0,0 +1,54 @@
+/** Browser capture contract, independent of source frameworks and corpus tooling. */
+import type { Page } from "playwright-core";
+import type { Layer, Theme } from "../model/layout.ts";
+/** An element the open-state pass activates (`browser/layers.ts`). */
+export interface Trigger {
+    /** Element path from the capture root. */
+    path: string;
+    activation: Layer["activation"];
+    /** Set by the native rules (`popovertarget`, `commandfor`, `interestfor`, `details`). */
+    relation?: Layer["relation"];
+    /** Layer id: slug of the trigger's name, unique per page. */
+    id: string;
+    /** LayoutNode id of the trigger. */
+    trigger: string;
+}
+export interface CaptureRequest {
+    /** Logical screen name (`home`). */
+    screen: string;
+    theme: Theme;
+    /** Fully-qualified URL, served by the source preparer. */
+    url: string;
+    /** Optional document served at `url`; relative resources resolve against that URL. */
+    html?: string;
+    /** CSS selector of the capture root; its box is the coordinate origin and screenshot clip. */
+    root: string;
+    /** Selector that must be attached before capture (mount check). Defaults to `root`. */
+    waitFor?: string;
+    /** Also take a device-scale screenshot clipped to the capture root (`Capture.png`). */
+    screenshot?: boolean;
+    /** Capture at this viewport instead of the browser context's (probe captures). */
+    viewport?: {
+        width: number;
+        height: number;
+    };
+    /** Hook after load, before settle (class toggles etc.). */
+    prepare?(page: Page): Promise<void>;
+    /** Internal to the layer pass: open this trigger and report what it shows (`Capture.opened`). */
+    open?: Trigger;
+    /** Internal to the layer pass: with `open`, also probe how the layer is dismissed. */
+    probeDismiss?: boolean;
+    /** The conversion reconstructs width media queries: they are not reported as losses. */
+    breakpoints?: boolean;
+}
+/** Stable node identity for re-sync. `path` = element-index path from the capture root ("0/2/1"); `tag` lower-case; `attrs` raw. */
+export type NodeIdentity = (tag: string, attrs: Record<string, string>, path: string) => string | undefined;
+export type HtmlSource = {
+    html: string;
+    baseURL?: string;
+    assetsDir?: string;
+} | {
+    file: string;
+} | {
+    url: string;
+};