@xdbml/parse 0.6.2 → 0.6.4

package/README.md

@@ -48,6 +48,15 @@ try {
 
 The package also exports `tokenize`, `LexError`, `Parser`, `SymbolTable`, and the AST types.
 
+For diagram views (spec §18), `diagramViews(doc)` lists the `DiagramView` declarations, and `diagramViewMembers(doc, name)` returns the entities, database views and sticky notes a diagram view contains, with the Containers, TableGroups and supertype groups a renderer frames or draws around them.
+
+```ts
+import { parse, diagramViewMembers } from '@xdbml/parse';
+
+const members = diagramViewMembers(parse(source), 'order_flow');
+console.log(members?.entities); // ['sales.orders', 'billing.invoices', ...]
+```
+
 ## Learn more
 
 - [xdbml.org](https://xdbml.org), and the language [in 5 minutes](https://xdbml.org/learn/)

package/dist/ast.d.ts

@@ -38,7 +38,7 @@ export interface ExperimentalDeclaration {
     features: string[];
     span: Span;
 }
-export type TopLevelStatement = ProjectDeclaration | ContainerDeclaration | EntityDeclaration | TypeDeclaration | EdgeDeclaration | ViewDeclaration | EnumDeclaration | RefDeclaration | TablePartialDeclaration | TableGroupDeclaration | SupertypeGroupDeclaration | NoteDeclaration | TopLevelRecordsDeclaration | ModuleImportDirective;
+export type TopLevelStatement = ProjectDeclaration | ContainerDeclaration | EntityDeclaration | TypeDeclaration | EdgeDeclaration | ViewDeclaration | EnumDeclaration | RefDeclaration | TablePartialDeclaration | TableGroupDeclaration | SupertypeGroupDeclaration | DiagramViewDeclaration | NoteDeclaration | TopLevelRecordsDeclaration | ModuleImportDirective;
 export interface ProjectDeclaration {
     kind: 'ProjectDeclaration';
     name: string;
@@ -385,6 +385,36 @@ export interface SupertypeGroupMember {
     settings: Setting[];
     span: Span;
 }
+export type DiagramViewCategoryName = 'Tables' | 'Views' | 'Containers' | 'TableGroups' | 'SupertypeGroups' | 'Notes';
+export interface DiagramViewDeclaration {
+    kind: 'DiagramViewDeclaration';
+    name: string;
+    /** Bracket settings: `note` and custom `x_` properties (spec §18.1). */
+    settings: Setting[];
+    /** `Note:` / `Note { }` elements of the body. `diagramViewNote()` gives the note. */
+    notes: NoteBlock[];
+    /** True when the whole body is `{ * }`: every element of every category. */
+    wildcardBody: boolean;
+    categories: DiagramViewCategory[];
+    span: Span;
+}
+export interface DiagramViewCategory {
+    kind: 'DiagramViewCategory';
+    /** Canonical category: `Schemas` reads as `Containers`. */
+    category: DiagramViewCategoryName;
+    /** The keyword as written, for round trips and the DBML-form check of §18.5. */
+    keyword: string;
+    /** True when the list holds `*`; names written beside it have no effect. */
+    wildcard: boolean;
+    items: DiagramViewItem[];
+    span: Span;
+}
+export interface DiagramViewItem {
+    kind: 'DiagramViewItem';
+    /** Name as written: `orders` or `sales.orders`. */
+    name: string;
+    span: Span;
+}
 export interface PartialInjection {
     kind: 'PartialInjection';
     /** Identifier after the `~`. */

package/dist/diagram-views.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Diagram views (spec §18, defined in v0.6.3).
+ *
+ * A diagram view is a named subset of the model's diagram. Its body lists
+ * categories of elements; `diagramViewMembers()` turns those lists into the
+ * members of §18.2, and `checkDiagramViews()` reports the conditions of
+ * §18.6. Both take a document and flatten it, so elements imported from
+ * other files count like the ones declared in place (§18.3).
+ *
+ * Element ids follow the renderer and the supertype group resolver: an
+ * entity or database view inside a Container is `container.name`, one at
+ * the top level is its name as declared, which for the DBML form
+ * `Table core.users` is `core.users` in the implicit Container `core`.
+ */
+import type { DiagramViewDeclaration, XDbmlDocument } from './ast.ts';
+import type { Diagnostic } from './name-resolver.ts';
+/** The members of a diagram view (spec §18.2) and what a renderer draws with them (§18.4). */
+export interface DiagramViewMembers {
+    /** The diagram view these members belong to. */
+    declaration: DiagramViewDeclaration;
+    /** Ids of the member entities, in declaration order. */
+    entities: string[];
+    /** Ids of the member database views, in declaration order. */
+    views: string[];
+    /** Names of the member sticky notes, in declaration order. */
+    notes: string[];
+    /** Containers holding at least one member: their frames surround those members only. */
+    containers: string[];
+    /** TableGroups with at least one member entity, named in the diagram view or not. */
+    tableGroups: string[];
+    /** Supertype groups whose supertype and at least one subtype are members (§12.9). */
+    supertypeGroups: string[];
+}
+/**
+ * The note of a diagram view (spec §18.1): its first `Note` in the body,
+ * otherwise the `note` setting in its brackets, otherwise undefined.
+ */
+export declare function diagramViewNote(view: DiagramViewDeclaration): string | undefined;
+/** Every DiagramView of a document, in declaration order, after module resolution. */
+export declare function diagramViews(doc: XDbmlDocument): DiagramViewDeclaration[];
+/**
+ * The members of the diagram view named `name`, or undefined when the
+ * document declares none of that name. With two of one name (an error),
+ * the first one counts.
+ */
+export declare function diagramViewMembers(doc: XDbmlDocument, name: string): DiagramViewMembers | undefined;
+/** The conditions of spec §18.6 that a parse leaves to name resolution. */
+export declare function checkDiagramViews(doc: XDbmlDocument): Diagnostic[];

package/dist/diagram-views.js

@@ -0,0 +1,411 @@
+/**
+ * Diagram views (spec §18, defined in v0.6.3).
+ *
+ * A diagram view is a named subset of the model's diagram. Its body lists
+ * categories of elements; `diagramViewMembers()` turns those lists into the
+ * members of §18.2, and `checkDiagramViews()` reports the conditions of
+ * §18.6. Both take a document and flatten it, so elements imported from
+ * other files count like the ones declared in place (§18.3).
+ *
+ * Element ids follow the renderer and the supertype group resolver: an
+ * entity or database view inside a Container is `container.name`, one at
+ * the top level is its name as declared, which for the DBML form
+ * `Table core.users` is `core.users` in the implicit Container `core`.
+ */
+import { flatten } from "./module-resolver.js";
+import { resolveSupertypeGroups } from "./supertypes.js";
+/**
+ * The note of a diagram view (spec §18.1): its first `Note` in the body,
+ * otherwise the `note` setting in its brackets, otherwise undefined.
+ */
+export function diagramViewNote(view) {
+    if (view.notes.length > 0)
+        return view.notes[0].body;
+    const s = view.settings.find((x) => x.name === 'note');
+    const v = s?.value;
+    return v && v.kind === 'StringValue' ? v.value : undefined;
+}
+/** Every DiagramView of a document, in declaration order, after module resolution. */
+export function diagramViews(doc) {
+    return flatten(doc).statements.filter((s) => s.kind === 'DiagramViewDeclaration');
+}
+/**
+ * The members of the diagram view named `name`, or undefined when the
+ * document declares none of that name. With two of one name (an error),
+ * the first one counts.
+ */
+export function diagramViewMembers(doc, name) {
+    const flat = flatten(doc);
+    const decl = flat.statements.find((s) => s.kind === 'DiagramViewDeclaration' && s.name === name);
+    if (!decl)
+        return undefined;
+    return computeMembers(decl, buildIndex(flat), flat);
+}
+const key = (kind, id) => `${kind}:${id}`;
+function buildIndex(doc) {
+    const elements = [];
+    const byKindId = new Map();
+    const entitiesOf = new Map();
+    const viewsOf = new Map();
+    const tableGroupMembers = new Map();
+    const aliasCandidates = new Map();
+    const takenNames = new Set();
+    const add = (kind, id, name, container, topLevel) => {
+        if (byKindId.has(key(kind, id)))
+            return;
+        const el = { kind, id, name, container, topLevel };
+        elements.push(el);
+        byKindId.set(key(kind, id), el);
+        if (container && (kind === 'entity' || kind === 'view')) {
+            const map = kind === 'entity' ? entitiesOf : viewsOf;
+            const list = map.get(container) ?? [];
+            list.push(id);
+            map.set(container, list);
+            if (!byKindId.has(key('container', container))) {
+                add('container', container, container, undefined, true);
+            }
+        }
+    };
+    const addBoxed = (kind, decl, container) => {
+        let id;
+        let bare;
+        let owner = container;
+        if (container) {
+            id = `${container}.${decl.name}`;
+            bare = decl.name;
+        }
+        else {
+            id = decl.name;
+            const dot = decl.name.lastIndexOf('.');
+            bare = dot > 0 ? decl.name.slice(dot + 1) : decl.name;
+            owner = dot > 0 ? decl.name.slice(0, dot) : undefined;
+        }
+        add(kind, id, bare, owner, owner === undefined);
+        takenNames.add(bare);
+        if (kind === 'entity') {
+            const alias = decl.alias;
+            if (alias)
+                aliasCandidates.set(alias, aliasCandidates.has(alias) ? null : id);
+        }
+    };
+    for (const stmt of doc.statements) {
+        switch (stmt.kind) {
+            case 'ContainerDeclaration': {
+                const c = stmt;
+                add('container', c.name, c.name, undefined, true);
+                takenNames.add(c.name);
+                for (const item of c.body) {
+                    if (item.kind === 'EntityDeclaration')
+                        addBoxed('entity', item, c.name);
+                    else if (item.kind === 'ViewDeclaration')
+                        addBoxed('view', item, c.name);
+                    else if (item.kind === 'EdgeDeclaration')
+                        add('edge', `${c.name}.${item.name}`, item.name, c.name, false);
+                }
+                break;
+            }
+            case 'EntityDeclaration':
+                addBoxed('entity', stmt);
+                break;
+            case 'ViewDeclaration':
+                addBoxed('view', stmt);
+                break;
+            case 'EdgeDeclaration':
+                add('edge', stmt.name, stmt.name, undefined, true);
+                break;
+            case 'TableGroupDeclaration':
+                add('tablegroup', stmt.name, stmt.name, undefined, true);
+                if (!tableGroupMembers.has(stmt.name))
+                    tableGroupMembers.set(stmt.name, stmt.members);
+                break;
+            case 'SupertypeGroupDeclaration':
+                add('supertypegroup', stmt.name, stmt.name, undefined, true);
+                break;
+            case 'NoteDeclaration':
+                if (stmt.name)
+                    add('note', stmt.name, stmt.name, undefined, true);
+                break;
+            default: break;
+        }
+    }
+    // An alias that repeats the name of an entity or a Container, or that two
+    // entities declare, names nothing (§7.4).
+    const aliases = new Map();
+    for (const [alias, id] of aliasCandidates) {
+        if (id !== null && !takenNames.has(alias))
+            aliases.set(alias, id);
+    }
+    return { elements, byKindId, entitiesOf, viewsOf, aliases, tableGroupMembers };
+}
+/* --------------------------------------------------------- resolution */
+const CATEGORY_KIND = {
+    Tables: 'entity',
+    Views: 'view',
+    Containers: 'container',
+    TableGroups: 'tablegroup',
+    SupertypeGroups: 'supertypegroup',
+    Notes: 'note',
+};
+const KIND_CATEGORY = {
+    entity: 'Tables',
+    view: 'Views',
+    container: 'Containers',
+    tablegroup: 'TableGroups',
+    supertypegroup: 'SupertypeGroups',
+    note: 'Notes',
+};
+const KIND_LABEL = {
+    entity: 'an entity',
+    view: 'a database view',
+    container: 'a Container',
+    tablegroup: 'a TableGroup',
+    supertypegroup: 'a supertype group',
+    note: 'a sticky note',
+    edge: 'an Edge',
+};
+/**
+ * Resolve a name of one kind (spec §18.3). A qualified name names the
+ * element with that id. An unqualified name names the element declared
+ * outside any Container under that name, if any, and otherwise the one
+ * element of that name inside a Container. Under Tables, an alias names
+ * its entity.
+ */
+function resolveName(name, kind, index) {
+    const direct = index.byKindId.get(key(kind, name));
+    if (direct)
+        return { ok: true, id: direct.id };
+    if (!name.includes('.') && (kind === 'entity' || kind === 'view')) {
+        const top = index.elements.find((e) => e.kind === kind && e.topLevel && e.name === name);
+        if (top)
+            return { ok: true, id: top.id };
+        const inside = index.elements.filter((e) => e.kind === kind && e.name === name);
+        if (inside.length === 1)
+            return { ok: true, id: inside[0].id };
+        if (inside.length > 1)
+            return { ok: false, reason: 'ambiguous', candidates: inside.map((e) => e.id) };
+    }
+    if (kind === 'entity') {
+        const aliased = index.aliases.get(name);
+        if (aliased)
+            return { ok: true, id: aliased };
+    }
+    for (const other of ['entity', 'view', 'container', 'tablegroup', 'supertypegroup', 'note', 'edge']) {
+        if (other === kind)
+            continue;
+        if (resolveSimple(name, other, index))
+            return { ok: false, reason: 'other-kind', kind: other };
+    }
+    return { ok: false, reason: 'unresolved' };
+}
+function resolveSimple(name, kind, index) {
+    if (index.byKindId.has(key(kind, name)))
+        return true;
+    if (!name.includes('.'))
+        return index.elements.some((e) => e.kind === kind && e.name === name);
+    return false;
+}
+/** The categories of a diagram view, with a body-level `*` read as `*` in every category (§28.8). */
+function effectiveCategories(decl) {
+    const out = new Map();
+    if (decl.wildcardBody) {
+        for (const name of Object.keys(CATEGORY_KIND)) {
+            out.set(name, { wildcard: true, items: [] });
+        }
+        return out;
+    }
+    // A category written twice is reported by checkDiagramViews(); its lists combine.
+    for (const c of decl.categories) {
+        const prev = out.get(c.category);
+        out.set(c.category, {
+            wildcard: (prev?.wildcard ?? false) || c.wildcard,
+            items: [...(prev?.items ?? []), ...c.items],
+        });
+    }
+    return out;
+}
+function computeMembers(decl, index, doc) {
+    const cats = effectiveCategories(decl);
+    const all = (kind) => index.elements.filter((e) => e.kind === kind).map((e) => e.id);
+    const named = (category) => {
+        const c = cats.get(category);
+        if (!c)
+            return new Set();
+        if (c.wildcard)
+            return new Set(all(CATEGORY_KIND[category]));
+        const ids = new Set();
+        for (const item of c.items) {
+            const r = resolveName(item.name, CATEGORY_KIND[category], index);
+            if (r.ok)
+                ids.add(r.id);
+        }
+        return ids;
+    };
+    const entities = named('Tables');
+    const views = named('Views');
+    // Rule 2: a listed Container contributes its entities and its database
+    // views, each list narrowed separately to the names under Tables or Views
+    // when they name at least one of the Container's own.
+    for (const container of named('Containers')) {
+        const ownEntities = index.entitiesOf.get(container) ?? [];
+        if (!ownEntities.some((id) => entities.has(id)))
+            ownEntities.forEach((id) => entities.add(id));
+        const ownViews = index.viewsOf.get(container) ?? [];
+        if (!ownViews.some((id) => views.has(id)))
+            ownViews.forEach((id) => views.add(id));
+    }
+    // Rule 3: each named TableGroup contributes all of its members.
+    for (const group of named('TableGroups')) {
+        for (const member of index.tableGroupMembers.get(group) ?? []) {
+            const r = resolveName(member, 'entity', index);
+            if (r.ok)
+                entities.add(r.id);
+        }
+    }
+    // Rule 4: each named supertype group contributes its supertype and subtypes.
+    const groups = resolveSupertypeGroups(doc);
+    const namedGroups = named('SupertypeGroups');
+    for (const g of groups) {
+        if (!namedGroups.has(g.declaration.name))
+            continue;
+        if (g.supertype)
+            entities.add(g.supertype);
+        for (const s of g.subtypes)
+            if (s.entity)
+                entities.add(s.entity);
+    }
+    const notes = named('Notes');
+    const ordered = (kind, set) => all(kind).filter((id) => set.has(id));
+    const memberEntities = ordered('entity', entities);
+    const memberViews = ordered('view', views);
+    const boxed = new Set([...memberEntities, ...memberViews]);
+    const containers = all('container').filter((c) => [...(index.entitiesOf.get(c) ?? []), ...(index.viewsOf.get(c) ?? [])].some((id) => boxed.has(id)));
+    const tableGroups = all('tablegroup').filter((g) => (index.tableGroupMembers.get(g) ?? []).some((m) => {
+        const r = resolveName(m, 'entity', index);
+        return r.ok && entities.has(r.id);
+    }));
+    const supertypeGroups = groups
+        .filter((g) => g.supertype && entities.has(g.supertype) && g.subtypes.some((s) => s.entity && entities.has(s.entity)))
+        .map((g) => g.declaration.name);
+    return {
+        declaration: decl,
+        entities: memberEntities,
+        views: memberViews,
+        notes: ordered('note', notes),
+        containers,
+        tableGroups,
+        supertypeGroups: [...new Set(supertypeGroups)],
+    };
+}
+/* --------------------------------------------------------- diagnostics */
+/** The conditions of spec §18.6 that a parse leaves to name resolution. */
+export function checkDiagramViews(doc) {
+    const views = doc.statements.filter((s) => s.kind === 'DiagramViewDeclaration');
+    if (views.length === 0)
+        return [];
+    const index = buildIndex(doc);
+    const diagnostics = [];
+    const declared = !!doc.version;
+    const seen = new Set();
+    for (const view of views) {
+        if (seen.has(view.name)) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'duplicate-diagram-view',
+                message: `A diagram view named '${view.name}' is already declared. Diagram view names are unique (spec §18.1).`,
+                span: view.span,
+            });
+        }
+        seen.add(view.name);
+        // §18.1: the brackets take `note` and custom properties only.
+        for (const setting of view.settings) {
+            if (setting.name === 'note' || setting.name.startsWith('x_'))
+                continue;
+            diagnostics.push({
+                severity: 'error',
+                code: 'unknown-diagram-view-setting',
+                message: `Diagram view '${view.name}' writes the setting '${setting.nameSource}'. A diagram view takes ` +
+                    'a note and custom x_ properties in its brackets, and no other setting (spec §18.1).',
+                span: setting.span,
+            });
+        }
+        // §18.5: a note and the brackets are xDBML extensions.
+        if (!declared && (view.settings.length > 0 || view.notes.length > 0)) {
+            diagnostics.push({
+                severity: 'error',
+                code: 'construct-requires-version',
+                message: `Diagram view '${view.name}' carries a note or settings, an xDBML extension that needs a ` +
+                    'version declaration such as xdbml: 0.6 at the top of the document (spec §18.5).',
+                span: (view.settings[0] ?? view.notes[0]).span,
+            });
+        }
+        const written = new Map();
+        for (const c of view.categories) {
+            const first = written.get(c.category);
+            if (first) {
+                const same = first.keyword.toLowerCase() === c.keyword.toLowerCase();
+                diagnostics.push({
+                    severity: declared ? 'error' : 'warning',
+                    code: 'duplicate-diagram-view-category',
+                    message: same
+                        ? `Diagram view '${view.name}' writes ${c.keyword} twice. Write each category once (spec §18.1).`
+                        : `Diagram view '${view.name}' writes both ${first.keyword} and ${c.keyword}, which are one ` +
+                            'category: Schemas is the DBML name of Containers (spec §18.1).',
+                    span: c.span,
+                });
+            }
+            else {
+                written.set(c.category, c);
+            }
+            // §18.5: Containers, Views and SupertypeGroups are xDBML extensions.
+            if (!declared && c.keyword.toLowerCase() !== 'schemas'
+                && (c.category === 'Containers' || c.category === 'Views' || c.category === 'SupertypeGroups')) {
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'construct-requires-version',
+                    message: `The ${c.keyword} category of a diagram view is an xDBML extension and needs a version ` +
+                        'declaration such as xdbml: 0.6 at the top of the document' +
+                        (c.category === 'Containers' ? ', or the DBML name Schemas' : '') + ' (spec §18.5).',
+                    span: c.span,
+                });
+            }
+            if (c.wildcard)
+                continue;
+            for (const item of c.items) {
+                const r = resolveName(item.name, CATEGORY_KIND[c.category], index);
+                if (r.ok)
+                    continue;
+                if (r.reason === 'ambiguous') {
+                    diagnostics.push({
+                        severity: 'error',
+                        code: 'ambiguous-diagram-view-name',
+                        message: `'${item.name}' under ${c.keyword} matches ${r.candidates.map((x) => `'${x}'`).join(' and ')}, ` +
+                            'and none is declared outside a Container: write the qualified name (spec §18.3).',
+                        span: item.span,
+                    });
+                }
+                else if (r.reason === 'other-kind') {
+                    const right = KIND_CATEGORY[r.kind];
+                    diagnostics.push({
+                        severity: 'error',
+                        code: 'diagram-view-wrong-category',
+                        message: `'${item.name}' under ${c.keyword} is ${KIND_LABEL[r.kind]}` +
+                            (right
+                                ? `: list it under ${right} (spec §18.3).`
+                                : ', which appears in a diagram view when both of its ends do and is never listed (spec §18.1, §18.4).'),
+                        span: item.span,
+                    });
+                }
+                else {
+                    diagnostics.push({
+                        severity: 'error',
+                        code: 'unresolved-diagram-view-name',
+                        message: `'${item.name}' under ${c.keyword} matches no ${KIND_LABEL[CATEGORY_KIND[c.category]].replace(/^an? /, '')} ` +
+                            'in the project (spec §18.3).',
+                        span: item.span,
+                    });
+                }
+            }
+        }
+    }
+    return diagnostics;
+}

