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

package/dist/Base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Base.js","names":["#isMounted","#optionReaders","#bindHandlers","#mountCycle","#initializeOptionEffects","#isActiveMountCycle","#initializeResponsiveOptions","#guard","#collectCleanup","#listeners","#tasks","#unmountCallbacks","#clearOptionEffects","#dispatch","#childrenWatchers","#runOptionEffect","#track","#optionCleanups","#bindDecoratedHandlers","#bindPlannedHandlers","#installDelegatedListeners","#bindGlobal","#bindOwn","#invokeDelegated"],"sources":["../src/Base.ts"],"sourcesContent":["import {\n  isInNamespace,\n  isNetChange,\n  NEGATED_RAW,\n  negatedOptionAttributeFor,\n  optionAttributeFor,\n  REF_ATTRIBUTE,\n} from './attributes.js';\nimport { BASE_BRAND } from './component-brand.js';\nimport { componentTokens } from './component-declarations.js';\nimport { registerChildrenWatcher, type ChildrenWatcher } from './children-watchers.js';\nimport { injectContext, injectContextSync, provideContext, type ContextKey } from './context.js';\nimport type { ToolkitDiagnosticCode } from './diagnostic-contract.js';\nimport { reportDiagnostic, warn, warnOnce } from './diagnostics.js';\nimport { compareDocumentOrder } from './document-order.js';\nimport { domVersion } from './dom-mutations.js';\nimport { EVENTS } from './events.js';\nimport { HANDLER_REGISTRATIONS, INSTANCES } from './protocol-symbols.js';\nimport { defaultScheduler, type ScheduledTask } from './scheduler.js';\nimport {\n  activeBreakpoint,\n  checkResponsiveAttributes,\n  responsiveRawValue,\n  watchBreakpoint,\n} from './responsive-options.js';\nimport type { MountStrategy } from './mount-strategies.js';\nimport { memo } from './utils/memo.js';\nimport { selectorFor } from './utils/selectors.js';\nimport { capitalize, kebabCase } from './utils/strings.js';\n\nconst REGEX_HANDLER = /^on[A-Z]/;\n\nlet componentId = 0;\n\nexport type OptionType =\n  | typeof String\n  | typeof Number\n  | typeof Boolean\n  | typeof Array\n  | typeof Object;\n\n/** An ordered list of types accepted by one option. */\nexport type OptionTypes = readonly OptionType[];\n\ntype OptionDefinitionType = OptionType | OptionTypes;\n\n/**\n * The value an option of a given type holds.\n */\ntype OptionValue<T extends OptionDefinitionType> = T extends OptionTypes\n  ? OptionValue<T[number]>\n  : T extends typeof String\n    ? string\n    : T extends typeof Number\n      ? number\n      : T extends typeof Boolean\n        ? boolean\n        : T extends typeof Array\n          ? unknown[]\n          : Record<string, unknown>;\n\ntype PrimitiveOptionType = typeof String | typeof Number | typeof Boolean;\n\n/** `Array` and `Object` defaults must be per-instance factories. */\ntype TypedOptionDefinition<T extends OptionDefinitionType = OptionDefinitionType> =\n  T extends OptionTypes\n    ? {\n        type: T;\n        default?:\n          | (() => OptionValue<T>)\n          | (Extract<T[number], PrimitiveOptionType> extends never\n              ? never\n              : OptionValue<Extract<T[number], PrimitiveOptionType>>);\n      }\n    : T extends OptionType\n      ? T extends typeof Array | typeof Object\n        ? { type: T; default?: () => OptionValue<T> }\n        : { type: T; default?: OptionValue<T> | (() => OptionValue<T>) }\n      : never;\n\nexport type OptionDefinition = OptionDefinitionType | TypedOptionDefinition;\n\nexport interface OptionChange<T = unknown> {\n  name: string;\n  value: T;\n  previousValue: T | undefined;\n  rawValue: string | null;\n  previousRawValue: string | null;\n  initial: boolean;\n}\n\nexport type OptionChangedReturn = void | (() => void);\n\n/** Lazy importer resolving to a component class, default export or module namespace. */\nexport type ComponentImporter = () => Promise<unknown>;\n\nexport interface BaseConfig {\n  name: string;\n  /** Child classes or lazy importers keyed by component name. Importers are registered without being called. */\n  components?: Record<string, BaseConstructor | ComponentImporter>;\n  refs?: string[];\n  options?: Record<string, OptionDefinition>;\n  /**\n   * When instances of this component mount. Defaults to `eager`; an\n   * element's `data-mount` attribute overrides it.\n   */\n  mountStrategy?: MountStrategy;\n}\n\n/** Structural component constructor compatible with typed `Base` subclasses. */\nexport interface BaseConstructor {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  new (el: HTMLElement): Base<any>;\n  config: BaseConfig;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  readonly prototype: Base<any>;\n}\n\n/** Child event payload. `payload` is the unchanged event detail, typed from the child's `$emits`. */\nexport interface DelegatedEvent<T extends Base = Base, K extends string = string> {\n  event: Event;\n  target: T;\n  payload: EmitDetail<PropsOf<T>, K>;\n}\n\n/**\n * Payload given to `on<Ref><Event>` handlers. `index` is the ref's position\n * among the same-named refs, so a list of buttons can be told apart.\n */\nexport interface RefEvent<T extends HTMLElement = HTMLElement> {\n  event: Event;\n  target: T;\n  index: number;\n}\n\n/** Global handler payload containing the named target and platform event. */\nexport interface GlobalEvent<T extends Event = Event> {\n  event: T;\n  target: Window | Document;\n}\n\n/**\n * Events that do not bubble, so their delegated listener must be registered\n * in the capture phase to be reached at all.\n */\nconst CAPTURED_EVENTS = new Set([\n  'blur',\n  'focus',\n  'load',\n  'error',\n  'scroll',\n  'mouseenter',\n  'mouseleave',\n  'pointerenter',\n  'pointerleave',\n]);\n\n/**\n * Type-level description of a component's public surface.\n *\n * `$el` narrows the root element. `$emits` maps event names to payload objects, or `void` for events without payloads. Declarations do not validate markup at runtime.\n */\nexport interface BaseProps {\n  $el?: HTMLElement;\n  $refs?: Record<string, HTMLElement | HTMLElement[]>;\n  /** `object` accepts named option interfaces without requiring an index signature. */\n  $options?: object;\n  $emits?: EmitMap;\n}\n\n/**\n * What `$emits` maps an event name to: the payload object the event carries,\n * or `void` for one that carries nothing.\n */\nexport type EmitMap = Record<string, object | void>;\n\n/* Intersections keep generic props resolved and `Base<T>` assignable to `Base`. */\n\ntype El<T extends BaseProps> = T['$el'] & HTMLElement;\n\ntype Refs<T extends BaseProps> = T['$refs'] & Record<string, HTMLElement | HTMLElement[]>;\n\ntype Options<T extends BaseProps> = T['$options'] & Record<string, unknown>;\n\n/** Resolve declared event names without widening them to `string`. */\ntype Emits<T extends BaseProps> = NonNullable<T['$emits']> &\n  (unknown extends T['$emits'] ? EmitMap : unknown);\n\n/**\n * A component that declares `$emits` may only emit those names; one that\n * does not keeps the unrestricted signature — `keyof EmitMap` is `string`.\n */\ntype EmitName<T extends BaseProps> = keyof Emits<T> & string;\n\n/**\n * The `detail` an event carries: the declared payload object, or `null` for an\n * event declared `void`. `null` rather than `{}` because that is what the\n * platform stores for a `CustomEvent` built without a detail — nothing is\n * synthesized to stand in for a payload nobody announced.\n */\ntype EmitDetail<T extends BaseProps, K extends string> =\n  // An un-narrowed `string` means the caller did not name the event, so\n  // there is nothing to look up.\n  string extends K ? unknown : PayloadOf<Emits<T>, K>;\n\n/**\n * One payload, looked up in a resolved `$emits` map. The lookup is an indexed\n * access rather than `K extends keyof M ? … : never`: `keyof M` mentions the\n * props parameter, and a conditional that tests against it is deferred for\n * every component that has one.\n */\ntype PayloadOf<M extends EmitMap, K extends string> = M[K] extends void ? null : M[K];\n\n/**\n * `$emit()`'s payload parameter, as a tuple so a declared payload is\n * **required** and a `void` event takes none — an event declared `void` accepts\n * no payload object, only the absent argument.\n */\ntype EmitArgs<T extends BaseProps, K extends string> = string extends K\n  ? [payload?: object]\n  : ArgsOf<Emits<T>, K>;\n\n/** Check concrete `void` first so generic component argument tuples remain resolvable. */\ntype ArgsOf<M extends EmitMap, K extends string> = void extends M[K]\n  ? [payload?: M[K]]\n  : [payload: M[K]];\n\n/**\n * The props a component was declared with, read from the phantom carrier\n * `Base` holds — inferring through `Base<infer P>` does not work, since the\n * parameter only appears inside conditional types.\n */\ntype PropsOf<T> = T extends { __props?: infer P }\n  ? NonNullable<P> extends BaseProps\n    ? NonNullable<P>\n    : BaseProps\n  : BaseProps;\n\nexport interface WatchChildrenCallbacks<T extends Base = Base> {\n  added?(instance: T): void;\n  removed?(instance: T): void;\n}\n\n/**\n * Live, DOM-ordered view over mounted descendants matched by exact component\n * name or by a component constructor and its subclasses.\n */\nexport interface ChildrenCollection<T extends Base = Base> extends Iterable<T> {\n  readonly size: number;\n  readonly items: T[];\n}\n\nexport interface LifecycleEventDetail {\n  instance: Base;\n}\n\n/**\n * One handler declared with the `@on` decorator. Initializers store these on\n * the realm-stable `HANDLER_REGISTRATIONS` key for each instance.\n */\nexport interface HandlerRegistration {\n  /**\n   * The decorated method's name, and the only key the magic name scan dedupes\n   * on. Not the function it decorates: `@read` and `@write` **replace** the\n   * method with a wrapper, so a `@write` applied above an `@on` leaves the\n   * class carrying a function this registration never saw. Comparing\n   * identities missed it and bound the same handler a second time, which made\n   * the order the two decorators are stacked in part of the interface. The\n   * name is the same on both sides whatever wraps the body.\n   */\n  method: string | symbol;\n  /**\n   * Global event target for `@on(window, …)` / `@on(document, …)`, `null` for\n   * everything the component can reach from its own subtree. Recorded as the\n   * target itself rather than as a reserved `child` name, so the string space\n   * stays free for a child or a ref actually called `window`.\n   */\n  target: Window | Document | null;\n  /**\n   * Child component name — or ref name, spelled the way `config.refs` declares\n   * it, `[]` included for a list — for delegated handlers. `null` for own\n   * events.\n   */\n  child: string | null;\n  type: string;\n  handler: (this: any, payload: any) => void;\n}\n\ndeclare global {\n  interface Element {\n    [INSTANCES]?: Map<string, Base>;\n  }\n}\n\n/** Warn for non-object payloads used from untyped code. The event still dispatches. */\nfunction checkPayload(instance: Base, event: string, payload: unknown): void {\n  if (payload !== undefined && (typeof payload !== 'object' || payload === null)) {\n    warnOnce(\n      instance,\n      event,\n      'event.invalid-emit-payload',\n      `\\`$emit('${event}', …)\\` takes one payload object; received ${typeof payload}. Name the value: \\`{ value }\\`.`,\n      { component: instance.$config.name, target: instance.$el },\n    );\n  }\n}\n\n/**\n * Test ref ownership. Plain refs stop at any component boundary; namespaced refs stop at a boundary with the named component.\n *\n * The root is not tested because the namespace uses the class config name, which can differ from its declaration token.\n */\nfunction belongsTo(el: Element, root: Element, owner?: string): boolean {\n  let parent = el.parentElement;\n  while (parent && parent !== root) {\n    const declarations = componentTokens(parent);\n    if (owner === undefined ? declarations.size > 0 : declarations.has(owner)) {\n      return false;\n    }\n    parent = parent.parentElement;\n  }\n  return parent === root;\n}\n\n/** The list suffix is part of both the declaration and `data-ref` value. */\nconst REF_LIST_SUFFIX = '[]';\n\nfunction isRefList(definition: string): boolean {\n  return definition.endsWith(REF_LIST_SUFFIX);\n}\n\n/** The name a `config.refs` entry takes in `$refs`, and in `on<Ref><Event>`. */\nfunction refPropertyName(definition: string): string {\n  return isRefList(definition) ? definition.slice(0, -REF_LIST_SUFFIX.length) : definition;\n}\n\n/** Namespaced refs name their owner and can cross other component boundaries. */\nconst REF_NAMESPACE_SEPARATOR = '.';\n\n/** Return `Component.ref[]`; the namespace wraps the complete ref definition. */\nfunction namespacedRef(componentName: string, definition: string): string {\n  return `${componentName}${REF_NAMESPACE_SEPARATOR}${definition}`;\n}\n\n/**\n * Does this element declare `definition` as a ref of `root`, in either\n * spelling? The two forms scope differently, so which one was written decides\n * how ownership is resolved.\n */\nfunction isRefOf(\n  el: Element,\n  root: Element,\n  componentName: string,\n  definition: string,\n): el is HTMLElement {\n  const declared = el.getAttribute(REF_ATTRIBUTE);\n  if (declared === definition) {\n    return belongsTo(el, root);\n  }\n  return (\n    declared === namespacedRef(componentName, definition) && belongsTo(el, root, componentName)\n  );\n}\n\n/** Return owned plain and namespaced refs for the declared name, in document order. */\nfunction queryRefs(root: HTMLElement, componentName: string, definition: string): HTMLElement[] {\n  const plain = [\n    ...root.querySelectorAll<HTMLElement>(`[${REF_ATTRIBUTE}=\"${definition}\"]`),\n  ].filter((el) => belongsTo(el, root));\n  const namespaced = root.querySelectorAll<HTMLElement>(\n    `[${REF_ATTRIBUTE}=\"${namespacedRef(componentName, definition)}\"]`,\n  );\n  if (namespaced.length === 0) {\n    return plain;\n  }\n  const owned = [...namespaced].filter((el) => belongsTo(el, root, componentName));\n  if (plain.length === 0) {\n    return owned;\n  }\n  // One property, so one document order — an index handed to `on<Ref><Event>`\n  // has to mean the same thing as an index into `$refs`.\n  return [...plain, ...owned].sort(compareDocumentOrder);\n}\n\n/** Warn once when a missing list ref has an unsuffixed markup candidate. */\nfunction warnMissingRefSuffix(instance: Base, definition: string, checked: Set<string>): void {\n  if (checked.has(definition)) {\n    return;\n  }\n  checked.add(definition);\n  const name = refPropertyName(definition);\n  const namespaced = namespacedRef(instance.$config.name, name);\n  // Both spellings, so `data-ref=\"Slider.dots\"` is caught the same way\n  // `data-ref=\"dots\"` is. This runs once per instance and per ref, and only\n  // when the ref found nothing, so the selector list costs nothing here.\n  if (\n    !instance.$el.querySelector(`[${REF_ATTRIBUTE}=\"${name}\"],[${REF_ATTRIBUTE}=\"${namespaced}\"]`)\n  ) {\n    return;\n  }\n  warnOnce(\n    instance,\n    `attribute:${definition}`,\n    'ref.mismatch',\n    `\\`${instance.$config.name}\\` declares \\`${definition}\\` and found no \\`data-ref=\"${definition}\"\\`, but the markup declares \\`data-ref=\"${name}\"\\`. A list ref carries the \\`[]\\` in the attribute too: add it, or drop it from \\`config.refs\\`.`,\n    { component: instance.$config.name, target: instance.$el },\n  );\n}\n\n/** Warn when `@on()` uses a list ref's derived property name instead of its suffixed declaration. */\nfunction warnRefSuffixMismatch(\n  instance: Base,\n  child: string,\n  refs: Array<{ definition: string }>,\n): void {\n  const other = isRefList(child) ? refPropertyName(child) : `${child}${REF_LIST_SUFFIX}`;\n  if (!refs.some(({ definition }) => definition === other)) {\n    return;\n  }\n  warnOnce(\n    instance,\n    `handler:${child}`,\n    'ref.mismatch',\n    `\\`${instance.$config.name}\\` binds \\`@on('${child}', …)\\`, which matches no component and no ref. The ref is declared \\`${other}\\`, and \\`@on()\\` names a ref the way it is declared: write \\`@on('${other}', …)\\`.`,\n    { component: instance.$config.name, target: instance.$el },\n  );\n}\n\n/**\n * Build live refs resolved from current DOM. List declarations return arrays; namespaced attributes use the unqualified property name.\n */\nfunction buildRefs(instance: Base): Record<string, HTMLElement | HTMLElement[]> {\n  const refs: Record<string, HTMLElement | HTMLElement[]> = {};\n  const checked = new Set<string>();\n  const componentName = instance.$config.name;\n  for (const definition of instance.$config.refs ?? []) {\n    const isList = isRefList(definition);\n    const name = refPropertyName(definition);\n    // Cache live refs by document version; structural changes invalidate them.\n    let cachedVersion = -1;\n    let cached: HTMLElement[] = [];\n    Object.defineProperty(refs, name, {\n      enumerable: true,\n      get() {\n        let elements: HTMLElement[];\n        // A detached subtree produces no mutation records, so nothing\n        // would ever invalidate a cache built from it.\n        if (instance.$el.isConnected) {\n          const version = domVersion();\n          if (version !== cachedVersion) {\n            cachedVersion = version;\n            cached = queryRefs(instance.$el, componentName, definition);\n          }\n          elements = cached;\n        } else {\n          elements = queryRefs(instance.$el, componentName, definition);\n        }\n        if (isList && elements.length === 0) {\n          warnMissingRefSuffix(instance, definition, checked);\n        }\n        return isList ? elements : elements[0];\n      },\n    });\n  }\n  return refs;\n}\n\n/** Build live attribute-backed options with per-instance defaults. */\ninterface OptionReader {\n  /** The unsuffixed `data-option-*` attribute — the base of the cascade. */\n  attribute: string;\n  /**\n   * The raw string in force now: the value of the breakpoint-scoped spelling\n   * the cascade selects, or the base attribute's when none is scoped.\n   */\n  rawValue(): string | null;\n  /**\n   * The raw string that was in force at another breakpoint, or before a\n   * mutation batch. `get` supplies the attribute values to resolve against, so\n   * the same cascade answers both questions.\n   */\n  rawValueAt(breakpoint: string, get: (name: string) => string | null): string | null;\n  /** Whether an attribute name is this option's, at any breakpoint. */\n  owns(attributeName: string): boolean;\n  read(raw: string | null): unknown;\n}\n\n/** The method name an option's effect is declared under. */\nfunction optionChangedMethod(name: string): string {\n  return `option${capitalize(name)}Changed`;\n}\n\n/** The effect an option declares, or `undefined` when the component declares none. */\nfunction optionChangedHandler(\n  instance: Base,\n  name: string,\n): ((change: OptionChange) => OptionChangedReturn) | undefined {\n  const handler = (instance as unknown as Record<string, unknown>)[optionChangedMethod(name)];\n  return typeof handler === 'function'\n    ? (handler as (change: OptionChange) => OptionChangedReturn)\n    : undefined;\n}\n\n/** Warn once per declaration for literal object or array defaults. Values are not copied. */\nfunction warnLiteralDefault(\n  componentName: string,\n  option: string,\n  definition: object,\n  declared: object,\n  target: Element,\n): void {\n  const kind = Array.isArray(declared) ? 'array' : 'object';\n  warnOnce(\n    definition,\n    '',\n    'option.literal-default',\n    `\\`${componentName}\\` declares option \\`${option}\\` with a literal ${kind} default, which every instance of it then shares. Only a primitive may be a default; declare this one as a factory: \\`default: () => (…)\\`.`,\n    { component: componentName, target },\n  );\n}\n\n/** Turn the attribute in force into a value. `null` means the attribute is absent. */\ntype OptionTypeRule = (raw: string | null, defaultValue: () => unknown) => unknown;\n\n/** An absent attribute reads the declared default, or the type's empty value. */\nfunction absentValue(defaultValue: () => unknown, empty: unknown): unknown {\n  const value = defaultValue();\n  return value === undefined ? empty : value;\n}\n\n/**\n * `buildDefault()` already answers `[]` or `{}` when nothing was declared, so\n * a structured type needs no empty value of its own. Unparsable JSON is not a\n * failure either: the option falls back to that same default.\n */\nfunction readJSON(raw: string | null, defaultValue: () => unknown): unknown {\n  if (raw === null) {\n    return absentValue(defaultValue, undefined);\n  }\n  try {\n    return JSON.parse(raw);\n  } catch {\n    return defaultValue();\n  }\n}\n\nfunction emptyValue(type: OptionType): unknown {\n  if (type === Boolean) return false;\n  if (type === Number) return 0;\n  if (type === String) return '';\n  if (type === Array) return [];\n  return {};\n}\n\nfunction isOptionValue(value: unknown, type: OptionType): boolean {\n  if (type === Boolean) return typeof value === 'boolean';\n  if (type === Number) return typeof value === 'number' && !Number.isNaN(value);\n  if (type === String) return typeof value === 'string';\n  if (type === Array) return Array.isArray(value);\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\n/** What each supported option type makes of its attribute. */\nconst OPTION_TYPE_RULES = new Map<OptionType, OptionTypeRule>([\n  // Presence is the value — the attribute is there or it is not, as a platform\n  // boolean attribute is — so `data-option-x=\"false\"` reads `true` and the way\n  // to turn one off is to remove the attribute or to write its negated\n  // spelling. Unlike every other type, a declared `null` default still reads\n  // as `false`.\n  [\n    Boolean,\n    (raw, defaultValue) => (raw === null ? (defaultValue() ?? false) : raw !== NEGATED_RAW),\n  ],\n  [Number, (raw, defaultValue) => (raw === null ? absentValue(defaultValue, 0) : Number(raw))],\n  [String, (raw, defaultValue) => (raw === null ? absentValue(defaultValue, '') : raw)],\n  [Array, readJSON],\n  [Object, readJSON],\n]);\n\nfunction readUnion(types: OptionTypes, raw: string | null, defaultValue: () => unknown): unknown {\n  if (raw === null) {\n    return absentValue(defaultValue, types[0] === undefined ? undefined : emptyValue(types[0]));\n  }\n\n  // A negation is not a value, so it is answered before the members are tried:\n  // `[String, Boolean]` would otherwise hand the sentinel to the string rule,\n  // which accepts any string, and the option would read as one.\n  if (raw === NEGATED_RAW) {\n    return false;\n  }\n\n  for (const type of types) {\n    const value = OPTION_TYPE_RULES.get(type)!(raw, () => undefined);\n    if (isOptionValue(value, type)) {\n      return value;\n    }\n  }\n\n  return defaultValue();\n}\n\nfunction isOptionTypes(value: unknown): value is OptionTypes {\n  return Array.isArray(value);\n}\n\nfunction isOptionShorthand(definition: OptionDefinition): definition is OptionType | OptionTypes {\n  return typeof definition === 'function' || isOptionTypes(definition);\n}\n\n/**\n * Whether an option can hold `false`, and therefore whether the negated\n * attribute means anything for it. A union is enough: `[Boolean, String]` can\n * be turned off, `[String, Number]` has nothing to turn off.\n */\nexport function declaresBoolean(definition: OptionDefinition): boolean {\n  const type = isOptionShorthand(definition) ? definition : definition.type;\n  return isOptionTypes(type) ? type.includes(Boolean) : type === Boolean;\n}\n\n/**\n * The `$options` view and the readers behind it, built in one pass: the getters\n * and the readers are the same closures seen from two sides.\n */\nfunction buildOptions(instance: Base): {\n  options: Record<string, unknown>;\n  readers: Map<string, OptionReader>;\n} {\n  const options: Record<string, unknown> = {};\n  const readers = new Map<string, OptionReader>();\n  const el = instance.$el;\n  for (const [name, definition] of Object.entries(instance.$config.options ?? {})) {\n    const shorthand = isOptionShorthand(definition);\n    const type = shorthand ? definition : definition.type;\n    const declared = shorthand ? undefined : definition.default;\n    const attribute = optionAttributeFor(name);\n    // Only an option which can hold `false` has an off spelling to read.\n    const negated = declaresBoolean(definition) ? negatedOptionAttributeFor(name) : undefined;\n\n    if (!shorthand && declared !== null && typeof declared === 'object') {\n      warnLiteralDefault(instance.$config.name, name, definition, declared, el);\n    }\n\n    // Built on first read and memoised, so repeated reads hand back the same\n    // object and a mutation of it sticks — for this instance only.\n    let memoized: unknown;\n    let isMemoized = false;\n    const defaultValue = (): unknown => {\n      if (!isMemoized) {\n        isMemoized = true;\n        memoized = buildDefault();\n      }\n      return memoized;\n    };\n    const buildDefault = (): unknown => {\n      // `Function` is not an option type, so a callable default is a factory.\n      if (typeof declared === 'function') {\n        return (declared as () => unknown)();\n      }\n      // Anything else is handed over as declared — including a literal object\n      // or array, which the contract does not allow and `warnLiteralDefault()`\n      // has already reported. Copying it here would repair a declaration the\n      // contract rejects, and make an unsupported form look supported.\n      if (declared !== undefined) {\n        return declared;\n      }\n      // An undeclared object or array default is still the instance's own.\n      const defaultType = isOptionTypes(type) ? type[0] : type;\n      if (defaultType === Array) return [];\n      if (defaultType === Object) return {};\n      return undefined;\n    };\n\n    const read = (raw: string | null): unknown =>\n      isOptionTypes(type)\n        ? readUnion(type, raw, defaultValue)\n        : (\n            OPTION_TYPE_RULES.get(type) ??\n            ((value, fallback) => (value === null ? absentValue(fallback, undefined) : value))\n          )(raw, defaultValue);\n\n    // Every option is responsive, and it is **derived on read**: the getter\n    // consults the viewport as well as the element, and stores nothing. This\n    // is what lets `$options` stay a read-only view — there is no moment at\n    // which a breakpoint change has to write a value in.\n    const fromElement = (attributeName: string) => el.getAttribute(attributeName);\n    const rawValue = () => responsiveRawValue(attribute, activeBreakpoint(), fromElement, negated);\n    const rawValueAt = (breakpoint: string, get: (attributeName: string) => string | null) =>\n      responsiveRawValue(attribute, breakpoint, get, negated);\n    // An option owns its generated namespace: the base name and every\n    // breakpoint-qualified spelling of it, on both the value and the negation.\n    const owns = (attributeName: string) =>\n      isInNamespace(attribute, attributeName) ||\n      (negated !== undefined && isInNamespace(negated, attributeName));\n\n    readers.set(name, { attribute, rawValue, rawValueAt, owns, read });\n    Object.defineProperty(options, name, {\n      enumerable: true,\n      get: () => read(rawValue()),\n    });\n  }\n  return { options, readers };\n}\n\n/**\n * Merge inherited config. Collections merge; declared scalar values override parent values.\n *\n * The registry uses this before an instance exists. Memoised per class: a\n * config is a pure function of the prototype chain, and `$config` reads it on\n * every access.\n */\nexport const resolveConfig = /* @__PURE__ */ memo((ctor: BaseConstructor): BaseConfig => {\n  const chain: BaseConfig[] = [];\n  let current: BaseConstructor | null = ctor;\n  while (current?.config) {\n    if (Object.hasOwn(current, 'config')) {\n      chain.unshift(current.config);\n    }\n    current = Object.getPrototypeOf(current) as BaseConstructor | null;\n  }\n\n  const config = chain.reduce<BaseConfig>(\n    (merged, own) => ({\n      ...merged,\n      ...own,\n      refs: [...new Set([...(merged.refs ?? []), ...(own.refs ?? [])])],\n      options: { ...merged.options, ...own.options },\n      components: { ...merged.components, ...own.components },\n    }),\n    { name: ctor.name },\n  );\n\n  return config;\n});\n\n/**\n * Define one of the four fixed instance properties.\n *\n * `readonly` is a compile-time promise and these four are the instance's\n * identity — the element it is bound to, the id derived from its name, and the\n * two views over its markup. A non-writable property makes the promise the\n * runtime's too: an assignment throws in a module rather than replacing what\n * every other part of the framework reads. The fields are `declare`d, so the\n * class emits no initializer to overwrite what this defines.\n */\nfunction defineFixed<T extends Base, K extends '$el' | '$id' | '$options' | '$refs'>(\n  instance: T,\n  property: K,\n  value: T[K],\n): void {\n  Object.defineProperty(instance, property, { value, enumerable: true });\n}\n\n/** Reserved handler prefixes for global targets. They take precedence over child and ref names. */\nconst GLOBAL_PREFIXES = ['Window', 'Document'] as const;\n\n/** Resolve a global handler prefix only when an event name follows it. */\nfunction resolveGlobal(rest: string): { target: Window | Document; type: string } | null {\n  for (const prefix of GLOBAL_PREFIXES) {\n    if (rest.length > prefix.length && rest.startsWith(prefix)) {\n      return {\n        target: prefix === 'Window' ? window : document,\n        type: kebabCase(rest.slice(prefix.length)),\n      };\n    }\n  }\n  return null;\n}\n\n/** Return inherited prototype handler names. Class fields are not included. */\nfunction handlerMethodNames(ctor: BaseConstructor): string[] {\n  const names = new Set<string>();\n  let proto: object | null = ctor.prototype;\n  while (proto && proto !== Base.prototype) {\n    for (const name of Object.getOwnPropertyNames(proto)) {\n      if (REGEX_HANDLER.test(name)) {\n        names.add(name);\n      }\n    }\n    proto = Object.getPrototypeOf(proto) as object | null;\n  }\n  return [...names];\n}\n\n/**\n * One resolved magic handler: which listener to create, and where, for an\n * `on<…>` method name — everything but the instance to call it on.\n */\ntype HandlerPlanEntry = { method: string; type: string } & (\n  | { kind: 'global'; target: Window | Document }\n  /** The declared child name. */\n  | { kind: 'child'; name: string }\n  /** The **declared** ref, `[]` included: it is what `queryRefs()` takes. */\n  | { kind: 'ref'; name: string }\n  | { kind: 'own' }\n);\n\ninterface HandlerPlan {\n  /** Declared child names, longest first. */\n  childNames: string[];\n  /** Declared refs, longest derived name first. */\n  refs: Array<{ name: string; definition: string }>;\n  componentName: string;\n  entries: HandlerPlanEntry[];\n}\n\n/**\n * Resolve and cache each class's handler plan.\n *\n * Keep the `@__PURE__` annotation so bundlers can remove unused handler planning.\n */\nconst handlerPlan = /* @__PURE__ */ memo((ctor: BaseConstructor): HandlerPlan => {\n  const config = resolveConfig(ctor);\n  // Longest name first, so `onSliderDragStart` resolves to the declared\n  // `SliderDrag` child, not to `Slider`.\n  const byLength = (a: string, b: string) => b.length - a.length;\n  const childNames = Object.keys(config.components ?? {}).sort(byLength);\n  // Keep both declared and derived ref names; list refs differ by `[]`.\n  const refs = (config.refs ?? [])\n    .map((definition) => ({ name: refPropertyName(definition), definition }))\n    .sort((a, b) => byLength(a.name, b.name));\n\n  // The global prefixes are matched first because they are reserved; children\n  // are matched before refs, so a name declared as both resolves to the\n  // component.\n  const entries = handlerMethodNames(ctor).map((method): HandlerPlanEntry => {\n    const rest = method.slice(2);\n    const global = resolveGlobal(rest);\n    if (global) {\n      return { kind: 'global', method, type: global.type, target: global.target };\n    }\n    const startsWith = (name: string) =>\n      rest.startsWith(capitalize(name)) && rest.length > name.length;\n    const childName = childNames.find(startsWith);\n    if (childName) {\n      return {\n        kind: 'child',\n        method,\n        type: kebabCase(rest.slice(childName.length)),\n        name: childName,\n      };\n    }\n    const ref = refs.find(({ name }) => startsWith(name));\n    if (ref) {\n      return {\n        kind: 'ref',\n        method,\n        type: kebabCase(rest.slice(ref.name.length)),\n        name: ref.definition,\n      };\n    }\n    return { kind: 'own', method, type: kebabCase(rest) };\n  });\n\n  return { childNames, refs, componentName: config.name, entries };\n});\n\n/** One handler waiting on a descendant, resolved at event time. */\ntype DelegatedEntry =\n  | { kind: 'child'; name: string; invoke: (payload: DelegatedEvent) => void }\n  // `name` here is the **declared** ref, suffix included: it is compared\n  // against the `data-ref` attribute and handed to `queryRefs()`.\n  | { kind: 'ref'; name: string; invoke: (payload: RefEvent) => void };\n\ntype DelegatedEntries = Map<string, DelegatedEntry[]>;\n\nfunction addDelegated(delegated: DelegatedEntries, type: string, entry: DelegatedEntry): void {\n  if (!delegated.has(type)) {\n    delegated.set(type, []);\n  }\n  delegated.get(type)?.push(entry);\n}\n\n/**\n * `mounted()` may return one cleanup, several, nothing — or a promise of\n * those. The shape nests, so a subclass composes with what it extends\n * without unpacking it: `return [super.mounted(), () => { … }]`.\n */\nexport type MountedReturn = void | (() => void) | MountedReturn[] | Promise<MountedReturn>;\n\nfunction reportLifecycleFailure(instance: Base, message: string, error: unknown): void {\n  reportDiagnostic('component.lifecycle-failed', message, error, {\n    component: instance.$config.name,\n    target: instance.$el,\n  });\n}\n\n/** What `#guard()` returns instead of a value when the guarded call threw. */\nconst GUARD_FAILED = Symbol('guard-failed');\n\n/**\n * The class every component extends.\n * @link https://js-toolkit-v4.studiometa.dev/api/\n */\nexport class Base<T extends BaseProps = BaseProps> {\n  /** A class-owned brand inherited by subclasses and shared by bundled copies. */\n  static readonly [BASE_BRAND] = true;\n\n  static config: BaseConfig = { name: 'Base' };\n\n  /**\n   * Phantom carrier for the props type: type-only, never assigned, so\n   * another component can read this one's declared surface.\n   */\n  declare readonly __props?: T;\n\n  /**\n   * Unique, stable instance id (`<ComponentName>-<sequence>`).\n   *\n   * Generated once during construction from the resolved component name. It\n   * stays unchanged across unmount and remount cycles, so a component can use\n   * it for persistent ARIA relationships without changing the DOM id itself.\n   */\n  declare readonly $id: string;\n\n  declare readonly $el: El<T>;\n\n  /**\n   * Live view over the component's `data-ref` elements: every access\n   * re-reads the DOM, so replaced markup is picked up with nothing to\n   * refresh.\n   */\n  declare readonly $refs: Refs<T>;\n\n  /**\n   * Read-only view over the component's `data-option-*` attributes: an option\n   * is an input, never a store.\n   *\n   * `buildOptions()` defines every property with a getter and no setter, so\n   * the value is derived from the DOM and the viewport on each access and\n   * nothing is ever written in. Assigning to one throws a `TypeError`, since\n   * a module is strict code; the type says the same thing ahead of the throw.\n   *\n   * A component which must change a value it read keeps a private field\n   * seeded from the option. One which means the DOM to change writes the\n   * attribute, which is the same statement the markup makes.\n   *\n   * The constructor is the one place it is set.\n   */\n  declare readonly $options: Readonly<Options<T>>;\n\n  #isMounted = false;\n\n  /** Per-mount-cycle listeners, removed on every `$unmount()`. */\n  #listeners: Array<[string, EventListener, EventTarget, boolean]> = [];\n\n  /** Per-mount-cycle cleanups (service unsubscriptions, `mounted()` return values). */\n  #unmountCallbacks: Array<() => void> = [];\n\n  /**\n   * The reader behind each declared option, built with the `$options` view.\n   *\n   * A side table rather than a cache: it holds no computed value, it holds the\n   * other half of what `buildOptions()` produced, so it lives with the\n   * instance like every other piece of its state.\n   */\n  #optionReaders: Map<string, OptionReader>;\n\n  /** Cleanup returned by each active `option<Name>Changed()` effect. */\n  #optionCleanups = new Map<string, () => void>();\n\n  /** Increments on mount so a reentrant effect cannot attach to a later cycle. */\n  #mountCycle = 0;\n\n  /**\n   * The `$watchChildren()` watchers this instance owns. The shared unmount\n   * listener only holds weak references to them, so this field is what keeps\n   * them alive — and what lets them die with their owner.\n   */\n  #childrenWatchers: ChildrenWatcher[] = [];\n\n  #tasks = new Set<ScheduledTask<unknown>>();\n\n  /** Filled by the `@on` decorator's initializers, if any are used. */\n  declare [HANDLER_REGISTRATIONS]?: HandlerRegistration[];\n\n  get $config(): BaseConfig {\n    return resolveConfig(this.constructor as BaseConstructor);\n  }\n\n  get $isMounted(): boolean {\n    return this.#isMounted;\n  }\n\n  constructor(el: HTMLElement) {\n    const { name } = this.$config;\n    componentId += 1;\n    // `$el` has to be readable before the views are built: `buildOptions()`\n    // and `buildRefs()` both read it off the instance.\n    defineFixed(this, '$el', el);\n    defineFixed(this, '$id', `${name}-${componentId - 1}`);\n    el[INSTANCES] ??= new Map();\n    el[INSTANCES].set(name, this);\n    // Both views resolve on access, so they are built once and stay correct\n    // for the instance's whole life.\n    const built = buildOptions(this);\n    // The view is a bag of getters, which no structural type describes once\n    // `Readonly<>` is mapped over a props parameter — core builds it, and the\n    // readonly says what every consumer may do with it.\n    defineFixed(this, '$options', built.options as Readonly<Options<T>>);\n    this.#optionReaders = built.readers;\n    defineFixed(this, '$refs', buildRefs(this));\n  }\n\n  /**\n   * Lifecycle hook, meant to be overridden. May return a cleanup function\n   * (or an array of them) that runs on the next `$unmount()` — sync or\n   * async:\n   *\n   *     async mounted() {\n   *       const signal = await this.$inject(SomeContext);\n   *       return signal.subscribe((value) => { … });\n   *     }\n   *\n   * A component extending a mixin returns what it extends along with its\n   * own, in any nesting:\n   *\n   *     mounted() {\n   *       return [super.mounted(), () => { … }];\n   *     }\n   */\n  mounted(): MountedReturn {}\n\n  /**\n   * Lifecycle hook, meant to be overridden. Runs at the end of `$unmount()`,\n   * after the `mounted()` cleanups, and returns nothing: a teardown that\n   * belongs to a specific piece of setup is better written as the cleanup\n   * `mounted()` returns, next to the setup it undoes.\n   */\n  unmounted(): void {}\n\n  /**\n   * Mount the instance. `$unmount()` is its inverse and the same instance can\n   * mount again — this is what happens when an element is moved or\n   * re-inserted in the DOM.\n   */\n  $mount(): this {\n    if (this.#isMounted) {\n      return this;\n    }\n    this.#bindHandlers();\n    this.#isMounted = true;\n    this.#mountCycle += 1;\n    const cycle = this.#mountCycle;\n    this.#initializeOptionEffects(cycle);\n    if (!this.#isActiveMountCycle(cycle)) {\n      return this;\n    }\n    this.#initializeResponsiveOptions(cycle);\n    if (!this.#isActiveMountCycle(cycle)) {\n      return this;\n    }\n    this.#guard('`mounted()` failed.', () => this.#collectCleanup(this.mounted(), cycle));\n    if (!this.#isActiveMountCycle(cycle)) {\n      return this;\n    }\n    // Announce the mounted instance to ancestors.\n    const detail: LifecycleEventDetail = { instance: this };\n    this.$el.dispatchEvent(\n      new CustomEvent(EVENTS.component.mounted, { bubbles: true, cancelable: false, detail }),\n    );\n    return this;\n  }\n\n  /**\n   * End the mount cycle. Removes the per-cycle listeners, leaves the\n   * services, cancels the scheduler tasks the cycle left pending, runs the\n   * `mounted()` cleanups and calls the `unmounted()` hook. The instance stays\n   * on its element and `$mount()` starts a new cycle.\n   */\n  $unmount(): this {\n    if (!this.#isMounted) {\n      return this;\n    }\n    this.#isMounted = false;\n    for (const [type, listener, target, capture] of this.#listeners) {\n      target.removeEventListener(type, listener, capture);\n    }\n    this.#listeners = [];\n    // Cancel cycle work before cleanup. Tasks scheduled by cleanup must remain active.\n    const pending = this.#tasks;\n    this.#tasks = new Set();\n    for (const task of pending) {\n      task.cancel();\n    }\n    const callbacks = this.#unmountCallbacks;\n    this.#unmountCallbacks = [];\n    for (const callback of callbacks) {\n      this.#guard('A mount cleanup failed.', callback);\n    }\n    this.#clearOptionEffects();\n    this.#guard('`unmounted()` failed.', () => this.unmounted());\n    // The element may already be detached, so a bubbling event would reach\n    // nobody: announce from the document instead.\n    const detail: LifecycleEventDetail = { instance: this };\n    document.dispatchEvent(\n      new CustomEvent(EVENTS.component.unmounted, { cancelable: false, detail }),\n    );\n    return this;\n  }\n\n  /**\n   * Dispatch a bubbling, cancelable event with the payload as `detail`.\n   *\n   * @returns The dispatched event. Check `defaultPrevented` for cancellation.\n   */\n  $emit<K extends EmitName<T>>(event: K, ...payload: EmitArgs<T, K>): CustomEvent<EmitDetail<T, K>>;\n  $emit(event: string, payload?: object): CustomEvent<unknown> {\n    checkPayload(this, event, payload);\n    return this.#dispatch(event, payload);\n  }\n\n  /** Build and dispatch a component event. */\n  #dispatch(event: string, detail: unknown): CustomEvent<unknown> {\n    const dispatched = new CustomEvent(event, { bubbles: true, cancelable: true, detail });\n    this.$el.dispatchEvent(dispatched);\n    return dispatched;\n  }\n\n  $on(type: string, listener: EventListener, options?: AddEventListenerOptions): () => void {\n    this.$el.addEventListener(type, listener, options);\n    return () => this.$el.removeEventListener(type, listener, options);\n  }\n\n  $off(type: string, listener: EventListener, options?: AddEventListenerOptions): void {\n    this.$el.removeEventListener(type, listener, options);\n  }\n\n  /**\n   * Mounted descendant instances by component name, in DOM order.\n   */\n  $query<T extends Base = Base>(name: string): T[] {\n    return [...this.$el.querySelectorAll(selectorFor(name))]\n      .map((el) => el[INSTANCES]?.get(name))\n      .filter((instance): instance is T => Boolean(instance?.$isMounted));\n  }\n\n  /**\n   * Nearest mounted ancestor instance by component name.\n   */\n  $closest<T extends Base = Base>(name: string): T | null {\n    let el = this.$el.parentElement;\n    while (el) {\n      const instance = el[INSTANCES]?.get(name);\n      if (instance?.$isMounted) {\n        return instance as T;\n      }\n      el = el.parentElement;\n    }\n    return null;\n  }\n\n  /**\n   * Return a live, DOM-ordered collection of mounted descendants.\n   *\n   * A string matches `config.name`. A class also matches subclasses.\n   */\n  $watchChildren<T extends Base = Base>(\n    name: string,\n    callbacks?: WatchChildrenCallbacks<T>,\n  ): ChildrenCollection<T>;\n  $watchChildren<T extends BaseConstructor>(\n    ComponentClass: T,\n    callbacks?: WatchChildrenCallbacks<InstanceType<T>>,\n  ): ChildrenCollection<InstanceType<T>>;\n  $watchChildren<T extends Base = Base>(\n    target: string | BaseConstructor,\n    callbacks: WatchChildrenCallbacks<T> = {},\n  ): ChildrenCollection<T> {\n    const instances = new Set<T>();\n    const matches = (instance: Base): instance is T =>\n      typeof target === 'string' ? instance.$config.name === target : instance instanceof target;\n    const add = (instance: T) => {\n      if ((instance as Base) !== this && !instances.has(instance)) {\n        instances.add(instance);\n        callbacks.added?.(instance);\n      }\n    };\n    const remove = (instance: T) => {\n      if (instances.delete(instance)) {\n        callbacks.removed?.(instance);\n      }\n    };\n\n    // Defer callbacks until construction completes; listeners attach before the sweep.\n    queueMicrotask(() => {\n      if (typeof target === 'string') {\n        for (const instance of this.$query<T>(target)) {\n          add(instance);\n        }\n        return;\n      }\n      // Constructor matching must inspect instances because subclasses can use other tokens.\n      for (const el of this.$el.querySelectorAll('*')) {\n        for (const instance of el[INSTANCES]?.values() ?? []) {\n          if (instance.$isMounted && matches(instance)) {\n            add(instance);\n          }\n        }\n      }\n    });\n\n    const onMounted = (event: Event) => {\n      const { instance } = (event as CustomEvent<LifecycleEventDetail>).detail;\n      if (instance.$isMounted && matches(instance)) {\n        add(instance);\n      }\n    };\n    // Unmounted instances announce from `document`, because their elements can\n    // be detached. The instance keeps its own watchers, and the shared listener\n    // reaches them weakly, so watching children adds no reference from the\n    // document to this component.\n    const watcher: ChildrenWatcher = (instance) => {\n      if (matches(instance)) {\n        remove(instance);\n      }\n    };\n    this.#childrenWatchers.push(watcher);\n    registerChildrenWatcher(watcher);\n    // Instance-lifetime, so neither registration is released: the collection\n    // survives unmount and mount cycles, and both ends die with the instance —\n    // the mount listener with the element it sits on, the watcher with the\n    // field above.\n    this.$el.addEventListener(EVENTS.component.mounted, onMounted);\n\n    return {\n      get size() {\n        return instances.size;\n      },\n      get items() {\n        return [...instances].sort((a, b) => compareDocumentOrder(a.$el, b.$el));\n      },\n      [Symbol.iterator]() {\n        return this.items[Symbol.iterator]();\n      },\n    };\n  }\n\n  /**\n   * Provide a value verbatim to the subtree for as long as the element lives.\n   * The nearest provider wins.\n   *\n   * The provider sits on the element, not on the mount cycle, so it answers\n   * through every unmount and mount. Nothing releases it early: a component\n   * whose declaration is withdrawn keeps providing until its element goes.\n   */\n  $provide<V>(key: ContextKey<V>, value: V): V {\n    provideContext(this.$el, key, value);\n    return value;\n  }\n\n  /**\n   * Resolve the nearest value now or when a provider appears. The request remains pending without a provider and is canceled on unmount.\n   */\n  $inject<V>(key: ContextKey<V>): Promise<V> {\n    const { promise, cancel } = injectContext(this.$el, key);\n    this.#unmountCallbacks.push(cancel);\n    return promise;\n  }\n\n  /** Resolve the nearest value now, or return `undefined` without queuing a request. */\n  $injectSync<V>(key: ContextKey<V>): V | undefined {\n    return injectContextSync(this.$el, key);\n  }\n\n  /**\n   * Apply one mutation batch after declaration reconciliation. Option cleanup runs before the next value and on unmount. Only resolved value changes trigger effects.\n   *\n   * @internal\n   */\n  $optionsChanged(changes: ReadonlyMap<string, string | null>): void {\n    if (!this.#isMounted) {\n      return;\n    }\n    const before = (attributeName: string) =>\n      changes.has(attributeName)\n        ? (changes.get(attributeName) ?? null)\n        : this.$el.getAttribute(attributeName);\n\n    for (const [name, reader] of this.#optionReaders) {\n      // The base attribute is one lookup; any of the scoped spellings may be\n      // the one the cascade was selecting, so a miss asks about every changed\n      // name before giving up.\n      let touched = changes.has(reader.attribute);\n      if (!touched) {\n        for (const attributeName of changes.keys()) {\n          if (reader.owns(attributeName)) {\n            touched = true;\n            break;\n          }\n        }\n      }\n      if (!touched) {\n        continue;\n      }\n      const previousRawValue = reader.rawValueAt(activeBreakpoint(), before);\n      if (isNetChange(reader.rawValue(), previousRawValue)) {\n        this.#runOptionEffect(name, reader, previousRawValue, false);\n      }\n    }\n  }\n\n  /**\n   * Report a warning on the diagnostic channel, as this component.\n   *\n   * The component name and the element are filled in from the instance, which\n   * is the whole reason this exists on `Base` rather than being a bare\n   * function a component imports: those two are what a listener filters and\n   * inspects on, and a component is the one thing that always knows both.\n   *\n   * The code is namespaced — `'figure.load-failed'` — so a listener can select\n   * one component's diagnostics without matching on message text. Core's own\n   * codes are enumerated in `DIAGNOSTICS`; a code outside that set is a\n   * consumer's, and the shape is all that is required of it.\n   *\n   * Canceling the event suppresses the default `console.warn` and nothing\n   * else, so a host application can route these into its own reporter.\n   */\n  $warn(code: ToolkitDiagnosticCode, message: string): void {\n    warn(code, message, { component: this.$config.name, target: this.$el });\n  }\n\n  /**\n   * Report a recovered failure on the diagnostic channel, as this component.\n   *\n   * The counterpart to {@link $warn} for the case where something threw and\n   * the component carried on: the original value is required, because a\n   * reporter that cannot see the cause cannot do anything useful with it.\n   * Canceling suppresses the default error sink.\n   */\n  $error(code: ToolkitDiagnosticCode, message: string, error: unknown): void {\n    reportDiagnostic(code, message, error, {\n      component: this.$config.name,\n      target: this.$el,\n    });\n  }\n\n  /** Schedule a DOM read; canceled automatically when the instance unmounts. */\n  $read<T>(fn: () => T): ScheduledTask<T> {\n    return this.#track(defaultScheduler.read(fn));\n  }\n\n  /** Schedule a DOM write; canceled automatically when the instance unmounts. */\n  $write<T>(fn: () => T): ScheduledTask<T> {\n    return this.#track(defaultScheduler.write(fn));\n  }\n\n  #track<T>(task: ScheduledTask<T>): ScheduledTask<T> {\n    this.#tasks.add(task);\n    const finished = () => this.#tasks.delete(task);\n    void task.promise.then(finished, finished);\n    return task;\n  }\n\n  #isActiveMountCycle(cycle: number): boolean {\n    return this.#isMounted && this.#mountCycle === cycle;\n  }\n\n  /**\n   * Run a hook or a cleanup owned by the component. A throw there must not\n   * abandon the framework bookkeeping which follows it, so it is reported and\n   * swallowed; the sentinel lets the few callers which care tell a failure\n   * from a value the call returned.\n   */\n  #guard<T>(message: string, run: () => T): T | typeof GUARD_FAILED {\n    try {\n      return run();\n    } catch (error) {\n      reportLifecycleFailure(this, message, error);\n      return GUARD_FAILED;\n    }\n  }\n\n  #initializeOptionEffects(cycle: number): void {\n    for (const [name, reader] of this.#optionReaders) {\n      if (!this.#isActiveMountCycle(cycle)) {\n        return;\n      }\n      this.#runOptionEffect(name, reader, null, true);\n    }\n  }\n\n  /** Subscribe to breakpoint changes for this mount cycle only when an option effect exists. */\n  #initializeResponsiveOptions(cycle: number): void {\n    const readers = this.#optionReaders;\n    if (!readers || readers.size === 0) {\n      return;\n    }\n    // Scan attributes once per mount for unknown breakpoint suffixes.\n    checkResponsiveAttributes(\n      this.$el,\n      [...readers.values()].map((reader) => reader.attribute),\n    );\n\n    const announces = [...readers.keys()].some(\n      (name) => optionChangedHandler(this, name) !== undefined,\n    );\n    if (!announces) {\n      return;\n    }\n\n    this.#collectCleanup(\n      watchBreakpoint((previous) => {\n        const fromElement = (attributeName: string) => this.$el.getAttribute(attributeName);\n        for (const [name, reader] of readers) {\n          // The attributes did not move; the viewport did. A crossing is only a\n          // change to the options whose cascade now selects a different one.\n          const previousRawValue = reader.rawValueAt(previous, fromElement);\n          if (isNetChange(reader.rawValue(), previousRawValue)) {\n            this.#runOptionEffect(name, reader, previousRawValue, false);\n          }\n        }\n      }),\n      cycle,\n    );\n  }\n\n  #runOptionEffect(\n    name: string,\n    reader: OptionReader,\n    previousRawValue: string | null,\n    initial: boolean,\n  ): void {\n    const previousCleanup = this.#optionCleanups.get(name);\n    this.#optionCleanups.delete(name);\n    if (previousCleanup) {\n      this.#guard(`Option \"${name}\" cleanup failed.`, previousCleanup);\n    }\n    if (!this.#isMounted) {\n      return;\n    }\n\n    const handler = optionChangedHandler(this, name);\n    if (!handler) {\n      return;\n    }\n\n    const cycle = this.#mountCycle;\n    const cleanup = this.#guard(`\\`${optionChangedMethod(name)}()\\` failed.`, () => {\n      const rawValue = reader.rawValue();\n      const change: OptionChange = {\n        name,\n        value: reader.read(rawValue),\n        previousValue: initial ? undefined : reader.read(previousRawValue),\n        rawValue,\n        previousRawValue,\n        initial,\n      };\n      return handler.call(this, change);\n    });\n    if (cleanup === GUARD_FAILED) {\n      return;\n    }\n    if (typeof cleanup === 'function') {\n      if (this.#isMounted && this.#mountCycle === cycle) {\n        this.#optionCleanups.set(name, cleanup);\n      } else {\n        this.#guard(`Option \"${name}\" cleanup failed.`, cleanup);\n      }\n    }\n  }\n\n  #clearOptionEffects(): void {\n    const cleanups = this.#optionCleanups;\n    this.#optionCleanups = new Map();\n    for (const [name, cleanup] of cleanups) {\n      this.#guard(`Option \"${name}\" cleanup failed.`, cleanup);\n    }\n  }\n\n  /**\n   * Register the cleanup value returned by `mounted()`. Async hooks are\n   * awaited; if their mount cycle ended in the meantime, the cleanup runs\n   * right away instead of leaking into a later cycle.\n   */\n  #collectCleanup(result: MountedReturn, cycle: number): void {\n    if (typeof result === 'function') {\n      if (this.#isActiveMountCycle(cycle)) {\n        this.#unmountCallbacks.push(result);\n      } else {\n        // The originating mount cycle ended while an async result was pending:\n        // run the cleanup right away instead of leaking.\n        this.#guard('A late mount cleanup failed.', result);\n      }\n      return;\n    }\n    if (Array.isArray(result)) {\n      for (const item of result) {\n        this.#collectCleanup(item, cycle);\n      }\n      return;\n    }\n    if (result instanceof Promise) {\n      result\n        .then((resolved) => this.#collectCleanup(resolved, cycle))\n        .catch((error) => {\n          reportLifecycleFailure(this, '`mounted()` failed.', error);\n        });\n    }\n  }\n\n  /** Bind root, delegated child/ref and global handlers for the current mount cycle. Delegated handlers resolve dynamic descendants at event time. */\n  #bindHandlers(): void {\n    // Resolve class-level handler metadata once.\n    const plan = handlerPlan(this.constructor as BaseConstructor);\n    const delegated: DelegatedEntries = new Map();\n    // Decorated handlers win: both passes name a method the same way, so the\n    // names bound here are what tells the second pass to skip them.\n    const decorated = this.#bindDecoratedHandlers(plan, delegated);\n    this.#bindPlannedHandlers(plan, delegated, decorated);\n    this.#installDelegatedListeners(plan.componentName, delegated);\n  }\n\n  #bindOwn(type: string, invoke: (event: Event) => void): void {\n    const listener: EventListener = (event) => invoke(event);\n    this.$el.addEventListener(type, listener);\n    this.#listeners.push([type, listener, this.$el, false]);\n  }\n\n  /** Bind a global handler in bubble phase for the current mount cycle. Capture is only for delegated non-bubbling events. */\n  #bindGlobal(\n    target: Window | Document,\n    type: string,\n    invoke: (payload: GlobalEvent) => void,\n  ): void {\n    const listener: EventListener = (event) => invoke({ event, target });\n    target.addEventListener(type, listener);\n    this.#listeners.push([type, listener, target, false]);\n  }\n\n  /**\n   * Bind the decorated handlers, which already carry resolved targets and\n   * event types, and return the method names they bound.\n   */\n  #bindDecoratedHandlers(plan: HandlerPlan, delegated: DelegatedEntries): Set<string | symbol> {\n    const { childNames, refs } = plan;\n    const registrations = this[HANDLER_REGISTRATIONS] ?? [];\n    const decorated: Set<string | symbol> = new Set(registrations.map(({ method }) => method));\n    for (const { target, child, type, handler } of registrations) {\n      if (target) {\n        this.#bindGlobal(target, type, (payload) => handler.call(this, payload));\n      } else if (child) {\n        // Decorators use the declared ref name, including `[]`.\n        const declaredChild = childNames.includes(child);\n        const ref = declaredChild ? undefined : refs.find(({ definition }) => definition === child);\n        if (!declaredChild && !ref) {\n          warnRefSuffixMismatch(this, child, refs);\n        }\n        addDelegated(delegated, type, {\n          kind: ref ? 'ref' : 'child',\n          name: child,\n          invoke: (payload: DelegatedEvent | RefEvent) => handler.call(this, payload),\n        });\n      } else {\n        this.#bindOwn(type, (event) => handler.call(this, event));\n      }\n    }\n    return decorated;\n  }\n\n  /** Bind the undecorated magic handlers from the cached class plan. */\n  #bindPlannedHandlers(\n    plan: HandlerPlan,\n    delegated: DelegatedEntries,\n    decorated: Set<string | symbol>,\n  ): void {\n    const self = this as unknown as Record<string, (payload: unknown) => void>;\n    for (const entry of plan.entries) {\n      const { method, type } = entry;\n      if (decorated.has(method)) {\n        continue;\n      }\n      // Read through the instance, deliberately: a class field can shadow a\n      // prototype method with something that is not callable, and the plan\n      // lists the name either way.\n      if (typeof self[method] !== 'function') {\n        continue;\n      }\n      if (entry.kind === 'global') {\n        this.#bindGlobal(entry.target, type, (payload) => self[method](payload));\n      } else if (entry.kind === 'own') {\n        this.#bindOwn(type, (event) => self[method](event));\n      } else {\n        addDelegated(delegated, type, {\n          kind: entry.kind,\n          name: entry.name,\n          invoke: (payload: DelegatedEvent | RefEvent) => self[method](payload),\n        });\n      }\n    }\n  }\n\n  /** Install one root listener per delegated event type. */\n  #installDelegatedListeners(componentName: string, delegated: DelegatedEntries): void {\n    for (const [type, entries] of delegated) {\n      const listener: EventListener = (event) => {\n        let el = event.target instanceof Element ? event.target : null;\n        while (el && el !== this.$el) {\n          let invoked = false;\n          for (const entry of entries) {\n            if (this.#invokeDelegated(entry, el, event, componentName)) {\n              invoked = true;\n            }\n          }\n          // Nearest matching target wins; every handler for it fired.\n          if (invoked) {\n            return;\n          }\n          el = el.parentElement;\n        }\n      };\n      // Non-bubbling events never reach the root during the bubble phase,\n      // so they are delegated from the capture phase instead.\n      const capture = CAPTURED_EVENTS.has(type);\n      this.$el.addEventListener(type, listener, capture);\n      this.#listeners.push([type, listener, this.$el, capture]);\n    }\n  }\n\n  /**\n   * Fire one delegated entry when `el` is what it waits on: a mounted child\n   * instance, or an owned ref. Returns whether it fired, which is how the\n   * walk knows it reached the nearest matching element.\n   */\n  #invokeDelegated(\n    entry: DelegatedEntry,\n    el: Element,\n    event: Event,\n    componentName: string,\n  ): boolean {\n    if (entry.kind === 'child') {\n      const child = el[INSTANCES]?.get(entry.name);\n      if (!child?.$isMounted) {\n        return false;\n      }\n      entry.invoke({\n        event,\n        target: child,\n        // The detail verbatim — what a plain listener reads.\n        payload: (event as CustomEvent).detail,\n      });\n      return true;\n    }\n    if (!isRefOf(el, this.$el, componentName, entry.name)) {\n      return false;\n    }\n    entry.invoke({\n      event,\n      target: el,\n      // The index within the ref list as `$refs` sees it, so the two\n      // spellings share one numbering.\n      index: queryRefs(this.$el, componentName, entry.name).indexOf(el),\n    });\n    return true;\n  }\n}\n"],"mappings":"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"}

