@adobe/data-testing 0.10.19 → 0.10.20

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

@@ -0,0 +1,8 @@
+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 {};

package/dist/conformance/adapt-spec.js

@@ -0,0 +1,45 @@
+import { buildDouble } from "./build-double.js";
+// Synthesize this case's recording doubles from the feature's shape-only `services`
+// templates and the case's `responses`, then merge them into `args` where the
+// transform expects each injected service. ALL registered services are injected (a
+// superset): a service a transform calls but the case neither schedules nor asserts
+// must still be present, and an unused one is harmless (its recorded calls aren't
+// asserted). The test-only `responses` channel is dropped — it is not a fn arg.
+const injectDoubles = (testCase, services) => {
+    const responses = testCase["responses"];
+    const args = testCase["args"];
+    const built = {};
+    for (const [name, template] of Object.entries(services)) {
+        built[name] = buildDouble(template, responses?.[name]);
+    }
+    const { responses: _responses, args: _args, ...rest } = testCase;
+    return { ...rest, args: { ...built, ...(args ?? {}) } };
+};
+// Adapt a manifest's `{ fns, cases }` into the `transitions` map shape the
+// discovery-based runners (`runSpec` / `runFeature`) already consume: one entry per
+// fn, `{ [fnName]: fn, cases: <envelope> }`. Derivation modules pass through as
+// `{ cases }`; transition modules keep their optional `args` schema, and — when
+// `injectServices` — gain per-case recording doubles in `args`. This is the entire
+// bridge from inert, data-only cases to the unchanged runners: the pure spec and the
+// ecs action side adapt WITH services (each side builds its own fresh doubles, so
+// their FIFO schedules never cross); the ecs transaction side adapts WITHOUT (a
+// transaction is a pure store mutation and never receives services).
+export const adaptCases = (fns, cases, services, injectServices) => {
+    const out = {};
+    for (const [name, fn] of Object.entries(fns)) {
+        const module = cases[name];
+        const list = module.cases;
+        const first = list[0];
+        if (first !== undefined && "value" in first) {
+            out[`./${name}`] = { [name]: fn, cases: { cases: list } };
+            continue;
+        }
+        const adapted = injectServices && services ? list.map((testCase) => injectDoubles(testCase, services)) : list;
+        out[`./${name}`] = {
+            [name]: fn,
+            cases: module.args ? { args: module.args, cases: adapted } : { cases: adapted },
+        };
+    }
+    return out;
+};
+//# sourceMappingURL=adapt-spec.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,2 @@
+export type Schedule = Readonly<Record<string, readonly unknown[]>>;
+export declare const buildDouble: (template: () => object, responses: Schedule | undefined) => object;

package/dist/conformance/build-double.js

@@ -0,0 +1,32 @@
+// © 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).
+//
+// 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.
+export const buildDouble = (template, responses) => {
+    const shape = template();
+    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
+        : [
+            key,
+            (..._args) => {
+                const queue = queues.get(key);
+                if (!queue)
+                    return undefined; // void method, or an unscheduled call
+                if (queue.length === 0)
+                    throw new Error(`response schedule exhausted for "${key}"`);
+                return queue.shift();
+            },
+        ]));
+};
+//# sourceMappingURL=build-double.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,42 @@
+import type { Database } from "@adobe/data/ecs";
+import type { MatchOptions } from "../match/match.js";
+import type { CaseModule, HasDerivations, HydrateExact, HydrationKeys, ProjectionShape, ProjectionStore, ProjectionValue, RequiredServices } from "./feature-types.js";
+import type { Projection } from "./run-feature.js";
+import type { SchemaSource } from "./refify.js";
+type AnyFn = (...args: never[]) => unknown;
+export interface FeatureSpec<State extends object, Fns extends Record<string, AnyFn>, StoreT> {
+    readonly state: {
+        create(): State;
+        readonly samples?: readonly State[];
+    };
+    readonly fns: Fns;
+    readonly cases: {
+        readonly [K in keyof Fns]: CaseModule<State, Fns[K]>;
+    };
+    readonly services?: Readonly<Record<string, () => object>>;
+    readonly plugin: Database.Plugin;
+    readonly computedPlugin?: Database.Plugin;
+    readonly projection: Projection<StoreT, State>;
+    readonly hydrate?: readonly string[];
+    readonly match?: MatchOptions;
+    readonly ops?: {
+        readonly transactions?: Record<string, unknown>;
+        readonly actions?: Record<string, unknown>;
+        readonly computeds?: Record<string, unknown>;
+    };
+}
+export declare const feature: <State extends object, Fns extends Record<string, AnyFn>, P extends ProjectionShape<State>, C extends { readonly [K in keyof Fns]: CaseModule<State, Fns[K]>; }, const H extends readonly Extract<keyof Fns, string>[] = readonly []>(spec: Omit<FeatureSpec<State, Fns, ProjectionStore<P>>, "projection" | "cases" | "hydrate" | "services" | "computedPlugin"> & {
+    readonly projection: P;
+    readonly cases: C;
+    readonly hydrate?: H;
+} & RequiredServices<Fns> & (HasDerivations<C> extends true ? {
+    readonly computedPlugin: Database.Plugin;
+} : {
+    readonly computedPlugin?: Database.Plugin;
+}) & ([Exclude<keyof C, keyof Fns>] extends [never] ? unknown : {
+    readonly __casesError: "a case module names something that is not a conformed fn";
+    readonly extra: Exclude<keyof C, keyof Fns>;
+}) & HydrateExact<H, HydrationKeys<Fns, ProjectionValue<P>>>) => FeatureSpec<State, Fns, ProjectionStore<P>>;
+export declare const checkSpec: <State extends object, Fns extends Record<string, AnyFn>, StoreT>(spec: FeatureSpec<State, Fns, StoreT>) => void;
+export declare const checkFeature: <State extends object, Fns extends Record<string, AnyFn>, StoreT extends SchemaSource>(spec: FeatureSpec<State, Fns, StoreT>) => void;
+export {};