package/dist/index.d.ts

@@ -33,6 +33,8 @@ export { classifyModuleSource, isUrlKey, ModuleSourceError, } from './module-res
 export type { ModuleSource } from './module-resolver.ts';
 export { resolveNames, SymbolTable } from './name-resolver.ts';
 export { checkViews, viewSourceQuery } from './views.ts';
+export { checkDiagramViews, diagramViewMembers, diagramViewNote, diagramViews } from './diagram-views.ts';
+export type { DiagramViewMembers } from './diagram-views.ts';
 export { bodyConstraints, checkConstraints, entityConstraints, isRelationalTarget, keyPathString, markPrimaryKeyNotNull, primaryKey, } from './constraints.ts';
 export type { CheckConstraint, Constraint, ConstraintSource, KeyConstraint } from './constraints.ts';
 export { FOREIGN_MASTER_FLAG, checkRelationships, hasForeignMasterFlag, isForeignMaster, pathToString, refChildEndpoint, refParentEndpoint, relationshipType, versionAtLeast, CONSTRAINT_TYPES, V04_RELATIONSHIP_SETTINGS, constraintType, entityNames, isEntityLevelEndpoint, isUndirected, } from './relationships.ts';

package/dist/index.js

@@ -31,6 +31,7 @@ export { flatten } from "./module-resolver.js";
 export { classifyModuleSource, isUrlKey, ModuleSourceError, } from "./module-resolver.js";
 export { resolveNames, SymbolTable } from "./name-resolver.js";
 export { checkViews, viewSourceQuery } from "./views.js";
