praxis-kit 0.1.0

package/dist/svelte/Polymorphic.svelte

@@ -0,0 +1,190 @@
+<!--
+  @component
+  Renders a `createContractComponent` bundle. Every praxis-kit component in the Svelte adapter
+  is a bundle passed to this component via the `bundle` prop:
+
+  ```svelte
+  <Polymorphic {bundle} intent="ghost" as="a" href="/home">Home</Polymorphic>
+  ```
+
+  Resolves the tag (`as` or the bundle's default), variant classes, filtered props, and ARIA
+  attributes, then renders the result via `<svelte:element>` — or, with `asChild`, renders
+  `children` as a snippet receiving the resolved props instead of a host element.
+-->
+<script module lang="ts">
+  declare const process: { env: { NODE_ENV: string } }
+</script>
+
+<script lang="ts">
+  import { enforceAllowedAs, isKnownAriaRole } from './_polymorphic-runtime.js'
+  import type { ElementType, IntrinsicProps } from './_polymorphic-runtime.js'
+  import { isObject, isString } from './_polymorphic-runtime.js'
+  import { applyFilter, resolveNormalizedProps } from './_polymorphic-runtime.js'
+  import type { Snippet } from 'svelte'
+  import type {
+    PolymorphicComponentProps,
+    ResolvedAttributes,
+    StyleObject,
+    UnknownProps,
+  } from './index.js'
+
+  let {
+    bundle,
+    as: asProp,
+    asChild,
+    class: cls,
+    recipe,
+    children,
+    ...rest
+  }: PolymorphicComponentProps = $props()
+  let hostEl: Element | undefined = $state()
+
+  // Svelte 5 event delegation requires lowercase handler names (onclick, onfocus…). This is a
+  // deliberate, documented compatibility feature — not an accident of the regex — so a bundle's
+  // caller can write React-style camelCase (onClick, onPointerDown) and it reaches
+  // <svelte:element> as the native lowercase name Svelte's runtime binds via addEventListener.
+  //
+  // The contract only covers camelCase→lowercase for keys already shaped like `onXxx`; every
+  // "on"-prefixed key, normalized or not, is still treated as event-related by Svelte's own
+  // attribute-spreading runtime (a non-function value is silently dropped, not rendered as a
+  // literal attribute) — including a component-level "callback prop" that happens to start with
+  // "on" (`onValueChange`), which becomes a dead listener rather than a plain callback. See
+  // `DECISIONS.md` → "`adapters/svelte` — the event-normalization contract" and
+  // `event-normalization.test.ts` for the exact pinned cases.
+  const EVENT_RE = /^on[A-Z]/
+  function normalizeEventKeys(props: UnknownProps): UnknownProps {
+    const out: ResolvedAttributes = {}
+    for (const k in props) {
+      out[EVENT_RE.test(k) ? k.toLowerCase() : k] = (props as ResolvedAttributes)[k]
+    }
+    return out as UnknownProps
+  }
+
+  // key.replace(/([A-Z])/g, '-$1') camelCase→kebab-case is also what makes a CSS custom property
+  // (`'--my-color'`) pass through untouched — it has no uppercase letters to rewrite — and what
+  // makes a vendor-prefixed key (`WebkitLineClamp`) come out correctly hyphenated
+  // (`-webkit-line-clamp`, a leading dash and all — that IS the real CSS property name). Both are
+  // asserted by test, not left as an implicit property of the regex. `value == null` (not
+  // `=== undefined`) skips both `null` and `undefined` values but keeps a falsy `0`.
+  function serializeStyle(style: StyleObject): string {
+    let result = ''
+    for (const key in style) {
+      const value = style[key]
+      if (value == null) continue
+      if (result) result += ';'
+      result += `${key.replace(/([A-Z])/g, '-$1').toLowerCase()}:${value}`
+    }
+    return result
+  }
+
+  function buildDomProps(
+    props: UnknownProps,
+    classStr: string | undefined,
+    tag: ElementType,
+    normalizedProps: UnknownProps,
+  ): ResolvedAttributes {
+    const { role, style, ...r } = normalizeEventKeys(props)
+    const styleStr = isObject(style, true)
+      ? serializeStyle(style as StyleObject)
+      : (style as string | undefined)
+    const ep: IntrinsicProps = {
+      ...(r as IntrinsicProps),
+      class: classStr,
+      ...(styleStr !== undefined && { style: styleStr }),
+    }
+    if (isKnownAriaRole(role)) ep.role = role
+    if (!isString(tag)) return ep as ResolvedAttributes
+    return bundle.runtime.resolveAria(tag, ep, normalizedProps as IntrinsicProps)
+      .props as ResolvedAttributes
+  }
+
+  // Unlike buildDomProps above, this intentionally skips normalizeEventKeys and style
+  // serialization — the asChild path hands props straight to a caller-authored snippet, which
+  // spreads them onto its own element via ordinary JSX/attribute semantics, not through
+  // <svelte:element>'s own attribute application; event-handler keys keep their caller-authored
+  // casing (`onClick`, not lowercased to `onclick`), and `style` passes through however the
+  // caller wrote it (object or string), unserialized. See `ResolvedSlotProps<G>`
+  // (types/resolved-slot-props.ts) for the type this produces — it deliberately omits `style`
+  // rather than asserting either shape, for this exact reason.
+  function buildSlotProps(props: UnknownProps, classStr: string | undefined): UnknownProps {
+    const { role, ...r } = props
+    return {
+      ...r,
+      class: classStr,
+      ...(isKnownAriaRole(role) && { role }),
+    }
+  }
+
+  const tag = $derived(bundle.runtime.resolveTag(asProp as ElementType | undefined))
+  const mergedProps = $derived(bundle.runtime.resolveProps(rest as UnknownProps))
+  const normalizedProps = $derived.by(() => {
+    const { runtime: { options } } = bundle
+    // Folded into this derived (rather than a standalone one) so it's guaranteed to run on
+    // both SSR and DOM — $derived is lazy in Svelte 5 and only evaluates when read; this one
+    // is read downstream by resolvedClass/filteredProps/domProps, which the template renders.
+    if (options.allowedAs !== undefined) {
+      enforceAllowedAs(
+        tag,
+        options.allowedAs,
+        options.diagnostics,
+        options.displayName,
+      )
+    }
+    return resolveNormalizedProps(options, tag, mergedProps)
+  })
+  const resolvedClass = $derived(
+    bundle.runtime.resolveClasses(tag, normalizedProps, cls as string | undefined, recipe),
+  )
+  const filteredProps = $derived(
+    applyFilter(normalizedProps, bundle.filterProps, bundle.runtime.options.variantKeys),
+  )
+  const domProps = $derived(buildDomProps(filteredProps, resolvedClass, tag, normalizedProps))
+
+  // Resolves whether to render as child slot; also enforces as+asChild mutual exclusion.
+  const useAsChild = $derived.by(() => {
+    if (!asChild) return false
+    if (asProp !== undefined) {
+      bundle.slotValidator.assertExclusive()
+      return false
+    }
+    return true
+  })
+
+  // DOM-only (like Lit skipping htmlChildrenEvaluatorFn for its SSR renderToString). Merely
+  // *registering* $effect during svelte/server's render() throws ("effect_orphan") — it's not
+  // enough to no-op inside the callback, the rune call itself must never happen during SSR.
+  // Reads real child nodes off the mounted host, same approach as Lit's Array.from(this.childNodes).
+  // Not reachable in the asChild branch — no host element there.
+  if (typeof document !== 'undefined') {
+    $effect(() => {
+      if (process.env.NODE_ENV === 'production' || !hostEl) return
+      const childArray = Array.from(hostEl.childNodes)
+      bundle.childrenEvaluator?.evaluate(childArray, { tag, props: normalizedProps })
+      bundle.runtime.options.htmlChildrenEvaluatorFn
+        ?.(tag)
+        ?.evaluate(childArray, { tag, props: normalizedProps })
+    })
+
+    const onElement = $derived(bundle.onElement)
+
+    // Unlike the effect above, this runs in every environment (not dev-only) — onElement is a
+    // real runtime feature, not a diagnostic. Re-runs (cleaning up the previous call first, via
+    // the returned teardown) whenever hostEl changes identity, e.g. the resolved tag changes and
+    // Svelte mounts a new host element.
+    $effect(() => {
+      if (!hostEl) return
+      const cleanup = onElement?.(hostEl, () => normalizedProps)
+      return () => cleanup?.()
+    })
+  }
+</script>
+
+{#if useAsChild}
+  {#if children}
+    {@render (children as Snippet<[UnknownProps]>)(buildSlotProps(filteredProps, resolvedClass))}
+  {/if}
+{:else}
+  <svelte:element this={tag as string} bind:this={hostEl} {...domProps}>
+    {@render (children as Snippet | undefined)?.()}
+  </svelte:element>
+{/if}

package/dist/svelte/_polymorphic-runtime.d.ts

@@ -0,0 +1,102 @@
+import "clsx";
+import { DiagnosticCode, Diagnostics } from "../_shared/diagnostics.js";
+import "type-fest";
+//#region ../../lib/foundation/src/string-map.d.ts
+/**
+ * A string-keyed object whose values are of type `T`.
+ */
+type StringMap<T = unknown> = Record<string, T>;
+/**
+ * A string-keyed object with values of unknown type.
+ */
+type AnyRecord = StringMap<unknown>;
+//#endregion
+//#region ../../lib/foundation/src/type-guards.d.ts
+export declare function isString(value: unknown): value is string;
+export declare function isObject(value: unknown, excludeArrays: true): value is AnyRecord;
+export declare function isObject(value: unknown, excludeArrays?: false): value is object;
+//#endregion
+//#region ../../lib/primitive/src/types/intrinsic-tag.d.ts
+type IntrinsicTag = keyof HTMLElementTagNameMap;
+//#endregion
+//#region ../../lib/primitive/src/types/element-type.d.ts
+type ElementType = IntrinsicTag | (string & {});
+//#endregion
+//#region ../../lib/primitive/src/constants/aria/known-aria-roles.d.ts
+declare const KNOWN_ARIA_ROLES: readonly ["alert", "alertdialog", "application", "article", "banner", "blockquote", "button", "caption", "cell", "checkbox", "code", "columnheader", "combobox", "complementary", "contentinfo", "definition", "deletion", "dialog", "document", "emphasis", "feed", "figure", "form", "generic", "grid", "gridcell", "group", "heading", "img", "insertion", "link", "list", "listbox", "listitem", "log", "main", "marquee", "math", "menu", "menubar", "menuitem", "menuitemcheckbox", "menuitemradio", "meter", "navigation", "none", "note", "option", "paragraph", "presentation", "progressbar", "radio", "radiogroup", "region", "row", "rowgroup", "rowheader", "scrollbar", "search", "searchbox", "separator", "slider", "spinbutton", "status", "strong", "subscript", "superscript", "switch", "tab", "table", "tablist", "tabpanel", "term", "textbox", "time", "timer", "toolbar", "tooltip", "tree", "treegrid", "treeitem"];
+type KnownAriaRole = (typeof KNOWN_ARIA_ROLES)[number];
+//#endregion
+//#region ../../lib/primitive/src/types/primitives/index.d.ts
+type AriaRole = KnownAriaRole | (string & {});
+type IntrinsicProps = AnyRecord & {
+  role?: AriaRole;
+};
+//#endregion
+//#region ../../lib/primitive/src/types/factory/prop-normalizer.d.ts
+type PropNormalizer = (props: Readonly<AnyRecord & IntrinsicProps>) => Partial<AnyRecord & IntrinsicProps>;
+//#endregion
+//#region ../../lib/primitive/src/types/factory/factory-options.d.ts
+type NormalizeFn<Props extends AnyRecord = AnyRecord> = {
+  normalize(props: Readonly<Props & IntrinsicProps>): Props & IntrinsicProps;
+}['normalize'];
+//#endregion
+//#region ../../lib/primitive/src/guards/aria/is-known-aria-role.d.ts
+export declare function isKnownAriaRole(value: unknown): value is KnownAriaRole;
+//#endregion
+//#region ../core/src/resolver/resolver.d.ts
+export declare function enforceAllowedAs(tag: ElementType, allowedAs: readonly ElementType[], diagnostics: Diagnostics | undefined, displayName?: string): void;
+//#endregion
+//#region ../../lib/adapter-utils/src/types/filter-predicate.d.ts
+/**
+ * Determines whether a prop should be stripped before forwarding to the
+ * rendered element.
+ *
+ * Returning `true` excludes the prop from the output; returning `false`
+ * keeps it. This is the inverse polarity of `shouldForwardProp`-style
+ * predicates (Emotion/styled-components), where `true` means include.
+ *
+ * @param key - The prop name being evaluated.
+ * @param variantKeys - The set of configured variant prop names.
+ * @returns `true` to strip the prop; `false` to forward it.
+ */
+type FilterPredicate = (key: string, variantKeys: ReadonlySet<string>) => boolean;
+//#endregion
+//#region ../../lib/adapter-utils/src/props/apply-filter.d.ts
+export declare function applyFilter(props: Readonly<AnyRecord>, filterProps: FilterPredicate, variantKeys: ReadonlySet<string>): AnyRecord;
+//#endregion
+//#region ../../lib/adapter-utils/src/props/resolve-normalized-props.d.ts
+/**
+ * The subset of the resolved runtime options that {@link resolveNormalizedProps}
+ * reads. Kept structural so every adapter's own `runtime.options` type satisfies
+ * it without a shared nominal import.
+ */
+interface NormalizeCapableOptions {
+  readonly htmlPropNormalizersFn?: ((tag: ElementType) => readonly PropNormalizer[] | undefined) | undefined;
+  readonly normalizeFn?: NormalizeFn | undefined;
+}
+/**
+ * The single canonical prop-normalization step for every render path — the five
+ * VDOM adapters (React, Preact, Vue, Solid, Svelte) and the host-state path
+ * shared by Lit, Web, and SSR.
+ *
+ * Ordering is fixed and load-bearing:
+ *
+ * ```text
+ * mergedProps  →  HTML built-in normalizers  →  normalizeFn
+ * ```
+ *
+ * `normalizeFn` is the primitive's composed `enforcement.props` normalizers plus
+ * the caller's `normalize` option (folded together by `composeNormalizers`).
+ * Running it last means a caller's `normalize` always observes — and can
+ * override — an HTML built-in's output for the same key. This must be identical
+ * across adapters: the same component with the same props has to normalize the
+ * same way whether it renders through React or through SSR.
+ *
+ * `mergedProps` must already be the result of `runtime.resolveProps(rest)`. The
+ * input object is never mutated; a copy is taken only when an HTML normalizer
+ * actually runs — most tags have none (`htmlPropNormalizersFn` returns
+ * `undefined` for every non-form element).
+ */
+export declare function resolveNormalizedProps(options: NormalizeCapableOptions, tag: ElementType, mergedProps: AnyRecord): AnyRecord;
+//#endregion
+export type { ElementType, IntrinsicProps };

package/dist/svelte/_polymorphic-runtime.js

@@ -0,0 +1,371 @@
+import { DiagnosticCategory, DiagnosticCode } from "../_shared/diagnostics.js";
+//#region ../../lib/foundation/src/iterate.ts
+function find(iterable, callback) {
+	for (const value of iterable) {
+		const result = callback(value);
+		if (result != null) return result;
+	}
+	return null;
+}
+function some(iterable, predicate) {
+	for (const value of iterable) if (predicate(value)) return true;
+	return false;
+}
+function every(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (!predicate(value, index++)) return false;
+	return true;
+}
+function* filter(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (predicate(value, index++)) yield value;
+}
+function* map(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) yield callback(value, index++);
+}
+function forEach(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) callback(value, index++);
+}
+function reduce(iterable, initial, callback) {
+	let accumulator = initial;
+	let index = 0;
+	for (const value of iterable) accumulator = callback(accumulator, value, index++);
+	return accumulator;
+}
+/**
+* Transforms an iterable into a Record.
+*
+* The callback returns a `[key, value]` tuple for each element. Returning
+* `null` aborts the collection and causes `collect()` to return `null`.
+*/
+function collect(iterable, callback) {
+	const result = {};
+	let index = 0;
+	for (const value of iterable) {
+		const entry = callback(value, index++);
+		if (entry === null) return null;
+		result[entry[0]] = entry[1];
+	}
+	return result;
+}
+function findLast(value, callback) {
+	for (let index = value.length - 1; index >= 0; index--) {
+		const result = callback(value[index], index);
+		if (result != null) return result;
+	}
+	return null;
+}
+function* items(collection) {
+	for (let i = 0; i < collection.length; i++) {
+		const item = collection.item(i);
+		if (item !== null) yield item;
+	}
+}
+function nodeList(list) {
+	return { *[Symbol.iterator]() {
+		for (let i = 0; i < list.length; i++) {
+			const node = list.item(i);
+			if (node !== null) yield node;
+		}
+	} };
+}
+function mapEntries(m) {
+	return m.entries();
+}
+function set(s) {
+	return s.values();
+}
+function hasOwn(object, key) {
+	return Object.hasOwn(object, key);
+}
+function* entries(object) {
+	for (const key in object) {
+		if (!hasOwn(object, key)) continue;
+		yield [key, object[key]];
+	}
+}
+function* keys(object) {
+	for (const [key] of entries(object)) yield key;
+}
+function* values(object) {
+	for (const [, value] of entries(object)) yield value;
+}
+function mapValues(object, callback) {
+	const result = {};
+	for (const [key, value] of entries(object)) result[key] = callback(value, key);
+	return result;
+}
+function forEachEntry(object, callback) {
+	for (const [key, value] of entries(object)) callback(key, value);
+}
+function forEachKey(object, callback) {
+	for (const key of keys(object)) callback(key);
+}
+function forEachValue(object, callback) {
+	for (const value of values(object)) callback(value);
+}
+function forEachSet(s, callback) {
+	for (const value of s) callback(value);
+}
+const iterate = Object.freeze({
+	entries,
+	filter,
+	find,
+	findLast,
+	forEach,
+	forEachEntry,
+	forEachKey,
+	forEachSet,
+	forEachValue,
+	items,
+	keys,
+	map,
+	mapEntries,
+	mapValues,
+	nodeList,
+	reduce,
+	collect,
+	set,
+	some,
+	every,
+	values
+});
+//#endregion
+//#region ../../lib/foundation/src/type-guards.ts
+function isString(value) {
+	return typeof value === "string";
+}
+function isObject(value, excludeArrays = false) {
+	if (value === null || typeof value !== "object") return false;
+	return excludeArrays ? !Array.isArray(value) : true;
+}
+//#endregion
+//#region ../../lib/primitive/src/constants/aria/known-aria-roles.ts
+const KNOWN_ARIA_ROLES = Object.freeze([
+	"alert",
+	"alertdialog",
+	"application",
+	"article",
+	"banner",
+	"blockquote",
+	"button",
+	"caption",
+	"cell",
+	"checkbox",
+	"code",
+	"columnheader",
+	"combobox",
+	"complementary",
+	"contentinfo",
+	"definition",
+	"deletion",
+	"dialog",
+	"document",
+	"emphasis",
+	"feed",
+	"figure",
+	"form",
+	"generic",
+	"grid",
+	"gridcell",
+	"group",
+	"heading",
+	"img",
+	"insertion",
+	"link",
+	"list",
+	"listbox",
+	"listitem",
+	"log",
+	"main",
+	"marquee",
+	"math",
+	"menu",
+	"menubar",
+	"menuitem",
+	"menuitemcheckbox",
+	"menuitemradio",
+	"meter",
+	"navigation",
+	"none",
+	"note",
+	"option",
+	"paragraph",
+	"presentation",
+	"progressbar",
+	"radio",
+	"radiogroup",
+	"region",
+	"row",
+	"rowgroup",
+	"rowheader",
+	"scrollbar",
+	"search",
+	"searchbox",
+	"separator",
+	"slider",
+	"spinbutton",
+	"status",
+	"strong",
+	"subscript",
+	"superscript",
+	"switch",
+	"tab",
+	"table",
+	"tablist",
+	"tabpanel",
+	"term",
+	"textbox",
+	"time",
+	"timer",
+	"toolbar",
+	"tooltip",
+	"tree",
+	"treegrid",
+	"treeitem"
+]);
+const KNOWN_ARIA_ROLES_SET = new Set(KNOWN_ARIA_ROLES);
+//#endregion
+//#region ../../lib/primitive/src/guards/aria/is-known-aria-role.ts
+function isKnownAriaRole(value) {
+	return isString(value) && KNOWN_ARIA_ROLES_SET.has(value);
+}
+//#endregion
+//#region ../../lib/contract/src/diagnostics/contract.ts
+const ContractDiagnostics = {
+	unexpectedChild(typeName, index, context) {
+		return {
+			code: DiagnosticCode.UnexpectedChild,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: unexpected child "${typeName}" at index ${index}.`
+		};
+	},
+	ambiguousChild(typeName, index, ruleNames, context) {
+		const quoted = ruleNames.map((n) => `"${n}"`).join(" and ");
+		return {
+			code: DiagnosticCode.AmbiguousChild,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: child "${typeName}" at index ${index} matches multiple child rules: ${quoted}.`
+		};
+	},
+	cardinalityMin(ruleName, min, context) {
+		return {
+			code: DiagnosticCode.CardinalityMin,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: "${ruleName}" requires at least ${min}.`
+		};
+	},
+	cardinalityMax(ruleName, max, context) {
+		return {
+			code: DiagnosticCode.CardinalityMax,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: "${ruleName}" allows at most ${max}.`
+		};
+	},
+	positionViolation(ruleName, position, index, context) {
+		return {
+			code: DiagnosticCode.PositionViolation,
+			category: DiagnosticCategory.Contract,
+			component: context,
+			message: `${context}: "${ruleName}" must be ${position}, got index ${index}`
+		};
+	},
+	unknownVariantDim(component, label, dim) {
+		return {
+			code: DiagnosticCode.ContractUnknownVariantDim,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: ${label} references unknown variant "${dim}".`
+		};
+	},
+	unknownVariantValue(component, label, dim, value, valid) {
+		return {
+			code: DiagnosticCode.ContractUnknownVariantValue,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: ${label} sets "${dim}" to unknown value "${value}" (valid: ${valid.join(", ")}).`
+		};
+	},
+	unknownRecipeKey(component, key) {
+		return {
+			code: DiagnosticCode.ContractUnknownRecipeKey,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: unknown recipeKey "${key}" — no preset with that name exists.`
+		};
+	},
+	invalidVariantValue(component, key, value) {
+		return {
+			code: DiagnosticCode.ContractInvalidVariantValue,
+			category: DiagnosticCategory.Contract,
+			message: `${component}: variant "${key}=${value}" is not a defined value for the "${key}" dimension.`
+		};
+	},
+	allowedAsViolation(tag, allowedAs, component) {
+		const allowed = allowedAs.map((t) => `"${String(t)}"`).join(", ");
+		return {
+			code: DiagnosticCode.AllowedAsViolation,
+			category: DiagnosticCategory.Contract,
+			component,
+			message: `<${component}>: "as" prop received "${tag}" but only [${allowed}] are allowed.`
+		};
+	}
+};
+//#endregion
+//#region ../core/src/resolver/resolver.ts
+function enforceAllowedAs(tag, allowedAs, diagnostics, displayName) {
+	if (allowedAs.includes(tag)) return;
+	if (!diagnostics) return;
+	const component = displayName ?? String(tag);
+	diagnostics.error(ContractDiagnostics.allowedAsViolation(String(tag), allowedAs, component));
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/props/apply-filter.ts
+function applyFilter(props, filterProps, variantKeys) {
+	const out = {};
+	iterate.forEachEntry(props, (k) => {
+		if (!Object.hasOwn(props, k)) return;
+		if (filterProps(k, variantKeys)) return;
+		out[k] = props[k];
+	});
+	return out;
+}
+//#endregion
+//#region ../../lib/adapter-utils/src/props/resolve-normalized-props.ts
+/**
+* The single canonical prop-normalization step for every render path — the five
+* VDOM adapters (React, Preact, Vue, Solid, Svelte) and the host-state path
+* shared by Lit, Web, and SSR.
+*
+* Ordering is fixed and load-bearing:
+*
+* ```text
+* mergedProps  →  HTML built-in normalizers  →  normalizeFn
+* ```
+*
+* `normalizeFn` is the primitive's composed `enforcement.props` normalizers plus
+* the caller's `normalize` option (folded together by `composeNormalizers`).
+* Running it last means a caller's `normalize` always observes — and can
+* override — an HTML built-in's output for the same key. This must be identical
+* across adapters: the same component with the same props has to normalize the
+* same way whether it renders through React or through SSR.
+*
+* `mergedProps` must already be the result of `runtime.resolveProps(rest)`. The
+* input object is never mutated; a copy is taken only when an HTML normalizer
+* actually runs — most tags have none (`htmlPropNormalizersFn` returns
+* `undefined` for every non-form element).
+*/
+function resolveNormalizedProps(options, tag, mergedProps) {
+	const htmlNormalizers = options.htmlPropNormalizersFn?.(tag);
+	let base = mergedProps;
+	if (htmlNormalizers?.length) {
+		base = { ...mergedProps };
+		for (const normalize of htmlNormalizers) Object.assign(base, normalize(base));
+	}
+	return typeof options.normalizeFn === "function" ? options.normalizeFn(base) : base;
+}
+//#endregion
+export { applyFilter, enforceAllowedAs, isKnownAriaRole, isObject, isString, resolveNormalizedProps };