@honua/app-platform 0.1.2-beta.0 → 0.1.7-beta.0

package/controls/registry.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Catalog-driven registration APIs spanning both the `controls` and
+ * `web-components` custom-element kits (issue #679; see `./catalog.js` for
+ * the metadata these operate over).
+ *
+ * `controls`-sourced catalog entries are registered synchronously against
+ * this module's local sibling files (`./basemap-switcher.js`, `./legend.js`,
+ * `./layer-list.js`, `./swipe-control.js`) — none of them import `src/core`
+ * or `src/runtime`, so statically importing them here costs nothing beyond
+ * what `@honua/sdk-js/controls` already bundles.
+ *
+ * `web-components`-sourced entries are registered through a **dynamic**
+ * `import("../web-components/elements.js")`, so merely importing this module
+ * (or `@honua/sdk-js/controls`, which re-exports it) never pulls the
+ * `web-components` kit's `src/core` / `src/runtime` dependency into a
+ * `controls`-only bundle. That dependency is only paid the first time a
+ * caller actually registers a `web-components`-sourced tag.
+ *
+ * Critically, `web-components/elements.js` is itself side-effect-free on
+ * import — it defines the element classes, the tag→constructor lookup, and
+ * `defineHonuaWebComponent(tag)` / `defineHonuaWebComponents()`, but does not
+ * call either. (The blanket auto-registration existing
+ * `@honua/sdk-js/web-components` consumers rely on lives in
+ * `web-components/index.js`, which calls `defineHonuaWebComponents()`
+ * explicitly.) Without that separation, this module's dynamic import would
+ * evaluate `elements.js` and its auto-run would claim every tag the kit
+ * owns — including contested tags — as a side effect of registering just
+ * one, which a Rollup/Vite production build can also reorder *earlier* than
+ * intended when the dynamic import target is merged into the same chunk as a
+ * sibling static import of `@honua/sdk-js/web-components` (issue #679 PR
+ * review; this combination was the root cause of a real ordering bug in the
+ * `web-components-basic` sample before this module existed).
+ *
+ * Because both the synchronous and dynamic paths funnel through the exact
+ * same catalog + `defineIfMissing`-style guards the two kits already use,
+ * calling these functions is deterministic and idempotent regardless of how
+ * many times, in what order, or from which subpath a caller invokes them —
+ * the fix for the import-order-dependent tag ownership issue #679 tracks.
+ *
+ * @module
+ */
+import { type HonuaComponentCatalogEntry } from "./catalog.js";
+/** The catalog id union; kept as `string` at the type level (see `./catalog.js`) but documented here for discoverability. */
+export type HonuaComponentCatalogId = HonuaComponentCatalogEntry["id"];
+/**
+ * The minimal `CustomElementRegistry` surface every registration function in
+ * this module (and both kits' existing `define*` functions) needs. A real
+ * `CustomElementRegistry`, the object `createComponentRegistry()` returns, or
+ * a hand-rolled `{ get, define }` test double all satisfy this.
+ */
+export type HonuaComponentRegistry = Pick<CustomElementRegistry, "get" | "define">;
+export interface HonuaComponentRegistrationOptions {
+    /** Registry to define tags on. Defaults to the global `customElements`. */
+    readonly registry?: HonuaComponentRegistry;
+}
+/** Thrown by `registerComponent(s)` for an id that is not in `HONUA_COMPONENT_CATALOG`. */
+export declare class HonuaComponentCatalogError extends Error {
+    constructor(id: string);
+}
+/**
+ * Registers a single catalog entry by id, e.g. `"web-components.map"` or
+ * `"controls.basemap-switcher"`. Always returns a `Promise` — `controls`
+ * entries resolve synchronously in practice, but a uniform async contract
+ * keeps this one typed shape usable for both kits (including the lazy
+ * `web-components` path) without callers branching on the id's source.
+ *
+ * Throws {@link HonuaComponentCatalogError} for an id not in the catalog.
+ * No-ops (resolves immediately) when no registry is available (Node/SSR
+ * without an explicit `registry` option) — matches every existing `define*`
+ * function's DOM-optional contract (NFR-001).
+ */
+export declare function registerComponent(id: HonuaComponentCatalogId, options?: HonuaComponentRegistrationOptions): Promise<void>;
+/** Registers a named subset of catalog entries. See {@link registerComponent}. */
+export declare function registerComponents(ids: readonly HonuaComponentCatalogId[], options?: HonuaComponentRegistrationOptions): Promise<void>;
+/**
+ * Registers every canonical catalog entry — i.e. everything
+ * `@honua/sdk-js/controls` + `@honua/sdk-js/web-components` would
+ * auto-register between them, from one call. Equivalent to importing both
+ * kits, without needing to import either as a side effect (useful for
+ * lazy-loading the whole component set, or for scoped-registry setups where
+ * side-effect module import cannot target a specific registry).
+ *
+ * Non-canonical entries (the `controls` implementations of `honua-legend` /
+ * `honua-layer-list`) are intentionally excluded — use
+ * {@link registerComponent} / {@link registerComponents} to opt into them
+ * explicitly.
+ */
+export declare function registerAllComponents(options?: HonuaComponentRegistrationOptions): Promise<void>;
+/**
+ * Creates a fresh, isolated component registry: a real `CustomElementRegistry`
+ * where the runtime supports constructing one (the Scoped Custom Element
+ * Registries proposal — not yet universal), otherwise an in-memory
+ * `{ get, define }` object with the same define-once-per-tag idempotency as
+ * every `define*` function in this kit.
+ *
+ * The fallback object satisfies {@link HonuaComponentRegistry} and every
+ * kit's `define*(registry)` parameter, so it is usable anywhere a caller
+ * wants an isolated registration target (tests, multiple independent
+ * catalogs in one process) — but, unlike a real `CustomElementRegistry`, it
+ * cannot be passed to `shadowRoot`-scoped APIs like `attachShadow` on
+ * runtimes that lack native scoped-registry support.
+ */
+export declare function createComponentRegistry(): HonuaComponentRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/controls/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/controls/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAGH,OAAO,EAA2B,KAAK,0BAA0B,EAA4B,MAAM,cAAc,CAAC;AAMlH,6HAA6H;AAC7H,MAAM,MAAM,uBAAuB,GAAG,0BAA0B,CAAC,IAAI,CAAC,CAAC;AAEvE;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,IAAI,CAAC,qBAAqB,EAAE,KAAK,GAAG,QAAQ,CAAC,CAAC;AAEnF,MAAM,WAAW,iCAAiC;IAChD,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,CAAC,EAAE,sBAAsB,CAAC;CAC5C;AAED,2FAA2F;AAC3F,qBAAa,0BAA2B,SAAQ,KAAK;gBAChC,EAAE,EAAE,MAAM;CAI9B;AAqBD;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,uBAAuB,EAC3B,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,kFAAkF;AAClF,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,SAAS,uBAAuB,EAAE,EACvC,OAAO,GAAE,iCAAsC,GAC9C,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,GAAE,iCAAsC,GAAG,OAAO,CAAC,IAAI,CAAC,CAG1G;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,IAAI,sBAAsB,CAmBhE"}

