@archcode-io/engine 0.2.0-preview.0

package/dist/src/lexer.d.ts

@@ -0,0 +1,7 @@
+import type { Token } from './tokens.js';
+/**
+ * Tokenize losslessly. Never throws: malformed input produces tokens plus
+ * diagnostics from the parser, because a broken file must still yield a
+ * partial model (D-58).
+ */
+export declare function lex(src: string): Token[];

package/dist/src/lexer.js

@@ -0,0 +1,135 @@
+// `@` starts a word so that owner handles (`@team-sales`) are one token rather
+// than a stray symbol followed by a name.
+const isWordStart = (c) => /[A-Za-z_@]/.test(c);
+const isWordChar = (c) => /[A-Za-z0-9_.\-]/.test(c);
+const isDigit = (c) => c >= '0' && c <= '9';
+/**
+ * Tokenize losslessly. Never throws: malformed input produces tokens plus
+ * diagnostics from the parser, because a broken file must still yield a
+ * partial model (D-58).
+ */
+export function lex(src) {
+    const out = [];
+    let i = 0, line = 1, col = 1;
+    const advance = (n) => {
+        for (let k = 0; k < n; k++) {
+            if (src[i] === '\n') {
+                line++;
+                col = 1;
+            }
+            else {
+                col++;
+            }
+            i++;
+        }
+    };
+    while (true) {
+        // ---- trivia: spaces, tabs, carriage returns, line comments ----
+        const triviaStart = i;
+        for (;;) {
+            const c = src[i];
+            if (c === ' ' || c === '\t' || c === '\r') {
+                advance(1);
+                continue;
+            }
+            if (c === '#') {
+                while (i < src.length && src[i] !== '\n')
+                    advance(1);
+                continue;
+            }
+            break;
+        }
+        const trivia = src.slice(triviaStart, i);
+        const tokLine = line, tokCol = col, tokStart = i;
+        const push = (kind, text) => {
+            out.push({ kind, text, trivia, start: triviaStart, end: tokStart + text.length, line: tokLine, col: tokCol });
+        };
+        if (i >= src.length) {
+            push('eof', '');
+            return out;
+        }
+        const c = src[i];
+        if (c === '\n') {
+            advance(1);
+            push('newline', '\n');
+            continue;
+        }
+        if (c === '{') {
+            advance(1);
+            push('lbrace', '{');
+            continue;
+        }
+        if (c === '}') {
+            advance(1);
+            push('rbrace', '}');
+            continue;
+        }
+        if (c === ',') {
+            advance(1);
+            push('comma', ',');
+            continue;
+        }
+        if (c === '"') {
+            const s = i;
+            advance(1);
+            while (i < src.length && src[i] !== '"' && src[i] !== '\n') {
+                if (src[i] === '\\' && i + 1 < src.length)
+                    advance(2);
+                else
+                    advance(1);
+            }
+            if (src[i] === '"')
+                advance(1); // unterminated string is tolerated
+            push('string', src.slice(s, i));
+            continue;
+        }
+        // `+1y`, `+30d`: a relative moment is one value (§6.3), the sign included
+        if (isDigit(c) || (c === '+' && isDigit(src[i + 1] ?? ''))) {
+            const s = i;
+            if (c === '+')
+                advance(1);
+            const numeral = () => {
+                // digits, then a unit suffix; `24x7`, `3x`, `p99`-style mixes stay one token —
+                // a value written without spaces is one value
+                while (i < src.length && /[0-9._]/.test(src[i]))
+                    advance(1);
+                while (i < src.length && /[A-Za-z0-9%]/.test(src[i]))
+                    advance(1);
+            };
+            numeral();
+            // a date `2026-12-01` and a ratio `0.7/2` or `800Mi/2Gi` stay one token:
+            // they are one value, and a reader never splits them either
+            // …and so does a rate `800Gi/mo`, `20000/day`
+            while ((src[i] === '-' && isDigit(src[i + 1] ?? '')) || (src[i] === '/' && /[0-9A-Za-z]/.test(src[i + 1] ?? ''))) {
+                advance(1);
+                if (isDigit(src[i]))
+                    numeral();
+                else
+                    while (i < src.length && /[A-Za-z]/.test(src[i]))
+                        advance(1);
+            }
+            push('number', src.slice(s, i));
+            continue;
+        }
+        if (isWordStart(c)) {
+            const s = i;
+            advance(1); // always consume the first character, or a
+            // start-only character like `@` loops forever
+            while (i < src.length && isWordChar(src[i]))
+                advance(1);
+            // pointer: scheme://rest
+            if (src.slice(i, i + 3) === '://') {
+                advance(3);
+                while (i < src.length && /[^\s,{}]/.test(src[i]))
+                    advance(1);
+                push('pointer', src.slice(s, i));
+                continue;
+            }
+            push('word', src.slice(s, i));
+            continue;
+        }
+        // any other byte becomes a one-character word token so nothing is lost
+        advance(1);
+        push('word', src.slice(tokStart, i));
+    }
+}

