@augeo/smelt 1.2.2

package/.claude/settings.json

@@ -0,0 +1,11 @@
+{
+	"permissions": {
+		"allow": [
+			"Bash(npm test)",
+			"Bash(npm test *)",
+			"Bash(npm run test:all)",
+			"Bash(npm run verify)",
+			"Bash(npm run build)"
+		]
+	}
+}

package/.github/workflows/verify.yml

@@ -0,0 +1,64 @@
+name: Verify
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+jobs:
+  verify:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v5
+        with:
+          submodules: true
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version-file: "package.json"
+          cache: "npm"
+          cache-dependency-path: |
+            package-lock.json
+            example/package-lock.json
+
+      - name: Install root dependencies
+        run: npm ci
+
+      - name: Install example dependencies
+        working-directory: example
+        run: npm ci
+
+      - name: Restore prettier cache
+        uses: actions/cache@v4
+        with:
+          path: node_modules/.cache/prettier
+          key:
+            prettier-${{ hashFiles('package-lock.json', '.prettierrc.cjs',
+            '.prettierignore') }}
+          restore-keys: prettier-
+
+      - name: Run lint
+        run: npm run lint
+
+      - name: Run typecheck
+        run: npm run typecheck
+
+      - name: Install Playwright browser (chromium)
+        run: npx playwright install --with-deps chromium
+
+      - name: Run tests (integration via example)
+        run: npm run test:all
+
+      - name: Check built files match source
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            echo "::error::Build produced uncommitted changes — did you forget to commit a rebuild?"
+            git status --porcelain
+            echo "---"
+            git diff
+            exit 1
+          fi

package/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/theme-liquid-docs"]
+	path = vendor/theme-liquid-docs
+	url = https://github.com/Shopify/theme-liquid-docs.git

package/.prettierignore

@@ -0,0 +1,25 @@
+# Prettier handles only .md and .liquid. Biome owns everything else.
+# Ignore everything by default, then re-allow what Prettier should format.
+*
+
+!*.md
+!**/*.md
+
+!*.liquid
+!**/*.liquid
+
+# Needed for the negations above to traverse into directories.
+!*/
+
+# Compiler output — managed by the Smelt build script.
+example/sections/built--*.liquid
+example/snippets/built--*.liquid
+example/blocks/built--*.liquid
+example/blocks/_built--*.liquid
+
+# Generated / vendored
+node_modules
+dist
+vendor
+lib/*.generated.ts
+.shopify

package/.prettierrc.cjs

@@ -0,0 +1,9 @@
+/** @type {import("prettier").Config} */
+const config = {
+	useTabs: true,
+	proseWrap: "always",
+	printWidth: 80,
+	plugins: ["@shopify/prettier-plugin-liquid"],
+};
+
+module.exports = config;

package/.zed/settings.json

@@ -0,0 +1,21 @@
+// Folder-specific settings
+//
+// For a full list of overridable settings, and general information on folder-specific settings,
+// see the documentation: https://zed.dev/docs/configuring-zed#settings-files
+{
+	"code_actions_on_format": {
+		"source.fixAll.biome": true,
+		"source.fixAll.prettier": true
+	},
+	"languages": {
+		"JavaScript": { "formatter": { "language_server": { "name": "biome" } } },
+		"TypeScript": { "formatter": { "language_server": { "name": "biome" } } },
+		"TSX": { "formatter": { "language_server": { "name": "biome" } } },
+		"JSON": { "formatter": { "language_server": { "name": "biome" } } },
+		"JSONC": { "formatter": { "language_server": { "name": "biome" } } },
+		"CSS": { "formatter": { "language_server": { "name": "biome" } } },
+		"GraphQL": { "formatter": { "language_server": { "name": "biome" } } },
+		"Liquid": { "formatter": "prettier" },
+		"Markdown": { "formatter": "prettier" }
+	}
+}

package/AGENTS.md

