@studiometa/js-toolkit 3.9.0 → 4.0.0-alpha.0

package/dist/registry.js

@@ -0,0 +1,442 @@
+import { COMPONENT_ATTRIBUTE, isComponentAttribute, isOptionAttribute, negatedOptionAttributeFor, optionAttributeFor, rememberPreviousValue } from "./attributes.js";
+import { isBaseConstructor } from "./component-brand.js";
+import { getSharedRuntimeSlot } from "./shared-runtime.js";
+import { reportDiagnostic, warnOnce } from "./diagnostics.js";
+import { defaultScheduler } from "./scheduler.js";
+import { registerDOMOptionAttributes, setDOMMutationProcessor, trackDOMLifecycleWork } from "./dom-mutations.js";
+import { onBreakpointsReplaced } from "./services/breakpoint.js";
+import { checkResponsiveAttributes, observeResponsiveAttribute, responsiveAttributeNames, watchBreakpoint } from "./responsive-options.js";
+import { componentTokens, hasComponentAttribute, hasResponsiveComponentAttribute } from "./component-declarations.js";
+import { INSTANCES } from "./protocol-symbols.js";
+import { selectorFor } from "./utils/selectors.js";
+import { declaresBoolean, resolveConfig } from "./Base.js";
+import { applyMountStrategy, mountStrategyBehaviour } from "./mount-strategies.js";
+//#region src/registry.ts
+observeResponsiveAttribute(COMPONENT_ATTRIBUTE);
+const registryState = /* @__PURE__ */ getSharedRuntimeSlot("registry", 2, () => ({
+	registry: /* @__PURE__ */ new Map(),
+	controllers: /* @__PURE__ */ new WeakMap(),
+	manifest: /* @__PURE__ */ new Map(),
+	imports: /* @__PURE__ */ new Map(),
+	responsiveElements: /* @__PURE__ */ new Set(),
+	unwatchBreakpoints: null,
+	responsiveTask: null,
+	pendingResponsiveElements: /* @__PURE__ */ new Set(),
+	isReplacementListenerAttached: false
+}));
+const { registry, controllers, manifest, imports, responsiveElements } = registryState;
+/** Distinguish an unbranded class from a callable importer. */
+function isClassLike(value) {
+	return Object.getOwnPropertyDescriptor(value, "prototype")?.writable === false;
+}
+/** Register classes and lazy importers from the merged `config.components`. */
+function registerFamily(ComponentClass) {
+	const { name, components } = resolveConfig(ComponentClass);
+	for (const [childName, Child] of Object.entries(components ?? {})) if (isBaseConstructor(Child)) registerComponent(Child);
+	else if (typeof Child === "function" && !isClassLike(Child)) registerLazyChild(childName, Child);
+	else warnOnce(ComponentClass, childName, "component.invalid-family-declaration", `"${name}" declares "${childName}" as neither a component class nor an importer; the declaration was ignored.`, { component: name });
+}
+/** Register a lazy child without loading it. The first declaration wins. */
+function registerLazyChild(name, load) {
+	if (registry.has(name) || manifest.has(name)) return;
+	manifest.set(name, { load });
+	setDOMMutationProcessor(processMutations);
+	scanName(document.documentElement, name);
+}
+function declaresComponent(el, name) {
+	return componentTokens(el).has(name);
+}
+/** Connected elements whose declarations need a breakpoint crossing. */
+function syncResponsiveElement(el) {
+	if (el.isConnected && hasResponsiveComponentAttribute(el)) {
+		responsiveElements.add(el);
+		registryState.unwatchBreakpoints ??= watchBreakpoint(() => {
+			scheduleResponsiveReconciliation(responsiveElements);
+		});
+		return;
+	}
+	responsiveElements.delete(el);
+	if (responsiveElements.size === 0) {
+		registryState.unwatchBreakpoints?.();
+		registryState.unwatchBreakpoints = null;
+	}
+}
+/** Coalesce responsive reconciliation in the background lifecycle queue. */
+function scheduleResponsiveReconciliation(elements) {
+	for (const el of elements) registryState.pendingResponsiveElements.add(el);
+	if (registryState.responsiveTask || registryState.pendingResponsiveElements.size === 0) return;
+	const task = defaultScheduler.background(() => {
+		const batch = registryState.pendingResponsiveElements;
+		registryState.pendingResponsiveElements = /* @__PURE__ */ new Set();
+		for (const el of batch) if (el.isConnected) reconcileElement(el);
+		else syncResponsiveElement(el);
+	});
+	registryState.responsiveTask = task;
+	trackDOMLifecycleWork(task.promise);
+	const finished = () => {
+		registryState.responsiveTask = null;
+		scheduleResponsiveReconciliation([]);
+	};
+	task.promise.then(finished, finished);
+}
+if (!registryState.isReplacementListenerAttached) {
+	registryState.isReplacementListenerAttached = true;
+	onBreakpointsReplaced(() => {
+		const candidates = new Set(responsiveElements);
+		const selector = responsiveAttributeNames(COMPONENT_ATTRIBUTE).map((attribute) => `[${CSS.escape(attribute)}]`).join(",");
+		if (selector) for (const el of document.querySelectorAll(selector)) candidates.add(el);
+		scheduleResponsiveReconciliation(candidates);
+	});
+}
+/**
+* Register a component and its merged family, then scan matching elements.
+*
+* The name comes from the merged config, like the instance's `$id` and the
+* `INSTANCES` map key it publishes itself under: a subclass which extends a
+* component with extra config and forgets to rename would otherwise register
+* under `undefined` instead of colliding with the name it inherited.
+* @link https://js-toolkit-v4.studiometa.dev/api/registry/registerComponent.html
+*/
+function registerComponent(ComponentClass) {
+	const { name } = resolveConfig(ComponentClass);
+	if (registry.has(name)) {
+		if (registry.get(name) !== ComponentClass) warnOnce(ComponentClass, name, "registry.conflict", `"${name}" is already registered; the incoming declaration was ignored.`, { component: name });
+		return;
+	}
+	registry.set(name, ComponentClass);
+	manifest.delete(name);
+	registerFamily(ComponentClass);
+	registerDOMOptionAttributes(optionAttributes(ComponentClass));
+	setDOMMutationProcessor(processMutations);
+	scanName(document.documentElement, name);
+}
+/** @link https://js-toolkit-v4.studiometa.dev/api/registry/registerComponents.html */
+function registerComponents(...classes) {
+	for (const ComponentClass of classes) registerComponent(ComponentClass);
+}
+/**
+* Register lazy component entries. Element `data-mount` overrides the entry strategy; unloaded components have no instance.
+* @link https://js-toolkit-v4.studiometa.dev/api/registry/registerManifest.html
+*/
+function registerManifest(entries) {
+	const added = [];
+	for (const [name, entry] of Object.entries(entries)) {
+		if (registry.has(name) || manifest.has(name)) {
+			warnOnce(entries, name, "registry.conflict", `"${name}" is already registered; the incoming declaration was ignored.`, { component: name });
+			continue;
+		}
+		manifest.set(name, typeof entry === "function" ? { load: entry } : entry);
+		added.push(name);
+	}
+	if (added.length === 0) return;
+	setDOMMutationProcessor(processMutations);
+	for (const name of added) scanName(document.documentElement, name);
+}
+/**
+* Drop every registration, so the names a test used are free again.
+*
+* `registerComponent()` has no inverse by design: a page registers once and
+* keeps the registration for as long as it lives. A test suite is the one
+* caller for which that is wrong — the registry is page-wide and it survives
+* `resetDom()`, so a name registered by one spec is still taken in the next
+* one, and the workaround is a counter that mints `Widget-1`, `Widget-2` and
+* tells the reader nothing. This is the escape hatch, re-exported from
+* `@studiometa/js-toolkit/test`; it is not part of a page's vocabulary.
+*
+* **It is coarse on purpose.** A targeted `unregisterComponent(name)` would
+* have to find the elements holding that name's live triggers, and the map
+* from element to controller is a `WeakMap`: it cannot be enumerated, so
+* nothing can walk it to dispose them, and a `querySelectorAll()` sweep would
+* still miss every detached element. Clearing the whole registry works because
+* the mutation-observer path already disposes a controller as its element
+* leaves the DOM — which is why the call belongs *after* `resetDom()`.
+*
+* Two things it therefore does not do. It cannot clear that `WeakMap`, so a
+* controller whose element is still connected keeps its trigger; empty the DOM
+* first. And it does not narrow the attribute filter the shared observer built
+* from the options of everything ever registered — an extra watched attribute
+* costs a reconciliation pass that finds no owner, and nothing more.
+*
+* **Where the call belongs.** Spec files register at module top level, so
+* this in an `afterEach` silently unregisters everything for every later test
+* in the file. Put it in an `afterAll`, or call it and register again straight
+* away:
+*
+* ```ts
+* afterEach(async () => {
+*   await resetDom();
+*   resetRegistry();
+*   registerComponents(Subject, Emitter);
+* });
+* ```
+*/
+function resetRegistry() {
+	registry.clear();
+	manifest.clear();
+	imports.clear();
+	responsiveElements.clear();
+	registryState.pendingResponsiveElements.clear();
+	registryState.responsiveTask?.cancel();
+	registryState.responsiveTask = null;
+	registryState.unwatchBreakpoints?.();
+	registryState.unwatchBreakpoints = null;
+}
+/** Import and register a lazy entry once per name. Failed imports are not retried. */
+function importComponent(name, target) {
+	const pending = imports.get(name);
+	if (pending) return pending;
+	const entry = manifest.get(name);
+	if (!entry) return Promise.resolve();
+	const work = Promise.resolve().then(() => entry.load()).then((module) => {
+		const ComponentClass = resolveComponentClass(module, name);
+		if (!ComponentClass) throw new TypeError(`"${name}" did not resolve to a component class.`);
+		const resolvedName = resolveConfig(ComponentClass).name;
+		if (resolvedName !== name) warnOnce(entry.load, name, "registry.lazy-name-mismatch", `"${name}" resolved to a component named "${resolvedName}".`, {
+			component: name,
+			target
+		});
+		manifest.delete(name);
+		registerComponent(ComponentClass);
+	}).catch((error) => {
+		reportDiagnostic("component.load-failed", `Failed to load component "${name}".`, error, {
+			component: name,
+			target
+		});
+	});
+	imports.set(name, work);
+	return work;
+}
+/** Resolve a component class from a direct value, named export, or default export. */
+function resolveComponentClass(module, name) {
+	if (isBaseConstructor(module)) return module;
+	if (typeof module !== "object" || module === null) return;
+	const exports = module;
+	for (const candidate of [exports[name], exports.default]) if (isBaseConstructor(candidate)) return candidate;
+}
+function optionAttributes(ComponentClass) {
+	const names = [];
+	for (const [name, definition] of Object.entries(resolveConfig(ComponentClass).options ?? {})) {
+		const attribute = optionAttributeFor(name);
+		names.push(attribute);
+		observeResponsiveAttribute(attribute);
+		if (declaresBoolean(definition)) {
+			const negated = negatedOptionAttributeFor(name);
+			names.push(negated);
+			observeResponsiveAttribute(negated);
+		}
+	}
+	return names;
+}
+/**
+* Resolve strategy precedence: element, then the default declared by whichever
+* half of the registry owns the name, then `eager`. A manifest entry states one
+* for exactly as long as its class cannot be read.
+*/
+function resolveStrategy(el, source) {
+	const declared = isBaseConstructor(source) ? resolveConfig(source).mountStrategy : source.mountStrategy;
+	return el.getAttribute("data-mount") ?? declared ?? "eager";
+}
+/**
+* The instance is created on first mount, not on discovery: a component
+* waiting for its strategy has no instance yet, so it stays invisible to
+* `$query`, `$closest` and `$watchChildren`, and announces nothing.
+*/
+function isCurrentPair(el, name, controller) {
+	return controller.state === "live" && controllers.get(el)?.get(name) === controller && el.isConnected && declaresComponent(el, name) && resolveStrategy(el, controller.source) === controller.strategy;
+}
+function mountPair(el, name, ComponentClass, controller) {
+	if (!isCurrentPair(el, name, controller)) return;
+	let instance = el[INSTANCES]?.get(name);
+	try {
+		if (!instance) instance = new ComponentClass(el);
+		instance.$mount();
+	} catch (error) {
+		if (!instance) el[INSTANCES]?.delete(name);
+		reportDiagnostic("component.mount-failed", `Failed to mount component "${name}".`, error, {
+			component: name,
+			target: el
+		});
+	}
+}
+function unmountPair(el, name, controller) {
+	if (isCurrentPair(el, name, controller)) el[INSTANCES]?.get(name)?.$unmount();
+}
+/**
+* Import the class a lazy declaration names, once.
+*
+* Importing is one-shot even on a reversible strategy, so the controller
+* stands down here instead of tearing its own trigger down: `media:` fires
+* while `applyMountStrategy()` is still running, when no teardown exists yet.
+* A spent controller fails `isCurrentPair()`, which is what makes a second
+* trigger inert, and the controller replacing it disposes the strategy.
+*/
+function importPair(el, name, controller) {
+	if (!isCurrentPair(el, name, controller)) return;
+	controller.state = "spent";
+	const work = importComponent(name, el);
+	if (controller.eager) trackDOMLifecycleWork(work);
+}
+/** The hooks a strategy drives: mount a class, or import the module naming one. */
+function hooksFor(el, name, controller) {
+	const { source } = controller;
+	if (isBaseConstructor(source)) return {
+		mount: () => mountPair(el, name, source, controller),
+		unmount: () => unmountPair(el, name, controller)
+	};
+	return {
+		mount: () => importPair(el, name, controller),
+		unmount() {}
+	};
+}
+function disposeController(el, name) {
+	const pairs = controllers.get(el);
+	const controller = pairs?.get(name);
+	if (!controller) return;
+	controller.state = "disposed";
+	controller.dispose();
+	pairs?.delete(name);
+	if (pairs?.size === 0) controllers.delete(el);
+}
+/**
+* Schedule one element/component pair on the strategy that element resolves
+* to, whichever half of the registry answers for the name.
+*
+* A controller is replaced when the strategy changes and when the source
+* does — which is how an import lands: `registerComponent()` swaps the entry
+* for the class, and this pass turns the spent import trigger into a mount
+* controller for the same pair.
+*/
+function schedule(el, name) {
+	const source = registry.get(name) ?? manifest.get(name);
+	if (!source) return;
+	const strategy = resolveStrategy(el, source);
+	let pairs = controllers.get(el);
+	const previous = pairs?.get(name);
+	if (previous?.strategy === strategy && previous.source === source) return;
+	const wasSatisfied = previous?.state === "spent" && previous.strategy === strategy;
+	if (previous) disposeController(el, name);
+	pairs = controllers.get(el);
+	if (!pairs) {
+		pairs = /* @__PURE__ */ new Map();
+		controllers.set(el, pairs);
+	}
+	const { eager, reversible } = mountStrategyBehaviour(strategy);
+	const controller = {
+		dispose() {},
+		eager,
+		source,
+		state: "live",
+		strategy
+	};
+	pairs.set(name, controller);
+	const applied = applyMountStrategy(el, strategy, hooksFor(el, name, controller));
+	controller.dispose = applied.dispose;
+	if (!applied.valid) reportDiagnostic("component.invalid-mount-strategy", `Failed to apply mount strategy "${strategy}" to component "${name}".`, applied.error, {
+		component: name,
+		target: el
+	});
+	trackDOMLifecycleWork(applied.eagerWork);
+	if (wasSatisfied && !reversible && isBaseConstructor(source)) {
+		controller.dispose();
+		mountPair(el, name, source, controller);
+	}
+}
+/**
+* Make the framework state on one connected element match its final
+* `data-component` token set.
+*/
+function reconcileElement(el) {
+	checkResponsiveAttributes(el, [COMPONENT_ATTRIBUTE]);
+	syncResponsiveElement(el);
+	const tokens = componentTokens(el);
+	const names = /* @__PURE__ */ new Set([...controllers.get(el)?.keys() ?? [], ...el[INSTANCES]?.keys() ?? []]);
+	for (const name of names) if (!tokens.has(name) && (registry.has(name) || manifest.has(name))) {
+		disposeController(el, name);
+		const instance = el[INSTANCES]?.get(name);
+		if (instance) {
+			instance.$unmount();
+			el[INSTANCES]?.delete(name);
+		}
+	}
+	for (const name of tokens) schedule(el, name);
+}
+/**
+* Scan an inserted subtree once. Elements carrying retained instances are
+* included even when their declaration changed while detached.
+*/
+function scan(root) {
+	if (!(root instanceof Element)) return;
+	for (const el of [root, ...root.querySelectorAll("*")]) if (hasComponentAttribute(el) || el[INSTANCES] || controllers.has(el)) reconcileElement(el);
+}
+/**
+* A newly registered name — a class or a lazy entry — only needs its own
+* token matches. This avoids a full document walk for every registration
+* while inserted subtrees still use the one-pass scanner above.
+*/
+function scanName(root, name) {
+	const selector = selectorFor(name);
+	const elements = root.matches(selector) ? [root, ...root.querySelectorAll(selector)] : [...root.querySelectorAll(selector)];
+	for (const el of elements) reconcileElement(el);
+}
+function unmountWithin(node, snapshot) {
+	if (!(node instanceof Element)) return;
+	for (const el of snapshot ?? [node, ...node.querySelectorAll("*")]) {
+		syncResponsiveElement(el);
+		const pairs = controllers.get(el);
+		if (pairs) for (const name of pairs.keys()) disposeController(el, name);
+		if (!el[INSTANCES]) continue;
+		for (const instance of el[INSTANCES].values()) instance.$unmount();
+	}
+}
+function unmountRemovedSubtrees(records) {
+	for (const { record, removedSubtrees } of records) if (record.type === "childList") for (const node of record.removedNodes) unmountWithin(node, removedSubtrees.get(node));
+}
+function collectAttributeChanges(records) {
+	const declarations = /* @__PURE__ */ new Set();
+	const strategies = /* @__PURE__ */ new Set();
+	const options = /* @__PURE__ */ new Map();
+	for (const { record } of records) {
+		if (record.type !== "attributes" || !(record.target instanceof HTMLElement)) continue;
+		if (isComponentAttribute(record.attributeName)) declarations.add(record.target);
+		else if (record.attributeName === "data-mount") strategies.add(record.target);
+		else if (isOptionAttribute(record.attributeName)) {
+			let changes = options.get(record.target);
+			if (!changes) {
+				changes = /* @__PURE__ */ new Map();
+				options.set(record.target, changes);
+			}
+			rememberPreviousValue(changes, record.attributeName, record.oldValue);
+		}
+	}
+	return {
+		declarations,
+		strategies,
+		options
+	};
+}
+function reconcileChangedElements({ declarations, strategies }) {
+	for (const el of declarations) if (el.isConnected) reconcileElement(el);
+	for (const el of strategies) if (el.isConnected && !declarations.has(el)) reconcileElement(el);
+}
+function applyOptionChanges({ options }) {
+	for (const [el, changes] of options) {
+		if (!el.isConnected) continue;
+		for (const instance of el[INSTANCES]?.values() ?? []) if (instance.$isMounted) instance.$optionsChanged(changes);
+	}
+}
+function scanAddedNodes(records) {
+	for (const { record } of records) if (record.type === "childList") {
+		for (const node of record.addedNodes) if (node.isConnected) scan(node);
+	}
+}
+function processMutations(records) {
+	unmountRemovedSubtrees(records);
+	const changes = collectAttributeChanges(records);
+	reconcileChangedElements(changes);
+	applyOptionChanges(changes);
+	scanAddedNodes(records);
+}
+//#endregion
+export { registerComponent, registerComponents, registerManifest, resetRegistry };
+
+//# sourceMappingURL=registry.js.map

