Merge develop into master

Author: chillenious

.changeset/20260501125058-pie-element-multiple-choice.md

@@ -0,0 +1,5 @@
+---
+  "@pie-element/multiple-choice": patch
+---
+
+multiple-choice release flow test

.changeset/common-cougars-hang.md

@@ -0,0 +1,5 @@
+---
+"@pie-element/multiple-choice": patch
+---
+
+test multiple-choice release flow

.changeset/floppy-sites-watch.md

@@ -0,0 +1,5 @@
+---
+"@pie-element/multiple-choice": patch
+---
+
+test release flow

.changeset/orange-toes-dream.md

@@ -0,0 +1,5 @@
+---
+"@pie-element/multiple-choice": patch
+---
+
+test multiple-choice release flow

.changeset/pre.json

@@ -0,0 +1,89 @@
+{
+  "mode": "pre",
+  "tag": "next",
+  "initialVersions": {
+    "@pie-element/element-demo": "0.1.1",
+    "esm-player-test": "1.0.0",
+    "@pie-element/core": "0.1.0",
+    "@pie-element/element-player": "0.1.1",
+    "@pie-element/element-theme": "0.1.0",
+    "@pie-element/element-theme-daisyui": "0.1.0",
+    "@pie-element/categorize": "13.0.1",
+    "@pie-element/charting": "12.0.1",
+    "@pie-element/complex-rubric": "7.0.1",
+    "@pie-element/drag-in-the-blank": "10.0.1",
+    "@pie-element/drawing-response": "12.0.1",
+    "@pie-element/ebsr": "14.1.0",
+    "@pie-element/explicit-constructed-response": "11.0.1",
+    "@pie-element/extended-text-entry": "15.0.1",
+    "@pie-element/fraction-model": "6.0.1",
+    "@pie-element/graphing": "10.0.1",
+    "@pie-element/graphing-solution-set": "6.0.1",
+    "@pie-element/hotspot": "11.0.1",
+    "@pie-element/image-cloze-association": "10.0.1",
+    "@pie-element/inline-dropdown": "10.0.1",
+    "@pie-element/likert": "4.0.1",
+    "@pie-element/match": "12.0.1",
+    "@pie-element/match-list": "7.0.1",
+    "@pie-element/math-inline": "0.1.0",
+    "@pie-element/math-templated": "0.1.0",
+    "@pie-element/matrix": "4.0.1",
+    "@pie-element/multi-trait-rubric": "8.0.1",
+    "@pie-element/multiple-choice": "13.1.0",
+    "@pie-element/number-line": "13.0.1",
+    "@pie-element/passage": "7.0.1",
+    "@pie-element/placement-ordering": "14.0.1",
+    "@pie-element/rubric": "8.0.1",
+    "@pie-element/select-text": "13.0.1",
+    "@pie-element/mc-populated-blank": "0.2.10",
+    "@pie-element/simple-cloze": "0.1.3",
+    "@pie-element/venn-classification": "0.1.0",
+    "@pie-lib/categorize": "2.0.1",
+    "@pie-lib/charting": "7.0.1",
+    "@pie-lib/config-ui": "13.0.1",
+    "@pie-lib/controller-utils": "2.0.1",
+    "@pie-lib/correct-answer-toggle": "4.0.1",
+    "@pie-lib/drag": "4.0.1",
+    "@pie-lib/editable-html-tip-tap": "2.0.1",
+    "@pie-lib/graphing": "4.0.2",
+    "@pie-lib/graphing-solution-set": "4.0.1",
+    "@pie-lib/graphing-utils": "3.0.1",
+    "@pie-lib/icons": "4.0.1",
+    "@pie-lib/mask-markup": "3.0.1",
+    "@pie-lib/math-input": "0.1.0",
+    "@pie-lib/math-rendering": "0.1.0",
+    "@pie-lib/math-toolbar": "3.0.1",
+    "@pie-lib/plot": "4.0.1",
+    "@pie-lib/render-ui": "6.0.1",
+    "@pie-lib/rubric": "2.0.1",
+    "@pie-lib/style-utils": "2.0.1",
+    "@pie-lib/test-utils": "2.0.1",
+    "@pie-lib/text-select": "3.0.1",
+    "@pie-lib/tools": "2.0.1",
+    "@pie-lib/translator": "4.0.1",
+    "@pie-lib/delivery-events-svelte": "0.1.0",
+    "@pie-lib/editable-html-tiptap-svelte": "0.1.2",
+    "@pie-lib/math-input-svelte": "0.1.0",
+    "@pie-lib/styling-svelte": "0.1.2",
+    "@pie-element/print-player": "1.0.1",
+    "@pie-element/element-bundler": "0.1.1",
+    "@pie-element/bundler-shared": "0.1.1",
+    "@pie-element/shared-configure-events": "0.1.0",
+    "@pie-element/shared-controller-utils": "0.1.0",
+    "@pie-element/shared-feedback": "0.1.0",
+    "@pie-element/shared-math-rendering-mathjax": "0.1.0",
+    "@pie-element/shared-player-events": "0.1.0",
+    "@pie-element/shared-test-utils": "0.1.0",
+    "@pie-element/shared-theming": "0.1.0",
+    "@pie-element/shared-theming-mui": "0.1.0",
+    "@pie-element/shared-types": "0.1.0",
+    "@pie-element/shared-utils": "0.1.0",
+    "@pie-element/cli": "0.1.1"
+  },
+  "changesets": [
+    "20260501125058-pie-element-multiple-choice",
+    "common-cougars-hang",
+    "floppy-sites-watch",
+    "orange-toes-dream"
+  ]
+}

