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

package/src/variants.ts

@@ -0,0 +1,47 @@
+/**
+ * Variant context — the binding-owned channel that propagates the current
+ * variant NAME (not resolved values) down the component tree (ADR-0007).
+ *
+ * The doctrine: through the tree the binding propagates the parent's current
+ * variant *name* plus the inherited transition; each child holds its own
+ * `variants` map and resolves the inherited name LOCALLY (a child's `"open"` is
+ * independent of its siblings'). A target then resolves by priority:
+ *
+ *   local `animate` > parent-context variant name > `initial`.
+ *
+ * This file owns only the context plumbing; the value's types are Solid-free, in `variant-tree.ts` (#209). `variant-node.ts` decides what each element
+ * provides and whether it joins its ancestor (CONTEXT.md, **Variant child**); every
+ * `wardic.*` element, component wrap and `<Reorder.Item>` provides it, and a `createWard`
+ * spread publishes it through `ward.Provider` (#50).
+ *
+ * Extensibility (ADR-0007, step 21b): the context value is intentionally an
+ * open object — registry / stagger / `when` fields are added later as OPTIONAL
+ * members, so adding them never breaks existing readers (they only read the
+ * fields they know about).
+ */
+import { createContext, useContext } from "solid-js"
+import type { WardicVariantContextValue } from "./variant-tree.ts"
+
+export type { WardicChildRegistration, WardicStaggerConfig, WardicVariantContextValue } from "./variant-tree.ts"
+
+/**
+ * The variant context: what the nearest variant parent hands its children, its names, transition and
+ * orchestration. Wardic's elements read it to follow their parent's variants; a binding of your own
+ * provides or reads it the same way. `undefined` outside a parent.
+ *
+ * @see https://wardic.dev/reference/solid/advanced/variant-context
+ */
+// ADR-0007.
+export const WardicVariantContext = createContext<WardicVariantContextValue | undefined>(undefined)
+
+/**
+ * The nearest variant parent's context, or `undefined` outside one: its current variant name,
+ * `initial`, transition and orchestration, for an element of your own that follows a parent's variants.
+ *
+ * @example
+ * const parent = useVariantContext()
+ * const name = () => parent?.variant()
+ * @see https://wardic.dev/reference/solid/advanced/variant-context
+ */
+// ADR-0007: local `animate` over the inherited name over `initial`.
+export const useVariantContext = (): WardicVariantContextValue | undefined => useContext(WardicVariantContext)

package/src/w.tsx

@@ -0,0 +1,59 @@
+/**
+ * `w` — the **Slim element**'s forms (#511, ADR-0067 decision 6; Motion's `m`): `w.<tag>`,
+ * `w.create(tag | Component)`, `w.createWard(config)` and the `use:w` directive, each as its
+ * `wardic` form is. A Slim element animates values (`initial`, `animate`, `exit`, variants,
+ * transitions, Keyframes), with the **Features** chosen above it: its `WardicProvider`'s and every
+ * `LazyWardic`'s between them. This module names no Feature, so an app of Slim elements ships only
+ * those it chooses.
+ *
+ * ```tsx
+ * <WardicProvider env={DomLive} features={[colors]}>
+ *   <w.div animate={{ color: "oklch(0.7 0.1 200)" }} />
+ * </WardicProvider>
+ * ```
+ *
+ * @module
+ */
+import type { Accessor, JSX } from "solid-js"
+import type { WardConfig, WardicVariantLabels } from "./config.ts"
+import { createWardWith, type SpineInternals, type Ward } from "./create-ward.tsx"
+import { runDirective } from "./directive.ts"
+import { type Create, createOf, formOf, type WardicComponent } from "./element.tsx"
+import type { InferredMotion, TargetKey } from "./ward-keys.ts"
+
+/** What a Slim element tells the spine: it brings no Feature of its own. */
+const SLIM: SpineInternals = {}
+
+/** The `use:w` directive. An arrow function, as `use:wardic`'s is. */
+const wDirective = (el: HTMLElement, value: Accessor<WardConfig>): void => runDirective(el, value, SLIM)
+
+/** `w.createWard(config)`: `createWard`'s Ward on a Slim element. */
+function createSlimWard<
+  K extends TargetKey = never,
+  N extends string = never,
+  LI extends WardicVariantLabels = never,
+  LA extends WardicVariantLabels = never,
+  D extends boolean | "x" | "y" = never,
+>(config: InferredMotion<WardConfig, K, N, LI, LA, D> | Accessor<InferredMotion<WardConfig, K, N, LI, LA, D>>): Ward {
+  return createWardWith(config as WardConfig | Accessor<WardConfig>, SLIM)
+}
+
+/** The typed `w` proxy: called, it's the `use:w` directive; `w.create`, `w.createWard` and `w.<tag>` are its forms. */
+export type W = ((el: HTMLElement, value: Accessor<WardConfig>) => void) & {
+  readonly create: Create
+  readonly createWard: typeof createSlimWard
+} & {
+  readonly [Tag in keyof JSX.IntrinsicElements]: WardicComponent<Tag>
+}
+
+/**
+ * The Slim element: `w.div`, `w.button` and every other tag, each taking the element's own props and
+ * Wardic's motion props. It has the Features its `WardicProvider` and any `LazyWardic` above it give.
+ * `w.create(Component)` makes your own component one, `w.createWard(config)` a ward for an element of
+ * your own, and `use:w={config}` the same as a directive. Motion's `m.div`.
+ *
+ * @example <w.div initial={{ opacity: 0 }} animate={{ opacity: 1 }} />
+ * @see https://wardic.dev/reference/solid/elements/w
+ */
+// Every form of the Slim element, as `wardic`'s are of the Complete one (ADR-0067).
+export const w: W = formOf<W>(wDirective, createOf(SLIM), { createWard: createSlimWard })

