create-obsidian-arrow 0.1.0

package/README.md

@@ -0,0 +1,47 @@
+# create-obsidian-arrow
+
+Scaffold a new [Obsidian](https://obsidian.md/)-styled [Arrow.js](https://arrow-js.com/)
+UI sandbox — a client-only Vite + TypeScript project that renders Arrow
+components against Obsidian's real `app.css`, ready to port into a plugin.
+
+## Usage
+
+```sh
+npm create obsidian-arrow@latest my-app
+# or: pnpm create obsidian-arrow my-app
+# or: npx create-obsidian-arrow my-app
+```
+
+Then:
+
+```sh
+cd my-app
+pnpm install
+pnpm pull-css   # required — extract Obsidian's app.css from your local install (macOS auto-detect)
+pnpm dev
+```
+
+> `public/app.css` is git-ignored and never bundled — it's Obsidian's proprietary
+> CSS, so each developer extracts it from their own install via `pnpm pull-css`.
+
+Local dev of the initializer itself (from the sandbox repo, before publishing):
+
+```sh
+node create-obsidian-arrow/index.mjs ../my-app
+```
+
+## What you get
+
+A full sandbox: client-only Vite + TS, `@arrow-js/core` + `@arrow-js/framework`
+(no SSR), `routeToPage` + Navigation-API router with an `/example` demo, Biome +
+husky pre-commit + `node:test` + GitHub Actions CI, bundled agent skills, and the
+`pull-css` script that extracts Obsidian's `app.css`.
+
+## Maintaining the template
+
+`template/` is **generated** from the sandbox repo so it never drifts. After
+changing the sandbox, regenerate it from the repo root:
+
+```sh
+pnpm create:sync
+```

package/index.mjs

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * create-obsidian-arrow — scaffold a new Obsidian-styled Arrow.js UI sandbox.
+ *
+ *   pnpm create obsidian-arrow my-app      # once published
+ *   node create-obsidian-arrow/index.mjs my-app   # locally, before publishing
+ *
+ * Copies the vendored template/ into <dir>, restores .gitignore (npm strips it
+ * from packages, so it's vendored as _gitignore), rewrites the project name,
+ * and runs `git init`. The template is a full, verified sandbox — see template/.
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+const templateDir = path.join(here, "template");
+
+function fail(message) {
+	console.error(`create-obsidian-arrow: ${message}`);
+	process.exit(1);
+}
+
+const targetArg = process.argv[2];
+if (!targetArg) {
+	fail("usage: create-obsidian-arrow <directory>");
+}
+
+const destRoot = path.resolve(process.cwd(), targetArg);
+const appName = path.basename(destRoot);
+
+if (fs.existsSync(destRoot) && fs.readdirSync(destRoot).length > 0) {
+	fail(`target "${targetArg}" already exists and is not empty.`);
+}
+if (!fs.existsSync(templateDir)) {
+	fail("template/ is missing — run scripts/sync-template.mjs to build it.");
+}
+
+function copyDir(src, dest) {
+	fs.mkdirSync(dest, { recursive: true });
+	for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+		const srcPath = path.join(src, entry.name);
+		// Vendored as _gitignore because npm omits .gitignore from published tarballs.
+		const destName = entry.name === "_gitignore" ? ".gitignore" : entry.name;
+		const destPath = path.join(dest, destName);
+		if (entry.isDirectory()) {
+			copyDir(srcPath, destPath);
+		} else {
+			fs.copyFileSync(srcPath, destPath);
+		}
+	}
+}
+
+copyDir(templateDir, destRoot);
+
+// Personalize the project name. Use a targeted replace (not JSON.parse +
+// stringify) so the template's existing Biome formatting stays byte-identical
+// and the fresh project passes `pnpm lint` out of the box.
+const pkgPath = path.join(destRoot, "package.json");
+const pkgText = fs.readFileSync(pkgPath, "utf8");
+const renamed = pkgText.replace(
+	/("name":\s*)"[^"]*"/,
+	(_match, prefix) => `${prefix}${JSON.stringify(appName)}`
+);
+fs.writeFileSync(pkgPath, renamed);
+
+// Initialize a git repo (best-effort; ignore if git is unavailable).
+spawnSync("git", ["init", "-q"], { cwd: destRoot, stdio: "ignore" });
+
+console.log(`\nScaffolded ${appName} in ${path.relative(process.cwd(), destRoot) || "."}\n`);
+console.log("Next steps:");
+console.log(`  cd ${targetArg}`);
+console.log("  pnpm install");
+console.log("  pnpm pull-css     # extract Obsidian's app.css (macOS auto-detect)");
+console.log("  pnpm dev\n");

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "create-obsidian-arrow",
+  "version": "0.1.0",
+  "description": "Scaffold an Obsidian-styled Arrow.js UI sandbox (pnpm create obsidian-arrow <dir>).",
+  "type": "module",
+  "bin": {
+    "create-obsidian-arrow": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "template"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "obsidian",
+    "obsidian-plugin",
+    "arrow-js",
+    "arrowjs",
+    "create",
+    "scaffold",
+    "template",
+    "ui",
+    "prototyping"
+  ],
+  "author": "Kyle Brodeur",
+  "license": "MIT",
+  "homepage": "https://github.com/kylebrodeur/obsidian-arrow-sandbox#readme",
+  "bugs": "https://github.com/kylebrodeur/obsidian-arrow-sandbox/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kylebrodeur/obsidian-arrow-sandbox.git",
+    "directory": "create-obsidian-arrow"
+  },
+  "scripts": {}
+}

