@wardic/dom 0.0.0-stage → 1.0.0-rc.2

package/dist/internal/report.d.ts

@@ -0,0 +1,30 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+/**
+ * `cause` logged at Error as `message`, with the cause, and handed to the Environment's
+ * `ErrorReporter`s. An interruption is neither: it's how a run is removed, by a retarget, an unmount or a
+ * dispose. Annotate the log by piping `Effect.annotateLogs` onto it.
+ */
+export declare const reportFailure: (message: string, cause: Cause.Cause<unknown>) => Effect.Effect<void>;
+/**
+ * Whether a Debug log would be kept, as Effect's `MinimumLogLevel` says. Run it once (a runtime, a
+ * build) and keep the answer, not once a log.
+ */
+export declare const debugKept: Effect.Effect<boolean>;
+/**
+ * A lifecycle debug log for `scope` (`wardic.projection`, say): `log(event, annotations?)` logs
+ * `scope: event` at Debug, forked on `runner`, with the annotations. Whether a Debug log would be kept
+ * is read once, here ({@link debugKept}): when it wouldn't, `on` is `false` and `log` returns at once,
+ * forking nothing. A site that builds its annotations per element checks `on` first.
+ */
+export declare const debugOf: (runner: {
+    readonly runSync: <A>(effect: Effect.Effect<A>) => A;
+    readonly runFork: <A>(effect: Effect.Effect<A>) => unknown;
+}, scope: string) => DebugLog;
+/** {@link debugOf}'s log: called with an event and its annotations, and `on` when a Debug log is kept. */
+export interface DebugLog {
+    (event: string, annotations?: Record<string, unknown>): void;
+    /** Whether a Debug log would be kept: when it's `false`, a call logs nothing. */
+    readonly on: boolean;
+}
+//# sourceMappingURL=report.d.ts.map

package/dist/internal/report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../src/internal/report.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAMvC;;;;GAIG;AACH,eAAO,MAAM,aAAa,YAAa,MAAM,SAAS,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAI3F,CAAA;AAEJ;;;GAGG;AAEH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,CAAqH,CAAA;AAElK;;;;;GAKG;AAGH,eAAO,MAAM,OAAO,WAAY;IAAE,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,OAAO,CAAA;CAAE,SAAS,MAAM,KAAG,QAYrK,CAAA;AAED,0GAA0G;AAC1G,MAAM,WAAW,QAAQ;IACvB,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;IAC5D,iFAAiF;IACjF,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;CACrB"}

package/dist/internal/report.js

@@ -0,0 +1,60 @@
+/**
+ * Where a binding's failure stops (ADR-0030, decision 4): `reportFailure` logs it at Error and
+ * reports it to the Environment's `ErrorReporter`s. Core doesn't report: the Frame loop hands each
+ * run's failure to its caller (ADR-0027, decision 7), and a Tier 2 caller may recover. A binding
+ * boundary that ends a fiber nobody observes calls this, so a failure there reaches the console
+ * and an app's reporters instead of stopping its feature with nothing said.
+ *
+ * An app installs its reporters on the Environment it hands the provider,
+ * `ErrorReporter.layer([…])` merged into `env`; Wardic ships none. With none installed, a report
+ * is one `getRef` and a size check, on the failure path only. A reporter built with
+ * `ErrorReporter.make` dedupes a cause and its original error, so a failure that crosses two
+ * boundaries reports once: pass the cause on as it came, never wrapped.
+ *
+ * Tier 2 (ADR-0008): for binding authors.
+ */
+import * as Bool from "effect/Boolean";
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import * as ErrorReporter from "effect/ErrorReporter";
+import * as LogLevel from "effect/LogLevel";
+import * as Predicate from "effect/Predicate";
+import * as References from "effect/References";
+/**
+ * `cause` logged at Error as `message`, with the cause, and handed to the Environment's
+ * `ErrorReporter`s. An interruption is neither: it's how a run is removed, by a retarget, an unmount or a
+ * dispose. Annotate the log by piping `Effect.annotateLogs` onto it.
+ */
+export const reportFailure = (message, cause) => Bool.match(Cause.hasInterruptsOnly(cause), {
+    onTrue: () => Effect.void,
+    onFalse: () => Effect.logError(message, cause).pipe(Effect.andThen(ErrorReporter.report(cause))),
+});
+/**
+ * Whether a Debug log would be kept, as Effect's `MinimumLogLevel` says. Run it once (a runtime, a
+ * build) and keep the answer, not once a log.
+ */
+// #618: the spine reads it alone, so an app that logs nothing else doesn't ship debugOf's log.
+export const debugKept = /*#__PURE__*/ Effect.map(References.MinimumLogLevel, (level) => Bool.not(LogLevel.isGreaterThan(level, "Debug")));
+/**
+ * A lifecycle debug log for `scope` (`wardic.projection`, say): `log(event, annotations?)` logs
+ * `scope: event` at Debug, forked on `runner`, with the annotations. Whether a Debug log would be kept
+ * is read once, here ({@link debugKept}): when it wouldn't, `on` is `false` and `log` returns at once,
+ * forking nothing. A site that builds its annotations per element checks `on` first.
+ */
+// #618 (M4): each call forked a fiber whatever the level, 0.3-0.5 µs to log nothing (one per layout
+// node's mount and unmount); core's Frame loop reads the level once as this does (frameLoop.ts).
+export const debugOf = (runner, scope) => {
+    const on = runner.runSync(debugKept);
+    const log = (event, annotations) => {
+        if (!on)
+            return;
+        const logged = Effect.logDebug(`${scope}: ${event}`);
+        if (Predicate.isUndefined(annotations)) {
+            runner.runFork(logged);
+            return;
+        }
+        runner.runFork(Effect.annotateLogs(logged, annotations));
+    };
+    return Object.assign(log, { on });
+};
+//# sourceMappingURL=report.js.map

