@lensmap/document 0.2.0 → 0.3.0

package/dist/export-schema.js

@@ -1,9 +1,14 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, resolve } from "node:path";
-import { generateJSONSchema } from "./index.js";
+import { generateJSONSchema, generateVocabularyJSONSchema } from "./index.js";
 const target = process.argv[2];
 if (!target)
     throw new Error("Supply the generated schema's output filename.");
 const path = resolve(target);
 await mkdir(dirname(path), { recursive: true });
 await writeFile(path, `${JSON.stringify({ ...generateJSONSchema(), title: "Lensmap experimental v1", $comment: "Generated from the owning Zod input schema. Not a public compatibility promise; document-wide IDs/references are checked by the engine." }, null, 2)}\n`);
+if (process.argv[3]) {
+    const vocabulary = resolve(process.argv[3]);
+    await mkdir(dirname(vocabulary), { recursive: true });
+    await writeFile(vocabulary, `${JSON.stringify({ ...generateVocabularyJSONSchema(), title: "Lensmap experimental connection vocabulary", $comment: "Generated from the owning Zod input schema. Layered inheritance and CSS value semantics are checked by the engine." }, null, 2)}\n`);
+}

package/dist/index.d.ts

@@ -1,3 +1,7 @@
+import { type NodePresentation } from "./node-style.js";
+export type { NodePresentation, NodeStyleDeclaration } from "./node-style.js";
+import { type ConnectionPresentation, type ResolvedConnectionType, type VocabularyInput } from "./vocabulary.js";
+export * from "./vocabulary.js";
 import { z } from "zod";
 import { type ConnectionType } from "./v1/schema.js";
 export type { ConnectionType, LensmapDocument, Reference, RichNode, } from "./v1/schema.js";
@@ -5,10 +9,15 @@ export { ConnectionTypeSchema, DocumentSchema } from "./v1/schema.js";
 export declare function generateJSONSchema(): z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
     version: z.ZodLiteral<"v1">;
     frontmatter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    connection_types: z.ZodOptional<z.ZodType<import("./vocabulary.js").ConnectionTypeDeclarations, unknown, z.core.$ZodTypeInternals<import("./vocabulary.js").ConnectionTypeDeclarations, unknown>>>;
+    node_styles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>]>>>;
     nodes: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodType<import("./v1/schema.js").RichNode, unknown, z.core.$ZodTypeInternals<import("./v1/schema.js").RichNode, unknown>>]>>;
 }, z.core.$strict>>;
+export declare function generateVocabularyJSONSchema(): z.core.ZodStandardJSONSchemaPayload<z.ZodObject<{
+    connection_types: z.ZodType<import("./vocabulary.js").ConnectionTypeDeclarations, unknown, z.core.$ZodTypeInternals<import("./vocabulary.js").ConnectionTypeDeclarations, unknown>>;
+}, z.core.$strict>>;
 /** Read the edge from the inspected endpoint, independently of structural kind. */