package/template/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v4
+        with:
+          version: 10.14.0
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: pnpm
+
+      - name: Install
+        run: pnpm install --frozen-lockfile
+
+      - name: Lint + format check (Biome)
+        run: pnpm biome ci .
+
+      - name: Typecheck
+        run: pnpm typecheck
+
+      - name: Test
+        run: pnpm test
+
+      - name: Build
+        run: pnpm build

package/template/.husky/pre-commit

@@ -0,0 +1,2 @@
+pnpm exec lint-staged
+pnpm typecheck

package/template/AGENTS.md

@@ -0,0 +1,90 @@
+# AGENTS.md
+
+Operating guide for AI agents working in **obsidian-arrow-sandbox** — a
+client-only environment for prototyping [Arrow.js](https://arrow-js.com/) UI that
+ports into an Obsidian plugin with near-zero refactoring.
+
+Full design + rationale: [`docs/superpowers/specs`](docs/superpowers/specs/2026-06-29-obsidian-arrow-sandbox-design.md).
+Deeper how-to skills: [`skills/`](skills/) (install via `npx skills`).
+
+## What this is (and isn't)
+
+- **Is:** a Vite + TypeScript sandbox. Components use `@arrow-js/core`
+  (`reactive`, `html`, `component`, `watch`) + `@arrow-js/framework` (`boundary`),
+  mounted with `template(container)` — the exact call an Obsidian
+  `ItemView.onOpen()` makes. Styling comes entirely from Obsidian's real
+  `app.css`, loaded under Obsidian body classes.
+- **Isn't:** an SSR app. There is **no server and no hydration** — an Obsidian
+  plugin renders only in the Electron renderer, so `@arrow-js/ssr` and
+  `@arrow-js/hydrate` are intentionally absent. Do not add them.
+
+## Run it
+
+```sh
+pnpm install
+pnpm pull-css     # macOS-only auto-detect; else --path <asar|css> / OBSIDIAN_ASAR=<path>
+pnpm dev          # Vite + HMR
+```
+
+`public/app.css` is **git-ignored** (Obsidian's proprietary CSS — not
+redistributed); run `pnpm pull-css` once before `pnpm dev`.
+
+## Arrow v1.0.6 footguns — READ BEFORE WRITING TEMPLATES
+
+These are hard runtime errors, not style nits. They are encoded in CI
+(`test/template-footguns.test.mjs`) where possible.
+
+1. **No literal HTML comments inside `html\`\`` templates.** Arrow uses HTML
+   comments as expression-slot markers; a literal `<!-- … -->` makes the slot
+   count mismatch and throws `Invalid HTML position`. Use JS `//` comments
+   *outside* the template literal.
+2. **An attribute expression must be the *entire* value.** Good:
+   `class="${() => '…'}"`. Broken: `class="static ${() => '…'}"` (partial values
+   aren't registered as placeholders → throws). Build the full string in one
+   expression.
+3. **Reactive vs static.** `${data.x}` renders once at mount; `${() => data.x}`
+   is tracked and updates only that slot. Forgetting the `() =>` is the #1
+   "why isn't it updating" bug. Returning `false` from an attribute expression
+   **removes** the attribute (vs `""` which keeps it empty).
+4. **`@event` handlers must type the param `Event`, not a narrowed subtype.**
+   `(e: MouseEvent) => …` fails to assign to Arrow's handler type (parameter
+   contravariance) → `TS2345`. Use `(e: Event) => …` and narrow inside; no-arg
+   handlers are fine. (Caught by `tsc`; footguns 1–2 are caught by
+   `test/template-footguns.test.mjs`, which also flags this for inline handlers.)
+
+Other conventions: property binding via `.prop` (`.checked="${() => …}"`),
+events via `@event` (`@click="${fn}"`), keyed lists via
+`html\`…\`.key(id)`, async sections via `component(asyncFn, { fallback })` wrapped
+in `boundary()`.
+
+## CSS scoping
+
+- Use Obsidian's own classes (`.setting-item`, `.clickable-icon`,
+  `.workspace-leaf`, `.vertical-tab-*`) and `var(--…)` tokens **first**. Add
+  custom CSS only where Obsidian has no class.
+- Scope any custom rule under a container class + element type (e.g.
+  `.oas-frame button.oas-theme-toggle`) so it beats Obsidian's global
+  `button:not(.clickable-icon)` rule and never leaks. Sandbox-only chrome lives
+  in `src/sandbox/sandbox.css`; component styling stays on Obsidian classes.
+
+## Verify before claiming done
+
+```sh
+pnpm typecheck    # tsc --noEmit
+pnpm test         # node:test
+pnpm lint         # biome
+pnpm check        # all of the above (format + typecheck + test)
+```
+
+Then confirm the actual render in the browser at the `pnpm dev` URL — check the
+console is clean and the component looks like a real Obsidian pane. Do not claim
+a component works on typecheck alone; Arrow's footguns only surface at render.
+
+## Porting a component into the plugin
+
+Components are framework-light and use only Obsidian classes/tokens, so porting
+is mechanical: copy the component file into the plugin's view directory and
+mount it from `ItemView.onOpen()` via `template(this.contentEl)`. If it uses
+`boundary()`/async components, add `@arrow-js/framework` to the plugin and the
+`import '@arrow-js/framework'` side-effect import. Strip any sandbox chrome
+(`src/sandbox/*`) — that stays here.