package/dist/internal/report.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.js","sourceRoot":"","sources":["../../src/internal/report.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AACtC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,aAAa,MAAM,sBAAsB,CAAA;AACrD,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAA;AAE/C;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,OAAe,EAAE,KAA2B,EAAuB,EAAE,CACjG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,iBAAiB,CAAC,KAAK,CAAC,EAAE;IACzC,MAAM,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI;IACzB,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;CACjG,CAAC,CAAA;AAEJ;;;GAGG;AACH,+FAA+F;AAC/F,MAAM,CAAC,MAAM,SAAS,GAA2B,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,eAAe,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,CAAA;AAElK;;;;;GAKG;AACH,oGAAoG;AACpG,iGAAiG;AACjG,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,MAA4H,EAAE,KAAa,EAAY,EAAE;IAC/K,MAAM,EAAE,GAAG,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAA;IACpC,MAAM,GAAG,GAAG,CAAC,KAAa,EAAE,WAAqC,EAAQ,EAAE;QACzE,IAAI,CAAC,EAAE;YAAE,OAAM;QACf,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,GAAG,KAAK,KAAK,KAAK,EAAE,CAAC,CAAA;QACpD,IAAI,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,EAAE,CAAC;YACvC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;YACtB,OAAM;QACR,CAAC;QACD,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAA;IAC1D,CAAC,CAAA;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;AACnC,CAAC,CAAA"}

package/dist/internal/require-global.d.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect";
+/** The browser globals a DomLive Layer can need. */
+export type BrowserGlobal = "requestAnimationFrame" | "document" | "window";
+/** The DOM's Layers that need a browser global, by the names an app knows them by. */
+export type ClientLayer = "DomClock.layer" | "DomInput.layer" | "DomProbe.layer" | "DomAnnouncer.layer";
+/**
+ * Fail the build of `layer` with ADR-0021's client-only error when `global` doesn't exist.
+ * Make it the first step of the build: anything that reads the global must come after it.
+ */
+export declare const requireGlobal: (layer: ClientLayer, global: BrowserGlobal) => Effect.Effect<void>;
+//# sourceMappingURL=require-global.d.ts.map

package/dist/internal/require-global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-global.d.ts","sourceRoot":"","sources":["../../src/internal/require-global.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,oDAAoD;AACpD,MAAM,MAAM,aAAa,GAAG,uBAAuB,GAAG,UAAU,GAAG,QAAQ,CAAA;AAE3E,sFAAsF;AACtF,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,oBAAoB,CAAA;AAUvG;;;GAGG;AAGH,eAAO,MAAM,aAAa,UAAW,WAAW,UAAU,aAAa,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAWzF,CAAA"}

package/dist/internal/require-global.js

