structured-context-map-views 0.0.0-stage → 0.2.0

package/dist/types/core/format/landscape-layout.d.ts

@@ -0,0 +1,102 @@
+/** Settings of the landscape layout: nested containers following an authored grouping. */
+export declare const landscapeLayoutSchema: {
+    readonly $schema: 'https://json-schema.org/draft/2020-12/schema';
+    readonly $id: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/landscape.json";
+    readonly title: 'Landscape layout';
+    readonly description: 'Nested containers: each grouping level becomes containers inside the level above, and the last level is drawn as nodes.';
+    readonly type: 'object';
+    readonly required: readonly ['type', 'group'];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly type: {
+            readonly const: 'landscape';
+        };
+        readonly orientation: {
+            readonly description: string;
+            readonly default: "horizontal";
+            readonly anyOf: readonly [{
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/settings.json#/$defs/orientation";
+            }, {
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+            }];
+        };
+        readonly group: {
+            readonly type: 'array';
+            readonly minItems: 1;
+            readonly description: 'Grouping levels, outermost first. The last level is drawn as nodes; the others as containers. Adjacent node levels are joined by any edge between their types, in either direction.';
+            readonly items: {
+                readonly type: 'object';
+                readonly if: {
+                    readonly type: 'object';
+                    readonly required: readonly ['field'];
+                };
+                readonly then: {
+                    readonly type: 'object';
+                    readonly description: "Containers labelled by the values of a field of the next node level's nodes. A node with several values appears under each.";
+                    readonly required: readonly ['field'];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly field: {
+                            readonly type: 'string';
+                            readonly minLength: 1;
+                        };
+                    };
+                };
+                readonly else: {
+                    readonly type: 'object';
+                    readonly description: 'A level of nodes of one type.';
+                    readonly required: readonly ['type'];
+                    readonly additionalProperties: false;
+                    readonly properties: {
+                        readonly type: {
+                            readonly description: 'Node type at this level.';
+                            readonly anyOf: readonly [{
+                                readonly type: 'string';
+                                readonly minLength: 1;
+                            }, {
+                                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+                            }];
+                        };
+                        readonly edge: {
+                            readonly type: 'object';
+                            readonly description: 'Which edges join this level to the node level above (or to the last `via` type). By default, any edge between the two types.';
+                            readonly required: readonly ['field'];
+                            readonly additionalProperties: false;
+                            readonly properties: {
+                                readonly field: {
+                                    readonly type: 'string';
+                                    readonly minLength: 1;
+                                };
+                            };
+                        };
+                        readonly via: {
+                            readonly type: 'array';
+                            readonly minItems: 1;
+                            readonly description: 'Types skipped between the node level above and this one, in order. Nodes are joined through a chain of edges across them. Ignored on the first level, which has no level above.';
+                            readonly items: {
+                                readonly type: 'string';
+                                readonly minLength: 1;
+                            };
+                        };
+                        readonly intermediate: {
+                            readonly description: string;
+                            readonly default: "hidden";
+                            readonly anyOf: readonly [{
+                                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/landscape.json#/$defs/intermediate";
+                            }, {
+                                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+                            }];
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly $defs: {
+        readonly intermediate: {
+            readonly title: 'Skipped levels';
+            readonly description: 'hidden: not shown. breadcrumb: listed on each node reached through them.';
+            readonly enum: readonly ['hidden', 'breadcrumb'];
+        };
+    };
+};

package/dist/types/core/format/param-ref.d.ts

@@ -0,0 +1,10 @@
+/** `$ref` target for a setting whose value comes from a declared parameter. */
+export declare const PARAM_REF: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+/** A setting that takes either a fixed value matching `valueSchema` or a `{ $param }` binding. */
+export declare function parameterisable<const S extends object, const D>(valueSchema: S, defaultValue: D, description: string): {
+    readonly description: string;
+    readonly default: D;
+    readonly anyOf: readonly [S, {
+        readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+    }];
+};

package/dist/types/core/format/schema-url.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Where the format schemas are published. `latest` follows the newest format; a release that changes it
+ * freezes a copy under its own version folder (`bun run generate:schemas --release`).
+ */
+export declare const SCHEMA_BASE_URL = "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated";
+/** Base of the `$id`s the sources use: the `latest` folder. */
+export declare const SCHEMA_URL: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest";

package/dist/types/core/format/settings.d.ts

@@ -0,0 +1,41 @@
+/** Reusable setting definitions. Parameters can `$ref` these and narrow them, e.g. with `allOf` and `enum`. */
+export declare const settingsSchema: {
+    readonly $schema: 'https://json-schema.org/draft/2020-12/schema';
+    readonly $id: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/settings.json";
+    readonly title: 'Shared map view settings';
+    readonly description: 'Reusable setting definitions. Parameters can $ref these and narrow them, e.g. with allOf and enum.';
+    readonly $defs: {
+        readonly orientation: {
+            readonly title: 'Orientation';
+            readonly enum: readonly ['vertical', 'horizontal'];
+        };
+        readonly nodeStyle: {
+            readonly title: 'Node style';
+            readonly description: 'card: a box with the title and selected fields. shape: a compact marker with a tooltip.';
+            readonly enum: readonly ['card', 'shape'];
+        };
+        readonly validationLevel: {
+            readonly title: 'Validation overlay';
+            readonly description: 'The lowest severity of validation result shown on nodes, or off. error: only errors. warning: errors and warnings. info: everything.';
+            readonly enum: readonly ['off', 'error', 'warning', 'info'];
+        };
+        readonly validationSources: {
+            readonly title: 'Validation sources';
+            readonly description: 'Which kinds of validation result are shown. schema: a node failing its schema. hierarchy: a node under a parent type it is not allowed under. rule: a schema rule violation.';
+            readonly type: 'array';
+            readonly items: {
+                readonly enum: readonly ['schema', 'hierarchy', 'rule'];
+            };
+            readonly uniqueItems: true;
+        };
+        readonly fieldList: {
+            readonly title: 'Fields';
+            readonly type: 'array';
+            readonly items: {
+                readonly type: 'string';
+                readonly minLength: 1;
+            };
+            readonly uniqueItems: true;
+        };
+    };
+};

package/dist/types/core/format/tree-layout.d.ts

@@ -0,0 +1,40 @@
+/** Settings of the tree layout: a tree over the schema's hierarchy. */
+export declare const treeLayoutSchema: {
+    readonly $schema: 'https://json-schema.org/draft/2020-12/schema';
+    readonly $id: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/tree.json";
+    readonly title: 'Tree layout';
+    readonly description: "A tree over the schema's hierarchy: root-type nodes at the top, children via hierarchy edges.";
+    readonly type: 'object';
+    readonly required: readonly ['type'];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly type: {
+            readonly const: 'tree';
+        };
+        readonly orientation: {
+            readonly description: string;
+            readonly default: "vertical";
+            readonly anyOf: readonly [{
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/settings.json#/$defs/orientation";
+            }, {
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+            }];
+        };
+        readonly dag: {
+            readonly description: string;
+            readonly default: "repeat";
+            readonly anyOf: readonly [{
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/tree.json#/$defs/dag";
+            }, {
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+            }];
+        };
+    };
+    readonly $defs: {
+        readonly dag: {
+            readonly title: 'Nodes with several parents';
+            readonly description: 'repeat: the node appears under each parent, its subtree shown once. cross-edge: the node appears under its first parent, with extra connectors from the others.';
+            readonly enum: readonly ['repeat', 'cross-edge'];
+        };
+    };
+};

package/dist/types/core/format/xy-layout.d.ts

@@ -0,0 +1,94 @@
+/** Settings of the XY layout: nodes positioned by two numeric fields. */
+export declare const xyLayoutSchema: {
+    readonly $schema: 'https://json-schema.org/draft/2020-12/schema';
+    readonly $id: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/xy.json";
+    readonly title: 'XY layout';
+    readonly description: 'Nodes positioned on two axes by numeric fields. Nodes of the plotted types without a usable value on both axes are listed beside the plot, not dropped.';
+    readonly type: 'object';
+    readonly required: readonly ['type', 'x', 'y'];
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly type: {
+            readonly const: 'xy';
+        };
+        readonly x: {
+            readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/xy.json#/$defs/axis";
+        };
+        readonly y: {
+            readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/xy.json#/$defs/axis";
+        };
+        readonly types: {
+            readonly description: string;
+            readonly default: readonly [];
+            readonly anyOf: readonly [{
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly uniqueItems: true;
+            }, {
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+            }];
+        };
+        readonly edgeFields: {
+            readonly description: string;
+            readonly default: readonly [];
+            readonly anyOf: readonly [{
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/settings.json#/$defs/fieldList";
+            }, {
+                readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+            }];
+        };
+    };
+    readonly $defs: {
+        readonly axis: {
+            readonly title: 'Axis';
+            readonly type: 'object';
+            readonly required: readonly ['field'];
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly field: {
+                    readonly description: 'Numeric field giving the position.';
+                    readonly anyOf: readonly [{
+                        readonly type: 'string';
+                        readonly minLength: 1;
+                    }, {
+                        readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+                    }];
+                };
+                readonly domain: {
+                    readonly description: 'Values at the two ends of the axis: [min, max], or "data" for the smallest and largest plotted values. Nodes outside a fixed domain are listed as unplaced.';
+                    readonly default: 'data';
+                    readonly anyOf: readonly [{
+                        readonly const: 'data';
+                    }, {
+                        readonly type: 'array';
+                        readonly items: {
+                            readonly type: 'number';
+                        };
+                        readonly minItems: 2;
+                        readonly maxItems: 2;
+                    }];
+                };
+                readonly direction: {
+                    readonly description: string;
+                    readonly default: "ascending";
+                    readonly anyOf: readonly [{
+                        readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/layouts/xy.json#/$defs/direction";
+                    }, {
+                        readonly $ref: "https://raw.githubusercontent.com/mindsocket/structured-context-map-views/main/schemas/generated/latest/definition.json#/$defs/paramRef";
+                    }];
+                };
+                readonly label: {
+                    readonly type: 'string';
+                    readonly description: 'Axis title. Defaults to the field name.';
+                };
+            };
+        };
+        readonly direction: {
+            readonly title: 'Axis direction';
+            readonly enum: readonly ['ascending', 'descending'];
+        };
+    };
+};

package/dist/types/core/graph.d.ts

@@ -0,0 +1,16 @@
+import type { Hierarchy, SpaceGraph, SpaceNode } from 'structured-context/api';
+type NodeId = SpaceNode['id'];
+/** A directed parent → child edge of a space graph, carrying the metadata of the reference it came from. */
+export type Edge = SpaceGraph['parentEdges'] extends ReadonlyMap<string, readonly (infer E)[]> ? E : never;
+/**
+ * Edges to a node's parents, in the order the node declares them. A graph narrowed by a filter keeps
+ * edges to parents outside it; those are left out.
+ */
+export declare function parentEdges(graph: SpaceGraph, id: NodeId): readonly Edge[];
+/** Edges to a node's children, in graph order of the children. */
+export declare function childEdges(graph: SpaceGraph, id: NodeId): readonly Edge[];
+/** Every edge whose parent and child are both in the graph. */
+export declare function edgesWithin(graph: SpaceGraph): Edge[];
+/** Whether an edge belongs to the given hierarchy (as opposed to a relationship or another hierarchy). */
+export declare function isHierarchyEdge(edge: Edge, hierarchy: Hierarchy | undefined): boolean;
+export {};

package/dist/types/core/landscape.d.ts

@@ -0,0 +1,44 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import type { LandscapeLayoutConfig } from './definition';
+/** One rendered container or node in a landscape. */
+export type LandscapeOccurrence = {
+    /** Path-based key, unique within the map view (see {@link occurrenceKey}). */
+    key: string;
+    /** Index of the grouping level this occurrence belongs to. */
+    level: number;
+    /** A node, or a field value shared by the nodes inside (`null`: the field is empty). */
+    item: {
+        kind: 'node';
+        node: SpaceNode;
+    } | {
+        kind: 'value';
+        field: string;
+        value: string | null;
+    };
+    /** Nodes on the `via` chain that joined this node to the node level above, one entry per skipped type. */
+    via: ViaStep[];
+    /** Key of the node's first occurrence when this is a repeat. Repeats are rendered in full. */
+    repeatOf?: string;
+    children: LandscapeOccurrence[];
+};
+export type ViaStep = {
+    type: string;
+    nodes: SpaceNode[];
+};
+export type Landscape = {
+    groups: LandscapeOccurrence[];
+    /**
+     * Nodes of a grouped level that no container above reaches (e.g. an Activity with no
+     * Outcome when grouping by Outcomes), each with its own contents.
+     */
+    ungrouped: LandscapeOccurrence[];
+};
+/**
+ * Lay a space out as nested containers following the layout's grouping levels.
+ *
+ * Adjacent node levels are joined by any edge between their types, in either direction, or only
+ * edges from `edge.field`. A `via` chain joins them through the skipped types. A field level
+ * splits the next node level by that field's values. A node reached from several containers
+ * appears in each, in full: the levels are finite, so repeating contents can't recurse.
+ */
+export declare function buildLandscape(graph: SpaceGraph, regionId: string, layout: LandscapeLayoutConfig): Landscape;

package/dist/types/core/occurrence.d.ts

@@ -0,0 +1,11 @@
+/**
+ * One step of an occurrence path: a node title, a `[field, value]` group, or `null` for the
+ * ungrouped area. Encoded distinctly, so a field group can't collide with a node of the same name.
+ */
+export type PathSegment = string | readonly [field: string, value: string | null] | null;
+/**
+ * Path-based key for one occurrence of a node: region, then the steps from the outermost
+ * container down to the node. Unique within a map view even when a node appears several times.
+ * Hosts can render several map views at once, so layouts scope keys to the map view instance.
+ */
+export declare function occurrenceKey(regionId: string, path: readonly PathSegment[]): string;

package/dist/types/core/tree.d.ts

@@ -0,0 +1,45 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import type { DagMode } from './definition';
+/** One rendered appearance of a node in a tree. */
+export type TreeOccurrence = {
+    /** Path-based key, unique within the map view (see {@link occurrenceKey}). */
+    key: string;
+    node: SpaceNode;
+    children: TreeOccurrence[];
+    /**
+     * Key of the node's primary occurrence when this is a repeat. A node with several parents
+     * appears under each of them, but its subtree is only rendered at its first occurrence.
+     */
+    repeatOf?: string;
+};
+export type Tree = {
+    roots: TreeOccurrence[];
+    /**
+     * Hierarchy-typed nodes not reachable from a root, rendered as extra roots: nodes with no
+     * hierarchy parent in the space, then entry points into otherwise unreachable cycles.
+     */
+    orphans: TreeOccurrence[];
+    /** Key of each node's primary (first, fully rendered) occurrence. */
+    primary: ReadonlyMap<string, string>;
+    /**
+     * In cross-edge mode, links from a node's other parents to its primary occurrence, which
+     * replace repeat occurrences. Empty in repeat mode.
+     */
+    crossLinks: TreeLink[];
+};
+export type TreeLink = {
+    from: string;
+    to: string;
+    kind: 'tree' | 'cross';
+};
+/**
+ * Lay a space out as a tree over its hierarchy.
+ *
+ * Roots are root-type nodes with no hierarchy parent. Traversal is depth-first in space order,
+ * so a node's primary occurrence is under the parent reached first. Under its other parents a
+ * node is either repeated without its subtree (`repeat`), or left out and linked by a cross-edge
+ * (`cross-edge`). Either way traversal stops there, which also keeps cycles from recursing.
+ */
+export declare function buildTree(graph: SpaceGraph, regionId: string, dag?: DagMode): Tree;
+/** Parent → child pairs of occurrence keys: one per rendered parent-child link, then cross-links. */
+export declare function treeLinks(tree: Tree): TreeLink[];

package/dist/types/core/xy.d.ts

@@ -0,0 +1,43 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import type { XYLayoutConfig } from './definition';
+/** A plotted node. `x` and `y` run from 0 to 1 across the plot, left to right and bottom to top. */
+export type XYPoint = {
+    key: string;
+    node: SpaceNode;
+    x: number;
+    y: number;
+};
+/** Why a node of a plotted type couldn't be placed, per axis. */
+export type Unplaced = {
+    key: string;
+    node: SpaceNode;
+    reasons: string[];
+};
+/**
+ * An edge between plotted nodes. `lane` separates edges joining the same two nodes: 0 when
+ * there's one, otherwise centred around 0 (e.g. -0.5 and 0.5), for layouts to draw side by side.
+ */
+export type XYLink = {
+    from: string;
+    to: string;
+    field: string;
+    hierarchy: boolean;
+    lane: number;
+};
+export type XYPlot = {
+    points: XYPoint[];
+    unplaced: Unplaced[];
+    /** Edges between plotted nodes. */
+    links: XYLink[];
+    /** Each axis's [min, max]; `direction` says which end is drawn where. */
+    domains: {
+        x: readonly [number, number];
+        y: readonly [number, number];
+    };
+};
+/**
+ * Position nodes by two numeric fields. Every node of a plotted type appears once: on the plot
+ * when both its values are numbers inside the axes' domains, otherwise in `unplaced` with the
+ * reason. Positions are normalised; layouts decide the plot's size.
+ */
+export declare function buildXYPlot(graph: SpaceGraph, regionId: string, layout: XYLayoutConfig): XYPlot;

package/dist/types/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The package's public surface. Everything else (layouts, node cards, the edge overlay, the projections)
+ * is internal; add an export here when a host needs it.
+ */
+export { type AnnotationIndex, type AnnotationSource, annotationsFrom, type NodeAnnotation, type Severity, type UnattachedAnnotation, type ValidationInput, worstSeverity, } from './core/annotations';
+export { MAP_VIEW_SCHEMAS, type MapViewDefinition, MapViewDefinitionError, mapViewsForSchema, type Parameter, type ParameterControl, type ParameterValues, parseMapViewDefinition, resolveParameterValues, selectionFilter, viewValidationLevel, } from './core/definition';
+export { MapView } from './layouts/MapView';
+export { ParameterControls } from './layouts/ParameterControls';
+export { MultiSelectParameterInput, ParameterInput, SelectParameterInput, ToggleParameterInput, } from './layouts/ParameterInputs';
+export { type ParameterControlState, useParameterControls } from './layouts/useParameterControls';

package/dist/types/layouts/EdgeOverlay.d.ts

@@ -0,0 +1,36 @@
+import type { Orientation } from '../core/definition';
+/**
+ * A connector between two occurrences. `cross` links (e.g. extra parents) are drawn dashed.
+ * `id` tells apart several links between the same occurrences; straight links between the same
+ * pair are drawn side by side, `lane` apart (0: on the line between centres).
+ */
+export type Link = {
+    from: string;
+    to: string;
+    kind?: 'tree' | 'cross';
+    id?: string;
+    lane?: number;
+};
+type Props = {
+    links: readonly Link[];
+    /** Rendered element of each occurrence, by occurrence key. */
+    elements: ReadonlyMap<string, HTMLElement>;
+    /**
+     * Positioned element the overlay covers; coordinates are relative to it. Passed as an element,
+     * not a ref: the overlay sits inside it, and React runs a child's layout effects before
+     * attaching the parent's ref.
+     */
+    container: HTMLElement | null;
+    /** Curves leaving along the tree's orientation, or straight lines between centres (drawn under the nodes). */
+    routing: Orientation | 'straight';
+};
+/**
+ * SVG layer drawing connectors between rendered occurrences.
+ *
+ * Measures occurrence elements after layout and redraws when the container or any occurrence
+ * resizes, so it follows embedded panes that resize independently of the window, and reflows
+ * such as late font loads. The SVG fills the container instead of being sized from it, so it
+ * never holds the container open after the layout shrinks.
+ */
+export declare function EdgeOverlay({ links, elements, container, routing }: Props): import("react").JSX.Element;
+export {};

package/dist/types/layouts/LandscapeLayout.d.ts

@@ -0,0 +1,8 @@
+import type { LandscapeLayoutConfig } from '../core/definition';
+import type { LayoutProps } from './TreeLayout';
+/**
+ * Nested containers following the layout's grouping levels; the last level is drawn as nodes.
+ * Flexbox does the nesting and wrapping. Containment shows the grouping edges, so no connectors
+ * are drawn. PROTOTYPE: `edges.show` has no effect here; other edges aren't drawn yet.
+ */
+export declare function LandscapeLayout({ graph, region, instanceId, onNodeSelect }: LayoutProps<LandscapeLayoutConfig>): import("react").JSX.Element;

package/dist/types/layouts/MapView.d.ts

@@ -0,0 +1,18 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import { type AnnotationIndex } from '../core/annotations';
+import { type MapViewDefinition, type ParameterValues } from '../core/definition';
+type Props = {
+    definition: MapViewDefinition;
+    graph: SpaceGraph;
+    /** Current parameter values (host-owned session state); missing values use defaults. */
+    values?: ParameterValues;
+    /**
+     * Validation results by node (see `annotationsFrom`). Which of them show, and at what severity, is
+     * the region's `nodes.validation` setting; with none supplied, nothing is drawn.
+     */
+    annotations?: AnnotationIndex;
+    onNodeSelect?: (node: SpaceNode) => void;
+};
+/** Renders a map view definition against a space. Sizes to its container and scrolls within it. */
+export declare function MapView({ definition, graph, values, annotations, onNodeSelect }: Props): import("react").JSX.Element;
+export {};

package/dist/types/layouts/NodeCard.d.ts

@@ -0,0 +1,16 @@
+import type { SpaceNode } from 'structured-context/api';
+import type { NodesConfig } from '../core/definition';
+type Props = {
+    node: SpaceNode;
+    /** The node's subtree is rendered at another occurrence. */
+    repeat: boolean;
+    nodes: NodesConfig;
+    onSelect?: (node: SpaceNode) => void;
+};
+/**
+ * A clickable node, drawn as a card (title plus selected fields) or a compact shape with a
+ * tooltip. Deliberately a `div` with button semantics rather than a `<button>`: hosts style
+ * native form controls globally (Obsidian fixes button height and disables wrapping).
+ */
+export declare function NodeCard({ node, repeat, nodes, onSelect }: Props): import("react").JSX.Element;
+export {};

package/dist/types/layouts/ParameterControls.d.ts

@@ -0,0 +1,13 @@
+import type { MapViewDefinition, ParameterValues } from '../core/definition';
+type Props = {
+    definition: MapViewDefinition;
+    /** Host-owned values; missing or stale ones show as the default, matching what renders. */
+    values: ParameterValues;
+    onChange: (name: string, value: unknown) => void;
+};
+/**
+ * Default layout for a map view's parameter controls: a wrapping row. Hosts wanting their own layout
+ * use `useParameterControls` with `ParameterInput` (or the typed inputs) instead.
+ */
+export declare function ParameterControls({ definition, values, onChange }: Props): import("react").JSX.Element | null;
+export {};

package/dist/types/layouts/ParameterInputs.d.ts

@@ -0,0 +1,21 @@
+import type { Parameter, ParameterControl } from '../core/definition';
+type InputProps<Kind extends ParameterControl['kind']> = {
+    parameter: Parameter & {
+        control: Extract<ParameterControl, {
+            kind: Kind;
+        }>;
+    };
+    value: unknown;
+    onChange: (value: unknown) => void;
+};
+/** A checkbox for a boolean parameter, labelled with the parameter's title. */
+export declare function ToggleParameterInput({ parameter, value, onChange }: InputProps<'toggle'>): import("react").JSX.Element;
+/** A dropdown for a parameter with one of several options. */
+export declare function SelectParameterInput({ parameter, value, onChange }: InputProps<'select'>): import("react").JSX.Element;
+/** A checkbox group for a parameter taking any subset of its options. */
+export declare function MultiSelectParameterInput({ parameter, value, onChange }: InputProps<'multiselect'>): import("react").JSX.Element;
+/** The input matching a parameter's control kind. */
+export declare function ParameterInput({ parameter, value, onChange, }: Omit<InputProps<ParameterControl['kind']>, 'parameter'> & {
+    parameter: Parameter;
+}): import("react").JSX.Element;
+export {};

package/dist/types/layouts/TreeLayout.d.ts

@@ -0,0 +1,16 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import type { LayoutConfig, Region, TreeLayoutConfig } from '../core/definition';
+export type LayoutProps<L extends LayoutConfig = LayoutConfig> = {
+    graph: SpaceGraph;
+    /** The region with parameter values applied, narrowed to the layout's own settings. */
+    region: Region & {
+        layout: L;
+    };
+    /** Scopes occurrence ids when several map views render in one document. */
+    instanceId: string;
+    onNodeSelect?: (node: SpaceNode) => void;
+};
+/**
+ * Tree over the schema's hierarchy. Flexbox does the branching; the SVG overlay draws connectors.
+ */
+export declare function TreeLayout({ graph, region, instanceId, onNodeSelect }: LayoutProps<TreeLayoutConfig>): import("react").JSX.Element;

package/dist/types/layouts/XYLayout.d.ts

@@ -0,0 +1,9 @@
+import type { XYLayoutConfig } from '../core/definition';
+import type { LayoutProps } from './TreeLayout';
+/**
+ * Nodes positioned by two numeric fields, with straight connectors between them. Positions are
+ * percentages of the plot area, which fills the container (scrolling below a minimum size). Nodes that can't be
+ * placed are listed under the plot with the reason.
+ * PROTOTYPE: labels may overlap where nodes sit close together; no collision handling.
+ */
+export declare function XYLayout({ graph, region, instanceId, onNodeSelect }: LayoutProps<XYLayoutConfig>): import("react").JSX.Element;

package/dist/types/layouts/annotations-context.d.ts

@@ -0,0 +1,4 @@
+import type { AnnotationIndex } from '../core/annotations';
+/** The annotations a map view shows, already narrowed by its validation settings. Read by node cards. */
+export declare const AnnotationsContext: import("react").Context<AnnotationIndex>;
+export declare const useAnnotations: () => AnnotationIndex;