@adobe/data-ai 0.10.2 → 0.10.6

package/.claude/rules/features/data/state.md

@@ -195,7 +195,7 @@ export const createTodo = (
     return { entities: new Map(state.entities).set(id, { name, complete: false, order }) };
 };
 
-export const cases = Conformance.cases(createTodo,
+export const cases = /*@__PURE__*/ Conformance.cases(createTodo,
     { name: "adds the first todo",
       before: {},                       // empty delta — the default State.create() (empty entities)
       args: { name: "a", analytics: AnalyticsService.createFake() },
@@ -217,7 +217,10 @@ export const cases = Conformance.cases(createTodo,
   injected service, etc. into it, never as a third positional. A transition that takes
   **no** args omits `args` from each case entirely (the shared `Case` type makes
   `args` optional exactly then). **Guard no-ops by returning an empty patch `{}`**
-  (or the unchanged slice), never throw.
+  (or the unchanged slice), never throw for an ordinary "nothing to do here"
+  condition. Reserve `throw` for a genuine precondition violation the case wants
+  to name (see "A case that expects a throw" below) — the rare exception, not the
+  default guard style.
 - **A composer merges sub-patches explicitly.** A transition built from smaller
   ones spreads them — `return { ...s, ...sub(s) }` — so each sub-patch's writes
   layer in; a transition that merely **delegates** to one sub-transition returns
@@ -227,6 +230,22 @@ export const cases = Conformance.cases(createTodo,
   any barrel member) in a top-level `cases` literal dead-locks the import cycle.
   Import the concrete helper directly (`import { create } from "./create.js"`) or
   inline full-`State` literals.
+- **Always write the call as `/*@__PURE__*/ Conformance.cases(fn, …)`** (same for
+  `Conformance.derivations`) — the annotation is not optional style, it is what
+  makes the co-location safe. `@adobe/data-testing`'s `sideEffects: false` only
+  lets a bundler drop an unused *import* of the package; `Conformance.cases(fn,
+  …)` is still an ordinary function call happening in *this* file, and an
+  unannotated call is conservatively kept even when the `cases` export it
+  initializes is never read — because the transition function `fn` is legitimately
+  used elsewhere, this module is very much reachable, so the unused `cases` const
+  is the only thing tree-shaking has to remove, and it can't without the hint.
+  Verified against this repo's actual Vite/Rollup production build: a transition
+  whose `cases` call lacked the annotation shipped the full case-fixture data
+  (and the builder's inlined logic) into the bundle; adding `/*@__PURE__*/`
+  removed it completely while leaving the transition function itself intact. A
+  linter/codemod catching a bare `Conformance.cases(`/`Conformance.derivations(`
+  call (missing the leading comment) in a `data/state/*.ts` file would catch this
+  by construction — worth adding if these calls keep getting hand-authored.
 - **`Conformance.cases(fn, ...cases)`** (the builder above) derives each case's
   types from `fn`'s own signature — pass the transition function and cases can't drift
   from what it accepts. **`before` is a delta over `State.create()`** — list only
@@ -295,6 +314,32 @@ export const cases = Conformance.cases(createTodo,
   and isn't a `(state,args)=>state` transform, so `runSpec` skips it: **keep its own
   sibling `*.test.ts`** rather than deleting it and losing coverage.
 
+### A case that expects a throw
+
+A case is normally `{ name, before, args?, after, effects? }`. When a transition
+must reject its input outright — not the "guard no-op, return `{}`" case above,
+but a genuine precondition violation the spec wants to name — declare `throws`
+instead of `after`/`effects`:
+
+```ts
+export const cases = Conformance.cases(withdrawFunds,
+    { name: "rejects a withdrawal over the balance",
+      before: { balance: 10 },
+      args: { amount: 11 },
+      throws: "insufficient funds" },   // substring the thrown Error.message must contain
+);
+```
+
+`throws: true` accepts any thrown error; a string narrows to one whose message
+**contains** it. A case can declare `after`/`effects` **or** `throws`, never
+both — the shared `Case` type makes them mutually exclusive, and there is
+nothing to compare against `after` once a call never returns a patch. The same
+case runs against the pure transform (`runSpec`) **and** the paired ecs
+transaction/action (`runFeature`/`runTransactions`/`runActions`), so a `throws`
+case proves both sides reject the same input the same way. Reach for this only
+when throwing is the transition's actual contract — most invalid input should
+still no-op per the rule above.
+
 ## Injected services and side effects
 
 A transform that needs an outside capability injects it with **`Pick<Services,

package/.claude/rules/features/services/main-service/conformance.md

@@ -165,7 +165,11 @@ It discovers every file exporting `cases`, enforces the two-exports rule, and
 dispatches on case shape (transition → state + effects, derivation →
 `fn(input) ≡ value`), seeding each case's `before`/`input` as a delta over
 `State.create()`. On the ECS side it resolves the reference args a case's `args`
-schema marks; the pure side reads them plain.
+schema marks; the pure side reads them plain. A transition case may declare
+`throws` instead of `after`/`effects` to assert the call rejects its input —
+see `../../data/state.md` ("A case that expects a throw"). `runSpec`,
+`runTransactions`, and `runActions` all honor it identically, so the same case
+proves the pure transform and its paired ecs op fail the same way.
 
 ## The exception — a per-surface `userId`, via the lower-level runners
 

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "adobe-data-ai",
-  "version": "0.10.2",
+  "version": "0.10.6",
   "description": "Architecture skills for @adobe/data — data-oriented modelling, archetype iteration, hot-path performance, and related conventions.",
   "author": {
     "name": "Adobe"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-ai",
-  "version": "0.10.2",
+  "version": "0.10.6",
   "description": "Cross-agent architecture skills for @adobe/data — installable as a Claude Code plugin or copied into any Agent-Skills-compatible agent (Cursor, Codex).",
   "type": "module",
   "private": false,
@@ -29,12 +29,12 @@
     "skills"
   ],
   "peerDependencies": {
-    "@adobe/data": "0.10.2"
+    "@adobe/data": "0.10.6"
   },
   "devDependencies": {
     "typescript": "^5.8.3",
     "vitest": "^1.6.0",
-    "@adobe/data": "0.10.2"
+    "@adobe/data": "0.10.6"
   },
   "license": "MIT",
   "scripts": {