@@ -0,0 +1,31 @@
+/**
+ * DomLive is client-only, and says so (ADR-0021, decision 7). A server render builds no
+ * runtime, so building a DomLive Layer on a server is always a mistake: each Layer that
+ * needs a browser global checks for it as its build starts, and fails with one message
+ * naming the Layer, the global and the rule, instead of a `ReferenceError` from deep
+ * inside the build.
+ *
+ * Read when the Layer builds, never when `@wardic/dom` is imported. Once per build, so
+ * no log or span (the cold path's message is the error itself).
+ */
+import * as Bool from "effect/Boolean";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+/** Where an app gets each: three are `DomLive`'s, and a gesture builds the input. */
+const FROM = {
+    "DomClock.layer": "DomLive's",
+    "DomProbe.layer": "DomLive's",
+    "DomAnnouncer.layer": "DomLive's",
+    "DomInput.layer": "a gesture's",
+};
+/**
+ * Fail the build of `layer` with ADR-0021's client-only error when `global` doesn't exist.
+ * Make it the first step of the build: anything that reads the global must come after it.
+ */
+// #618 (D7): the error named the Layers ADR-0041 renamed (`ClockDomLive`…), and an ADR; `layer` is a
+// union of today's names, so a rename can't leave it behind. Short, as every app ships it.
+export const requireGlobal = (layer, global) => Effect.suspend(() => Bool.match(Predicate.isUndefined(globalThis[global]), {
+    onTrue: () => Effect.die(new Error(`${layer} (${FROM[layer]}) needs ${global}: Wardic's runtime is client-only, never built during a server render.`)),
+    onFalse: () => Effect.void,
+}));
+//# sourceMappingURL=require-global.js.map

package/dist/internal/require-global.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-global.js","sourceRoot":"","sources":["../../src/internal/require-global.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAA;AAQ7C,qFAAqF;AACrF,MAAM,IAAI,GAA0C;IAClD,gBAAgB,EAAE,WAAW;IAC7B,gBAAgB,EAAE,WAAW;IAC7B,oBAAoB,EAAE,WAAW;IACjC,gBAAgB,EAAE,aAAa;CAChC,CAAA;AAED;;;GAGG;AACH,qGAAqG;AACrG,2FAA2F;AAC3F,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,KAAkB,EAAE,MAAqB,EAAuB,EAAE,CAC9F,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAClB,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,WAAW,CAAE,UAAsC,CAAC,MAAM,CAAC,CAAC,EAAE;IACjF,MAAM,EAAE,GAAG,EAAE,CACX,MAAM,CAAC,GAAG,CACR,IAAI,KAAK,CACP,GAAG,KAAK,KAAK,IAAI,CAAC,KAAK,CAAC,WAAW,MAAM,wEAAwE,CAClH,CACF;IACH,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI;CAC3B,CAAC,CACH,CAAA"}

package/dist/internal/reveal.d.ts

@@ -0,0 +1,16 @@
+/** A box on screen, in client coordinates. */
+interface Rect {
+    readonly left: number;
+    readonly top: number;
+    readonly right: number;
+    readonly bottom: number;
+}
+/**
+ * `el`'s layout box on screen: its painted box with its own transform undone. A translate and a
+ * scale (the projection's) about its `transform-origin`; a box drawn with no transform is as painted.
+ */
+export declare const layoutRectOf: (el: Element) => Rect;
+/** Scroll `el`'s new place into view (see the module doc). */
+export declare const revealLayoutOf: (el: Element) => void;
+export {};
+//# sourceMappingURL=reveal.d.ts.map

package/dist/internal/reveal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reveal.d.ts","sourceRoot":"","sources":["../../src/internal/reveal.ts"],"names":[],"mappings":"AAaA,8CAA8C;AAC9C,UAAU,IAAI;IACZ,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,OAAQ,OAAO,KAAG,IAW1C,CAAA;AAYD,8DAA8D;AAC9D,eAAO,MAAM,cAAc,OAAQ,OAAO,KAAG,IAmB5C,CAAA"}

package/dist/internal/reveal.js

