@dbml/parse 11.0.0-alpha.5 → 11.0.0

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

@@ -1,18 +1,9 @@
-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';
-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, };
@@ -21,21 +12,8 @@ export default class Compiler {
     readonly nodeIdGenerator: SyntaxNodeIdGenerator;
     readonly symbolIdGenerator: NodeSymbolIdGenerator;
     readonly symbolFactory: SymbolFactory;
-    readonly explicitModules: GlobalModule[] | undefined;
-    private readonly explicitDialect;
-    readonly dialect: DialectOptions;
-    constructor(layout: DbmlProjectLayout, modules?: GlobalModule[], dialect?: DialectOptions);
+    constructor(layout: DbmlProjectLayout);
     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;
@@ -92,9 +70,8 @@ export default class Compiler {
             }[];
         };
     }>;
-    nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | SyntaxToken | undefined;
+    nodeAtPosition: (filepath: Filepath, offset: number) => SyntaxNode | import('..').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) => {
@@ -106,22 +83,22 @@ export default class Compiler {
         edits: import('.').TextEdit[];
     };
     readonly token: {
-        invalidStream: (filepath: Filepath) => readonly SyntaxToken[];
-        flatStream: (filepath: Filepath) => readonly SyntaxToken[];
+        invalidStream: (filepath: Filepath) => readonly import('..').SyntaxToken[];
+        flatStream: (filepath: Filepath) => readonly import('..').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('../core/types').CompileWarning>[];
-        tokens: (filepath?: Filepath) => readonly Readonly<SyntaxToken>[];
+        warnings: (filepath?: Filepath) => readonly Readonly<import('..').CompileWarning>[];
+        tokens: (filepath?: Filepath) => readonly Readonly<import('..').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: SyntaxToken;
+            token: import('..').SyntaxToken;
             index: number;
         } | {
             token: undefined;
@@ -134,6 +111,7 @@ export default class Compiler {
     initMonacoServices(options?: {
         autocompletion?: {
             triggerCharacters?: string[];
+            fileListDepth?: number;
         };
     }): {
         definitionProvider: DBMLDefinitionProvider;

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

@@ -1,6 +1,12 @@
 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;
@@ -12,6 +18,7 @@ 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/transform/index.d.ts

@@ -1,7 +1,6 @@
 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, ArchElementIdentifier, ArchLinkIdentifier, } from './types';
+export type { ElementIdentifier, SchemaIdentifier, TableIdentifier, ColumnIdentifier, EnumIdentifier, EndpointRef, RefIdentifier, DepIdentifier, NoteIdentifier, TableGroupIdentifier, } from './types';

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 | ArchElementIdentifier | ArchLinkIdentifier) & {
+export type ElementIdentifier = (SchemaIdentifier | TableIdentifier | ColumnIdentifier | EnumIdentifier | RefIdentifier | DepIdentifier | NoteIdentifier | TableGroupIdentifier) & {
     kind: string;
 };
 export interface SchemaIdentifier {
@@ -46,12 +46,3 @@ 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/core/global_modules/index.d.ts

@@ -7,8 +7,7 @@ import { NodeMetadata } from '../types/symbol/metadata';
 import { SchemaElement } from '../types/schemaJson';
 import { NodeSymbol } from '../types/symbol';
 import { GlobalModule } from './types';
-export declare const dbmlModules: GlobalModule[];
-export declare const archModules: GlobalModule[];
+export declare const modules: 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/interpret.d.ts

@@ -2,13 +2,13 @@ import { default as Compiler } from '../../../compiler';
 import { Filepath } from '../../types';
 import { MetadataElementMetadata } from '../../types/symbol/metadata';
 import { default as Report } from '../../types/report';
-import { MetadataValues } from '../../types/schemaJson';
+import { CustomMetadata } from '../../types/schemaJson';
 export default class MetadataInterpreter {
     private declarationNode;
     private compiler;
     private filepath;
     private values;
     constructor(compiler: Compiler, metadata: MetadataElementMetadata, filepath: Filepath);
-    interpret(): Report<MetadataValues>;
+    interpret(): Report<CustomMetadata>;
     private interpretValues;
 }

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

@@ -0,0 +1,19 @@
+import { SettingName } from '../../types/keywords';
+import { Color, Column, Note, Table, TableGroup } from '../../types/schemaJson';
+import { MetadataTargetKind } from '../../types/symbol';
+import { MetadataFieldRegistry } from './utils';
+export declare const TABLE_METADATA_FIELDS: MetadataFieldRegistry<Table, {
+    [SettingName.Note]: string;
+    [SettingName.HeaderColor]: Color;
+}>;
+export declare const COLUMN_METADATA_FIELDS: MetadataFieldRegistry<Column, {
+    [SettingName.Note]: string;
+}>;
+export declare const TABLEGROUP_METADATA_FIELDS: MetadataFieldRegistry<TableGroup, {
+    [SettingName.Note]: string;
+    [SettingName.Color]: Color;
+}>;
+export declare const NOTE_METADATA_FIELDS: MetadataFieldRegistry<Note, {
+    [SettingName.Color]: Color;
+}>;
+export declare const METADATA_FIELDS_BY_KIND: Record<MetadataTargetKind, MetadataFieldRegistry<any, any>>;

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

@@ -1,22 +1,29 @@
 import { default as Compiler } from '../../../compiler/index';
-import { Filepath, FilepathId, SettingName } from '../../types';
-import { Column, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
+import { Filepath, SettingName } from '../../types';
+import { Column, CustomMetadataValue, CustomMetadataValueType, Note, Table, TableGroup, TokenPosition } from '../../types/schemaJson';
 import { ElementDeclarationNode, SyntaxNode } from '../../types/nodes';
 import { NodeSymbol, SymbolKind, MetadataTargetKind } from '../../types/symbol';
 export type MetadataTarget = Table | TableGroup | Note | Column;
 /**
-  * Specs for builtin metadata (table's note, tablegroup's color, .etc) for different element types. Does 2 things:
-  * - `validate`: Validating if the metadata value is syntactically correct
-  * - `assign`: Write the metadata value to the element builtin props (e.g. write `table.note` instead of `table.metadata`)
+  * Spec for one builtin metadata field (table's note, tablegroup's color, .etc) of an element kind.
+  * Used for both the inline settings list and Metadata blocks:
+  * - `parse`: Read the field's own value from a source node, `undefined` means the value is invalid
+  * - `assign`: Write the parsed value to the element builtin props (e.g. write `table.note` instead of `table.metadata`)
   */
-interface MetadataField<T extends MetadataTarget> {
-    /** Check if the metadata value is syntactically correct */
-    isValidBuiltinFieldValue(node?: SyntaxNode): boolean;
+type MetadataField<T, V> = {
+    /** Type of the parsed value, reported when the field is read as a metadata entry */
+    type: CustomMetadataValueType;
+    /** Parse the source node into the field's value, `undefined` if the node is not a valid value for this field */
+    parse(node?: SyntaxNode): V | undefined;
     message: string;
-    /** Write the metadata value to the element builtin props (e.g. write to `table.note`) */
-    assignBuiltinField(element: Partial<T>, value: string, token: TokenPosition): void;
-}
-export type MetadataFieldRegistry<T extends MetadataTarget, K extends SettingName = SettingName> = Record<K, MetadataField<T>>;
+    /** Write the parsed value to the element builtin props (e.g. write to `table.note`) */
+    assign(element: Partial<T>, value: V, token: TokenPosition): void;
+};
+export type MetadataFieldRegistry<T extends MetadataTarget, R extends {
+    [K in SettingName]?: CustomMetadataValue['value'];
+}> = {
+    [K in keyof R]: MetadataField<T, R[K]>;
+};
 type NameWithSymbolKind = {
     name: string;
     symbolKind: SymbolKind;
@@ -24,8 +31,6 @@ 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/note/interpret.d.ts

@@ -1,9 +1,7 @@
 import { Note } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { SettingName, Filepath, NoteSymbol } from '../../types';
+import { Filepath, NoteSymbol } from '../../types';
 import { default as Report } from '../../types/report';
-import { MetadataFieldRegistry } from '../metadata/utils';
-export declare const NOTE_METADATA_FIELDS: MetadataFieldRegistry<Note, SettingName.Color>;
 export declare class StickyNoteInterpreter {
     private declarationNode;
     private symbol;

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

@@ -6,7 +6,6 @@ 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,8 +14,6 @@ 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/global_modules/records/utils/data/values.d.ts

@@ -1,9 +1,8 @@
 import { FunctionExpressionNode, SyntaxNode } from '../../../../types/nodes';
-export { extractNumericLiteral } from '../../../../utils/expression';
+export { extractNumericLiteral, extractSignedNumber } from '../../../../utils/expression';
 export declare function isNullish(value: SyntaxNode): boolean;
 export declare function isEmptyStringLiteral(value: SyntaxNode): boolean;
 export declare function isFunctionExpression(value: SyntaxNode): value is FunctionExpressionNode;
-export declare function extractSignedNumber(node: SyntaxNode): number | null;
 export declare function tryExtractNumeric(value: SyntaxNode | number | string | boolean | undefined | null): number | null;
 export declare function tryExtractInteger(value: SyntaxNode | number | string | boolean | undefined | null): number | null;
 export declare const TRUTHY_VALUES: string[];

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

@@ -2,10 +2,9 @@ import { default as Compiler } from '../../../compiler';
 import { SettingName } from '../../types/keywords';
 import { ElementDeclarationNode } from '../../types/nodes';
 import { default as Report } from '../../types/report';
-import { Column, Table } from '../../types/schemaJson';
+import { Table } from '../../types/schemaJson';
 import { Filepath } from '../../types/filepath';
 import { TableSymbol } from '../../types/symbol/symbols';
-import { MetadataFieldRegistry } from '../metadata/utils';
 export declare class TableInterpreter {
     private declarationNode;
     private compiler;
@@ -33,5 +32,3 @@ export declare class TableInterpreter {
   * TODO: Catch these settings when we support more data types for custom metadata
   */
 export declare const RECOGNIZED_COLUMN_SETTINGS: readonly SettingName[];
-export declare const TABLE_METADATA_FIELDS: MetadataFieldRegistry<Table, SettingName.Note | SettingName.HeaderColor>;
-export declare const COLUMN_METADATA_FIELDS: MetadataFieldRegistry<Column, SettingName.Note>;

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

@@ -1,9 +1,7 @@
 import { TableGroup } from '../../types/schemaJson';
 import { default as Compiler } from '../../../compiler';
-import { SettingName, Filepath, TableGroupSymbol } from '../../types';
+import { Filepath, TableGroupSymbol } from '../../types';
 import { default as Report } from '../../types/report';
-import { MetadataFieldRegistry } from '../metadata/utils';
-export declare const TABLEGROUP_METADATA_FIELDS: MetadataFieldRegistry<TableGroup, SettingName.Note | SettingName.Color>;
 export declare class TableGroupInterpreter {
     private compiler;
     private symbol;

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

@@ -1,9 +1,6 @@
 import { Filepath } from '../types/filepath';
 import { default as Report } from '../types/report';
 import { SyntaxToken, SyntaxTokenKind } from '../types/tokens';
-export interface LexerOptions {
-    allowFrontMatter?: boolean;
-}
 export default class Lexer {
     private start;
     private current;
@@ -11,9 +8,7 @@ export default class Lexer {
     private filepath;
     private tokens;
     private errors;
-    private readonly options;
-    constructor(text: string, filepath: Filepath, options?: LexerOptions);
-    private scanFrontMatter;
+    constructor(text: string, filepath: Filepath);
     private isAtEnd;
     private advance;
     private peek;

package/dist/src/core/local_modules/dep/validate.d.ts

@@ -1,8 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { Settings } from '../../utils/validate';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
 export default class DepValidator {
     private declarationNode;
     private compiler;
@@ -16,4 +14,3 @@ export default class DepValidator {
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
     private validateSubElements;
 }
-export declare function validateDepSettings(settings: ListExpressionNode): Report<Settings>;

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

@@ -4,7 +4,6 @@ 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/local_modules/note/validate.d.ts

@@ -9,8 +9,6 @@ export default class NoteValidator {
     private validateContext;
     private validateName;
     private validateAlias;
-    private isStickyNote;
-    private validateSettingList;
     validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
     private validateSubElements;

package/dist/src/core/local_modules/table/validate.d.ts

@@ -1,8 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { ElementDeclarationNode, ExpressionNode, ListExpressionNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { Settings } from '../../utils/validate';
+import { ElementDeclarationNode } from '../../types/nodes';
 export default class TableValidator {
     private declarationNode;
     private compiler;
@@ -11,11 +9,7 @@ export default class TableValidator {
     private validateContext;
     private validateName;
     private validateAlias;
-    private validateSettingList;
     private validateBody;
     private validateFields;
-    private validateFieldSetting;
     private validateSubElements;
 }
-export declare function validateTableSettings(settingList?: ListExpressionNode): Report<Settings>;
-export declare function validateFieldSetting(parts: ExpressionNode[]): Report<Settings>;

package/dist/src/core/local_modules/tableGroup/validate.d.ts

@@ -1,8 +1,6 @@
 import { default as Compiler } from '../../../compiler';
 import { CompileError } from '../../types/errors';
-import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode, ListExpressionNode } from '../../types/nodes';
-import { default as Report } from '../../types/report';
-import { Settings } from '../../utils/validate';
+import { BlockExpressionNode, ElementDeclarationNode, FunctionApplicationNode } from '../../types/nodes';
 export default class TableGroupValidator {
     private declarationNode;
     private compiler;
@@ -11,9 +9,7 @@ export default class TableGroupValidator {
     private validateContext;
     private validateName;
     private validateAlias;
-    private validateSettingList;
     validateBody(body?: FunctionApplicationNode | BlockExpressionNode): CompileError[];
     validateFields(fields: FunctionApplicationNode[]): CompileError[];
     private validateSubElements;
 }
-export declare function validateSettingList(settingList?: ListExpressionNode): Report<Settings>;

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

@@ -2,9 +2,6 @@ import { Filepath } from '../types/filepath';
 import { ProgramNode, SyntaxNodeIdGenerator } from '../types/nodes';
 import { default as Report } from '../types/report';
 import { SyntaxToken } from '../types/tokens';
-export interface ParserOptions {
-    allowBodylessElement?: boolean;
-}
 export default class Parser {
     private tokens;
     private current;
@@ -13,8 +10,7 @@ export default class Parser {
     private nodeFactory;
     private source;
     private filepath;
-    private readonly options;
-    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath, options?: ParserOptions);
+    constructor(source: string, tokens: SyntaxToken[], nodeIdGenerator: SyntaxNodeIdGenerator, filepath: Filepath);
     private isAtEnd;
     private advance;
     private peek;

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

@@ -112,6 +112,10 @@ export declare enum CompileErrorCode {
     DUPLICATE_DIAGRAMVIEW_NAME = 3094,
     INVALID_DIAGRAMVIEW_FIELD = 3095,
     DUPLICATE_DIAGRAMVIEW_FIELD = 3096,
+    DUPLICATE_TABLEGROUP_SETTING = 3097,
+    INVALID_TABLEGROUP_SETTING_VALUE = 3098,
+    DUPLICATE_DEP_SETTING = 3099,
+    INVALID_DEP_SETTING_VALUE = 3100,
     BINDING_ERROR = 4000,
     NONEXISTENT_MODULE = 4001,
     UNSUPPORTED = 5000,
@@ -126,23 +130,7 @@ export declare enum CompileErrorCode {
     TABLE_REAPPEAR_IN_TABLEGROUP = 5009,
     INVALID_METADATA_TARGET_KIND = 5010,
     INVALID_METADATA_FIELD = 5011,
-    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
+    DUPLICATE_METADATA_FIELD = 5012
 }
 export interface RelatedLocation {
     nodeOrToken: SyntaxNode | SyntaxToken;

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

@@ -5,10 +5,12 @@ export type FilepathId = string & {
 };
 export declare class Filepath implements Internable<FilepathId> {
     private readonly protocol?;
-    private readonly path;
+    private readonly root;
+    private readonly segments;
     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,7 +95,6 @@ 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

@@ -2,7 +2,13 @@ import { NONE_COLOR } from '../../../constants';
 import { Filepath } from '../filepath';
 import { Position } from '../position';
 import { RelationshipOp, RelationCardinality } from '../relation';
-export type CustomMetadata = Record<string, string>;
+export type CustomMetadataValueType = 'string' | 'number' | 'bool' | 'color';
+export interface CustomMetadataValue {
+    value: string | number | boolean;
+    type: CustomMetadataValueType;
+    token: TokenPosition;
+}
+export type CustomMetadata = Record<string, CustomMetadataValue>;
 export type Color = `#${string}` | typeof NONE_COLOR;
 export declare enum AliasKind {
     Table = "table"
@@ -27,9 +33,6 @@ export interface DatabaseExternals {
     tableGroups: ElementRef[];
     tablePartials: ElementRef[];
     notes: ElementRef[];
-    nodes?: ElementRef[];
-    groups?: ElementRef[];
-    kinds?: ElementRef[];
 }
 /**
  * FilterConfig is a tri-state filter:
@@ -73,57 +76,6 @@ export interface Database {
     externals: DatabaseExternals;
     diagramViews: DiagramView[];
     token?: TokenPosition;
-    nodes?: Node[];
-    groups?: Group[];
-    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 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>;
@@ -333,10 +285,6 @@ export interface TableRecord {
     example?: boolean;
     token: TokenPosition;
 }
-export type MetadataValues = Record<string, {
-    value: string;
-    token: TokenPosition;
-}>;
 export type Project = Record<string, never> | {
     name: string | null;
     tables: Table[];
@@ -351,4 +299,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 | Node | Group | Link | Kind | ArchSettings;
+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 | CustomMetadata;

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

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