package/dist/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../src/registry.ts"],"sourcesContent":["import {\n  declaresBoolean,\n  resolveConfig,\n  type BaseConstructor,\n  type ComponentImporter,\n} from './Base.js';\nimport {\n  COMPONENT_ATTRIBUTE,\n  isComponentAttribute,\n  isOptionAttribute,\n  MOUNT_ATTRIBUTE,\n  negatedOptionAttributeFor,\n  optionAttributeFor,\n  rememberPreviousValue,\n} from './attributes.js';\nimport { isBaseConstructor } from './component-brand.js';\nimport {\n  componentTokens,\n  hasComponentAttribute,\n  hasResponsiveComponentAttribute,\n} from './component-declarations.js';\nimport { reportDiagnostic, warnOnce } from './diagnostics.js';\nimport {\n  registerDOMOptionAttributes,\n  setDOMMutationProcessor,\n  trackDOMLifecycleWork,\n  type DOMMutationRecord,\n} from './dom-mutations.js';\nimport {\n  applyMountStrategy,\n  mountStrategyBehaviour,\n  type MountStrategy,\n  type MountStrategyHooks,\n} from './mount-strategies.js';\nimport { INSTANCES } from './protocol-symbols.js';\nimport {\n  checkResponsiveAttributes,\n  observeResponsiveAttribute,\n  responsiveAttributeNames,\n  watchBreakpoint,\n} from './responsive-options.js';\nimport { defaultScheduler, type ScheduledTask } from './scheduler.js';\nimport { getSharedRuntimeSlot } from './shared-runtime.js';\nimport { onBreakpointsReplaced } from './services/breakpoint.js';\nimport { selectorFor } from './utils/selectors.js';\n\n// Register exact responsive component attribute names with the shared observer filter.\nobserveResponsiveAttribute(COMPONENT_ATTRIBUTE);\n\nexport type { ComponentImporter };\n\n/** A lazy component importer and its optional pre-load mount strategy. */\nexport interface ComponentManifestEntry {\n  load: ComponentImporter;\n  mountStrategy?: MountStrategy;\n}\n\n/** `data-component` tokens mapped to the lazy entry which resolves them. */\nexport type ComponentManifest = Record<string, ComponentImporter | ComponentManifestEntry>;\n\n/**\n * The half of the registry which answers for a name. A class mounts on its\n * strategy; an entry imports on the same one, then registers a class.\n */\ntype ComponentSource = BaseConstructor | ComponentManifestEntry;\n\n/**\n * A controller's lifetime.\n *\n * `live` is the pair's current decision. A spent controller is an import\n * trigger which has fired: it stays in the map as the memory that its\n * condition was satisfied, so the controller replacing it once the class\n * lands does not wait for the very same condition a second time. `disposed`\n * is set before teardown, so a callback a strategy already queued cannot act\n * through a controller which is gone.\n */\ntype PairState = 'live' | 'spent' | 'disposed';\n\n/**\n * One element/component pair, scheduled once whichever half of the registry\n * owns its name. The hooks handed to the strategy either mount the class or\n * import the module; everything else — precedence, replacement, teardown,\n * settlement — is the same algorithm.\n */\ninterface PairController {\n  dispose(): void;\n  /** DOM settlement waits for an eager mount or import, never for a condition. */\n  eager: boolean;\n  source: ComponentSource;\n  state: PairState;\n  strategy: string;\n}\n\ninterface RegistryRuntimeState {\n  registry: Map<string, BaseConstructor>;\n  controllers: WeakMap<Element, Map<string, PairController>>;\n  manifest: Map<string, ComponentManifestEntry>;\n  imports: Map<string, Promise<void>>;\n  responsiveElements: Set<HTMLElement>;\n  unwatchBreakpoints: (() => void) | null;\n  responsiveTask: ScheduledTask<void> | null;\n  pendingResponsiveElements: Set<HTMLElement>;\n  isReplacementListenerAttached: boolean;\n}\n\n// Revision 2: both halves share one controller map, so a copy still keeping\n// its import triggers in a second one cannot share this layout.\nconst registryState = /* @__PURE__ */ getSharedRuntimeSlot<RegistryRuntimeState>(\n  'registry',\n  2,\n  () => ({\n    registry: new Map(),\n    controllers: new WeakMap(),\n    manifest: new Map(),\n    imports: new Map(),\n    responsiveElements: new Set(),\n    unwatchBreakpoints: null,\n    responsiveTask: null,\n    pendingResponsiveElements: new Set(),\n    isReplacementListenerAttached: false,\n  }),\n);\nconst { registry, controllers, manifest, imports, responsiveElements } = registryState;\n\n/** Distinguish an unbranded class from a callable importer. */\nfunction isClassLike(value: (...args: never[]) => unknown): boolean {\n  return Object.getOwnPropertyDescriptor(value, 'prototype')?.writable === false;\n}\n\n/** Register classes and lazy importers from the merged `config.components`. */\nfunction registerFamily(ComponentClass: BaseConstructor): void {\n  const { name, components } = resolveConfig(ComponentClass);\n  for (const [childName, Child] of Object.entries(components ?? {})) {\n    if (isBaseConstructor(Child)) {\n      registerComponent(Child);\n    } else if (typeof Child === 'function' && !isClassLike(Child)) {\n      registerLazyChild(childName, Child);\n    } else {\n      warnOnce(\n        ComponentClass,\n        childName,\n        'component.invalid-family-declaration',\n        `\"${name}\" declares \"${childName}\" as neither a component class nor an importer; the declaration was ignored.`,\n        { component: name },\n      );\n    }\n  }\n}\n\n/** Register a lazy child without loading it. The first declaration wins. */\nfunction registerLazyChild(name: string, load: ComponentImporter): void {\n  if (registry.has(name) || manifest.has(name)) {\n    return;\n  }\n  manifest.set(name, { load });\n  setDOMMutationProcessor(processMutations);\n  scanName(document.documentElement, name);\n}\n\nfunction declaresComponent(el: Element, name: string): boolean {\n  return componentTokens(el).has(name);\n}\n\n/** Connected elements whose declarations need a breakpoint crossing. */\nfunction syncResponsiveElement(el: HTMLElement): void {\n  if (el.isConnected && hasResponsiveComponentAttribute(el)) {\n    responsiveElements.add(el);\n    registryState.unwatchBreakpoints ??= watchBreakpoint(() => {\n      scheduleResponsiveReconciliation(responsiveElements);\n    });\n    return;\n  }\n\n  responsiveElements.delete(el);\n  if (responsiveElements.size === 0) {\n    registryState.unwatchBreakpoints?.();\n    registryState.unwatchBreakpoints = null;\n  }\n}\n\n/** Coalesce responsive reconciliation in the background lifecycle queue. */\nfunction scheduleResponsiveReconciliation(elements: Iterable<HTMLElement>): void {\n  for (const el of elements) {\n    registryState.pendingResponsiveElements.add(el);\n  }\n  if (registryState.responsiveTask || registryState.pendingResponsiveElements.size === 0) {\n    return;\n  }\n\n  const task = defaultScheduler.background(() => {\n    const batch = registryState.pendingResponsiveElements;\n    registryState.pendingResponsiveElements = new Set();\n    for (const el of batch) {\n      if (el.isConnected) {\n        reconcileElement(el);\n      } else {\n        syncResponsiveElement(el);\n      }\n    }\n  });\n  registryState.responsiveTask = task;\n  trackDOMLifecycleWork(task.promise);\n  const finished = () => {\n    registryState.responsiveTask = null;\n    scheduleResponsiveReconciliation([]);\n  };\n  void task.promise.then(finished, finished);\n}\n\nif (!registryState.isReplacementListenerAttached) {\n  registryState.isReplacementListenerAttached = true;\n  onBreakpointsReplaced(() => {\n    const candidates = new Set(responsiveElements);\n    const selector = responsiveAttributeNames(COMPONENT_ATTRIBUTE)\n      .map((attribute) => `[${CSS.escape(attribute)}]`)\n      .join(',');\n    if (selector) {\n      for (const el of document.querySelectorAll<HTMLElement>(selector)) {\n        candidates.add(el);\n      }\n    }\n    scheduleResponsiveReconciliation(candidates);\n  });\n}\n\n/**\n * Register a component and its merged family, then scan matching elements.\n *\n * The name comes from the merged config, like the instance's `$id` and the\n * `INSTANCES` map key it publishes itself under: a subclass which extends a\n * component with extra config and forgets to rename would otherwise register\n * under `undefined` instead of colliding with the name it inherited.\n * @link https://js-toolkit-v4.studiometa.dev/api/registry/registerComponent.html\n */\nexport function registerComponent(ComponentClass: BaseConstructor): void {\n  const { name } = resolveConfig(ComponentClass);\n  if (registry.has(name)) {\n    if (registry.get(name) !== ComponentClass) {\n      warnOnce(\n        ComponentClass,\n        name,\n        'registry.conflict',\n        `\"${name}\" is already registered; the incoming declaration was ignored.`,\n        { component: name },\n      );\n    }\n    return;\n  }\n  registry.set(name, ComponentClass);\n  manifest.delete(name);\n\n  registerFamily(ComponentClass);\n\n  registerDOMOptionAttributes(optionAttributes(ComponentClass));\n  setDOMMutationProcessor(processMutations);\n  scanName(document.documentElement, name);\n}\n\n/** @link https://js-toolkit-v4.studiometa.dev/api/registry/registerComponents.html */\nexport function registerComponents(...classes: BaseConstructor[]): void {\n  for (const ComponentClass of classes) {\n    registerComponent(ComponentClass);\n  }\n}\n\n/**\n * Register lazy component entries. Element `data-mount` overrides the entry strategy; unloaded components have no instance.\n * @link https://js-toolkit-v4.studiometa.dev/api/registry/registerManifest.html\n */\nexport function registerManifest(entries: ComponentManifest): void {\n  const added: string[] = [];\n\n  for (const [name, entry] of Object.entries(entries)) {\n    if (registry.has(name) || manifest.has(name)) {\n      warnOnce(\n        entries,\n        name,\n        'registry.conflict',\n        `\"${name}\" is already registered; the incoming declaration was ignored.`,\n        { component: name },\n      );\n      continue;\n    }\n    manifest.set(name, typeof entry === 'function' ? { load: entry } : entry);\n    added.push(name);\n  }\n\n  if (added.length === 0) {\n    return;\n  }\n\n  setDOMMutationProcessor(processMutations);\n  for (const name of added) {\n    scanName(document.documentElement, name);\n  }\n}\n\n/**\n * Drop every registration, so the names a test used are free again.\n *\n * `registerComponent()` has no inverse by design: a page registers once and\n * keeps the registration for as long as it lives. A test suite is the one\n * caller for which that is wrong — the registry is page-wide and it survives\n * `resetDom()`, so a name registered by one spec is still taken in the next\n * one, and the workaround is a counter that mints `Widget-1`, `Widget-2` and\n * tells the reader nothing. This is the escape hatch, re-exported from\n * `@studiometa/js-toolkit/test`; it is not part of a page's vocabulary.\n *\n * **It is coarse on purpose.** A targeted `unregisterComponent(name)` would\n * have to find the elements holding that name's live triggers, and the map\n * from element to controller is a `WeakMap`: it cannot be enumerated, so\n * nothing can walk it to dispose them, and a `querySelectorAll()` sweep would\n * still miss every detached element. Clearing the whole registry works because\n * the mutation-observer path already disposes a controller as its element\n * leaves the DOM — which is why the call belongs *after* `resetDom()`.\n *\n * Two things it therefore does not do. It cannot clear that `WeakMap`, so a\n * controller whose element is still connected keeps its trigger; empty the DOM\n * first. And it does not narrow the attribute filter the shared observer built\n * from the options of everything ever registered — an extra watched attribute\n * costs a reconciliation pass that finds no owner, and nothing more.\n *\n * **Where the call belongs.** Spec files register at module top level, so\n * this in an `afterEach` silently unregisters everything for every later test\n * in the file. Put it in an `afterAll`, or call it and register again straight\n * away:\n *\n * ```ts\n * afterEach(async () => {\n *   await resetDom();\n *   resetRegistry();\n *   registerComponents(Subject, Emitter);\n * });\n * ```\n */\nexport function resetRegistry(): void {\n  registry.clear();\n  manifest.clear();\n  imports.clear();\n  responsiveElements.clear();\n  registryState.pendingResponsiveElements.clear();\n  registryState.responsiveTask?.cancel();\n  registryState.responsiveTask = null;\n  registryState.unwatchBreakpoints?.();\n  registryState.unwatchBreakpoints = null;\n}\n\n/** Import and register a lazy entry once per name. Failed imports are not retried. */\nfunction importComponent(name: string, target?: Element): Promise<void> {\n  const pending = imports.get(name);\n  if (pending) {\n    return pending;\n  }\n  const entry = manifest.get(name);\n  if (!entry) {\n    return Promise.resolve();\n  }\n\n  const work = Promise.resolve()\n    .then(() => entry.load())\n    .then((module) => {\n      const ComponentClass = resolveComponentClass(module, name);\n      if (!ComponentClass) {\n        throw new TypeError(`\"${name}\" did not resolve to a component class.`);\n      }\n      const resolvedName = resolveConfig(ComponentClass).name;\n      if (resolvedName !== name) {\n        warnOnce(\n          entry.load,\n          name,\n          'registry.lazy-name-mismatch',\n          `\"${name}\" resolved to a component named \"${resolvedName}\".`,\n          { component: name, target },\n        );\n      }\n      manifest.delete(name);\n      registerComponent(ComponentClass);\n    })\n    .catch((error: unknown) => {\n      reportDiagnostic('component.load-failed', `Failed to load component \"${name}\".`, error, {\n        component: name,\n        target,\n      });\n    });\n\n  imports.set(name, work);\n  return work;\n}\n\n/** Resolve a component class from a direct value, named export, or default export. */\nfunction resolveComponentClass(module: unknown, name: string): BaseConstructor | undefined {\n  if (isBaseConstructor(module)) {\n    return module;\n  }\n  if (typeof module !== 'object' || module === null) {\n    return undefined;\n  }\n  const exports = module as Record<string, unknown>;\n  for (const candidate of [exports[name], exports.default]) {\n    if (isBaseConstructor(candidate)) {\n      return candidate;\n    }\n  }\n  return undefined;\n}\n\nfunction optionAttributes(ComponentClass: BaseConstructor): string[] {\n  const names: string[] = [];\n  for (const [name, definition] of Object.entries(resolveConfig(ComponentClass).options ?? {})) {\n    const attribute = optionAttributeFor(name);\n    names.push(attribute);\n    // Register each exact breakpoint-scoped spelling with the observer filter.\n    observeResponsiveAttribute(attribute);\n\n    // Only a boolean can be turned off by a bare attribute, so only a boolean\n    // costs the observer its negated spellings.\n    if (declaresBoolean(definition)) {\n      const negated = negatedOptionAttributeFor(name);\n      names.push(negated);\n      observeResponsiveAttribute(negated);\n    }\n  }\n\n  return names;\n}\n\n/**\n * Resolve strategy precedence: element, then the default declared by whichever\n * half of the registry owns the name, then `eager`. A manifest entry states one\n * for exactly as long as its class cannot be read.\n */\nfunction resolveStrategy(el: Element, source: ComponentSource): string {\n  const declared = isBaseConstructor(source)\n    ? resolveConfig(source).mountStrategy\n    : source.mountStrategy;\n  return el.getAttribute(MOUNT_ATTRIBUTE) ?? declared ?? 'eager';\n}\n\n/**\n * The instance is created on first mount, not on discovery: a component\n * waiting for its strategy has no instance yet, so it stays invisible to\n * `$query`, `$closest` and `$watchChildren`, and announces nothing.\n */\nfunction isCurrentPair(el: HTMLElement, name: string, controller: PairController): boolean {\n  return (\n    controller.state === 'live' &&\n    controllers.get(el)?.get(name) === controller &&\n    el.isConnected &&\n    declaresComponent(el, name) &&\n    resolveStrategy(el, controller.source) === controller.strategy\n  );\n}\n\nfunction mountPair(\n  el: HTMLElement,\n  name: string,\n  ComponentClass: BaseConstructor,\n  controller: PairController,\n): void {\n  if (!isCurrentPair(el, name, controller)) {\n    return;\n  }\n  let instance = el[INSTANCES]?.get(name);\n  try {\n    if (!instance) {\n      instance = new ComponentClass(el);\n    }\n    instance.$mount();\n  } catch (error) {\n    // A failed derived constructor can leave the instance published by `Base`.\n    if (!instance) {\n      el[INSTANCES]?.delete(name);\n    }\n    reportDiagnostic('component.mount-failed', `Failed to mount component \"${name}\".`, error, {\n      component: name,\n      target: el,\n    });\n  }\n}\n\nfunction unmountPair(el: HTMLElement, name: string, controller: PairController): void {\n  if (isCurrentPair(el, name, controller)) {\n    el[INSTANCES]?.get(name)?.$unmount();\n  }\n}\n\n/**\n * Import the class a lazy declaration names, once.\n *\n * Importing is one-shot even on a reversible strategy, so the controller\n * stands down here instead of tearing its own trigger down: `media:` fires\n * while `applyMountStrategy()` is still running, when no teardown exists yet.\n * A spent controller fails `isCurrentPair()`, which is what makes a second\n * trigger inert, and the controller replacing it disposes the strategy.\n */\nfunction importPair(el: HTMLElement, name: string, controller: PairController): void {\n  if (!isCurrentPair(el, name, controller)) {\n    return;\n  }\n  controller.state = 'spent';\n  const work = importComponent(name, el);\n  if (controller.eager) {\n    // DOM settlement tracks eager imports only; conditional triggers can remain pending.\n    trackDOMLifecycleWork(work);\n  }\n}\n\n/** The hooks a strategy drives: mount a class, or import the module naming one. */\nfunction hooksFor(el: HTMLElement, name: string, controller: PairController): MountStrategyHooks {\n  const { source } = controller;\n  if (isBaseConstructor(source)) {\n    return {\n      mount: () => mountPair(el, name, source, controller),\n      unmount: () => unmountPair(el, name, controller),\n    };\n  }\n  return { mount: () => importPair(el, name, controller), unmount() {} };\n}\n\nfunction disposeController(el: Element, name: string): void {\n  const pairs = controllers.get(el);\n  const controller = pairs?.get(name);\n  if (!controller) {\n    return;\n  }\n  controller.state = 'disposed';\n  controller.dispose();\n  pairs?.delete(name);\n  if (pairs?.size === 0) {\n    controllers.delete(el);\n  }\n}\n\n/**\n * Schedule one element/component pair on the strategy that element resolves\n * to, whichever half of the registry answers for the name.\n *\n * A controller is replaced when the strategy changes and when the source\n * does — which is how an import lands: `registerComponent()` swaps the entry\n * for the class, and this pass turns the spent import trigger into a mount\n * controller for the same pair.\n */\nfunction schedule(el: HTMLElement, name: string): void {\n  const source = registry.get(name) ?? manifest.get(name);\n  if (!source) {\n    return;\n  }\n\n  const strategy = resolveStrategy(el, source);\n  let pairs = controllers.get(el);\n  const previous = pairs?.get(name);\n  if (previous?.strategy === strategy && previous.source === source) {\n    return;\n  }\n  // Read before teardown, which marks the controller disposed: a spent\n  // trigger on this very strategy is a condition already satisfied.\n  const wasSatisfied = previous?.state === 'spent' && previous.strategy === strategy;\n  if (previous) {\n    disposeController(el, name);\n  }\n\n  pairs = controllers.get(el);\n  if (!pairs) {\n    pairs = new Map();\n    controllers.set(el, pairs);\n  }\n\n  const { eager, reversible } = mountStrategyBehaviour(strategy);\n  const controller: PairController = {\n    dispose() {},\n    eager,\n    source,\n    state: 'live',\n    strategy,\n  };\n  pairs.set(name, controller);\n  const applied = applyMountStrategy(el, strategy, hooksFor(el, name, controller));\n  controller.dispose = applied.dispose;\n  if (!applied.valid) {\n    reportDiagnostic(\n      'component.invalid-mount-strategy',\n      `Failed to apply mount strategy \"${strategy}\" to component \"${name}\".`,\n      applied.error,\n      { component: name, target: el },\n    );\n  }\n  trackDOMLifecycleWork(applied.eagerWork);\n\n  // The class this pair just received is here because its own trigger fired.\n  // A one-shot condition cannot fire twice, so waiting for it again would\n  // leave the component unmounted forever; the import is the proof it was\n  // satisfied. A reversible condition is simply observed again.\n  if (wasSatisfied && !reversible && isBaseConstructor(source)) {\n    controller.dispose();\n    mountPair(el, name, source, controller);\n  }\n}\n\n/**\n * Make the framework state on one connected element match its final\n * `data-component` token set.\n */\nfunction reconcileElement(el: HTMLElement): void {\n  checkResponsiveAttributes(el, [COMPONENT_ATTRIBUTE]);\n  syncResponsiveElement(el);\n  const tokens = componentTokens(el);\n  const names = new Set<string>([\n    ...(controllers.get(el)?.keys() ?? []),\n    ...(el[INSTANCES]?.keys() ?? []),\n  ]);\n\n  for (const name of names) {\n    if (!tokens.has(name) && (registry.has(name) || manifest.has(name))) {\n      disposeController(el, name);\n      // Removing a declaration while the element remains is not a\n      // disconnection: it withdraws the component identity from the element.\n      // The two steps below say that in order — leave the mount cycle, then\n      // drop the identity — where a disconnection only does the first and\n      // keeps the instance for a later insertion. Declaring the name again\n      // builds a new instance, which is what the responsive crossing back\n      // expects.\n      const instance = el[INSTANCES]?.get(name);\n      if (instance) {\n        instance.$unmount();\n        el[INSTANCES]?.delete(name);\n      }\n    }\n  }\n\n  for (const name of tokens) {\n    schedule(el, name);\n  }\n}\n\n/**\n * Scan an inserted subtree once. Elements carrying retained instances are\n * included even when their declaration changed while detached.\n */\nfunction scan(root: Node): void {\n  if (!(root instanceof Element)) {\n    return;\n  }\n  for (const el of [root, ...root.querySelectorAll<HTMLElement>('*')]) {\n    if (hasComponentAttribute(el) || el[INSTANCES] || controllers.has(el)) {\n      reconcileElement(el as HTMLElement);\n    }\n  }\n}\n\n/**\n * A newly registered name — a class or a lazy entry — only needs its own\n * token matches. This avoids a full document walk for every registration\n * while inserted subtrees still use the one-pass scanner above.\n */\nfunction scanName(root: Element, name: string): void {\n  const selector = selectorFor(name);\n  const elements = root.matches(selector)\n    ? [root, ...root.querySelectorAll<HTMLElement>(selector)]\n    : [...root.querySelectorAll<HTMLElement>(selector)];\n  for (const el of elements) {\n    reconcileElement(el as HTMLElement);\n  }\n}\n\n// Disconnection unmounts an instance reversibly. Re-insertion remounts the same instance.\nfunction unmountWithin(node: Node, snapshot?: readonly Element[]): void {\n  if (!(node instanceof Element)) {\n    return;\n  }\n  for (const el of snapshot ?? [node, ...node.querySelectorAll<HTMLElement>('*')]) {\n    syncResponsiveElement(el as HTMLElement);\n    const pairs = controllers.get(el);\n    if (pairs) {\n      for (const name of pairs.keys()) {\n        disposeController(el, name);\n      }\n    }\n    if (!el[INSTANCES]) {\n      continue;\n    }\n    for (const instance of el[INSTANCES].values()) {\n      instance.$unmount();\n    }\n  }\n}\n\n/** The attribute mutations of one batch, sorted by what they affect. */\ninterface AttributeChanges {\n  declarations: Set<HTMLElement>;\n  strategies: Set<HTMLElement>;\n  options: Map<HTMLElement, Map<string, string | null>>;\n}\n\nfunction unmountRemovedSubtrees(records: readonly DOMMutationRecord[]): void {\n  for (const { record, removedSubtrees } of records) {\n    if (record.type === 'childList') {\n      for (const node of record.removedNodes) {\n        unmountWithin(node, removedSubtrees.get(node));\n      }\n    }\n  }\n}\n\nfunction collectAttributeChanges(records: readonly DOMMutationRecord[]): AttributeChanges {\n  const declarations = new Set<HTMLElement>();\n  const strategies = new Set<HTMLElement>();\n  const options = new Map<HTMLElement, Map<string, string | null>>();\n  for (const { record } of records) {\n    if (record.type !== 'attributes' || !(record.target instanceof HTMLElement)) {\n      continue;\n    }\n    if (isComponentAttribute(record.attributeName)) {\n      declarations.add(record.target);\n    } else if (record.attributeName === MOUNT_ATTRIBUTE) {\n      strategies.add(record.target);\n    } else if (isOptionAttribute(record.attributeName)) {\n      let changes = options.get(record.target);\n      if (!changes) {\n        changes = new Map();\n        options.set(record.target, changes);\n      }\n      // Mutation records carry each preceding value; the batch is applied\n      // against the final DOM, so only the first one is kept.\n      rememberPreviousValue(changes, record.attributeName, record.oldValue);\n    }\n  }\n  return { declarations, strategies, options };\n}\n\nfunction reconcileChangedElements({ declarations, strategies }: AttributeChanges): void {\n  // Reconcile once from final DOM state even when a morph changed the same\n  // attribute several times in this observer batch.\n  for (const el of declarations) {\n    if (el.isConnected) {\n      reconcileElement(el);\n    }\n  }\n  for (const el of strategies) {\n    if (el.isConnected && !declarations.has(el)) {\n      reconcileElement(el);\n    }\n  }\n}\n\nfunction applyOptionChanges({ options }: AttributeChanges): void {\n  for (const [el, changes] of options) {\n    if (!el.isConnected) {\n      continue;\n    }\n    for (const instance of el[INSTANCES]?.values() ?? []) {\n      if (instance.$isMounted) {\n        // Pass the full batch so responsive options can resolve previous values.\n        instance.$optionsChanged(changes);\n      }\n    }\n  }\n}\n\nfunction scanAddedNodes(records: readonly DOMMutationRecord[]): void {\n  for (const { record } of records) {\n    if (record.type === 'childList') {\n      for (const node of record.addedNodes) {\n        if (node.isConnected) {\n          scan(node);\n        }\n      }\n    }\n  }\n}\n\nfunction processMutations(records: readonly DOMMutationRecord[]): void {\n  // Teardown must finish before a moved node mounts under its new ancestor.\n  unmountRemovedSubtrees(records);\n  // Every attribute of the batch is collected before any of them is applied,\n  // so an element touched several times reconciles once, from final DOM state.\n  const changes = collectAttributeChanges(records);\n  reconcileChangedElements(changes);\n  // Option effects only run on components which survived declaration\n  // reconciliation and are mounted in this cycle. A waiting strategy reads\n  // the final values when it eventually mounts.\n  applyOptionChanges(changes);\n  // Insertions come last: a node moved within this batch was torn down above\n  // and mounts here, under the ancestor it ended up in.\n  scanAddedNodes(records);\n}\n"],"mappings":"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"}