@@ -0,0 +1,66 @@
+/**
+ * Keep a **Keyboard reorder**'s item in view (ADR-0037, Q13): after a step, scroll its new place
+ * into view, as little as needed, in each scroller that moves it and then the page, as
+ * `scrollIntoView({ block: "nearest", inline: "nearest" })` would. Its new place, not where it's
+ * drawn: a step's layout animation starts it where it was, so the box is the element's painted one
+ * with its own transform (a translate and a scale about its origin) undone. Instant, so it never
+ * runs against the step's own animation, and with nothing for reduced motion to stop.
+ *
+ * @internal for the Reorder controller.
+ */
+import { scrollersOf } from "./scrollers.js";
+import * as Arr from "effect/Array";
+/**
+ * `el`'s layout box on screen: its painted box with its own transform undone. A translate and a
+ * scale (the projection's) about its `transform-origin`; a box drawn with no transform is as painted.
+ */
+export const layoutRectOf = (el) => {
+    const painted = el.getBoundingClientRect();
+    const style = getComputedStyle(el);
+    const m = new DOMMatrixReadOnly(style.transform);
+    if (m.isIdentity)
+        return painted;
+    if (m.a === 0)
+        return painted;
+    if (m.d === 0)
+        return painted;
+    const [ox = 0, oy = 0] = style.transformOrigin.split(" ").map((v) => Number.parseFloat(v));
+    const left = painted.left - m.e - ox * (1 - m.a);
+    const top = painted.top - m.f - oy * (1 - m.d);
+    return { left, top, right: left + painted.width / m.a, bottom: top + painted.height / m.d };
+};
+/**
+ * How far to scroll a view from `viewMin` to `viewMax` so `min` to `max` shows: 0 when it does, else
+ * the least that brings it in, its start first when it can't all fit.
+ */
+const scrollToShow = (min, max, viewMin, viewMax) => {
+    if (min < viewMin)
+        return min - viewMin;
+    if (max > viewMax)
+        return Math.min(max - viewMax, min - viewMin);
+    return 0;
+};
+/** Scroll `el`'s new place into view (see the module doc). */
+export const revealLayoutOf = (el) => {
+    const { ancestors, page } = scrollersOf(el);
+    // Each scroller in turn, nearest first: what it scrolls moves the element for the next.
+    const rect = Arr.reduce(ancestors, layoutRectOf(el), (rect, scroller) => {
+        const box = scroller.getBoundingClientRect();
+        const top = box.top + scroller.clientTop;
+        const left = box.left + scroller.clientLeft;
+        const dy = scrollToShow(rect.top, rect.bottom, top, top + scroller.clientHeight);
+        const dx = scrollToShow(rect.left, rect.right, left, left + scroller.clientWidth);
+        if (dx === 0 && dy === 0)
+            return rect;
+        scroller.scrollBy({ left: dx, top: dy, behavior: "instant" });
+        return { left: rect.left - dx, top: rect.top - dy, right: rect.right - dx, bottom: rect.bottom - dy };
+    });
+    const win = el.ownerDocument.defaultView;
+    if (page && win !== null) {
+        const dy = scrollToShow(rect.top, rect.bottom, 0, win.innerHeight);
+        const dx = scrollToShow(rect.left, rect.right, 0, win.innerWidth);
+        if (dx !== 0 || dy !== 0)
+            win.scrollBy({ left: dx, top: dy, behavior: "instant" });
+    }
+};
+//# sourceMappingURL=reveal.js.map

package/dist/internal/reveal.js.map

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

package/dist/internal/runner.d.ts

@@ -0,0 +1,21 @@
+import * as Effect from "effect/Effect";
+import type * as Fiber from "effect/Fiber";
+import * as Scope from "effect/Scope";
+/** Runs Effects synchronously, and forked into the Scope it was made in. */
+export interface Runner<R> {
+    readonly runSync: <A, E>(effect: Effect.Effect<A, E, R>) => A;
+    readonly runFork: <A, E>(effect: Effect.Effect<A, E, R>) => Fiber.Fiber<A, E>;
+    /**
+     * The Scope it was made in: what a service built with it keeps its own fibers in, so closing the
+     * Scope ends them, after the service's own cleanup, and awaits them.
+     */
+    readonly scope: Scope.Scope;
+}
+/**
+ * A runner over the current context, without a sync scheduler, forking into a `FiberSet` in the
+ * current Scope. It forks with that context itself (`Effect.runForkWith`), not through
+ * `FiberSet.runtime`, which reads the context again in the current fiber, where the building call's
+ * scheduler still is: `Effect.provideContext` merges into a fiber's context, it doesn't replace it.
+ */
+export declare const makeRunner: <R>() => Effect.Effect<Runner<R>, never, R | Scope.Scope>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/internal/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/internal/runner.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAG1C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,4EAA4E;AAC5E,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAA;IAC7D,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;IAC7E;;;OAGG;IAEH,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAA;CAC5B;AAED;;;;;GAKG;AAGH,eAAO,MAAM,UAAU,GAAI,CAAC,OAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAW5E,CAAA"}

package/dist/internal/runner.js

