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

package/dist/types/core/schemas/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/schemas/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/schemas/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/schemas/settings.d.ts

@@ -0,0 +1,27 @@
+/** 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 fieldList: {
+            readonly title: 'Fields';
+            readonly type: 'array';
+            readonly items: {
+                readonly type: 'string';
+                readonly minLength: 1;
+            };
+            readonly uniqueItems: true;
+        };
+    };
+};

package/dist/types/core/schemas/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/schemas/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/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,7 @@
+/**
+ * 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 { MAP_VIEW_SCHEMAS, type MapViewDefinition, MapViewDefinitionError, mapViewsForSchema, type ParameterValues, parseMapViewDefinition, resolveParameterValues, selectionFilter, } from './core';
+export { MapView } from './layouts/MapView';
+export { ParameterControls } from './layouts/ParameterControls';

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

@@ -0,0 +1,36 @@
+import type { Orientation } from '../core';
+/**
+ * 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';
+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,12 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import { type MapViewDefinition, type ParameterValues } from '../core';
+type Props = {
+    definition: MapViewDefinition;
+    graph: SpaceGraph;
+    /** Current parameter values (host-owned session state); missing values use defaults. */
+    values?: ParameterValues;
+    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, 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';
+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, type ParameterValues } from '../core';
+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;
+};
+/**
+ * Controls generated from a map view's declared parameters. Hosts own the values (session
+ * state) and decide where the controls go.
+ */
+export declare function ParameterControls({ definition, values, onChange }: Props): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,16 @@
+import type { SpaceGraph, SpaceNode } from 'structured-context/api';
+import { type LayoutConfig, type Region, type TreeLayoutConfig } from '../core';
+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';
+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/node/bundled-definitions.d.ts

@@ -0,0 +1 @@
+export declare const BUNDLED_DEFINITIONS: Record<string, string>;

package/dist/types/node/index.d.ts

@@ -0,0 +1,17 @@
+import { type Config } from 'structured-context/api';
+import { type MapViewDefinition } from '../core';
+export type LoadMapViewDefinitionsOptions = {
+    /** Directory of the main config file. Defaults to where structured-context finds it. */
+    configDir?: string;
+};
+/**
+ * Every map view definition available with `config`, from:
+ * - this package's embedded definitions (`sctx-map-view://core/<name>`), for structured-context's bundled schemas;
+ * - each plugin found from a config folder or named by a space (`sctx-map-view://<plugin>/<name>`): the
+ *   folder named by `"sctx": { "mapViews": "…" }` in its package.json, else its `map-views/` folder;
+ * - a `map-views/` folder next to each config file (`sctx-map-view://<name>`).
+ *
+ * Each definition's `$id` must be in the namespace of where it was found, and ids must be unique.
+ * Throws on the first invalid definition.
+ */
+export declare function loadMapViewDefinitions(config: Config, options?: LoadMapViewDefinitionsOptions): MapViewDefinition[];

package/package.json

@@ -1,6 +1,71 @@
 {
   "name": "structured-context-map-views",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Declarative map views of structured-context spaces: render a space as a tree, nested containers or an XY plot from a short definition.",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mindsocket/structured-context-map-views.git",
+    "directory": "packages/map-views"
+  },
+  "homepage": "https://github.com/mindsocket/structured-context-map-views#readme",
+  "bugs": "https://github.com/mindsocket/structured-context-map-views/issues",
+  "keywords": [
+    "structured-context",
+    "visualisation",
+    "map-view",
+    "react"
+  ],
+  "files": [
+    "dist/"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/types/node/index.d.ts",
+      "default": "./dist/node.js"
+    },
+    "./styles.css": "./dist/styles.css"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "generate": "bun run generate:schemas && bun run generate:definitions",
+    "generate:schemas": "bun scripts/generate-schemas.ts",
+    "generate:definitions": "bun scripts/generate-definitions.ts",
+    "build": "bun run clean && bun run generate && bun --bun vite build && tsc -p tsconfig.build.json && tailwindcss -i src/layouts/styles.css -o dist/styles.css",
+    "typecheck": "tsc --noEmit",
+    "capture-fixtures": "bun scripts/capture-fixtures.ts",
+    "test": "bun test",
+    "test:package": "bash scripts/test-package.sh",
+    "prepublishOnly": "bun run build",
+    "preversion": "bun run generate && bun run --cwd ../.. lint:fix && bun run --cwd ../.. test && bun run test:package",
+    "version": "bun run generate:schemas --release && git add -A"
+  },
+  "peerDependencies": {
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "structured-context": "^0.17.1"
+  },
+  "dependencies": {
+    "ajv": "^8.20.0",
+    "json-schema-to-ts": "^3.1.1",
+    "json5": "^2.2.3"
+  },
+  "devDependencies": {
+    "@tailwindcss/cli": "^4.3.3",
+    "@types/node": "^22.20.5",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@vitejs/plugin-react": "^6.1.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "structured-context": "^0.17.1",
+    "tailwindcss": "^4.3.3",
+    "vite": "^8.3.2"
+  }
+}