@dbml/parse 10.4.0-alpha.2 → 11.0.0-alpha.2

package/dist/src/compiler/index.d.ts

@@ -1,9 +1,22 @@
+import { GlobalModule } from '../core/global_modules/types';
+import { ParserOptions } from '../core/parser/parser';
+import { LexerOptions } from '../core/lexer/lexer';
+import { SyntaxToken } from '../core/types/tokens';
+import { FileKind, FileScan } from './queries/files/fileKind';
 import { Filepath } from '../core/types/filepath';
 import { SyntaxNode, SyntaxNodeIdGenerator } from '../core/types/nodes';
 import { NodeSymbolIdGenerator, SymbolFactory } from '../core/types/symbol';
 import { DBMLCodeActionProvider, DBMLCompletionItemProvider, DBMLDefinitionProvider, DBMLDiagnosticsProvider, DBMLReferencesProvider } from '../services/index';
 import { DbmlProjectLayout } from './projectLayout';
 import { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString } from './queries/utils';
+/**
+ * Grammar switches a dialect asks for, gathered in one place so the Compiler does not grow a
+ * parameter per stage. Every switch inside is off by default, so DBML is exactly what it was.
+ */
+export interface DialectOptions {
+    lexer?: LexerOptions;
+    parser?: ParserOptions;
+}
 export { ScopeKind } from './types';
 export type { TextEdit } from './queries/transform';
 export { addDoubleQuoteIfNeeded, escapeString, formatRecordValue, isValidIdentifier, normalizeQualifiedName, splitQualifiedIdentifier, unescapeString, };
@@ -12,8 +25,27 @@ export default class Compiler {
     readonly nodeIdGenerator: SyntaxNodeIdGenerator;
     readonly symbolIdGenerator: NodeSymbolIdGenerator;
     readonly symbolFactory: SymbolFactory;
-    constructor(layout: DbmlProjectLayout);
+    readonly explicitModules: GlobalModule[] | undefined;
+    private readonly explicitDialect;
+    readonly dialect: DialectOptions;
+    /**
+     * @param layout the structure of the DbmlProject
+     * @param modules the element vocabulary for every file. When omitted, each file uses the
+     *   modules of its own kind (DBML or architecture).
+     * @param dialect grammar switches for every file. When omitted, each file gets its kind's switches.
+     */
+    constructor(layout: DbmlProjectLayout, modules?: GlobalModule[], dialect?: DialectOptions);
     getSource(filepath: Filepath): string | undefined;
+    lexerOptions(): LexerOptions;
+    parserOptions(kind: FileKind): ParserOptions;
+    private fileScans;
+    private fileKinds;
+    scanFile(filepath: Filepath, tokens?: readonly SyntaxToken[]): FileScan;
+    fileKind(filepath: Filepath): FileKind;
+    fileKindForParse(filepath: Filepath, tokens?: readonly SyntaxToken[]): FileKind;
+    parsedFileKind(filepath: Filepath): FileKind;
+    private decideKind;
+    private refreshFileKind;
     private sourceSnapshot;
     private cleanStaleLocalCache;
     private entrypointsSnapshot;
@@ -70,8 +102,9 @@ export default class Compiler {
             }[];
         };
     }>;
-    nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | import('..').SyntaxToken | undefined;
+    nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | SyntaxToken | undefined;
     renameTable: (filepath: Filepath, oldName: string | import('..').TableIdentifier, newName: string | import('..').TableIdentifier) => Map<string, string>;