package/controls/registry.js

@@ -0,0 +1,150 @@
+/**
+ * Catalog-driven registration APIs spanning both the `controls` and
+ * `web-components` custom-element kits (issue #679; see `./catalog.js` for
+ * the metadata these operate over).
+ *
+ * `controls`-sourced catalog entries are registered synchronously against
+ * this module's local sibling files (`./basemap-switcher.js`, `./legend.js`,
+ * `./layer-list.js`, `./swipe-control.js`) — none of them import `src/core`
+ * or `src/runtime`, so statically importing them here costs nothing beyond
+ * what `@honua/sdk-js/controls` already bundles.
+ *
+ * `web-components`-sourced entries are registered through a **dynamic**
+ * `import("../web-components/elements.js")`, so merely importing this module
+ * (or `@honua/sdk-js/controls`, which re-exports it) never pulls the
+ * `web-components` kit's `src/core` / `src/runtime` dependency into a
+ * `controls`-only bundle. That dependency is only paid the first time a
+ * caller actually registers a `web-components`-sourced tag.
+ *
+ * Critically, `web-components/elements.js` is itself side-effect-free on
+ * import — it defines the element classes, the tag→constructor lookup, and
+ * `defineHonuaWebComponent(tag)` / `defineHonuaWebComponents()`, but does not
+ * call either. (The blanket auto-registration existing
+ * `@honua/sdk-js/web-components` consumers rely on lives in
+ * `web-components/index.js`, which calls `defineHonuaWebComponents()`
+ * explicitly.) Without that separation, this module's dynamic import would
+ * evaluate `elements.js` and its auto-run would claim every tag the kit
+ * owns — including contested tags — as a side effect of registering just
+ * one, which a Rollup/Vite production build can also reorder *earlier* than
+ * intended when the dynamic import target is merged into the same chunk as a
+ * sibling static import of `@honua/sdk-js/web-components` (issue #679 PR
+ * review; this combination was the root cause of a real ordering bug in the
+ * `web-components-basic` sample before this module existed).
+ *
+ * Because both the synchronous and dynamic paths funnel through the exact
+ * same catalog + `defineIfMissing`-style guards the two kits already use,
+ * calling these functions is deterministic and idempotent regardless of how
+ * many times, in what order, or from which subpath a caller invokes them —
+ * the fix for the import-order-dependent tag ownership issue #679 tracks.
+ *
+ * @module
+ */
+import { defineHonuaBasemapSwitcher } from "./basemap-switcher.js";
+import { HONUA_COMPONENT_CATALOG, getComponentCatalogEntry } from "./catalog.js";
+import { globalDom } from "./element-utils.js";
+import { defineHonuaLayerList } from "./layer-list.js";
+import { defineHonuaLegend } from "./legend.js";
+import { defineHonuaSwipeControl } from "./swipe-control.js";
+/** Thrown by `registerComponent(s)` for an id that is not in `HONUA_COMPONENT_CATALOG`. */
+export class HonuaComponentCatalogError extends Error {
+    constructor(id) {
+        super(`Unknown Honua component catalog id "${id}".`);
+        this.name = "HonuaComponentCatalogError";
+    }
+}
+const CONTROLS_REGISTRARS = {
+    "controls.basemap-switcher": defineHonuaBasemapSwitcher,
+    "controls.swipe-control": defineHonuaSwipeControl,
+    "controls.legend": defineHonuaLegend,
+    "controls.layer-list": defineHonuaLayerList,
+};
+async function registerWebComponentsEntry(entry, registry) {
+    // `elements.js` is side-effect-free (see the module doc above); this only
+    // ever defines `entry.tag`, never the other 15 tags the kit owns.
+    const webComponents = await import("../web-components/elements.js");
+    webComponents.defineHonuaWebComponent(entry.tag, registry);
+}
+/**
+ * Registers a single catalog entry by id, e.g. `"web-components.map"` or
+ * `"controls.basemap-switcher"`. Always returns a `Promise` — `controls`
+ * entries resolve synchronously in practice, but a uniform async contract
+ * keeps this one typed shape usable for both kits (including the lazy
+ * `web-components` path) without callers branching on the id's source.
+ *
+ * Throws {@link HonuaComponentCatalogError} for an id not in the catalog.
+ * No-ops (resolves immediately) when no registry is available (Node/SSR
+ * without an explicit `registry` option) — matches every existing `define*`
+ * function's DOM-optional contract (NFR-001).
+ */
+export async function registerComponent(id, options = {}) {
+    const entry = getComponentCatalogEntry(id);
+    if (!entry)
+        throw new HonuaComponentCatalogError(id);
+    const registry = options.registry ?? globalDom.customElements;
+    if (!registry)
+        return;
+    if (entry.source === "controls") {
+        CONTROLS_REGISTRARS[entry.id]?.(registry);
+        return;
+    }
+    await registerWebComponentsEntry(entry, registry);
+}
+/** Registers a named subset of catalog entries. See {@link registerComponent}. */
+export async function registerComponents(ids, options = {}) {
+    for (const id of ids) {
+        await registerComponent(id, options);
+    }
+}
+/**
+ * Registers every canonical catalog entry — i.e. everything
+ * `@honua/sdk-js/controls` + `@honua/sdk-js/web-components` would
+ * auto-register between them, from one call. Equivalent to importing both
+ * kits, without needing to import either as a side effect (useful for
+ * lazy-loading the whole component set, or for scoped-registry setups where
+ * side-effect module import cannot target a specific registry).
+ *
+ * Non-canonical entries (the `controls` implementations of `honua-legend` /
+ * `honua-layer-list`) are intentionally excluded — use
+ * {@link registerComponent} / {@link registerComponents} to opt into them
+ * explicitly.
+ */
+export async function registerAllComponents(options = {}) {
+    const canonicalIds = HONUA_COMPONENT_CATALOG.filter((entry) => entry.canonical).map((entry) => entry.id);
+    await registerComponents(canonicalIds, options);
+}
+/**
+ * Creates a fresh, isolated component registry: a real `CustomElementRegistry`
+ * where the runtime supports constructing one (the Scoped Custom Element
+ * Registries proposal — not yet universal), otherwise an in-memory
+ * `{ get, define }` object with the same define-once-per-tag idempotency as
+ * every `define*` function in this kit.
+ *
+ * The fallback object satisfies {@link HonuaComponentRegistry} and every
+ * kit's `define*(registry)` parameter, so it is usable anywhere a caller
+ * wants an isolated registration target (tests, multiple independent
+ * catalogs in one process) — but, unlike a real `CustomElementRegistry`, it
+ * cannot be passed to `shadowRoot`-scoped APIs like `attachShadow` on
+ * runtimes that lack native scoped-registry support.
+ */
+export function createComponentRegistry() {
+    const registryCtor = globalThis
+        .CustomElementRegistry;
+    if (typeof registryCtor === "function") {
+        try {
+            return new registryCtor();
+        }
+        catch {
+            // Some runtimes expose the constructor without allowing construction
+            // (e.g. spec-gated behind a flag); fall through to the in-memory registry.
+        }
+    }
+    const defined = new Map();
+    return {
+        get: (tagName) => defined.get(tagName),
+        define: (tagName, ctor) => {
+            if (defined.has(tagName))
+                return;
+            defined.set(tagName, ctor);
+        },
+    };
+}

