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

package/dist/server/unstable/v2/presence.js

@@ -0,0 +1,142 @@
+var _m$ = Symbol();
+var _d$ = {
+  get() {
+    const Tracker = this[_m$];
+    return Tracker({});
+  },
+  enumerable: true,
+  configurable: true
+};
+function _P$(_p, _p2) {
+  this[_m$] = _p;
+  this.value = _p2;
+  Object.defineProperty(this, "children", _d$);
+}
+_P$.prototype = Object.prototype;
+var _d$2 = {
+  get() {
+    const Tracker = this[_m$];
+    return Tracker({});
+  },
+  enumerable: true,
+  configurable: true
+};
+function _P$2(_p3, _p4) {
+  this[_m$] = _p3;
+  this.value = _p4;
+  Object.defineProperty(this, "children", _d$2);
+}
+_P$2.prototype = Object.prototype;
+/**
+ * `<AnimatePresence>` on Solid 2 (#209, ADR-0007): exit-before-unmount for its children (many since
+ * #277, ADR-0048), and `mode="wait"`, as the Solid 1 binding's. Its work (each retained node, its parent-driven exit,
+ * the twins it hands back) is Solid-free, in `presence-controller.ts`. What's Solid 2's:
+ *
+ * - **The children are resolved with `children()`** under the presence's context, so each child's
+ *   ward registers its exit record with it.
+ * - **An effect tells the controller which elements are present,** in its apply: after Solid 2's
+ *   flush has applied the change, the leaving nodes removed. The controller puts them back before
+ *   the flush ends, so no paint shows them gone.
+ * - **Once settled** (`onSettledClientOnly`), the first render has ended, for `initial={false}` (#134).
+ *
+ * @module
+ */
+import { isServer } from "@solidjs/web";
+import * as Bool from "effect/Boolean";
+import { constUndefined } from "effect/Function";
+import * as Option from "effect/Option";
+import * as UndefinedOr from "effect/UndefinedOr";
+import { children, createContext, createEffect, createMemo, createSignal, onCleanup, untrack, useContext } from "solid-js";
+import { makePresence, propagateTo } from "../../presence-controller.js";
+import { useBuiltProjection, useWardicDefaultTransition, useWardicPositionalKeys, useWardicReducedMotion, useWardicRenderer, useWardicRuntime } from "./provider.js";
+import { CLIENT_ONLY, onSettledClientOnly } from "./solid-reactivity.js";
+import { hasRef, makePresenceHandle, serverPresenceHandle } from "./presence-handle.js";
+/**
+ * The nearest `<AnimatePresence>`'s registrar, `null` outside one: Solid 2 takes an `undefined`
+ * default for none and then throws in `useContext`.
+ */
+export const PresenceContext = createContext(null);
+/** The nearest `<AnimatePresence>`'s registrar, `undefined` outside one. */
+export const usePresenceContext = () => Option.getOrUndefined(Option.fromNullishOr(useContext(PresenceContext)));
+/**
+ * Wraps its children (a conditional one, `<Show>`, or a `<For>`'s) and animates each one's exit
+ * before it's removed: each that leaves exits in its place, and one that comes back mid-exit
+ * is a new node, entering beside the leaver, or, with the leaver's `key` on its Wardic element,
+ * taking over from where the leaver is.
+ * A leaving child runs its own `exit` if it's a `wardic.*` element or an element with a ward on
+ * it, and the exits of the Wardic elements inside it either way, staying until they've ended; a
+ * plain child with nothing inside it to wait for goes at once. Inside a `<WardicProvider>`.
+ */
+export function AnimatePresence(props) {
+  // A server render has no exit to drive: the same boundaries, a context that registers nothing.
+  // eslint-disable-next-line solid/components-return-once -- `isServer` is a constant: the component takes one path for its life
+  if (isServer) return serverPresence(props);
+  // Its own handle, made only when `ref` is given (#257): its exits are told to it, and it's handed to `ref`.
+  const ref = untrack(() => props.ref);
+  const own = Bool.match(hasRef(ref), {
+    onTrue: makePresenceHandle,
+    onFalse: constUndefined
+  });
+  // `mode="wait"`'s held children may go on the page (#277): the children are rendered again.
+  const [released, release] = createSignal(undefined, {
+    equals: false
+  });
+  // The presence above, if any (#277's PR 5c): read before this one provides its own.
+  const parent = usePresenceContext();
+  const presence = makePresence({
+    runtime: useWardicRuntime(),
+    renderer: useWardicRenderer(),
+    projection: useBuiltProjection(),
+    reducedMotion: useWardicReducedMotion(),
+    positionalKeys: useWardicPositionalKeys(),
+    defaultTransition: useWardicDefaultTransition(),
+    initial: () => untrack(() => props.initial),
+    events: UndefinedOr.map(own, handle => handle.events),
+    mode: () => props.mode,
+    custom: () => untrack(() => props.custom),
+    anchorX: () => untrack(() => props.anchorX),
+    anchorY: () => untrack(() => props.anchorY),
+    presenceAffectsLayout: () => untrack(() => props.presenceAffectsLayout),
+    release: () => release(undefined)
+  });
+  UndefinedOr.map(own, handle => ref(handle.handle));
+  onSettledClientOnly(presence.mounted);
+  // `propagate` (#277's PR 5c): with a presence above, its teardown waits to hear whether this one's
+  // child left. Read before this presence provides its own context.
+  onCleanup(propagateTo(parent, untrack(() => props.propagate) === true, presence));
+  // Resolved under the context, so the child's ward sees it.
+  const Tracker = () => {
+    const resolved = children(() => props.children);
+    // What goes on the page (#277): every child, but under `mode="wait"` one entering is held off it
+    // while a child exits. The controller is told what went on.
+    const shown = createMemo(() => {
+      released();
+      return presence.shown(resolved());
+    }, CLIENT_ONLY);
+    createEffect(shown, current => {
+      presence.present(current);
+    }, CLIENT_ONLY);
+    return shown;
+  };
+  // Its `custom`, reactive, for `usePresenceData` (#277's PR 5b).
+  const context = {
+    ...presence.context,
+    data: () => props.custom
+  };
+  return PresenceContext(new _P$(Tracker, context));
+}
+/** {@link AnimatePresence} during a server render: the client's boundaries, nothing to track. */
+const serverPresence = props => {
+  // A `ref` is handed the server's handle, on which nothing exits (#257).
+  const ref = untrack(() => props.ref);
+  if (hasRef(ref)) ref(serverPresenceHandle());
+  // A server renders once: every child is set up with the first render (#134).
+  const context = {
+    register: () => () => {},
+    blocksInitial: () => untrack(() => props.initial) === false,
+    data: () => props.custom
+  };
+  const Tracker = () => children(() => props.children);
+  return PresenceContext(new _P$2(Tracker, context));
+};
+//# sourceMappingURL=presence.js.map