@@ -0,0 +1,48 @@
+/**
+ * A Layer-built service's runner (#132, ADR-0041): how `FlushGate.make` and `DomProjectionSystem.make`
+ * run their Effects after they're built, synchronously and forked, on the context their Layer was
+ * built in, forking into its Scope.
+ *
+ * The context drops a sync scheduler, and keeps any other (ADR-0041, *Amendment (#208)*). A
+ * binding's first read builds the Layer inside a `ManagedRuntime.runSync`, whose fiber carries a sync
+ * `MixedScheduler`: kept, it would pin every later fork to that scheduler, which resumes a fork's
+ * yields on a microtask, where Effect's default resumes them on a macrotask. Without it, forks use
+ * the default, as a `ManagedRuntime`'s do. A host's own async scheduler, provided in the Layers it
+ * hands Wardic (Foldkit's microtask `MixedScheduler`), is the host's choice: forks keep it (ADR-0027,
+ * decision 6: a fork inherits the scheduler it's forked under). A host that provides a *sync* one is
+ * overridden too: a sync scheduler is for draining a `runSync`.
+ */
+import * as Bool from "effect/Boolean";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as FiberSet from "effect/FiberSet";
+import * as Scheduler from "effect/Scheduler";
+import * as Scope from "effect/Scope";
+/**
+ * A runner over the current context, without a sync scheduler, forking into a `FiberSet` in the
+ * current Scope. It forks with that context itself (`Effect.runForkWith`), not through
+ * `FiberSet.runtime`, which reads the context again in the current fiber, where the building call's
+ * scheduler still is: `Effect.provideContext` merges into a fiber's context, it doesn't replace it.
+ */
+// Not `Effect.fnUntraced`, as effect-4's guide prefers: TypeScript can't carry `R` through it, and the
+// runner's context would be `unknown` (#618, H1).
+export const makeRunner = () => Effect.gen(function* () {
+    const context = withoutSyncScheduler(yield* Effect.context());
+    const fibers = yield* FiberSet.make();
+    const fork = Effect.runForkWith(context);
+    const runFork = (effect) => {
+        const fiber = fork(effect);
+        FiberSet.addUnsafe(fibers, fiber);
+        return fiber;
+    };
+    return { runSync: Effect.runSyncWith(context), runFork, scope: Context.get(context, Scope.Scope) };
+});
+/**
+ * `context` without its scheduler when that one is sync (`runSync`'s), else as it is: a host's
+ * async scheduler stays, and with none stored the context has Effect's default already.
+ */
+const withoutSyncScheduler = (context) => Bool.match(Context.get(context, Scheduler.Scheduler).executionMode === "sync", {
+    onTrue: () => Context.omit(Scheduler.Scheduler)(context),
+    onFalse: () => context,
+});
+//# sourceMappingURL=runner.js.map

package/dist/internal/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../../src/internal/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,KAAK,IAAI,MAAM,gBAAgB,CAAA;AACtC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,KAAK,SAAS,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAcrC;;;;;GAKG;AACH,uGAAuG;AACvG,kDAAkD;AAClD,MAAM,CAAC,MAAM,UAAU,GAAG,GAAwD,EAAE,CAClF,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,OAAO,GAAG,oBAAoB,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,EAAmB,CAAC,CAAA;IAC9E,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAA;IACrC,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,CAAA;IACxC,MAAM,OAAO,GAAG,CAAO,MAA8B,EAAqB,EAAE;QAC1E,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAA;QAC1B,QAAQ,CAAC,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QACjC,OAAO,KAAK,CAAA;IACd,CAAC,CAAA;IACD,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,CAAA;AACpG,CAAC,CAAC,CAAA;AAEJ;;;GAGG;AACH,MAAM,oBAAoB,GAAG,CAAI,OAA2B,EAAsB,EAAE,CAClF,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,aAAa,KAAK,MAAM,EAAE;IAC7E,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC;IACxD,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO;CACvB,CAAC,CAAA"}