package/template/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kyle Brodeur
+
+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/template/README.md

@@ -0,0 +1,116 @@
+# Obsidian Arrow Sandbox
+
+A client-only prototyping environment for building [Arrow.js](https://arrow-js.com/)
+UI that drops into an Obsidian plugin with near-zero refactoring. Components are
+written with `@arrow-js/core` (+ `@arrow-js/framework` for async boundaries) and
+styled entirely by Obsidian's real `app.css`, so what you see here is what you
+get inside a plugin view.
+
+See the design + decision record in
+[`docs/superpowers/specs`](docs/superpowers/specs/2026-06-29-obsidian-arrow-sandbox-design.md).
+
+## Scaffold a new project
+
+Scaffold a fresh sandbox with the published initializer
+([`create-obsidian-arrow`](create-obsidian-arrow/)):
+
+```sh
+npm create obsidian-arrow@latest my-app
+# or:  pnpm create obsidian-arrow my-app
+# or:  npx create-obsidian-arrow my-app
+```
+
+Then `cd my-app && pnpm install && pnpm pull-css && pnpm dev`. A freshly
+scaffolded project passes `pnpm run ci` out of the box. The initializer's
+template is generated from this repo (`pnpm create:sync`), so it never drifts.
+
+> This repo (the full sandbox) is **not** published to npm — only the
+> `create-obsidian-arrow/` initializer is. An agent-onboarding prompt lives in
+> [`docs/prompts/agent-setup.md`](docs/prompts/agent-setup.md).
+
+## Quick start
+
+```sh
+pnpm install
+pnpm pull-css     # extract Obsidian's app.css from your local install (required)
+pnpm dev          # Vite dev server with HMR
+```
+
+`pull-css` reads `app.css` out of `Obsidian.app/.../obsidian.asar` (macOS) and
+writes `public/app.css`. Override the location with `--path <obsidian.asar|app.css>`
+or `OBSIDIAN_ASAR=<path>`. **Run it once before `pnpm dev`** — it needs a local
+Obsidian install.
+
+> **Why it isn't committed:** `public/app.css` is **git-ignored**. It's
+> Obsidian's proprietary stylesheet, so we don't redistribute it — each developer
+> extracts it from their own licensed Obsidian install via `pnpm pull-css`.
+
+> **Platform note:** automatic Obsidian discovery is currently **macOS-only** —
+> `pull-css` knows where `Obsidian.app` lives on macOS. Windows and WSL paths are
+> not auto-detected yet (planned). On those platforms, point the script at the
+> file explicitly via `--path <obsidian.asar|app.css>` or `OBSIDIAN_ASAR=<path>`.
+
+## Scripts
+
+| Script | What it does |
+|---|---|
+| `pnpm dev` | Vite dev server (client-only, HMR) |
+| `pnpm build` / `pnpm preview` | Production build / preview |
+| `pnpm typecheck` | `tsc --noEmit` |
+| `pnpm test` | Node built-in test runner (`test/*.test.mjs`) |
+| `pnpm lint` / `pnpm format` | Biome check / check-and-write |
+| `pnpm check` | format + typecheck + test (local pre-flight) |
+| `pnpm ci` | Biome CI + typecheck + test + build (what CI runs) |
+| `pnpm pull-css` | refresh `public/app.css` from the local Obsidian install |
+
+A husky `pre-commit` hook runs `lint-staged` (Biome on staged files) + a full
+typecheck. CI (`.github/workflows/ci.yml`) runs the `ci` script on push/PR.
+
+## Bundled agent skills
+
+This repo ships [`skills`](https://github.com/vercel-labs/skills)-compatible skills
+under [`skills/`](skills/) — it doubles as a local skill marketplace:
+
+- `obsidian-arrow-sandbox` — running and using this sandbox, and porting to a plugin.
+- `arrow-js-obsidian-templates` — Arrow v1.0.6 template rules + footguns.
+- `arrow-js-obsidian-patterns` — integration patterns: icons (Lucide / data-icon
+  sweep), CSS scoping vs Obsidian globals, mount/unmount lifecycle, reactive state.
+
+Install them into your agent via the interactive TUI:
+
+```sh
+pnpm skills:install      # = npx skills add .  (pick skills in the TUI)
+```
+
+`postinstall` offers this automatically after `pnpm install`, but only in an
+interactive terminal — it skips in CI / non-TTY (set `SKIP_SKILLS_INSTALL=1` to
+opt out entirely). You can also add this repo from anywhere with
+`npx skills add <git-url-or-path>`.
+
+## Porting a component into the plugin
+
+Components use only Obsidian classes + `var(--…)` tokens and mount via
+`template(container)` — the same call an `ItemView.onOpen()` makes. To port:
+copy the component file into the plugin's view directory and mount it from
+`onOpen()`. If it uses `boundary()`/async components, add `@arrow-js/framework`
+to the plugin and the `import '@arrow-js/framework'` side-effect import.
+
+## Arrow v1.0.6 footguns (learned the hard way)
+
+These are enforced/encoded so they don't regress:
+
+1. **No literal HTML comments inside `html\`\`` templates.** Arrow uses HTML
+   comments as expression-slot markers; a literal `<!-- … -->` inflates the slot
+   count and throws `Invalid HTML position`. Use JS `//` comments outside the
+   template. Guarded by `test/template-footguns.test.mjs`.
+2. **An attribute expression must be the *entire* value.** `class="${() => '…'}"`
+   works; `class="static ${() => '…'}"` (partial) does not register as a
+   placeholder and throws. Build the full string inside one expression.
+3. **Reactive vs static:** `${data.x}` renders once; `${() => data.x}` is tracked
+   and updates only that slot. Returning `false` from an attribute expression
+   removes the attribute.
+4. **`@event` handlers must type the param `Event`, not a narrowed subtype**
+   (`MouseEvent`, …). Parameter contravariance makes `(e: MouseEvent) => void`
+   fail to assign to Arrow's handler type (`TS2345`); use `(e: Event) => …` and
+   narrow inside. Caught by `tsc`, and the inline form is also guarded by
+   `test/template-footguns.test.mjs`.

package/template/_gitignore

@@ -0,0 +1,8 @@
+node_modules
+dist
+.DS_Store
+*.tgz
+
+# Obsidian's app.css is proprietary — extract it locally with `pnpm pull-css`,
+# don't commit/redistribute it.
+public/app.css

package/template/biome.json

@@ -0,0 +1,30 @@
+{
+	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+	"organizeImports": {
+		"enabled": true
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"suspicious": {
+				"noExplicitAny": "off"
+			}
+		}
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "tab",
+		"lineWidth": 100
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "double",
+			"trailingCommas": "es5",
+			"semicolons": "always"
+		}
+	},
+	"files": {
+		"ignore": ["dist", "node_modules", "public", "pnpm-lock.yaml", "create-obsidian-arrow/template"]
+	}
+}