package/src/ward-keys.ts

@@ -0,0 +1,343 @@
+/**
+ * The keys a ward can read, typed from its config (#209 PR 3's Q4): completion offers every key the
+ * config animates, through `initial`, `animate`, `exit`, any variant, `whileHover`, `whileTap`,
+ * `whileDrag` or `style`, and `x`/`y` when it drags; any other key is still accepted (a custom
+ * property, a config built at run time). A config typed as a plain `WardConfig` offers every key.
+ *
+ * And a config's transitions' entries, checked against the keys each drives (#301's PR 2,
+ * {@link WardCheckedConfig}): Solid 2's `ward()` checks its config so.
+ *
+ * And a Wardic element's keys, inferred from its targets alone (#305, {@link InferredMotion}): the
+ * `wardic.*` components of both bindings and Solid 1's `createWard` check their transitions so.
+ * Types only.
+ *
+ * @module
+ */
+import type * as Machine from "@wardic/core/Machine"
+import type { Atom } from "effect/reactivity"
+import type {
+  WardicInertia,
+  WardicInherit,
+  WardicOrchestration,
+  WardicReducedMotion,
+  WardicSkipAnimations,
+  WardicTargetValues,
+  WardicTransformShorthands,
+  WardicTransition,
+  WardicTransitionWith,
+  WardicValueEntries,
+  WardicValueKey,
+  WardicValues,
+  WardicValueTransition,
+  WardicVariantLabels,
+  WardicVariantResolver,
+} from "./config.ts"
+import type { WardicAnimationControls } from "./animation-controls.ts"
+import type { Accessor } from "./reactivity.ts"
+
+/** A key's value through its accessor, the Solid 2 binding's per-key form (#259): what it returns. */
+type Unwrap<V> = V extends (...args: never) => infer R ? R : V
+
+/**
+ * A layer's values map: nothing for a variant name, a list of names (#297), `false`, **Animation
+ * controls** (#433) or none; an accessor's, what it returns.
+ */
+type MapOf<V> = Unwrap<V> extends infer U
+  ? U extends object
+    ? U extends (...args: never) => unknown
+      ? never
+      : U extends ReadonlyArray<unknown>
+        ? never
+        : U extends WardicAnimationControls
+          ? never
+          : U
+    : never
+  : never
+
+/** Every variant's values map. */
+type VariantMaps<C> = C extends { readonly variants?: infer Ws }
+  ? Unwrap<Ws> extends infer Vs
+    ? Vs extends object
+      ? MapOf<Exclude<Vs, undefined>[keyof Exclude<Vs, undefined>]>
+      : never
+    : never
+  : never
+
+/** Every values map a config animates. */
+type MotionLayers<C> =
+  | MapOf<C extends { readonly initial?: infer V } ? V : never>
+  | MapOf<C extends { readonly animate?: infer V } ? V : never>
+  | MapOf<C extends { readonly exit?: infer V } ? V : never>
+  | MapOf<C extends { readonly whileHover?: infer V } ? V : never>
+  | MapOf<C extends { readonly whileTap?: infer V } ? V : never>
+  | MapOf<C extends { readonly whileDrag?: infer V } ? V : never>
+  | VariantMaps<C>
+
+/** Every values map a config animates or styles with. */
+type Layers<C> = MotionLayers<C> | MapOf<C extends { readonly style?: infer V } ? V : never>
+
+/** The keys of each member of a union. */
+// A target's own `transition` (#277) is how it animates, not a key it animates; its `transitionEnd`
+// (#428) holds keys, not a value.
+type KeysOf<U> = U extends unknown ? Exclude<keyof U & string, "transition" | "transitionEnd"> : never
+
+/** Each member's Transition end's keys (#428): keys a ward reads, though no transition drives them. */
+type EndKeysOf<U> = U extends { readonly transitionEnd?: infer E } ? KeysOf<MapOf<E>> : never
+
+/** A config's `drag`, through its accessor. */
+type DragOf<C> = C extends { readonly drag: infer D } ? Unwrap<D> : never
+
+/** The keys a drag moves: its axis's, or both. */
+// No `drag` is `never`, which every tuple below would take: none first (#297's WK7 found it).
+type DragKeys<C> = [DragOf<C>] extends [never]
+  ? never
+  : [DragOf<C>] extends ["x"]
+    ? "x"
+    : [DragOf<C>] extends ["y"]
+      ? "y"
+      : [DragOf<C>] extends [true]
+        ? "x" | "y"
+        : never
+
+/** The keys a config animates, and the ones its targets' Transition ends set. */
+export type AnimatedKey<C> = KeysOf<Layers<C>> | EndKeysOf<MotionLayers<C>> | DragKeys<C>
+
+/**
+ * The keys a config's transitions drive (#305's Q2): {@link AnimatedKey}'s but `style`'s. Wardic never
+ * follows a `style` change (ADR-0022, decision 5), so a key only `style` sets never runs on one.
+ */
+export type DrivenKey<C> = KeysOf<MotionLayers<C>> | DragKeys<C>
+
+/** A key a ward can read: one its config animates (completed), or any other (accepted). */
+export type WardKey<C> = AnimatedKey<C> | (string & {})
+
+/** A value as a ward reads it: a number or a string, a Live value read through. */
+type Widen<V> = V extends number ? number : V extends string ? string : V extends Accessor<infer A> ? Widen<A> : V extends Atom.Atom<infer A> ? Widen<A> : never
+
+/** `K`'s values across a config's layers. */
+type ValuesAt<C, K extends string> = Layers<C> extends infer L ? (L extends unknown ? (K extends keyof L ? L[K] : never) : never) : never
+
+/**
+ * What a ward reads for `K`: a transform key is always a number (its identity at rest); any other
+ * key, the type its config gives it (a number or a string), or `undefined` with no value.
+ */
+export type WardValueOf<C, K extends string> = K extends keyof WardicTransformShorthands
+  ? number
+  : [Widen<ValuesAt<C, K>>] extends [never]
+    ? number | string | undefined
+    : Widen<ValuesAt<C, K>> | undefined
+
+// --- Transition entries, checked (#301's PR 2, ADR-0049) ---------------------------------------
+
+/** A transition option's name, on either arm, a target's `inherit` among them: never an entry. */
+type OptionName =
+  | keyof (Omit<Machine.SpringOptions, "from"> & Machine.AnimateOptions & WardicOrchestration & WardicReducedMotion & WardicSkipAnimations & WardicInherit & WardicInertia)
+  | "type"
+
+/**
+ * What a name that's neither an option nor an entry the transition allows is checked against: why.
+ * As an object for a value that isn't one (a mistyped option), which a string would meet as `never`.
+ */
+type NotHere<P extends string, V> = V extends object
+  ? `'${P}' is neither a transition option nor a key animated here`
+  : { readonly "is neither a transition option nor a key animated here": P }
+
+/** Whether keys are every value's (a config typed wide, `WardConfig`'s): no literal key is a template. */
+type IsWide<K> = `-${string}` extends K ? true : false
+
+/**
+ * Each member's keys, as one union. A union's own `keyof` is the keys they share, an intersection:
+ * for a transition's two arms, two unions of every value's name, which TS crosses (TS2590).
+ */
+type KeysIn<T> = T extends unknown ? keyof T & string : never
+
+/** Each member's value at `P`. */
+type ValueIn<T, P extends string> = T extends unknown ? (P extends keyof T ? T[P] : never) : never
+
+/** `X` in the form `raw` was given: an accessor of it for an accessor (#259's per-key config), which may read none. */
+type Rewrap<Raw, X> = Raw extends (...args: never) => unknown ? () => X | undefined : X
+
+/**
+ * The transition given as `raw`, checked (#301): entries for `K` (and `default`), every other name
+ * an option, else an error naming it.
+ */
+type CheckedTransition<Raw, E, K extends string> =
+  IsWide<K | KeysIn<NonNullable<Unwrap<Raw>>>> extends true
+    ? unknown
+    : Rewrap<
+        Raw,
+        & WardicTransitionWith<E>
+        & WardicInherit
+        & { readonly [P in Exclude<KeysIn<NonNullable<Unwrap<Raw>>>, K | OptionName | "default">]: NotHere<P, ValueIn<NonNullable<Unwrap<Raw>>, P>> }
+      >
+
+/** `C`'s value at `K`, or `undefined` without one. */
+type RawOf<C, K extends string> = K extends keyof C ? C[K] : undefined
+
+/**
+ * A target, checked: its values as any target's, Keyframes among them (#429), and its own transition (#277) with entries for the
+ * keys it sets (Q2) and `default`, no `layout`. A dynamic variant is a resolver as ever, a variant
+ * name or `false` as it is.
+ */
+type CheckedTarget<T> = T extends (...args: never) => unknown
+  ? WardicVariantResolver
+  : T extends WardicAnimationControls
+    ? T
+    : T extends object
+      ? T extends ReadonlyArray<unknown>
+        ? T
+        : Omit<WardicTargetValues, "transition"> & { readonly transition?: CheckedTransition<RawOf<T, "transition">, WardicValueEntries<KeysOf<T>>, KeysOf<T>> } & CheckedEnd<T> & NoStray<T>
+      : T
+
+/** `initial`, checked (#305's Q4): its values' names. A variant name, a list of them or `false` as it is. */
+type CheckedInitial<T> = T extends object ? (T extends ReadonlyArray<unknown> ? T : Omit<WardicTargetValues, "transition"> & CheckedEnd<T> & NoStray<T>) : T
+
+/** What a name in a values map that isn't a value meets: an error naming it, an object, as {@link NotHere}'s. */
+type NotAValue<P extends string> = { readonly "is not a value Wardic animates": P }
+
+/**
+ * `T`'s names that aren't values, each an error (#305's Q4). The config is inferred from its literal,
+ * so every name a values map has is a known property: the check is what rejects `opacty`.
+ */
+type NoStray<T> = T extends object
+  ? IsWide<keyof T & string> extends true
+    ? unknown
+    : { readonly [P in Exclude<keyof T & string, WardicValueKey | "transition" | "transitionEnd">]: NotAValue<P> }
+  : unknown
+
+/** A target's Transition end, checked (#428): a values map whose names are values. */
+type CheckedEnd<T> = { readonly transitionEnd?: Omit<WardicValues, "transition"> & NoStray<RawOf<T, "transitionEnd">> }
+
+/** The config props that take a target. */
+type TargetProp = "animate" | "exit" | "whileHover" | "whileTap" | "whileDrag" | "whileFocus" | "whileInView"
+
+/** Each variant, checked; a variants map typed wide as it is. */
+type VariantsOf<C> = Unwrap<C["variants" & keyof C]> extends infer Vs
+  ? Vs extends object
+    ? Rewrap<C["variants" & keyof C], { readonly [N in keyof Vs]: CheckedTarget<Vs[N]> }>
+    : C["variants" & keyof C]
+  : never
+
+/** Whether a prop gives a variant name, or a list of them (#297), or **Animation controls** (#433), which give them. */
+type GivesLabels<V> = Unwrap<V> extends string | ReadonlyArray<string> | WardicAnimationControls ? true : false
+
+/**
+ * Whether Variant children can join the element (Motion's `isVariantNode`): it has `variants`, or
+ * gives a variant name in `initial` or `animate`. They inherit its `transition`, so its entries may
+ * be for their keys.
+ */
+type HandsDown<C> = true extends
+  | ("variants" extends keyof C ? ([Unwrap<C["variants" & keyof C]>] extends [undefined] ? false : true) : false)
+  | ("initial" extends keyof C ? GivesLabels<C["initial" & keyof C]> : false)
+  | ("animate" extends keyof C ? GivesLabels<C["animate" & keyof C]> : false)
+  ? true
+  : false
+
+/**
+ * The element's `transition`, checked (Q1): entries for the keys it animates, `default` and `layout`.
+ * An element Variant children can join takes every value's name, as Motion types it: they inherit
+ * it.
+ */
+type ElementTransition<C> = HandsDown<C> extends true
+  ? Rewrap<RawOf<C, "transition">, WardicTransition>
+  : CheckedTransition<RawOf<C, "transition">, WardicValueEntries<DrivenKey<C>> & { readonly layout?: WardicValueTransition }, DrivenKey<C> | "layout">
+
+/**
+ * A config `C` with its transitions' entries checked (#301's PR 2, ADR-0049), for a binding whose
+ * config is `W`: completion inside a `transition` offers the keys it drives, and an entry for any
+ * other is an error naming it. The element's `transition` takes the keys the element animates,
+ * `default` and `layout`, every value's name for an element Variant children can join; a target's
+ * own (a variant's, `animate`'s, a gesture's, `exit`'s), the keys that target sets and `default`. A
+ * config typed as a plain `WardConfig` takes every name. Every other key is `W`'s, so a callback's
+ * parameters are typed as ever.
+ */
+export type WardCheckedConfig<C, W> = C & {
+  readonly [K in keyof W]?: K extends "transition"
+    ? ElementTransition<C>
+    : K extends keyof C
+      ? K extends TargetProp
+        ? Rewrap<C[K], CheckedTarget<Unwrap<C[K]>>>
+        : K extends "variants"
+          ? VariantsOf<C>
+          : K extends "initial"
+            ? Rewrap<C[K], CheckedInitial<Unwrap<C[K]>>>
+            : W[K]
+      : W[K]
+}
+
+// --- A Wardic element's keys, inferred (#305, ADR-0049) -------------------------------------------
+
+/** A name a target sets: a value's, its own `transition`, or its `transitionEnd` (#428). */
+export type TargetKey = WardicValueKey | "transition" | "transitionEnd"
+
+/** The value names among a target's names: not its `transition` or its `transitionEnd`. */
+type ValueNameOf<K> = Exclude<K, "transition" | "transitionEnd">
+
+/**
+ * The names `K` a values map sets, inferred from it. One that isn't a value fails `K`'s constraint, so
+ * `K` is every name and the map is checked against all of them, where it's an excess property.
+ */
+type NamesOf<K extends string> = { readonly [P in K]?: unknown }
+
+/**
+ * A target, its names inferred into `K` (#305's Q1): any target's values, and its own transition with
+ * entries for the element's keys `E` and `default`, no `layout` (Q3). A values map's own type stays
+ * whole, so an editor completes every value's name inside it while `K` is being inferred.
+ */
+export type InferredTarget<K extends TargetKey, E extends string> =
+  & Omit<WardicTargetValues, "transition">
+  & { readonly transition?: (WardicTransitionWith<WardicValueEntries<E>> & WardicInherit) | WardicValues["transition"] }
+  & { readonly transitionEnd?: Omit<WardicValues, "transition"> }
+  & NamesOf<K>
+
+/** The keys a drag `D` moves. */
+type DragMoves<D> = [D] extends [never] ? never : [D] extends ["x"] ? "x" : [D] extends ["y"] ? "y" : [D] extends [true] ? "x" | "y" : never
+
+/**
+ * Whether variant names `L` were given. A values map is inferred into `L` too, failing its constraint,
+ * so `L` is then every name, `string`-wide: only a literal name counts.
+ */
+type GivesNames<L> = [L] extends [never] ? false : string extends L ? false : true
+
+/**
+ * Whether Variant children can join the element (Motion's `isVariantNode`): it has `variants` (names
+ * `N`), or gives a name in `initial` or `animate`. They inherit its `transition`, so it takes every
+ * value's name (#301's Q1).
+ */
+type JoinedBy<N extends string, LI, LA> = [N] extends [never] ? (true extends GivesNames<LI> | GivesNames<LA> ? true : false) : true
+
+/**
+ * The keys the element animates: its targets' names, its drag axis's, and `X`, those it animates
+ * through a ward given to it (#398). A key only `style` sets never runs on a transition (Q2).
+ */
+type InferredKey<K extends TargetKey, D, X extends string> = ValueNameOf<K> | DragMoves<D> | X
+
+/** The props {@link InferredMotion} types again. */
+type InferredProp = "initial" | "animate" | "exit" | "whileHover" | "whileTap" | "whileDrag" | "whileFocus" | "whileInView" | "variants" | "transition" | "drag"
+
+/**
+ * The motion props `M` (a Wardic element's, or a Solid 1 ward's config) with their keys inferred
+ * (#305): `K` from every target, `N` from `variants`' names, `LI` and `LA` from a name given in
+ * `initial` and `animate`, `D` from `drag`; `X`, the keys a ward given to the element animates. Each target keeps its own type, so a name in it that isn't
+ * a value is still an error. The element's `transition` takes entries for the keys it animates,
+ * `default` and `layout`, every value's name when Variant children can join it, or when no key could
+ * be inferred: an overloaded generic call in a target (Effect's `Bool.match`) gives TS none.
+ * `transition` gives `K` no names of its own (`NoInfer`).
+ */
+export type InferredMotion<M, K extends TargetKey, N extends string, LI extends WardicVariantLabels, LA extends WardicVariantLabels, D extends boolean | "x" | "y", X extends string = never> =
+  & Omit<M, InferredProp>
+  & {
+    readonly initial?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | LI | false
+    readonly animate?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | LA | WardicAnimationControls
+    readonly exit?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | WardicVariantLabels
+    readonly whileHover?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | WardicVariantLabels
+    readonly whileTap?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | WardicVariantLabels
+    readonly whileDrag?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | WardicVariantLabels
+    readonly whileFocus?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | WardicVariantLabels
+    readonly whileInView?: InferredTarget<K, NoInfer<ValueNameOf<K>>> | WardicVariantLabels
+    readonly variants?: { readonly [V in N]: InferredTarget<K, NoInfer<ValueNameOf<K>>> | WardicVariantResolver }
+    readonly drag?: D
+    readonly transition?: true extends NoInfer<JoinedBy<N, LI, LA> | ([InferredKey<K, D, X>] extends [never] ? true : false)>
+      ? WardicTransition
+      : WardicTransitionWith<NoInfer<WardicValueEntries<InferredKey<K, D, X>> & { readonly layout?: WardicValueTransition }>>
+  }