package/controls/swipe-control.d.ts

@@ -23,7 +23,9 @@
  * ## Attributes
  * - `position` — divider position as a percentage 0–100 (default 50).
  * - `orientation` — `"vertical"` (default) or `"horizontal"`.
- * - `label` — accessible name of the divider (default "Compare maps").
+ * - `label` — optional accessible name of the divider. Supply this from the
+ *   host application's message source when the divider needs an accessible
+ *   name; the control does not provide a locale-specific fallback.
  *
  * ## Events
  * - `change` — `CustomEvent<HonuaSwipeChangeDetail>` (bubbles, composed)
@@ -65,6 +67,9 @@ export declare class HonuaSwipeControlElement extends HTMLElementBase {
     /** Divider orientation. Reflects the `orientation` attribute. */
     get orientation(): HonuaSwipeOrientation;
     set orientation(value: HonuaSwipeOrientation);
+    /** Accessible name of the divider. Reflects the `label` attribute. */
+    get label(): string | null;
+    set label(value: string | null);
     attributeChangedCallback(name: string, _oldValue: string | null, newValue: string | null): void;
     connectedCallback(): void;
     disconnectedCallback(): void;

package/controls/swipe-control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swipe-control.d.ts","sourceRoot":"","sources":["../../../src/controls/swipe-control.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,eAAe,EAA8B,MAAM,oBAAoB,CAAC;AACjF,OAAO,KAAK,EAA0B,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAM/F;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,eAAe;;IAC3D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IASD,mEAAmE;IACnE,IAAW,MAAM,IAAI,aAAa,GAAG,SAAS,CAE7C;IAED,IAAW,MAAM,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,EAI/C;IAED,+CAA+C;IAC/C,IAAW,SAAS,IAAI,aAAa,GAAG,SAAS,CAEhD;IAED,IAAW,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,EAElD;IAED,4EAA4E;IACrE,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,IAAI;IAKtE,iFAAiF;IACjF,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,IAAW,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEhC;IAED,iEAAiE;IACjE,IAAW,WAAW,IAAI,qBAAqB,CAE9C;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,qBAAqB,EAGlD;IAEM,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAgB/F,iBAAiB,IAAI,IAAI;IAMzB,oBAAoB,IAAI,IAAI;IA4CnC,SAAS,CAAC,MAAM,IAAI,IAAI;CAoJzB;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKjF"}
+{"version":3,"file":"swipe-control.d.ts","sourceRoot":"","sources":["../../../src/controls/swipe-control.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAAE,eAAe,EAAgD,MAAM,oBAAoB,CAAC;AACnG,OAAO,KAAK,EAA0B,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAM/F;;;;GAIG;AACH,qBAAa,wBAAyB,SAAQ,eAAe;;IAC3D,WAAkB,kBAAkB,IAAI,MAAM,EAAE,CAE/C;IASD,mEAAmE;IACnE,IAAW,MAAM,IAAI,aAAa,GAAG,SAAS,CAE7C;IAED,IAAW,MAAM,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,EAI/C;IAED,+CAA+C;IAC/C,IAAW,SAAS,IAAI,aAAa,GAAG,SAAS,CAEhD;IAED,IAAW,SAAS,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS,EAElD;IAED,4EAA4E;IACrE,OAAO,CAAC,MAAM,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,aAAa,GAAG,IAAI;IAKtE,iFAAiF;IACjF,IAAW,QAAQ,IAAI,MAAM,CAE5B;IAED,IAAW,QAAQ,CAAC,KAAK,EAAE,MAAM,EAEhC;IAED,iEAAiE;IACjE,IAAW,WAAW,IAAI,qBAAqB,CAE9C;IAED,IAAW,WAAW,CAAC,KAAK,EAAE,qBAAqB,EAGlD;IAED,sEAAsE;IACtE,IAAW,KAAK,IAAI,MAAM,GAAG,IAAI,CAEhC;IAED,IAAW,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAOpC;IAEM,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAgB/F,iBAAiB,IAAI,IAAI;IAMzB,oBAAoB,IAAI,IAAI;IA8CnC,SAAS,CAAC,MAAM,IAAI,IAAI;CA0KzB;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,wBAA2B,GAAG,IAAI,CAKjF"}

package/controls/swipe-control.js

@@ -23,7 +23,9 @@
  * ## Attributes
  * - `position` — divider position as a percentage 0–100 (default 50).
  * - `orientation` — `"vertical"` (default) or `"horizontal"`.
- * - `label` — accessible name of the divider (default "Compare maps").
+ * - `label` — optional accessible name of the divider. Supply this from the
+ *   host application's message source when the divider needs an accessible
+ *   name; the control does not provide a locale-specific fallback.
  *
  * ## Events
  * - `change` — `CustomEvent<HonuaSwipeChangeDetail>` (bubbles, composed)
@@ -41,7 +43,7 @@
  *
  * @module
  */
-import { HTMLElementBase, escapeAttribute, globalDom } from "./element-utils.js";
+import { HTMLElementBase, escapeAttribute, globalDom, renderShadowRoot } from "./element-utils.js";
 const DEFAULT_POSITION = 50;
 const STEP = 1;
 const STEP_LARGE = 10;
@@ -98,6 +100,20 @@ export class HonuaSwipeControlElement extends HTMLElementBase {
             return;
         this.setAttribute("orientation", value === "horizontal" ? "horizontal" : "vertical");
     }
+    /** Accessible name of the divider. Reflects the `label` attribute. */
+    get label() {
+        return this.#label();
+    }
+    set label(value) {
+        if (typeof this.setAttribute !== "function")
+            return;
+        if (value === null) {
+            this.removeAttribute?.("label");
+        }
+        else {
+            this.setAttribute("label", value);
+        }
+    }
     attributeChangedCallback(name, _oldValue, newValue) {
         if (name === "position") {
             const parsed = newValue === null ? DEFAULT_POSITION : Number(newValue);
@@ -146,7 +162,9 @@ export class HonuaSwipeControlElement extends HTMLElementBase {
         container.style.clipPath =
             this.orientation === "horizontal"
                 ? `inset(${pct} 0 0 0)` // hide the top portion above the divider
-                : `inset(0 0 0 ${pct})`; // hide the left portion before the divider
+                : this.#isRtl()
+                    ? `inset(0 ${pct} 0 0)` // hide the right portion before the divider
+                    : `inset(0 0 0 ${pct})`; // hide the left portion before the divider
     }
     #clearClip(map) {
         const container = map?.getContainer?.();
@@ -167,8 +185,9 @@ export class HonuaSwipeControlElement extends HTMLElementBase {
             this.#updateDividerDom();
             return;
         }
-        root.innerHTML = `
-      <style>${structuralStyles()}</style>
+        const label = this.#label();
+        const ariaLabel = label === null ? "" : ` aria-label="${escapeAttribute(label)}"`;
+        renderShadowRoot(root, structuralStyles(), `
       <div
         part="divider"
         class="divider"
@@ -177,12 +196,12 @@ export class HonuaSwipeControlElement extends HTMLElementBase {
         aria-valuemin="0"
         aria-valuemax="100"
         aria-valuenow="${this.#position}"
-        aria-orientation="${this.orientation}"
-        aria-label="${escapeAttribute(this.#label())}"
+        aria-orientation="${this.#ariaOrientation()}"
+        ${ariaLabel}
       >
         <span part="handle" class="handle" aria-hidden="true"></span>
       </div>
-    `;
+    `);
         this.#rendered = true;
         this.#bindDivider(root);
         this.#updateDividerDom();
@@ -199,17 +218,21 @@ export class HonuaSwipeControlElement extends HTMLElementBase {
             return;
         const pct = `${this.#position}%`;
         if (this.orientation === "horizontal") {
-            divider.style.left = "0";
-            divider.style.top = pct;
+            divider.style.insetInlineStart = "0";
+            divider.style.insetBlockStart = pct;
         }
         else {
-            divider.style.top = "0";
-            divider.style.left = pct;
+            divider.style.insetBlockStart = "0";
+            divider.style.insetInlineStart = pct;
         }
         divider.classList?.toggle("divider-horizontal", this.orientation === "horizontal");
         divider.setAttribute?.("aria-valuenow", String(this.#position));
-        divider.setAttribute?.("aria-orientation", this.orientation);
-        divider.setAttribute?.("aria-label", this.#label());
+        divider.setAttribute?.("aria-orientation", this.#ariaOrientation());
+        const label = this.#label();
+        if (label === null)
+            divider.removeAttribute?.("aria-label");
+        else
+            divider.setAttribute?.("aria-label", label);
     }
     // ── interaction ────────────────────────────────────────────
     #bindDivider(root) {
@@ -257,21 +280,24 @@ export class HonuaSwipeControlElement extends HTMLElementBase {
                 : (event.clientY - rect.top) / rect.height
             : rect.width === 0
                 ? 0
-                : (event.clientX - rect.left) / rect.width;
+                : this.#isRtl()
+                    ? 1 - (event.clientX - rect.left) / rect.width
+                    : (event.clientX - rect.left) / rect.width;
         this.#setPosition(ratio * 100, true);
     }
     #onKeyDown(event) {
         const horizontal = this.orientation === "horizontal";
+        const reverseInlineDirection = !horizontal && this.#isRtl();
         const step = event.shiftKey ? STEP_LARGE : STEP;
         let next;
         switch (event.key) {
             case "ArrowRight":
             case "ArrowDown":
-                next = this.#position + step;
+                next = this.#position + (reverseInlineDirection && event.key === "ArrowRight" ? -step : step);
                 break;
             case "ArrowLeft":
             case "ArrowUp":
-                next = this.#position - step;
+                next = this.#position - (reverseInlineDirection && event.key === "ArrowLeft" ? -step : step);
                 break;
             case "Home":
                 next = horizontal ? 100 : 0;
@@ -287,11 +313,23 @@ export class HonuaSwipeControlElement extends HTMLElementBase {
     }
     // ── helpers ────────────────────────────────────────────────
     #label() {
-        return this.#attr("label") ?? "Compare maps";
+        return this.#attr("label");
     }
     #attr(name) {
         return typeof this.getAttribute === "function" ? this.getAttribute(name) : null;
     }
+    #isRtl() {
+        const explicitDirection = this.#attr("dir")?.toLowerCase();
+        if (explicitDirection === "rtl")
+            return true;
+        if (explicitDirection === "ltr")
+            return false;
+        return globalDom.getComputedStyle?.(this).direction === "rtl";
+    }
+    /** ARIA describes the axis of the slider value, not the divider's visual axis. */
+    #ariaOrientation() {
+        return this.orientation === "vertical" ? "horizontal" : "vertical";
+    }
     #reflectPosition(value) {
         if (typeof this.setAttribute !== "function" || typeof this.getAttribute !== "function")
             return;
@@ -330,12 +368,25 @@ function clampPercent(value) {
 /** Structural-only styles; theme via `::part(divider)` / `::part(handle)`. */
 function structuralStyles() {
     return `
-    :host { position: absolute; inset: 0; pointer-events: none; display: block; }
+    :host {
+      position: absolute;
+      inset: 0;
+      display: block;
+      box-sizing: border-box;
+      min-width: 0;
+      max-width: 100%;
+      min-height: 0;
+      max-height: 100%;
+      pointer-events: none;
+    }
     .divider {
       position: absolute;
-      top: 0;
+      inset-block-start: 0;
       block-size: 100%;
       inline-size: 0;
+      box-sizing: border-box;
+      max-width: 100%;
+      max-height: 100%;
       border-inline-start: 2px solid currentColor;
       transform: translateX(-1px);
       cursor: ew-resize;
@@ -364,5 +415,16 @@ function structuralStyles() {
       inset-block-start: 0;
       inset-inline-start: 50%;
     }
+    @media (forced-colors: active), (prefers-contrast: more) {
+      .divider {
+        forced-color-adjust: none;
+        border-color: ButtonText;
+      }
+      .handle {
+        background: ButtonText;
+        outline: 2px solid Canvas;
+        outline-offset: 1px;
+      }
+    }
   `;
 }

package/core/client.d.ts

@@ -2,6 +2,7 @@ import { type HonuaMetadataRequestOptions } from "./cache-state.js";
 import { HonuaOdataEntitySet } from "./odata.js";
 import { type OgcApiLayoutMode } from "./ogc-endpoint-layout.js";
 import { HonuaOgcMaps } from "./ogc-maps.js";
+import type { HonuaOgcProcessesOptions } from "./ogc-processes.js";
 import { HonuaOgcProcesses } from "./ogc-processes.js";
 import { HonuaOgcRecords } from "./ogc-records.js";
 import { HonuaOgcTiles } from "./ogc-tiles.js";
@@ -9,7 +10,7 @@ import { type HonuaProcessRunner } from "./process-runner.js";
 import type { GeospatialGrpcProcessClient, HonuaProcessAdapter } from "./process-runner.js";
 import { HonuaStacSearch } from "./stac.js";
 import { HonuaFeatureLayer, HonuaGeometryService, HonuaGeoprocessingService, HonuaImageService, HonuaMapLayer, HonuaMapService, HonuaOgcFeatures, HonuaService } from "./surfaces.js";
-import type { ApplyEditsRequest, ExportMapRequest, HonuaApplyEditsResponse, HonuaAuthCredentials, HonuaAuthRefreshReason, HonuaAuthRevocationContext, HonuaClientOptions, HonuaCompatibilityRequest, HonuaExportMapResponse, HonuaFeature, HonuaFindResponse, HonuaIdentifyResponse, HonuaLayerMetadata, HonuaLegendResponse, HonuaOgcCollectionMetadata, HonuaOgcCollectionsResponse, HonuaOgcConformanceResponse, HonuaOgcFeatureCollectionResponse, HonuaOgcFeatureResponse, HonuaOgcLandingResponse, HonuaOgcMapImageResponse, HonuaOgcProcessDescription, HonuaOgcProcessJobAccepted, HonuaOgcProcessJobResults, HonuaOgcProcessJobStatus, HonuaOgcProcessesResponse, HonuaOgcQueryablesResponse, HonuaOgcRecordResponse, HonuaOgcRecordsResponse, HonuaOgcTileMatrixSet, HonuaOgcTileMatrixSetsResponse, HonuaOgcTileResponse, HonuaOgcTilesetMetadata, HonuaOgcTilesetsResponse, HonuaQueryResponse, HonuaRawRequest, HonuaRelatedRecordsResponse, HonuaServerCompatibility, HonuaServerCompatibilityFeature, HonuaServerCompatibilityStatus, HonuaServiceMetadata, HonuaServicesResponse, HonuaStacItemCollectionResponse, HonuaStacItemResponse, HonuaStacLandingResponse, MapFindRequest, MapIdentifyRequest, MapLayerQueryRequest, MapLegendRequest, MapRelatedRecordsRequest, MigrationInventoryScanRequest, MigrationSourceInventoryArtifact, OgcCollectionRequest, OgcCreateItemRequest, OgcDeleteItemRequest, OgcEndpointLayout, OgcItemRequest, OgcItemsRequest, OgcMapImageRequest, OgcMetadataRequest, OgcPatchItemRequest, OgcProcessExecuteRequest, OgcRecordItemRequest, OgcRecordRawItemRequest, OgcRecordsRawSearchRequest, OgcRecordsSearchRequest, OgcReplaceItemRequest, OgcTileRequest, OgcTilesetRequest, OgcTilesetsRequest, QueryFeaturesRequest, QueryMethod, QueryRelatedRecordsRequest, StacSearchRequest } from "./types.js";
+import type { ApplyEditsRequest, ExportMapRequest, HonuaApplyEditsResponse, HonuaAuthCredentials, HonuaAuthRefreshReason, HonuaAuthRevocationContext, HonuaClientOptions, HonuaCompatibilityRequest, HonuaExportMapResponse, HonuaFeature, HonuaFindResponse, HonuaIdentifyResponse, HonuaLayerMetadata, HonuaLegendResponse, HonuaOgcCollectionMetadata, HonuaOgcCollectionsResponse, HonuaOgcConformanceResponse, HonuaOgcFeatureCollectionResponse, HonuaOgcFeatureResponse, HonuaOgcLandingResponse, HonuaOgcMapImageResponse, HonuaOgcProcessDescription, HonuaOgcProcessJobAccepted, HonuaOgcProcessJobResults, HonuaOgcProcessJobStatus, HonuaOgcProcessesResponse, HonuaOgcQueryablesResponse, HonuaOgcRecordResponse, HonuaOgcRecordsResponse, HonuaOgcTileMatrixSet, HonuaOgcTileMatrixSetsResponse, HonuaOgcTileResponse, HonuaOgcTilesetMetadata, HonuaOgcTilesetsResponse, HonuaQueryResponse, HonuaRawRequest, HonuaRelatedRecordsResponse, HonuaRequestContext, HonuaServerCompatibility, HonuaServerCompatibilityFeature, HonuaServerCompatibilityStatus, HonuaServiceMetadata, HonuaServicesResponse, HonuaStacItemCollectionResponse, HonuaStacItemResponse, HonuaStacLandingResponse, MapFindRequest, MapIdentifyRequest, MapLayerQueryRequest, MapLegendRequest, MapRelatedRecordsRequest, MigrationInventoryScanRequest, MigrationSourceInventoryArtifact, OgcCollectionRequest, OgcCreateItemRequest, OgcDeleteItemRequest, OgcEndpointLayout, OgcItemRequest, OgcItemsRequest, OgcMapImageRequest, OgcMetadataRequest, OgcPatchItemRequest, OgcProcessExecuteRequest, OgcProcessJobRequest, OgcRecordItemRequest, OgcRecordRawItemRequest, OgcRecordsRawSearchRequest, OgcRecordsSearchRequest, OgcReplaceItemRequest, OgcTileRequest, OgcTilesetRequest, OgcTilesetsRequest, QueryFeaturesRequest, QueryMethod, QueryRelatedRecordsRequest, StacSearchRequest } from "./types.js";
 import { HonuaWfs } from "./wfs.js";
 import type { WmsCapabilities } from "./wms-capabilities.js";
 import type { HonuaWmsFeatureInfoResponse, HonuaWmsImageResponse, HonuaWmtsFeatureInfoResponse, HonuaWmtsTileResponse, WmsFeatureInfoRequest, WmsLegendRequest, WmsMapRequest, WmtsFeatureInfoRequest, WmtsTileRequest } from "./wms-types.js";
@@ -252,13 +253,23 @@ export declare class HonuaClient {
     ogcRecords(): HonuaOgcRecords;
     wms(serviceId: string): HonuaWms;
     wmts(serviceId: string): HonuaWmts;
-    ogcProcesses(): HonuaOgcProcesses;
+    /**
+     * Construct the OGC API Processes client wrapper.
+     *
+     * `basePath` pins every describe / execute / job route to a raw third-party
+     * service root (as discovered by `discoverOgcProcesses()`); omitting it uses
+     * the Honua facade prefix `/ogc/processes`. Pass the discovery result (or a
+     * `/conformance` response) as `conformance` — and optionally
+     * `capabilityPolicy: "strict"` — to gate execution and dismissal against what
+     * the server actually declares.
+     */
+    ogcProcesses(options?: Omit<HonuaOgcProcessesOptions, "client">): HonuaOgcProcesses;
     stac(): HonuaStacSearch;
     imageService(serviceId: string): HonuaImageService;
     geometryService(): HonuaGeometryService;
     geoprocessing(serviceId: string, taskName?: string): HonuaGeoprocessingService;
     processRunner(adapter: HonuaProcessAdapter): HonuaProcessRunner;
-    ogcProcessRunner(): HonuaProcessRunner;
+    ogcProcessRunner(options?: Omit<HonuaOgcProcessesOptions, "client">): HonuaProcessRunner;
     geoprocessingRunner(serviceId: string, taskName?: string): HonuaProcessRunner;
     geospatialGrpcProcessRunner(processClient: GeospatialGrpcProcessClient): HonuaProcessRunner;
     wfs(endpointUrl?: string, options?: {
@@ -363,6 +374,32 @@ export declare class HonuaClient {
         okStatuses?: readonly number[];
         redirect?: "safe-follow" | "error" | "manual";
         discardErrorBody?: boolean;
+        /**
+         * Builds the body retained by `HonuaHttpError` for unsuccessful
+         * responses. Bounded protocol clients use this hook to consume failure
+         * bodies under the same byte ceiling as successful responses.
+         */
+        errorBody?: (response: Response, deadlineSignal: AbortSignal | undefined) => Promise<unknown>;
+        /**
+         * Invoked immediately before every physical fetch attempt, including
+         * retry and replay-safe authentication attempts. Bounded callers use
+         * this guard to reserve request and byte budgets before network I/O.
+         */
+        beforeAttempt?: (request: Readonly<HonuaRequestContext>, attempt: number) => void | Promise<void>;
+        /**
+         * Invoked before credential refresh or retry backoff can lead to another
+         * physical request. Single-attempt binary lanes throw here so a response
+         * that cannot be replayed never waits on work whose only purpose is replay.
+         */
+        beforeReplay?: (request: Readonly<HonuaRequestContext>, statusCode: number | undefined, reason: "authentication" | "retry") => void | Promise<void>;
+        /**
+         * Validate and replace a successful response before `after`
+         * interceptors run. The callback remains inside the request timeout and
+         * receives its combined caller/deadline signal. Bounded binary lanes use
+         * this to consume the network stream under a hard ceiling, then return
+         * an in-memory response that interceptors may inspect safely.
+         */
+        prepareResponse?: (response: Response, deadlineSignal: AbortSignal | undefined) => Promise<Response>;
     }): Promise<Response>;
     private requestCachedMetadataJson;
     private staleMetadataFallback;
@@ -475,24 +512,9 @@ export declare class HonuaClient {
         processId: string;
     } & OgcMetadataRequest): Promise<HonuaOgcProcessDescription>;
     executeOgcProcess(request: OgcProcessExecuteRequest): Promise<HonuaOgcProcessJobAccepted>;
-    getOgcProcessJob(request: {
-        jobId: string;
-        signal?: AbortSignal;
-        responseFormat?: string;
-        extraParams?: Record<string, string | number | boolean>;
-    }): Promise<HonuaOgcProcessJobStatus>;
-    getOgcProcessJobResults(request: {
-        jobId: string;
-        signal?: AbortSignal;
-        responseFormat?: string;
-        extraParams?: Record<string, string | number | boolean>;
-    }): Promise<HonuaOgcProcessJobResults>;
-    cancelOgcProcessJob(request: {
-        jobId: string;
-        signal?: AbortSignal;
-        responseFormat?: string;
-        extraParams?: Record<string, string | number | boolean>;
-    }): Promise<HonuaOgcProcessJobStatus>;
+    getOgcProcessJob(request: OgcProcessJobRequest): Promise<HonuaOgcProcessJobStatus>;
+    getOgcProcessJobResults(request: OgcProcessJobRequest): Promise<HonuaOgcProcessJobResults>;
+    cancelOgcProcessJob(request: OgcProcessJobRequest): Promise<HonuaOgcProcessJobStatus>;
     getStacLanding(request?: OgcMetadataRequest): Promise<HonuaStacLandingResponse>;
     listStacCollections(request?: OgcMetadataRequest): Promise<HonuaOgcCollectionsResponse>;
     getStacCollection(request: OgcCollectionRequest): Promise<HonuaOgcCollectionMetadata>;
@@ -563,6 +585,8 @@ export declare class HonuaClient {
         contentType?: string;
         body?: BodyInit;
         signal?: AbortSignal;
+        /** Maximum response-body bytes accepted before text decoding/parsing. */
+        maxResponseBytes?: number;
     }): Promise<{
         text: string;
         contentType: string;
@@ -604,6 +628,12 @@ export declare class HonuaClient {
     /** Whether any registered interceptor inspects responses (`after` hook). */
     private hasAfterInterceptors;
     private applyErrorInterceptors;
+    /**
+     * Start every terminal error hook independently so one nonsettling hook
+     * cannot prevent later hooks from observing the same failure. Each hook is
+     * contained so a detached deadline notification can never reject unhandled.
+     */
+    private applyErrorInterceptorsConcurrently;
     private refreshReplaySafeRequestAuth;
     private sleepBeforeRetry;
 }