package/dist/src/model.d.ts

@@ -0,0 +1,63 @@
+import type { Doc } from './cst.js';
+/** The semantic model: a flat catalogue plus relations, lowered from the CST. */
+/** Sizing at a later moment: `at 2026-12 cpu 12 mem 24Gi`. */
+export interface Moment {
+    when: string;
+    attrs: Record<string, string[]>;
+}
+/** `exposes http openapi://checkout.yaml @9f3c2e1` — a contract the object offers, by pointer (spec §4.3). */
+export interface Interface {
+    verb: 'exposes' | 'stores';
+    kind: string;
+    pointer?: string;
+    rev?: string;
+    label?: string;
+    attrs: Record<string, string[]>;
+    line: number;
+}
+export interface ModelObject {
+    id: string;
+    /** The identifier exactly as declared, without the scope prefix. */
+    localId: string;
+    kind: string;
+    name?: string;
+    attrs: Record<string, string[]>;
+    /** Contracts this object exposes or stores, in document order. */
+    interfaces: Interface[];
+    /** Later moments of the same figures, in document order. */
+    timeline: Moment[];
+    parent?: string;
+    line: number;
+}
+export interface ModelRelation {
+    from: string;
+    to: string;
+    verb: string;
+    over?: string;
+    via?: string[];
+    spec?: string;
+    as?: string;
+    port?: string;
+    label?: string;
+    /** Attributes from the relation body: `{ phase transit  timeout 2s }`. */
+    attrs: Record<string, string[]>;
+    line: number;
+}
+/**
+ * `run checkout replicas 6 cpu 2 mem 4Gi` inside a placement block: the logical
+ * object `checkout` runs on `host`. One object may run in many places; the
+ * object is never copied (spec §6).
+ */
+export interface Placement {
+    host: string;
+    ref: string;
+    attrs: Record<string, string[]>;
+    timeline: Moment[];
+    line: number;
+}
+export interface Model {
+    objects: Map<string, ModelObject>;
+    relations: ModelRelation[];
+    placements: Placement[];
+}
+export declare function lower(doc: Doc): Model;

package/dist/src/model.js