package/dist/internal/scale-correction.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Scale-correction registry (ADR-0011) — the visual-correction half of the
+ * projection (ADR-0009). A scaling projection counter-scales an element's
+ * geometry via the transform, but non-geometric CSS — `border-radius`,
+ * `box-shadow` — is still distorted by that scale. Each {@link ScaleCorrector}
+ * reads the element's base value at measure time and, per frame, emits a CSS
+ * string that — once the transform scales it — renders as the AUTHORED value.
+ *
+ * The projection coordinator owns the pipeline (it has the element + the per-frame
+ * `delta`/`treeScale`); the corrected value is written into the node's gate entry
+ * as an ordinary style key, so the Renderer stays pure (ADR-0002/0006) — it just
+ * applies what the projection computed.
+ *
+ * Units: `getComputedStyle` resolves em/rem/etc. to px, leaving only **px**
+ * (corrected via `/scale`) and **`%`** (self-correcting — a percentage stays the
+ * same fraction of each scaled dimension, so it passes through). Reading resolved
+ * values therefore gives full-grammar parity.
+ */
+import type * as Box from "@wardic/core/Box";
+import type * as Point from "@wardic/core/Point";
+import type * as Projection from "@wardic/core/Projection";
+/**
+ * What an app's scale corrector is handed beside the value: the projection node's fields Motion's
+ * correctors read, as Motion names them. `target` is the box the node is drawn into this frame,
+ * `treeScale` its ancestors' scale, `projectionDelta` its delta.
+ */
+export interface CorrectorInfo {
+    /** The box the node is drawn into this frame. */
+    readonly target: Box.Box;
+    /** Its ancestors' scale, multiplied together. */
+    readonly treeScale: Point.Point;
+    /** Its delta, from its layout box to `target`. */
+    readonly projectionDelta: Projection.Delta;
+}
+/**
+ * An app's scale corrector (Motion's `addScaleCorrector` entry), given to a provider by the value key it
+ * corrects (`borderRadius`, `--card-radius`): `correct` turns the element's value into the one to write
+ * while its projection scales it, written under `applyTo`'s keys when given, else its own.
+ */
+export interface ScaleCorrectorEntry {
+    /** The value to write while the projection scales the element, from its own value, `latest`, and the node's fields. */
+    readonly correct: (latest: string | number, info: CorrectorInfo) => string | number;
+    /** The keys the corrected value is written under: its own key when left out. */
+    readonly applyTo?: ReadonlyArray<string> | undefined;
+}
+/** A registered scale corrector — owns reading its base + emitting the corrected value. */
+export interface ScaleCorrector {
+    /** The gate value-map / CSS key the corrected value is written under. */
+    readonly key: string;
+    /**
+     * Read the element's base value(s) at measure time (read phase), or `undefined`
+     * if there is nothing to correct (e.g. radius all `0px`, shadow `none`).
+     */
+    readonly read: (el: HTMLElement) => unknown;
+    /** Emit the corrected CSS string for the per-axis visual scale `(sx, sy)`. */
+    readonly correct: (base: unknown, sx: number, sy: number) => string;
+}
+/** Whether a per-axis scale is ~identity (no correction needed). */
+export declare const isUnitScale: (sx: number, sy: number) => boolean;
+export declare const borderRadiusCorrector: ScaleCorrector;
+export declare const ZERO_RADIUS: unknown;
+/**
+ * A border radius between a twin's and a Lead's at `progress` (ADR-0010 *Amendment (#166)*): corner by
+ * corner and axis by axis, `undefined` standing for no radius. What {@link borderRadiusCorrector}
+ * corrects while a handover blends. Per frame.
+ */
+export declare const blendRadius: (from: unknown, to: unknown, progress: number) => unknown;
+/**
+ * `radius` as drawn under an own scale `(sx, sy)` (ADR-0010 *Amendment (#166)*): its px components
+ * scaled, its `%` ones as they are (a fraction of the scaled box already). Per frame.
+ */
+export declare const scaleRadius: (radius: unknown, sx: number, sy: number) => unknown;
+export declare const boxShadowCorrector: ScaleCorrector;
+/**
+ * The default scale-corrector registry (ADR-0011). Ship `borderRadius` +
+ * `boxShadow`; a public `addScaleCorrector` API is a deferred follow-up (adding
+ * an entry here is the extension point until then).
+ */
+export declare const SCALE_CORRECTORS: ReadonlyArray<ScaleCorrector>;
+//# sourceMappingURL=scale-correction.d.ts.map

package/dist/internal/scale-correction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale-correction.d.ts","sourceRoot":"","sources":["../../src/internal/scale-correction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,KAAK,GAAG,MAAM,kBAAkB,CAAA;AAC5C,OAAO,KAAK,KAAK,KAAK,MAAM,oBAAoB,CAAA;AAChD,OAAO,KAAK,KAAK,UAAU,MAAM,yBAAyB,CAAA;AAG1D;;;;GAIG;AAEH,MAAM,WAAW,aAAa;IAC5B,iDAAiD;IACjD,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAA;IACxB,iDAAiD;IACjD,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,KAAK,CAAA;IAC/B,kDAAkD;IAClD,QAAQ,CAAC,eAAe,EAAE,UAAU,CAAC,KAAK,CAAA;CAC3C;AAED;;;;GAIG;AAEH,MAAM,WAAW,mBAAmB;IAClC,uHAAuH;IACvH,QAAQ,CAAC,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,aAAa,KAAK,MAAM,GAAG,MAAM,CAAA;IACnF,gFAAgF;IAChF,QAAQ,CAAC,OAAO,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAAA;CACrD;AAED,2FAA2F;AAC3F,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,WAAW,KAAK,OAAO,CAAA;IAC3C,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,KAAK,MAAM,CAAA;CACpE;AAGD,oEAAoE;AACpE,eAAO,MAAM,WAAW,OAAQ,MAAM,MAAM,MAAM,KAAG,OAA2D,CAAA;AA4ChH,eAAO,MAAM,qBAAqB,EAAE,cAkBnC,CAAA;AAID,eAAO,MAAM,WAAW,EAAE,OAA4E,CAAA;AAwBtG;;;;GAIG;AACH,eAAO,MAAM,WAAW,SAAU,OAAO,MAAM,OAAO,YAAY,MAAM,KAAG,OAG1E,CAAA;AAQD;;;GAGG;AACH,eAAO,MAAM,WAAW,WAAY,OAAO,MAAM,MAAM,MAAM,MAAM,KAAG,OAIrE,CAAA;AA8GD,eAAO,MAAM,kBAAkB,EAAE,cAYhC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAAa,CAAC,cAAc,CAA+C,CAAA"}