package/template/docs/prompts/agent-setup.md

@@ -0,0 +1,94 @@
+# Agent setup prompt
+
+Copy everything in the block below and give it to a coding agent (Claude Code or
+similar) to scaffold a new Obsidian Arrow sandbox and orient itself.
+
+---
+
+```text
+Scaffold and set up an Obsidian Arrow Sandbox, then orient yourself on it.
+
+WHAT IT IS
+A client-only Vite + TypeScript sandbox for prototyping Obsidian plugin UI with
+Arrow.js (@arrow-js/core + @arrow-js/framework), rendered against Obsidian's real
+app.css so components look exactly as they will inside a plugin. Components mount
+via `template(container)` — the same call an Obsidian ItemView.onOpen() makes —
+so a finished component copy-pastes into a plugin with near-zero refactoring.
+There is NO SSR/hydration (an Obsidian plugin renders entirely client-side); do
+not add @arrow-js/ssr or @arrow-js/hydrate.
+
+SCAFFOLD IT (use the published tool — pick one)
+  npm create obsidian-arrow@latest my-app
+  pnpm create obsidian-arrow my-app
+  npx create-obsidian-arrow my-app
+
+Then:
+  cd my-app
+  pnpm install
+  pnpm pull-css     # REQUIRED before dev — extracts Obsidian's app.css from your
+                    # LOCAL install into public/app.css (git-ignored, never
+                    # committed; it's Obsidian's proprietary CSS). Auto-detect is
+                    # macOS-only; on Windows/WSL pass --path <obsidian.asar|app.css>
+                    # or set OBSIDIAN_ASAR=<path>.
+  pnpm dev          # open the printed URL: / is the examples index, /example the demo.
+                    # The toolbar slider/presets + edge drag handle resize the panel.
+  pnpm skills:install   # install the bundled agent skills (npx skills add .) — pick
+                        # them in the TUI; this is how you load the domain knowledge.
+
+READ FIRST
+- AGENTS.md (root) — operating guide: run, footguns, CSS scoping, verify, port.
+- skills/*/SKILL.md — obsidian-arrow-sandbox (workflow), arrow-js-obsidian-
+  templates (template syntax + footguns), arrow-js-obsidian-patterns (icons via
+  Lucide/data-icon sweep, CSS scoping, mount/unmount lifecycle, reactive state).
+- docs/superpowers/specs/ — design + decision record (why core+framework, no SSR).
+
+ARROW v1.0.6 FOOTGUNS — do not relearn these the hard way:
+1. NO literal HTML comments inside html`` templates — Arrow treats HTML comments
+   as expression-slot markers, so `<!-- … -->` throws "Invalid HTML position" at
+   render. Use JS // comments outside the template.
+2. An attribute expression must be the ENTIRE value. `class="${() => '…'}"` works;
+   `class="static ${() => '…'}"` (partial) throws. Build the full string in one
+   expression. Returning `false` from a whole-value attribute expr removes the attr.
+3. Reactive vs static: `${x}` renders once; `${() => x}` is tracked and updates
+   only that slot. Forgetting the `() =>` is the #1 "not updating" bug.
+4. @event handlers must type the param as `Event`, not a narrowed subtype
+   (MouseEvent, …) — contravariance makes it fail to assign (TS2345). Use
+   `(e: Event) => …` and narrow inside; no-arg handlers are fine.
+Footguns 1, 2, 4 are guarded by test/template-footguns.test.mjs + tsc.
+
+CONVENTIONS
+- Use Obsidian's own classes (.setting-item, .clickable-icon, .workspace-leaf,
+  .vertical-tab-*, .modal, .mod-cta) and var(--…) tokens first; add custom CSS
+  only when Obsidian has no class, scoped under a container class + element type
+  (e.g. `.my-panel button.my-action`) so it beats Obsidian's global button rule.
+- Sandbox-only chrome lives in src/sandbox/* — it does NOT port to a plugin.
+- Add a demo by exporting an Arrow component and registering it in
+  src/examples/registry.ts (it shows on the index and at its own route).
+
+VERIFY BEFORE CLAIMING DONE
+- `pnpm typecheck && pnpm test && pnpm lint` (or `pnpm run ci` for the full chain).
+- Then open the `pnpm dev` URL and confirm the component renders like a real
+  Obsidian pane with a clean console — Arrow's footguns only surface at render,
+  so typecheck passing is not proof a component works.
+
+PORTING TO A PLUGIN
+Copy the component file into the plugin's view dir and mount from
+ItemView.onOpen() via `template(this.contentEl)`. If it uses boundary()/async
+components, add @arrow-js/framework to the plugin and the side-effect
+`import '@arrow-js/framework'`. Leave src/sandbox/* behind.
+
+Start by scaffolding, running setup steps, then read AGENTS.md and confirm
+`pnpm dev` renders /example correctly. Report what you see.
+```
+
+---
+
+## Notes
+
+- The scaffolder is published to npm as **`create-obsidian-arrow`**, which is why
+  all three of `npm create obsidian-arrow`, `pnpm create obsidian-arrow`, and
+  `npx create-obsidian-arrow` work (the `create-` prefix is what `*/create`
+  resolves to).
+- `pnpm pull-css` is the one step that won't "just work" on a fresh machine —
+  it needs a local Obsidian install (macOS auto-detected). That's intentional:
+  Obsidian's `app.css` is proprietary and never committed/redistributed.