-export declare function connectionWording(type: ConnectionType | undefined, direction: "outgoing" | "incoming"): string;
+export declare function connectionWording(type: ConnectionType | undefined, direction: "outgoing" | "incoming", presentation?: ConnectionPresentation): string;
 type AnchorThought = {
     readonly key: string;
     readonly id?: string;
@@ -39,6 +48,7 @@ export type Thought = {
         x: number;
         y: number;
     };
+    style?: NodePresentation;
     path: string;
     destination?: {
         kind: "map_link" | "external_link";
@@ -51,6 +61,7 @@ export type Connection = {
     to: string;
     kind: "branch" | "cross";
     type?: ConnectionType;
+    presentation?: ConnectionPresentation;
     path: string;
 };
 export type SemanticGraph = {
@@ -66,8 +77,11 @@ export type Binding = {
 export type Diagnostic = {
     message: string;
     range: SourceRange;
+    uri?: string;
 };
 export type DocumentSnapshot = {
+    vocabulary?: Record<string, ResolvedConnectionType>;
+    graphGeneration?: number;
     attachmentId?: string;
     uri: string;
     revision: number;
@@ -98,6 +112,7 @@ export declare function positionToOffset(source: string, position: SourcePositio
 export declare function offsetToPosition(source: string, offset: number): SourcePosition;
 export declare class DocumentSession {
     readonly uri: string;
+    private vocabularyInput;
     private readonly attachmentId;
     private text;
     private version;
@@ -105,7 +120,8 @@ export declare class DocumentSession {
     private records;
     private validSource;
     private serial;
-    constructor(uri: string, source?: string, revision?: number);
+    constructor(uri: string, source?: string, revision?: number, vocabularyInput?: VocabularyInput);
+    setVocabulary(input: VocabularyInput): DocumentSnapshot;
     get source(): string;
     get revision(): number;
     receive(source: string, revision: number): DocumentSnapshot;

package/dist/index.js

@@ -1,3 +1,6 @@
+import { parseNodeStyle, resolveNodeStyle, } from "./node-style.js";
+import { resolveVocabulary, VocabularySchema, } from "./vocabulary.js";
+export * from "./vocabulary.js";
 import { isAlias, isMap, isScalar, parseDocument } from "yaml";
 import { z } from "zod";
 import { DocumentSchema, } from "./v1/schema.js";
@@ -5,8 +8,15 @@ export { ConnectionTypeSchema, DocumentSchema } from "./v1/schema.js";
 export function generateJSONSchema() {
     return z.toJSONSchema(DocumentSchema, { io: "input" });
 }
+export function generateVocabularyJSONSchema() {
+    return z.toJSONSchema(VocabularySchema, { io: "input" });
+}
 /** Read the edge from the inspected endpoint, independently of structural kind. */
-export function connectionWording(type, direction) {
+export function connectionWording(type, direction, presentation) {
+    if (presentation)
+        return direction === "outgoing"
+            ? presentation.text
+            : presentation.reverseText;
     switch (type) {
         case "precedes":
             return direction === "outgoing" ? "precedes" : "follows";
@@ -93,6 +103,7 @@ function rejectCycles(value, ancestors = new Set()) {
 }
 export class DocumentSession {
     uri;
+    vocabularyInput;
     attachmentId = `attachment:${++attachmentSerial}`;
     text;
     version;
@@ -100,8 +111,9 @@ export class DocumentSession {
     records = [];
     validSource = "";
     serial = 0;
-    constructor(uri, source = "", revision = 0) {
+    constructor(uri, source = "", revision = 0, vocabularyInput = {}) {
         this.uri = uri;
+        this.vocabularyInput = vocabularyInput;
         this.text = source;
         this.version = revision;
         this.state = {
@@ -118,6 +130,10 @@ export class DocumentSession {
         };
         this.analyze();
     }
+    setVocabulary(input) {
+        this.vocabularyInput = input;
+        return this.analyze();
+    }
     get source() {
         return this.text;
     }
@@ -182,6 +198,36 @@ export class DocumentSession {
                     .sort((a, b) => b.path.length - a.path.length)[0];
                 throw Object.assign(new Error(located?.issue.message ?? z.prettifyError(result.error)), { offset: located?.offset ?? 0 });
             }
+            const vocabulary = resolveVocabulary(this.vocabularyInput, result.data.connection_types, { source: this.text, uri: this.uri });
+            const definition = (type, offset = 0) => {
+                if (!Object.hasOwn(vocabulary, type))
+                    throw Object.assign(new Error(`Unknown connection type: ${type}. Available types: ${Object.keys(vocabulary).join(", ")}`), { offset });
+                return vocabulary[type];
+            };
+            const styleRules = new Map();
+            const ruleSyntax = doc.get("node_styles", true);
+            const resolvedRules = isAlias(ruleSyntax)
+                ? ruleSyntax.resolve(doc)
+                : ruleSyntax;
+            // JS objects reorder integer-looking keys. CSS rule order is the author's
+            // YAML order, not Object.entries order after structural validation.
+            const ruleNames = isMap(resolvedRules)
+                ? resolvedRules.items.map((pair) => String(isScalar(pair.key) ? pair.key.value : ""))
+                : Object.keys(result.data.node_styles ?? {});
+            for (const name of ruleNames) {
+                const style = result.data.node_styles?.[name];
+                if (style === undefined)
+                    continue;
+                try {
+                    styleRules.set(name, parseNodeStyle(style));
+                }
+                catch (error) {
+                    throw Object.assign(error instanceof Error ? error : new Error(String(error)), {
+                        offset: doc.getIn(["node_styles", name], true)
+                            ?.range?.[0] ?? 0,
+                    });
+                }
+            }
             const records = [];
             const edges = [];
             const bindings = [];
@@ -237,9 +283,19 @@ export class DocumentSession {
                     : Array.isArray(entry)
                         ? { full_text: null, connections: entry }
                         : entry;
-                const destination = (content.type === "map_link" || content.type === "external_link") &&
+                const coreKind = content.type === undefined
+                    ? "ordinary"
+                    : definition(content.type, span.start).coreKind;
+                if (!parent && content.type !== undefined && coreKind === "ordinary")
+                    throw Object.assign(new Error("Ordinary relationship types are not starting thoughts"), { offset: span.start });
+                if ((coreKind === "ordinary" && content.url !== undefined) ||
+                    (coreKind !== "ordinary" && content.url === undefined))
+                    throw Object.assign(new Error("Invalid portal definition"), {
+                        offset: span.start,
+                    });
+                const destination = (coreKind === "map_link" || coreKind === "external_link") &&
                     content.url !== undefined
-                    ? { kind: content.type, url: content.url }
+                    ? { kind: coreKind, url: content.url }
                     : undefined;
                 const fallback = content.summary === undefined && content.full_text === undefined
                     ? (destination?.url ?? "")
@@ -249,6 +305,20 @@ export class DocumentSession {
                     ? (content.summary ?? "")
                     : (content.full_text ?? fallback).split(/\r?\n/, 1)[0];
                 const key = `thought:${++this.serial}`;
+                let style;
+                try {
+                    style = resolveNodeStyle(content.classes, content.style, styleRules);
+                }
+                catch (error) {
+                    throw Object.assign(error instanceof Error ? error : new Error(String(error)), {
+                        offset: doc.getIn([
+                            ...path,
+                            content.classes?.some((name) => !styleRules.has(name))
+                                ? "classes"
+                                : "style",
+                        ], true)?.range?.[0] ?? span.start,
+                    });
+                }
                 const thought = {
                     key,
                     id: content.id,
@@ -258,6 +328,7 @@ export class DocumentSession {
                     position: content.position,
                     path: pathName,
                     ...(destination ? { destination } : {}),
+                    ...(style ? { style } : {}),
                 };
                 records.push({ thought, span, ast });
                 bindings.push({ key, kind: "definition", span });
@@ -337,9 +408,10 @@ export class DocumentSession {
                 const to = ids.get(ref.id);
                 if (!to)
                     throw Object.assign(new Error(`${ref.path}.node_id: no node has id "${ref.id}".`), { offset: ref.span.start });
-                if ((ref.type === "map_link" || ref.type === "external_link") &&
+                if (ref.type !== undefined &&
+                    definition(ref.type, ref.span.start).coreKind !== "ordinary" &&
                     records.find((r) => r.thought.key === to)?.thought.destination
-                        ?.kind !== ref.type)
+                        ?.kind !== definition(ref.type, ref.span.start).coreKind)
                     throw Object.assign(new Error(`${ref.path}.type: reference requires a ${ref.type} destination.`), { offset: ref.span.start });
                 const endpoints = `${ref.from}:${to}`;
                 const occurrence = parallelReferences.get(endpoints) ?? 0;
@@ -359,6 +431,11 @@ export class DocumentSession {
                     ownerKey: ref.from,
                 });
             }
+            for (const edge of edges)
+                if (edge.type !== undefined) {
+                    const { coreKind: _coreKind, ...presentation } = definition(edge.type);
+                    edge.presentation = presentation;
+                }
             this.records = records;
             this.validSource = this.text;
             this.state = {
@@ -367,6 +444,8 @@ export class DocumentSession {
                 revision: this.version,
                 analyzedRevision: this.version,
                 graphRevision: this.version,
+                graphGeneration: (this.state.graphGeneration ?? 0) + 1,
+                vocabulary,
                 valid: true,
                 pending: false,
                 graph: { nodes: records.map((r) => r.thought), edges },
@@ -378,6 +457,8 @@ export class DocumentSession {
             const offset = typeof error === "object" && error !== null && "offset" in error
                 ? Number(error.offset)
                 : 0;
+            const context = error;
+            const diagnosticSource = context?.source ?? this.text;
             this.state = {
                 ...this.state,
                 analyzedRevision: this.version,
@@ -387,7 +468,11 @@ export class DocumentSession {
                 diagnostics: [
                     {
                         message: error instanceof Error ? error.message : String(error),
-                        range: this.range({ start: offset, end: offset }),
+                        range: {
+                            start: offsetToPosition(diagnosticSource, offset),
+                            end: offsetToPosition(diagnosticSource, offset),
+                        },
+                        ...(context?.uri ? { uri: context.uri } : {}),
                     },
                 ],
             };
@@ -490,7 +575,7 @@ export class DocumentSession {
                 source.slice(0, change.start) +
                     change.newText +
                     source.slice(change.end);
-        const candidate = new DocumentSession(this.uri, source, this.version);
+        const candidate = new DocumentSession(this.uri, source, this.version, this.vocabularyInput);
         if (!candidate.snapshot().valid)
             throw new ContentEditError("invalid-edit", "Proposed content does not form a valid document.");
         return {

package/dist/node-style.d.ts

@@ -0,0 +1,17 @@
+import { z } from "zod";
+export type NodeStyleDeclaration = {
+    property: string;
+    value: string;
+    important: boolean;
+};
+export type NodePresentation = {
+    declarations: NodeStyleDeclaration[];
+    scale?: number | "auto";
+    icon?: string;
+};
+export declare const NodeStyleSchema: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>]>;
+export type NodeStyle = z.infer<typeof NodeStyleSchema>;
+/** Parse inert declarations only; never return authored stylesheet text. */
+export declare function parseNodeStyle(input: NodeStyle): NodeStyleDeclaration[];
+/** Low-to-high cascade order preserves shorthand interactions for browser application. */
+export declare function resolveNodeStyle(classes: string[] | undefined, inline: NodeStyle | undefined, rules: Map<string, NodeStyleDeclaration[]>): NodePresentation | undefined;

package/dist/node-style.js

@@ -0,0 +1,165 @@
+import * as css from "css-tree";
+import { z } from "zod";
+export const NodeStyleSchema = z.union([
+    z.string(),
+    z.record(z.string(), z.union([z.string(), z.number().finite()])),
+]);
+const properties = new Set([
+    "color",
+    "background-color",
+    "font-family",
+    "font-size",
+    "font-weight",
+    "font-style",
+    "line-height",
+    "border",
+    "border-color",
+    "border-width",
+    "border-style",
+    "padding",
+    ...["top", "right", "bottom", "left"].flatMap((side) => [
+        `padding-${side}`,
+        `border-${side}`,
+        `border-${side}-color`,
+        `border-${side}-width`,
+        `border-${side}-style`,
+    ]),
+]);
+const functions = new Set([
+    "rgb",
+    "rgba",
+    "hsl",
+    "hsla",
+    "hwb",
+    "lab",
+    "lch",
+    "oklab",
+    "oklch",
+    "color",
+    "color-mix",
+    "light-dark",
+]);
+function fail(message) {
+    throw new Error(`Node style: ${message}`);
+}
+const unsafeText = (text) => [...text].some((char) => char === "<" || char === ">" || char.charCodeAt(0) < 32);
+/** Parse inert declarations only; never return authored stylesheet text. */
+export function parseNodeStyle(input) {
+    const parse = (text) => {
+        const ast = css.parse(text, {
+            context: "declarationList",
+            onParseError: (error) => {
+                throw error;
+            },
+        });
+        const out = [];
+        if (ast.type !== "DeclarationList")
+            return fail("Expected declarations");
+        ast.children.forEach((node) => {
+            if (node.type !== "Declaration")
+                fail("Only declarations are supported");
+            const decodedProperty = css.ident.decode(node.property);
+            const property = decodedProperty.startsWith("--")
+                ? decodedProperty
+                : decodedProperty.toLowerCase();
+            if (!properties.has(property) &&
+                property !== "--lensmap-scale" &&
+                property !== "--lensmap-icon")
+                fail(`Unsupported property ${property}`);
+            const valueText = css.generate(node.value).trim();
+            const value = css.parse(valueText, {
+                context: "value",
+                onParseError: (error) => {
+                    throw error;
+                },
+            });
+            css.walk(value, (token) => {
+                if (token.type === "Raw" ||
+                    token.type === "Url" ||
+                    (token.type === "Function" &&
+                        !functions.has(css.ident.decode(token.name).toLowerCase())))
+                    fail(`Unsafe or unsupported value for ${property}`);
+                if (token.type === "String" && unsafeText(token.value))
+                    fail("Unsafe text");
+                if (token.type === "Identifier" &&
+                    /^(inherit|initial|unset|revert|revert-layer|infinity|-infinity|nan)$/i.test(css.ident.decode(token.name)))
+                    fail("CSS-wide keywords are unsupported");
+                if ((token.type === "Number" ||
+                    token.type === "Dimension" ||
+                    token.type === "Percentage") &&
+                    !Number.isFinite(Number(token.value)))
+                    fail("Lengths and numbers must be finite");
+            });
+            if (property === "--lensmap-scale") {
+                const scalar = value.type === "Value" ? value.children.first : undefined;
+                if (valueText !== "auto" &&
+                    (value.type !== "Value" ||
+                        value.children.size !== 1 ||
+                        scalar?.type !== "Number" ||
+                        !Number.isFinite(Number(scalar.value)) ||
+                        Number(scalar.value) <= 0))
+                    fail("Scale must be positive or auto");
+            }
+            else if (property === "--lensmap-icon") {
+                if (value.type !== "Value" ||
+                    value.children.size !== 1 ||
+                    value.children.first?.type !== "String")
+                    fail("Icon must be a CSS string");
+                const first = value.type === "Value" ? value.children.first : undefined;
+                if (first?.type === "String" && unsafeText(first.value))
+                    fail("Unsafe icon text");
+            }
+            else if (css.lexer.matchProperty(property, value).error)
+                fail(`Invalid value for ${property}`);
+            out.push({
+                property,
+                value: valueText,
+                important: Boolean(node.important),
+            });
+        });
+        return out;
+    };
+    if (typeof input === "string")
+        return parse(input);
+    return Object.entries(input).flatMap(([property, value]) => {
+        if (!/^(?:--lensmap-(?:scale|icon)|[a-z-]+)$/i.test(property))
+            return fail(`Invalid property ${property}`);
+        const text = property === "--lensmap-icon"
+            ? css.generate({ type: "String", value: String(value) })
+            : String(value);
+        const declarations = parse(`${property}:${text}`);
+        if (declarations.length !== 1 ||
+            declarations[0].property !==
+                (property.startsWith("--") ? property : property.toLowerCase()))
+            fail("Mapping values must contain one declaration value");
+        return declarations;
+    });
+}
+/** Low-to-high cascade order preserves shorthand interactions for browser application. */
+export function resolveNodeStyle(classes, inline, rules) {
+    for (const name of classes ?? [])
+        if (!rules.has(name))
+            fail(`Unknown class ${name}`);
+    const selected = new Set(classes);
+    const declarations = [...rules]
+        .filter(([name]) => selected.has(name))
+        .flatMap(([, values]) => values);
+    declarations.push(...(inline === undefined ? [] : parseNodeStyle(inline)));
+    declarations.sort((a, b) => Number(a.important) - Number(b.important));
+    if (!declarations.length)
+        return undefined;
+    const presentation = { declarations: [] };
+    for (const declaration of declarations) {
+        if (declaration.property === "--lensmap-scale")
+            presentation.scale =
+                declaration.value === "auto" ? "auto" : Number(declaration.value);
+        else if (declaration.property === "--lensmap-icon") {
+            const value = css.parse(declaration.value, { context: "value" });
+            if (value.type === "Value" && value.children.first?.type === "String")
+                presentation.icon = value.children.first.value;
+        }
+        else
+            presentation.declarations.push(declaration);
+    }
+    return presentation;
+}

package/dist/project.d.ts

@@ -0,0 +1,6 @@
+import { type VocabularyInput } from "./vocabulary.js";
+/** Root-bounded Node adapter. The browser entry deliberately never imports it. */
+export declare function readProjectVocabulary(root: string, buffers?: ReadonlyMap<string, string>): Promise<{
+    input: VocabularyInput;
+    files: string[];
+}>;

package/dist/project.js

@@ -0,0 +1,91 @@
+import { lstat, readFile, realpath } from "node:fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { pathToFileURL } from "node:url";
+import { isScalar, parseDocument } from "yaml";
+import { parseVocabulary } from "./vocabulary.js";
+/** Root-bounded Node adapter. The browser entry deliberately never imports it. */
+export async function readProjectVocabulary(root, buffers = new Map()) {
+    const config = resolve(root, "lensmap.config.json");
+    const files = [config];
+    let source;
+    let offset = 0;
+    try {
+        const canonicalRoot = await realpath(root);
+        const inside = (path) => {
+            const rel = relative(canonicalRoot, path);
+            return (rel === "" ||
+                (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel)));
+        };
+        const authorize = async (path) => {
+            let ancestor = path;
+            for (;;) {
+                try {
+                    await lstat(ancestor);
+                    const canonical = await realpath(ancestor);
+                    if (!inside(canonical))
+                        throw new Error("Vocabulary path escapes project root");
+                    return;
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                    const parent = dirname(ancestor);
+                    if (parent === ancestor)
+                        throw error;
+                    ancestor = parent;
+                }
+            }
+        };
+        await authorize(config);
+        source = buffers.get(config);
+        if (source === undefined) {
+            try {
+                source = await readFile(config, "utf8");
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return { input: {}, files };
+                throw error;
+            }
+        }
+        // JSON.parse enforces JSON syntax; YAML's JSON mode additionally detects duplicate keys.
+        const json = JSON.parse(source);
+        const parsed = parseDocument(source, { schema: "json", uniqueKeys: true });
+        if (parsed.errors.length)
+            throw new Error(parsed.errors[0].message);
+        if (!json ||
+            typeof json !== "object" ||
+            Array.isArray(json) ||
+            Object.keys(json).length !== 1 ||
+            !Object.hasOwn(json, "types") ||
+            typeof json.types !== "string" ||
+            !json.types.trim())
+            throw new Error("Config requires exactly one nonblank types path");
+        const field = parsed.get("types", true);
+        if (isScalar(field))
+            offset = field.range?.[0] ?? 0;
+        const target = resolve(dirname(config), json.types);
+        const lexical = relative(resolve(root), target);
+        if (lexical === ".." ||
+            lexical.startsWith(`..${sep}`) ||
+            isAbsolute(lexical))
+            throw new Error("Vocabulary path escapes project root");
+        await authorize(target);
+        if (!target.endsWith(".lenstypes"))
+            throw new Error("Vocabulary must be a .lenstypes file");
+        files.push(target);
+        const text = buffers.get(target) ?? (await readFile(target, "utf8"));
+        return { input: parseVocabulary(text, pathToFileURL(target).href), files };
+    }
+    catch (error) {
+        return {
+            input: {
+                uri: pathToFileURL(config).href,
+                source,
+                error: error instanceof Error ? error.message : String(error),
+                offset,
+            },
+            files,
+        };
+    }
+}

package/dist/v1/schema.d.ts

@@ -1,3 +1,5 @@
+export type { ConnectionTypeDeclarations } from "../vocabulary.js";
+export { ConnectionTypeDeclarationSchema, ConnectionTypeDeclarationsSchema, } from "../vocabulary.js";
 import { z } from "zod";
 /** Experimental v1 subset. Fields may be added or refined before v1 stabilizes. */
 export declare const PositionSchema: z.ZodObject<{
@@ -13,18 +15,10 @@ export declare const ConnectionTypeSchema: z.ZodEnum<{
     precedes: "precedes";
     prevents: "prevents";
 }>;
-export type ConnectionType = z.infer<typeof ConnectionTypeSchema>;
+export type ConnectionType = string;
 export declare const ReferenceSchema: z.ZodObject<{
     node_id: z.ZodString;
-    type: z.ZodOptional<z.ZodEnum<{
-        connected: "connected";
-        external_link: "external_link";
-        follows: "follows";
-        map_link: "map_link";
-        optional: "optional";
-        precedes: "precedes";
-        prevents: "prevents";
-    }>>;
+    type: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 declare const NodeContentSchema: z.ZodObject<{
     id: z.ZodOptional<z.ZodString>;
@@ -34,6 +28,8 @@ declare const NodeContentSchema: z.ZodObject<{
         x: z.ZodNumber;
         y: z.ZodNumber;
     }, z.core.$strict>>;
+    classes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    style: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>]>>;
 }, z.core.$strict>;
 export type Reference = z.infer<typeof ReferenceSchema>;
 export type RichNode = z.infer<typeof NodeContentSchema> & {
@@ -48,7 +44,8 @@ export declare const NodeSchema: z.ZodUnion<readonly [z.ZodString, z.ZodType<Ric
 export declare const DocumentSchema: z.ZodObject<{
     version: z.ZodLiteral<"v1">;
     frontmatter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    connection_types: z.ZodOptional<z.ZodType<import("../vocabulary.js").ConnectionTypeDeclarations, unknown, z.core.$ZodTypeInternals<import("../vocabulary.js").ConnectionTypeDeclarations, unknown>>>;
+    node_styles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>]>>>;
     nodes: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodType<RichNode, unknown, z.core.$ZodTypeInternals<RichNode, unknown>>]>>;
 }, z.core.$strict>;
 export type LensmapDocument = z.infer<typeof DocumentSchema>;
-export {};

package/dist/v1/schema.js

@@ -1,3 +1,6 @@
+import { NodeStyleSchema } from "../node-style.js";
+import { ConnectionTypeDeclarationsSchema } from "../vocabulary.js";
+export { ConnectionTypeDeclarationSchema, ConnectionTypeDeclarationsSchema, } from "../vocabulary.js";
 import { z } from "zod";
 /** Experimental v1 subset. Fields may be added or refined before v1 stabilizes. */
 export const PositionSchema = z.strictObject({
@@ -14,26 +17,27 @@ export const ConnectionTypeSchema = z.enum([
     "external_link",
     "map_link",
 ]);
-const LocalTypeSchema = z.enum([
-    "connected",
-    "precedes",
-    "follows",
-    "prevents",
-    "optional",
-]);
+const AuthoredTypeSchema = z.string().regex(/\S/);
 export const ReferenceSchema = z.strictObject({
     node_id: IdSchema,
-    type: ConnectionTypeSchema.optional(),
+    type: AuthoredTypeSchema.optional(),
 });
 const NodeContentSchema = z.strictObject({
     id: IdSchema.optional(),
     summary: z.string().nullable().optional(),
     full_text: z.string().nullable().optional(),
     position: PositionSchema.optional(),
+    classes: z.array(z.string()).optional(),
+    style: NodeStyleSchema.optional(),
 });
 const ordinary = (typed) => {
     const base = typed
-        ? NodeContentSchema.extend({ type: LocalTypeSchema.optional() })
+        ? NodeContentSchema.extend({
+            type: z
+                .string()
+                .regex(/^(?!(?:map_link|external_link)$).*\S/s)
+                .optional(),
+        })
         : NodeContentSchema;
     return z.union([
         base.extend({
@@ -47,7 +51,7 @@ const ordinary = (typed) => {
     ]);
 };
 const portal = () => NodeContentSchema.extend({
-    type: z.enum(["map_link", "external_link"]),
+    type: AuthoredTypeSchema,
     url: z.string().regex(/\S/, "A portal URL must not be blank."),
     connections: z.array(ConnectionSchema).optional(),
 });
@@ -63,5 +67,7 @@ export const NodeSchema = z.union([z.string(), RootNodeSchema]);
 export const DocumentSchema = z.strictObject({
     version: z.literal("v1"),
     frontmatter: z.record(z.string(), z.unknown()).optional(),
+    connection_types: ConnectionTypeDeclarationsSchema.optional(),
+    node_styles: z.record(z.string(), NodeStyleSchema).optional(),
     nodes: z.array(NodeSchema),
 });

package/dist/vocabulary.d.ts

@@ -0,0 +1,67 @@
+import { z } from "zod";
+export interface ConnectionPresentation {
+    strokeWidth: number | string;
+    lineStyle: "solid" | "dashed" | "dotted";
+    lineColor: string;
+    startMarker: "none" | "arrow" | "bar" | "circle" | "diamond";
+    endMarker: "none" | "arrow" | "bar" | "circle" | "diamond";
+    text: string;
+    reverseText: string;
+}
+export interface ResolvedConnectionType extends ConnectionPresentation {
+    coreKind: "ordinary" | "map_link" | "external_link";
+}
+export declare const ConnectionTypeDeclarationSchema: z.ZodObject<{
+    extends: z.ZodOptional<z.ZodString>;
+    "stroke-width": z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>>;
+    "line-style": z.ZodOptional<z.ZodEnum<{
+        dashed: "dashed";
+        dotted: "dotted";
+        solid: "solid";
+    }>>;
+    "line-color": z.ZodOptional<z.ZodString>;
+    "start-marker": z.ZodOptional<z.ZodEnum<{
+        arrow: "arrow";
+        bar: "bar";
+        circle: "circle";
+        diamond: "diamond";
+        none: "none";
+    }>>;
+    "end-marker": z.ZodOptional<z.ZodEnum<{
+        arrow: "arrow";
+        bar: "bar";
+        circle: "circle";
+        diamond: "diamond";
+        none: "none";
+    }>>;
+    text: z.ZodOptional<z.ZodString>;
+    reverse_text: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ConnectionTypeDeclaration = z.infer<typeof ConnectionTypeDeclarationSchema>;
+export type ConnectionTypeDeclarations = Record<string, z.infer<typeof ConnectionTypeDeclarationSchema>>;
+export declare const ConnectionTypeDeclarationsSchema: z.ZodType<ConnectionTypeDeclarations>;
+export interface VocabularyInput {
+    declarations?: ConnectionTypeDeclarations;
+    source?: string;
+    uri?: string;
+    error?: string;
+    offset?: number;
+}
+export declare const VocabularySchema: z.ZodObject<{
+    connection_types: z.ZodType<ConnectionTypeDeclarations, unknown, z.core.$ZodTypeInternals<ConnectionTypeDeclarations, unknown>>;
+}, z.core.$strict>;
+export declare function parseVocabulary(source: string, uri?: string): VocabularyInput;
+export declare const builtinVocabulary: Record<string, ResolvedConnectionType>;
+export declare function resolveVocabulary(shared?: VocabularyInput, local?: ConnectionTypeDeclarations, localContext?: VocabularyInput): Record<string, ResolvedConnectionType>;
+/** Source-only provenance for host hover/diagnostics; never embedded in edges. */
+export declare function vocabularyLocations(source: string, uri?: string): Record<string, {
+    uri?: string;
+    name: {
+        start: number;
+        end: number;
+    };
+    parent?: {
+        start: number;
+        end: number;
+    };
+}>;

package/dist/vocabulary.js

@@ -0,0 +1,530 @@
+import { ident, lexer, parse, walk } from "css-tree";
+import { parseDocument } from "yaml";
+import { z } from "zod";
+function productDimension(a, b, divide) {
+    const powers = new Map();
+    for (const [dimension, sign] of [
+        [a, 1],
+        [b, divide ? -1 : 1],
+    ]) {
+        if (dimension === "number")
+            continue;
+        for (const term of dimension.split("*")) {
+            const [unit, exponent] = term.split("^");
+            powers.set(unit, (powers.get(unit) ?? 0) + sign * Number(exponent ?? 1));
+        }
+    }
+    return ([...powers]
+        .filter(([, power]) => power !== 0)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([unit, power]) => (power === 1 ? unit : `${unit}^${power}`))
+        .join("*") || "number");
+}
+function mathDimension(node, percentageHint = "length") {
+    const fail = () => {
+        throw new Error("Invalid CSS math dimensions");
+    };
+    const compatible = (a, b) => (a === b ? a : fail());
+    const expression = (nodes) => {
+        if (!nodes.length || nodes.length % 2 === 0)
+            return fail();
+        const values = [];
+        let current = mathDimension(nodes[0], percentageHint);
+        for (let i = 1; i < nodes.length; i += 2) {
+            const operator = nodes[i];
+            if (operator.type !== "Operator")
+                return fail();
+            const op = operator.value.trim();
+            const next = mathDimension(nodes[i + 1], percentageHint);
+            if (op === "*" || op === "/") {
+                current = productDimension(current, next, op === "/");
+            }
+            else if (op === "+" || op === "-") {
+                values.push(current);
+                current = next;
+            }
+            else
+                return fail();
+        }
+        values.push(current);
+        return values.reduce(compatible);
+    };
+    if (node.type === "Number") {
+        if (!Number.isFinite(Number(node.value)))
+            return fail();
+        return "number";
+    }
+    if (node.type === "Percentage") {
+        if (!Number.isFinite(Number(node.value)))
+            return fail();
+        return percentageHint;
+    }
+    if (node.type === "Dimension") {
+        if (!Number.isFinite(Number(node.value)))
+            return fail();
+        for (const unit of [
+            "length",
+            "angle",
+            "time",
+            "frequency",
+            "resolution",
+            "flex",
+        ])
+            if (lexer.matchType(unit, node).matched)
+                return unit;
+        return fail();
+    }
+    if (node.type === "Identifier") {
+        if (["e", "pi"].includes(ident.decode(node.name).toLowerCase()))
+            return "number";
+        return fail();
+    }
+    if (node.type === "Value" || node.type === "Parentheses")
+        return expression(node.children.toArray());
+    if (node.type !== "Function")
+        return fail();
+    const groups = [[]];
+    for (const child of node.children) {
+        if (child.type === "Operator" && child.value.trim() === ",")
+            groups.push([]);
+        else
+            groups[groups.length - 1].push(child);
+    }
+    const fn = ident.decode(node.name).toLowerCase();
+    if (fn === "round" &&
+        groups[0].length === 1 &&
+        groups[0][0].type === "Identifier" &&
+        ["nearest", "up", "down", "to-zero"].includes(groups[0][0].name.toLowerCase()))
+        groups.shift();
+    const args = groups.map(expression);
+    const arity = (min, max = min) => {
+        if (args.length < min || args.length > max)
+            fail();
+    };
+    if (fn === "calc") {
+        arity(1);
+        return args[0];
+    }
+    if (["min", "max", "hypot"].includes(fn)) {
+        arity(1, Infinity);
+        return args.reduce(compatible);
+    }
+    if (fn === "clamp") {
+        arity(3);
+        return args.reduce(compatible);
+    }
+    if (["mod", "rem"].includes(fn)) {
+        arity(2);
+        return args.reduce(compatible);
+    }
+    if (fn === "round") {
+        arity(1, 2);
+        if (args.length === 1 && args[0] !== "number")
+            return fail();
+        return args.reduce(compatible);
+    }
+    if (fn === "abs") {
+        arity(1);
+        return args[0];
+    }
+    if (fn === "sign") {
+        arity(1);
+        return "number";
+    }
+    if (["sin", "cos", "tan"].includes(fn)) {
+        arity(1);
+        if (!["number", "angle"].includes(args[0]))
+            return fail();
+        return "number";
+    }
+    if (["asin", "acos", "atan"].includes(fn)) {
+        arity(1);
+        if (args[0] !== "number")
+            return fail();
+        return "angle";
+    }
+    if (fn === "atan2") {
+        arity(2);
+        args.reduce(compatible);
+        return "angle";
+    }
+    if (["pow", "sqrt", "log", "exp"].includes(fn)) {
+        arity(fn === "pow" ? 2 : 1, fn === "log" ? 2 : fn === "pow" ? 2 : 1);
+        if (args.some((a) => a !== "number"))
+            return fail();
+        return "number";
+    }
+    return fail();
+}
+function css(value, property) {
+    try {
+        const ast = parse(value, { context: "value" });
+        let safe = true;
+        walk(ast, (node) => {
+            if (property === "color" && node.type === "Function") {
+                const fn = ident.decode(node.name).toLowerCase();
+                if ([
+                    "rgb",
+                    "rgba",
+                    "hsl",
+                    "hsla",
+                    "hwb",
+                    "lab",
+                    "lch",
+                    "oklab",
+                    "oklch",
+                    "color",
+                    "device-cmyk",
+                ].includes(fn)) {
+                    const channels = node.children
+                        .toArray()
+                        .filter((child) => child.type !== "Operator");
+                    const hue = ["hsl", "hsla", "hwb"].includes(fn)
+                        ? 0
+                        : ["lch", "oklch"].includes(fn)
+                            ? 2
+                            : -1;
+                    channels.forEach((channel, index) => {
+                        if (channel.type === "Function" &&
+                            [
+                                "calc",
+                                "min",
+                                "max",
+                                "clamp",
+                                "round",
+                                "mod",
+                                "rem",
+                                "abs",
+                                "sign",
+                                "sin",
+                                "cos",
+                                "tan",
+                                "asin",
+                                "acos",
+                                "atan",
+                                "atan2",
+                                "pow",
+                                "sqrt",
+                                "hypot",
+                                "log",
+                                "exp",
+                            ].includes(ident.decode(channel.name).toLowerCase())) {
+                            const dimension = mathDimension(channel, index === hue ? "percentage" : "number");
+                            if (index === hue
+                                ? !["number", "angle"].includes(dimension)
+                                : dimension !== "number")
+                                safe = false;
+                        }
+                    });
+                }
+            }
+            if (property === "color" &&
+                node.type === "Function" &&
+                [
+                    "calc",
+                    "min",
+                    "max",
+                    "clamp",
+                    "round",
+                    "mod",
+                    "rem",
+                    "abs",
+                    "sign",
+                    "sin",
+                    "cos",
+                    "tan",
+                    "asin",
+                    "acos",
+                    "atan",
+                    "atan2",
+                    "pow",
+                    "sqrt",
+                    "hypot",
+                    "log",
+                    "exp",
+                ].includes(ident.decode(node.name).toLowerCase()))
+                mathDimension(node, "number");
+            if (node.type === "Raw" || node.type === "Url")
+                safe = false;
+            if (node.type === "Function" &&
+                ["var", "env", "attr", "url", "paint"].includes(ident.decode(node.name).toLowerCase()))
+                safe = false;
+            if (node.type === "Identifier" &&
+                (/^(inherit|initial|unset|revert|revert-layer|infinity|-infinity|nan)$/i.test(node.name) ||
+                    ident.decode(node.name).startsWith("--")))
+                safe = false;
+        });
+        if (!safe || !lexer.matchProperty(property, ast).matched)
+            return false;
+        if (property === "stroke-width" &&
+            !["number", "length"].includes(mathDimension(ast)))
+            return false;
+        if (property === "stroke-width" && ast.type === "Value") {
+            const literal = ast.children.first;
+            if (literal &&
+                ["Number", "Dimension", "Percentage"].includes(literal.type) &&
+                "value" in literal &&
+                Number(literal.value) < 0)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const name = z.string().regex(/\S/);
+const marker = z.enum(["none", "arrow", "bar", "circle", "diamond"]);
+export const ConnectionTypeDeclarationSchema = z
+    .strictObject({
+    extends: name.optional(),
+    "stroke-width": z
+        .union([
+        z.number().finite().nonnegative(),
+        z
+            .string()
+            .refine((v) => css(v, "stroke-width"), "Invalid scalar CSS width"),
+    ])
+        .optional(),
+    "line-style": z.enum(["solid", "dashed", "dotted"]).optional(),
+    "line-color": z
+        .string()
+        .refine((v) => v === "auto" || css(v, "color"), "Invalid CSS colour")
+        .optional(),
+    "start-marker": marker.optional(),
+    "end-marker": marker.optional(),
+    text: name.optional(),
+    reverse_text: name.optional(),
+})
+    .refine((v) => (v.text === undefined) === (v.reverse_text === undefined), "Supply both text and reverse_text")
+    .meta({
+    anyOf: [
+        { required: ["text", "reverse_text"] },
+        {
+            not: {
+                anyOf: [{ required: ["text"] }, { required: ["reverse_text"] }],
+            },
+        },
+    ],
+});
+// Zod records intentionally discard __proto__; validate entries without copying
+// through an ordinary object's property setter so every exact authored name survives.
+export const ConnectionTypeDeclarationsSchema = z
+    .any()
+    .superRefine((value, ctx) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Expected a declaration mapping",
+        });
+        return;
+    }
+    for (const [key, declaration] of Object.entries(value)) {
+        if (!name.safeParse(key).success)
+            ctx.addIssue({
+                code: "custom",
+                path: [key],
+                message: "Type names must be nonblank",
+            });
+        const result = ConnectionTypeDeclarationSchema.safeParse(declaration);
+        if (!result.success)
+            for (const issue of result.error.issues)
+                ctx.addIssue({ ...issue, path: [key, ...issue.path] });
+    }
+})
+    .meta({
+    type: "object",
+    propertyNames: { type: "string", pattern: "\\S" },
+    additionalProperties: z.toJSONSchema(ConnectionTypeDeclarationSchema, {
+        io: "input",
+    }),
+});
+export const VocabularySchema = z.strictObject({
+    connection_types: ConnectionTypeDeclarationsSchema,
+});
+export function parseVocabulary(source, uri) {
+    try {
+        const doc = parseDocument(source, { uniqueKeys: true });
+        const problem = [...doc.errors, ...doc.warnings][0];
+        if (problem)
+            return { source, uri, error: problem.message, offset: problem.pos[0] };
+        const result = VocabularySchema.safeParse(doc.toJS({ maxAliasCount: 100 }));
+        if (!result.success) {
+            const issue = result.error.issues[0];
+            const ast = doc.getIn(issue.path, true);
+            return {
+                source,
+                uri,
+                error: issue.message,
+                offset: ast?.range?.[0] ?? 0,
+            };
+        }
+        const value = result.data;
+        return { source, uri, declarations: value.connection_types };
+    }
+    catch (error) {
+        return {
+            source,
+            uri,
+            error: error instanceof Error ? error.message : String(error),
+            offset: 0,
+        };
+    }
+}
+const neutral = {
+    strokeWidth: 2.5,
+    lineStyle: "solid",
+    lineColor: "auto",
+    startMarker: "none",
+    endMarker: "none",
+    text: "connected to",
+    reverseText: "connected to",
+    coreKind: "ordinary",
+};
+export const builtinVocabulary = Object.fromEntries([
+    ["connected", {}],
+    [
+        "precedes",
+        { endMarker: "arrow", text: "precedes", reverseText: "follows" },
+    ],
+    [
+        "follows",
+        { startMarker: "arrow", text: "follows", reverseText: "precedes" },
+    ],
+    [
+        "prevents",
+        { endMarker: "bar", text: "prevents", reverseText: "is prevented by" },
+    ],
+    [
+        "optional",
+        {
+            lineStyle: "dashed",
+            text: "optionally connected to",
+            reverseText: "optionally connected to",
+        },
+    ],
+    [
+        "map_link",
+        {
+            coreKind: "map_link",
+            text: "links to map",
+            reverseText: "map linked from",
+        },
+    ],
+    [
+        "external_link",
+        {
+            coreKind: "external_link",
+            text: "links to resource",
+            reverseText: "resource linked from",
+        },
+    ],
+].map(([key, value]) => [key, { ...neutral, ...value }]));
+export function resolveVocabulary(shared = {}, local = {}, localContext = {}) {
+    if (shared.error)
+        throw Object.assign(new Error(shared.error), {
+            offset: shared.offset ?? 0,
+            uri: shared.uri,
+            source: shared.source,
+        });
+    const layers = [
+        ConnectionTypeDeclarationsSchema.parse(shared.declarations ?? {}),
+        ConnectionTypeDeclarationsSchema.parse(local),
+    ];
+    const declarations = new Map();
+    for (const layer of layers)
+        for (const [key, value] of Object.entries(layer))
+            declarations.set(key, { ...declarations.get(key), ...value });
+    const fail = (key, message) => {
+        const parentIsLocal = Object.hasOwn(local, key) &&
+            (declarations.get(key)?.extends === undefined ||
+                Object.hasOwn(local[key], "extends"));
+        const context = parentIsLocal ? localContext : shared;
+        const location = context.source
+            ? vocabularyLocations(context.source, context.uri)[key]
+            : undefined;
+        throw Object.assign(new Error(message), {
+            uri: context.uri,
+            source: context.source,
+            offset: location?.parent?.start ?? location?.name.start ?? 0,
+        });
+    };
+    const resolved = new Map();
+    const visiting = new Set();
+    const resolve = (key) => {
+        const existing = resolved.get(key);
+        if (existing)
+            return existing;
+        if (visiting.has(key))
+            fail(key, `Connection type inheritance cycle: ${key}`);
+        const seed = Object.hasOwn(builtinVocabulary, key)
+            ? builtinVocabulary[key]
+            : undefined;
+        const authored = declarations.get(key);
+        if (!seed && !authored)
+            throw new Error(`Unknown connection type: ${key}`);
+        if (authored?.extends !== undefined &&
+            !declarations.has(authored.extends) &&
+            !Object.hasOwn(builtinVocabulary, authored.extends))
+            fail(key, `Unknown parent connection type: ${authored.extends}`);
+        visiting.add(key);
+        const base = authored?.extends !== undefined
+            ? resolve(authored.extends)
+            : (seed ?? resolve("connected"));
+        if (seed && seed.coreKind !== base.coreKind)
+            fail(key, `Cannot change built-in core capability: ${key}`);
+        const value = { ...base };
+        const fields = {
+            "stroke-width": "strokeWidth",
+            "line-style": "lineStyle",
+            "line-color": "lineColor",
+            "start-marker": "startMarker",
+            "end-marker": "endMarker",
+            text: "text",
+            reverse_text: "reverseText",
+        };
+        for (const [field, target] of Object.entries(fields))
+            if (authored && Object.hasOwn(authored, field))
+                Object.assign(value, {
+                    [target]: authored[field],
+                });
+        visiting.delete(key);
+        resolved.set(key, value);
+        return value;
+    };
+    for (const key of new Set([
+        ...Object.keys(builtinVocabulary),
+        ...declarations.keys(),
+    ]))
+        resolve(key);
+    return Object.fromEntries(resolved);
+}
+/** Source-only provenance for host hover/diagnostics; never embedded in edges. */
+export function vocabularyLocations(source, uri) {
+    const doc = parseDocument(source);
+    const mapping = doc.getIn(["connection_types"], true);
+    const entries = [];
+    if (mapping &&
+        typeof mapping === "object" &&
+        "items" in mapping &&
+        Array.isArray(mapping.items))
+        for (const pair of mapping.items) {
+            if (!pair || typeof pair !== "object" || !("key" in pair))
+                continue;
+            const key = pair.key;
+            if (!key || !("value" in key) || typeof key.value !== "string")
+                continue;
+            const parent = doc.getIn(["connection_types", key.value, "extends"], true);
+            entries.push([
+                key.value,
+                {
+                    uri,
+                    name: { start: key.range?.[0] ?? 0, end: key.range?.[1] ?? 0 },
+                    ...(parent?.range
+                        ? { parent: { start: parent.range[0], end: parent.range[1] } }
+                        : {}),
+                },
+            ]);
+        }
+    return Object.fromEntries(entries);
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@lensmap/document",
   "license": "MIT",
   "description": "Experimental Lensmap document engine: YAML analysis, semantic graphs and revision-bound source edits",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "files": [
     "dist"
   ],
@@ -28,13 +28,19 @@
     "./v1": {
       "types": "./dist/v1/schema.d.ts",
       "default": "./dist/v1/schema.js"
+    },
+    "./project": {
+      "types": "./dist/project.d.ts",
+      "default": "./dist/project.js"
     }
   },
   "dependencies": {
+    "css-tree": "3.2.1",
     "yaml": "2.9.1",
     "zod": "4.6.7"
   },
   "devDependencies": {
+    "@types/css-tree": "3.2.0",
     "@types/node": "24.19.2",
     "ajv": "8.20.0",
     "typescript": "7.0.2",