package/dist/conformance/feature-spec.js

@@ -0,0 +1,53 @@
+import { runSpec } from "./run-spec.js";
+import { runFeature } from "./run-feature.js";
+import { adaptCases } from "./adapt-spec.js";
+// Author a feature's conformance manifest. Purely a typed identity — it exists so the
+// generics infer from the argument and arm the compile-time guards. `P` (projection)
+// and `C` (the concrete case modules) are captured, not widened, so their real types
+// feed the checks:
+//   • `cases` coverage — `C extends { [K in keyof Fns]: CaseModule }` requires a module
+//     for every fn (missing → error); the `NoExtraCases` factor rejects a module whose
+//     key is not a fn (extra → error).
+//   • `hydrate` exactness — must be EXACTLY the entity-list derivations (`HydrateExact`).
+//   • `services` requiredness — exactly the injected-service keys the fns declare, or
+//     absent when none (`RequiredServices`); a missing template is a compile error, not
+//     a runtime crash.
+//   • `computedPlugin` requiredness — required when any authored case module is a
+//     derivation (`HasDerivations<C>`), so a feature with derivations can't silently skip
+//     its computed conformance by omitting the plugin.
+export const feature = (spec) => 
+// Runtime invariant the checker can't see: the constrained param IS this FeatureSpec
+// (`P` widens to the stored `Projection`, `C` to the `cases` mapped type, `H` to
+// `readonly string[]`, the fake factories to `() => object`). The several requiredness
+// factors are compile-only phantoms with no runtime shape, and together they defeat
+// TS's structural-overlap check for a direct `as`, so this goes through `unknown`.
+spec;
+// The pure-spec suite for a manifest: adapt the inert cases into the discovery map
+// `runSpec` consumes — WITH freshly-built recording doubles merged into each case's
+// args from the `services` templates + `responses` — and run it unchanged. This
+// test file's doubles are its own, independent of the ecs side's.
+export const checkSpec = (spec) => {
+    runSpec({
+        state: spec.state,
+        transitions: adaptCases(spec.fns, spec.cases, spec.services, true),
+        plugin: spec.plugin,
+        match: spec.match,
+    });
+};
+// The ecs conformance suite for a manifest: the same adapted, doubles-injected map
+// drives `runFeature` unchanged (transactions ignore the injected services; only the
+// actions consume each case's response schedule, exactly once). Fresh doubles again,
+// so the pure and ecs runs never share FIFO state.
+export const checkFeature = (spec) => {
+    runFeature({
+        state: spec.state,
+        transitions: adaptCases(spec.fns, spec.cases, spec.services, true),
+        plugin: spec.plugin,
+        computedPlugin: spec.computedPlugin,
+        projection: spec.projection,
+        hydrate: spec.hydrate,
+        match: spec.match,
+        ops: spec.ops,
+    });
+};
+//# sourceMappingURL=feature-spec.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-spec.js","sourceRoot":"","sources":["../../src/conformance/feature-spec.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAmC7C,sFAAsF;AACtF,qFAAqF;AACrF,qFAAqF;AACrF,mBAAmB;AACnB,wFAAwF;AACxF,uFAAuF;AACvF,uCAAuC;AACvC,0FAA0F;AAC1F,sFAAsF;AACtF,wFAAwF;AACxF,uBAAuB;AACvB,kFAAkF;AAClF,0FAA0F;AAC1F,uDAAuD;AACvD,MAAM,CAAC,MAAM,OAAO,GAAG,CAOrB,IASyD,EACZ,EAAE;AAC/C,qFAAqF;AACrF,iFAAiF;AACjF,uFAAuF;AACvF,oFAAoF;AACpF,mFAAmF;AACnF,IAA8D,CAAC;AAEjE,mFAAmF;AACnF,oFAAoF;AACpF,gFAAgF;AAChF,kEAAkE;AAClE,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,IAAqC,EAC/B,EAAE;IACR,OAAO,CAAC;QACN,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,WAAW,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC;QAClE,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,KAAK,EAAE,IAAI,CAAC,KAAK;KAClB,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,mFAAmF;AACnF,qFAAqF;AACrF,qFAAqF;AACrF,mDAAmD;AACnD,MAAM,CAAC,MAAM,YAAY,GAAG,CAC1B,IAAqC,EAC/B,EAAE;IACR,UAAU,CAAmC;QAC3C,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,WAAW,EAAE,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC;QAClE,MAAM,EAAE,IAAI,CAAC,MAAM;QACnB,cAAc,EAAE,IAAI,CAAC,cAAc;QACnC,UAAU,EAAE,IAAI,CAAC,UAAU;QAC3B,OAAO,EAAE,IAAI,CAAC,OAAO;QACrB,KAAK,EAAE,IAAI,CAAC,KAAK;QACjB,GAAG,EAAE,IAAI,CAAC,GAAG;KACd,CAAC,CAAC;AACL,CAAC,CAAC"}

