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

package/interactions/declarative-contract.js

@@ -0,0 +1,293 @@
+/**
+ * The declarative interaction vocabulary from the open geospatial MCP
+ * standard (geospatial-mcp ADR-0030, `spec/schemas/common/interactions.schema.json`).
+ *
+ * This module owns ONLY the data shapes, the standard's closed sets, and the
+ * pure validation rules — no binding, no DOM, no imports — so the same rules
+ * can be reused by the agent-tool vocabulary (`@honua/sdk-js/agent-tools`'
+ * `bindInteraction` verb) without dragging the compiler
+ * (`./declarative.js`) and its exploration primitives into that bundle.
+ *
+ * The normative rules encoded here:
+ *
+ * - **Closed event set** — `featureSelect`/`featureHover` (layer sources),
+ *   `selection` (widget sources), `change` (control sources),
+ *   `viewportChange` (map source). Extending it requires a standard ADR.
+ * - **Closed verb set** — `setFilter`, `setViewport`, `selectFeature`,
+ *   `runWidgetQuery`, `setVisibility`. Verbs mutate presentation/exploration
+ *   state only, never source records.
+ * - **Arguments are static JSON plus `$event.*` path substitution.** There is
+ *   no expression language: no arithmetic, no conditionals, no function
+ *   calls. A string that starts with `$event` MUST be a well-formed
+ *   `$event.<segment>[.<segment>…]` path.
+ * - **Unique ids** within one interactions block.
+ * - **Fan-out cap** — at most {@link HONUA_INTERACTION_FANOUT_CAP} (8,
+ *   the standard's RECOMMENDED cap) interactions may share one
+ *   (`on.ref`, `on.event`) pair. Blocks over the cap are rejected, never
+ *   truncated.
+ *
+ * Reference resolution ("does `layer:parcels` exist in this document?") is a
+ * validation-gate responsibility the standard deliberately leaves to the
+ * host; the compiler in `./declarative.js` performs it against the concrete
+ * components it is handed.
+ *
+ * @module
+ */
+/** Closed event vocabulary (`$defs/eventName`). */
+export const HONUA_INTERACTION_EVENTS = [
+    "featureSelect",
+    "featureHover",
+    "selection",
+    "change",
+    "viewportChange",
+];
+/** Closed action-verb vocabulary (`$defs/actionVerb`). */
+export const HONUA_INTERACTION_VERBS = [
+    "setFilter",
+    "setViewport",
+    "selectFeature",
+    "runWidgetQuery",
+    "setVisibility",
+];
+/** Component-reference kinds addressable by an interaction (`$defs/componentRef`). */
+export const HONUA_INTERACTION_REF_KINDS = ["map", "layer", "widget", "control"];
+/**
+ * The standard's RECOMMENDED per-(`on.ref`, `on.event`) fan-out cap. A block
+ * that exceeds it is rejected whole rather than truncated.
+ */
+export const HONUA_INTERACTION_FANOUT_CAP = 8;
+/** The `$event.` prefix that marks the only dynamic element of an argument value. */
+export const HONUA_INTERACTION_EVENT_PATH_PREFIX = "$event.";
+const REF_PATTERN = /^(map|layer:.+|widget:.+|control:.+)$/;
+const EVENT_PATH_PATTERN = /^\$event(\.[^.\s]+)+$/;
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** True for a syntactically valid `map` | `layer:{id}` | `widget:{id}` | `control:{id}` reference. */
+export function isHonuaInteractionRef(value) {
+    return typeof value === "string" && REF_PATTERN.test(value);
+}
+/** Splits a component reference into its kind and id. Returns `undefined` for a malformed reference. */
+export function parseHonuaInteractionRef(ref) {
+    if (ref === "map")
+        return { kind: "map" };
+    const separator = ref.indexOf(":");
+    if (separator <= 0)
+        return undefined;
+    const kind = ref.slice(0, separator);
+    const id = ref.slice(separator + 1);
+    if (id.length === 0)
+        return undefined;
+    if (kind !== "layer" && kind !== "widget" && kind !== "control")
+        return undefined;
+    return { kind, id };
+}
+export function isHonuaInteractionEvent(value) {
+    return typeof value === "string" && HONUA_INTERACTION_EVENTS.includes(value);
+}
+export function isHonuaInteractionVerb(value) {
+    return typeof value === "string" && HONUA_INTERACTION_VERBS.includes(value);
+}
+/**
+ * True when a string value is a `$event.*` substitution path. A string that
+ * starts with `$event` but is not a well-formed path (`"$event"`,
+ * `"$event."`, `"$eventfoo"`) is NOT a path — it is a validation failure,
+ * caught by {@link validateHonuaInteraction}.
+ */
+export function isHonuaInteractionEventPath(value) {
+    return EVENT_PATH_PATTERN.test(value);
+}
+/**
+ * Reads the value at a `$event.a.b` path out of an event payload. Returns
+ * `undefined` when any segment is missing — there is no error channel and no
+ * default, matching the standard's "substitution, not expression" posture.
+ */
+export function readHonuaInteractionEventPath(payload, path) {
+    const segments = path.slice("$event".length).split(".").filter(Boolean);
+    let current = payload;
+    for (const segment of segments) {
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index))
+                return undefined;
+            current = current[index];
+            continue;
+        }
+        if (!isRecord(current))
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+/**
+ * Substitutes every `$event.*` string in `args` with the value at that path
+ * in `payload`, recursing through nested objects and arrays. Non-string
+ * values and strings without the prefix are copied through unchanged — this
+ * is the whole of the dynamic surface.
+ */
+export function resolveHonuaInteractionArgs(args, payload) {
+    if (!args)
+        return {};
+    return substitute(args, payload);
+}
+function substitute(value, payload) {
+    if (typeof value === "string") {
+        return value.startsWith(HONUA_INTERACTION_EVENT_PATH_PREFIX)
+            ? readHonuaInteractionEventPath(payload, value)
+            : value;
+    }
+    if (Array.isArray(value))
+        return value.map((entry) => substitute(entry, payload));
+    if (isRecord(value)) {
+        const next = {};
+        for (const [key, child] of Object.entries(value))
+            next[key] = substitute(child, payload);
+        return next;
+    }
+    return value;
+}
+/**
+ * Validates ONE interaction against the standard's schema-level rules
+ * (shape, closed sets, reference grammar, `$event.*` argument discipline).
+ * Fan-out and id uniqueness are block-level rules — see
+ * {@link validateHonuaInteractions}.
+ */
+export function validateHonuaInteraction(value, path = "interaction") {
+    const issues = [];
+    if (!isRecord(value)) {
+        return [{ code: "invalid-shape", path, message: "An interaction must be a JSON object." }];
+    }
+    const interactionId = typeof value.id === "string" ? value.id : undefined;
+    const issue = (code, field, message) => {
+        issues.push({ code, ...(interactionId ? { interactionId } : {}), path: `${path}.${field}`, message });
+    };
+    if (typeof value.id !== "string" || value.id.length === 0 || value.id.length > 200) {
+        issue("invalid-shape", "id", "`id` must be a non-empty string of at most 200 characters.");
+    }
+    if (value.disabled !== undefined && typeof value.disabled !== "boolean") {
+        issue("invalid-shape", "disabled", "`disabled` must be a boolean when present.");
+    }
+    if (!isRecord(value.on)) {
+        issue("invalid-shape", "on", "`on` must be an object with `ref` and `event`.");
+    }
+    else {
+        if (!isHonuaInteractionRef(value.on.ref)) {
+            issue("invalid-ref", "on.ref", "`on.ref` must be `map`, `layer:{id}`, `widget:{id}`, or `control:{id}`.");
+        }
+        if (!isHonuaInteractionEvent(value.on.event)) {
+            issue("unknown-event", "on.event", `\`on.event\` must be one of: ${HONUA_INTERACTION_EVENTS.join(", ")}.`);
+        }
+        for (const key of Object.keys(value.on)) {
+            if (key !== "ref" && key !== "event") {
+                issue("invalid-shape", `on.${key}`, "`on` accepts only `ref` and `event`.");
+            }
+        }
+    }
+    if (!isRecord(value.do)) {
+        issue("invalid-shape", "do", "`do` must be an object with `ref` and `verb`.");
+    }
+    else {
+        if (!isHonuaInteractionRef(value.do.ref)) {
+            issue("invalid-ref", "do.ref", "`do.ref` must be `map`, `layer:{id}`, `widget:{id}`, or `control:{id}`.");
+        }
+        if (!isHonuaInteractionVerb(value.do.verb)) {
+            issue("unknown-verb", "do.verb", `\`do.verb\` must be one of: ${HONUA_INTERACTION_VERBS.join(", ")}.`);
+        }
+        if (value.do.args !== undefined) {
+            if (!isRecord(value.do.args)) {
+                issue("invalid-shape", "do.args", "`do.args` must be a JSON object when present.");
+            }
+            else {
+                collectEventPathIssues(value.do.args, `${path}.do.args`, interactionId, issues);
+            }
+        }
+        for (const key of Object.keys(value.do)) {
+            if (key !== "ref" && key !== "verb" && key !== "args") {
+                issue("invalid-shape", `do.${key}`, "`do` accepts only `ref`, `verb`, and `args`.");
+            }
+        }
+    }
+    for (const key of Object.keys(value)) {
+        if (key !== "id" && key !== "on" && key !== "do" && key !== "disabled") {
+            issue("invalid-shape", key, "An interaction accepts only `id`, `on`, `do`, and `disabled`.");
+        }
+    }
+    return issues;
+}
+function collectEventPathIssues(value, path, interactionId, issues) {
+    if (typeof value === "string") {
+        if (value.startsWith("$event") && !isHonuaInteractionEventPath(value)) {
+            issues.push({
+                code: "invalid-event-path",
+                ...(interactionId ? { interactionId } : {}),
+                path,
+                message: "A `$event` argument must be a `$event.<path>` substitution — the vocabulary has no expression language.",
+            });
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((entry, index) => collectEventPathIssues(entry, `${path}[${index}]`, interactionId, issues));
+        return;
+    }
+    if (isRecord(value)) {
+        for (const [key, child] of Object.entries(value)) {
+            collectEventPathIssues(child, `${path}.${key}`, interactionId, issues);
+        }
+    }
+}
+/**
+ * Validates a whole `interactions` block: every member's schema-level rules
+ * plus the two block-level ones (unique ids, fan-out cap). Disabled
+ * interactions are validated like any other — they are retained in the
+ * document, only skipped at dispatch — but they do NOT count toward the
+ * fan-out cap, which bounds live dispatch work.
+ */
+export function validateHonuaInteractions(interactions, options = {}) {
+    const cap = options.fanOutCap ?? HONUA_INTERACTION_FANOUT_CAP;
+    if (!Array.isArray(interactions)) {
+        return {
+            ok: false,
+            issues: [{ code: "invalid-shape", path: "interactions", message: "`interactions` must be an array." }],
+        };
+    }
+    const issues = [];
+    const seenIds = new Set();
+    const fanOut = new Map();
+    interactions.forEach((interaction, index) => {
+        const path = `interactions[${index}]`;
+        issues.push(...validateHonuaInteraction(interaction, path));
+        if (!isRecord(interaction))
+            return;
+        const id = typeof interaction.id === "string" ? interaction.id : undefined;
+        if (id !== undefined) {
+            if (seenIds.has(id)) {
+                issues.push({
+                    code: "duplicate-id",
+                    interactionId: id,
+                    path: `${path}.id`,
+                    message: `Interaction id "${id}" is declared more than once in this block.`,
+                });
+            }
+            seenIds.add(id);
+        }
+        if (interaction.disabled === true)
+            return;
+        const on = isRecord(interaction.on) ? interaction.on : undefined;
+        if (!isHonuaInteractionRef(on?.ref) || !isHonuaInteractionEvent(on?.event))
+            return;
+        const key = `${on.ref}${on.event}`;
+        fanOut.set(key, (fanOut.get(key) ?? 0) + 1);
+    });
+    for (const [key, count] of fanOut) {
+        if (count <= cap)
+            continue;
+        const [ref, event] = key.split("");
+        issues.push({
+            code: "fan-out-exceeded",
+            path: "interactions",
+            message: `${count} interactions share (${ref}, ${event}); the fan-out cap is ${cap}. The block is rejected, not truncated.`,
+        });
+    }
+    return { ok: issues.length === 0, issues };
+}

package/interactions/declarative.d.ts

@@ -0,0 +1,198 @@
+/**
+ * `@honua/sdk-js/interactions/declarative` — compiles a standard
+ * `interactions[]` block (geospatial-mcp ADR-0030) onto this SDK's existing
+ * imperative binding primitives.
+ *
+ * The standard constrains the *document*, not the dispatcher: "client
+ * runtimes implement dispatch by compiling bindings onto whatever imperative
+ * primitives they already have". That is exactly what this module does — it
+ * owns no event plumbing of its own, only a compile table from the closed
+ * (`on.event`, `do.verb`) vocabulary onto `createSelectionHandler`,
+ * `createHoverHandler`, `bindTableSelectionToExploration`,
+ * `bindFilterControlsToExploration`, and `subscribeExplorationSelector`.
+ *
+ * Three properties are load-bearing and asserted by the suite:
+ *
+ * 1. **Validate before binding.** `compileHonuaInteractions` runs the whole
+ *    block through {@link validateHonuaInteractions} plus reference
+ *    resolution against the components it was handed. A block with issues
+ *    binds *nothing* — the standard rejects over-cap and malformed documents
+ *    rather than truncating them.
+ * 2. **Actions never emit events.** A verb-driven state change must not
+ *    re-enter the dispatcher. Two mechanisms enforce it: every compiled
+ *    handler is skipped while an action is in flight (`#dispatching`), and
+ *    exploration-backed subscriptions run with the view controller's default
+ *    `includeSelf: false`, so a change this compiler originated is never
+ *    delivered back to this compiler. There is no cycle detection because
+ *    there can be no cycle.
+ * 3. **Unsupported pairs are named, never dropped.** When a binding's
+ *    (`on.event`, `do.verb`) pair — or the component behind a ref — has no
+ *    primitive to compile onto, it lands in
+ *    {@link HonuaCompiledInteractions.unsupported} with the pair spelled out,
+ *    so a host can surface a real "this runtime cannot honor that binding"
+ *    message instead of silently rendering an inert app.
+ *
+ * @experimental The compiler surface tracks geospatial-mcp ADR-0030 while
+ * that ADR is Proposed; the component-adapter shapes may gain fields.
+ *
+ * @module
+ */
+import type { SourceId } from "../contract/types.js";
+import type { ExplorationViewController, FilterClause } from "../exploration/types.js";
+import type { InteractiveMap } from "./feature-state.js";
+import { type HonuaInteractionEvent, type HonuaInteractionIssue, type HonuaInteractionVerb } from "./declarative-contract.js";
+export * from "./declarative-contract.js";
+/**
+ * A layer addressed as `layer:{id}`. `map` is what the
+ * `featureSelect`/`featureHover` primitives bind to; the optional methods are
+ * the layer-scoped action targets.
+ */
+export interface HonuaInteractionLayerComponent {
+    /** MapLibre-style interactive map this layer renders on — the event source for `featureSelect`/`featureHover`. */
+    readonly map?: InteractiveMap;
+    /** Source id feature-state is written to. Defaults to the ref's id. */
+    readonly sourceId?: SourceId;
+    /** Rendered layer id clicks/hovers are observed on. Defaults to the ref's id. */
+    readonly layerId?: string;
+    /** Source layer, for vector-tile sources. */
+    readonly sourceLayer?: string;
+    /** Select multiple features rather than replacing on each click. @default false */
+    readonly multiSelect?: boolean;
+    /** `setVisibility` target. */
+    setVisibility?(visible: boolean): void;
+    /** `setFilter` target. When absent, `setFilter` falls back to the shared exploration filter keyed by this ref's id. */
+    setFilter?(clause: FilterClause | undefined): void;
+}
+export interface HonuaInteractionViewport {
+    readonly bbox?: readonly [number, number, number, number];
+    readonly center?: readonly [number, number];
+    readonly zoom?: number;
+    readonly pitch?: number;
+    readonly bearing?: number;
+}
+/** The `map` component. */
+export interface HonuaInteractionMapComponent {
+    /**
+     * `setViewport` target. When absent, `setViewport` falls back to the
+     * exploration view's `setExtent` for `bbox`-shaped arguments.
+     */
+    setViewport?(viewport: HonuaInteractionViewport): void;
+}
+/** A widget addressed as `widget:{id}`. */
+export interface HonuaInteractionWidgetComponent {
+    /** `runWidgetQuery` target. There is no exploration-level fallback for this verb. */
+    runQuery?(request: Readonly<Record<string, unknown>>): void;
+    /** `setFilter` target. When absent, falls back to the shared exploration filter keyed by this ref's id. */
+    setFilter?(clause: FilterClause | undefined): void;
+    /** `setVisibility` target. */
+    setVisibility?(visible: boolean): void;
+}
+/**
+ * A control addressed as `control:{id}`. A control's `change` event is read
+ * off the shared exploration filter slice keyed by the control's id — that is
+ * the same seam `bindFilterControlsToExploration` writes through, so a
+ * filter bar wired with that primitive needs no extra adapter here.
+ */
+export interface HonuaInteractionControlComponent {
+    /** `setVisibility` target. */
+    setVisibility?(visible: boolean): void;
+    /** `setFilter` target. When absent, falls back to the shared exploration filter keyed by this ref's id. */
+    setFilter?(clause: FilterClause | undefined): void;
+}
+/**
+ * The components an `interactions[]` block's refs resolve against. A ref that
+ * resolves to no component is a validation failure (`unresolved-ref`), matching
+ * the standard's "an implementation MUST reject a binding whose `ref` does not
+ * resolve within the document".
+ *
+ * `control:` and `widget:` refs may be declared with an empty object when the
+ * component needs no adapter — their events and their `setFilter` action both
+ * run through the shared exploration view.
+ */
+export interface HonuaInteractionComponents {
+    readonly map?: HonuaInteractionMapComponent;
+    readonly layers?: Readonly<Record<string, HonuaInteractionLayerComponent>>;
+    readonly widgets?: Readonly<Record<string, HonuaInteractionWidgetComponent>>;
+    readonly controls?: Readonly<Record<string, HonuaInteractionControlComponent>>;
+}
+/** One binding this runtime cannot honor, with the pair named. */
+export interface HonuaUnsupportedInteraction {
+    readonly interactionId: string;
+    readonly on: {
+        readonly ref: string;
+        readonly event: HonuaInteractionEvent;
+    };
+    readonly do: {
+        readonly ref: string;
+        readonly verb: HonuaInteractionVerb;
+    };
+    /** `"{event} -> {verb}"`, the pair as the standard spells it. */
+    readonly pair: string;
+    readonly reason: string;
+}
+/** One binding that compiled onto a primitive. */
+export interface HonuaCompiledInteractionBinding {
+    readonly interactionId: string;
+    readonly on: {
+        readonly ref: string;
+        readonly event: HonuaInteractionEvent;
+    };
+    readonly do: {
+        readonly ref: string;
+        readonly verb: HonuaInteractionVerb;
+    };
+    readonly pair: string;
+    /** Disposes just this binding. Idempotent. */
+    dispose(): void;
+}
+export interface HonuaCompiledInteractions {
+    /** True when the block validated and every non-disabled binding compiled. */
+    readonly ok: boolean;
+    /** Validation failures. When non-empty, nothing was bound. */
+    readonly issues: ReadonlyArray<HonuaInteractionIssue>;
+    readonly bindings: ReadonlyArray<HonuaCompiledInteractionBinding>;
+    readonly unsupported: ReadonlyArray<HonuaUnsupportedInteraction>;
+    /** Interaction ids skipped because `disabled: true`. */
+    readonly disabled: ReadonlyArray<string>;
+    /** Disposes every compiled binding. Idempotent. */
+    dispose(): void;
+}
+export interface CompileHonuaInteractionsOptions {
+    /**
+     * The exploration view this compiler owns — every action verb writes
+     * through it, and every exploration-backed event source subscribes on it.
+     *
+     * **Pass a view bound for the compiler alone** (`ctx.connectView({ id:
+     * "interactions", role: "custom" })`), not a view a widget also dispatches
+     * through. That is what makes "actions never emit events" structural rather
+     * than best-effort: an `ExplorationViewController` delivers a bound view its
+     * own notifications only under `includeSelf`, so a state change this
+     * compiler originated is never routed back into this compiler, while a real
+     * user gesture published by any *other* view is.
+     */
+    readonly view: ExplorationViewController;
+    readonly components?: HonuaInteractionComponents;
+    /** Per-(`on.ref`, `on.event`) fan-out cap. @default 8 */
+    readonly fanOutCap?: number;
+    /**
+     * Observes each dispatched action. Called after the verb ran; never called
+     * for a suppressed (action-originated) event, which is the whole point of
+     * "actions never emit events".
+     */
+    readonly onDispatch?: (dispatch: HonuaInteractionDispatch) => void;
+}
+export interface HonuaInteractionDispatch {
+    readonly interactionId: string;
+    readonly event: HonuaInteractionEvent;
+    readonly verb: HonuaInteractionVerb;
+    readonly ref: string;
+    /** Arguments after `$event.*` substitution. */
+    readonly args: Readonly<Record<string, unknown>>;
+}
+/**
+ * Compiles an `interactions[]` block onto live components. Returns disposers;
+ * never throws for a bad document — a malformed or over-cap block comes back
+ * as `{ ok: false, issues }` with nothing bound.
+ */
+export declare function compileHonuaInteractions(interactions: unknown, options: CompileHonuaInteractionsOptions): HonuaCompiledInteractions;
+//# sourceMappingURL=declarative.d.ts.map

package/interactions/declarative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarative.d.ts","sourceRoot":"","sources":["../../../src/interactions/declarative.ts"],"names":[],"mappings":"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"}