package/dist/server/unstable/v2/presence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"presence.js","names":["Tracker","enumerable","configurable","_P$","_p","_p2","_m$","value","Object","defineProperty","_d$","prototype","_d$2","get","_P$2","_p3","_p4","isServer","Bool","constUndefined","Option","UndefinedOr","children","createContext","createEffect","createMemo","createSignal","onCleanup","untrack","useContext","makePresence","propagateTo","useBuiltProjection","useWardicDefaultTransition","useWardicPositionalKeys","useWardicReducedMotion","useWardicRenderer","useWardicRuntime","CLIENT_ONLY","onSettledClientOnly","hasRef","makePresenceHandle","serverPresenceHandle","PresenceContext","usePresenceContext","getOrUndefined","fromNullishOr","AnimatePresence","props","serverPresence","ref","own","match","onTrue","onFalse","released","release","undefined","equals","parent","presence","runtime","renderer","projection","reducedMotion","positionalKeys","defaultTransition","initial","events","map","handle","mode","custom","anchorX","anchorY","presenceAffectsLayout","mounted","propagate","resolved","shown","current","present","context","data","register","blocksInitial"],"sources":["../../../../src/unstable/v2/presence.tsx"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/dist/server/unstable/v2/press-sensor.js

@@ -0,0 +1,29 @@
+import { press } from "../../features/press.js";
+import { PressGesture } from "../../features/keys.js";
+import { serviceOf } from "../../gesture-features.js";
+import { useBrought } from "./provider.js";
+import { watchSensorOf } from "./sensors.js";
+/** What it brings (ADR-0067 decision 12): its gesture's Feature, whatever its section has (#511). */
+const PRESS = [press];
+/**
+ * `true` while the element it's given to as a `ref` is pressed, by a pointer held down on it or by
+ * Enter or Space while it has focus, `false` once it's released or the press is cancelled. An element
+ * that takes no focus of itself is given `tabindex="0"`, so a keyboard can press it.
+ *
+ * @example
+ * const pressed = createPress()
+ * <button ref={pressed}>{pressed() ? "Holding" : "Press and hold"}</button>
+ * @see https://wardic.dev/reference/solid/gestures/create-press
+ */
+// The core press watch; a Keyboard press (#427).
+export const createPress = () => {
+  const services = useBrought(PRESS);
+  return watchSensorOf((target, {
+    on,
+    onDefect
+  }) => serviceOf(services(), PressGesture).watch(target, {
+    on: press => on(press.phase === "start"),
+    onDefect
+  }), false);
+};
+//# sourceMappingURL=press-sensor.js.map

package/dist/server/unstable/v2/press-sensor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"press-sensor.js","names":["press","PressGesture","serviceOf","useBrought","watchSensorOf","PRESS","createPress","services","target","on","onDefect","watch","phase"],"sources":["../../../../src/unstable/v2/press-sensor.ts"],"sourcesContent":[null],"mappings":"AAOA,SAASA,KAAK,QAAQ,yBAAyB;AAC/C,SAASC,YAAY,QAAQ,wBAAwB;AACrD,SAASC,SAAS,QAAQ,2BAA2B;AACrD,SAASC,UAAU,QAAQ,eAAgB;AAC3C,SAAsBC,aAAa,QAAQ,cAAc;AAEzD;AACA,MAAMC,KAAK,GAA2B,CAACL,KAAK,CAAC;AAE7C;;;;;;;;;;AAUA;AACA,OAAO,MAAMM,WAAW,GAAGA,CAAA,KAAsB;EAC/C,MAAMC,QAAQ,GAAGJ,UAAU,CAACE,KAAK,CAAC;EAClC,OAAOD,aAAa,CAAU,CAACI,MAAM,EAAE;IAAEC,EAAE;IAAEC;EAAQ,CAAE,KAAKR,SAAS,CAACK,QAAQ,EAAE,EAAEN,YAAY,CAAC,CAACU,KAAK,CAACH,MAAM,EAAE;IAAEC,EAAE,EAAGT,KAAK,IAAKS,EAAE,CAACT,KAAK,CAACY,KAAK,KAAK,OAAO,CAAC;IAAEF;EAAQ,CAAE,CAAC,EAAE,KAAK,CAAC;AACjL,CAAC","ignoreList":[]}

