Changelog

Release history for the Swift package. Source of truth: CHANGELOG.md.

All notable changes to Aurum-iOS. Follows Keep a Changelog;

versions follow semver (patch = token/bug fix, minor = new component/token,

major = breaking API).

[0.2.3] - 2026-07-30

Fixed

  • **AurumSectionHeaderAction.link now renders neutral-subtle, matching its

Figma master (5442:462).** The link action was styled identically to the

text action — Title/XS-SemiBold in interactive.textPrimaryNormal

(brand purple) with a 20pt iconPrimaryNormal chevron — so "View All /

See More" links shouted as loudly as the section title and were

indistinguishable from a brand text-button. The sheet's action link

layer specifies Body/S-Medium in interactive.textNeutralSubtle with a

12pt interactive.iconNeutralSubtle chevron; the component now follows

it. text is unchanged and remains the brand-emphasis option.

Consumer impact: every existing link action becomes grey and one

step smaller — intended, but visible. Mirrors aurum-android 0.3.29.

  • **surface.textStaticBlackDisabled / surface.iconStaticBlackDisabled

were #121212; Figma and Android say #000000** (same 32% alpha). The

token-codegen carried a deliberate "normalize `_global-colors/neutral/

black/100 to palette black100` for Android parity" mapping whose premise

was false — verified against the live Figma file (alias chain walks to

#000000@0.32) and Android's manifest (ships #000000). The mapping also

silenced the codegen's own alias-integrity check. Removed: aliases into

collections outside the primitives export now inline Figma's resolved

value verbatim (and colors/* misses still hard-fail). Surfaced by

aurum-mcp's cross-platform token-parity check at merge time.

Changed

  • Portal redesigned as a specimen book (tooling/gallery/): the

presentation layer is now the locked Aurum-portal design system

(tooling/gallery/design.md, shared with aurum-android; platform lens

tokens are the only divergence). Newspaper masthead with the version as

the issue line, live type specimens rendered from real tokens on the

landing page, hairline plates instead of cards, tabular spec sheets on

component pages, typographic Do/Don't columns, a build-facts colophon

footer, full OKLCH tokenisation (tooling/gallery/tokens.css), in-place

copy feedback, and a platform-lens colour drawn from the system's own

palette (iOS = visual.blue.600). Verified at 320/375/768/1440 px with no

horizontal scroll; light + dark.

  • Gallery rebuilt as the "Aurum for iOS" designer portal

(tooling/gallery/generate.py): the presentation layer is now a port of

aurum-android's portal — landing page with hero/stats/release card,

light/dark/auto theme, ⌘K live search on components and icons,

copy-to-clipboard token swatches and icon symbol paths, per-component

pages with intended-use/Do/Don't cards and pinned-simulator snapshot

tiles, SPM install section, and bidirectional cross-links with the

Android portal. Data layer, CLI (--validate / --emit-manifest /

--out), and manifest schema unchanged.

Added

  • AurumIcons.Navigation.caretBold{Up,Down,Left,Right} (+ Filled).

Their masters have been sitting in the canonical icon sheet

(5130:35416) without code counterparts on either platform. Single-weight

in Figma, so both weights resolve to the same asset — the same convention

the existing caret family uses. Imported via make icons-import from

aurum-android's normalized Vector Drawables, bringing the iOS set back to

parity at 89 icons × 2 weights. The ICON_MANIFEST in

tooling/icon-import/import_icons.py gained the matching entries; it is a

verbatim port of Android's table, so an entry added on one platform must

land on the other in the same sitting.

  • Catalog app (catalog/AurumCatalog.xcodeproj, XcodeGen-generated

from project.yml — SPM can't declare app targets): an on-device

showcase with 11 family screens covering every component, including

live demos of the stateful surfaces the static gallery can't show —

the toast FIFO queue + timers, the persistent banner host, bottom

sheet presentations, and interactive tabs / nav bar / stepper /

selection controls. make catalog regenerates + builds.

  • Gallery + MCP manifest tooling (tooling/gallery/generate.py, the

iOS twin of aurum-android's generator): --validate enforces the

doc-tag + Figma-url contract in CI (make validate-docs, wired into

check.yml); --out renders the static HTML gallery (components with

doc tags + snapshot strips, tokens, icons, changelog); --emit-manifest

emits the aurum-mcp manifest (schemaVersion: 2,

platforms: ["ios"]), schema-validated against aurum-android's

contract. pages.yml deploys gallery + /data/manifest.json to GitHub

Pages after check passes on main.

[0.2.2] - 2026-07-21

Fixed

  • Code Connect: the checkbox mappings used property names guessed from

the radio set; the Figma checkbox masters actually expose

shownSubtext / shownLabel / shownHelptext / validationState

(and "indeterminate", not "intermediate"). v0.2.1's tag publish

failed validation on these; this release republishes all 197 mappings.

AurumCheckbox's mapping also gained the types label-position axis

(parity with Android's).

[0.2.1] - 2026-07-21

Added

  • AurumNavBar: bottom navigation with standard3/4/5 and

centerQr5 layouts (item-count preconditions), line→filled icon swap,

the purple/500 → pink/50 @ 61% brand ramp on selected glyphs (sRGB

blend helper — Color.mix needs iOS 18), and the raised 56 pt Scan-QR

dome (elliptical radial wash, gradient ring, purple hard shadow, 33 pt

glyph box for Figma's 27 pt drawn size). Labels clip at the cell edge

(Figma's overflow-clip) instead of ellipsising. One Code Connect

mapping (197 total parse clean) + one snapshot tile. **This completes

the aurum-android component-catalogue port** — every Figma-backed

Android component now has a SwiftUI counterpart (AurumScreen /

AurumFragmentBridge are Android platform glue with no iOS

equivalent).

  • Surface, stepper, transaction card: AurumSurface (base container

primitive — token background + shape clip + optional border +

.aurumShadow elevation; codebase-only), AurumStepper (± quantity

control, neutral/brand, "Add" initial state at minValue, bound-aware

disabling), AurumTransactionListCard (status-tinted history row:

feedback.* outer wash, white inner card, status badge, tinted amount,

optional 40 pt leading slot + helper line). Two Code Connect mappings

(196 total parse clean) + three snapshot tiles.

  • Selection family: AurumRadioButton + AurumRadioGroup,

AurumCheckbox (tri-state with check/indeterminate glyph shapes) +

AurumCheckboxGroup, and AurumSwitch (custom-drawn to the Figma/M3

anatomy — 52×32 track, thumb grows 16→24 pt with a check glyph when on,

which the native Toggle can't render). Controls draw Figma's press

state-layer via a press-reporting button style; error tinting, disabled

fade, start/end label positions, 32 pt-indented subtext, and group

label/helper/error lines all mirror Android. Five Code Connect mappings

(194 total parse clean) + four snapshot tiles.

  • Tabs: AurumTab (selected/unselected cell, optional 24 pt leading

icon, Title/XS-Bold label) + AurumTabRow (data-driven items: array —

a documented deviation from Android's slot lambda; fit-or-scroll width

algorithm max(widestNatural, 100 pt) with flex-equal fit and

pinned-width scroll modes, animated 2 pt indicator, hairline divider).

Two Code Connect mappings (189 total parse clean) + one snapshot tile.

  • Headers: AurumGlobalHeader (profile pill with radial sheen +

support / rewards+notifications / live-price right-group variants,

onLight/onDark schemes with dark-glass gradient borders) and

AurumPageHeader (56 pt title-and-actions row covering the 10 Figma

trailing-action types via nilable button/icon/overflow slots, 32×40 pt

icon wrappers, onDark scheme). Both bleed containerColor under the

status bar at the top edge (Android's inset params with no API). Two

Code Connect mappings (187 total parse clean) + two snapshot tiles.

  • Toast + Banner families: AurumToast (6 tones × small/large, per-tone

status glyph, always-dismissible; Code Connect mapping — 185 total parse

clean) with AurumToastHost/AurumToastHostState (FIFO-serialised async

showToast, short/long/indefinite auto-dismiss, slide-up/fade);

AurumBanner (persistent full-bleed top band, same tonal language,

inline action + optional ✕; backgrounds bleed under the status bar at the

top edge — Android's windowInsets for free) with

AurumBannerHost/AurumBannerHostState (single persistent slot,

slide-from-top expand/collapse). Plus AurumIconButton (icon-only

button, 44 pt touch floor, pressed dim) — needed by both close

affordances. Hosts + banner + icon button are codebase-only (no Figma

nodes), mirroring Android. AurumElevationLevel gained a public init

(Android parity) for the toast's master-declared 0/1/1 shadow recipe.

Four snapshot tiles.

  • Progress bars: AurumProgressBar (determinate 8 pt track + primary

fill, optional label/percentage header) and AurumSegmentedProgressBar

(bars/bubbles × 6 intents, numbered checkpoints). Two Code Connect

mappings (184 total parse clean) + two snapshot tiles.

  • AurumBottomSheet (.aurumBottomSheet modifier): native .sheet

presentation with a self-sizing .height detent, token corner radius +

card colour, strict (56 pt header + sticky button slot) and flexible

types. Platform deviations documented: system drag indicator inside the

card, system scrim.

  • AurumOtpInput: underline digit cells (4/6), invisible capture field

with oneTimeCode autofill, none/error/success/timer validation states,

completion-boundary onComplete. AurumTypeStyle gained a public init

(parity with Android's constructible TextStyle) for its Figma-specified

24/32 Bold digit style.

  • Field family: AurumTextField (static-label anatomy, validation-driven

borders and derived status affordances, counter, secure entry, multiline;

shape via a small enum — SwiftUI's InsettableShape can't be type-erased),

AurumSearchField (pill + magnifier + clear), AurumPhoneNumberInput

(country prefix + digits-only filter), AurumAmountInput (Num/XL hero

value + currency symbol + derived suffix). Three more Code Connect

mappings (180 total parse clean) and four snapshot tiles.

  • Second component wave, API-parity ports of aurum-android prioritized

by jar consumer usage: AurumLabel (default/subtle/strong × uppercase),

AurumLinkButton (text-only brand action with pressed dim + slots),

AurumBadge (6 roles × 2 emphases × 2 sizes, cross-axis token pairing,

optional leading icon), AurumChip (action/other × neutral/brand/black/

selected × large/small with pressed states), AurumSectionHeader

(title/subtitle + link/text/icon actions). Each with doc tags, a Code

Connect mapping (177 total now published on release), and snapshot tiles.

Fixed

  • AurumChip's capsule border rasterizes its stroke (drawingGroup) to

side-step an iOS 26.5 shape-layer quirk that paints stray vertical

hairlines at a stroked capsule's horizontal extremes.

[0.2.0] - 2026-07-20

Removed

  • **AurumIcons.Navigation.caretCircleUp/Down/Left/Right (+ Filled) —

removed to restore the 1:1 sheet↔catalog contract** (breaking). Their

Figma masters were deleted from the "Component Icons" sheet and current

product designs use chevron affordances exclusively; keeping ghost icons

breaks the premise that the catalog mirrors the sheet. Mirrors

aurum-android PR #57 (same removal); jar-android's only usage migrates to

a disc + chevronRight composition. 8 imagesets, 8 catalog entries gone

(170 remain); the FIGMA_DELETED workaround in the importer is gone with

them — a deleted Figma node now fails the import loudly, as the 1:1

contract demands.

[0.1.2] - 2026-07-20

Fixed

  • Code Connect: skip the four CaretCircle* icon mappings — their Figma

master components were deleted from the file (verified via the components

API; only the plain Caret set survives), and publish validation fails on

ghost nodes. The icon assets remain in the catalog. Android's

ICON_MANIFEST carries the same stale node ids and needs the same fix.

[0.1.1] - 2026-07-20

Added

  • Figma Code Connect (research §11.4): FigmaConnect/ dev-only nested

SPM package with 180 .figma.swift mappings — AurumButton (variant ×

size × isFullWidth × label), AurumLoader, and one per icon×weight

emitted by the icon importer. All 180 validated with the Swift parser

(make figma-parse). figma-code-connect.yml parse-validates on PR and

publishes to Dev Mode only from v*.*.* tags (Android's release gate,

mirrored).

[0.1.0] - 2026-07-20

Added

  • First components (research §11.3), API-parity ports of aurum-android:
  • AurumText — canonical text primitive over Aurum.type.* roles with the

Android foreground-resolution order (explicit foreground: ShapeStyle →

color: → textDefaultNormal); AttributedString overload for

per-run styling.

  • AurumIcon + generated AurumIcons catalog (89 icons × line/filled) —

template-rendered asset-catalog SVGs with tint resolution explicit →

ambient \.aurumContentColor (the LocalContentColor port) →

iconDefaultNormal; gradient tint overload.

  • Icon importer (tooling/icon-import/import_icons.py): converts

aurum-android's committed, already-normalized Vector Drawables to

imagesets + the Swift catalog, so both platforms share one normalization

pipeline (make icons-import).

  • AurumButton — variants primary/secondary/tertiary × sizes 40/48/56 pt,

full-width, loading, auto-advance progress, leading/trailing slots;

radial primary fill, top-lit rim, and the dimensional purple/800

hard-shadow press (drop + 2 pt sink) via a private ButtonStyle.

  • AurumLoader — track + 90° arc spinner with optional right/bottom label.
  • AurumDivider, AurumSkeleton (t=0-deterministic shimmer).
  • Tests: icon-catalog contract suite, button-defaults unit suite, and 13

component snapshot tiles mirroring the Android @AurumPreview groups.

  • Foundations — the initial package skeleton per the architecture research

(docs/ios-design-system-research.md):

  • Source SPM package with two products: AurumTokens (extension-safe token

layer) and Aurum (components + paint toolkit, re-exports the tokens).

iOS 17 floor.

  • Token codegen (tooling/token-codegen/generate.py): committed Figma

W3C JSON exports → generated Swift token layer (Sources/AurumTokens/Token/),

with a --check determinism gate for CI. Name mapping is a faithful port

of the Token Sync plugin's mapping.ts. 156 palette primitives, 295

semantic + visual colors, 45 typography composites, 4 elevation recipes,

spacing/radius/borderWidth/iconSize scales.

  • Theme layer: static Aurum.* namespace (colors, type, space,

radius, borderWidth, shape, elevation, iconSize, motion,

opacity), theme-shaped structs, AurumRoot / .aurumTheme().

  • Typography: bundled static Inter + Frank Ruhl Libre TTFs registered at

runtime (Aurum.registerFonts(), idempotent); every style carries a

Dynamic Type anchor (relativeTo); .aurumType(_:) reproduces Figma's

exact line height and scales it along the anchor curve.

  • Paint toolkit: AurumLinearGradient (CSS-angle, size-aware),

AurumRadialGradient (circular + rotated-elliptical via Core Graphics),

.aurumShadow() (offset/blur/spread/tint, Figma-blur÷2 conversion,

interior knockout, optional alpha mask), .aurumHardShadow(),

.aurumInnerShadow(), Aurum.shape.smooth() continuous corners.

  • Tests: token integrity + paint math unit suites; snapshot harness on

swift-snapshot-testing with Git LFS baselines (pinned: iPhone 17 Pro,

iOS 26.5) covering gradients, shadows, squircle audit, and the full type

ramp.

  • CI: check.yml (codegen gate + build + test) and record.yml

(label-triggered baseline re-record).