package/dist/responsive-options.d.ts

@@ -0,0 +1,34 @@
+//#region src/responsive-options.d.ts
+/**
+ * Exact scoped spellings used by declaration cascades and observer filters.
+ * @internal
+ */
+declare function responsiveAttributeNames(attribute: string): readonly string[];
+/** Add an attribute's breakpoint-scoped names to the mutation observer filter. */
+declare function observeResponsiveAttribute(attribute: string): void;
+/** Return the widest matching breakpoint without creating a subscription. */
+declare function activeBreakpoint(): string;
+/**
+ * Resolve a raw option value by cascading from a breakpoint to the base attribute.
+ *
+ * `negated` is the off spelling of a boolean option, consulted at each level
+ * **after** the on spelling: a narrower breakpoint wins over a wider one
+ * whichever spelling it uses, and at one breakpoint the positive attribute
+ * wins, since declaring both there says nothing coherent. It resolves to
+ * `NEGATED_RAW`, so one cascade answers both spellings.
+ */
+declare function responsiveRawValue(attribute: string, breakpoint: string, get: (name: string) => string | null, negated?: string): string | null;
+/**
+ * The scoped value in force at one breakpoint, without falling back to the
+ * plain attribute. An empty string is a present override; `null` means no
+ * scoped candidate was present.
+ *
+ * @internal
+ */
+declare function responsiveScopedRawValue(attribute: string, breakpoint: string, get: (name: string) => string | null): string | null;
+/** Watch breakpoint changes and pass the previous breakpoint to the callback. */
+declare function watchBreakpoint(callback: (previous: string) => void): () => void;
+/** Warn once for each responsive attribute suffix that names no breakpoint. */
+declare function checkResponsiveAttributes(el: HTMLElement, attributes: readonly string[]): void;
+//#endregion
+export { activeBreakpoint, checkResponsiveAttributes, observeResponsiveAttribute, responsiveAttributeNames, responsiveRawValue, responsiveScopedRawValue, watchBreakpoint };