package/dist/internal/scale-correction.js

@@ -0,0 +1,227 @@
+import * as Predicate from "effect/Predicate";
+const EPS = 1e-3;
+/** Whether a per-axis scale is ~identity (no correction needed). */
+export const isUnitScale = (sx, sy) => Math.abs(sx - 1) < EPS && Math.abs(sy - 1) < EPS;
+const CORNER_PROPS = [
+    "borderTopLeftRadius",
+    "borderTopRightRadius",
+    "borderBottomRightRadius",
+    "borderBottomLeftRadius",
+];
+/** Parse a computed longhand (`"H V"` or `"H"`) into its H + V components. */
+const parseCorner = (computed) => {
+    // `split` gives at least one part. A single value is circular (H === V).
+    const parts = computed.trim().split(/\s+/);
+    const h = parts[0];
+    if (parts.length < 2)
+        return { h, v: h };
+    return { h, v: parts[1] };
+};
+/** Whether every corner is zero (nothing to correct). */
+const isZeroRadius = (base) => base.every((c) => (Number.parseFloat(c.h) || 0) === 0 && (Number.parseFloat(c.v) || 0) === 0);
+/**
+ * Correct one radius component for `scale`. A `%` is self-correcting (a fraction
+ * of each scaled dimension) and passes through; a px value is divided by the
+ * scale so the transform renders it back to the authored px.
+ */
+const correctRadiusComponent = (value, scale) => {
+    if (value.endsWith("%"))
+        return value;
+    const px = Number.parseFloat(value);
+    if (!Number.isFinite(px))
+        return value;
+    return `${px / scale}px`;
+};
+export const borderRadiusCorrector = {
+    // Kebab-case: corrected values flow through the gate's style object, which the
+    // binding applies via `el.style.setProperty` — that requires hyphenated names
+    // (a camelCase key is silently dropped). `transform`/`opacity` work either way.
+    key: "border-radius",
+    read: (el) => {
+        const cs = getComputedStyle(el);
+        const base = CORNER_PROPS.map((p) => parseCorner(cs[p] || "0px"));
+        if (isZeroRadius(base))
+            return undefined;
+        return base;
+    },
+    correct: (base, sx, sy) => {
+        const corners = base;
+        const h = corners.map((c) => correctRadiusComponent(c.h, sx)).join(" ");
+        const v = corners.map((c) => correctRadiusComponent(c.v, sy)).join(" ");
+        // Elliptical shorthand: horizontal radii / vertical radii.
+        return `${h} / ${v}`;
+    },
+};
+/** No corner rounded: what a twin with no radius blends from or to (ADR-0010 *Amendment (#166)*). */
+const ZERO_CORNER = { h: "0px", v: "0px" };
+export const ZERO_RADIUS = [ZERO_CORNER, ZERO_CORNER, ZERO_CORNER, ZERO_CORNER];
+/** A radius, or {@link ZERO_RADIUS} for none. */
+const orZero = (radius) => {
+    if (Predicate.isUndefined(radius))
+        return ZERO_RADIUS;
+    return radius;
+};
+/**
+ * One radius component between `from` and `to` at `progress` (ADR-0010 *Amendment (#166)*, Motion's
+ * `mixValues`): mixed when both are the same unit or either is 0, as a `%` when either is one, and
+ * never below 0; otherwise `to` as it is. Per frame.
+ */
+const blendComponent = (from, to, progress) => {
+    const f = Number.parseFloat(from) || 0;
+    const t = Number.parseFloat(to) || 0;
+    const fromPercent = from.endsWith("%");
+    const toPercent = to.endsWith("%");
+    if (f !== 0 && t !== 0 && fromPercent !== toPercent)
+        return to;
+    const mixed = Math.max(f + (t - f) * progress, 0);
+    if (fromPercent || toPercent)
+        return `${mixed}%`;
+    return `${mixed}px`;
+};
+/**
+ * A border radius between a twin's and a Lead's at `progress` (ADR-0010 *Amendment (#166)*): corner by
+ * corner and axis by axis, `undefined` standing for no radius. What {@link borderRadiusCorrector}
+ * corrects while a handover blends. Per frame.
+ */
+export const blendRadius = (from, to, progress) => {
+    const b = orZero(to);
+    return orZero(from).map((corner, i) => blendCorner(corner, b[i], progress));
+};
+/** One corner between `from` and `to` at `progress`, axis by axis. Per frame. */
+const blendCorner = (from, to, progress) => {
+    if (Predicate.isUndefined(to))
+        return from;
+    return { h: blendComponent(from.h, to.h, progress), v: blendComponent(from.v, to.v, progress) };
+};
+/**
+ * `radius` as drawn under an own scale `(sx, sy)` (ADR-0010 *Amendment (#166)*): its px components
+ * scaled, its `%` ones as they are (a fraction of the scaled box already). Per frame.
+ */
+export const scaleRadius = (radius, sx, sy) => {
+    if (Predicate.isUndefined(radius))
+        return undefined;
+    if (sx === 1 && sy === 1)
+        return radius;
+    return radius.map((corner) => ({ h: scaleComponent(corner.h, sx), v: scaleComponent(corner.v, sy) }));
+};
+/** One radius component under an own scale: px scaled, `%` as it is. */
+const scaleComponent = (value, scale) => {
+    if (value.endsWith("%"))
+        return value;
+    return `${(Number.parseFloat(value) || 0) * scale}px`;
+};
+/** Split a `box-shadow` value into layers on TOP-LEVEL commas (ignoring `rgb(…)` commas). */
+const splitLayers = (value) => {
+    const layers = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < value.length; i++) {
+        const ch = value[i];
+        if (ch === "(")
+            depth++;
+        if (ch === ")")
+            depth--;
+        if (ch === "," && depth === 0) {
+            layers.push(value.slice(start, i));
+            start = i + 1;
+        }
+    }
+    layers.push(value.slice(start));
+    return layers;
+};
+/** Tokenise a layer, keeping parenthesised groups (e.g. `rgb(0, 0, 0)`) intact. */
+const tokenizeLayer = (layer) => {
+    const tokens = [];
+    let depth = 0;
+    let cur = "";
+    for (const ch of layer.trim()) {
+        if (ch === "(")
+            depth++;
+        if (ch === ")")
+            depth--;
+        if (/\s/.test(ch) && depth === 0) {
+            if (cur !== "")
+                tokens.push(cur);
+            cur = "";
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur !== "")
+        tokens.push(cur);
+    return tokens;
+};
+const isLength = (t) => Number.isFinite(Number.parseFloat(t));
+const parseLayer = (layer) => {
+    const tokens = tokenizeLayer(layer);
+    if (tokens.length === 0)
+        return undefined;
+    let inset = false;
+    const lengths = [];
+    let color = "";
+    for (const t of tokens) {
+        if (t === "inset") {
+            inset = true;
+            continue;
+        }
+        if (isLength(t)) {
+            lengths.push(Number.parseFloat(t));
+            continue;
+        }
+        color = t; // a non-length, non-inset token is the color (verbatim)
+    }
+    if (lengths.length < 2)
+        return undefined; // offsetX + offsetY are required
+    return {
+        color,
+        offsetX: lengths[0],
+        offsetY: lengths[1],
+        blur: lengthAt(lengths, 2),
+        spread: lengthAt(lengths, 3),
+        inset,
+        lengthCount: lengths.length,
+    };
+};
+/** A shadow's `i`th length, 0 when it wasn't authored. */
+const lengthAt = (lengths, i) => {
+    if (i >= lengths.length)
+        return 0;
+    return lengths[i];
+};
+const formatLayer = (l, sx, sy) => {
+    const mean = (sx + sy) / 2;
+    // Per-axis offsets exact; blur + spread are scalar -> axis mean (no exact value
+    // under non-uniform scale).
+    const lens = [l.offsetX / sx, l.offsetY / sy, l.blur / mean, l.spread / mean]
+        .slice(0, l.lengthCount)
+        .map((n) => `${n}px`);
+    const parts = [];
+    if (l.inset)
+        parts.push("inset");
+    parts.push(...lens);
+    if (l.color !== "")
+        parts.push(l.color);
+    return parts.join(" ");
+};
+export const boxShadowCorrector = {
+    key: "box-shadow", // kebab-case (see borderRadiusCorrector.key)
+    read: (el) => {
+        const value = getComputedStyle(el).boxShadow;
+        if (value === "" || value === "none")
+            return undefined;
+        const layers = splitLayers(value)
+            .map(parseLayer)
+            .filter(Predicate.isNotUndefined);
+        if (layers.length === 0)
+            return undefined;
+        return layers;
+    },
+    correct: (base, sx, sy) => base.map((l) => formatLayer(l, sx, sy)).join(", "),
+};
+/**
+ * The default scale-corrector registry (ADR-0011). Ship `borderRadius` +
+ * `boxShadow`; a public `addScaleCorrector` API is a deferred follow-up (adding
+ * an entry here is the extension point until then).
+ */
+export const SCALE_CORRECTORS = [borderRadiusCorrector, boxShadowCorrector];
+//# sourceMappingURL=scale-correction.js.map