.claude/skills/grill-with-docs/ADR-FORMAT.md

@@ -0,0 +1,47 @@
+# ADR Format
+
+ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc.
+
+Create the `docs/adr/` directory lazily — only when the first ADR is needed.
+
+## Template
+
+```md
+# {Short title of the decision}
+
+{1-3 sentences: what's the context, what did we decide, and why.}
+```
+
+That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections.
+
+## Optional sections
+
+Only include these when they add genuine value. Most ADRs won't need them.
+
+- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited
+- **Considered Options** — only when the rejected alternatives are worth remembering
+- **Consequences** — only when non-obvious downstream effects need to be called out
+
+## Numbering
+
+Scan `docs/adr/` for the highest existing number and increment by one.
+
+## When to offer an ADR
+
+All three of these must be true:
+
+1. **Hard to reverse** — the cost of changing your mind later is meaningful
+2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?"
+3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
+
+If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."
+
+### What qualifies
+
+- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
+- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP."
+- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
+- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
+- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
+- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
+- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.

.claude/skills/grill-with-docs/CONTEXT-FORMAT.md

@@ -0,0 +1,77 @@
+# CONTEXT.md Format
+
+## Structure
+
+```md
+# {Context Name}
+
+{One or two sentence description of what this context is and why it exists.}
+
+## Language
+
+**Order**:
+{A concise description of the term}
+_Avoid_: Purchase, transaction
+
+**Invoice**:
+A request for payment sent to a customer after delivery.
+_Avoid_: Bill, payment request
+
+**Customer**:
+A person or organization that places orders.
+_Avoid_: Client, buyer, account
+
+## Relationships
+
+- An **Order** produces one or more **Invoices**
+- An **Invoice** belongs to exactly one **Customer**
+
+## Example dialogue
+
+> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
+> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed."
+
+## Flagged ambiguities
+
+- "account" was used to mean both **Customer** and **User** — resolved: these are distinct concepts.
+```
+
+## Rules
+
+- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid.
+- **Flag conflicts explicitly.** If a term is used ambiguously, call it out in "Flagged ambiguities" with a clear resolution.
+- **Keep definitions tight.** One sentence max. Define what it IS, not what it does.
+- **Show relationships.** Use bold term names and express cardinality where obvious.
+- **Only include terms specific to this project's context.** General programming concepts (timeouts, error types, utility patterns) don't belong even if the project uses them extensively. Before adding a term, ask: is this a concept unique to this context, or a general programming concept? Only the former belongs.
+- **Group terms under subheadings** when natural clusters emerge. If all terms belong to a single cohesive area, a flat list is fine.
+- **Write an example dialogue.** A conversation between a dev and a domain expert that demonstrates how the terms interact naturally and clarifies boundaries between related concepts.
+
+## Single vs multi-context repos
+
+**Single context (most repos):** One `CONTEXT.md` at the repo root.
+
+**Multiple contexts:** A `CONTEXT-MAP.md` at the repo root lists the contexts, where they live, and how they relate to each other:
+
+```md
+# Context Map
+
+## Contexts
+
+- [Ordering](./src/ordering/CONTEXT.md) — receives and tracks customer orders
+- [Billing](./src/billing/CONTEXT.md) — generates invoices and processes payments
+- [Fulfillment](./src/fulfillment/CONTEXT.md) — manages warehouse picking and shipping
+
+## Relationships
+
+- **Ordering → Fulfillment**: Ordering emits `OrderPlaced` events; Fulfillment consumes them to start picking
+- **Fulfillment → Billing**: Fulfillment emits `ShipmentDispatched` events; Billing consumes them to generate invoices
+- **Ordering ↔ Billing**: Shared types for `CustomerId` and `Money`
+```
+
+The skill infers which structure applies:
+
+- If `CONTEXT-MAP.md` exists, read it to find contexts
+- If only a root `CONTEXT.md` exists, single context
+- If neither exists, create a root `CONTEXT.md` lazily when the first term is resolved
+
+When multiple contexts exist, infer which one the current topic relates to. If unclear, ask.

