@wardic/test 0.0.0-stage → 1.0.0-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the Wardic contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,14 @@
-# Temporary Holding Version
+# @wardic/test
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Headless testing Layers for [Wardic](https://wardic.dev)'s core and for a new Environment: animation code runs with no page at all.
+
+- `TestClock`: a clock that replays the frames you give it, so every frame's values can be read in turn;
+- `TestRenderer`: a renderer that records what it's asked to draw (`TestRenderer.make()`);
+- `TestInput`: pointer, keyboard and focus input you push;
+- `TestProbe`: the page as you script it: its boxes, viewport, scroll and what's in view.
+
+`TestLive` (or `testLayer(frames)`) is all four together. It draws nothing on a page, and its clock moves only through the frames it's given, so an element rendered under it stays at its starting style. To test an app's components, render them with `DomLive` in jsdom or happy-dom, under your test runner's fake timers: see https://wardic.dev/guides/testing.
+
+- Docs: https://wardic.dev
+- Source: https://github.com/wardiclabs/wardic/tree/main/packages/test
+- Licence: MIT

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,145 @@
+# Third-party notices
+
+Wardic follows the API of [Motion](https://motion.dev) for React, and parts of its source are ported from Motion's: rewritten in Wardic's own style, keeping Motion's algorithms, formulas and constants so the results match. Motion is MIT licensed, and its notice follows.
+
+## Motion
+
+https://github.com/motiondivision/motion
+
+Ported from Motion's source:
+
+- `@wardic/core`:
+  - `Box` and `Projection`: the projection geometry (`motion-dom`'s `projection/geometry`: `models`, `delta-calc`, `delta-apply`, `applyTreeDeltas`);
+  - `Spring`: the solver for a spring's stiffness and damping from its duration and bounce (`findSpring`);
+  - `Velocity`: a gesture's velocity from its points (`getVelocity`);
+  - `Reorder`: moving an item, and the axis a list runs on (`moveItem`, `detectAxis`);
+  - `AutoScroll`: scrolling a container while an item is dragged near its edge (`autoScrollIfNeeded`).
+- `@wardic/dom`:
+  - the projection transform (`buildProjectionTransform`);
+  - the scroll offsets (`render/dom/scroll/offsets`).
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2024 [Motion](https://motion.dev) B.V.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Manrope
+
+https://github.com/googlefonts/manrope
+
+The docs site serves Manrope for its headings (`site/public/fonts/manrope-latin.woff2`, its variable weights 600 to 800, Latin only, with its licence beside it as `OFL.txt`), and Wardic's wordmark is "wardic" set in Manrope ExtraBold and outlined (`brand/`, and the docs header's logo, `site/src/components/logo-paths.ts`). Manrope is licensed under the SIL Open Font License, Version 1.1.
+
+```
+Copyright 2018 The Manrope Project Authors (https://github.com/googlefonts/manrope)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+```

package/dist/clock.d.ts

@@ -0,0 +1,55 @@
+import * as Clock from "@wardic/core/Clock";
+import * as RefreshFrameSource from "@wardic/core/RefreshFrameSource";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * A deterministic Clock for frame-level tests. `ticks` replays the supplied `dt`
+ * sequence (in seconds) exactly once, so a primitive's per-frame output can be
+ * collected with `Stream.runCollect` and asserted. Its `now` is the time those
+ * ticks have reached, in ms, from 0: the furthest any subscriber has
+ * reached, so two subscribers replaying the same frames don't run it twice as
+ * fast. A live Clock (rAF-driven) is `@wardic/dom`'s.
+ */
+export declare const make: (frames?: ReadonlyArray<number>) => Clock.Clock["Service"];
+/** Clock Layer that emits `frames` (dt values, seconds) then completes. */
+export declare const layer: (frames?: ReadonlyArray<number>) => Layer.Layer<Clock.Clock>;
+/**
+ * Convenience: `n` frames of a fixed `dt` (default 1/60s) — e.g. `frames(30)`
+ * for half a second at 60fps.
+ */
+export declare const frames: (count: number, dt?: number) => ReadonlyArray<number>;
+/**
+ * A push-based Clock for tests that need to advance frames *on demand* —
+ * interleaved with pointer input — rather than replaying a fixed sequence. The
+ * static {@link layer} drains its whole `ticks` stream as fast as the consumer
+ * pulls, which makes it impossible to assert "advance a few frames, do
+ * something, advance more". This form lets the test `advance` one dt at a time.
+ *
+ * Backed by a `PubSub` (broadcast, no replay) so a consumer only sees ticks
+ * pushed *after* it subscribes — matching a live rAF clock where motion starts
+ * from the moment you subscribe. It has no Cold start: its ticks are the advances.
+ *
+ * Its `layer` also provides the Environment's `RefreshFrameSource`, and one `advance`
+ * is one Refresh frame in the web's order: it runs the frames requested so far (a flush gate's
+ * flush of a write made outside a tick), in request order, then publishes `dt` (the Clock's
+ * tick, at whose end a Frame loop over this Clock calls its `afterTick` hooks: the gate's
+ * flush). A frame requested during that `advance` waits for the next one. The frames'
+ * timestamps start at 0 and advance by `dt`, and the Clock's `now` is the last one's: a test's
+ * advances drive velocities too.
+ *
+ * It doesn't yield: a subscriber waiting on the ticks handles the tick inside the
+ * publish, as every subscriber does inside a real Refresh frame's callback, so a consumer that
+ * hops through Effect's scheduler on its way to its sink hasn't got there when `advance`
+ * returns, and its test sees it.
+ *
+ * @example
+ * const clock = yield* TestClock.pushable()
+ * // … fork a stream that consumes Clock.ticks, providing clock.layer …
+ * yield* clock.advance()        // one 1/60s frame
+ * yield* clock.advance(1 / 30)  // a custom dt
+ */
+export declare const pushable: () => Effect.Effect<{
+    readonly layer: Layer.Layer<Clock.Clock | RefreshFrameSource.RefreshFrameSource>;
+    readonly advance: (dt?: number) => Effect.Effect<void>;
+}>;
+//# sourceMappingURL=clock.d.ts.map

package/dist/clock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clock.d.ts","sourceRoot":"","sources":["../src/clock.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,oBAAoB,CAAA;AAC3C,OAAO,KAAK,kBAAkB,MAAM,iCAAiC,CAAA;AAErE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAOrC;;;;;;;GAOG;AAEH,eAAO,MAAM,IAAI,YAAY,aAAa,CAAC,MAAM,CAAC,KAAQ,KAAK,CAAC,KAAK,CAAC,SAAS,CAa9E,CAAA;AAED,2EAA2E;AAC3E,eAAO,MAAM,KAAK,YAAY,aAAa,CAAC,MAAM,CAAC,KAAQ,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAErC,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,MAAM,UAAW,MAAM,kBAAgB,aAAa,CAAC,MAAM,CAC/B,CAAA;AAkCzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,eAAO,MAAM,QAAQ,EAAE,MAAM,MAAM,CAAC,MAAM,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,GAAG,kBAAkB,CAAC,kBAAkB,CAAC,CAAA;IAChF,QAAQ,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CACvD,CAoBG,CAAA"}

package/dist/clock.js

@@ -0,0 +1,119 @@
+import * as Clock from "@wardic/core/Clock";
+import * as RefreshFrameSource from "@wardic/core/RefreshFrameSource";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import { constVoid } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as MutableRef from "effect/MutableRef";
+import * as Predicate from "effect/Predicate";
+import * as PubSub from "effect/PubSub";
+import * as Stream from "effect/Stream";
+import * as UndefinedOr from "effect/UndefinedOr";
+/**
+ * A deterministic Clock for frame-level tests. `ticks` replays the supplied `dt`
+ * sequence (in seconds) exactly once, so a primitive's per-frame output can be
+ * collected with `Stream.runCollect` and asserted. Its `now` is the time those
+ * ticks have reached, in ms, from 0: the furthest any subscriber has
+ * reached, so two subscribers replaying the same frames don't run it twice as
+ * fast. A live Clock (rAF-driven) is `@wardic/dom`'s.
+ */
+// `now`: #460.
+export const make = (frames = []) => {
+    const time = MutableRef.make(0);
+    // Each frame with the time it reaches, in ms from 0 (#618, decision 7: each subscriber added its
+    // frames to one sum).
+    const reached = Arr.zip(frames, Arr.drop(Arr.scan(frames, 0, (at, dt) => at + dt * 1000), 1));
+    return {
+        ticks: Stream.map(Stream.fromIterable(reached), ([dt, at]) => {
+            MutableRef.update(time, (t) => Math.max(t, at));
+            return dt;
+        }),
+        tick: (_t) => Effect.sync(() => { }),
+        now: () => MutableRef.get(time),
+    };
+};
+/** Clock Layer that emits `frames` (dt values, seconds) then completes. */
+export const layer = (frames = []) => 
+// A Clock per build: one Layer built twice shares no time (#618).
+Layer.sync(Clock.Clock, () => make(frames));
+/**
+ * Convenience: `n` frames of a fixed `dt` (default 1/60s) — e.g. `frames(30)`
+ * for half a second at 60fps.
+ */
+export const frames = (count, dt = 1 / 60) => Array.from({ length: count }, () => dt);
+/**
+ * The Refresh frames `pushable`'s `advance` fires: a `RefreshFrameSource` that keeps the
+ * contract's order rules, as `requestAnimationFrame` does (ADR-0031, decision 4). `fire` runs the
+ * callbacks requested before it, in request order. One requested while they run waits for the
+ * next `fire`, and one cancelled before its turn never runs.
+ */
+const makeFrames = () => {
+    const pending = new Map();
+    const nextHandle = MutableRef.make(1);
+    const source = {
+        requestFrame: (callback) => {
+            const handle = MutableRef.getAndIncrement(nextHandle);
+            pending.set(handle, callback);
+            return handle;
+        },
+        cancelFrame: (handle) => {
+            if (Predicate.isNumber(handle))
+                pending.delete(handle);
+        },
+    };
+    /** Run the callbacks requested so far at timestamp `t` (ms). */
+    const fire = (t) => Arr.forEach(Arr.fromIterable(pending.keys()), (handle) => UndefinedOr.match(pending.get(handle), {
+        onUndefined: constVoid,
+        onDefined: (callback) => {
+            pending.delete(handle);
+            callback(t);
+        },
+    }));
+    return { source, fire };
+};
+/**
+ * A push-based Clock for tests that need to advance frames *on demand* —
+ * interleaved with pointer input — rather than replaying a fixed sequence. The
+ * static {@link layer} drains its whole `ticks` stream as fast as the consumer
+ * pulls, which makes it impossible to assert "advance a few frames, do
+ * something, advance more". This form lets the test `advance` one dt at a time.
+ *
+ * Backed by a `PubSub` (broadcast, no replay) so a consumer only sees ticks
+ * pushed *after* it subscribes — matching a live rAF clock where motion starts
+ * from the moment you subscribe. It has no Cold start: its ticks are the advances.
+ *
+ * Its `layer` also provides the Environment's `RefreshFrameSource`, and one `advance`
+ * is one Refresh frame in the web's order: it runs the frames requested so far (a flush gate's
+ * flush of a write made outside a tick), in request order, then publishes `dt` (the Clock's
+ * tick, at whose end a Frame loop over this Clock calls its `afterTick` hooks: the gate's
+ * flush). A frame requested during that `advance` waits for the next one. The frames'
+ * timestamps start at 0 and advance by `dt`, and the Clock's `now` is the last one's: a test's
+ * advances drive velocities too.
+ *
+ * It doesn't yield: a subscriber waiting on the ticks handles the tick inside the
+ * publish, as every subscriber does inside a real Refresh frame's callback, so a consumer that
+ * hops through Effect's scheduler on its way to its sink hasn't got there when `advance`
+ * returns, and its test sees it.
+ *
+ * @example
+ * const clock = yield* TestClock.pushable()
+ * // … fork a stream that consumes Clock.ticks, providing clock.layer …
+ * yield* clock.advance()        // one 1/60s frame
+ * yield* clock.advance(1 / 30)  // a custom dt
+ */
+// The RefreshFrameSource: ADR-0031. The gate's flush at the tick's end: ADR-0033. `now`: #460. No
+// yield: ADR-0032.
+export const pushable = Effect.fnUntraced(function* () {
+    const pubsub = yield* PubSub.unbounded();
+    const frames = makeFrames();
+    const time = MutableRef.make(0);
+    return {
+        layer: Layer.merge(Layer.succeed(Clock.Clock, {
+            ticks: Stream.fromPubSub(pubsub),
+            tick: (_t) => Effect.sync(() => { }),
+            now: () => MutableRef.get(time),
+        }), RefreshFrameSource.layer(frames.source)),
+        advance: (dt = 1 / 60) => Effect.sync(() => frames.fire(MutableRef.updateAndGet(time, (t) => t + dt * 1000))).pipe(Effect.andThen(PubSub.publish(pubsub, dt)), Effect.asVoid),
+    };
+});
+//# sourceMappingURL=clock.js.map

package/dist/clock.js.map

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

package/dist/feeds.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The Test Environment's **Input feeds** (#318): a script replayed to each subscriber, and a hub a
+ * test pushes into.
+ */
+import type * as InputFeed from "@wardic/core/InputFeed";
+import * as Effect from "effect/Effect";
+/**
+ * A fixed script as a feed: each subscriber hears every event as it subscribes, then the end. A
+ * Stream over it (`InputFeed.toStream`) emits the script and ends, as `Stream.fromIterable` did; an
+ * empty one ends at once. Not shared: each subscriber gets the whole script (tests address one
+ * surface, and a consumer may read it twice).
+ */
+export declare const script: <A>(events: ReadonlyArray<A>) => InputFeed.InputFeed<A>;
+/** A live feed a test pushes into, and the push. */
+export interface Hub<A> {
+    readonly feed: InputFeed.InputFeed<A>;
+    readonly push: (event: A) => Effect.Effect<void>;
+}
+/**
+ * A live feed: every subscriber hears each event pushed after it subscribed, in the order they
+ * subscribed. `push` doesn't yield (ADR-0032): a subscriber handles the event inside the push, as an
+ * Environment's consumers handle a real event inside its dispatch.
+ */
+export declare const hub: <A>() => Hub<A>;
+//# sourceMappingURL=feeds.d.ts.map

package/dist/feeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"feeds.d.ts","sourceRoot":"","sources":["../src/feeds.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,KAAK,SAAS,MAAM,wBAAwB,CAAA;AAExD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAChB,CAAC,UAAU,aAAa,CAAC,CAAC,CAAC,KAAG,SAAS,CAAC,SAAS,CAAC,CAAC,CAKnD,CAAA;AAEH,oDAAoD;AACpD,MAAM,WAAW,GAAG,CAAC,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;IACrC,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CACjD;AAED;;;;GAIG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,OAAK,GAAG,CAAC,CAAC,CAW9B,CAAA"}

package/dist/feeds.js

@@ -0,0 +1,32 @@
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import { constVoid } from "effect/Function";
+/**
+ * A fixed script as a feed: each subscriber hears every event as it subscribes, then the end. A
+ * Stream over it (`InputFeed.toStream`) emits the script and ends, as `Stream.fromIterable` did; an
+ * empty one ends at once. Not shared: each subscriber gets the whole script (tests address one
+ * surface, and a consumer may read it twice).
+ */
+export const script = (events) => (emit, end) => {
+    Arr.forEach(events, emit);
+    end();
+    return constVoid;
+};
+/**
+ * A live feed: every subscriber hears each event pushed after it subscribed, in the order they
+ * subscribed. `push` doesn't yield (ADR-0032): a subscriber handles the event inside the push, as an
+ * Environment's consumers handle a real event inside its dispatch.
+ */
+export const hub = () => {
+    let subscribers = [];
+    return {
+        feed: (emit) => {
+            subscribers = Arr.append(subscribers, emit);
+            return () => {
+                subscribers = Arr.filter(subscribers, (s) => s !== emit);
+            };
+        },
+        push: (event) => Effect.sync(() => Arr.forEach(subscribers, (emit) => emit(event))),
+    };
+};
+//# sourceMappingURL=feeds.js.map

package/dist/feeds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feeds.js","sourceRoot":"","sources":["../src/feeds.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,GAAG,MAAM,cAAc,CAAA;AACnC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;;;;GAKG;AACH,MAAM,CAAC,MAAM,MAAM,GACjB,CAAI,MAAwB,EAA0B,EAAE,CACxD,CAAC,IAAI,EAAE,GAAG,EAAE,EAAE;IACZ,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;IACzB,GAAG,EAAE,CAAA;IACL,OAAO,SAAS,CAAA;AAClB,CAAC,CAAA;AAQH;;;;GAIG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,GAAc,EAAE;IACjC,IAAI,WAAW,GAAsC,EAAE,CAAA;IACvD,OAAO;QACL,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE;YACb,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAA;YAC3C,OAAO,GAAG,EAAE;gBACV,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAA;YAC1D,CAAC,CAAA;QACH,CAAC;QACD,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;KACpF,CAAA;AACH,CAAC,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @wardic/test — headless testing Layers.
+ *
+ * Provide `TestLive` (or `testLayer(frames)`) in place of `@wardic/dom`'s
+ * `DomLive` to run animation code without a page. The Clock is deterministic
+ * (replays a `dt` sequence), so primitive output is collectable frame-by-frame.
+ * Nothing is drawn on a page: an app's components are tested with `DomLive`
+ * under the test runner's fake timers, as https://wardic.dev/guides/testing shows.
+ */
+export declare const VERSION = "0.1.0-alpha.0";
+export * as TestClock from "./clock.ts";
+export * as TestRenderer from "./renderer.ts";
+export * as TestProbe from "./probe.ts";
+export * as TestInput from "./input.ts";
+export { testLayer, TestLive } from "./layer.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,eAAO,MAAM,OAAO,kBAAkB,CAAA;AAEtC,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,YAAY,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/index.js

@@ -0,0 +1,17 @@
+/**
+ * @wardic/test — headless testing Layers.
+ *
+ * Provide `TestLive` (or `testLayer(frames)`) in place of `@wardic/dom`'s
+ * `DomLive` to run animation code without a page. The Clock is deterministic
+ * (replays a `dt` sequence), so primitive output is collectable frame-by-frame.
+ * Nothing is drawn on a page: an app's components are tested with `DomLive`
+ * under the test runner's fake timers, as https://wardic.dev/guides/testing shows.
+ */
+// The testing guide: #558.
+export const VERSION = "0.1.0-alpha.0";
+export * as TestClock from "./clock.js";
+export * as TestRenderer from "./renderer.js";
+export * as TestProbe from "./probe.js";
+export * as TestInput from "./input.js";
+export { testLayer, TestLive } from "./layer.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,2BAA2B;AAC3B,MAAM,CAAC,MAAM,OAAO,GAAG,eAAe,CAAA;AAEtC,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,YAAY,MAAM,eAAe,CAAA;AAC7C,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,YAAY,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/input.d.ts

@@ -0,0 +1,60 @@
+import * as InputSource from "@wardic/core/InputSource";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+/**
+ * An InputSource that replays fixed scripts of events, as **Input feeds** that end after their
+ * script: a Stream over one ends too. `pointer(target)` replays the same `pointerEvents`,
+ * `focus(target)` the same `focusEvents` and `keyboard(target)` the same `keyEvents` to each
+ * subscriber (each ignores `target` — tests address a single surface). The first positional arg is
+ * pointer events for back-compat; focus and key events are optional, defaulting to empty so existing
+ * call sites emit nothing on them. Each script plays whole when its feed is subscribed, so scripts of
+ * two kinds don't interleave: a test that needs them to pushes them ({@link pushable}). Called with no
+ * args it yields an InputSource that emits nothing — for tests that don't exercise gestures. It adopts
+ * no pointer: `adoptPointer` delivers nothing.
+ */
+export declare const layer: (pointerEvents?: ReadonlyArray<InputSource.PointerLikeEvent>, focusEvents?: ReadonlyArray<InputSource.FocusLikeEvent>, keyEvents?: ReadonlyArray<InputSource.KeyboardLikeEvent>) => Layer.Layer<InputSource.InputSource>;
+/**
+ * A push-based InputSource for tests that need to interleave pointer events with
+ * other effects (e.g. advancing the Clock between a release and a re-grab). Unlike
+ * {@link layer} — which replays a fixed script that drains immediately — this
+ * form lets the test `push` events one at a time, on its own schedule.
+ *
+ * Backed by a hub (`feeds.ts`) so that every subscription to `pointer(target)`
+ * hears every event: a consumer may subscribe to `input.pointer(target)` more than once
+ * (a binding's drag track reads the drag fold and the grabs). There is no replay buffer,
+ * so only events pushed *after* a subscription is live reach it.
+ *
+ * `push` doesn't yield: a subscriber handles the event inside the push, as an
+ * Environment's consumers handle a real event inside its dispatch, so a pipeline that hops
+ * through Effect's scheduler on its way to its sink hasn't got there when `push` returns,
+ * and its test sees it.
+ *
+ * Returns `{ layer, push }`. Resolve it inside an `Effect.gen`, provide `layer`,
+ * and drive the surface with `push`:
+ *
+ * @example
+ * const input = yield* TestInput.pushable()
+ * yield* Stream.runForEach(drag(undefined), …).pipe(Effect.fork…)  // subscribe
+ * yield* input.push(ev("down", 0, 0, 0))
+ *
+ * Returns `pushFocus` and `pushKey` alongside `push` so focus/blur transitions and keys can be
+ * driven on the same schedule; `focus(target)` and `keyboard(target)` mirror `pointer(target)`, each
+ * with its own hub.
+ *
+ * `adoptPointer(target, raw)` takes a pointer event as its `raw`: a pressed one is pushed on
+ * the pointer hub as an adopted down, inside the call, as the DOM's is. The hub holds no pointer, so
+ * the test pushes that pointer's later events itself.
+ *
+ * `options.focusWithin` is the source's `focusWithin`, for a test of a **Keyboard press** that
+ * holds its keys only while focus is within its target. Without it the source says nothing of focus,
+ * and a press hears every key pushed.
+ */
+export declare const pushable: (options?: {
+    readonly focusWithin?: ((target: unknown) => boolean) | undefined;
+}) => Effect.Effect<{
+    readonly layer: Layer.Layer<InputSource.InputSource>;
+    readonly push: (event: InputSource.PointerLikeEvent) => Effect.Effect<void>;
+    readonly pushFocus: (event: InputSource.FocusLikeEvent) => Effect.Effect<void>;
+    readonly pushKey: (event: InputSource.KeyboardLikeEvent) => Effect.Effect<void>;
+}>;
+//# sourceMappingURL=input.d.ts.map

package/dist/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../src/input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,WAAW,MAAM,0BAA0B,CAAA;AAEvD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAKrC;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,KAAK,mBACD,aAAa,CAAC,WAAW,CAAC,gBAAgB,CAAC,gBAC7C,aAAa,CAAC,WAAW,CAAC,cAAc,CAAC,cAC3C,aAAa,CAAC,WAAW,CAAC,iBAAiB,CAAC,KACtD,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,CAMlC,CAAA;AAEJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,eAAO,MAAM,QAAQ,aAAc;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,SAAS,CAAA;CAAE,KAAG,MAAM,CAAC,MAAM,CAAC;IACvH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,CAAC,CAAA;IACpD,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,gBAAgB,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC3E,QAAQ,CAAC,SAAS,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,cAAc,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IAC9E,QAAQ,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,WAAW,CAAC,iBAAiB,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;CAChF,CAwBG,CAAA"}

package/dist/input.js

@@ -0,0 +1,90 @@
+import * as InputSource from "@wardic/core/InputSource";
+import * as Bool from "effect/Boolean";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Layer from "effect/Layer";
+import * as UndefinedOr from "effect/UndefinedOr";
+import * as Option from "effect/Option";
+import * as Feeds from "./feeds.js";
+/**
+ * An InputSource that replays fixed scripts of events, as **Input feeds** that end after their
+ * script: a Stream over one ends too. `pointer(target)` replays the same `pointerEvents`,
+ * `focus(target)` the same `focusEvents` and `keyboard(target)` the same `keyEvents` to each
+ * subscriber (each ignores `target` — tests address a single surface). The first positional arg is
+ * pointer events for back-compat; focus and key events are optional, defaulting to empty so existing
+ * call sites emit nothing on them. Each script plays whole when its feed is subscribed, so scripts of
+ * two kinds don't interleave: a test that needs them to pushes them ({@link pushable}). Called with no
+ * args it yields an InputSource that emits nothing — for tests that don't exercise gestures. It adopts
+ * no pointer: `adoptPointer` delivers nothing.
+ */
+// Input feeds: #318. adoptPointer: #431.
+export const layer = (pointerEvents = [], focusEvents = [], keyEvents = []) => Layer.succeed(InputSource.InputSource, {
+    pointer: () => Feeds.script(pointerEvents),
+    keyboard: () => Feeds.script(keyEvents),
+    focus: () => Feeds.script(focusEvents),
+    adoptPointer: () => Option.none(),
+});
+/**
+ * A push-based InputSource for tests that need to interleave pointer events with
+ * other effects (e.g. advancing the Clock between a release and a re-grab). Unlike
+ * {@link layer} — which replays a fixed script that drains immediately — this
+ * form lets the test `push` events one at a time, on its own schedule.
+ *
+ * Backed by a hub (`feeds.ts`) so that every subscription to `pointer(target)`
+ * hears every event: a consumer may subscribe to `input.pointer(target)` more than once
+ * (a binding's drag track reads the drag fold and the grabs). There is no replay buffer,
+ * so only events pushed *after* a subscription is live reach it.
+ *
+ * `push` doesn't yield: a subscriber handles the event inside the push, as an
+ * Environment's consumers handle a real event inside its dispatch, so a pipeline that hops
+ * through Effect's scheduler on its way to its sink hasn't got there when `push` returns,
+ * and its test sees it.
+ *
+ * Returns `{ layer, push }`. Resolve it inside an `Effect.gen`, provide `layer`,
+ * and drive the surface with `push`:
+ *
+ * @example
+ * const input = yield* TestInput.pushable()
+ * yield* Stream.runForEach(drag(undefined), …).pipe(Effect.fork…)  // subscribe
+ * yield* input.push(ev("down", 0, 0, 0))
+ *
+ * Returns `pushFocus` and `pushKey` alongside `push` so focus/blur transitions and keys can be
+ * driven on the same schedule; `focus(target)` and `keyboard(target)` mirror `pointer(target)`, each
+ * with its own hub.
+ *
+ * `adoptPointer(target, raw)` takes a pointer event as its `raw`: a pressed one is pushed on
+ * the pointer hub as an adopted down, inside the call, as the DOM's is. The hub holds no pointer, so
+ * the test pushes that pointer's later events itself.
+ *
+ * `options.focusWithin` is the source's `focusWithin`, for a test of a **Keyboard press** that
+ * holds its keys only while focus is within its target. Without it the source says nothing of focus,
+ * and a press hears every key pushed.
+ */
+// The hub: #318. No yield: ADR-0032. Keys: #427. adoptPointer: #431. focusWithin: #460.
+export const pushable = (options) => Effect.sync(() => {
+    const pointer = Feeds.hub();
+    const focus = Feeds.hub();
+    const keys = Feeds.hub();
+    return {
+        layer: Layer.succeed(InputSource.InputSource, {
+            pointer: () => pointer.feed,
+            keyboard: () => keys.feed,
+            focus: () => focus.feed,
+            focusWithin: UndefinedOr.map(options, (o) => o.focusWithin),
+            adoptPointer: (_target, raw) => {
+                if (isPressedPointer(raw)) {
+                    const down = { ...raw, type: "down", adopted: true };
+                    Effect.runSync(pointer.push(down));
+                    return Option.some(down);
+                }
+                return Option.none();
+            },
+        }),
+        push: pointer.push,
+        pushFocus: focus.push,
+        pushKey: keys.push,
+    };
+});
+/** Whether `raw` is a pointer event with a button pressed: one the pushable InputSource adopts (#431). */
+const isPressedPointer = (raw) => Bool.and(Predicate.hasProperty(raw, "pointerId"), Predicate.hasProperty(raw, "pressed")) && raw.pressed;
+//# sourceMappingURL=input.js.map