package/src/wardic-component.ts

@@ -0,0 +1,96 @@
+/**
+ * What both bindings' `wardic.create` shares, Solid-free (#443): its options (Motion's `motion.create`
+ * options, `forwardMotionProps` and `type`), the mark it sets on what it makes (Motion's
+ * `motionComponentSymbol`), and the `WardicConfig` `isValidProp` filter on a tag's own props.
+ *
+ * @module
+ */
+import * as Arr from "effect/Array"
+import * as Bool from "effect/Boolean"
+import { identity } from "effect/Function"
+import * as Predicate from "effect/Predicate"
+import * as UndefinedOr from "effect/UndefinedOr"
+
+/** `wardic.create`'s options (Motion's `motion.create(Component, options)`). */
+export interface WardicCreateOptions {
+  /**
+   * Hand the motion props on to what it renders as well (Motion's `forwardMotionProps`): a wrapped
+   * component gets `animate`, `whileHover` and the rest beside the Ward's spread, and a tag gets them as
+   * attributes, as Motion's does. They still drive the element. Default `false`.
+   */
+  readonly forwardMotionProps?: boolean | undefined
+  /**
+   * What its element is, for its server render and its Starting style (Motion's `type`): `"svg"`, an
+   * element inside an `<svg>`, whose attribute keys (`d`, `cx`, `pathLength`…) render as attributes;
+   * `"html"`, every key as style. Left out, a tag's own name decides, and a wrapped component's
+   * element is HTML. In the browser, the element itself decides, as it always has.
+   */
+  readonly type?: "svg" | "html" | undefined
+}
+
+/**
+ * The tag a wrapped component's svg-inner element routes its keys by when its own tag isn't known:
+ * every svg-inner element routes them alike (ADR-0014).
+ */
+const SVG_INNER = "g"
+
+/**
+ * The tag an element's server render and Starting style route its keys by (#443): `type`'s over its
+ * own (`undefined` for a wrapped component). `"svg"` keeps a known tag, which says which SVG element.
+ */
+export const routingTagOf = (tag: string | undefined, type: WardicCreateOptions["type"]): string | undefined => {
+  if (type === "html") return undefined
+  if (type === "svg") return UndefinedOr.match(tag, { onUndefined: () => SVG_INNER, onDefined: identity })
+  return tag
+}
+
+/**
+ * The mark on every component `wardic.create` and `wardic.<tag>` make (#443, Motion's
+ * `motionComponentSymbol`), holding the tag or the component it wraps. Registered, so both bindings,
+ * and two copies of the package, read each other's.
+ */
+const WARDIC_COMPONENT: unique symbol = Symbol.for("@wardic/solid/component")
+
+/** A component function, as {@link unwrapWardicComponent} gives it back, whichever Solid it's for. */
+export type AnyComponentFunction = (props: never) => unknown
+
+/** `component`, marked as made by `wardic.create` from `wraps` (#443). */
+export const markWardic = <C extends object>(component: C, wraps: string | AnyComponentFunction): C =>
+  Object.defineProperty(component, WARDIC_COMPONENT, { value: wraps })
+
+/**
+ * Whether `component` is a Wardic element's component: one that `w.<tag>`, `wardic.<tag>` or
+ * `wardic.create` made, on either binding. Motion's `isMotionComponent`.
+ *
+ * @example
+ * isWardicComponent(wardic.div) // true
+ * @see https://wardic.dev/reference/solid/utilities/component-checks
+ */
+// #443.
+export const isWardicComponent = (component: unknown): boolean => Predicate.hasProperty(component, WARDIC_COMPONENT)
+
+/**
+ * What a Wardic element's component wraps: its tag, `"div"` for `wardic.div`, or the component given to
+ * `wardic.create`; `undefined` for anything else. Motion's `unwrapMotionComponent`.
+ *
+ * @see https://wardic.dev/reference/solid/utilities/component-checks
+ */
+// #443.
+export const unwrapWardicComponent = (component: unknown): string | AnyComponentFunction | undefined => {
+  if (Bool.not(isWardicComponent(component))) return undefined
+  return (component as { readonly [WARDIC_COMPONENT]: string | AnyComponentFunction })[WARDIC_COMPONENT]
+}
+
+/**
+ * The keys of a tag's own props (`keysOf`: the motion props, `ref` and `style` split off) that a
+ * `WardicConfig`'s `isValidProp` keeps from the element (#443, Motion's `filterProps`): each that
+ * doesn't start with `on` and that it says isn't valid. None without one, or for a wrapped component,
+ * which gets every prop, as Motion's does; `keysOf` isn't read then. Decided for the keys it has as
+ * it's made.
+ */
+export const droppedKeysOf = (keysOf: () => ReadonlyArray<string>, isValidProp: ((key: string) => boolean) | undefined, isTag: boolean): ReadonlyArray<string> => {
+  if (Predicate.isUndefined(isValidProp)) return Arr.empty()
+  if (Bool.not(isTag)) return Arr.empty()
+  // `&&`, not `Bool.and`: `isValidProp` is asked of no `on` key, as Motion asks it.
+  return Arr.filter(keysOf(), (key) => !key.startsWith("on") && !isValidProp(key))
+}