package/dist/responsive-options.js

@@ -0,0 +1,106 @@
+import { memo } from "./utils/memo.js";
+import { namespaceQualifier, namespacedAttribute } from "./attributes.js";
+import { getSharedRuntimeSlot } from "./shared-runtime.js";
+import { warnOnce } from "./diagnostics.js";
+import { registerDOMOptionAttributes, replaceDOMOptionAttributes } from "./dom-mutations.js";
+import { breakpointNames, onBreakpointsReplaced, useBreakpoint } from "./services/breakpoint.js";
+//#region src/responsive-options.ts
+/**
+* Responsive options cascade from the active breakpoint through narrower breakpoints to the unsuffixed base value.
+*
+* Values are resolved on read and are not stored.
+*/
+const responsiveOptionsState = /* @__PURE__ */ getSharedRuntimeSlot("responsive-options", 2, () => ({
+	scopedAttributes: memo((attribute) => breakpointNames().map((name) => namespacedAttribute(attribute, name))),
+	observed: /* @__PURE__ */ new Set(),
+	isReplacementListenerAttached: false
+}));
+const { scopedAttributes, observed } = responsiveOptionsState;
+/**
+* Exact scoped spellings used by declaration cascades and observer filters.
+* @internal
+*/
+function responsiveAttributeNames(attribute) {
+	return scopedAttributes(attribute);
+}
+/** Base attributes whose scoped spellings the one observer filters for. */
+if (!responsiveOptionsState.isReplacementListenerAttached) {
+	responsiveOptionsState.isReplacementListenerAttached = true;
+	onBreakpointsReplaced(() => {
+		const previous = [...observed].flatMap((attribute) => scopedAttributes(attribute));
+		scopedAttributes.clear();
+		const next = [...observed].flatMap((attribute) => scopedAttributes(attribute));
+		replaceDOMOptionAttributes(previous, next);
+	});
+}
+/** Add an attribute's breakpoint-scoped names to the mutation observer filter. */
+function observeResponsiveAttribute(attribute) {
+	observed.add(attribute);
+	registerDOMOptionAttributes(scopedAttributes(attribute));
+}
+/** Return the widest matching breakpoint without creating a subscription. */
+function activeBreakpoint() {
+	return useBreakpoint().props().name;
+}
+/**
+* Resolve a raw option value by cascading from a breakpoint to the base attribute.
+*
+* `negated` is the off spelling of a boolean option, consulted at each level
+* **after** the on spelling: a narrower breakpoint wins over a wider one
+* whichever spelling it uses, and at one breakpoint the positive attribute
+* wins, since declaring both there says nothing coherent. It resolves to
+* `NEGATED_RAW`, so one cascade answers both spellings.
+*/
+function responsiveRawValue(attribute, breakpoint, get, negated) {
+	if (negated === void 0) return responsiveScopedRawValue(attribute, breakpoint, get) ?? get(attribute);
+	const names = breakpointNames();
+	const scoped = scopedAttributes(attribute);
+	const scopedNegations = scopedAttributes(negated);
+	for (let index = names.indexOf(breakpoint); index >= 0; index -= 1) {
+		const value = get(scoped[index]);
+		if (value !== null) return value;
+		if (get(scopedNegations[index]) !== null) return "\0";
+	}
+	return get(attribute) ?? (get(negated) === null ? null : "\0");
+}
+/**
+* The scoped value in force at one breakpoint, without falling back to the
+* plain attribute. An empty string is a present override; `null` means no
+* scoped candidate was present.
+*
+* @internal
+*/
+function responsiveScopedRawValue(attribute, breakpoint, get) {
+	const names = breakpointNames();
+	const scoped = scopedAttributes(attribute);
+	for (let index = names.indexOf(breakpoint); index >= 0; index -= 1) {
+		const value = get(scoped[index]);
+		if (value !== null) return value;
+	}
+	return null;
+}
+/** Watch breakpoint changes and pass the previous breakpoint to the callback. */
+function watchBreakpoint(callback) {
+	let previous = activeBreakpoint();
+	return useBreakpoint().subscribe(({ name }) => {
+		const left = previous;
+		previous = name;
+		callback(left);
+	});
+}
+/** Warn once for each responsive attribute suffix that names no breakpoint. */
+function checkResponsiveAttributes(el, attributes) {
+	if (attributes.length === 0) return;
+	const names = breakpointNames();
+	for (const name of el.getAttributeNames()) for (const attribute of attributes) {
+		const qualifier = namespaceQualifier(attribute, name);
+		if (qualifier !== null && !names.includes(qualifier)) {
+			warnOnce(el, name, "responsive.unknown-breakpoint", `\`${name}\` names no breakpoint, so it is never read. One breakpoint per attribute, cascading upwards from it — known names: ${names.join(", ")}.`, { target: el });
+			break;
+		}
+	}
+}
+//#endregion
+export { activeBreakpoint, checkResponsiveAttributes, observeResponsiveAttribute, responsiveAttributeNames, responsiveRawValue, responsiveScopedRawValue, watchBreakpoint };
+
+//# sourceMappingURL=responsive-options.js.map