package/dist/attribute-namespaces.d.ts

@@ -0,0 +1,67 @@
+//#region src/attribute-namespaces.d.ts
+/**
+ * The mechanism half of the attribute grammar: one namespace, watched on one
+ * element, rebound whenever one of its attributes changes.
+ *
+ * `attributes.ts` owns the grammar — what a namespace is, where the colon goes,
+ * and that a qualifier's parts belong to whoever declared the namespace. This
+ * module owns the other half of the split: **core decides when to re-parse and
+ * how the attribute is observed, and the caller decides what the string means.**
+ *
+ * Which mechanism a namespace gets follows from whether its whole set of names
+ * is enumerable, not from whether its qualifier vocabulary is finite. A
+ * declared option's names are `attribute × breakpoint` — finite, so they are
+ * registered with the one document observer and no second observer exists. A
+ * namespace whose names cannot be listed in advance is this module's case:
+ * `data-on:<any DOM event>`, and `data-bind:class.<any class name>`, whose
+ * qualifier head is finite while its tail is not. See DESIGN.md §3.
+ */
+/** One declaration read off an element, as {@link watchAttributeNamespace} reports it. */
+interface AttributeNamespaceDeclaration {
+  /** Everything after the colon: `click.prevent`, `prop.value`, `view.once`. */
+  qualifier: string;
+  /** The attribute's value. Never `null` — an absent attribute releases instead. */
+  value: string;
+  /** The whole attribute name, which is the key the binding is held under. */
+  attribute: string;
+}
+/**
+ * Build whatever one declaration means, and return its release. Returning
+ * nothing says the declaration produced no binding — a malformed value, say —
+ * and leaves nothing to release.
+ */
+type AttributeNamespaceBinder = (declaration: AttributeNamespaceDeclaration) => (() => void) | void;
+interface AttributeNamespaceOptions {
+  /**
+   * The qualifier heads this namespace declares. Given, a head outside the set
+   * warns once and binds nothing; omitted, the vocabulary is open and anything
+   * binds. This is independent of the mechanism: a finite head does not make a
+   * name enumerable, which is why `data-bind` is watched and validated at once.
+   */
+  qualifiers?: readonly string[];
+  /** The component name carried by the warning, when there is one. */
+  component?: string;
+}
+/**
+ * Bind every `<namespace>:<qualifier>` attribute of one element, and keep the
+ * bindings in step with the element.
+ *
+ * The declarations present now are bound on subscription; afterwards each
+ * attribute of the namespace is its own binding, keyed by the name that
+ * produced it, so one `#bind` covers all three shapes a change can take —
+ * **added** attaches with nothing to release, **changed** releases then
+ * attaches, **removed** releases with nothing to attach. This is what a
+ * memoised parse cannot do, and rewriting an attribute in place is not
+ * hypothetical: `swap({ mode: 'morph' })` does it, and so does any
+ * `data-bind:` template around the element.
+ *
+ * @param el        The element whose attributes are read and watched.
+ * @param namespace The namespace, without its colon: `data-on`, `data-track`.
+ * @param bind      Called once per declaration; returns that binding's release.
+ * @param options   An optional finite head vocabulary, and a component name.
+ * @returns An idempotent cleanup releasing every binding and stopping the watch.
+ * @link https://js-toolkit-v4.studiometa.dev/api/dom/watchAttributeNamespace.html
+ */
+declare function watchAttributeNamespace(el: Element, namespace: string, bind: AttributeNamespaceBinder, { qualifiers, component }?: AttributeNamespaceOptions): () => void;
+//#endregion
+export { AttributeNamespaceBinder, AttributeNamespaceDeclaration, AttributeNamespaceOptions, watchAttributeNamespace };