package/dist/conformance/feature-spec.type-test.d.ts

@@ -0,0 +1,111 @@
+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("./feature-spec.js").FeatureSpec<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("./feature-spec.js").FeatureSpec<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("./feature-spec.js").FeatureSpec<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("./feature-spec.js").FeatureSpec<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("./feature-spec.js").FeatureSpec<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("./feature-spec.js").FeatureSpec<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("./feature-spec.js").FeatureSpec<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const servicesOk: import("./feature-spec.js").FeatureSpec<State, {
+    record: (s: Pick<State, "count">, args: {
+        readonly by: number;
+        readonly logger: Logger;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const missingServices: import("./feature-spec.js").FeatureSpec<State, {
+    record: (s: Pick<State, "count">, args: {
+        readonly by: number;
+        readonly logger: Logger;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const incompleteServices: import("./feature-spec.js").FeatureSpec<State, {
+    record: (s: Pick<State, "count">, args: {
+        readonly by: number;
+        readonly logger: Logger;
+    }) => Pick<State, "count">;
+}, Store>;
+export declare const extraServices: import("./feature-spec.js").FeatureSpec<State, {
+    bump: (s: Pick<State, "count">, args: {
+        readonly by: number;
+    }) => Pick<State, "count">;
+}, Store>;
+export {};

package/dist/conformance/feature-spec.type-test.js

@@ -0,0 +1,95 @@
+import { feature } from "./feature-spec.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 = feature({ state, fns, plugin, computedPlugin, projection, hydrate: ["listFoos"], cases: { bump: bumpCases, listFoos: listFoosCases } });
+// NEGATIVE (cases coverage) — a conformed fn with no case module.
+// @ts-expect-error — `cases` is missing `listFoos`
+export const missingCase = feature({ state, fns, plugin, computedPlugin, projection, hydrate: ["listFoos"], cases: { bump: bumpCases } });
+// 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 = feature({ state, fns, plugin, computedPlugin, projection, hydrate: ["listFoos"], cases: { bump: bumpCases, listFoos: listFoosCases, bogus: bumpCases } });
+// 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 = feature({ state, fns, plugin, computedPlugin, projection, hydrate: [], cases: { bump: bumpCases, listFoos: listFoosCases } });
+// 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 = feature({ state, fns, plugin, computedPlugin, projection, hydrate: ["listFoos", "bump"], cases: { bump: bumpCases, listFoos: listFoosCases } });
+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 = feature({ state, fns, plugin, projection, hydrate: ["listFoos"], cases: { bump: bumpCases, listFoos: listFoosCases } });
+// POSITIVE — a transition-only feature may omit `computedPlugin` (no derivations).
+const txFns = { bump };
+export const noComputedOk = feature({ state, fns: txFns, plugin, projection, cases: { bump: txCases } });
+const svcFns = { record };
+// POSITIVE — the injected service `logger` has a template.
+export const servicesOk = feature({ state, fns: svcFns, plugin, projection, services: { logger: () => logger }, cases: { record: recordCases } });
+// 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 = feature({ state, fns: svcFns, plugin, projection, cases: { record: recordCases } });
+// NEGATIVE — `services` omits the required `logger` template.
+// @ts-expect-error — `services` is missing the `logger` template
+export const incompleteServices = feature({ state, fns: svcFns, plugin, projection, services: {}, cases: { record: recordCases } });
+// 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 = feature({ state, fns: txFns, plugin, projection, services: { logger: () => logger }, cases: { bump: txCases } });
+//# sourceMappingURL=feature-spec.type-test.js.map

package/dist/conformance/feature-spec.type-test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-spec.type-test.js","sourceRoot":"","sources":["../../src/conformance/feature-spec.type-test.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAM5C,sFAAsF;AACtF,qDAAqD;AACrD,MAAM,IAAI,GAAG,CAAC,CAAuB,EAAE,IAA6B,EAAwB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;AAC9H,MAAM,QAAQ,GAAG,CAAC,CAA0B,EAAkB,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;AAC1F,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAS/B,oFAAoF;AACpF,wEAAwE;AACxE,MAAM,UAAU,GAAG;IACjB,SAAS,EAAE,CAAC,MAAa,EAAE,EAAS,EAAQ,EAAE,GAAE,CAAC;IACjD,OAAO,EAAE,CAAC,MAAa,EAAS,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,GAAG,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IACtE,MAAM,EAAE,CAAC,MAAa,EAAE,EAAU,EAAO,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;CAC3D,CAAC;AAEF,MAAM,SAAS,GAAkC;IAC/C,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;CAC7E,CAAC;AACF,MAAM,aAAa,GAAqC;IACtD,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,QAAQ,EAAE,IAAI,GAAG,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;CACtE,CAAC;AAEF,uFAAuF;AACvF,MAAM,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;AAE1J,kEAAkE;AAClE,mDAAmD;AACnD,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;AAE1I,mFAAmF;AACnF,gEAAgE;AAChE,MAAM,CAAC,MAAM,SAAS,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;AAEnL,kFAAkF;AAClF,gFAAgF;AAChF,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;AAE5J,2EAA2E;AAC3E,2EAA2E;AAC3E,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;AAQ5K,MAAM,MAAM,GAAG,CAAC,CAAuB,EAAE,IAAsD,EAAwB,EAAE,CAAC,CAAC;IACzH,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,IAAI,CAAC,EAAE,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;CACrD,CAAC,CAAC;AAEH,yFAAyF;AACzF,qEAAqE;AACrE,MAAM,CAAC,MAAM,KAAK,GAAoC;IACpD,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,CAAC;CACrJ,CAAC;AAEF,qEAAqE;AACrE,yEAAyE;AACzE,MAAM,CAAC,MAAM,iBAAiB,GAAoC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AAE3J,0CAA0C;AAC1C,yDAAyD;AACzD,MAAM,CAAC,MAAM,aAAa,GAAoC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AAEpI,sFAAsF;AACtF,0EAA0E;AAC1E,MAAM,CAAC,MAAM,eAAe,GAAoC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AAEpL,sFAAsF;AACtF,0DAA0D;AAC1D,MAAM,CAAC,MAAM,gBAAgB,GAAoC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AAEzL,iEAAiE;AACjE,MAAM,CAAC,MAAM,SAAS,GAAoC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC;AAElI,0DAA0D;AAC1D,uFAAuF;AACvF,MAAM,CAAC,MAAM,OAAO,GAAoC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;AAWnJ,MAAM,CAAC,MAAM,OAAO,GAAoC,UAAU,CAAC;AAMnE,MAAM,CAAC,MAAM,OAAO,GAAwC,UAAU,CAAC;AAEvE,yFAAyF;AACzF,MAAM,CAAC,MAAM,KAAK,GAAuC,aAAa,CAAC;AAGvE,MAAM,CAAC,MAAM,KAAK,GAAoC,QAAQ,CAAC;AAG/D,MAAM,CAAC,MAAM,QAAQ,GAAoC,UAAU,CAAC;AAEpE,qFAAqF;AACrF,kGAAkG;AAClG,MAAM,CAAC,MAAM,eAAe,GAAmC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;AACzH,mGAAmG;AACnG,MAAM,CAAC,MAAM,eAAe,GAAkC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;AAE1H,wFAAwF;AACxF,kEAAkE;AAClE,6GAA6G;AAC7G,MAAM,CAAC,MAAM,OAAO,GAAmC,aAAa,CAAC;AAOrE,MAAM,CAAC,MAAM,WAAW,GAAoC,UAAU,CAAC;AAEvE,wFAAwF;AACxF,uFAAuF;AACvF,iEAAiE;AACjE,qFAAqF;AACrF,MAAM,CAAC,MAAM,qBAAqB,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC,UAAU,CAAC,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,aAAa,EAAE,EAAE,CAAC,CAAC;AAE7J,mFAAmF;AACnF,MAAM,KAAK,GAAG,EAAE,IAAI,EAAE,CAAC;AAEvB,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;AAIzG,MAAM,MAAM,GAAG,EAAE,MAAM,EAAE,CAAC;AAG1B,2DAA2D;AAC3D,MAAM,CAAC,MAAM,UAAU,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;AAElJ,wFAAwF;AACxF,8EAA8E;AAC9E,MAAM,CAAC,MAAM,eAAe,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;AAEnH,8DAA8D;AAC9D,iEAAiE;AACjE,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,EAAE,KAAK,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;AAEpI,mEAAmE;AACnE,6EAA6E;AAC7E,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,95 @@
+import type { Schema } from "@adobe/data/schema";
+import type { Effects } from "./types.js";
+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;
+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> = {
+    [M in keyof S]-?: S[M] extends (...a: never[]) => infer R ? ([Payload<R>] extends [void] ? never : M) : never;
+}[keyof S];
+type ServiceResponses<S> = {
+    readonly [M in ValueMethodKeys<S>]?: ScheduleOf<S[M]>;
+};
+export type Responses<Args> = {
+    readonly [K in keyof Args as IsService<Args[K]> extends true ? K : never]?: ServiceResponses<Args[K]>;
+};
+type DataArgKeys<Args> = {
+    [K in keyof Args]-?: IsService<Args[K]> extends true ? never : K;
+}[keyof Args];
+type DataArgs<Args> = Pick<Args, DataArgKeys<Args>>;
+export type SpecCase<State, Args> = ({
+    readonly name: string;
+    readonly before: Partial<State>;
+} & ({
+    readonly after: Partial<State>;
+    readonly effects?: Effects<Args>;
+    readonly responses?: Responses<Args>;
+    readonly throws?: undefined;
+} | {
+    readonly throws: true | string;
+    readonly after?: undefined;
+    readonly effects?: undefined;
+    readonly responses?: undefined;
+})) & ([keyof DataArgs<Args>] extends [never] ? {
+    readonly args?: undefined;
+} : {
+    readonly args: DataArgs<Args>;
+});
+export type SpecDerivationCase<Input, Value> = {
+    readonly name: string;
+    readonly input: Input;
+    readonly value: Value;
+};
+export type SpecCases<State, F extends (...a: never[]) => unknown> = {
+    readonly args?: Schema;
+    readonly cases: readonly SpecCase<State, ArgsOf<F>>[];
+};
+export type SpecDerivations<F extends (...a: never[]) => unknown> = {
+    readonly cases: readonly SpecDerivationCase<Parameters<F>[0], ReturnType<F>>[];
+};
+export type ProjectionValue<P> = P extends {
+    toData?: (store: never, entity: never) => infer V;
+} ? V : never;
+export type ProjectionStore<P> = P extends {
+    toState: (store: infer S) => unknown;
+} ? S : unknown;
+export type ProjectionShape<State> = {
+    readonly fromState: (store: never, state: State) => unknown;
+    readonly toState: (store: never) => State;
+    readonly toData?: (store: never, entity: never) => unknown;
+};
+export type HydrationKeys<Fns, V> = [V] extends [never] ? never : {
+    [K in keyof Fns]: Fns[K] extends (...a: never[]) => infer R ? [R] extends [readonly V[]] ? K & string : [R] extends [ReadonlySet<V>] ? K & string : never : never;
+}[keyof Fns];
+export type HydrateExact<Provided extends readonly string[], Required extends string> = [
+    Exclude<Required, Provided[number]>
+] extends [never] ? [Exclude<Provided[number], Required>] extends [never] ? unknown : {
+    readonly __hydrateError: "hydrate lists a computed that does not need hydration";
+    readonly unexpected: Exclude<Provided[number], Required>;
+} : {
+    readonly __hydrateError: "hydrate is missing required entity-list computed(s)";
+    readonly missing: Exclude<Required, Provided[number]>;
+};
+export type ServiceArgKeys<Fns> = {
+    [K in keyof Fns]: {
+        [A in keyof ArgsOf<Fns[K]>]-?: IsService<ArgsOf<Fns[K]>[A]> extends true ? A : never;
+    }[keyof ArgsOf<Fns[K]>];
+}[keyof Fns] & string;
+export type ServiceForKey<Fns, K extends string> = {
+    [F in keyof Fns]: K extends keyof ArgsOf<Fns[F]> ? ArgsOf<Fns[F]>[K] : never;
+}[keyof Fns];
+export type RequiredServices<Fns> = [ServiceArgKeys<Fns>] extends [never] ? {
+    readonly services?: undefined;
+} : {
+    readonly services: {
+        readonly [K in ServiceArgKeys<Fns>]: () => ServiceForKey<Fns, K>;
+    };
+};
+export type HasDerivations<Cases> = true extends {
+    [K in keyof Cases]: Cases[K] extends SpecDerivations<(...a: never[]) => unknown> ? true : false;
+}[keyof Cases] ? true : false;
+export type CaseModule<State, F extends (...a: never[]) => unknown> = SpecCases<State, F> | SpecDerivations<F>;
+export {};

package/dist/conformance/feature-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=feature-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feature-types.js","sourceRoot":"","sources":["../../src/conformance/feature-types.ts"],"names":[],"mappings":""}

package/dist/conformance/public.d.ts

@@ -1,10 +1,11 @@
-export type { Case, Cases, DerivationCase, DerivationCases, Effects, ServiceCall } from "./types.js";
-export { casesBuilder, derivationsBuilder, type CasesBuilder, type CasesResult, type DerivationsBuilder, type DerivationsResult, } from "./cases.js";
-export { runSpec, type SpecRunConfig } from "./run-spec.js";
+export { feature, checkSpec, checkFeature, type FeatureSpec } from "./feature-spec.js";
+export type { Responses, SpecCase, SpecCases, SpecDerivationCase, SpecDerivations, CaseModule, } from "./feature-types.js";
+export type { Effects, ServiceCall } from "./types.js";
+export { adaptCases } from "./adapt-spec.js";
 export { runTransactions, type TransactionRunConfig } from "./run-transactions.js";
 export { runActions, type ActionRunConfig } from "./run-actions.js";
 export { runComputeds, type ComputedRunConfig } from "./run-computeds.js";
-export { runFeature, type FeatureRunConfig, type Projection } from "./run-feature.js";
+export type { Projection } from "./run-feature.js";
 export { assertState } from "./assert-state.js";
 export { expectThrows } from "./expect-throws.js";
 export type { SchemaSource } from "./refify.js";

package/dist/conformance/public.js

@@ -1,13 +1,16 @@
-export { casesBuilder, derivationsBuilder, } from "./cases.js";
-export { runSpec } from "./run-spec.js";
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+// The conformance manifest API — the standard surface. `feature` builds a feature's
+// manifest; `checkSpec` runs the pure spec suite, `checkFeature` the ecs suite.
+export { feature, checkSpec, checkFeature } from "./feature-spec.js";
+// The escape hatch — the lower-level runners, for a feature whose ecs conformance needs
+// per-surface `seedContext` or a custom concurrency/db (e.g. a user-scoped `userId`); it
+// feeds them from its manifest with `adaptCases`. Ordinary features use `checkFeature`.
+export { adaptCases } from "./adapt-spec.js";
 export { runTransactions } from "./run-transactions.js";
 export { runActions } from "./run-actions.js";
 export { runComputeds } from "./run-computeds.js";
-export { runFeature } from "./run-feature.js";
-// For custom conformance harnesses (e.g. an ECS-system frame): compare two States
-// up to an id-bijection, the same way the runners do.
+// For custom conformance harnesses: compare two States up to an id-bijection, and assert
+// a call throws, the same way the built-in runners do.
 export { assertState } from "./assert-state.js";
-// For custom conformance harnesses: assert a call throws, the same way a case's
-// `throws` field does in the built-in runners.
 export { expectThrows } from "./expect-throws.js";
 //# sourceMappingURL=public.js.map

package/dist/conformance/public.js.map

@@ -1 +1 @@
-{"version":3,"file":"public.js","sourceRoot":"","sources":["../../src/conformance/public.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,YAAY,EACZ,kBAAkB,GAKnB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,OAAO,EAAsB,MAAM,eAAe,CAAC;AAC5D,OAAO,EAAE,eAAe,EAA6B,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,UAAU,EAAwB,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,YAAY,EAA0B,MAAM,oBAAoB,CAAC;AAC1E,OAAO,EAAE,UAAU,EAA0C,MAAM,kBAAkB,CAAC;AACtF,kFAAkF;AAClF,sDAAsD;AACtD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,gFAAgF;AAChF,+CAA+C;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"public.js","sourceRoot":"","sources":["../../src/conformance/public.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,oFAAoF;AACpF,gFAAgF;AAChF,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAoB,MAAM,mBAAmB,CAAC;AAWvF,wFAAwF;AACxF,yFAAyF;AACzF,wFAAwF;AACxF,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,eAAe,EAA6B,MAAM,uBAAuB,CAAC;AACnF,OAAO,EAAE,UAAU,EAAwB,MAAM,kBAAkB,CAAC;AACpE,OAAO,EAAE,YAAY,EAA0B,MAAM,oBAAoB,CAAC;AAG1E,yFAAyF;AACzF,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/conformance/run-spec.empty-cases.test.js

@@ -1,9 +1,9 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Conformance } from "../index.js";
+import { runSpec } from "./run-spec.js";
 // A module whose envelope holds `cases: []` opens an empty `describe` and used to
 // leave the file suite-less. Empty discovery registers a no-op so Vitest still
 // collects a suite.
-Conformance.runSpec({
+runSpec({
     state: { create: () => ({ n: 0 }) },
     transitions: {
         "./empty-cases.ts": {

package/dist/conformance/run-spec.empty-cases.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"run-spec.empty-cases.test.js","sourceRoot":"","sources":["../../src/conformance/run-spec.empty-cases.test.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,kFAAkF;AAClF,+EAA+E;AAC/E,oBAAoB;AACpB,WAAW,CAAC,OAAO,CAAC;IAClB,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;IACnC,WAAW,EAAE;QACX,kBAAkB,EAAE;YAClB,IAAI,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK;YACrC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;SACrB;KACF;CACF,CAAC,CAAC"}
+{"version":3,"file":"run-spec.empty-cases.test.js","sourceRoot":"","sources":["../../src/conformance/run-spec.empty-cases.test.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,kFAAkF;AAClF,+EAA+E;AAC/E,oBAAoB;AACpB,OAAO,CAAC;IACN,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;IACnC,WAAW,EAAE;QACX,kBAAkB,EAAE;YAClB,IAAI,EAAE,CAAC,KAAoB,EAAE,EAAE,CAAC,KAAK;YACrC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE;SACrB;KACF;CACF,CAAC,CAAC"}

package/dist/conformance/run-spec.empty.test.js

@@ -1,10 +1,10 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Conformance } from "../index.js";
+import { runSpec } from "./run-spec.js";
 // Features with empty State and no pure transforms still call `runSpec` from a
 // dedicated `spec.test.ts`. Discovery with zero case modules must not leave the
 // file suite-less (Vitest: "No test suite found"). This file is the regression:
 // it is only this call — if empty discovery failed, vitest would fail the file.
-Conformance.runSpec({
+runSpec({
     state: { create: () => ({}) },
     transitions: {},
 });

package/dist/conformance/run-spec.empty.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"run-spec.empty.test.js","sourceRoot":"","sources":["../../src/conformance/run-spec.empty.test.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,gFAAgF;AAChF,WAAW,CAAC,OAAO,CAAC;IAClB,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE;IAC7B,WAAW,EAAE,EAAE;CAChB,CAAC,CAAC"}
+{"version":3,"file":"run-spec.empty.test.js","sourceRoot":"","sources":["../../src/conformance/run-spec.empty.test.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,gFAAgF;AAChF,OAAO,CAAC;IACN,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE;IAC7B,WAAW,EAAE,EAAE;CAChB,CAAC,CAAC"}

package/dist/conformance/run-spec.test.js

@@ -1,5 +1,5 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
-import { Conformance } from "../index.js";
+import { runSpec } from "./run-spec.js";
 // Non-empty discovery: one pure transition with co-located cases still pairs and
 // asserts as before (empty-discovery path must not break populated specs).
 const increment = (state, { by }) => ({ n: state.n + by });
@@ -9,7 +9,7 @@ const withdraw = (state, { amount }) => {
         throw new Error(`insufficient funds: have ${state.n}, want ${amount}`);
     return { n: state.n - amount };
 };
-Conformance.runSpec({
+runSpec({
     state: { create: () => ({ n: 0 }) },
     transitions: {
         "./increment.ts": {

package/dist/conformance/run-spec.test.js.map

@@ -1 +1 @@
-{"version":3,"file":"run-spec.test.js","sourceRoot":"","sources":["../../src/conformance/run-spec.test.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,iFAAiF;AACjF,2EAA2E;AAC3E,MAAM,SAAS,GAAG,CAChB,KAAoB,EACpB,EAAE,EAAE,EAAkB,EACP,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AAE1C,6EAA6E;AAC7E,MAAM,QAAQ,GAAG,CACf,KAAoB,EACpB,EAAE,MAAM,EAAsB,EACf,EAAE;IACjB,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,KAAK,CAAC,CAAC,UAAU,MAAM,EAAE,CAAC,CAAC;IAC7F,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,WAAW,CAAC,OAAO,CAAC;IAClB,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;IACnC,WAAW,EAAE;QACX,gBAAgB,EAAE;YAChB,SAAS;YACT,iFAAiF;YACjF,wEAAwE;YACxE,KAAK,EAAE;gBACL,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,oCAAoC;wBAC1C,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE;wBACf,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE;qBAChB;oBACD;wBACE,IAAI,EAAE,mCAAmC;wBACzC,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE;wBACf,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;qBACjB;iBACF;aACF;SACF;QACD,eAAe,EAAE;YACf,QAAQ;YACR,KAAK,EAAE;gBACL,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,0BAA0B;wBAChC,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE;wBACnB,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE;qBAChB;oBACD;wBACE,IAAI,EAAE,yCAAyC;wBAC/C,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;wBACpB,MAAM,EAAE,IAAI;qBACb;oBACD;wBACE,IAAI,EAAE,sDAAsD;wBAC5D,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;wBACpB,MAAM,EAAE,oBAAoB;qBAC7B;iBACF;aACF;SACF;KACF;CACF,CAAC,CAAC"}
+{"version":3,"file":"run-spec.test.js","sourceRoot":"","sources":["../../src/conformance/run-spec.test.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,iFAAiF;AACjF,2EAA2E;AAC3E,MAAM,SAAS,GAAG,CAChB,KAAoB,EACpB,EAAE,EAAE,EAAkB,EACP,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;AAE1C,6EAA6E;AAC7E,MAAM,QAAQ,GAAG,CACf,KAAoB,EACpB,EAAE,MAAM,EAAsB,EACf,EAAE;IACjB,IAAI,MAAM,GAAG,KAAK,CAAC,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,4BAA4B,KAAK,CAAC,CAAC,UAAU,MAAM,EAAE,CAAC,CAAC;IAC7F,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,MAAM,EAAE,CAAC;AACjC,CAAC,CAAC;AAEF,OAAO,CAAC;IACN,KAAK,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;IACnC,WAAW,EAAE;QACX,gBAAgB,EAAE;YAChB,SAAS;YACT,iFAAiF;YACjF,wEAAwE;YACxE,KAAK,EAAE;gBACL,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,oCAAoC;wBAC1C,MAAM,EAAE,EAAE;wBACV,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE;wBACf,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE;qBAChB;oBACD;wBACE,IAAI,EAAE,mCAAmC;wBACzC,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,EAAE;wBACf,KAAK,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;qBACjB;iBACF;aACF;SACF;QACD,eAAe,EAAE;YACf,QAAQ;YACR,KAAK,EAAE;gBACL,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,0BAA0B;wBAChC,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE;wBACnB,KAAK,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE;qBAChB;oBACD;wBACE,IAAI,EAAE,yCAAyC;wBAC/C,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;wBACpB,MAAM,EAAE,IAAI;qBACb;oBACD;wBACE,IAAI,EAAE,sDAAsD;wBAC5D,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE;wBACjB,IAAI,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;wBACpB,MAAM,EAAE,oBAAoB;qBAC7B;iBACF;aACF;SACF;KACF;CACF,CAAC,CAAC"}

package/dist/conformance/types.d.ts

@@ -8,28 +8,9 @@ export type ServiceCall<S> = {
 export type Effects<Args> = {
     readonly [K in keyof Args as IsService<Args[K]> extends true ? K : never]?: readonly ServiceCall<Args[K]>[] | ReadonlySet<ServiceCall<Args[K]>>;
 };
-type ArgsOf<F extends (...args: never[]) => unknown> = Parameters<F> extends [unknown, infer Args, ...unknown[]] ? Args : void;
-export type Case<State, Args> = ({
-    readonly name: string;
-    readonly before: Partial<State>;
-} & ({
-    readonly after: Partial<State>;
-    readonly effects?: Effects<Args>;
-    readonly throws?: undefined;
-} | {
-    readonly throws: true | string;
-    readonly after?: undefined;
-    readonly effects?: undefined;
-})) & ([Args] extends [void] ? {
-    readonly args?: undefined;
-} : {
-    readonly args: Args;
-});
-export type Cases<State, F extends (...args: never[]) => unknown> = readonly Case<State, ArgsOf<F>>[];
 export type DerivationCase<Input, Value> = {
     readonly name: string;
     readonly input: Input;
     readonly value: Value;
 };
-export type DerivationCases<F extends (...args: never[]) => unknown> = readonly DerivationCase<Parameters<F>[0], ReturnType<F>>[];
 export {};

package/dist/index.d.ts

@@ -1,3 +1,3 @@
 export * as Match from "./match/public.js";
 export * as Conformance from "./conformance/public.js";
-export type { Case, Cases, CasesResult, DerivationCase, DerivationCases, DerivationsResult, Effects, ServiceCall, } from "./conformance/public.js";
+export type { SpecCase, SpecCases, SpecDerivationCase, SpecDerivations, Responses, CaseModule, FeatureSpec, Effects, ServiceCall, } from "./conformance/public.js";

package/dist/index.js

@@ -1,18 +1,10 @@
 // © 2026 Adobe. MIT License. See /LICENSE for details.
 // Shared test-only utilities for the spec↔ecs conformance pattern. Two namespaces:
 //   Match       — tolerant, matcher-aware value comparison (framework-agnostic).
-//   Conformance — the case types, effect recording, id resolution, and the
-//                 spec/transaction/action/computed runner drivers.
-// Import only from `*.test.ts`. `sideEffects: false` lets a bundler drop an
-// unused *import* of this package, but a co-located `Conformance.cases(fn, …)` /
-// `Conformance.derivations(fn, …)` call in a transform file is still a plain
-// function call — an unannotated call is kept even when its result (the `cases`
-// export) is never read. Every call site MUST be written
-// `/*@__PURE__*/ Conformance.cases(...)` (see `data/state.md`), or the case
-// fixtures — and this package's builder code — ship in the production bundle
-// of any app that actually calls the transition. Verified against a Vite/Rollup
-// production build: without the annotation the case data is retained; with it,
-// gone.
+//   Conformance — the manifest API (`feature` / `checkSpec` / `checkFeature`), the case
+//                 types, and the lower-level runner escape hatch.
+// Import only from a feature's test tier (its `*.cases.ts`, `spec.ts`, `*.fake.ts`, and
+// `*.test.ts`), which the package's project-reference wall keeps out of the runtime build.
 export * as Match from "./match/public.js";
 export * as Conformance from "./conformance/public.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,mFAAmF;AACnF,iFAAiF;AACjF,2EAA2E;AAC3E,mEAAmE;AACnE,4EAA4E;AAC5E,iFAAiF;AACjF,6EAA6E;AAC7E,gFAAgF;AAChF,yDAAyD;AACzD,4EAA4E;AAC5E,6EAA6E;AAC7E,gFAAgF;AAChF,+EAA+E;AAC/E,QAAQ;AACR,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,mFAAmF;AACnF,iFAAiF;AACjF,wFAAwF;AACxF,kEAAkE;AAClE,wFAAwF;AACxF,2FAA2F;AAC3F,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adobe/data-testing",
-  "version": "0.10.19",
+  "version": "0.10.20",
   "description": "Conformance-testing utilities (Match + Conformance runners) for @adobe/data ECS features",
   "type": "module",
   "sideEffects": false,
@@ -15,7 +15,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@adobe/data": "0.10.19"
+    "@adobe/data": "0.10.20"
   },
   "peerDependencies": {
     "vitest": "^1.6.0"