+export { checkDiagramViews, diagramViewMembers, diagramViewNote, diagramViews } from "./diagram-views.js";
 export { bodyConstraints, checkConstraints, entityConstraints, isRelationalTarget, keyPathString, markPrimaryKeyNotNull, primaryKey, } from "./constraints.js";
 export { FOREIGN_MASTER_FLAG, checkRelationships, hasForeignMasterFlag, isForeignMaster, pathToString, refChildEndpoint, refParentEndpoint, relationshipType, versionAtLeast, CONSTRAINT_TYPES, V04_RELATIONSHIP_SETTINGS, constraintType, entityNames, isEntityLevelEndpoint, isUndirected, } from "./relationships.js";
 export { SUPERTYPE_GROUP_VALUES, canonicalSupertypeGroupValue, checkSupertypeGroups, resolveSupertypeGroups, subtypeStrategy, supertypeChains, supertypeGroupSettings, } from "./supertypes.js";

package/dist/keywords.d.ts

@@ -39,6 +39,7 @@ export declare const POLYMORPHISM_KEYWORDS: readonly ["union", "oneof", "anyof",
 export declare const SCALAR_TYPES: readonly ["tinyint", "smallint", "mediumint", "int", "integer", "bigint", "int32", "int64", "float", "double", "decimal", "dec", "numeric", "real", "bit", "bool", "boolean", "char", "varchar", "varchar2", "nvarchar", "nvarchar2", "nchar", "text", "mediumtext", "longtext", "string", "ntext", "binary", "varbinary", "blob", "mediumblob", "longblob", "tinyblob", "tinytext", "json", "jsonb", "variant", "xml", "date", "time", "datetime", "datetime2", "timestamp", "timestamptz", "year", "uuid", "inet6", "money", "smallmoney", "enum"];
 export declare const BSON_TYPES: readonly ["objectid", "decimal128", "bindata", "minkey", "maxkey", "symbol", "regex", "long", "double"];
 export declare const BLOCK_KEYWORDS: readonly ["indexes", "checks", "constraints", "records"];
+export declare const DIAGRAM_VIEW_CATEGORIES: readonly ["tables", "views", "containers", "schemas", "tablegroups", "supertypegroups", "notes"];
 export declare const TARGET_NATIVE_TYPES: readonly ["number", "binary_float", "binary_double", "clob", "nclob", "bfile", "raw", "rowid", "urowid", "xmltype", "sdo_geometry", "interval", "serial", "smallserial", "bigserial", "serial2", "serial4", "serial8", "int2", "int4", "int8", "float4", "float8", "bytea", "citext", "inet", "cidr", "macaddr", "macaddr8", "tsvector", "tsquery", "hstore", "jsonpath", "timetz", "varbit", "int4range", "int8range", "numrange", "tsrange", "tstzrange", "daterange", "uniqueidentifier", "datetimeoffset", "smalldatetime", "rowversion", "hierarchyid", "sql_variant", "timestamp_ntz", "timestamp_ltz", "timestamp_tz", "vector", "float64", "bignumeric", "bigdecimal", "bytes", "geometry", "geography", "ascii", "varint", "timeuuid", "uint32", "uint64", "sint32", "sint64", "fixed32", "fixed64", "sfixed32", "sfixed64", "uint8", "uint16", "int16", "float32"];
 export declare const SETTING_FLAGS: readonly ["pk", "primary", "key", "unique", "null", "not", "required", "increment", "inactive", "foreign_master"];
 export declare const SETTING_KEYS: readonly ["note", "default", "ref", "name", "color", "headercolor", "as", "check", "type", "target", "targets", "database_type", "source", "source_cardinality", "target_cardinality", "min_source", "max_source", "min_target", "max_target", "undirected", "source_role", "target_role", "source_verb", "target_verb", "constraint_type", "discriminator", "supertype", "completeness", "exclusivity", "strategy", "merge", "source_query", "materialized", "refresh_schedule", "refresh_on", "source_database", "storage_options", "pattern", "format", "minlength", "maxlength", "minimum", "maximum", "exclusiveminimum", "exclusivemaximum", "multipleof", "minitems", "maxitems", "uniqueitems", "minproperties", "maxproperties", "synonyms", "business_term", "granularity", "tags", "delete", "update", "indexes", "checks", "constraints", "replication", "location", "default_charset", "cloned_at"];

package/dist/keywords.js

@@ -170,6 +170,22 @@ export const BSON_TYPES = [
  * and only when `{` follows, since a field may carry one of these names.
  * ----------------------------------------------------------------------- */
 export const BLOCK_KEYWORDS = ['indexes', 'checks', 'constraints', 'records'];
+/* -------------------------------------------------------------------------
+ * DiagramView categories (spec §18.1, v0.6.3)
+ *
+ * The words that open a category inside a DiagramView body. `schemas` is
+ * the DBML name of `containers`. Both highlighters color them only when `{`
+ * follows, since an entity or a field may carry one of these names.
+ * ----------------------------------------------------------------------- */
+export const DIAGRAM_VIEW_CATEGORIES = [
+    'tables',
+    'views',
+    'containers',
+    'schemas',
+    'tablegroups',
+    'supertypegroups',
+    'notes',
+];
 export const TARGET_NATIVE_TYPES = [
     // Oracle
     'number', 'binary_float', 'binary_double', 'clob', 'nclob', 'bfile',

package/dist/module-resolver.d.ts

@@ -107,6 +107,12 @@ export declare function isUrlKey(s: string): boolean;
  * union; throws ModuleSourceError for disallowed forms. Pure and sync.
  */
 export declare function classifyModuleSource(from: string): ModuleSource;
+/**
+ * A local file path with Windows backslashes turned into forward slashes;
+ * a URL key is returned unchanged. The parser keys modules, and detects
+ * import cycles, on paths in this form.
+ */
+export declare function toForwardSlashes(p: string): string;
 /**
  * Default recursion depth limit for module resolution. Enough for any
  * realistic module graph; small enough to bound stack usage on

package/dist/module-resolver.js

@@ -78,7 +78,18 @@ function flattenTopLevel(stmt, out) {
         return;
     }
     if (stmt.kind === 'ContainerDeclaration') {
-        out.push(flattenContainer(stmt));
+        // A `reuse *` inside a Container body can clone a DiagramView into it.
+        // A DiagramView is top-level only (spec §18.1), so it moves out to the
+        // top level, after its Container.
+        const flat = flattenContainer(stmt);
+        const hoisted = flat.body.filter((b) => b.kind === 'DiagramViewDeclaration');
+        if (hoisted.length === 0) {
+            out.push(flat);
+            return;
+        }
+        out.push({ ...flat, body: flat.body.filter((b) => !hoisted.includes(b)) });
+        for (const view of hoisted)
+            out.push(view);
         return;
     }
     // All other top-level statement kinds pass through unchanged.
@@ -376,8 +387,13 @@ function findImportTarget(item, doc) {
         }
         return undefined;
     }
-    // View / DiagramView: top-level OR container-scoped.
-    if (item.elementType === 'view' || item.elementType === 'diagramview') {
+    // DiagramView (spec §18): top-level only, bare name. Its names resolve
+    // in the importing document, like the members of a TableGroup.
+    if (item.elementType === 'diagramview') {
+        return doc.statements.find((s) => s.kind === 'DiagramViewDeclaration' && s.name === path);
+    }
+    // View: top-level OR container-scoped.
+    if (item.elementType === 'view') {
         if (segments.length === 1) {
             return doc.statements.find((s) => s.kind === 'ViewDeclaration' && s.name === segments[0]);
         }
@@ -614,6 +630,8 @@ function applyAlias(stmt, item) {
             return { ...stmt, name: item.alias };
         case 'SupertypeGroupDeclaration':
             return { ...stmt, name: item.alias };
+        case 'DiagramViewDeclaration':
+            return { ...stmt, name: item.alias };
         case 'TablePartialDeclaration':
             return { ...stmt, name: item.alias };
         case 'NoteDeclaration':
@@ -713,8 +731,11 @@ export function classifyModuleSource(from) {
  *     exactly as in v0.2.
  *
  * Uses pure string / WHATWG-URL manipulation (no node:path) so the same
- * code runs in Node and the browser. Forward slashes only; Windows paths
- * with backslashes should be normalized before reaching the parser.
+ * code runs in Node and the browser. A local path may use backslashes, as
+ * a native Windows path does (`C:\\repo\\main.xdbml`): they read as forward
+ * slashes, and the key handed to `readFile` uses forward slashes, which
+ * Node's fs accepts on Windows. Until v0.6.4 a backslash path lost its
+ * directory, so './lib' was read from the working directory instead.
  */
 function resolveModulePath(fromClause, importerPath) {
     const source = classifyModuleSource(fromClause);
@@ -731,21 +752,30 @@ function resolveModulePath(fromClause, importerPath) {
         // also what we want for the cycle-detection / de-duplication key.
         return new URL(rel, importerPath).href;
     }
-    // Local relative source (unchanged v0.2 behavior).
-    let withExt = source.from;
+    // Local relative source (v0.2 behavior, with Windows separators read as
+    // forward slashes from v0.6.4).
+    let withExt = toForwardSlashes(source.from);
     if (!withExt.endsWith('.xdbml')) {
         withExt = `${withExt}.xdbml`;
     }
-    // Absolute path: return as-is.
-    if (withExt.startsWith('/'))
+    // Absolute path, POSIX or with a Windows drive letter: return as-is.
+    if (withExt.startsWith('/') || /^[A-Za-z]:\//.test(withExt))
         return withExt;
     // No importer context: return as-is (resolver handles it).
     if (!importerPath)
         return withExt;
     // Resolve relative to importer's directory.
-    const importerDir = posixDirname(importerPath);
+    const importerDir = posixDirname(toForwardSlashes(importerPath));
     return posixJoin(importerDir, withExt);
 }
+/**
+ * A local file path with Windows backslashes turned into forward slashes;
+ * a URL key is returned unchanged. The parser keys modules, and detects
+ * import cycles, on paths in this form.
+ */
+export function toForwardSlashes(p) {
+    return isUrlKey(p) ? p : p.replace(/\\/g, '/');
+}
 function posixDirname(p) {
     const idx = p.lastIndexOf('/');
     if (idx < 0)

package/dist/monarch.js

@@ -18,7 +18,7 @@
  * dependency on consumers that just want to parse. The Monaco types
  * are structurally compatible -- the consumer casts at the boundary.
  */
-import { CONTAINER_KEYWORDS, ENTITY_KEYWORDS, DECLARATION_KEYWORDS, STRUCTURAL_TYPE_KEYWORDS, POLYMORPHISM_KEYWORDS, SCALAR_TYPES, BSON_TYPES, TARGET_NATIVE_TYPES, SETTING_FLAGS, SETTING_KEYS, GRANULARITY_VALUES, } from "./keywords.js";
+import { CONTAINER_KEYWORDS, ENTITY_KEYWORDS, DECLARATION_KEYWORDS, STRUCTURAL_TYPE_KEYWORDS, POLYMORPHISM_KEYWORDS, SCALAR_TYPES, BSON_TYPES, TARGET_NATIVE_TYPES, SETTING_FLAGS, SETTING_KEYS, GRANULARITY_VALUES, DIAGRAM_VIEW_CATEGORIES, } from "./keywords.js";
 /* -------------------------------------------------------------------------
  * Language configuration
  * ----------------------------------------------------------------------- */
@@ -160,6 +160,9 @@ export const xdbmlMonarchTokensProvider = {
             // or at the top level before a name and '{'. Anywhere else it names a
             // field, so it takes the identifier color like any other field name.
             [/note(?![\w$])(?!\s*[:{])(?!\s+(?:[A-Za-z_][\w$]*|"[^"]*")\s*\{)/, 'identifier'],
+            // Spec §18.1 (v0.6.3): a DiagramView category keyword opens its list
+            // only before '{'. Elsewhere the same word names an entity or a field.
+            [new RegExp(`(?:${DIAGRAM_VIEW_CATEGORIES.join('|')})(?![\\w$])(?=\\s*\\{)`), 'keyword.declaration'],
             // Identifiers and keyword recognition.
             // The parser is the authority on keyword vs identifier disambiguation;
             // Monarch does coarse highlighting based on lowercase comparison.

package/dist/name-resolver.d.ts

@@ -67,7 +67,7 @@ export interface SymbolEntry {
  * Stable diagnostic code. Tooling can match on these to filter or style
  * messages without parsing the human-readable text.
  */
-export type DiagnosticCode = 'duplicate-declaration' | 'name-collision' | 'container-target-missing' | 'container-target-not-in-project' | 'unresolved-type' | 'possible-type-typo' | 'unresolved-key-field' | 'unresolved-index-field' | 'key-path-crosses-collection' | 'invalid-key-flags' | 'duplicate-primary-key' | 'duplicate-unique-key' | 'null-in-primary-key' | 'duplicate-constraints-block' | 'ref-target-not-key' | 'unresolved-entity' | 'unresolved-field' | 'unresolved-partial' | 'unresolved-tablegroup-member' | 'unresolved-records-entity' | 'unresolved-records-column' | 'empty-import' | 'invalid-nested-path' | 'foreign-master-composite' | 'foreign-master-duplicate-child' | 'foreign-master-without-ref' | 'construct-requires-version' | 'ambiguous-ref-endpoint' | 'invalid-constraint-type' | 'constraint-type-on-foreign-master' | 'invalid-undirected' | 'entity-level-many-to-many' | 'missing-supertype' | 'unresolved-supertype-group-member' | 'invalid-supertype-group-value' | 'duplicate-subtype' | 'supertype-is-subtype' | 'subtype-in-multiple-groups' | 'supertype-cycle' | 'supertype-attribute-redeclared' | 'discriminator-on-overlapping-group' | 'merge-without-roll-up' | 'empty-supertype-group' | 'source-query-in-settings' | 'duplicate-source-query';
+export type DiagnosticCode = 'duplicate-declaration' | 'name-collision' | 'container-target-missing' | 'container-target-not-in-project' | 'unresolved-type' | 'possible-type-typo' | 'unresolved-key-field' | 'unresolved-index-field' | 'key-path-crosses-collection' | 'invalid-key-flags' | 'duplicate-primary-key' | 'duplicate-unique-key' | 'null-in-primary-key' | 'duplicate-constraints-block' | 'ref-target-not-key' | 'unresolved-entity' | 'unresolved-field' | 'unresolved-partial' | 'unresolved-tablegroup-member' | 'unresolved-records-entity' | 'unresolved-records-column' | 'empty-import' | 'invalid-nested-path' | 'foreign-master-composite' | 'foreign-master-duplicate-child' | 'foreign-master-without-ref' | 'construct-requires-version' | 'ambiguous-ref-endpoint' | 'invalid-constraint-type' | 'constraint-type-on-foreign-master' | 'invalid-undirected' | 'entity-level-many-to-many' | 'missing-supertype' | 'unresolved-supertype-group-member' | 'invalid-supertype-group-value' | 'duplicate-subtype' | 'supertype-is-subtype' | 'subtype-in-multiple-groups' | 'supertype-cycle' | 'supertype-attribute-redeclared' | 'discriminator-on-overlapping-group' | 'merge-without-roll-up' | 'empty-supertype-group' | 'source-query-in-settings' | 'duplicate-source-query' | 'duplicate-diagram-view' | 'duplicate-diagram-view-category' | 'unresolved-diagram-view-name' | 'ambiguous-diagram-view-name' | 'diagram-view-wrong-category' | 'unknown-diagram-view-setting' | 'invalid-tuple-positions' | 'named-type-shadows-builtin';
 /**
  * A single resolution diagnostic. Severity is currently always `error`,
  * but the field is included to leave room for future warnings (e.g.,

package/dist/name-resolver.js

@@ -45,6 +45,7 @@ import { checkSupertypeGroups } from "./supertypes.js";
 import { checkConstraints, checkTargets } from "./constraints.js";
 import { versionAtLeast } from "./relationships.js";
 import { checkViews } from "./views.js";
+import { checkDiagramViews } from "./diagram-views.js";
 /**
  * Read-only handle on the collected symbol table.
  *
@@ -236,6 +237,30 @@ export function resolveNames(doc) {
     diagnostics.push(...checkTargets(flat));
     // Pass 6: view source queries (spec §14.7).
     diagnostics.push(...checkViews(flat));
+    // Pass 7: diagram views (spec §18.6).
+    diagnostics.push(...checkDiagramViews(flat));
+    // Pass 8: Types under the name of a built-in type (spec §15.2).
+    for (const t of flat.statements) {
+        if (t.kind !== 'TypeDeclaration' || !BUILTIN_TYPES.has(t.name.toLowerCase()))
+            continue;
+        {
+            diagnostics.push({
+                severity: 'error',
+                code: 'named-type-shadows-builtin',
+                message: `Type '${t.name}' takes the name of a built-in type. Built-in types take precedence, so a field ` +
+                    `typed ${t.name.toLowerCase()} keeps the built-in type: rename the Type (spec §15.2).`,
+                span: t.span,
+            });
+        }
+    }
+    // The parser checked neither rule before v0.6.4, so a document declaring
+    // a version earlier than 0.6 draws a warning and stays valid (§8.6, §15.2).
+    if (!versionAtLeast(flat, '0.6')) {
+        for (const d of diagnostics) {
+            if (d.code === 'invalid-tuple-positions' || d.code === 'named-type-shadows-builtin')
+                d.severity = 'warning';
+        }
+    }
     return { diagnostics, symbols };
 }
 /* -------------------------------------------------------------------------
@@ -566,11 +591,24 @@ function resolveTypeExpression(expr, symbols, diagnostics) {
         case 'SetType':
             resolveTypeExpression(expr.elementType, symbols, diagnostics);
             return;
-        case 'TupleType':
+        case 'TupleType': {
+            // Spec §8.6: positions form a contiguous range from 0, each once.
+            const positions = expr.elements.map((e) => e.position);
+            const sorted = [...positions].sort((a, b) => a - b);
+            if (sorted.some((p, i) => p !== i)) {
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'invalid-tuple-positions',
+                    message: `Tuple positions ${positions.map((p) => `[${p}]`).join(', ')} do not run from [0] to ` +
+                        `[${positions.length - 1}], each once: a tuple numbers its elements from 0 without a gap (spec §8.6).`,
+                    span: expr.span,
+                });
+            }
             for (const elem of expr.elements) {
                 resolveTypeExpression(elem.type, symbols, diagnostics);
             }
             return;
+        }
         case 'JsonType':
             // No nested type expressions.
             return;

package/dist/parser.d.ts

@@ -26,7 +26,7 @@ export declare class ParseError extends Error {
  * declaring a later version is refused (spec 4.1) rather than parsed with
  * semantics it does not have.
  */
-export declare const SUPPORTED_XDBML_VERSION = "0.6.2";
+export declare const SUPPORTED_XDBML_VERSION = "0.6.4";
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export declare function compareVersions(a: string, b: string): number;
 export declare class Parser {
@@ -40,6 +40,8 @@ export declare class Parser {
      * 1-arg form).
      */
     private options;
+    /** The version the document declares, once read; undefined without a declaration. */
+    private declaredVersion;
     /**
      * The set of file paths currently being parsed in the resolution chain.
      * Used for cycle detection: when resolving a directive whose `from` path
@@ -345,6 +347,21 @@ export declare class Parser {
      * rather than stopping the parse.
      */
     private parseSupertypeGroup;
+    /**
+     * `DiagramView <name> { <Category> { <names> | * } ... }`, or
+     * `DiagramView <name> { * }` for every element of every category.
+     * Category keywords are case-insensitive; `Schemas` reads as `Containers`.
+     * Lists follow spec §3.9: whitespace between names, with commas and
+     * semicolons allowed and meaningless. Names stay unresolved here; the
+     * checks of §18.6 run after parsing, in `checkDiagramViews()`, so a bad
+     * name gets a located diagnostic and the rest of the diagram still draws.
+     * Two conditions stop the parse because they leave no category to read:
+     * an unknown category, `Edges` included, and a body-level `*` with a
+     * category beside it. A note may sit in the brackets or in the body
+     * (spec §18.1, v0.6.3).
+     */
+    private parseDiagramView;
+    private parseDiagramViewCategory;
     private parseIndexes;
     private parseIndexEntry;
     private parseIndexComponent;

package/dist/parser.js

@@ -11,7 +11,7 @@
  */
 import { markPrimaryKeyNotNull } from "./constraints.js";
 import { TokenKind, tokenize, } from "./lexer.js";
-import { resolveImport, classifyModuleSource, ModuleSourceError } from "./module-resolver.js";
+import { resolveImport, classifyModuleSource, ModuleSourceError, toForwardSlashes } from "./module-resolver.js";
 export class ParseError extends Error {
     position;
     /**
@@ -32,7 +32,7 @@ export class ParseError extends Error {
  * declaring a later version is refused (spec 4.1) rather than parsed with
  * semantics it does not have.
  */
-export const SUPPORTED_XDBML_VERSION = '0.6.2';
+export const SUPPORTED_XDBML_VERSION = '0.6.4';
 /** Compare dotted version strings numerically: -1, 0 or 1. */
 export function compareVersions(a, b) {
     const pa = a.split('.').map((n) => Number(n) || 0);
@@ -74,6 +74,19 @@ const IMPORT_ELEMENT_TYPES = new Set([
     'type', 'edge', 'view', 'diagramview',
     'field', 'supertypegroup',
 ]);
+/**
+ * DiagramView categories (spec §18.1), by lowercased keyword. `Schemas`, the
+ * DBML name, reads as `Containers`, after the `Schema` keyword (§6.2).
+ */
+const DIAGRAM_VIEW_CATEGORIES = {
+    tables: 'Tables',
+    views: 'Views',
+    containers: 'Containers',
+    schemas: 'Containers',
+    tablegroups: 'TableGroups',
+    supertypegroups: 'SupertypeGroups',
+    notes: 'Notes',
+};
 const STRUCTURAL_TYPE_KEYWORDS = new Set([
     'object', 'struct', 'record', 'array', 'list', 'map', 'dict', 'dictionary',
     'set', 'union', 'oneof', 'anyof', 'allof', 'json', 'jsonb', 'variant',
@@ -121,6 +134,8 @@ export class Parser {
      * 1-arg form).
      */
     options;
+    /** The version the document declares, once read; undefined without a declaration. */
+    declaredVersion;
     /**
      * The set of file paths currently being parsed in the resolution chain.
      * Used for cycle detection: when resolving a directive whose `from` path
@@ -261,6 +276,7 @@ export class Parser {
             this.advance(); // .
             version += `.${this.advance().text}`;
         }
+        this.declaredVersion = version;
         if (compareVersions(version, SUPPORTED_XDBML_VERSION) > 0) {
             throw new ParseError(`This document declares 'xdbml: ${version}', which is newer than the ` +
                 `latest version this parser supports (${SUPPORTED_XDBML_VERSION}). ` +
@@ -320,6 +336,8 @@ export class Parser {
             return this.parseTableGroup();
         if (k === 'supertypegroup')
             return this.parseSupertypeGroup();
+        if (k === 'diagramview')
+            return this.parseDiagramView();
         if (k === 'note')
             return this.parseNoteDeclaration();
         if (k === 'records')
@@ -471,6 +489,10 @@ export class Parser {
             else if (k === 'use' || k === 'reuse') {
                 body.push(this.parseModuleDirective('container-body'));
             }
+            else if (k === 'diagramview') {
+                throw new ParseError(`A DiagramView is a top-level declaration and never appears in a Container (spec §18.1). ` +
+                    `Move it out of Container '${name}'.`, t.start);
+            }
             else {
                 // Unknown line; tolerate as no-op rather than fail the whole parse.
                 throw new ParseError(`Unexpected token in Container body: ${t.kind} ${JSON.stringify(t.text)}`, t.start);
@@ -714,6 +736,12 @@ export class Parser {
         const start = this.peek().start;
         const modeTok = this.advance(); // 'use' or 'reuse'
         const mode = modeTok.text.toLowerCase();
+        // Appendix D, item 3: the module system belongs to the v0.2 feature set,
+        // so a document declaring xdbml: 0.1 cannot use it (checked from v0.6.4).
+        if (this.declaredVersion && compareVersions(this.declaredVersion, '0.2') < 0) {
+            throw new ParseError(`The module system (use and reuse) needs xdbml: 0.2 or later; this document declares ` +
+                `xdbml: ${this.declaredVersion} (spec §27, Appendix D).`, modeTok.start);
+        }
         // Import spec: '*' or '{ ... }'
         let spec;
         if (this.check(TokenKind.Star)) {
@@ -723,16 +751,15 @@ export class Parser {
         else if (this.check(TokenKind.LBrace)) {
             this.advance();
             const items = [];
-            // Skip leading whitespace/newlines (already handled by lexer).
-            while (!this.check(TokenKind.RBrace) && !this.check(TokenKind.EOF)) {
-                items.push(this.parseImportItem(context));
-                if (this.match(TokenKind.Comma)) {
-                    // Tolerate trailing comma before the closing brace.
-                    continue;
-                }
-                else {
+            // A list body (spec §3.9, §27.2, v0.6.4): items one per line, or
+            // separated by commas, with commas and semicolons optional anywhere
+            // between items. Until v0.6.4 the parser required a comma between
+            // two items, against the multi-line form §27.2 shows.
+            for (;;) {
+                this.skipListSeparators();
+                if (this.check(TokenKind.RBrace) || this.check(TokenKind.EOF))
                     break;
-                }
+                items.push(this.parseImportItem(context));
             }
             this.expect(TokenKind.RBrace, "Expected '}' closing import item list");
             if (items.length === 0) {
@@ -860,6 +887,11 @@ export class Parser {
             throw new ParseError(`Unknown import element type '${elemTok.text}'. ` +
                 `Expected one of: ${Array.from(IMPORT_ELEMENT_TYPES).join(', ')}.`, elemTok.start);
         }
+        if (elementType === 'diagramview' && context !== 'file-scope') {
+            // Spec §18.1, §27.5: a DiagramView is a top-level declaration, so its
+            // import goes at file scope, where the declaration itself would.
+            throw new ParseError('A DiagramView is a top-level declaration: import it at file scope, not inside a Container body (spec §18.1, §27.5).', elemTok.start);
+        }
         if (elementType === 'field' && context !== 'file-scope') {
             // Spec §27.8: field imports must appear at file scope. Inside a
             // Container body, the field's eventual placement (as a Named Type)
@@ -1951,6 +1983,120 @@ export class Parser {
             span: this.spanFrom(start),
         };
     }
+    /* ----- DiagramView (spec §18, defined in v0.6.3) ----- */
+    /**
+     * `DiagramView <name> { <Category> { <names> | * } ... }`, or
+     * `DiagramView <name> { * }` for every element of every category.
+     * Category keywords are case-insensitive; `Schemas` reads as `Containers`.
+     * Lists follow spec §3.9: whitespace between names, with commas and
+     * semicolons allowed and meaningless. Names stay unresolved here; the
+     * checks of §18.6 run after parsing, in `checkDiagramViews()`, so a bad
+     * name gets a located diagnostic and the rest of the diagram still draws.
+     * Two conditions stop the parse because they leave no category to read:
+     * an unknown category, `Edges` included, and a body-level `*` with a
+     * category beside it. A note may sit in the brackets or in the body
+     * (spec §18.1, v0.6.3).
+     */
+    parseDiagramView() {
+        const start = this.peek().start;
+        this.advance(); // DiagramView
+        const nameTok = this.peek();
+        if (nameTok.kind !== TokenKind.Identifier && nameTok.kind !== TokenKind.QuotedIdentifier) {
+            throw new ParseError('Expected a name after DiagramView (spec §18.1)', nameTok.start);
+        }
+        const name = this.parseIdentLikeName('DiagramView name');
+        // Spec §18.1 (v0.6.3): `note` and custom properties in the brackets.
+        // Other settings are reported by checkDiagramViews(), not here.
+        const settings = this.maybeSettingsBlock();
+        this.expect(TokenKind.LBrace, `Expected '{' after DiagramView ${name}`);
+        const categories = [];
+        const notes = [];
+        let wildcardBody = false;
+        for (;;) {
+            this.skipListSeparators();
+            const t = this.peek();
+            if (t.kind === TokenKind.RBrace || t.kind === TokenKind.EOF)
+                break;
+            if (this.atNoteElement()) {
+                notes.push(this.parseNoteBlockOrSetting());
+                continue;
+            }
+            if (t.kind === TokenKind.Star) {
+                if (categories.length > 0 || wildcardBody) {
+                    throw new ParseError(`A '*' body lists every element of every category, so no category goes beside it in DiagramView ${name} (spec §18.1)`, t.start);
+                }
+                this.advance();
+                wildcardBody = true;
+                continue;
+            }
+            const k = kw(t);
+            const category = k ? DIAGRAM_VIEW_CATEGORIES[k] : undefined;
+            if (!category) {
+                if (k === 'edges') {
+                    throw new ParseError('Edges is not a DiagramView category: a Ref or an Edge appears in a diagram view when both ' +
+                        'of its ends do, so there is nothing to list (spec §18.1, §18.4)', t.start);
+                }
+                throw new ParseError(`Unknown DiagramView category ${JSON.stringify(t.text)}. Expected Tables, Views, Containers ` +
+                    '(or Schemas), TableGroups, SupertypeGroups or Notes, each followed by { names }, or a Note (spec §18.1)', t.start);
+            }
+            if (wildcardBody) {
+                throw new ParseError(`A '*' body lists every element of every category, so no category goes beside it in DiagramView ${name} (spec §18.1)`, t.start);
+            }
+            categories.push(this.parseDiagramViewCategory(category));
+        }
+        this.expect(TokenKind.RBrace, "Expected '}' closing DiagramView");
+        return {
+            kind: 'DiagramViewDeclaration',
+            name,
+            settings,
+            notes,
+            wildcardBody,
+            categories,
+            span: this.spanFrom(start),
+        };
+    }
+    parseDiagramViewCategory(category) {
+        const start = this.peek().start;
+        const keywordTok = this.advance();
+        this.expect(TokenKind.LBrace, `Expected '{' after ${keywordTok.text} in a DiagramView`);
+        const items = [];
+        let wildcard = false;
+        for (;;) {
+            this.skipListSeparators();
+            const t = this.peek();
+            if (t.kind === TokenKind.RBrace || t.kind === TokenKind.EOF)
+                break;
+            if (t.kind === TokenKind.Star) {
+                this.advance();
+                wildcard = true;
+                continue;
+            }
+            if (t.kind !== TokenKind.Identifier && t.kind !== TokenKind.QuotedIdentifier) {
+                throw new ParseError(`Expected a name or '*' in ${keywordTok.text} { }, got ${t.kind} ${JSON.stringify(t.text)}`, t.start);
+            }
+            this.advance();
+            let n = t.kind === TokenKind.QuotedIdentifier ? (t.value ?? '') : t.text;
+            while (this.check(TokenKind.Dot)) {
+                this.advance();
+                const next = this.peek();
+                if (next.kind !== TokenKind.Identifier && next.kind !== TokenKind.QuotedIdentifier) {
+                    throw new ParseError(`Expected identifier after '.' in ${keywordTok.text} { }`, next.start);
+                }
+                this.advance();
+                n += `.${next.kind === TokenKind.QuotedIdentifier ? (next.value ?? '') : next.text}`;
+            }
+            items.push({ kind: 'DiagramViewItem', name: n, span: this.spanFrom(t.start) });
+        }
+        this.expect(TokenKind.RBrace, `Expected '}' closing ${keywordTok.text}`);
+        return {
+            kind: 'DiagramViewCategory',
+            category,
+            keyword: keywordTok.text,
+            wildcard,
+            items,
+            span: this.spanFrom(start),
+        };
+    }
     /* ----- Indexes ----- */
     parseIndexes() {
         const start = this.peek().start;
@@ -2386,7 +2532,7 @@ export function parse(source, options = {}) {
     // the outer level too). If no filePath is provided, the stack is empty.
     const initialStack = new Set();
     if (options.filePath)
-        initialStack.add(options.filePath);
+        initialStack.add(toForwardSlashes(options.filePath));
     const doc = new Parser(tokens, options, initialStack, 0).parseDocument();
     applyEntityAliases(doc);
     return doc;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xdbml/parse",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Parser for xDBML (eXtended Database Markup Language), a strict superset of DBML 3.13.6: tokenizer, parser, module resolver, and name resolver.",
   "license": "Apache-2.0",
   "author": "Hackolade",