@@ -0,0 +1,232 @@
+# AGENTS.md
+
+This file provides guidance to AI agents working with code in this repository.
+
+## Project Overview
+
+Smelt is being turned inside-out from "a Shopify theme with a custom build
+script" into **a library + CLI** (`@augeo/smelt`) that other Shopify themes
+install and consume. Consumer themes write colocated components (Liquid + TS +
+CSS + tests in one directory); the Smelt engine compiles them into the flat,
+namespaced files Shopify expects. The build is **additive** — it only writes
+files prefixed `built--` and never touches hand-written output files.
+
+The repo currently has two halves:
+
+- **Root** — the library under construction. Each CLI command is a
+  `lib/<command>/` directory; today only `lib/build/` exists. `lib/cli.ts` wires
+  its `defineCommand` exports into the citty entry, and tsdown bundles the CLI
+  to `dist/cli.mjs` (the published `smelt` bin). `src/` is the **baseline
+  layer** — components shipped with the package; structurally identical to a
+  consumer's `src/`. `lib/resolver.ts` walks the ordered layer list and produces
+  a merged component map (per-file shadowing, first wins).
+- **`example/`** — a working consumer theme that consumes the package via
+  `"@augeo/smelt": "file:.."` and exercises the engine end-to-end. This is the
+  integration test bed (same pattern as
+  [`@augeo/assay`](https://github.com/seanhealy/assay)'s `example/`).
+
+See [`docs/build-spec.md`](./docs/build-spec.md) for the build pipeline spec and
+[`docs/library-conversion-plan.md`](./docs/library-conversion-plan.md) for the
+phased plan to publish it as `@augeo/smelt`.
+
+## Tech Stack
+
+- **Theme:** [Shopify Liquid](https://shopify.dev/docs/api/liquid)
+- **Language:** TypeScript
+- **Build:** Custom compiler at `lib/build/build.ts`, wrapped as a citty command
+  in `lib/build/command.ts`, and wired into `lib/cli.ts` (bundled by
+  [tsdown](https://tsdown.dev/) to `dist/cli.mjs`). See `docs/build-spec.md`.
+- **Test runner:** [Vitest](https://vitest.dev/) (Browser Mode) via
+  [`@augeo/assay`](https://www.npmjs.com/package/@augeo/assay)
+- **Linter / Formatter (JS/TS/CSS/JSON):** [Biome](https://biomejs.dev/)
+- **Formatter (Markdown / Liquid):** [Prettier](https://prettier.io/) with
+  `@shopify/prettier-plugin-liquid`
+- **Theme linter:**
+  [Shopify theme check](https://shopify.dev/docs/storefronts/themes/tools/theme-check)
+
+## Project Structure
+
+```
+lib/
+├── cli.ts                            # citty entry — wires up subCommands
+├── schema.ts                         # defineSchemaSection + defineSchemaBlock (./schema export)
+├── schema-section.generated.ts       # codegen'd from vendor/theme-liquid-docs/section.json
+├── schema-block.generated.ts         # codegen'd from vendor/theme-liquid-docs/theme_block.json
+├── resolver.ts                       # walks N layers → merged ResolvedComponent map
+├── resolver.test.ts                  # colocated unit tests
+└── build/
+    ├── index.ts                      # barrel: re-exports `build` (the command)
+    ├── command.ts                    # defineCommand wrapper + layer wiring
+    ├── build.ts                      # the build engine (consumes ResolvedComponent[])
+    └── build.test.ts                 # colocated unit tests
+scripts/
+└── codegen-schema.ts                 # generates lib/schema-*.generated.ts
+vendor/
+└── theme-liquid-docs/                # git submodule — Shopify's JSON Schemas
+src/                         # baseline layer — same shape as a consumer's src/
+├── tsconfig.json            # DOM lib + @/* paths for the baseline tree
+├── sections/
+├── blocks/
+├── components/              # e.g. button/ (button.liquid, .ts, .css)
+└── utilities/
+dist/                        # gitignored — tsdown output (dist/cli.mjs bin)
+docs/                        # specs and contributor docs
+vitest.config.ts             # picks up lib/**, src/**, tests/** *.test.ts
+
+example/                     # consumer theme — integration test bed
+├── package.json             # theme scripts (dev, push, theme:check, …)
+├── vitest.config.ts
+├── .theme-check.yml
+├── .shopifyignore
+├── .gitattributes
+├── src/                     # consumer's layer — shadows baseline file-by-file
+│   ├── sections/            # → example/sections/built--*.liquid
+│   ├── blocks/              # → example/blocks/built--*.liquid
+│   ├── components/          # → example/snippets/built--*.liquid
+│   └── utilities/           # TS/CSS-only; bundled into importers
+├── sections/                # Shopify-flat output dirs
+├── snippets/                #   (mixed hand-written + built--*.liquid)
+├── blocks/
+├── layout/
+├── templates/
+├── config/
+├── locales/
+└── assets/
+```
+
+Component conventions, naming rules, and the `{% render '@/...' %}` alias are
+all defined in [`docs/build-spec.md`](./docs/build-spec.md). Read it before
+making changes that affect the build.
+
+## Commands
+
+Run from the **repo root**:
+
+| Command                  | Description                                                                                      |
+| ------------------------ | ------------------------------------------------------------------------------------------------ |
+| `npm run build`          | tsdown bundles `lib/cli.ts` → `dist/cli.mjs` (the `smelt` bin); `prebuild` runs `schema:codegen` |
+| `npm run build:watch`    | tsdown watch mode (rebuilds the bin on `lib/` edits)                                             |
+| `npm run schema:codegen` | Regenerates `lib/schema-*.generated.ts` from `vendor/theme-liquid-docs`                          |
+| `npm run docs:update`    | `git submodule update --remote vendor/theme-liquid-docs` — pulls the latest Shopify schemas      |
+| `npm run lint`           | Biome + Prettier check across the whole tree                                                     |
+| `npm run verify`         | `lint:fix → typecheck` — fast code-quality gate                                                  |
+| `npm test`               | `build → vitest` — root unit tests (lib + tests/)                                                |
+| `npm run test:all`       | `npm test` + `npm test --prefix example` — full integration check                                |
+
+Run from **`example/`** (theme-bound commands; they need cwd=`example/`). These
+mirror what a real consumer's `package.json` would look like — no references
+back to the library.
+
+| Command               | Description                                             |
+| --------------------- | ------------------------------------------------------- |
+| `npm run dev`         | `shopify theme dev`                                     |
+| `npm run theme:check` | Shopify theme linter                                    |
+| `npm run build`       | `smelt build`                                           |
+| `npm test`            | `typecheck → build → vitest → theme:check` — full check |
+
+`npm run build` at root is what keeps `dist/cli.mjs` fresh — `npm test` calls it
+first, and `prepare` runs it on `npm install`. If you're working purely in
+`example/`, the bin is whatever `build` last produced.
+
+Two canonical gates at root: `npm run verify` for the fast quality loop
+(lint/typecheck), `npm run test:all` for the full integration check (root
+vitest + `example/`'s typecheck/build/vitest/theme-check). CI runs both.
+
+## Formatting
+
+- **Biome** owns JS / TS / CSS / JSON formatting and linting.
+- **Prettier** owns Markdown and Liquid formatting (with
+  `@shopify/prettier-plugin-liquid`).
+- The two never overlap — see `.prettierignore` for the boundary.
+- Tabs for indentation, 80-char line width, double quotes.
+- Imports are auto-organized by Biome.
+- Compiler output (`built--*.liquid`) is ignored by Prettier so it isn't
+  reformatted between builds.
+
+## Coding Conventions
+
+- Use **full words** for variable names, not abbreviations (e.g., `action` not
+  `fn`, `context` not `ctx`).
+- Prefer **named exports** over default exports (config files that require
+  default exports are an exception).
+- Use **`function` declarations** for named/top-level functions; arrow functions
+  are fine for anonymous callbacks.
+- Use **`undefined`**, not `null`, for absent values.
+- **Function ordering:** most important first, helpers last. Exported / primary
+  functions at the top of the file, internal helpers below.
+- **Object / interface properties:** order by importance, not alphabetically.
+  Group related properties. Identifying fields first, core fields next, optional
+  / metadata fields last.
+- **Iteration:** prefer enumerables (`forEach`, `map`, `reduce`, `filter`,
+  `find`) over `for` loops.
+- **Directory modules:** when a module grows into a directory, use `index.ts` as
+  a barrel export only — implementation lives in a named file.
+- **Keep it simple.** Don't over-engineer. The only certainty is that we'll need
+  to change what we write — favor code that's easy to mutate.
+
+### Liquid
+
+- Use `{% liquid %}` blocks for multi-statement logic, not repetitive
+  `{%- ... -%}` tags.
+- Multi-line class attributes: static classes first, then conditionals with
+  spaces around them:
+  ```liquid
+  <div
+  	class="
+  		component
+  		component--modifier
+  		{% if condition %} conditional-class {% endif %}
+  	"
+  >
+  ```
+- Document component props with TypeScript-style interfaces in `{% comment %}`
+  blocks. See `docs/build-spec.md` for examples.
+
+### TypeScript
+
+- Import alias `@/*` → the consumer's `src/*` (defined in the consumer's own
+  `tsconfig.json`; for this repo, see `example/tsconfig.json`). Matches the
+  Liquid `@/...` render alias.
+- **No cross-component TS imports.** Each component is its own bundle. Sharing
+  happens through `src/utilities/`. See `docs/build-spec.md` for the rationale.
+
+## Working with the Operator
+
+- **File references in conversation text** use project-relative paths (e.g.,
+  `lib/build/build.ts:14`), not absolute paths. The project root is the implicit
+  base.
+- **Slow down before writing.** Read each task fully and think through naming,
+  file placement, and structure before writing code — don't rush to a working
+  result and clean up later.
+- **Keep tests in sync.** When modifying a module that has a `.test.ts` file,
+  update the tests in the same pass. Don't leave them stale.
+- **Prefer the Grep tool over CLI `grep`** when searching file contents — it
+  handles permissions cleanly. Use CLI `grep` only when piping into another
+  shell command that the Grep tool can't express.
+
+## Working Style
+
+- **Ask before assuming.** Stop and ask for clarification when requirements are
+  unclear.
+- **One problem at a time** for complex multi-file changes. Fix one and verify
+  before continuing.
+- **Investigate before modifying components.** Search the codebase for renders
+  of the component (`render '@/components/<name>'` in source,
+  `render 'built--…--<name>'` in built output) and check `templates/*.json` for
+  active usage before changing shared components.
+
+## Testing
+
+See [`docs/TESTING.md`](./docs/TESTING.md) for test-writing conventions.
+
+Tests run against the **built** Liquid output (in
+`example/{sections,snippets, blocks}/`) rather than against `src/` directly,
+because the testing harness (LiquidJS via `@augeo/assay`) cannot resolve the
+`@/...` source alias. From `example/`, `npm test` builds first, then runs
+Vitest.
+
+## Before Submitting Changes
+
+Run `npm run verify && npm run test:all` — verify auto-fixes lint and
+type-checks; test:all runs the full integration chain (root vitest, then
+`example/`'s typecheck → build → vitest → theme:check).

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Augeō
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,266 @@
+# Smelt
+
+[![Verify](https://github.com/AugeoCorp/smelt/actions/workflows/verify.yml/badge.svg)](https://github.com/AugeoCorp/smelt/actions/workflows/verify.yml)
+
+Build Shopify themes from colocated components. Author your `button/` directory
+once — `button.liquid`, `button.ts`, `button.css`, `button.test.ts`,
+`button.schema.ts` — and Smelt compiles it into the flat, namespaced files
+Shopify expects.
+
+## Why
+
+- **Colocation.** Every component lives in one directory. Liquid markup,
+  TypeScript behavior, CSS, tests, and schema are authored side-by-side instead
+  of scattered across `sections/`, `snippets/`, and `assets/`.
+- **Layering.** Smelt ships with a baseline component library; your theme
+  shadows any file. Drop in a `button.css` to restyle without touching markup,
+  TS, or schema. Same pattern as Nuxt Layers or Gatsby shadowing.
+- **Typed schemas.** Author `{% schema %}` blocks in TypeScript with
+  autocomplete derived from Shopify's authoritative JSON Schemas. The build
+  executes the file and injects the result.
+- **Private blocks for free.** Nest a `blocks/` directory under a section or
+  block and its children become private theme blocks — emitted with Shopify's
+  `_` prefix and auto-merged into the parent's schema. No manual filename
+  mangling.
+- **Additive build.** Only files prefixed `built--` (or `_built--` for private
+  blocks) are written or cleaned. Hand-written theme files are preserved, so you
+  can adopt incrementally.
+
+---
+
+## Contents
+
+- [Example](#example)
+- [Install](#install)
+- [Authoring](#authoring)
+- [Schemas](#schemas)
+- [Private blocks](#private-blocks)
+- [Layering](#layering)
+- [Build](#build)
+- [Learn More](#learn-more)
+- [Future Plans](#future-plans)
+
+---
+
+## Example
+
+A consumer theme writes one directory per component:
+
+```
+src/
+├── sections/
+│   └── hero/
+│       ├── hero.liquid
+│       ├── hero.css
+│       └── hero.schema.ts
+└── components/
+    └── card/
+        ├── card.liquid
+        └── card.css
+```
+
+`src/sections/hero/hero.liquid`:
+
+```liquid
+<section class="tr-hero">
+	<h2>{{ section.settings.heading }}</h2>
+	{% render '@/components/card', title: 'Hello', body: 'World' %}
+</section>
+```
+
+`src/sections/hero/hero.schema.ts`:
+
+```typescript
+import { defineSchemaSection } from "@augeo/smelt/schema";
+
+export const schema = defineSchemaSection({
+	name: "Hero",
+	settings: [
+		{ type: "text", id: "heading", label: "Heading", default: "Welcome" },
+	],
+	presets: [{ name: "Hero" }],
+});
+```
+
+Compile:
+
+```bash
+smelt build
+```
+
+Outputs `sections/built--sections--hero.liquid`,
+`snippets/built--components--card.liquid`, etc. — flat and namespaced, the way
+Shopify wants.
+
+See the [📄 `example/`](./example) directory for a working consumer theme.
+
+## Install
+
+```bash
+npm install -D @augeo/smelt
+```
+
+This installs the `smelt` CLI and the `@augeo/smelt/schema` import for schema
+authoring.
+
+## Authoring
+
+Each component is a directory under `src/<type>/<name>/` where `<type>` is
+`sections`, `blocks`, or `components`. Files inside share the directory name:
+
+| File               | Role                                         |
+| ------------------ | -------------------------------------------- |
+| `<name>.liquid`    | Markup (required — anchors the component)    |
+| `<name>.ts`        | Bundled and injected into `{% javascript %}` |
+| `<name>.css`       | Injected into `{% stylesheet %}`             |
+| `<name>.schema.ts` | Typed schema (sections + blocks only)        |
+| `<name>.test.ts`   | Colocated test file, picked up by vitest     |
+
+Components reference other components with the `@/` alias:
+
+```liquid
+{% render '@/components/button', label: 'Continue' %}
+```
+
+`@/` resolves through the merged layer tree, so a consumer's `button.liquid`
+automatically shadows the baseline.
+
+## Schemas
+
+Author schemas in TypeScript with full type inference:
+
+```typescript
+import { defineSchemaSection } from "@augeo/smelt/schema";
+
+export const schema = defineSchemaSection({
+	name: "Hero",
+	settings: [
+		{ type: "text", id: "heading", label: "Heading" },
+		{
+			type: "select",
+			id: "alignment",
+			label: "Alignment",
+			options: [
+				{ value: "left", label: "Left" },
+				{ value: "center", label: "Center" },
+			],
+			default: "center",
+		},
+	],
+});
+```
+
+Types are codegen'd from Shopify's authoritative schemas in
+[`theme-liquid-docs`](https://github.com/Shopify/theme-liquid-docs). Update via
+`npm run docs:update`.
+
+Inline `{% schema %}` blocks in `.liquid` files are a build error — single
+source of truth.
+
+## Private blocks
+
+Shopify treats theme block files prefixed with `_` as **private** — hidden from
+the merchant's block picker, renderable only via a parent's
+`{% content_for "blocks" %}`. Smelt expresses this structurally: a `blocks/`
+directory nested under a section or block emits its children with the `_` prefix
+automatically.
+
+```
+src/sections/hero/
+├── hero.liquid
+├── hero.schema.ts
+└── blocks/
+    └── feature/
+        ├── feature.liquid
+        └── feature.schema.ts
+```
+
+Compiles to:
+
+```
+sections/built--sections--hero.liquid
+blocks/_built--sections--hero--blocks--feature.liquid
+```
+
+The parent's schema auto-merges discovered children into its `blocks: []` array
+— sorted by directory name and prepended; any explicit entries you list (e.g.
+globally-shared block types) appended after. Nesting is recursive: a private
+block can have its own `blocks/` subdir.
+
+Top-level `src/blocks/*` files remain public (no `_` prefix).
+
+## Layering
+
+Smelt walks an ordered list of layers and merges them per-file. The default is:
+
+1. **Consumer** — your theme's `src/` (`process.cwd()`).
+2. **`@augeo/smelt`** — the package's baseline `src/`.
+
+For each component slot (`liquid`, `ts`, `css`, `schema`), the first layer that
+has the file wins. Drop just a `button.css` in your consumer to override styles;
+the baseline's `button.liquid` and `button.ts` are inherited.
+
+## Build
+
+```bash
+smelt build
+```
+
+Run from the theme root. Outputs go to `sections/built--*.liquid`,
+`blocks/built--*.liquid`, and `snippets/built--*.liquid` — prefixed so they
+coexist with hand-written files in the same directories.
+
+### Watch mode
+
+```bash
+smelt dev
+```
+
+Runs an initial build, then watches each layer's `src/` and rebuilds on file
+changes (add, edit, delete). Build failures log and keep the watcher alive. Pair
+with `shopify theme dev` (in another terminal or via
+[`concurrently`](https://www.npmjs.com/package/concurrently)) — `smelt dev`
+writes the built files; `shopify theme dev` uploads them.
+
+### Committing the output
+
+Shopify imports themes from git, so `built--*` files (and `_built--*` for
+private blocks) need to be **committed** alongside source. Two configs keep the
+noise down:
+
+`.gitattributes` — marks output as generated so GitHub collapses it in PR diffs
+and excludes it from language stats:
+
+```
+sections/built--*.liquid linguist-generated=true
+snippets/built--*.liquid linguist-generated=true
+blocks/built--*.liquid linguist-generated=true
+blocks/_built--*.liquid linguist-generated=true
+```
+
+`.prettierignore` — skips the output so Prettier doesn't reformat it between
+builds:
+
+```
+sections/built--*.liquid
+snippets/built--*.liquid
+blocks/built--*.liquid
+blocks/_built--*.liquid
+```
+
+## Learn More
+
+- [📄 Build Spec](./docs/build-spec.md) — pipeline, alias rules, conventions
+- [📄 Testing Conventions](./docs/TESTING.md) — how to write tests against the
+  built output
+- [📄 Library Conversion Plan](./docs/library-conversion-plan.md) — phased plan
+  for publishing
+- [`@augeo/assay`](https://www.npmjs.com/package/@augeo/assay) — the test runner
+  Smelt uses
+
+## Future Plans
+
+- **`smelt.config.ts`** — consumer-defined layer list, enabling N-layer
+  composition (e.g., a community component pack between consumer and baseline).
+- **More baseline components** — currently just `button` demo. Expanding to a
+  real default set.