+    renameElement: (filepath: Filepath, oldHandle: string, newName: string) => Map<string, string>;
     updateElementSetting: (filepath: Filepath, target: import('..').ElementIdentifier, settingName: string, value: string | null | undefined) => string;
     updateElementSettingEdit: (filepath: Filepath, target: import('..').ElementIdentifier, settingName: string, value: string | null | undefined) => import('.').TextEdit[];
     syncDiagramView: (filepath: Filepath, operations: import('..').DiagramViewSyncOperation[], blocks?: import('..').DiagramViewBlock[] | undefined) => {
@@ -83,22 +116,22 @@ export default class Compiler {
         edits: import('.').TextEdit[];
     };
     readonly token: {
-        invalidStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
-        flatStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
+        invalidStream: (filepath: Filepath) => readonly SyntaxToken[];
+        flatStream: (filepath: Filepath) => readonly SyntaxToken[];
     };
     readonly parse: {
         source: (filepath: Filepath) => string;
         ast: (filepath?: Filepath) => Readonly<import('../core/types/nodes').ProgramNode>;
         errors: (filepath?: Filepath) => readonly Readonly<import('..').CompileError>[];
-        warnings: (filepath?: Filepath) => readonly Readonly<import('..').CompileWarning>[];
-        tokens: (filepath?: Filepath) => readonly Readonly<import('..').SyntaxToken>[];
+        warnings: (filepath?: Filepath) => readonly Readonly<import('../core/types').CompileWarning>[];
+        tokens: (filepath?: Filepath) => readonly Readonly<SyntaxToken>[];
         rawDb: (filepath?: Filepath) => Readonly<import('..').Database> | undefined;
         publicSymbolTable: (filepath?: Filepath) => readonly Readonly<import('../core/types/symbol').NodeSymbol>[] | undefined;
     };
     readonly container: {
         stack: (filepath: Filepath, offset: number) => readonly Readonly<SyntaxNode>[];
         token: (filepath: Filepath, offset: number) => {
-            token: import('..').SyntaxToken;
+            token: SyntaxToken;
             index: number;
         } | {
             token: undefined;
@@ -111,7 +144,6 @@ export default class Compiler {
     initMonacoServices(options?: {
         autocompletion?: {
             triggerCharacters?: string[];
-            fileListDepth?: number;
         };
     }): {
         definitionProvider: DBMLDefinitionProvider;

package/dist/src/compiler/projectLayout/layout.d.ts

@@ -1,12 +1,6 @@
 import { Filepath } from '../../core/types/filepath';
-export interface FileSpecifierInfo {
-    specifier: string;
-    label?: string;
-    detail?: string;
-}
 export interface DbmlProjectLayout {
     resolveFileSpecifier(currentFilepath: Filepath, specifier: string): Filepath | undefined;
-    getFileSpecifierInfo(currentFilepath: Filepath, targetFilepath: Filepath): FileSpecifierInfo | undefined;
     getSource(filePath: Filepath): string | undefined;
     exists(filePath: Filepath): boolean;
     isFile(filePath: Filepath): boolean;
@@ -18,7 +12,6 @@ export declare class MemoryProjectLayout implements DbmlProjectLayout {
     private readonly files;
     constructor(files?: Map<string, string> | Record<string, string>);
     resolveFileSpecifier(currentFilepath: Filepath, relativePath: string): Filepath | undefined;
-    getFileSpecifierInfo(currentFilepath: Filepath, targetFilepath: Filepath): FileSpecifierInfo | undefined;
     setSource(filePath: Filepath, content: string): void;
     getSource(filePath: Filepath): string | undefined;
     deleteSource(filePath: Filepath): void;

package/dist/src/compiler/queries/files/fileKind.d.ts

@@ -0,0 +1,18 @@
+import { SyntaxToken } from '../../../core/types/tokens';
+export type FileKind = 'dbml' | 'arch';
+export declare const ARCH_DIAGRAM_TYPES: Set<string>;
+export declare const isArchDiagramType: (type: string | null | undefined) => boolean;
+export interface FileScan {
+    frontMatter: Record<string, string>;
+    topWords: string[];
+    kindNames: string[];
+    usePaths: string[];
+}
+export declare function readFrontMatter(block: string): Record<string, string>;
+export declare function frontMatterToken(tokens: readonly SyntaxToken[]): SyntaxToken | undefined;
+export declare function scanTokens(tokens: readonly SyntaxToken[]): FileScan;
+export interface FileKindResult {
+    kind: FileKind;
+    dependsOnImports: boolean;
+}
+export declare function decideFileKind(scan: FileScan, importedScans: () => FileScan[]): FileKindResult;

package/dist/src/compiler/queries/transform/index.d.ts

@@ -1,6 +1,7 @@
 export { renameTable } from './renameTable';
+export { renameElement } from './renameElement';
 export { updateElementSetting, updateElementSettingEdit } from './updateElementSetting';
 export { syncDiagramView, findDiagramViewBlocks, type DiagramViewSyncOperation, type DiagramViewBlock, } from './syncDiagramView';
 export { syncDep, generateDepBlock, type DepSyncOperation, type DepSyncEdge, type DepEndpointRef, } from './syncDep';
 export { applyTextEdits, type TextEdit } from './applyTextEdits';
-export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, } from './types';
+export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, ArchElementIdentifier, ArchLinkIdentifier, } from './types';

package/dist/src/compiler/queries/transform/renameElement.d.ts

@@ -0,0 +1,13 @@
+import { Filepath } from '../../../core/types/filepath';
+import { default as Compiler } from '../../index';
+/**
+ * Renames an architecture element (node, group or note box) in `filepath`.
+ *
+ * With an `as` alias, links, groups and metadata name the element by its alias, so only the
+ * name changes. Without one the name is the handle, so every link endpoint, group member and
+ * metadata target in the same file that names it is renamed too.
+ *
+ * Returns a map of absolute file paths to new source content. An empty map indicates a no-op
+ * (lookup miss or name collision).
+ */
+export declare function renameElement(this: Compiler, filepath: Filepath, oldHandle: string, newName: string): Map<string, string>;

package/dist/src/compiler/queries/transform/types.d.ts

@@ -1,6 +1,6 @@
 import { SymbolKind } from '../../../core/types/symbol';
 import { MetadataKind } from '../../../core/types/symbol/metadata';
-export type ElementIdentifier = (SchemaIdentifier | TableIdentifier | ColumnIdentifier | EnumIdentifier | RefIdentifier | DepIdentifier | NoteIdentifier | TableGroupIdentifier) & {
+export type ElementIdentifier = (SchemaIdentifier | TableIdentifier | ColumnIdentifier | EnumIdentifier | RefIdentifier | DepIdentifier | NoteIdentifier | TableGroupIdentifier | ArchElementIdentifier | ArchLinkIdentifier) & {
     kind: string;
 };
 export interface SchemaIdentifier {
@@ -46,3 +46,12 @@ export interface TableGroupIdentifier {
     schema?: string;
     name: string;
 }
+export interface ArchElementIdentifier {
+    kind?: typeof SymbolKind.Element;
+    name: string;
+}
+export interface ArchLinkIdentifier {
+    kind?: 'Link';
+    from: string;
+    to: string;
+}

package/dist/src/compiler/queries/transform/utils/arch.d.ts

@@ -0,0 +1,6 @@
+import { Filepath } from '../../../../core/types/filepath';
+import { ElementDeclarationNode } from '../../../../core/types/nodes';
+import { default as Compiler } from '../../../index';
+export declare function archDeclarations(compiler: Compiler, filepath: Filepath): ElementDeclarationNode[];
+export declare function findArchElement(compiler: Compiler, filepath: Filepath, handle: string): ElementDeclarationNode | undefined;
+export declare function findArchLink(compiler: Compiler, filepath: Filepath, from: string, to: string): ElementDeclarationNode | undefined;

package/dist/src/core/arch/icons.d.ts

@@ -0,0 +1,5 @@
+export declare const ICON_NAMES: string[];
+/** what people actually type; an alias costs one line and saves a diagnostic */
+export declare const ICON_ALIAS: Record<string, string>;
+export declare const resolveIcon: (name: string) => string;
+export declare const isIconName: (name: string) => boolean;

package/dist/src/core/arch/read.d.ts

@@ -0,0 +1,51 @@
+import { ElementDeclarationNode, ListExpressionNode, SyntaxNode } from '../types/nodes';
+import { ArchSettingValue, ArchSettings } from '../types/schemaJson';
+export type ArchSort = 'node' | 'group' | 'note' | 'kind' | 'link' | 'metadata' | 'project';
+export declare const declarationWord: (node: ElementDeclarationNode) => string | undefined;
+export declare function isTopLevel(node: SyntaxNode): node is ElementDeclarationNode;
+export declare function archSort(node: SyntaxNode): ArchSort | undefined;
+export declare function topLevelDeclaration(node: SyntaxNode): ElementDeclarationNode | undefined;
+export declare function nameOf(node?: SyntaxNode): string | undefined;
+export declare const handleOf: (node: ElementDeclarationNode) => string | undefined;
+export declare function numberOf(node?: SyntaxNode): number | null;
+export declare function valueOf(node: SyntaxNode): ArchSettingValue | undefined;
+export declare function settingsOf(list?: ListExpressionNode): ArchSettings;
+export declare function bodyOf(node: ElementDeclarationNode): SyntaxNode[];
+export interface Row {
+    callee: SyntaxNode | undefined;
+    args: SyntaxNode[];
+    settings: ListExpressionNode | undefined;
+}
+export declare function rowOf(node: SyntaxNode | undefined): Row | undefined;
+export interface Infix {
+    left: SyntaxNode;
+    op: string;
+    right: SyntaxNode;
+}
+export declare function infixOf(node?: SyntaxNode): Infix | undefined;
+export declare function endpointNode(node: SyntaxNode): SyntaxNode;
+export declare const LINK_OPS: Set<string>;
+export interface LinkParts {
+    row: Row | undefined;
+    infix: Infix;
+}
+export declare function linkPartsOf(declaration: ElementDeclarationNode): LinkParts | undefined;
+export interface Property {
+    key: string;
+    value: ArchSettingValue | undefined;
+}
+export declare function propertyOf(node: SyntaxNode): Property | undefined;
+export declare function noteDeclarationOf(declaration: ElementDeclarationNode): ElementDeclarationNode | undefined;
+export declare function noteTextOf(note: ElementDeclarationNode): string;
+export declare function noteBoxTextOf(declaration: ElementDeclarationNode): string;
+export declare const IMAGE_URL: RegExp;
+export declare const IMAGE_REFUSED = "A picture must be an https: URL or a data:image/ URI.";
+export interface BodyRead {
+    settings: ArchSettings;
+    problems: {
+        code: 'bad' | 'duplicate';
+        message: string;
+        node: SyntaxNode;
+    }[];
+}
+export declare function readBody(declaration: ElementDeclarationNode, settings: ArchSettings, bareWordIsAFlag: boolean): BodyRead;

package/dist/src/core/arch/vocabulary.d.ts

@@ -0,0 +1,11 @@
+export type Category = 'compute' | 'data' | 'net' | 'edge' | 'people' | 'ops' | 'custom';
+export interface KindSpec {
+    icon: string;
+    category: Category;
+}
+export declare const BUILTIN_KINDS: Record<string, KindSpec>;
+export declare const builtinKindName: (typed: string) => string | undefined;
+export declare function suggestKind(typed: string): string;
+export declare const RESERVED: Set<string>;
+export declare const isReserved: (word: string) => boolean;
+export declare function suggestIcon(typed: string): string;

package/dist/src/core/global_modules/arch/index.d.ts

@@ -0,0 +1,2 @@
+import { GlobalModule } from '../types';
+export declare const archModule: GlobalModule;

package/dist/src/core/global_modules/arch/interpret.d.ts

@@ -0,0 +1,11 @@
+import { default as Compiler } from '../../../compiler';
+import { Filepath } from '../../types/filepath';
+import { default as Report } from '../../types/report';
+import { ArchSettings, Group, Kind, Link, Node, NoteBox } from '../../types/schemaJson';
+import { ElementSymbol, KindSymbol } from '../../types/symbol';
+import { ArchMetadataElementMetadata, LinkMetadata } from '../../types/symbol/metadata';
+export declare function interpretElement(compiler: Compiler, symbol: ElementSymbol, filepath: Filepath): Report<Node | Group | NoteBox | undefined>;
+export declare function interpretKind(symbol: KindSymbol): Report<Kind | undefined>;
+export declare function builtinKinds(): Kind[];
+export declare function interpretLink(compiler: Compiler, metadata: LinkMetadata): Report<Link | undefined>;
+export declare function interpretArchMetadata(metadata: ArchMetadataElementMetadata): Report<ArchSettings>;

package/dist/src/core/global_modules/arch/utils.d.ts

@@ -0,0 +1,7 @@
+import { default as Compiler } from '../../../compiler';
+import { Filepath } from '../../types/filepath';
+import { NodeSymbol, SymbolKind } from '../../types/symbol';
+export declare function lookupVisible(compiler: Compiler, filepath: Filepath, kind: SymbolKind, name: string): NodeSymbol | undefined;
+export declare function visibleKinds(compiler: Compiler, filepath: Filepath): Map<string, NodeSymbol>;
+export declare function resolveRole(compiler: Compiler, filepath: Filepath, word: string): string | undefined;
+export declare function originalHandle(symbol: NodeSymbol): string | undefined;

package/dist/src/core/global_modules/index.d.ts

@@ -7,7 +7,21 @@ import { NodeMetadata } from '../types/symbol/metadata';
 import { SchemaElement } from '../types/schemaJson';
 import { NodeSymbol } from '../types/symbol';
 import { GlobalModule } from './types';
-export declare const modules: GlobalModule[];
+/**
+ * The DBML vocabulary: the modules a Compiler uses when nobody says otherwise.
+ *
+ * The dispatcher tries each in order until one claims the node, so order is meaningful. Each
+ * time you add a new DBML element, register its module here.
+ *
+ * A Compiler may also be built with a different list (see `Compiler`'s second argument). The
+ * lexer and the parser do not know this vocabulary at all: `parser.ts` has one generic
+ * `elementDeclaration()` and never mentions `ElementKind`, so another dialect is a different
+ * array, not a different grammar. Pass a different list and the same front end binds a
+ * different language, which is how the architecture dialect reuses all of this without forking
+ * it or widening DBML's own vocabulary by a single word.
+ */
+export declare const dbmlModules: GlobalModule[];
+export declare const archModules: GlobalModule[];
 export declare function nodeSymbol(this: Compiler, node: SyntaxNode): Report<NodeSymbol> | Report<Unhandled>;
 export declare function symbolMembers(this: Compiler, symbol: NodeSymbol): Report<NodeSymbol[]> | Report<Unhandled>;
 export declare function nodeReferee(this: Compiler, node: SyntaxNode): Report<NodeSymbol | undefined> | Report<Unhandled>;

package/dist/src/core/global_modules/metadata/utils.d.ts

@@ -1,5 +1,5 @@
 import { default as Compiler } from '../../../compiler/index';
-import { Filepath, SettingName } from '../../types';
+import { Filepath, FilepathId, SettingName } from '../../types';
 import { Column, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
 import { ElementDeclarationNode, SyntaxNode } from '../../types/nodes';
 import { NodeSymbol, SymbolKind, MetadataTargetKind } from '../../types/symbol';
@@ -24,6 +24,8 @@ type NameWithSymbolKind = {
 /** @internal Exported for testing only. */
 export declare function mapNamePartToSymbolKind(nameParts: string[], targetKind: MetadataTargetKind): NameWithSymbolKind[];
 export declare function resolveMetadataTarget(compiler: Compiler, metadataNode: ElementDeclarationNode): NodeSymbol | undefined;
+/** Get precedence score of files in import tree, lower score means lower precedence */
+export declare function metadataFilePrecedence(compiler: Compiler, root: Filepath): Map<FilepathId, number>;
 /** Merge every custom-metadata block, reachable from the current program, targeting element to it's `metadata` and other builtin (note/headercolor/...) fields */
 export declare function attachCustomMetadata<T extends MetadataTarget>(compiler: Compiler, targetElement: Partial<T>, targetSymbol: NodeSymbol, fieldsRegistry: MetadataFieldRegistry<T, any>, filepath: Filepath): void;
 export {};

package/dist/src/core/global_modules/program/bind.d.ts

@@ -6,6 +6,7 @@ export default class Binder {
     private compiler;
     constructor(ast: ProgramNode, compiler: Compiler);
     resolve(): Report<void>;
+    private isArchFile;
     private checkDuplicateRefs;
     private checkStandaloneRefs;
     private checkInlineRefs;

package/dist/src/core/global_modules/program/interpret.d.ts

@@ -14,6 +14,8 @@ export default class ProgramInterpreter {
     private db;
     constructor(compiler: Compiler, symbol: ProgramSymbol, filepath: Filepath);
     interpret(): Report<SchemaElement | SchemaElement[] | undefined>;
+    private arch;
+    private finishArch;
     private interpretAllSymbols;
     private interpretUseSymbol;
     private interpretAllMetadata;

package/dist/src/core/lexer/lexer.d.ts

@@ -1,6 +1,19 @@
 import { Filepath } from '../types/filepath';
 import { default as Report } from '../types/report';
 import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
+/**
+ * Grammar switches the lexer offers a dialect. Off by default, so DBML is untouched.
+ */
+export interface LexerOptions {
+    /**
+     * Read a `---` fenced block at the very top of a file as one trivia token.
+     *
+     * It is Markdown's convention and people expect it for file-level metadata. DBML has no use
+     * for it, because `Project { ... }` already carries that and its interpreter files any
+     * unrecognised field as a free-form property. A dialect that wants both says so here.
+     */
+    allowFrontMatter?: boolean;
+}
 export default class Lexer {
     private start;
     private current;
@@ -8,7 +21,16 @@ export default class Lexer {
     private filepath;
     private tokens;
     private errors;
-    constructor(text: string, filepath: Filepath);
+    private readonly options;
+    constructor(text: string, filepath: Filepath, options?: LexerOptions);
+    /**
+     * Only at offset zero, and only up to the closing fence.
+     *
+     * It is consumed character by character like everything else, so `line` and `column` keep
+     * counting and every token after it still reports where it really is. Lifting the block out
+     * of the text instead would shift every diagnostic in the file by however many lines it had.
+     */
+    private scanFrontMatter;
     private isAtEnd;
     private advance;
     private peek;

package/dist/src/core/local_modules/arch/index.d.ts

@@ -0,0 +1,2 @@
+import { LocalModule } from '../types';
+export declare const archModule: LocalModule;

package/dist/src/core/local_modules/index.d.ts

@@ -4,6 +4,7 @@ import { SyntaxNode } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { LocalModule, Settings } from './types';
 export declare const modules: LocalModule[];
+export declare const archModules: LocalModule[];
 export declare function validateNode(this: Compiler, node: SyntaxNode): Report<void> | Report<Unhandled>;
 export declare function nodeSettings(this: Compiler, node: SyntaxNode): Report<Settings> | Report<Unhandled>;
 export declare function nodeFullname(this: Compiler, node: SyntaxNode): Report<string[] | undefined> | Report<Unhandled>;

package/dist/src/core/parser/parser.d.ts

@@ -2,6 +2,22 @@ import { Filepath } from '../types/filepath';
 import { ProgramNode, SyntaxNodeIdGenerator } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { SyntaxToken } from '../types/tokens';
+/**
+ * Grammar switches a dialect may ask for. Every one of these is off by default, so the DBML
+ * grammar is exactly what it was; a dialect that wants a different shape says so, and the
+ * difference is one flag rather than a forked parser.
+ */
+export interface ParserOptions {
+    /**
+     * Allow an element declaration with no body: `Database mongo1` as a complete statement.
+     *
+     * DBML has nothing that reads that way, because every DBML element carries something: a Table
+     * has columns, a Ref has endpoints. An architecture file is the opposite, mostly bare nouns
+     * with the occasional body, and writing `Database mongo1 { }` on every line to satisfy a
+     * grammar rule that exists for a different language would be the tail wagging the dog.
+     */
+    allowBodylessElement?: boolean;
+}
 export default class Parser {
     private tokens;
     private current;
@@ -10,7 +26,8 @@ export default class Parser {
     private nodeFactory;
     private source;
     private filepath;
-    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath);
+    private readonly options;
+    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath, options?: ParserOptions);
     private isAtEnd;
     private advance;
     private peek;

package/dist/src/core/types/errors.d.ts

@@ -126,7 +126,23 @@ export declare enum CompileErrorCode {
     TABLE_REAPPEAR_IN_TABLEGROUP = 5009,
     INVALID_METADATA_TARGET_KIND = 5010,
     INVALID_METADATA_FIELD = 5011,
-    DUPLICATE_METADATA_FIELD = 5012
+    DUPLICATE_METADATA_FIELD = 5012,
+    UNKNOWN_KIND = 6000,
+    MISSING_NAME = 6001,
+    RESERVED_KIND = 6002,
+    UNKNOWN_ENDPOINT = 6003,
+    EMPTY_LINK = 6004,
+    BAD_LINK = 6005,
+    UNKNOWN_METADATA_TARGET = 6006,
+    BAD_PROPERTY = 6007,
+    DUPLICATE_PROPERTY = 6008,
+    DIAGRAM_TYPE_NOT_HERE = 6009,
+    METADATA_KIND_MISMATCH = 6010,
+    UNKNOWN_TYPE = 6011,
+    UNKNOWN_ICON = 6012,
+    BAD_IMAGE = 6013,
+    DUPLICATE_LINK = 6014,
+    NESTED_ENDPOINTS = 6015
 }
 export interface RelatedLocation {
     nodeOrToken: SyntaxNode | SyntaxToken;

package/dist/src/core/types/filepath.d.ts

@@ -5,12 +5,10 @@ export type FilepathId = string & {
 };
 export declare class Filepath implements Internable<FilepathId> {
     private readonly protocol?;
-    private readonly root;
-    private readonly segments;
+    private readonly path;
     constructor(absolutePath: string, options?: {
         protocol?: string;
     });
-    private get path();
     intern(): FilepathId;
     static from(absolutePath: string): Filepath;
     static resolve(fromDir: string, relativePath: string): Filepath;

package/dist/src/core/types/nodes.d.ts

@@ -95,6 +95,7 @@ export declare class UseSpecifierNode extends SyntaxNode {
         asKeyword?: SyntaxToken;
         alias?: NormalExpressionNode;
     }, id: SyntaxNodeId, filepath: Filepath);
+    archImport?: boolean;
     isKind(...importKinds: ImportKind[]): boolean;
     getSymbolKind(): SymbolKind | undefined;
 }

package/dist/src/core/types/schemaJson/types.d.ts

@@ -27,6 +27,10 @@ export interface DatabaseExternals {
     tableGroups: ElementRef[];
     tablePartials: ElementRef[];
     notes: ElementRef[];
+    nodes?: ElementRef[];
+    groups?: ElementRef[];
+    noteBoxes?: ElementRef[];
+    kinds?: ElementRef[];
 }
 /**
  * FilterConfig is a tri-state filter:
@@ -70,6 +74,64 @@ export interface Database {
     externals: DatabaseExternals;
     diagramViews: DiagramView[];
     token?: TokenPosition;
+    nodes?: Node[];
+    groups?: Group[];
+    noteBoxes?: NoteBox[];
+    links?: Link[];
+    kinds?: Kind[];
+    frontMatter?: Record<string, string>;
+    diagramType?: 'arch';
+}
+export type ArchSettingValue = string | number | boolean;
+export type ArchSettings = Record<string, ArchSettingValue>;
+export type KindCategory = 'compute' | 'data' | 'net' | 'edge' | 'people' | 'ops' | 'custom';
+export interface Node {
+    name: string;
+    alias: string | null;
+    kind: string;
+    type: string | null;
+    image: string | null;
+    settings: ArchSettings;
+    note: {
+        value: string;
+        token: TokenPosition;
+    } | null;
+    token: TokenPosition;
+}
+export interface Group {
+    name: string;
+    alias: string | null;
+    children: string[];
+    settings: ArchSettings;
+    note: {
+        value: string;
+        token: TokenPosition;
+    } | null;
+    token: TokenPosition;
+}
+export interface NoteBox {
+    name: string;
+    alias: string | null;
+    content: string;
+    token: TokenPosition;
+}
+export type LinkOp = '>' | '<' | '<>' | '-';
+export interface Link {
+    from: string;
+    to: string;
+    op: LinkOp;
+    settings: ArchSettings;
+    token: TokenPosition;
+}
+export interface Kind {
+    name: string;
+    icon: string;
+    glyph: string[] | null;
+    image: string | null;
+    category: KindCategory;
+    color: string | null;
+    builtin: boolean;
+    token: TokenPosition | null;
 }
 export interface MasterDatabase {
     files: Record<string, Database>;
@@ -297,4 +359,4 @@ export type Project = Record<string, never> | {
     token: TokenPosition;
     [index: string & Omit<any, 'name' | 'tables' | 'refs' | 'enums' | 'tableGroups' | 'note' | 'tablePartials' | 'records'>]: string;
 };
-export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | InlineDep | Ref | RefEndpoint | Dep | DepEdge | DepEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues;
+export type SchemaElement = Database | Project | Table | Note | Column | ColumnType | Index | Check | InlineRef | InlineDep | Ref | RefEndpoint | Dep | DepEdge | DepEndpoint | Enum | EnumField | TableGroup | TableGroupField | Alias | TablePartial | TablePartialInjection | TableRecord | RecordValue | MetadataValues | Node | Group | NoteBox | Link | Kind | ArchSettings;

package/dist/src/core/types/symbol/metadata.d.ts

@@ -12,7 +12,8 @@ export declare enum MetadataKind {
     Indexes = "indexes",
     Records = "records",
     Project = "project",
-    MetadataElement = "metadata element"
+    MetadataElement = "metadata element",
+    Link = "link"
 }
 declare const __nodeMetadataBrand: unique symbol;
 export type NodeMetadataId = number & {
@@ -115,6 +116,16 @@ export declare class MetadataElementMetadata extends NodeMetadata {
     target(compiler: Compiler): NodeSymbol | undefined;
     owners(compiler: Compiler): NodeSymbol[];
 }
+export declare class LinkMetadata extends NodeMetadata {
+    declaration: ElementDeclarationNode;
+    readonly kind = MetadataKind.Link;
+    constructor(declaration: ElementDeclarationNode);
+    endpoints(compiler: Compiler): [NodeSymbol | undefined, NodeSymbol | undefined];
+    owners(compiler: Compiler): NodeSymbol[];
+}
+export declare class ArchMetadataElementMetadata extends MetadataElementMetadata {
+    target(compiler: Compiler): NodeSymbol | undefined;
+}
 export declare class ProjectMetadata extends NodeMetadata {
     readonly kind = MetadataKind.Project;
     constructor(declaration: SyntaxNode);

package/dist/src/core/types/symbol/symbols.d.ts

@@ -25,6 +25,8 @@ export declare enum SymbolKind {
     DiagramViewNote = "DiagramView note",
     DiagramViewSchema = "DiagramView schema",
     Metadata = "Metadata",
+    Element = "Element",
+    Kind = "Kind",
     Program = "Program"
 }
 export declare const ImportKind: {
@@ -203,6 +205,22 @@ export declare class TableGroupFieldSymbol extends NodeSymbol {
     get canBeImported(): boolean;
     get originalSymbol(): NodeSymbol;
 }
+export declare class ElementSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
+export declare class KindSymbol extends NodeSymbol {
+    constructor({ declaration, name, }: {
+        declaration?: SyntaxNode;
+        name?: string;
+    }, id: NodeSymbolId, filepath: Filepath);
+    get canBeImported(): boolean;
+    get originalSymbol(): NodeSymbol;
+}
 export declare class NoteSymbol extends NodeSymbol {
     constructor({ declaration, name, }: {
         declaration?: SyntaxNode;

package/dist/src/core/types/tokens.d.ts

@@ -25,6 +25,8 @@ export declare enum SyntaxTokenKind {
     COLON = "<colon>",
     SINGLE_LINE_COMMENT = "<single-line-comment>",
     MULTILINE_COMMENT = "<multiline-comment>",
+    /** a `---` fenced block at the very top of a file; only a dialect that asks for it gets one */
+    FRONT_MATTER = "<front-matter>",
     WILDCARD = "<wildcard>"
 }
 export declare function isTriviaToken(token: SyntaxToken): boolean;