package/dist/server/unstable/v2/provider.js

@@ -0,0 +1,475 @@
+var _m$ = Symbol();
+var _d$ = {
+  get() {
+    const props = this[_m$];
+    return props.children;
+  },
+  enumerable: true,
+  configurable: true
+};
+function _P$(_p, _p2) {
+  this[_m$] = _p;
+  this.value = _p2;
+  Object.defineProperty(this, "children", _d$);
+}
+_P$.prototype = Object.prototype;
+var _d$2 = {
+  get() {
+    const props = this[_m$];
+    return props.children;
+  },
+  enumerable: true,
+  configurable: true
+};
+function _P$2(_p3, _p4) {
+  this[_m$] = _p3;
+  this.value = _p4;
+  Object.defineProperty(this, "children", _d$2);
+}
+_P$2.prototype = Object.prototype;
+/**
+ * `WardicProvider` for Solid 2 (`@wardic/solid/unstable/v2`, #209): one Effect runtime for a
+ * subtree, as the Solid 1 binding's provider (`../../provider.tsx`), over the same runtime and
+ * services (`../../runtime.ts`). What Solid 2 changes:
+ *
+ * - **No `batch`.** Solid 2 batches every update on a microtask, and a read lags its setter until
+ *   then. The flush gate needs a frame's Starting-style switches to have reached the elements
+ *   before it commits (ADR-0034), so it gets `flush(apply)`: the switches set their signals in a
+ *   synchronous flush scope, drained as it returns, with no microtask scheduled for them (#257
+ *   item 12). The gate runs them from its frame flush, outside any owner, where Solid 2 lets a
+ *   signal be written.
+ * - **A context value is its own provider** (`<WardicContext value={…}>`).
+ * - **`onSettled`** opens the Hydration hold where Solid 1 had `onMount` (`onSettledClientOnly`: a
+ *   server starts nothing, so it takes no hydration id).
+ * - **Appear animations' `<style>` goes through the head registry** (`useHead`, #209 PR 4a) where
+ *   Solid 1 had `useAssets`. Registered on the server only, in its function form, which the server
+ *   reads when it writes the head, once the shell has rendered: every element is entered then, with
+ *   its timing. A client never registers it, and leaves the server's in the head. A late chunk's
+ *   elements register their own, which streams with the chunk as a head patch (`ward.tsx`).
+ *
+ * @module
+ */
+import * as Bool from "effect/Boolean";
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+import { constUndefined, identity } from "effect/Function";
+import * as Latch from "effect/Latch";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as UndefinedOr from "effect/UndefinedOr";
+import { isServer, useHead } from "@solidjs/web";
+import { createContext, DEV, flush, isHydrating, onCleanup, onSettled, runWithOwner, untrack, useContext } from "solid-js";
+import * as Context from "effect/Context";
+import * as Report from "@wardic/dom/Report";
+import { ROOT, strictMessage } from "../../feature.js";
+import { FeatureSectionContext, sectionUnder, useLazySection } from "./feature-section.js";
+import { explainerOf, serverAppear } from "../../appear.js";
+import { animateLayoutOf, clientContext, fromContext, interrupted, prepareIdle, reducedMotionSettingWith, reducedMotionWith, reported, serverContext, whenIdle } from "../../runtime.js";
+import { onSettledClientOnly } from "./solid-reactivity.js";
+import { useWardicConfig } from "./wardic-config.js";
+import { skipAnimationsOf } from "../../wardic-config-value.js";
+import { instantLayoutOf, instantTransitionOf, resetOf } from "../../instant.js";
+/** A frame's Starting-style switches, applied and drained before the gate commits (ADR-0034): Solid 2's `batch`. */
+const applyAndFlush = apply => {
+  flush(apply);
+};
+/**
+ * The runtime and services a provider carries down its subtree; `null` outside one. Solid 2 takes
+ * an `undefined` default for none, and its `useContext` then throws its own error outside a
+ * provider: `null` keeps Wardic's, which names the hook.
+ */
+const WardicContext = createContext(null);
+/** The nearest provider's value, `undefined` outside one. */
+const contextValue = () => Option.getOrUndefined(Option.fromNullishOr(useContext(WardicContext)));
+/**
+ * Puts Wardic in your app: every Wardic element sits under one. Give it the Environment, `DomLive` in
+ * a browser, and the Features your elements use.
+ *
+ * @example
+ * <WardicProvider env={DomLive} features={[domAnimation]}>
+ *   <App />
+ * </WardicProvider>
+ * @see https://wardic.dev/reference/solid/provider/wardic-provider
+ */
+// As the Solid 1 binding's: one runtime made once from `env` (#51: built on first need), disposed on
+// unmount, inert during a server render (ADR-0021). reducedMotion is read as each animation starts
+// (ADR-0029), a WardicConfig's over it (#434); appear (ADR-0044, #585) on the server once.
+export function WardicProvider(props) {
+  const value = Bool.match(isServer, {
+    onTrue: () => serverContext(props.env, serverAppearOf(props.appear, props.reducedMotion, props.nonce), () => untrack(() => props.reducedMotion)),
+    onFalse: () => clientContext(props.env, applyAndFlush, () => untrack(() => props.reducedMotion),
+    // eslint-disable-next-line solid/reactivity -- the provider's setting, tracked too: `createReducedMotionConfig` reads it where it tracks (#584)
+    () => props.reducedMotion, untrack(() => props.scaleCorrectors))
+  });
+  // Disposing the runtime closes its Scope: the projection system, then the gate (#132). Its
+  // disposal rejects first, ending every `animateLayout` still waiting: their flights won't end (#257).
+  let abort = constUndefined;
+  const disposed = new Promise((_, reject) => {
+    abort = reject;
+  });
+  // Each waiting call races it and handles it; with none, it's handled here.
+  disposed.catch(constUndefined);
+  disposals.set(value, disposed);
+  onCleanup(() => {
+    abort(new DOMException("The WardicProvider was disposed before its layout animations ended.", "AbortError"));
+    // Its Features end first, then the runtime they stand on (#511).
+    void value.features.dispose();
+  });
+  const section = sectionOf(value, ROOT, props);
+  sections.set(value, section);
+  // Built at the browser's idle time, after this render (#535): what a first element would build, so an
+  // element mounted after pays none of it. One mounted before then builds it itself, as before. Asked
+  // for here, with no computation of the provider's own (an `onSettled`'s would shift a hydration's
+  // owners from the server's), and on the client alone.
+  if (Bool.not(isServer)) onCleanup(whenIdle(() => prepareIdle(value, section)));
+  return WardicContext(new _P$(props, value));
+}
+/**
+ * Each provider's own section (#511): its Features, the first section of its tree. Kept beside its
+ * context value, not in a context of its own, so a provider renders one context, as before.
+ */
+// Module state (#460, Q7): each provider's root section, held weakly by its context value.
+const sections = new WeakMap();
+/**
+ * The section an element is in (#511): the nearest `LazyWardic`'s, else its provider's own; outside a
+ * provider, none. Internal.
+ */
+export function useFeatureSection() {
+  return UndefinedOr.match(useLazySection(), {
+    onDefined: identity,
+    onUndefined: () => UndefinedOr.match(contextValue(), {
+      onUndefined: () => ROOT,
+      onDefined: value => UndefinedOr.getOrThrow(sections.get(value))
+    })
+  });
+}
+/**
+ * The section `props` make under `parent` (#511), on `value`'s registry: a failed lazy load reported
+ * as a fiber's failure is (ADR-0030, decision 4).
+ */
+const sectionOf = (value, parent, props) => sectionUnder(parent, value.features, untrack(() => props.features), untrack(() => props.strict) === true, cause => {
+  value.runtime.runFork(Report.failure("wardic.features: a lazy load of Features failed", cause));
+});
+/**
+ * Gives the `w.*` elements in its section more Features, beside their provider's: at once
+ * (`features={[drag]}`), or loaded with a function, which runs as the section renders, so a page loads
+ * a Feature only when it needs it. Motion's `LazyMotion`.
+ *
+ * @example
+ * <LazyWardic features={() => import("./drag-feature").then((m) => m.drag)}>
+ *   <w.div drag />
+ * </LazyWardic>
+ * @see https://wardic.dev/reference/solid/provider/lazy-wardic
+ */
+// #511, ADR-0067, as the Solid 1 binding's: given at once, built at first need; loaded lazily, each
+// Feature takes effect as it arrives (#551, #582). A failed load is reported once; a server loads nothing.
+export function LazyWardic(props) {
+  const section = fromContext(contextValue(), "LazyWardic", value => sectionOf(value, useFeatureSection(), props));
+  return FeatureSectionContext(new _P$2(props, section));
+}
+/**
+ * The Features an element has (#511): its section's, and those it brings, a Complete element's every
+ * one (`brings`), built at once. A Complete element under a `strict` section is an error in
+ * development. Internal.
+ */
+export function useElementFeatures(brings, complete) {
+  const section = useFeatureSection();
+  if (DEV && complete && section.strict) throw new Error(strictMessage("wardic.*, wardic.create, ward()", "w.*, w.create, w.ward()"));
+  if (Predicate.isUndefined(brings)) return section;
+  const registry = useFeatureRegistry();
+  // A Complete element has every Feature, whatever its section has: one section per provider.
+  if (complete) return registry.section(brings);
+  const own = registry.build(brings);
+  return {
+    services: () => Context.merge(section.services(), own),
+    pending: section.pending,
+    strict: section.strict
+  };
+}
+/** The provider's Features (#511). Internal. */
+export function useFeatureRegistry() {
+  return fromContext(contextValue(), "useFeatureRegistry", value => value.features);
+}
+/**
+ * The services of `features`, which a hook or component brings (#511, decision 12) whatever its
+ * section has: built the first time they're read, on the client. `features` is a list the caller keeps,
+ * so its provider joins it once. Internal.
+ */
+export function useBrought(features) {
+  const registry = useFeatureRegistry();
+  return () => registry.build(features);
+}
+/** Each client provider's disposal (#257): a promise that rejects with an `AbortError` then. */
+// Module state (#460, Q7): each provider's disposal, held weakly by its context value.
+const disposals = new WeakMap();
+/**
+ * A server render's Appear animations (#48, ADR-0044), with the head's `<style>` registered for
+ * them, or `undefined` with `appear={false}`. Each element takes a slot as it renders; the head
+ * gets every rule and timing once the shell has rendered.
+ */
+const serverAppearOf = (appear, reducedMotion, nonce) => {
+  if (appear === false) return undefined;
+  const state = serverAppear(UndefinedOr.match(reducedMotion, {
+    onUndefined: () => "user",
+    onDefined: identity
+  }), explainerOf(appear), nonce);
+  useHead(appearStyle(() => state.css(), nonce));
+  return state;
+};
+/**
+ * The head tags for an Appear `<style>` whose CSS `css` gives, in `useHead`'s function form: read
+ * when the server writes the head, and once, so a second read can't find it written already. No
+ * tag when there's none to write. With a `nonce` (#618, P1), the tag carries it. Internal: the
+ * provider's, and a late chunk's (`ward.tsx`).
+ */
+export const appearStyle = (css, nonce) => {
+  let tags;
+  return () => {
+    if (Predicate.isUndefined(tags)) tags = styleTags(css(), nonce);
+    return tags;
+  };
+};
+const styleTags = (css, nonce) => {
+  if (css === "") return [];
+  if (Predicate.isUndefined(nonce)) return [{
+    tag: "style",
+    props: {
+      "data-wardic-appear": "",
+      children: css
+    }
+  }];
+  return [{
+    tag: "style",
+    props: {
+      "data-wardic-appear": "",
+      nonce,
+      children: css
+    }
+  }];
+};
+/** A server render's Appear animations; `undefined` on the client, or with `appear={false}`. Internal. */
+export function useWardicAppear() {
+  return UndefinedOr.match(contextValue(), {
+    onUndefined: constUndefined,
+    onDefined: value => value.appear
+  });
+}
+/**
+ * The nearest `WardicProvider`'s Effect runtime, for running Effect code on Wardic's services: its
+ * clock, frame loop, renderer, probe and the rest. Throws outside a provider. During a server render
+ * it isn't built: hold it, but run on it only once the element has mounted.
+ *
+ * @example
+ * const runtime = useWardicRuntime()
+ * onSettled(() => {
+ *   runtime.runFork(Effect.log("mounted"))
+ * })
+ * @see https://wardic.dev/reference/solid/advanced/runtime
+ */
+// ADR-0021: a server builds no runtime, and DomLive refuses with its client-only error.
+export function useWardicRuntime() {
+  return fromContext(contextValue(), "useWardicRuntime", value => value.runtime);
+}
+/**
+ * The nearest `WardicProvider`'s flush gate: what a binding registers its elements with, and writes
+ * their values into, committed once a frame. For building an element of your own on Wardic's
+ * rendering. Throws outside a provider; during a server render it's an inert gate that does nothing.
+ *
+ * @see https://wardic.dev/reference/solid/advanced/flush-gate
+ */
+// ADR-0006; inert on a server (ADR-0021, decision 9).
+export function useWardicGate() {
+  return fromContext(contextValue(), "useWardicGate", value => value.gate);
+}
+/** The Environment's Renderer (ADR-0003), read once by the provider: what an element and a presence project and commit through. Internal. */
+export function useWardicRenderer() {
+  return fromContext(contextValue(), "useWardicRenderer", value => value.renderer);
+}
+/** The Environment's Positional keys (ADR-0036): which keys reduced motion Snaps. Internal. */
+export function useWardicPositionalKeys() {
+  return fromContext(contextValue(), "useWardicPositionalKeys", value => value.positionalKeys);
+}
+/** The Environment's Default transition (ADR-0051): what a key with no transition of its own runs on. Internal. */
+export function useWardicDefaultTransition() {
+  return fromContext(contextValue(), "useWardicDefaultTransition", value => value.defaultTransition);
+}
+/**
+ * Whether reduced motion applies now (ADR-0029): the nearest `WardicConfig`'s `reducedMotion` (#434),
+ * else the provider's, and the user's preference; always `false` during a server render. Internal.
+ */
+export function useWardicReducedMotion() {
+  const config = useWardicConfig();
+  return fromContext(contextValue(), "useWardicReducedMotion", value => reducedMotionWith(value, config));
+}
+/**
+ * Whether the elements here skip their animations now (#468): the nearest `WardicConfig`'s
+ * `skipAnimations`, or the provider's Instant change while one runs (#443). Read when each starts.
+ * Internal.
+ */
+export function useWardicSkipAnimations() {
+  const config = skipAnimationsOf(useWardicConfig());
+  const value = contextValue();
+  if (Predicate.isUndefined(value)) return config;
+  const instant = value.instant;
+  return () => Bool.or(instant.active(), config());
+}
+/**
+ * Makes a layout change land at once: `start(fn)` runs `fn`, and every layout element goes straight
+ * to its new box, a running layout animation ending there too. The change's other animations run as
+ * ever. `start()` with no function does the same for a change made later in the task. Motion's
+ * `useInstantLayoutTransition`. On a server it runs `fn`.
+ *
+ * @example
+ * const start = createInstantLayoutTransition()
+ * start(() => setOrder(sorted()))
+ * @see https://wardic.dev/reference/solid/layout/create-instant-layout-transition
+ */
+// #443, as Solid 1's: an Instant change of the layout, the projection system's `instant`.
+export function createInstantLayoutTransition() {
+  return fromContext(contextValue(), "createInstantLayoutTransition", value => instantLayoutOf(() => value.projection));
+}
+/**
+ * Makes a change land at once, with no animation: `start(fn)` runs `fn`, and its layout change and
+ * every animation that starts until two frames after the call land where they're going. A later call
+ * extends it, and `start.end()` ends it now. For a change that shouldn't animate: a reset, a jump to
+ * a route. Motion's `useInstantTransition`.
+ *
+ * @example
+ * const start = createInstantTransition()
+ * <button onClick={() => start(() => setOpen(all))}>Open all</button>
+ * @see https://wardic.dev/reference/solid/layout/create-instant-transition
+ */
+// #443, as Solid 1's: an Instant change, each animation it covers a Skipped animation (#468).
+export function createInstantTransition() {
+  return fromContext(contextValue(), "createInstantTransition", value => instantTransitionOf(() => value.projection, () => value.instant));
+}
+/**
+ * Starts layout animations afresh: `reset()` ends every running layout animation where the layout puts
+ * its element, lets go of every leaving `layoutId` element, and has the next measure take every box as
+ * it is, animating none. For a change that replaces the page wholesale. Motion's `useResetProjection`.
+ * On a server it does nothing.
+ *
+ * @example
+ * const reset = createResetProjection()
+ * const openWorkspace = (id: string) => {
+ *   reset()
+ *   setWorkspace(id)
+ * }
+ * @see https://wardic.dev/reference/solid/layout/create-reset-projection
+ */
+// #443, as Solid 1's: a Projection reset, the projection system's `reset`: leavers and Switch seeds dropped.
+export function createResetProjection() {
+  return fromContext(contextValue(), "createResetProjection", value => resetOf(() => value.projection));
+}
+/**
+ * The reduced-motion setting that applies here (#443): the nearest `WardicConfig`'s `reducedMotion`,
+ * else the provider's, else `"user"`, each tracked (#584). Internal.
+ */
+export function useWardicReducedMotionSetting() {
+  const config = useWardicConfig();
+  return fromContext(contextValue(), "useWardicReducedMotionSetting", value => reducedMotionSettingWith(value, config));
+}
+/**
+ * `read` of the nearest provider's context value, named `name` in the error outside one: for a hook in
+ * a module of its own (#548), such as `useWardicProjection`, which brings `layout`.
+ */
+export const fromWardicContext = (name, read) => fromContext(contextValue(), name, read);
+/**
+ * The provider's projection system once its `layout` Feature is built (#511), read as it's needed;
+ * `undefined` until then, and during a server render. For what brings no `layout` and works with the
+ * layout elements that are there: an element registering its values, a presence. Internal.
+ */
+export function useBuiltProjection() {
+  return fromContext(contextValue(), "useBuiltProjection", value => () => value.projection);
+}
+/**
+ * Animates a layout change you make: `animateLayout(fn)` runs `fn`, and every layout element animates
+ * from where it was at the call to where the change puts it. For a change nothing else sees, such as a
+ * keyed `<For>` reordered or a plain element's class changed. A write Solid holds, inside an `action`
+ * or beside a write that starts async work, animates once it lands. Its promise resolves with what
+ * `fn` returns once the animations it started have ended. Only what `fn` changes synchronously
+ * animates. Throws outside a `WardicProvider`.
+ *
+ * @example
+ * const animateLayout = useAnimateLayout()
+ * const shuffle = () => animateLayout(() => setItems(shuffled(items())))
+ * @see https://wardic.dev/reference/solid/layout/use-animate-layout
+ */
+export function useAnimateLayout() {
+  const value = contextValue();
+  const declare = animateLayoutOf(value);
+  const disposed = UndefinedOr.match(value, {
+    onUndefined: constUndefined,
+    onDefined: v => disposals.get(v)
+  });
+  return fn => {
+    // A server render has nothing to animate, and never settles.
+    if (isServer) return Promise.resolve(declare(fn));
+    let settle = constUndefined;
+    const settled = new Promise(resolve => {
+      settle = resolve;
+    });
+    // A throw from `fn` is thrown here: `settled` is just dropped, unsettled.
+    const result = declare(fn);
+    // Once what the call is part of has settled, a pass from the boxes the last one kept: it folds into
+    // the call's own when nothing was held, and measures a write Solid 2 held (inside an action, or in
+    // the frame of a write that started async work) once it lands. The promise waits for that pass's
+    // animations (#618, decision 13). Unowned, so it runs once whatever the caller's owner does: an
+    // owner disposed first would drop it, and the promise with it.
+    runWithOwner(null, () => onSettled(() => {
+      declare(constUndefined, {
+        from: "lastPass",
+        onSettled: () => settle()
+      });
+    }));
+    const waiting = UndefinedOr.match(disposed, {
+      onUndefined: () => settled,
+      onDefined: gone => Promise.race([settled, gone])
+    });
+    return waiting.then(() => result);
+  };
+}
+/**
+ * Runs `effect` on `runtime`, and interrupts it as the current owner is cleaned up, its Scope closed
+ * with it. Returns its fiber. A failure is logged and reported to the Environment's error reporters;
+ * an interruption is neither. On a server it starts nothing, and while hydrating it starts once its owner has settled.
+ * Call it within a Solid owner.
+ *
+ * @example
+ * runScoped(runtime, Stream.runForEach(ticks, (t) => Effect.sync(() => setTick(t))))
+ * @see https://wardic.dev/reference/solid/advanced/runtime
+ */
+// ADR-0006: the per-element fiber lifecycle; a failure is `wardic.runScoped: a fiber failed`
+// (ADR-0030, decision 4); the Hydration hold (ADR-0021 decisions 8 and 9).
+export function runScoped(runtime, effect) {
+  if (isServer) return interrupted();
+  const run = reported(effect);
+  if (isHydrating()) {
+    const latch = Latch.makeUnsafe(false);
+    const held = runtime.runFork(Effect.andThen(latch.await, run));
+    onSettledClientOnly(() => {
+      latch.openUnsafe();
+    });
+    onCleanup(() => held.interruptUnsafe());
+    return held;
+  }
+  const fiber = runtime.runFork(run);
+  // Interrupted where the cleanup runs, nothing waiting on its end, as `runCallback`'s interruptor
+  // does: a forked `Fiber.interrupt` was a fiber of its own for each (#618, L2).
+  onCleanup(() => fiber.interruptUnsafe());
+  return fiber;
+}
+/**
+ * Runs the Effect `effectThunk` makes on the provider's runtime, as `runScoped` does, until the
+ * current owner is cleaned up. The thunk is called once; not on a server. Returns its fiber.
+ *
+ * @example
+ * useWardicFiber(() => Stream.runForEach(ticks, (t) => Effect.sync(() => setTick(t))))
+ * @see https://wardic.dev/reference/solid/advanced/runtime
+ */
+export function useWardicFiber(effectThunk) {
+  const runtime = useWardicRuntime();
+  if (isServer) return interrupted();
+  return runScoped(runtime, effectThunk());
+}
+//# sourceMappingURL=provider.js.map