package/dist/attribute-namespaces.js

@@ -0,0 +1,97 @@
+import { namespaceQualifier, qualifierHead } from "./attributes.js";
+import { warnOnce } from "./diagnostics.js";
+import { watchAttributes } from "./dom-mutations.js";
+//#region src/attribute-namespaces.ts
+/**
+* The mechanism half of the attribute grammar: one namespace, watched on one
+* element, rebound whenever one of its attributes changes.
+*
+* `attributes.ts` owns the grammar — what a namespace is, where the colon goes,
+* and that a qualifier's parts belong to whoever declared the namespace. This
+* module owns the other half of the split: **core decides when to re-parse and
+* how the attribute is observed, and the caller decides what the string means.**
+*
+* Which mechanism a namespace gets follows from whether its whole set of names
+* is enumerable, not from whether its qualifier vocabulary is finite. A
+* declared option's names are `attribute × breakpoint` — finite, so they are
+* registered with the one document observer and no second observer exists. A
+* namespace whose names cannot be listed in advance is this module's case:
+* `data-on:<any DOM event>`, and `data-bind:class.<any class name>`, whose
+* qualifier head is finite while its tail is not. See DESIGN.md §3.
+*/
+/**
+* Bind every `<namespace>:<qualifier>` attribute of one element, and keep the
+* bindings in step with the element.
+*
+* The declarations present now are bound on subscription; afterwards each
+* attribute of the namespace is its own binding, keyed by the name that
+* produced it, so one `#bind` covers all three shapes a change can take —
+* **added** attaches with nothing to release, **changed** releases then
+* attaches, **removed** releases with nothing to attach. This is what a
+* memoised parse cannot do, and rewriting an attribute in place is not
+* hypothetical: `swap({ mode: 'morph' })` does it, and so does any
+* `data-bind:` template around the element.
+*
+* @param el        The element whose attributes are read and watched.
+* @param namespace The namespace, without its colon: `data-on`, `data-track`.
+* @param bind      Called once per declaration; returns that binding's release.
+* @param options   An optional finite head vocabulary, and a component name.
+* @returns An idempotent cleanup releasing every binding and stopping the watch.
+* @link https://js-toolkit-v4.studiometa.dev/api/dom/watchAttributeNamespace.html
+*/
+function watchAttributeNamespace(el, namespace, bind, { qualifiers, component } = {}) {
+	/** Live bindings by the attribute that produced them, each holding its release. */
+	const bindings = /* @__PURE__ */ new Map();
+	const rebind = (attribute, value) => {
+		bindings.get(attribute)?.();
+		const qualifier = namespaceQualifier(namespace, attribute);
+		const release = value === null || qualifier === null || !isWellFormed(el, attribute, qualifier, component) || !isDeclared(el, namespace, attribute, qualifier, qualifiers, component) ? void 0 : bind({
+			qualifier,
+			value,
+			attribute
+		});
+		if (release) bindings.set(attribute, release);
+		else bindings.delete(attribute);
+	};
+	for (const { name, value } of Array.from(el.attributes)) rebind(name, value);
+	const stopWatchingAttributes = watchAttributes(el, ({ name, value }) => {
+		if (namespaceQualifier(namespace, name) !== null) rebind(name, value);
+	});
+	return () => {
+		stopWatchingAttributes();
+		for (const release of bindings.values()) release();
+		bindings.clear();
+	};
+}
+/**
+* Whether a qualifier holds the grammar's one colon and no more, warning once
+* if not. `namespaceQualifier()` returns everything after the first colon
+* unexamined, so `data-on:click:s` reaches here as the qualifier `click:s` —
+* a second declaration's separator leaking into the first — and an open
+* namespace with no declared vocabulary would otherwise bind it as though
+* `click:s` were an event name instead of the ill-formed attribute J1 settled
+* it to be.
+*/
+function isWellFormed(el, attribute, qualifier, component) {
+	if (!qualifier.includes(":")) return true;
+	warnOnce(el, attribute, "attribute.unknown-qualifier", `\`${attribute}\` declares nothing: a qualifier holds one colon at most, and this one holds a second.`, {
+		component,
+		target: el
+	});
+	return false;
+}
+/** Whether a qualifier names a member of the vocabulary, warning once if not. */
+function isDeclared(el, namespace, attribute, qualifier, qualifiers, component) {
+	if (qualifiers === void 0) return true;
+	const head = qualifierHead(qualifier);
+	if (qualifiers.includes(head)) return true;
+	warnOnce(el, attribute, "attribute.unknown-qualifier", `\`${attribute}\` declares nothing: \`${head}\` names no \`${namespace}\` binding — known names: ${qualifiers.join(", ")}.`, {
+		component,
+		target: el
+	});
+	return false;
+}
+//#endregion
+export { watchAttributeNamespace };
+
+//# sourceMappingURL=attribute-namespaces.js.map