@@ -0,0 +1,114 @@
+import { OPAQUE_KINDS } from './vocab.js';
+/** Repeated keys accumulate: two `subscriber` lines mean two subscribers. */
+const mergeAttrs = (into, list) => {
+    // own keys only: an attribute called `constructor` must not meet Object.prototype
+    for (const a of list)
+        into[a.key] = [...(Object.prototype.hasOwnProperty.call(into, a.key) ? into[a.key] : []), ...a.values];
+    return into;
+};
+const attrsOf = (list) => mergeAttrs({}, list);
+const isMoment = (v) => /^(\d{4}(-\d{2}){0,2}|\+\d+[dwmy])$/.test(v);
+/** `at 2026-12 cpu 12 mem 24Gi` → { when: '2026-12', attrs: { cpu: ['12'], mem: ['24Gi'] } } */
+function momentOf(values) {
+    const [when, ...rest] = values;
+    if (!when || !isMoment(when))
+        return undefined;
+    // `count 3 cpu 16 disk data 15Ti` — a sizing key starts a pair, everything
+    // up to the next sizing key is its value (`disk data 15Ti`, `capacity size 7Ti`)
+    const KEYS = new Set(['replicas', 'count', 'nodes', 'cpu', 'mem', 'disk', 'gpu', 'capacity']);
+    const attrs = {};
+    let k;
+    for (const w of rest) {
+        if (KEYS.has(w) || k === undefined) {
+            k = w;
+            if (!Object.prototype.hasOwnProperty.call(attrs, k))
+                attrs[k] = [];
+            continue;
+        }
+        attrs[k].push(w);
+    }
+    return { when, attrs };
+}
+/** Body lines split into plain attributes and `at` moments. */
+function bodyAttrs(body, into) {
+    const timeline = [];
+    for (const c of body ?? []) {
+        if (c.type !== 'attr')
+            continue;
+        const a = c;
+        const m = a.key === 'at' ? momentOf(a.values) : undefined;
+        if (m)
+            timeline.push(m);
+        else
+            mergeAttrs(into, [a]);
+    }
+    return timeline;
+}
+export function lower(doc) {
+    const objects = new Map();
+    const relations = [];
+    const placements = [];
+    // an interface with an explicit subject may name an object declared later
+    const pendingIfaces = [];
+    const walk = (nodes, parent) => {
+        for (const n of nodes) {
+            if (n.type === 'decl') {
+                const d = n;
+                // a declaration without an id was reported by the parser (AC002); the
+                // statement stays in the tree, but there is no object to build from it
+                if (!d.id) {
+                    if (d.body)
+                        walk(d.body, parent);
+                    continue;
+                }
+                const id = parent && !d.id.includes('.') ? `${parent}.${d.id}` : d.id;
+                const attrs = attrsOf(d.inline);
+                const timeline = bodyAttrs(d.body, attrs);
+                objects.set(id, {
+                    id, localId: d.id, kind: d.kind, name: d.name, attrs, timeline, parent, interfaces: [],
+                    line: d.tokens[0]?.line ?? 0,
+                });
+                if (d.body && !OPAQUE_KINDS.has(d.kind))
+                    walk(d.body, id); // a view or a reserved block holds no objects
+            }
+            else if (n.type === 'iface') {
+                const f = n;
+                const attrs = {};
+                bodyAttrs(f.body, attrs);
+                pendingIfaces.push({ owner: f.subject ?? parent ?? '', scope: parent, iface: {
+                        verb: f.verb, kind: f.kind, pointer: f.pointer, rev: f.rev, label: f.label, attrs, line: f.tokens[0]?.line ?? 0,
+                    } });
+            }
+            else if (n.type === 'rel') {
+                const r = n;
+                const from = r.subject ?? parent ?? '';
+                const attrs = {};
+                bodyAttrs(r.body, attrs);
+                relations.push({
+                    from, to: r.object, verb: r.canonicalVerb,
+                    over: r.over, via: r.via, spec: r.spec, as: r.as, port: r.port, label: r.label, attrs,
+                    line: r.tokens[0]?.line ?? 0,
+                });
+                if (r.body)
+                    walk(r.body, parent);
+            }
+            else if (n.type === 'run') {
+                const r = n;
+                // an `at …` written inline (`run x replicas 2  at 2027-01 replicas 4`) is a moment like one in the body
+                const attrs = attrsOf(r.attrs.filter(a => !(a.key === 'at' && momentOf(a.values))));
+                const timeline = [...r.attrs.filter(a => a.key === 'at').map(a => momentOf(a.values)).filter((m) => !!m), ...bodyAttrs(r.body, attrs)];
+                // `run` outside a host is reported (AC108); it places nothing
+                if (parent)
+                    for (const ref of r.refs)
+                        placements.push({ host: parent, ref, attrs, timeline, line: r.tokens[0]?.line ?? 0 });
+            }
+        }
+    };
+    walk(doc.body);
+    for (const { owner, scope, iface } of pendingIfaces) {
+        const target = objects.get(owner) ?? (scope ? objects.get(`${scope}.${owner}`) : undefined)
+            ?? [...objects.values()].find(o => o.localId === owner);
+        target?.interfaces.push(iface);
+    }
+    return { objects, relations, placements };
+}

package/dist/src/parser.d.ts

@@ -0,0 +1,7 @@
+import type { Doc } from './cst.js';
+import { type Diagnostic } from './diagnostics.js';
+export interface ParseResult {
+    doc: Doc;
+    diagnostics: Diagnostic[];
+}
+export declare function parse(src: string): ParseResult;

package/dist/src/parser.js

