@adobe/data-testing 0.10.21 → 0.10.23

package/README.md

@@ -1,9 +1,8 @@
 # @adobe/data-testing
 
-Conformance-testing utilities for `@adobe/data` ECS features — the `Match` and
-`Conformance` namespaces used by the co-located conformance pattern (see
-`@adobe/data-ai`'s `features/data/state.md` and
-`features/services/main-service/conformance.md`).
+Conformance-testing utilities for `@adobe/data` ECS features: the `Match` and
+`Conformance` namespaces behind the spec ⇄ ECS conformance pattern (see
+`@adobe/data-ai`'s `features/spec/index.md` and `features/ecs/conformance.md`).
 
 This package exists separately from `@adobe/data` so that installing
 `@adobe/data` never pulls in a `vitest` peer dependency — only projects that
@@ -19,26 +18,44 @@ pnpm add -D @adobe/data-testing vitest
 ## Usage
 
 ```ts
-// data/state/conformance-case.ts
-import { Conformance as ConformanceApi } from "@adobe/data-testing";
-import type { State } from "./state.js";
-
-export type Conformance<F extends (...args: never[]) => unknown> = ConformanceApi.Cases<State, F>;
-export const entity = ConformanceApi.entity;
-```
-
-```ts
-// data/state/spec.test.ts
-import { Conformance } from "@adobe/data-testing";
-import { State } from "./state.js";
-import { transitions } from "./transitions.js";
-
-Conformance.runSpec({ state: State, transitions });
+// spec/spec.ts — the pure spec: State, its actions and derivations, their cases
+export const spec = Conformance.spec({
+  state: State,
+  fns: transforms,
+  schemas: { ...components, ...resources },
+  services: { analytics: AnalyticsService.createFake },
+  cases: { createTodo, toggleComplete, visibleTodos },
+});
+
+// spec/spec.test.ts
+Conformance.checkSpec(spec);
+
+// ecs/conformance/implementation.ts — the spec paired with its ECS build
+export const implementation = Conformance.implementation(spec, {
+  plugin: MainService.plugin,
+  computedPlugin: ComputedDatabase.plugin,
+  projection,
+  hydrate: ["visibleTodos"],
+});
+
+// ecs/conformance/conformance.test.ts
+Conformance.checkFeature(implementation);
 ```
 
-`Match` provides tolerant, matcher-aware value comparison (`matches`, `ref`,
-`anyNumber`, `anyString`) used by the `after` side of a conformance case.
-`Conformance` provides the case types (`Cases`, `DerivationCases`, `Effects`)
-and the runner drivers (`runSpec`, `runTransactions`, `runActions`,
-`runComputeds`, `runFeature`) that drive vitest's `describe`/`it` against
-spec-owned cases.
+- **`checkSpec`** runs every case against the pure spec functions. No ECS is built.
+- **`checkFeature`** runs every case against the ECS:
+  - each spec action against the same-named action;
+  - each derivation against its computed;
+  - each ECS system against the same-named spec system function, running just that
+    system;
+  - each frame case by running every modelled system once, in the order the systems'
+    `schedule`s declare (the `frame` option lists arg writers and unmodelled systems).
+
+  It also round-trips `State.samples` through the projection. A spec op with no
+  implementation fails by name.
+- **`Conformance.StateMatches<State, typeof resources, typeof components>`** pins a
+  `State`'s keys to the feature's resource and component names.
+- **`Match`** provides tolerant, matcher-aware comparison (`matches`, `ref`,
+  `anyNumber`, `anyString`).
+- The lower-level runners (`runActions`, `runComputeds`, `runTransactions`,
+  `adaptCases`) remain for a feature that needs per-case ambient context.

package/dist/conformance/adapt-spec.d.ts

@@ -1,8 +1,3 @@
-import type { Schema } from "@adobe/data/schema";
 type AnyFn = (...args: never[]) => unknown;
-type LooseCaseModule = {
-    readonly args?: Schema;
-    readonly cases: readonly Record<string, unknown>[];
-};
-export declare const adaptCases: (fns: Readonly<Record<string, AnyFn>>, cases: Readonly<Record<string, LooseCaseModule>>, services: Readonly<Record<string, () => object>> | undefined, injectServices: boolean) => Record<string, Record<string, unknown>>;
+export declare const adaptCases: (fns: Readonly<Record<string, AnyFn>>, cases: object, services: Readonly<Record<string, () => object>> | undefined, injectServices: boolean) => Record<string, Record<string, unknown>>;
 export {};

package/dist/conformance/adapt-spec.js

@@ -27,6 +27,8 @@ const injectDoubles = (testCase, services) => {
 export const adaptCases = (fns, cases, services, injectServices) => {
     const out = {};
     for (const [name, fn] of Object.entries(fns)) {
+        // Runtime invariant: a manifest's `cases` holds one case module per fn (the
+        // `Conformance.spec` coverage guard).
         const module = cases[name];
         const list = module.cases;
         const first = list[0];

package/dist/conformance/adapt-spec.js.map

@@ -1 +1 @@
-{"version":3,"file":"adapt-spec.js","sourceRoot":"","sources":["../../src/conformance/adapt-spec.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAiB,MAAM,mBAAmB,CAAC;AAQ/D,oFAAoF;AACpF,8EAA8E;AAC9E,mFAAmF;AACnF,oFAAoF;AACpF,kFAAkF;AAClF,gFAAgF;AAChF,MAAM,aAAa,GAAG,CACpB,QAAiC,EACjC,QAAgD,EACvB,EAAE;IAC3B,MAAM,SAAS,GAAG,QAAQ,CAAC,WAAW,CAAmD,CAAC;IAC1F,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAuB,CAAC;IACpD,MAAM,KAAK,GAA2B,EAAE,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxD,KAAK,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACzD,CAAC;IACD,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,QAAQ,CAAC;IACjE,OAAO,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,EAAE,GAAG,KAAK,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;AAC1D,CAAC,CAAC;AAEF,2EAA2E;AAC3E,oFAAoF;AACpF,gFAAgF;AAChF,gFAAgF;AAChF,mFAAmF;AACnF,qFAAqF;AACrF,kFAAkF;AAClF,gFAAgF;AAChF,qEAAqE;AACrE,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,GAAoC,EACpC,KAAgD,EAChD,QAA4D,EAC5D,cAAuB,EACkB,EAAE;IAC3C,MAAM,GAAG,GAA4C,EAAE,CAAC;IACxD,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7C,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAwC,CAAC;QAC7D,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,IAAI,KAAK,EAAE,CAAC;YAC5C,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;YAC1D,SAAS;QACX,CAAC;QACD,MAAM,OAAO,GAAG,cAAc,IAAI,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9G,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG;YACjB,CAAC,IAAI,CAAC,EAAE,EAAE;YACV,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE;SAChF,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC"}
+{"version":3,"file":"adapt-spec.js","sourceRoot":"","sources":["../../src/conformance/adapt-spec.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAiB,MAAM,mBAAmB,CAAC;AAQ/D,oFAAoF;AACpF,8EAA8E;AAC9E,mFAAmF;AACnF,oFAAoF;AACpF,kFAAkF;AAClF,gFAAgF;AAChF,MAAM,aAAa,GAAG,CACpB,QAAiC,EACjC,QAAgD,EACvB,EAAE;IAC3B,MAAM,SAAS,GAAG,QAAQ,CAAC,WAAW,CAAmD,CAAC;IAC1F,MAAM,IAAI,GAAG,QAAQ,CAAC,MAAM,CAAuB,CAAC;IACpD,MAAM,KAAK,GAA2B,EAAE,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxD,KAAK,CAAC,IAAI,CAAC,GAAG,WAAW,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;IACzD,CAAC;IACD,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,IAAI,EAAE,GAAG,QAAQ,CAAC;IACjE,OAAO,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,EAAE,GAAG,KAAK,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;AAC1D,CAAC,CAAC;AAEF,2EAA2E;AAC3E,oFAAoF;AACpF,gFAAgF;AAChF,gFAAgF;AAChF,mFAAmF;AACnF,qFAAqF;AACrF,kFAAkF;AAClF,gFAAgF;AAChF,qEAAqE;AACrE,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,GAAoC,EACpC,KAAa,EACb,QAA4D,EAC5D,cAAuB,EACkB,EAAE;IAC3C,MAAM,GAAG,GAA4C,EAAE,CAAC;IACxD,KAAK,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7C,4EAA4E;QAC5E,sCAAsC;QACtC,MAAM,MAAM,GAAI,KAAmD,CAAC,IAAI,CAAE,CAAC;QAC3E,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAwC,CAAC;QAC7D,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,IAAI,KAAK,EAAE,CAAC;YAC5C,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;YAC1D,SAAS;QACX,CAAC;QACD,MAAM,OAAO,GAAG,cAAc,IAAI,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;QAC9G,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,GAAG;YACjB,CAAC,IAAI,CAAC,EAAE,EAAE;YACV,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE;SAChF,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC,CAAC"}

package/dist/conformance/build-double.js

@@ -1,32 +1,36 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 // Build a recording double for one service from a SHAPE-ONLY template and a case's
-// response schedule. The template — the feature's registered fake — is called once
-// purely to enumerate the service's members (types are erased at runtime, and Proxy
-// is banned on these paths, so the method names must come from a real value); its
-// own behavior is never used. Every value-returning call drains that method's FIFO;
-// a `void` method (or any method with no schedule) returns `undefined`. Draining an
-// EXHAUSTED schedule throws, so a transform that calls a method more times than the
-// case scheduled is a hard failure — the determinism a conformance oracle needs
-// (the old fakes cycled, silently masking an over-call).
+// response schedule. The template — the feature's registered fake — supplies the
+// method names (types are erased at runtime, and Proxy is banned on these paths), and
+// one probe call per method tells a value method (returns something) from a void one
+// (returns `undefined`); fakes are inert, so probing is safe. Every value-returning
+// call drains that method's FIFO. Calling a value method with no response scheduled,
+// or more times than scheduled, throws: a case must own every value its code reads.
 //
-// The returned double still gets wrapped by `recordCalls` (call recording) on its
-// way into a case's args, exactly like the live fakes it replaces — so effect
-// assertion is unchanged; only the RETURNS now come from the case, not the fake.
+// The returned double still gets wrapped by `recordCalls` on its way into a case's
+// args, so effect assertion is unchanged; only the RETURNS come from the case.
 export const buildDouble = (template, responses) => {
     const shape = template();
+    const service = "serviceName" in shape ? String(shape.serviceName) : "service";
     const queues = new Map(Object.entries(responses ?? {}).map(([method, schedule]) => [method, [...schedule]]));
-    return Object.fromEntries(Object.entries(shape).map(([key, value]) => typeof value !== "function"
-        ? [key, value] // serviceName and other non-method members pass through
-        : [
+    return Object.fromEntries(Object.entries(shape).map(([key, value]) => {
+        if (typeof value !== "function")
+            return [key, value]; // serviceName and other non-method members pass through
+        const returnsValue = value() !== undefined;
+        return [
             key,
             (..._args) => {
                 const queue = queues.get(key);
-                if (!queue)
-                    return undefined; // void method, or an unscheduled call
+                if (queue === undefined) {
+                    if (!returnsValue)
+                        return undefined; // a void method
+                    throw new Error(`no response scheduled for "${service}.${key}"; add it to the case's responses`);
+                }
                 if (queue.length === 0)
-                    throw new Error(`response schedule exhausted for "${key}"`);
+                    throw new Error(`response schedule exhausted for "${service}.${key}"`);
                 return queue.shift();
             },
-        ]));
+        ];
+    }));
 };
 //# sourceMappingURL=build-double.js.map

package/dist/conformance/build-double.js.map

@@ -1 +1 @@
-{"version":3,"file":"build-double.js","sourceRoot":"","sources":["../../src/conformance/build-double.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAMvD,mFAAmF;AACnF,mFAAmF;AACnF,oFAAoF;AACpF,kFAAkF;AAClF,oFAAoF;AACpF,oFAAoF;AACpF,oFAAoF;AACpF,gFAAgF;AAChF,yDAAyD;AACzD,EAAE;AACF,kFAAkF;AAClF,8EAA8E;AAC9E,iFAAiF;AACjF,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,QAAsB,EAAE,SAA+B,EAAU,EAAE;IAC7F,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,MAAM,GAAG,IAAI,GAAG,CACpB,MAAM,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CACrF,CAAC;IACF,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CACzC,OAAO,KAAK,KAAK,UAAU;QACzB,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,wDAAwD;QACvE,CAAC,CAAC;YACE,GAAG;YACH,CAAC,GAAG,KAAgB,EAAW,EAAE;gBAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC9B,IAAI,CAAC,KAAK;oBAAE,OAAO,SAAS,CAAC,CAAC,sCAAsC;gBACpE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;oBAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,GAAG,GAAG,CAAC,CAAC;gBACpF,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC;YACvB,CAAC;SACF,CACN,CACF,CAAC;AACJ,CAAC,CAAC"}
+{"version":3,"file":"build-double.js","sourceRoot":"","sources":["../../src/conformance/build-double.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAMvD,mFAAmF;AACnF,iFAAiF;AACjF,sFAAsF;AACtF,qFAAqF;AACrF,oFAAoF;AACpF,qFAAqF;AACrF,oFAAoF;AACpF,EAAE;AACF,mFAAmF;AACnF,+EAA+E;AAC/E,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,QAAsB,EAAE,SAA+B,EAAU,EAAE;IAC7F,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,OAAO,GAAG,aAAa,IAAI,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAC/E,MAAM,MAAM,GAAG,IAAI,GAAG,CACpB,MAAM,CAAC,OAAO,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CACrF,CAAC;IACF,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE;QACzC,IAAI,OAAO,KAAK,KAAK,UAAU;YAAE,OAAO,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,wDAAwD;QAC9G,MAAM,YAAY,GAAI,KAAuB,EAAE,KAAK,SAAS,CAAC;QAC9D,OAAO;YACL,GAAG;YACH,CAAC,GAAG,KAAgB,EAAW,EAAE;gBAC/B,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC9B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;oBACxB,IAAI,CAAC,YAAY;wBAAE,OAAO,SAAS,CAAC,CAAC,gBAAgB;oBACrD,MAAM,IAAI,KAAK,CAAC,8BAA8B,OAAO,IAAI,GAAG,mCAAmC,CAAC,CAAC;gBACnG,CAAC;gBACD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;oBAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,OAAO,IAAI,GAAG,GAAG,CAAC,CAAC;gBAC/F,OAAO,KAAK,CAAC,KAAK,EAAE,CAAC;YACvB,CAAC;SACF,CAAC;IACJ,CAAC,CAAC,CACH,CAAC;AACJ,CAAC,CAAC"}

package/dist/conformance/build-double.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/conformance/build-double.test.js

@@ -0,0 +1,30 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { describe, it, expect } from "vitest";
+import { buildDouble } from "./build-double.js";
+const template = () => ({
+    serviceName: "rng",
+    next: () => 0,
+    fetch: () => Promise.resolve(""),
+    log: () => { },
+});
+describe("buildDouble", () => {
+    it("returns scheduled responses in order", () => {
+        const double = buildDouble(template, { next: [1, 2] });
+        expect([double.next(), double.next()]).toEqual([1, 2]);
+    });
+    it("throws on a value method with no response scheduled", () => {
+        const double = buildDouble(template, undefined);
+        expect(() => double.next()).toThrow('no response scheduled for "rng.next"');
+        expect(() => double.fetch()).toThrow('no response scheduled for "rng.fetch"');
+    });
+    it("throws once a schedule is exhausted", () => {
+        const double = buildDouble(template, { next: [1] });
+        double.next();
+        expect(() => double.next()).toThrow('response schedule exhausted for "rng.next"');
+    });
+    it("lets a void method run unscheduled", () => {
+        const double = buildDouble(template, undefined);
+        expect(double.log()).toBeUndefined();
+    });
+});
+//# sourceMappingURL=build-double.test.js.map

package/dist/conformance/build-double.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-double.test.js","sourceRoot":"","sources":["../../src/conformance/build-double.test.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,QAAQ,GAAG,GAAG,EAAE,CAAC,CAAC;IACtB,WAAW,EAAE,KAAK;IAClB,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;IACb,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;IAChC,GAAG,EAAE,GAAG,EAAE,GAAE,CAAC;CACd,CAAC,CAAC;AAGH,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,EAAE,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAC9C,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAQ,CAAC;QAC9D,MAAM,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC7D,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAQ,CAAC;QACvD,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,sCAAsC,CAAC,CAAC;QAC5E,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,uCAAuC,CAAC,CAAC;IAChF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC7C,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAQ,CAAC;QAC3D,MAAM,CAAC,IAAI,EAAE,CAAC;QACd,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,4CAA4C,CAAC,CAAC;IACpF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,oCAAoC,EAAE,GAAG,EAAE;QAC5C,MAAM,MAAM,GAAG,WAAW,CAAC,QAAQ,EAAE,SAAS,CAAQ,CAAC;QACvD,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,aAAa,EAAE,CAAC;IACvC,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/conformance/check-feature.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaSource } from "./refify.js";
+import type { Implementation } from "./implementation.js";
+type AnyFn = (...args: never[]) => unknown;
+export declare const checkFeature: <State extends object, Fns extends Record<string, AnyFn>, StoreT extends SchemaSource>(impl: Implementation<State, Fns, StoreT>) => void;
+export {};

package/dist/conformance/check-feature.js

@@ -0,0 +1,50 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { runFeature } from "./run-feature.js";
+import { runSystems } from "./run-systems.js";
+import { adaptCases } from "./adapt-spec.js";
+import { withNoOp } from "./with-no-op.js";
+// Frame cases with recording doubles injected into their `args`, as `adaptCases` does
+// for an op's cases.
+const frameCasesOf = (frame, services) => {
+    if (frame === undefined)
+        return [];
+    const adapted = adaptCases({ frame: () => undefined }, { frame }, services, true)["./frame"];
+    // Runtime invariant: `adaptCases` keeps a transition envelope's `{ cases }` list.
+    return adapted["cases"].cases;
+};
+// The ecs conformance suite: the spec's cases drive the implementation's actions and
+// computeds (fresh doubles again, so the pure and ecs runs never share FIFO state).
+// A spec op with no same-named implementation is a named failure.
+export const checkFeature = (impl) => {
+    const { spec } = impl;
+    runFeature({
+        state: spec.state,
+        transitions: adaptCases(spec.fns, spec.cases, spec.services, true),
+        plugin: impl.plugin,
+        computedPlugin: impl.computedPlugin,
+        projection: impl.projection,
+        hydrate: impl.hydrate,
+        services: impl.services,
+        match: spec.match,
+        ops: impl.ops,
+    });
+    if (spec.systems && impl.frame) {
+        const baseServices = () => Object.fromEntries(Object.entries(impl.services ?? {}).map(([name, create]) => [name, create()]));
+        runSystems({
+            // Runtime invariant: a plugin builds a database whose system surface and store
+            // are the projection's (`implementation` types `plugin` and `projection` together).
+            makeDb: (services) => Database.toSystemDatabase(Database.create(impl.plugin, { services: { ...baseServices(), ...services } })),
+            fromState: impl.projection.fromState,
+            toState: impl.projection.toState,
+            initial: spec.state.create(),
+            systems: adaptCases(spec.systems.fns, withNoOp(spec.systems.cases, spec.systems.noOp), spec.services, true),
+            frameCases: () => frameCasesOf(impl.frame?.cases, spec.services),
+            // Runtime invariant: `implementation` types each writer against this db and arg.
+            args: impl.frame.args,
+            unmodelled: impl.frame.unmodelled ?? {},
+            match: spec.match,
+        });
+    }
+};
+//# sourceMappingURL=check-feature.js.map

package/dist/conformance/check-feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-feature.js","sourceRoot":"","sources":["../../src/conformance/check-feature.ts"],"names":[],"mappings":"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"}

package/dist/conformance/check-spec.d.ts

@@ -0,0 +1,4 @@
+import type { Spec } from "./spec.js";
+type AnyFn = (...args: never[]) => unknown;
+export declare const checkSpec: <State extends object, Fns extends Record<string, AnyFn>, C extends object, Sys extends Record<string, AnyFn>>(spec: Spec<State, Fns, C, Sys>) => void;
+export {};

package/dist/conformance/check-spec.js

@@ -0,0 +1,20 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { runSpec } from "./run-spec.js";
+import { adaptCases } from "./adapt-spec.js";
+import { withNoOp } from "./with-no-op.js";
+// The pure-spec suite: run every case against its spec fn, with fresh recording
+// doubles built from the `services` templates + each case's `responses`. Reference
+// fields are found from `spec.schemas`; no store or plugin is built. Per-system cases
+// run here too; whole-frame cases need the ECS's system order, so `checkFeature` runs them.
+export const checkSpec = (spec) => {
+    runSpec({
+        state: spec.state,
+        transitions: {
+            ...adaptCases(spec.fns, spec.cases, spec.services, true),
+            ...(spec.systems ? adaptCases(spec.systems.fns, withNoOp(spec.systems.cases, spec.systems.noOp), spec.services, true) : {}),
+        },
+        schemas: spec.schemas,
+        match: spec.match,
+    });
+};
+//# sourceMappingURL=check-spec.js.map

package/dist/conformance/check-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-spec.js","sourceRoot":"","sources":["../../src/conformance/check-spec.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAK3C,gFAAgF;AAChF,mFAAmF;AACnF,sFAAsF;AACtF,4FAA4F;AAC5F,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,IAA8B,EACxB,EAAE;IACR,OAAO,CAAC;QACN,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,WAAW,EAAE;YACX,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC;YACxD,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;SAC5H;QACD,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,KAAK,EAAE,IAAI,CAAC,KAAK;KAClB,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/conformance/feature-types.d.ts

@@ -4,7 +4,7 @@ type MethodKeys<T> = {
     [K in keyof T]-?: T[K] extends (...a: never[]) => unknown ? K : never;
 }[keyof T];
 type IsService<T> = T extends readonly unknown[] ? false : T extends (...a: never[]) => unknown ? false : T extends object ? [MethodKeys<T>] extends [never] ? false : true : false;
-type ArgsOf<F> = F extends (...a: never[]) => unknown ? Parameters<F> extends [unknown, infer A, ...unknown[]] ? A : void : void;
+export type ArgsOf<F> = F extends (...a: never[]) => unknown ? Parameters<F> extends [unknown, infer A, ...unknown[]] ? A : void : void;
 type Payload<R> = R extends Promise<infer T> ? T : R extends AsyncGenerator<infer T, unknown, unknown> ? T : R;
 type ScheduleOf<M> = M extends (...a: never[]) => infer R ? readonly Payload<R>[] : never;
 type ValueMethodKeys<S> = {
@@ -16,7 +16,7 @@ type ServiceResponses<S> = {
 export type Responses<Args> = {
     readonly [K in keyof Args as IsService<Args[K]> extends true ? K : never]?: ServiceResponses<Args[K]>;
 };
-type DataArgKeys<Args> = {
+export type DataArgKeys<Args> = {
     [K in keyof Args]-?: IsService<Args[K]> extends true ? never : K;
 }[keyof Args];
 type DataArgs<Args> = Pick<Args, DataArgKeys<Args>>;

package/dist/conformance/implementation.d.ts

@@ -0,0 +1,41 @@
+import type { Database } from "@adobe/data/ecs";
+import type { HasDerivations, HydrateExact, HydrationKeys, ProjectionShape, ProjectionStore, ProjectionValue } from "./feature-types.js";
+import type { Projection } from "./run-feature.js";
+import type { Spec } from "./spec.js";
+import type { FrameArgWriters, FrameCases, SystemKeys, SystemsExact } from "./systems-types.js";
+type AnyFn = (...args: never[]) => unknown;
+export interface Implementation<State extends object, Fns extends Record<string, AnyFn>, StoreT> {
+    readonly spec: Spec<State, Fns, object, Record<string, AnyFn>>;
+    readonly plugin: Database.Plugin;
+    readonly frame?: {
+        readonly args: Readonly<Record<string, (db: never, value: never) => void>>;
+        readonly unmodelled?: Readonly<Record<string, string>>;
+        readonly cases?: object;
+    };
+    readonly computedPlugin?: Database.Plugin;
+    readonly projection: Projection<StoreT, State>;
+    readonly hydrate?: readonly string[];
+    readonly services?: Readonly<Record<string, () => object>>;
+    readonly ops?: {
+        readonly actions?: Record<string, unknown>;
+        readonly computeds?: Record<string, unknown>;
+    };
+}
+export declare const implementation: <State extends object, Fns extends Record<string, AnyFn>, C extends object, P extends ProjectionShape<State>, const H extends readonly Extract<keyof Fns, string>[] = readonly [], PL extends Database.Plugin = Database.Plugin, Sys extends Record<string, AnyFn> = {}, U extends string = never>(spec: Spec<State, Fns, C, Sys>, impl: Omit<Implementation<State, Fns, ProjectionStore<P>>, "spec" | "plugin" | "projection" | "hydrate" | "computedPlugin" | "frame"> & {
+    readonly plugin: PL;
+    readonly projection: P;
+    readonly hydrate?: H;
+} & (HasDerivations<C> extends true ? {
+    readonly computedPlugin: Database.Plugin;
+} : {
+    readonly computedPlugin?: Database.Plugin;
+}) & HydrateExact<H, HydrationKeys<Fns, ProjectionValue<P>>> & ([keyof Sys] extends [never] ? {
+    readonly frame?: undefined;
+} : {
+    readonly frame: {
+        readonly args: FrameArgWriters<PL, Sys>;
+        readonly unmodelled?: { readonly [K in U]: string; };
+        readonly cases?: FrameCases<State, Sys>;
+    } & SystemsExact<Extract<keyof Sys, string>, U, SystemKeys<PL>>;
+})) => Implementation<State, Fns, ProjectionStore<P>>;
+export {};

package/dist/conformance/implementation.js

@@ -0,0 +1,11 @@
+// Pair a spec with its ECS implementation. A typed identity that arms the guards:
+//   • `hydrate` exactness — EXACTLY the entity-list derivations (`HydrateExact`).
+//   • `computedPlugin` requiredness — required when the spec has a derivation.
+//   • `frame` requiredness and exactness — required when the spec has systems; one arg
+//     writer per frame data arg; every ECS system modelled xor unmodelled.
+export const implementation = (spec, impl) => 
+// Runtime invariant the checker can't see: `impl` plus the spec IS this
+// Implementation (`P` widens to the stored `Projection`, `H` to `readonly string[]`;
+// the requiredness factors are compile-only phantoms).
+({ ...impl, spec });
+//# sourceMappingURL=implementation.js.map

package/dist/conformance/implementation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"implementation.js","sourceRoot":"","sources":["../../src/conformance/implementation.ts"],"names":[],"mappings":"AAkDA,kFAAkF;AAClF,kFAAkF;AAClF,+EAA+E;AAC/E,uFAAuF;AACvF,2EAA2E;AAC3E,MAAM,CAAC,MAAM,cAAc,GAAG,CAU5B,IAA8B,EAC9B,IAcQ,EACwC,EAAE;AAClD,wEAAwE;AACxE,qFAAqF;AACrF,uDAAuD;AACvD,CAAC,EAAE,GAAG,IAAI,EAAE,IAAI,EAAE,CAA8D,CAAC"}

package/dist/conformance/manifest.type-test.d.ts

@@ -0,0 +1,122 @@
+import type { CaseModule, SpecCases, SpecDerivations } from "./feature-types.js";
+type Foo = {
+    readonly name: string;
+};
+type State = {
+    readonly entities: ReadonlyMap<number, Foo>;
+    readonly count: number;
+};
+declare const bump: (s: Pick<State, "count">, args: {
+    readonly by: number;
+}) => Pick<State, "count">;
+declare const listFoos: (s: Pick<State, "entities">) => readonly Foo[];
+interface Store {
+    readonly componentSchemas: Record<string, unknown>;
+}
+export declare const ok: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+    listFoos: (s: Pick<State, "entities">) => readonly Foo[];
+}, Store>;
+export declare const missingCase: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+    listFoos: (s: Pick<State, "entities">) => readonly Foo[];
+}, Store>;
+export declare const extraCase: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+    listFoos: (s: Pick<State, "entities">) => readonly Foo[];
+}, Store>;
+export declare const missingHydrate: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+    listFoos: (s: Pick<State, "entities">) => readonly Foo[];
+}, Store>;
+export declare const extraHydrate: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+    listFoos: (s: Pick<State, "entities">) => readonly Foo[];
+}, Store>;
+interface Logger {
+    log: (msg: string) => void;
+    next: () => Promise<number>;
+}
+declare const record: (s: Pick<State, "count">, args: {
+    readonly by: number;
+    readonly logger: Logger;
+}) => Pick<State, "count">;
+export declare const recOk: SpecCases<State, typeof record>;
+export declare const recBadArgsService: SpecCases<State, typeof record>;
+export declare const recMissingArg: SpecCases<State, typeof record>;
+export declare const recVoidResponse: SpecCases<State, typeof record>;
+export declare const recWrongResponse: SpecCases<State, typeof record>;
+export declare const recThrows: SpecCases<State, typeof record>;
+export declare const recBoth: SpecCases<State, typeof record>;
+declare const reset: (s: Pick<State, "count">) => Pick<State, "count">;
+export declare const resetOk: CaseModule<State, typeof reset>;
+declare const saveAsync: (s: Pick<State, "count">, a: {
+    readonly id: number;
+}) => Promise<Pick<State, "count">>;
+export declare const asyncOk: CaseModule<State, typeof saveAsync>;
+export declare const arrOk: CaseModule<State, typeof listFoos>;
+declare const idsOf: (s: State) => ReadonlySet<number>;
+export declare const setOk: CaseModule<State, typeof idsOf>;
+declare const total: (s: State) => number;
+export declare const scalarOk: CaseModule<State, typeof total>;
+export declare const wrongTransition: SpecCases<State, typeof reset>;
+export declare const wrongDerivation: SpecDerivations<typeof total>;
+export declare const mispair: CaseModule<State, typeof bump>;
+declare const count: (s: State) => number;
+export declare const residualGap: CaseModule<State, typeof count>;
+export declare const missingComputedPlugin: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+    listFoos: (s: Pick<State, "entities">) => readonly Foo[];
+}, Store>;
+export declare const noComputedOk: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const servicesOk: import("./implementation.js").Implementation<State, {
+    record: (s: Pick<State, "count">, args: {
+        readonly by: number;
+        readonly logger: Logger;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const missingServices: import("./implementation.js").Implementation<State, {
+    record: (s: Pick<State, "count">, args: {
+        readonly by: number;
+        readonly logger: Logger;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const incompleteServices: import("./implementation.js").Implementation<State, {
+    record: (s: Pick<State, "count">, args: {
+        readonly by: number;
+        readonly logger: Logger;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const extraServices: import("./implementation.js").Implementation<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+}, Store>;
+import type { StateMatches } from "./state-matches.js";
+type Assert<T extends true> = T;
+type Resources = {
+    readonly count: unknown;
+};
+type Components = {
+    readonly name: unknown;
+};
+export type _stateOk = Assert<StateMatches<State, Resources, Components>>;
+export type _badSingleton = Assert<StateMatches<State, {}, Components>>;
+export type _badEntity = Assert<StateMatches<State, Resources, {}>>;
+export {};

package/dist/conformance/manifest.type-test.js

@@ -0,0 +1,96 @@
+import { spec as specOf } from "./spec.js";
+import { implementation } from "./implementation.js";
+// A transition (2 params) and an entity-list derivation (returns `readonly Foo[]`, so
+// its ecs computed emits ids → it MUST be hydrated).
+const bump = (s, args) => ({ count: s.count + args.by });
+const listFoos = (s) => [...s.entities.values()];
+const fns = { bump, listFoos };
+// A concrete projection whose `toData` returns the entity value `Foo` — that return
+// type is what tells the guard `listFoos` is an entity-list derivation.
+const projection = {
+    fromState: (_store, _s) => { },
+    toState: (_store) => ({ entities: new Map(), count: 0 }),
+    toData: (_store, _e) => ({ name: "" }),
+};
+const bumpCases = {
+    cases: [{ name: "bumps", before: {}, args: { by: 1 }, after: { count: 1 } }],
+};
+const listFoosCases = {
+    cases: [{ name: "lists", input: { entities: new Map() }, value: [] }],
+};
+// POSITIVE — every fn has a case, and `hydrate` is exactly the entity-list derivation.
+export const ok = implementation(specOf({ state, fns, cases: { bump: bumpCases, listFoos: listFoosCases } }), { plugin, computedPlugin, projection, hydrate: ["listFoos"] });
+// NEGATIVE (cases coverage) — a conformed fn with no case module.
+// @ts-expect-error — `cases` is missing `listFoos`
+export const missingCase = implementation(specOf({ state, fns, cases: { bump: bumpCases } }), { plugin, computedPlugin, projection, hydrate: ["listFoos"] });
+// NEGATIVE (cases coverage) — a case module for a name that is not a conformed fn.
+// @ts-expect-error — `cases` has `bogus`, which is not in `fns`
+export const extraCase = implementation(specOf({ state, fns, cases: { bump: bumpCases, listFoos: listFoosCases, bogus: bumpCases } }), { plugin, computedPlugin, projection, hydrate: ["listFoos"] });
+// NEGATIVE (hydrate exactness) — an entity-list derivation left out of `hydrate`.
+// @ts-expect-error — `hydrate` is missing the entity-list derivation `listFoos`
+export const missingHydrate = implementation(specOf({ state, fns, cases: { bump: bumpCases, listFoos: listFoosCases } }), { plugin, computedPlugin, projection, hydrate: [] });
+// NEGATIVE (hydrate exactness) — a non-entity-list fn listed in `hydrate`.
+// @ts-expect-error — `hydrate` lists `bump`, which does not need hydration
+export const extraHydrate = implementation(specOf({ state, fns, cases: { bump: bumpCases, listFoos: listFoosCases } }), { plugin, computedPlugin, projection, hydrate: ["listFoos", "bump"] });
+const record = (s, args) => ({
+    count: s.count + args.by + (args.logger.log("x"), 0),
+});
+// POSITIVE — data-only `args` (the `logger` service is stripped), a scheduled return for
+// the value method `next`, and the void `log` asserted in `effects`.
+export const recOk = {
+    cases: [{ name: "ok", before: {}, args: { by: 1 }, responses: { logger: { next: [5] } }, after: { count: 6 }, effects: { logger: [["log", "x"]] } }],
+};
+// NEGATIVE — a live service instance in `args` (args are DATA only).
+// @ts-expect-error — `logger` is a service; it must not appear in `args`
+export const recBadArgsService = { cases: [{ name: "x", before: {}, args: { by: 1, logger: {} }, after: { count: 1 } }] };
+// NEGATIVE — a required data arg omitted.
+// @ts-expect-error — `args` is missing the required `by`
+export const recMissingArg = { cases: [{ name: "x", before: {}, args: {}, after: { count: 1 } }] };
+// NEGATIVE — scheduling a response for a `void` method (only value methods take one).
+// @ts-expect-error — `log` is void; it cannot be scheduled in `responses`
+export const recVoidResponse = { cases: [{ name: "x", before: {}, args: { by: 1 }, responses: { logger: { log: ["y"] } }, after: { count: 1 } }] };
+// NEGATIVE — a scheduled response of the wrong payload type (`next` yields `number`).
+// @ts-expect-error — `next` yields `number`, not `string`
+export const recWrongResponse = { cases: [{ name: "x", before: {}, args: { by: 1 }, responses: { logger: { next: ["nope"] } }, after: { count: 1 } }] };
+// POSITIVE — a `throws` case (no `after`/`effects`/`responses`).
+export const recThrows = { cases: [{ name: "x", before: {}, args: { by: 1 }, throws: "boom" }] };
+// NEGATIVE — `after` and `throws` are mutually exclusive.
+// @ts-expect-error — a case is either an `after` expectation or a `throws`, never both
+export const recBoth = { cases: [{ name: "x", before: {}, args: { by: 1 }, after: { count: 1 }, throws: true }] };
+export const resetOk = resetCases;
+export const asyncOk = asyncCases;
+// POSITIVE — derivations returning an array (also a hydration key), a set, and a scalar.
+export const arrOk = listFoosCases;
+export const setOk = idsCases;
+export const scalarOk = totalCases;
+// NEGATIVE — wrong-arm annotation, caught by the envelope's content (not its arity).
+// @ts-expect-error — a transition envelope cannot hold derivation-shaped `{ input, value }` cases
+export const wrongTransition = { cases: [{ name: "x", input: { count: 0 }, value: 0 }] };
+// @ts-expect-error — a derivation envelope cannot hold transition-shaped `{ before, after }` cases
+export const wrongDerivation = { cases: [{ name: "x", before: {}, after: { count: 1 } }] };
+// NEGATIVE — mis-pairing an array-derivation module into a transition fn's slot, caught
+// by the `ReturnType`/args mismatch inside the envelope generics.
+// @ts-expect-error — a derivation module for `listFoos` is not a valid case module for the transition `bump`
+export const mispair = listFoosCases;
+export const residualGap = resetCases;
+// ── `computedPlugin` requiredness (needed iff the manifest has a derivation) ─────────
+// `fns` above has `listFoos` (a derivation), so `ok` (which includes `computedPlugin`)
+// is the POSITIVE. NEGATIVE — omit it with a derivation present:
+// @ts-expect-error — `computedPlugin` is required because `listFoos` is a derivation
+export const missingComputedPlugin = implementation(specOf({ state, fns, cases: { bump: bumpCases, listFoos: listFoosCases } }), { plugin, projection, hydrate: ["listFoos"] });
+// POSITIVE — a transition-only feature may omit `computedPlugin` (no derivations).
+const txFns = { bump };
+export const noComputedOk = implementation(specOf({ state, fns: txFns, cases: { bump: txCases } }), { plugin, projection });
+const svcFns = { record };
+// POSITIVE — the injected service `logger` has a template.
+export const servicesOk = implementation(specOf({ state, fns: svcFns, services: { logger: () => logger }, cases: { record: recordCases } }), { plugin, projection });
+// NEGATIVE — a fn injects `logger`, but `services` is omitted (today: a runtime crash).
+// @ts-expect-error — `services` is required because `record` injects `logger`
+export const missingServices = implementation(specOf({ state, fns: svcFns, cases: { record: recordCases } }), { plugin, projection });
+// NEGATIVE — `services` omits the required `logger` template.
+// @ts-expect-error — `services` is missing the `logger` template
+export const incompleteServices = implementation(specOf({ state, fns: svcFns, services: {}, cases: { record: recordCases } }), { plugin, projection });
+// NEGATIVE — a service-free feature must not carry dead templates.
+// @ts-expect-error — `bump` injects no service, so `services` must be absent
+export const extraServices = implementation(specOf({ state, fns: txFns, services: { logger: () => logger }, cases: { bump: txCases } }), { plugin, projection });
+//# sourceMappingURL=manifest.type-test.js.map