.claude/skills/grill-with-docs/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: grill-with-docs
+description: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
+---
+
+<what-to-do>
+
+Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
+
+Ask the questions one at a time, waiting for feedback on each question before continuing.
+
+If a question can be answered by exploring the codebase, explore the codebase instead.
+
+</what-to-do>
+
+<supporting-info>
+
+## Domain awareness
+
+During codebase exploration, also look for existing documentation:
+
+### File structure
+
+Most repos have a single context:
+
+```
+/
+├── CONTEXT.md
+├── docs/
+│   └── adr/
+│       ├── 0001-event-sourced-orders.md
+│       └── 0002-postgres-for-write-model.md
+└── src/
+```
+
+If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives:
+
+```
+/
+├── CONTEXT-MAP.md
+├── docs/
+│   └── adr/                          ← system-wide decisions
+├── src/
+│   ├── ordering/
+│   │   ├── CONTEXT.md
+│   │   └── docs/adr/                 ← context-specific decisions
+│   └── billing/
+│       ├── CONTEXT.md
+│       └── docs/adr/
+```
+
+Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed.
+
+## During the session
+
+### Challenge against the glossary
+
+When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"
+
+### Sharpen fuzzy language
+
+When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things."
+
+### Discuss concrete scenarios
+
+When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.
+
+### Cross-reference with code
+
+When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?"
+
+### Update CONTEXT.md inline
+
+When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md).
+
+Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts.
+
+### Offer ADRs sparingly
+
+Only offer to create an ADR when all three are true:
+
+1. **Hard to reverse** — the cost of changing your mind later is meaningful
+2. **Surprising without context** — a future reader will wonder "why did they do it this way?"
+3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
+
+If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md).
+
+</supporting-info>

.claude/skills/improve-codebase-architecture/DEEPENING.md

@@ -0,0 +1,37 @@
+# Deepening
+
+How to deepen a cluster of shallow modules safely, given its dependencies. Assumes the vocabulary in [LANGUAGE.md](LANGUAGE.md) — **module**, **interface**, **seam**, **adapter**.
+
+## Dependency categories
+
+When assessing a candidate for deepening, classify its dependencies. The category determines how the deepened module is tested across its seam.
+
+### 1. In-process
+
+Pure computation, in-memory state, no I/O. Always deepenable — merge the modules and test through the new interface directly. No adapter needed.
+
+### 2. Local-substitutable
+
+Dependencies that have local test stand-ins (PGLite for Postgres, in-memory filesystem). Deepenable if the stand-in exists. The deepened module is tested with the stand-in running in the test suite. The seam is internal; no port at the module's external interface.
+
+### 3. Remote but owned (Ports & Adapters)
+
+Your own services across a network boundary (microservices, internal APIs). Define a **port** (interface) at the seam. The deep module owns the logic; the transport is injected as an **adapter**. Tests use an in-memory adapter. Production uses an HTTP/gRPC/queue adapter.
+
+Recommendation shape: *"Define a port at the seam, implement an HTTP adapter for production and an in-memory adapter for testing, so the logic sits in one deep module even though it's deployed across a network."*
+
+### 4. True external (Mock)
+
+Third-party services (Stripe, Twilio, etc.) you don't control. The deepened module takes the external dependency as an injected port; tests provide a mock adapter.
+
+## Seam discipline
+
+- **One adapter means a hypothetical seam. Two adapters means a real one.** Don't introduce a port unless at least two adapters are justified (typically production + test). A single-adapter seam is just indirection.
+- **Internal seams vs external seams.** A deep module can have internal seams (private to its implementation, used by its own tests) as well as the external seam at its interface. Don't expose internal seams through the interface just because tests use them.
+
+## Testing strategy: replace, don't layer
+
+- Old unit tests on shallow modules become waste once tests at the deepened module's interface exist — delete them.
+- Write new tests at the deepened module's interface. The **interface is the test surface**.
+- Tests assert on observable outcomes through the interface, not internal state.
+- Tests should survive internal refactors — they describe behaviour, not implementation. If a test has to change when the implementation changes, it's testing past the interface.