@@ -0,0 +1,305 @@
+import { lex } from './lexer.js';
+import { ATTR_KEYS, FLAG_ATTRS, OBJECT_KINDS, IFACE_VERBS, OPAQUE_KINDS, PAIR_KEYS, RELATION_MODIFIERS, RUN, RUN_KEYS, VERBS, VERB_SUGAR } from './vocab.js';
+import { diag } from './diagnostics.js';
+const unquote = (s) => s.startsWith('"') ? s.slice(1, s.endsWith('"') && s.length > 1 ? -1 : undefined).replace(/\\(.)/g, '$1') : s;
+class Parser {
+    t;
+    i = 0;
+    diagnostics = [];
+    /** Every id declared anywhere in the document — one cheap pass before parsing. */
+    declared = new Set();
+    constructor(t) {
+        this.t = t;
+        for (let k = 0; k + 1 < t.length; k++)
+            if (t[k].kind === 'word' && OBJECT_KINDS.has(t[k].text) && t[k + 1].kind === 'word')
+                this.declared.add(t[k + 1].text);
+    }
+    peek(k = 0) { return this.t[Math.min(this.i + k, this.t.length - 1)]; }
+    at(kind, k = 0) { return this.peek(k).kind === kind; }
+    next() { return this.t[this.i++] ?? this.t[this.t.length - 1]; }
+    slice(from) { return this.t.slice(from, this.i); }
+    /** Words on the current logical line, used to decide the statement shape. */
+    lineWords() {
+        const out = [];
+        for (let k = this.i; k < this.t.length; k++) {
+            const tok = this.t[k];
+            if (tok.kind === 'newline' || tok.kind === 'eof' || tok.kind === 'lbrace' || tok.kind === 'rbrace')
+                break;
+            out.push(tok);
+        }
+        return out;
+    }
+    parseDoc() {
+        const body = [];
+        while (!this.at('eof'))
+            body.push(this.parseStatement());
+        const eof = this.next();
+        return { type: 'doc', body, tokens: this.t.slice(), tail: [eof] };
+    }
+    /** Consume the newline that terminates a statement, if present. */
+    eatEol() { if (this.at('newline'))
+        this.next(); }
+    /** True while parsing a body opened and closed on one line: `{ transit  auth oidc }`. */
+    oneLine = false;
+    parseStatement() {
+        if (this.at('newline')) {
+            const from = this.i;
+            this.next();
+            return { type: 'blank', tokens: this.slice(from) };
+        }
+        const words = this.lineWords();
+        const first = words[0];
+        if (!first) { // stray '{' or '}' at statement position
+            const from = this.i;
+            this.next();
+            this.eatEol();
+            const t = this.t[from];
+            this.diagnostics.push(diag('error', 'AC001', `unexpected \`${t.text}\``, t.line, t.col));
+            return { type: 'blank', tokens: this.slice(from) };
+        }
+        if (first.kind === 'word' && OBJECT_KINDS.has(first.text))
+            return this.parseDecl();
+        if (first.kind === 'word' && first.text === RUN && words[1]?.kind === 'word')
+            return this.parseRun();
+        const second = words[1];
+        // `checkout calls billing` is a relation; `capacity calls 20000/day` is an
+        // attribute whose value happens to be a verb. A declared id or a dotted
+        // path is a subject; a known attribute key is not.
+        const subjectLike = !ATTR_KEYS.has(first.text) || this.declared.has(first.text) || first.text.includes('.');
+        if (second && second.kind === 'word' && VERBS.has(second.text) && subjectLike)
+            return this.parseRel(true);
+        if (first.kind === 'word' && VERBS.has(first.text))
+            return this.parseRel(false);
+        if (second && second.kind === 'word' && IFACE_VERBS.has(second.text) && subjectLike)
+            return this.parseIface(true);
+        if (first.kind === 'word' && IFACE_VERBS.has(first.text))
+            return this.parseIface(false);
+        return this.parseAttr(this.oneLine);
+    }
+    parseDecl() {
+        const from = this.i;
+        const kind = this.next().text;
+        let id = '';
+        if (this.at('word'))
+            id = this.next().text;
+        else {
+            const t = this.peek();
+            this.diagnostics.push(diag('error', 'AC002', `\`${kind}\` needs an identifier`, t.line, t.col));
+        }
+        let name;
+        if (this.at('string'))
+            name = unquote(this.next().text);
+        const inline = [];
+        while (!this.at('newline') && !this.at('eof') && !this.at('lbrace') && !this.at('rbrace')) {
+            inline.push(this.parseAttr(/*inline*/ true));
+        }
+        let body;
+        if (this.at('lbrace'))
+            body = OPAQUE_KINDS.has(kind) ? this.parseRawBlock() : this.parseBlock(id);
+        else
+            this.eatEol();
+        return { type: 'decl', kind, id, name, inline, body, tokens: this.slice(from) };
+    }
+    /** `{ … }` of a reserved or `view` block: balanced braces, nothing interpreted. */
+    parseRawBlock() {
+        const open = this.next(); // '{'
+        const from = this.i;
+        let depth = 1;
+        while (!this.at('eof')) {
+            if (this.at('lbrace'))
+                depth++;
+            else if (this.at('rbrace') && --depth === 0)
+                break;
+            this.next();
+        }
+        const raw = { type: 'raw', tokens: this.slice(from) };
+        if (this.at('rbrace')) {
+            this.next();
+            this.eatEol();
+        }
+        else
+            this.diagnostics.push(diag('error', 'AC003', 'unclosed `{`', open.line, open.col));
+        return [raw];
+    }
+    /** `run <ref>[, <ref>…] [sizing…] [{ body }]` */
+    parseRun() {
+        const from = this.i;
+        this.next(); // `run`
+        const refs = [this.next().text];
+        while (this.at('comma')) {
+            this.next();
+            if (this.at('word'))
+                refs.push(this.next().text);
+        }
+        const attrs = [];
+        // Inline, a run takes its sizing (`run api 3 cpu 2`) and its phase; in a
+        // one-line host body (`{ run s3  agent restic }`) anything else is the host's.
+        while (!this.at('newline') && !this.at('eof') && !this.at('lbrace') && !this.at('rbrace')
+            && (!this.oneLine || RUN_KEYS.has(this.peek().text)))
+            attrs.push(this.parseAttr(/*inline*/ true));
+        let body;
+        if (this.at('lbrace'))
+            body = this.parseBlock(refs[0]);
+        else if (!this.oneLine)
+            this.eatEol();
+        return { type: 'run', refs, attrs, body, tokens: this.slice(from) };
+    }
+    parseBlock(_owner) {
+        this.next(); // '{'
+        const body = [];
+        // A body that starts on the same line as its `{` holds attributes side by
+        // side, exactly like the declaration line does; a body that opens with a
+        // newline holds one statement per line.
+        const outer = this.oneLine;
+        this.oneLine = !this.at('newline');
+        while (!this.at('rbrace') && !this.at('eof'))
+            body.push(this.parseStatement());
+        this.oneLine = outer;
+        if (this.at('rbrace')) {
+            this.next();
+            this.eatEol();
+        }
+        else {
+            const t = this.peek();
+            this.diagnostics.push(diag('error', 'AC003', 'unclosed `{`', t.line, t.col));
+        }
+        return body;
+    }
+    /** `key value[, value…]`. In inline mode, stops after one key/value group. */
+    parseAttr(inline = false) {
+        const from = this.i;
+        const keyTok = this.next();
+        const values = [];
+        const readValue = () => {
+            const v = this.next();
+            values.push(v.kind === 'string' ? unquote(v.text) : v.text);
+        };
+        // A flag takes no value when it sits beside other attributes (`transit  auth oidc`)
+        const flag = inline && FLAG_ATTRS.has(keyTok.text) && !/^(true|false)$/.test(this.peek().text);
+        const stop = () => this.at('newline') || this.at('eof') || this.at('lbrace') || this.at('rbrace');
+        // Several pairs may share a line — `dc dc1  vlan 3076`, `host x  ip y  os "z"`,
+        // `tech Go 1.21  cpu 2` — so a value list ends where the next known key
+        // begins (spec §6.1, D-305/A3). `at` is the exception: its line is one
+        // moment with its own pairs inside. On its own line an unknown word is
+        // still a value (`capacity rps 300 p99 250ms`); inline, beside other
+        // attributes, an unknown word starts the next attribute (`auth oidc`) —
+        // there, only numbers and strings continue a value (`tech Go 1.21`).
+        // `capacity` carries its own open-ended pairs (`rps 300 p99 250ms`), inline too
+        const greedy = keyTok.text === 'at', open = keyTok.text === 'capacity';
+        const opensPair = () => !greedy && values.length > 0 && this.peek().kind === 'word' && (PAIR_KEYS.has(this.peek().text) || (inline && !open));
+        if (!flag && !stop())
+            readValue();
+        while (!flag && !stop()) {
+            if (this.at('comma')) {
+                this.next();
+                if (!stop())
+                    readValue();
+                continue;
+            }
+            if (opensPair())
+                break;
+            readValue();
+        }
+        if (!inline)
+            this.eatEol();
+        return { type: 'attr', key: keyTok.text, values, tokens: this.slice(from) };
+    }
+    /** `exposes http openapi://checkout.yaml @9f3c2e1 "label" { … }` — see Iface. */
+    parseIface(explicitSubject) {
+        const from = this.i;
+        const subject = explicitSubject ? this.next().text : undefined;
+        const verbTok = this.next();
+        const verb = verbTok.text;
+        let kind = '';
+        if (this.at('word'))
+            kind = this.next().text;
+        else
+            this.diagnostics.push(diag('error', 'AC004', `\`${verb}\` needs an interface kind (http, grpc, schema, cli…)`, verbTok.line, verbTok.col));
+        let pointer, rev, label;
+        while (!this.at('newline') && !this.at('eof') && !this.at('lbrace') && !this.at('rbrace')) {
+            const t = this.next();
+            if (t.kind === 'string') {
+                label = unquote(t.text);
+                continue;
+            }
+            if (t.text.startsWith('@') && pointer !== undefined) {
+                rev = t.text.slice(1);
+                continue;
+            }
+            if (pointer === undefined) {
+                const at = t.text.includes('://') ? t.text.lastIndexOf('@') : -1; // `openapi://x.yaml@a1b2c3d`
+                if (at > t.text.indexOf('://')) {
+                    pointer = t.text.slice(0, at);
+                    rev = t.text.slice(at + 1);
+                }
+                else
+                    pointer = t.text;
+                continue;
+            }
+            this.diagnostics.push(diag('warning', 'AC005', `unexpected \`${t.text}\` after the pointer`, t.line, t.col));
+        }
+        let body;
+        if (this.at('lbrace'))
+            body = this.parseBlock(kind);
+        else if (!this.oneLine)
+            this.eatEol();
+        return { type: 'iface', subject, verb, kind, pointer, rev, label, body, tokens: this.slice(from) };
+    }
+    parseRel(explicitSubject) {
+        const from = this.i;
+        const subject = explicitSubject ? this.next().text : undefined;
+        const verbTok = this.next();
+        const verb = verbTok.text;
+        let object = '';
+        if (!this.at('newline') && !this.at('eof') && !this.at('lbrace'))
+            object = this.next().text;
+        else
+            this.diagnostics.push(diag('error', 'AC004', `\`${verb}\` needs an object`, verbTok.line, verbTok.col));
+        let over, via, spec, as, label, port;
+        while (!this.at('newline') && !this.at('eof') && !this.at('lbrace') && !this.at('rbrace')) {
+            const t = this.peek();
+            if (t.kind === 'string') {
+                label = unquote(this.next().text);
+                continue;
+            }
+            if (t.kind === 'word' && RELATION_MODIFIERS.has(t.text)) {
+                const mod = this.next().text;
+                const vals = [];
+                if (!this.at('newline') && !this.at('eof'))
+                    vals.push(this.next().text);
+                while (this.at('comma')) {
+                    this.next();
+                    if (!this.at('newline') && !this.at('eof'))
+                        vals.push(this.next().text);
+                }
+                if (mod === 'over')
+                    over = vals[0];
+                else if (mod === 'via')
+                    via = vals;
+                else if (mod === 'spec')
+                    spec = vals[0];
+                else if (mod === 'as')
+                    as = vals[0];
+                else if (mod === 'port')
+                    port = vals[0];
+                continue;
+            }
+            this.diagnostics.push(diag('warning', 'AC005', `unexpected \`${t.text}\` in relation`, t.line, t.col));
+            this.next();
+        }
+        let body;
+        if (this.at('lbrace'))
+            body = this.parseBlock(object);
+        else
+            this.eatEol();
+        return {
+            type: 'rel', subject, verb, canonicalVerb: VERB_SUGAR[verb] ?? verb,
+            object, over, via, spec, as, port, label, body, tokens: this.slice(from),
+        };
+    }
+}
+export function parse(src) {
+    const p = new Parser(lex(src));
+    const doc = p.parseDoc();
+    return { doc, diagnostics: p.diagnostics };
+}