package/dist/attribute-namespaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-namespaces.js","names":[],"sources":["../src/attribute-namespaces.ts"],"sourcesContent":["/**\n * The mechanism half of the attribute grammar: one namespace, watched on one\n * element, rebound whenever one of its attributes changes.\n *\n * `attributes.ts` owns the grammar — what a namespace is, where the colon goes,\n * and that a qualifier's parts belong to whoever declared the namespace. This\n * module owns the other half of the split: **core decides when to re-parse and\n * how the attribute is observed, and the caller decides what the string means.**\n *\n * Which mechanism a namespace gets follows from whether its whole set of names\n * is enumerable, not from whether its qualifier vocabulary is finite. A\n * declared option's names are `attribute × breakpoint` — finite, so they are\n * registered with the one document observer and no second observer exists. A\n * namespace whose names cannot be listed in advance is this module's case:\n * `data-on:<any DOM event>`, and `data-bind:class.<any class name>`, whose\n * qualifier head is finite while its tail is not. See DESIGN.md §3.\n */\n\nimport { namespaceQualifier, qualifierHead, QUALIFIER_SEPARATOR } from './attributes.js';\nimport { warnOnce } from './diagnostics.js';\nimport { watchAttributes } from './dom-mutations.js';\n\n/** One declaration read off an element, as {@link watchAttributeNamespace} reports it. */\nexport interface AttributeNamespaceDeclaration {\n  /** Everything after the colon: `click.prevent`, `prop.value`, `view.once`. */\n  qualifier: string;\n  /** The attribute's value. Never `null` — an absent attribute releases instead. */\n  value: string;\n  /** The whole attribute name, which is the key the binding is held under. */\n  attribute: string;\n}\n\n/**\n * Build whatever one declaration means, and return its release. Returning\n * nothing says the declaration produced no binding — a malformed value, say —\n * and leaves nothing to release.\n */\nexport type AttributeNamespaceBinder = (\n  declaration: AttributeNamespaceDeclaration,\n) => (() => void) | void;\n\nexport interface AttributeNamespaceOptions {\n  /**\n   * The qualifier heads this namespace declares. Given, a head outside the set\n   * warns once and binds nothing; omitted, the vocabulary is open and anything\n   * binds. This is independent of the mechanism: a finite head does not make a\n   * name enumerable, which is why `data-bind` is watched and validated at once.\n   */\n  qualifiers?: readonly string[];\n  /** The component name carried by the warning, when there is one. */\n  component?: string;\n}\n\n/**\n * Bind every `<namespace>:<qualifier>` attribute of one element, and keep the\n * bindings in step with the element.\n *\n * The declarations present now are bound on subscription; afterwards each\n * attribute of the namespace is its own binding, keyed by the name that\n * produced it, so one `#bind` covers all three shapes a change can take —\n * **added** attaches with nothing to release, **changed** releases then\n * attaches, **removed** releases with nothing to attach. This is what a\n * memoised parse cannot do, and rewriting an attribute in place is not\n * hypothetical: `swap({ mode: 'morph' })` does it, and so does any\n * `data-bind:` template around the element.\n *\n * @param el        The element whose attributes are read and watched.\n * @param namespace The namespace, without its colon: `data-on`, `data-track`.\n * @param bind      Called once per declaration; returns that binding's release.\n * @param options   An optional finite head vocabulary, and a component name.\n * @returns An idempotent cleanup releasing every binding and stopping the watch.\n * @link https://js-toolkit-v4.studiometa.dev/api/dom/watchAttributeNamespace.html\n */\nexport function watchAttributeNamespace(\n  el: Element,\n  namespace: string,\n  bind: AttributeNamespaceBinder,\n  { qualifiers, component }: AttributeNamespaceOptions = {},\n): () => void {\n  /** Live bindings by the attribute that produced them, each holding its release. */\n  const bindings = new Map<string, () => void>();\n\n  const rebind = (attribute: string, value: string | null): void => {\n    // Release first, whatever comes next: a rewritten attribute must not leave\n    // its previous binding attached, which is the whole point of watching.\n    bindings.get(attribute)?.();\n    const qualifier = namespaceQualifier(namespace, attribute);\n    const release =\n      value === null ||\n      qualifier === null ||\n      !isWellFormed(el, attribute, qualifier, component) ||\n      !isDeclared(el, namespace, attribute, qualifier, qualifiers, component)\n        ? undefined\n        : bind({ qualifier, value, attribute });\n\n    if (release) {\n      // `set` on a key already there keeps its position, so the order the\n      // element declares its bindings in survives a rewrite.\n      bindings.set(attribute, release);\n    } else {\n      bindings.delete(attribute);\n    }\n  };\n\n  for (const { name, value } of Array.from(el.attributes)) {\n    rebind(name, value);\n  }\n\n  // The watcher covers every attribute of the element, framework names\n  // included, so the namespace is what narrows it — and a removal keeps the\n  // name it was declared under, so one test covers all three shapes.\n  const stopWatchingAttributes = watchAttributes(el, ({ name, value }) => {\n    if (namespaceQualifier(namespace, name) !== null) {\n      rebind(name, value);\n    }\n  });\n\n  return () => {\n    stopWatchingAttributes();\n    for (const release of bindings.values()) {\n      release();\n    }\n    bindings.clear();\n  };\n}\n\n/**\n * Whether a qualifier holds the grammar's one colon and no more, warning once\n * if not. `namespaceQualifier()` returns everything after the first colon\n * unexamined, so `data-on:click:s` reaches here as the qualifier `click:s` —\n * a second declaration's separator leaking into the first — and an open\n * namespace with no declared vocabulary would otherwise bind it as though\n * `click:s` were an event name instead of the ill-formed attribute J1 settled\n * it to be.\n */\nfunction isWellFormed(\n  el: Element,\n  attribute: string,\n  qualifier: string,\n  component: string | undefined,\n): boolean {\n  if (!qualifier.includes(QUALIFIER_SEPARATOR)) {\n    return true;\n  }\n  warnOnce(\n    el,\n    attribute,\n    'attribute.unknown-qualifier',\n    `\\`${attribute}\\` declares nothing: a qualifier holds one colon at most, and this one holds a second.`,\n    { component, target: el },\n  );\n  return false;\n}\n\n/** Whether a qualifier names a member of the vocabulary, warning once if not. */\nfunction isDeclared(\n  el: Element,\n  namespace: string,\n  attribute: string,\n  qualifier: string,\n  qualifiers: readonly string[] | undefined,\n  component: string | undefined,\n): boolean {\n  if (qualifiers === undefined) {\n    return true;\n  }\n  const head = qualifierHead(qualifier);\n  if (qualifiers.includes(head)) {\n    return true;\n  }\n  warnOnce(\n    el,\n    attribute,\n    'attribute.unknown-qualifier',\n    `\\`${attribute}\\` declares nothing: \\`${head}\\` names no \\`${namespace}\\` binding — known names: ${qualifiers.join(', ')}.`,\n    { component, target: el },\n  );\n  return false;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,wBACd,IACA,WACA,MACA,EAAE,YAAY,cAAyC,CAAC,GAC5C;;CAEZ,MAAM,2BAAW,IAAI,IAAwB;CAE7C,MAAM,UAAU,WAAmB,UAA+B;EAGhE,SAAS,IAAI,SAAS,CAAC,GAAG;EAC1B,MAAM,YAAY,mBAAmB,WAAW,SAAS;EACzD,MAAM,UACJ,UAAU,QACV,cAAc,QACd,CAAC,aAAa,IAAI,WAAW,WAAW,SAAS,KACjD,CAAC,WAAW,IAAI,WAAW,WAAW,WAAW,YAAY,SAAS,IAClE,KAAA,IACA,KAAK;GAAE;GAAW;GAAO;EAAU,CAAC;EAE1C,IAAI,SAGF,SAAS,IAAI,WAAW,OAAO;OAE/B,SAAS,OAAO,SAAS;CAE7B;CAEA,KAAK,MAAM,EAAE,MAAM,WAAW,MAAM,KAAK,GAAG,UAAU,GACpD,OAAO,MAAM,KAAK;CAMpB,MAAM,yBAAyB,gBAAgB,KAAK,EAAE,MAAM,YAAY;EACtE,IAAI,mBAAmB,WAAW,IAAI,MAAM,MAC1C,OAAO,MAAM,KAAK;CAEtB,CAAC;CAED,aAAa;EACX,uBAAuB;EACvB,KAAK,MAAM,WAAW,SAAS,OAAO,GACpC,QAAQ;EAEV,SAAS,MAAM;CACjB;AACF;;;;;;;;;;AAWA,SAAS,aACP,IACA,WACA,WACA,WACS;CACT,IAAI,CAAC,UAAU,SAAA,GAA4B,GACzC,OAAO;CAET,SACE,IACA,WACA,+BACA,KAAK,UAAU,yFACf;EAAE;EAAW,QAAQ;CAAG,CAC1B;CACA,OAAO;AACT;;AAGA,SAAS,WACP,IACA,WACA,WACA,WACA,YACA,WACS;CACT,IAAI,eAAe,KAAA,GACjB,OAAO;CAET,MAAM,OAAO,cAAc,SAAS;CACpC,IAAI,WAAW,SAAS,IAAI,GAC1B,OAAO;CAET,SACE,IACA,WACA,+BACA,KAAK,UAAU,yBAAyB,KAAK,gBAAgB,UAAU,4BAA4B,WAAW,KAAK,IAAI,EAAE,IACzH;EAAE;EAAW,QAAQ;CAAG,CAC1B;CACA,OAAO;AACT"}

package/dist/attributes.d.ts

@@ -0,0 +1,137 @@
+//#region src/attributes.d.ts
+/**
+ * How the framework spells its own attributes, and how it reads a batch of
+ * writes to them.
+ *
+ * One shape covers every attribute the framework reads:
+ *
+ * ```
+ * data-<namespace>[:<qualifier>[.<part>…]]
+ * ```
+ *
+ * A namespace is a whole name, and it is one of two kinds. A **fixed** one is
+ * written here or by whoever owns it — `data-component`, `data-mount`,
+ * `data-ref`, and in ui `data-on`, `data-track`, `data-bind`. A **generated**
+ * one comes from a declaration: every declared option owns the namespace
+ * {@link optionAttributeFor} builds for it, so `columns` owns
+ * `data-option-columns`. The kind decides the mechanism — a generated
+ * namespace's whole set of names is enumerable, so it is registered with the
+ * one observer, while a fixed namespace with open qualifiers can only be
+ * watched per element. See DESIGN.md §3.
+ *
+ * Both kinds take exactly one {@link QUALIFIER_SEPARATOR}, and neither reads
+ * past it: a qualifier's parts belong to whoever declared the namespace.
+ *
+ * This module is deliberately a **leaf**: it imports nothing from core. The
+ * mutation engine, the registry and `Base` all need the same names, and the
+ * modules which used to own them sit downstream of the engine — the engine
+ * carried string literals rather than close the cycle
+ * `dom-mutations → component-declarations → responsive-options → dom-mutations`.
+ * Moving the names down instead of importing them sideways breaks that cycle
+ * without the copies. Anything which needs the DOM, a breakpoint or the
+ * observer belongs upstream of here, not in this file.
+ */
+/** Declares one or more component names, as whitespace-separated tokens. */
+declare const COMPONENT_ATTRIBUTE = "data-component";
+/**
+ * Overrides the mount strategy of the element's declared components.
+ * @link https://js-toolkit-v4.studiometa.dev/api/html/data-mount.html
+ */
+declare const MOUNT_ATTRIBUTE = "data-mount";
+/** Names an element as a ref of the component which owns it. */
+declare const REF_ATTRIBUTE = "data-ref";
+/**
+ * Every declared option is `data-option-` plus its kebab-cased name.
+ *
+ * This is a **namespace family**, not a namespace: the name after it is the
+ * option's own, so `columns` owns `data-option-columns` — see the grammar
+ * below.
+ */
+declare const OPTION_ATTRIBUTE_PREFIX = "data-option-";
+/**
+ * Introduces one qualifier of the namespace on its left, and there is **at most
+ * one of these in an attribute the framework reads**.
+ *
+ * A colon can never appear in a kebab-cased name, so `data-option-columns:s`
+ * stays unambiguous where `data-option-columns-s` would not.
+ */
+declare const QUALIFIER_SEPARATOR = ":";
+/**
+ * Splits a qualifier into its parts. Core never reads them: what a part means
+ * belongs to whoever owns the namespace — a modifier for `data-on:click.prevent`,
+ * a property name for `data-bind:prop.value`.
+ */
+declare const PART_SEPARATOR = ".";
+/** One qualified spelling: `data-on` + `click.prevent` → `data-on:click.prevent`. */
+declare function namespacedAttribute(namespace: string, qualifier: string): string;
+/**
+ * Whether a name belongs to a namespace, plainly or qualified. `data-component`
+ * and `data-component:s` both answer yes; `data-components` does not.
+ */
+declare function isInNamespace(namespace: string, name: string | null): name is string;
+/**
+ * The qualifier a name carries within a namespace, or `null` when the name is
+ * outside it — the bare namespace included, since a namespace with nothing
+ * after the colon declares nothing.
+ * @link https://js-toolkit-v4.studiometa.dev/guide/concepts/attribute-grammar.html
+ */
+declare function namespaceQualifier(namespace: string, name: string): string | null;
+/**
+ * The part of a qualifier which names the member: `click` of `click.prevent`,
+ * `prop` of `prop.value`. The one piece of a qualifier core reads, and only to
+ * check it against a vocabulary its owner declared.
+ */
+declare function qualifierHead(qualifier: string): string;
+/**
+ * The names every page observes, before a single component declares an option.
+ * The rest of the observer's filter is accumulated at registration time.
+ */
+declare const FRAMEWORK_ATTRIBUTES: readonly ["data-component", "data-mount", "data-ref"];
+/** The attribute holding one option's value at the base of the cascade. */
+declare function optionAttributeFor(name: string): string;
+/**
+ * What a present negation resolves to.
+ *
+ * A boolean reads presence, not value, so the raw string has to carry **which
+ * spelling was there** rather than what it said. A NUL character is that
+ * signal: the HTML parser replaces it with U+FFFD in an attribute value, so no
+ * markup can produce it, and change detection still sees a plain string.
+ */
+declare const NEGATED_RAW = "\0";
+/**
+ * The attribute which turns a boolean option off by being there.
+ *
+ * `data-option-no-view-transition` is another spelling of
+ * `data-option-view-transition="false"`, which is what v3 wrote and what reads
+ * better in markup: a flag is present or it is not.
+ */
+declare function negatedOptionAttributeFor(name: string): string;
+/**
+ * Whether a name is a declared option's, at any breakpoint. The scoped
+ * spellings share the prefix, so one test covers the whole family.
+ */
+declare function isOptionAttribute(attribute: string | null): attribute is string;
+/** Whether a name declares components, plainly or scoped to a breakpoint. */
+declare function isComponentAttribute(attribute: string | null): attribute is string;
+/**
+ * Several writes to one attribute in a batch are **one** change, from the value
+ * it held before the first write to the value the DOM ends the batch with. So
+ * the first previous value wins and every later record is dropped: a morph
+ * rewriting an attribute twice must not look like two changes.
+ *
+ * This is the first half of the coalescing rule; {@link isNetChange} is the
+ * second. Declared options, watched attributes and the responsive cascade all
+ * answer to it, which is why it is stated here once rather than in each of them.
+ */
+declare function rememberPreviousValue(previousValues: Map<string, string | null>, attribute: string, previousValue: string | null): void;
+/**
+ * The second half of the rule: a batch ending where it started changed nothing
+ * and is not reported. The comparison is on raw strings — what is in force now
+ * against what was in force before — so it holds for an attribute read straight
+ * off the element and for a value resolved through the responsive cascade
+ * alike, which is what lets a breakpoint crossing and an attribute rewrite be
+ * the same kind of event.
+ */
+declare function isNetChange(value: string | null, previousValue: string | null): boolean;
+//#endregion
+export { COMPONENT_ATTRIBUTE, FRAMEWORK_ATTRIBUTES, MOUNT_ATTRIBUTE, NEGATED_RAW, OPTION_ATTRIBUTE_PREFIX, PART_SEPARATOR, QUALIFIER_SEPARATOR, REF_ATTRIBUTE, isComponentAttribute, isInNamespace, isNetChange, isOptionAttribute, namespaceQualifier, namespacedAttribute, negatedOptionAttributeFor, optionAttributeFor, qualifierHead, rememberPreviousValue };