@aitos/core 1.0.0 → 1.0.1

package/dist/acs.js

@@ -0,0 +1,719 @@
+"use strict";
+/**
+ * AITOS Compact Syntax (ACS)
+ *
+ * ACS is a compact representation of Graph JSON, designed for:
+ * - AI generation (10-20x more compact than JSON)
+ * - Human readability (for auditing AI output)
+ * - Unambiguous compilation to/from Graph JSON
+ *
+ * Syntax:
+ *   graph <name> {
+ *     [mode: kernel|user]
+ *     [in: <type> | <name>: <type>, ...]
+ *     [out: <type>]
+ *
+ *     let <nodeId> = <atom>(<param>: <value>, ...)
+ *     if <refNodeId> {
+ *       <nodes...>
+ *     } [else {
+ *       <nodes...>
+ *     }]
+ *     loop [max: N] [cond: <storeKey>] {
+ *       <nodes...>
+ *     }
+ *     forEach <itemKey> in <arrayRef> [max: N] {
+ *       <nodes...>
+ *     }
+ *   }
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AcsDecompiler = exports.AcsCompiler = exports.AcsParser = void 0;
+exports.compileAcs = compileAcs;
+exports.decompileAcs = decompileAcs;
+class AcsParser {
+    constructor() {
+        this.pos = 0;
+        this.src = '';
+    }
+    parse(text) {
+        this.src = text.trim();
+        this.pos = 0;
+        return this.parseGraph();
+    }
+    parseGraph() {
+        this.expect('graph');
+        const name = this.readIdentifier();
+        this.expect('{');
+        const graph = { name, nodes: [] };
+        while (!this.peek('}') && this.pos < this.src.length) {
+            this.skipWhitespaceAndComments();
+            if (this.peek('mode:')) {
+                this.advance(5);
+                graph.mode = this.readIdentifier();
+            }
+            else if (this.peek('meta:')) {
+                this.advance(5);
+                graph.meta = this.parseMetaDecl();
+            }
+            else if (this.peek('in:')) {
+                this.advance(3);
+                graph.input = this.parseInputDecl();
+            }
+            else if (this.peek('out:')) {
+                this.advance(4);
+                graph.output = this.readIdentifier();
+            }
+            else if (this.peek('let')) {
+                graph.nodes.push(this.parseLet());
+            }
+            else if (this.peek('if')) {
+                graph.nodes.push(this.parseIf());
+            }
+            else if (this.peek('loop')) {
+                graph.nodes.push(this.parseLoop());
+            }
+            else if (this.peek('forEach')) {
+                graph.nodes.push(this.parseForEach());
+            }
+            else if (this.peek('filter')) {
+                graph.nodes.push(this.parseFilter());
+            }
+            else {
+                throw new Error(`ACS parse error at pos ${this.pos}: unexpected "${this.src.slice(this.pos, this.pos + 20)}"`);
+            }
+            this.skipWhitespaceAndComments();
+        }
+        this.expect('}');
+        return graph;
+    }
+    parseLet() {
+        this.expect('let');
+        const id = this.readIdentifier();
+        this.expect('=');
+        this.skipWhitespaceAndComments();
+        if (this.peek('if')) {
+            const ifNode = this.parseIf();
+            ifNode.id = id;
+            return ifNode;
+        }
+        if (this.peek('forEach')) {
+            const forEachNode = this.parseForEach();
+            forEachNode.id = id;
+            return forEachNode;
+        }
+        if (this.peek('loop')) {
+            const loopNode = this.parseLoop();
+            loopNode.id = id;
+            return loopNode;
+        }
+        if (this.peek('filter')) {
+            const filterNode = this.parseFilter();
+            filterNode.id = id;
+            return filterNode;
+        }
+        const atom = this.readIdentifier();
+        const params = this.parseParams();
+        return { type: 'let', id, atom, params };
+    }
+    parseIf() {
+        this.expect('if');
+        this.skipWhitespaceAndComments();
+        const savedPos = this.pos;
+        const firstIdent = this.readIdentifier();
+        this.skipWhitespaceAndComments();
+        let ref;
+        let inlineCondAtom;
+        if (this.peek('(')) {
+            const params = this.parseParams();
+            inlineCondAtom = { atom: firstIdent, params };
+            ref = `__inline_cond_${savedPos}`;
+        }
+        else {
+            ref = firstIdent;
+        }
+        this.expect('{');
+        const body = this.parseBody();
+        this.expect('}');
+        let elseBody;
+        this.skipWhitespaceAndComments();
+        if (this.peek('else')) {
+            this.advance(4);
+            this.expect('{');
+            elseBody = this.parseBody();
+            this.expect('}');
+        }
+        const ifNode = { type: 'if', ref, body, elseBody };
+        if (inlineCondAtom) {
+            ifNode.inlineCondAtom = inlineCondAtom;
+        }
+        return ifNode;
+    }
+    parseLoop() {
+        this.expect('loop');
+        let maxIterations;
+        let condKey;
+        this.skipWhitespaceAndComments();
+        if (this.peek('max:')) {
+            this.advance(4);
+            maxIterations = this.readNumber();
+        }
+        this.skipWhitespaceAndComments();
+        if (this.peek('cond:')) {
+            this.advance(5);
+            condKey = this.readString() || this.readIdentifier();
+        }
+        this.expect('{');
+        const body = this.parseBody();
+        this.expect('}');
+        return { type: 'loop', maxIterations, condKey, body };
+    }
+    parseForEach() {
+        this.expect('forEach');
+        const itemKey = this.readIdentifier();
+        let indexKey;
+        this.skipWhitespaceAndComments();
+        if (this.peek(',')) {
+            this.advance(1);
+            indexKey = this.readIdentifier();
+        }
+        this.expect('in');
+        const arrayRef = this.readIdentifier();
+        let maxItems;
+        this.skipWhitespaceAndComments();
+        if (this.peek('max:')) {
+            this.advance(4);
+            maxItems = this.readNumber();
+        }
+        this.expect('{');
+        const body = this.parseBody();
+        this.expect('}');
+        return { type: 'forEach', itemKey, indexKey, arrayRef, maxItems, body };
+    }
+    parseFilter() {
+        this.expect('filter');
+        const itemKey = this.readIdentifier();
+        let indexKey;
+        this.skipWhitespaceAndComments();
+        if (this.peek('index:')) {
+            this.advance(6);
+            indexKey = this.readIdentifier();
+        }
+        this.expect('in');
+        const arrayRef = this.readIdentifier();
+        this.expect('{');
+        const body = this.parseBody();
+        this.expect('}');
+        return { type: 'filter', itemKey, indexKey, arrayRef, body };
+    }
+    parseBody() {
+        const nodes = [];
+        this.skipWhitespaceAndComments();
+        while (!this.peek('}') && this.pos < this.src.length) {
+            if (this.peek('let'))
+                nodes.push(this.parseLet());
+            else if (this.peek('if'))
+                nodes.push(this.parseIf());
+            else if (this.peek('loop'))
+                nodes.push(this.parseLoop());
+            else if (this.peek('forEach'))
+                nodes.push(this.parseForEach());
+            else if (this.peek('filter'))
+                nodes.push(this.parseFilter());
+            else
+                break;
+            this.skipWhitespaceAndComments();
+        }
+        return nodes;
+    }
+    parseParams() {
+        if (!this.peek('('))
+            return {};
+        this.advance(1); // skip (
+        const params = {};
+        while (!this.peek(')') && this.pos < this.src.length) {
+            const key = this.readIdentifier();
+            this.expect(':');
+            const value = this.readValue();
+            params[key] = value;
+            this.skipWhitespaceAndComments();
+            if (this.peek(','))
+                this.advance(1);
+            this.skipWhitespaceAndComments();
+        }
+        this.expect(')');
+        return params;
+    }
+    parseInputDecl() {
+        if (this.peek('none')) {
+            this.advance(4);
+            return [];
+        }
+        const result = [];
+        while (!this.peek('\n') && !this.peek('}') && this.pos < this.src.length) {
+            const name = this.readIdentifier();
+            this.expect(':');
+            const type = this.readIdentifier();
+            result.push({ name, type });
+            this.skipWhitespaceAndComments();
+            if (this.peek(','))
+                this.advance(1);
+            this.skipWhitespaceAndComments();
+        }
+        return result;
+    }
+    parseMetaDecl() {
+        this.expect('{');
+        const meta = {};
+        while (!this.peek('}') && this.pos < this.src.length) {
+            const key = this.readIdentifier();
+            this.expect(':');
+            meta[key] = this.readString() || this.readIdentifier();
+            this.skipWhitespaceAndComments();
+            if (this.peek(','))
+                this.advance(1);
+            this.skipWhitespaceAndComments();
+        }
+        this.expect('}');
+        return meta;
+    }
+    readValue() {
+        this.skipWhitespaceAndComments();
+        if (this.peek('"'))
+            return this.readString();
+        if (this.peek("'"))
+            return this.readString();
+        if (this.src[this.pos] === '-' || this.src[this.pos] >= '0' && this.src[this.pos] <= '9')
+            return this.readNumber();
+        if (this.peek('true')) {
+            this.advance(4);
+            return true;
+        }
+        if (this.peek('false')) {
+            this.advance(5);
+            return false;
+        }
+        if (this.peek('null')) {
+            this.advance(4);
+            return null;
+        }
+        if (this.peek('{{'))
+            return this.readReference();
+        if (this.peek('{'))
+            return this.readObject();
+        if (this.peek('['))
+            return this.readArray();
+        return this.readIdentifier();
+    }
+    readReference() {
+        const start = this.pos;
+        this.advance(2);
+        const ref = this.readUntil('}}');
+        this.advance(2);
+        return `{{${ref}}}`;
+    }
+    readObject() {
+        this.expect('{');
+        const obj = {};
+        this.skipWhitespaceAndComments();
+        while (!this.peek('}') && this.pos < this.src.length) {
+            let key;
+            if (this.peek('"') || this.peek("'")) {
+                key = this.readString();
+            }
+            else {
+                key = this.readIdentifier();
+            }
+            this.expect(':');
+            const value = this.readValue();
+            obj[key] = value;
+            this.skipWhitespaceAndComments();
+            if (this.peek(','))
+                this.advance(1);
+            this.skipWhitespaceAndComments();
+        }
+        this.expect('}');
+        return obj;
+    }
+    readArray() {
+        this.expect('[');
+        const arr = [];
+        this.skipWhitespaceAndComments();
+        while (!this.peek(']') && this.pos < this.src.length) {
+            arr.push(this.readValue());
+            this.skipWhitespaceAndComments();
+            if (this.peek(','))
+                this.advance(1);
+            this.skipWhitespaceAndComments();
+        }
+        this.expect(']');
+        return arr;
+    }
+    skipWhitespaceAndComments() {
+        while (this.pos < this.src.length) {
+            if (/\s/.test(this.src[this.pos])) {
+                this.pos++;
+                continue;
+            }
+            if (this.src[this.pos] === '/' && this.src[this.pos + 1] === '/') {
+                while (this.pos < this.src.length && this.src[this.pos] !== '\n')
+                    this.pos++;
+                continue;
+            }
+            break;
+        }
+    }
+    peek(s) {
+        return this.src.slice(this.pos, this.pos + s.length) === s;
+    }
+    expect(s) {
+        this.skipWhitespaceAndComments();
+        if (!this.peek(s)) {
+            throw new Error(`ACS parse error at pos ${this.pos}: expected "${s}", got "${this.src.slice(this.pos, this.pos + 10)}"`);
+        }
+        this.pos += s.length;
+    }
+    advance(n) {
+        this.pos += n;
+    }
+    readIdentifier() {
+        this.skipWhitespaceAndComments();
+        let start = this.pos;
+        while (this.pos < this.src.length && /[a-zA-Z0-9_@\-/.]/.test(this.src[this.pos]))
+            this.pos++;
+        if (this.pos === start)
+            throw new Error(`ACS parse error at pos ${this.pos}: expected identifier`);
+        return this.src.slice(start, this.pos);
+    }
+    readNumber() {
+        this.skipWhitespaceAndComments();
+        let start = this.pos;
+        if (this.src[this.pos] === '-')
+            this.pos++;
+        while (this.pos < this.src.length && /[0-9.]/.test(this.src[this.pos]))
+            this.pos++;
+        return Number(this.src.slice(start, this.pos));
+    }
+    readString() {
+        this.skipWhitespaceAndComments();
+        const quote = this.src[this.pos];
+        if (quote !== '"' && quote !== "'")
+            throw new Error(`ACS parse error at pos ${this.pos}: expected string`);
+        this.pos++;
+        let result = '';
+        while (this.pos < this.src.length && this.src[this.pos] !== quote) {
+            if (this.src[this.pos] === '\\') {
+                this.pos++;
+                const ch = this.src[this.pos];
+                if (ch === 'n')
+                    result += '\n';
+                else if (ch === 't')
+                    result += '\t';
+                else if (ch === 'r')
+                    result += '\r';
+                else if (ch === '\\')
+                    result += '\\';
+                else if (ch === quote)
+                    result += quote;
+                else if (ch === '{')
+                    result += '\\{';
+                else
+                    result += ch;
+            }
+            else {
+                result += this.src[this.pos];
+            }
+            this.pos++;
+        }
+        this.pos++;
+        return result;
+    }
+    readUntil(end) {
+        let result = '';
+        while (this.pos < this.src.length && !this.peek(end)) {
+            result += this.src[this.pos];
+            this.pos++;
+        }
+        return result;
+    }
+}
+exports.AcsParser = AcsParser;
+class AcsCompiler {
+    compile(acsGraph) {
+        const graph = {
+            order: [],
+            nodes: {},
+        };
+        if (acsGraph.mode)
+            graph.mode = acsGraph.mode;
+        if (acsGraph.meta)
+            graph._meta = acsGraph.meta;
+        if (acsGraph.input && acsGraph.input.length > 0) {
+            graph.interface = {
+                input: acsGraph.input.map(i => ({ name: i.name, type: i.type })),
+                output: { type: acsGraph.output || 'void' },
+            };
+        }
+        this.compileNodes(acsGraph.nodes, graph);
+        return graph;
+    }
+    compileNodes(acsNodes, graph) {
+        for (const node of acsNodes) {
+            switch (node.type) {
+                case 'let': {
+                    const graphNode = { atom: node.atom, ...node.params };
+                    graph.order.push(node.id);
+                    graph.nodes[node.id] = graphNode;
+                    break;
+                }
+                case 'if': {
+                    if (node.inlineCondAtom) {
+                        const condNodeId = node.ref;
+                        const condGraphNode = { atom: node.inlineCondAtom.atom, ...node.inlineCondAtom.params };
+                        graph.order.push(condNodeId);
+                        graph.nodes[condNodeId] = condGraphNode;
+                    }
+                    let ifNodeId;
+                    if (node.id) {
+                        ifNodeId = node.id;
+                    }
+                    else {
+                        ifNodeId = `if_${node.ref}`;
+                        if (graph.nodes[ifNodeId]) {
+                            ifNodeId = `if_${node.ref}_${graph.order.length}`;
+                        }
+                    }
+                    const thenGraph = this.compileSubGraph(node.body || []);
+                    const elseGraph = node.elseBody ? this.compileSubGraph(node.elseBody) : undefined;
+                    const graphNode = {
+                        atom: 'branch',
+                        cond: `{{${node.ref}}}`,
+                    };
+                    if (thenGraph.order.length > 0 || !elseGraph)
+                        graphNode.then = thenGraph;
+                    if (elseGraph)
+                        graphNode.else = elseGraph;
+                    graph.order.push(ifNodeId);
+                    graph.nodes[ifNodeId] = graphNode;
+                    break;
+                }
+                case 'loop': {
+                    const loopNodeId = node.id || `loop_${graph.order.length}`;
+                    const bodyGraph = this.compileSubGraph(node.body || []);
+                    const graphNode = {
+                        atom: 'loop',
+                        nodes: bodyGraph,
+                    };
+                    if (node.maxIterations)
+                        graphNode.maxIterations = node.maxIterations;
+                    if (node.condKey)
+                        graphNode.condKey = node.condKey;
+                    graph.order.push(loopNodeId);
+                    graph.nodes[loopNodeId] = graphNode;
+                    break;
+                }
+                case 'forEach': {
+                    const feNodeId = node.id || `forEach_${graph.order.length}`;
+                    const bodyGraph = this.compileSubGraph(node.body || []);
+                    const graphNode = {
+                        atom: 'forEach',
+                        array: `{{${node.arrayRef}}}`,
+                        nodes: bodyGraph,
+                        itemKey: node.itemKey,
+                    };
+                    if (node.indexKey)
+                        graphNode.indexKey = node.indexKey;
+                    if (node.maxItems)
+                        graphNode.maxItems = node.maxItems;
+                    graph.order.push(feNodeId);
+                    graph.nodes[feNodeId] = graphNode;
+                    break;
+                }
+                case 'filter': {
+                    const fNodeId = node.id || `filter_${graph.order.length}`;
+                    const bodyGraph = this.compileSubGraph(node.body || []);
+                    const graphNode = {
+                        atom: 'filter',
+                        array: `{{${node.arrayRef}}}`,
+                        nodes: bodyGraph,
+                        itemKey: node.itemKey,
+                    };
+                    if (node.indexKey)
+                        graphNode.indexKey = node.indexKey;
+                    graph.order.push(fNodeId);
+                    graph.nodes[fNodeId] = graphNode;
+                    break;
+                }
+            }
+        }
+    }
+    compileSubGraph(acsNodes) {
+        const graph = { order: [], nodes: {} };
+        this.compileNodes(acsNodes, graph);
+        return graph;
+    }
+}
+exports.AcsCompiler = AcsCompiler;
+class AcsDecompiler {
+    decompile(graph, name = 'unnamed') {
+        const lines = [];
+        lines.push(`graph ${name} {`);
+        if (graph.mode)
+            lines.push(`  mode: ${graph.mode}`);
+        if (graph._meta) {
+            const parts = Object.entries(graph._meta).map(([k, v]) => `${k}: "${v}"`).join(', ');
+            lines.push(`  meta: { ${parts} }`);
+        }
+        if (graph.interface) {
+            if (graph.interface.input.length === 0) {
+                lines.push(`  in: none`);
+            }
+            else {
+                const inStr = graph.interface.input.map(i => `${i.name}: ${i.type}`).join(', ');
+                lines.push(`  in: ${inStr}`);
+            }
+            lines.push(`  out: ${graph.interface.output.type}`);
+        }
+        lines.push('');
+        for (const nodeId of graph.order) {
+            const node = graph.nodes[nodeId];
+            if (nodeId.startsWith('__inline_cond_') && node.atom !== 'branch')
+                continue;
+            lines.push(...this.decompileNode(nodeId, node, 1, graph.nodes));
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    decompileNode(nodeId, node, indent, allNodes) {
+        const prefix = '  '.repeat(indent);
+        const lines = [];
+        if (node.atom === 'branch') {
+            const condRef = this.extractCondRef(node.cond);
+            const isNamedIf = nodeId && !nodeId.startsWith('if_');
+            const ifPrefix = isNamedIf ? `${prefix}let ${nodeId} = ` : '';
+            let condStr = condRef || nodeId;
+            if (condRef && condRef.startsWith('__inline_cond_') && allNodes && allNodes[condRef]) {
+                const condNode = allNodes[condRef];
+                const condParams = this.formatParams(condNode);
+                condStr = `${condNode.atom}(${condParams})`;
+                lines.push(`${ifPrefix}if ${condStr} {`);
+            }
+            else {
+                lines.push(`${ifPrefix}if ${condStr} {`);
+            }
+            if (node.then)
+                lines.push(...this.decompileSubGraph(node.then, indent + 1));
+            if (node.else) {
+                lines.push(`${prefix}} else {`);
+                lines.push(...this.decompileSubGraph(node.else, indent + 1));
+            }
+            lines.push(`${prefix}}`);
+        }
+        else if (node.atom === 'loop') {
+            const isNamedLoop = nodeId && !nodeId.startsWith('loop_');
+            const loopPrefix = isNamedLoop ? `${prefix}let ${nodeId} = ` : '';
+            const extras = [];
+            if (node.maxIterations)
+                extras.push(`max: ${node.maxIterations}`);
+            if (node.condKey)
+                extras.push(`cond: "${node.condKey}"`);
+            lines.push(`${loopPrefix}loop ${extras.join(' ')} {`);
+            if (node.nodes)
+                lines.push(...this.decompileSubGraph(node.nodes, indent + 1));
+            lines.push(`${prefix}}`);
+        }
+        else if (node.atom === 'forEach') {
+            const isNamedForEach = nodeId && !nodeId.startsWith('forEach_');
+            const fePrefix = isNamedForEach ? `${prefix}let ${nodeId} = ` : '';
+            const extras = [];
+            if (node.maxItems)
+                extras.push(`max: ${node.maxItems}`);
+            const idx = node.indexKey ? `, ${node.indexKey}` : '';
+            lines.push(`${fePrefix}forEach ${node.itemKey || 'item'}${idx} in ${this.extractArrayRef(node.array)} ${extras.join(' ')} {`);
+            if (node.nodes)
+                lines.push(...this.decompileSubGraph(node.nodes, indent + 1));
+            lines.push(`${prefix}}`);
+        }
+        else if (node.atom === 'filter') {
+            const isNamedFilter = nodeId && !nodeId.startsWith('filter_');
+            const fPrefix = isNamedFilter ? `${prefix}let ${nodeId} = ` : '';
+            const idx = node.indexKey ? ` index: ${node.indexKey}` : '';
+            lines.push(`${fPrefix}filter ${node.itemKey || 'item'}${idx} in ${this.extractArrayRef(node.array)} {`);
+            if (node.nodes)
+                lines.push(...this.decompileSubGraph(node.nodes, indent + 1));
+            lines.push(`${prefix}}`);
+        }
+        else {
+            const params = this.formatParams(node);
+            lines.push(`${prefix}let ${nodeId} = ${node.atom}(${params})`);
+        }
+        return lines;
+    }
+    decompileSubGraph(graph, indent) {
+        const lines = [];
+        for (const nodeId of graph.order) {
+            if (nodeId.startsWith('__inline_cond_') && graph.nodes[nodeId].atom !== 'branch')
+                continue;
+            lines.push(...this.decompileNode(nodeId, graph.nodes[nodeId], indent, graph.nodes));
+        }
+        return lines;
+    }
+    formatParams(node) {
+        const SKIP = new Set(['atom', 'nodes', 'then', 'else', 'cond', 'maxIterations', 'itemKey', 'maxItems']);
+        if (node.atom === 'forEach' || node.atom === 'filter')
+            SKIP.add('array');
+        const parts = [];
+        for (const [key, value] of Object.entries(node)) {
+            if (SKIP.has(key))
+                continue;
+            parts.push(`${key}: ${this.formatValue(value)}`);
+        }
+        return parts.join(', ');
+    }
+    formatValue(value) {
+        if (typeof value === 'string') {
+            const escaped = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+            return `"${escaped}"`;
+        }
+        if (typeof value === 'number' || typeof value === 'boolean')
+            return String(value);
+        if (value === null)
+            return 'null';
+        if (Array.isArray(value))
+            return `[${value.map(v => this.formatValue(v)).join(', ')}]`;
+        if (typeof value === 'object') {
+            const parts = Object.entries(value).map(([k, v]) => {
+                const keyStr = /^[a-zA-Z_]\w*$/.test(k) ? k : `"${k}"`;
+                return `${keyStr}: ${this.formatValue(v)}`;
+            });
+            return `{ ${parts.join(', ')} }`;
+        }
+        return String(value);
+    }
+    extractArrayRef(array) {
+        if (typeof array === 'string' && array.startsWith('{{')) {
+            const match = array.match(/^\{\{(\w+)\}\}$/);
+            return match ? match[1] : array;
+        }
+        return String(array);
+    }
+    extractCondRef(cond) {
+        if (typeof cond === 'string' && cond.startsWith('{{')) {
+            const match = cond.match(/^\{\{(\w+)(?:\.(.+?))?\}\}$/);
+            return match ? (match[2] ? `${match[1]}.${match[2]}` : match[1]) : String(cond);
+        }
+        return String(cond);
+    }
+}
+exports.AcsDecompiler = AcsDecompiler;
+function compileAcs(text) {
+    const parser = new AcsParser();
+    const ast = parser.parse(text);
+    const compiler = new AcsCompiler();
+    return compiler.compile(ast);
+}
+function decompileAcs(graph, name) {
+    const decompiler = new AcsDecompiler();
+    return decompiler.decompile(graph, name);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"acs.js","sourceRoot":"","sources":["../src/acs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * AITOS Compact Syntax (ACS)\n *\n * ACS is a compact representation of Graph JSON, designed for:\n * - AI generation (10-20x more compact than JSON)\n * - Human readability (for auditing AI output)\n * - Unambiguous compilation to/from Graph JSON\n *\n * Syntax:\n *   graph <name> {\n *     [mode: kernel|user]\n *     [in: <type> | <name>: <type>, ...]\n *     [out: <type>]\n *\n *     let <nodeId> = <atom>(<param>: <value>, ...)\n *     if <refNodeId> {\n *       <nodes...>\n *     } [else {\n *       <nodes...>\n *     }]\n *     loop [max: N] [cond: <storeKey>] {\n *       <nodes...>\n *     }\n *     forEach <itemKey> in <arrayRef> [max: N] {\n *       <nodes...>\n *     }\n *   }\n */\n\nimport { Graph, GraphNode } from './types';\n\ninterface AcsNode {\n  type: 'let' | 'if' | 'loop' | 'forEach' | 'filter';\n  id?: string;\n  atom?: string;\n  params?: Record<string, any>;\n  ref?: string;\n  body?: AcsNode[];\n  elseBody?: AcsNode[];\n  maxIterations?: number;\n  condKey?: string;\n  itemKey?: string;\n  indexKey?: string;\n  arrayRef?: string;\n  maxItems?: number;\n  inlineCondAtom?: { atom: string; params: Record<string, any> };\n}\n\ninterface AcsGraph {\n  name: string;\n  mode?: 'kernel' | 'user';\n  meta?: { description?: string; type?: string; category?: string; author?: string };\n  input?: Array<{ name: string; type: string }>;\n  output?: string;\n  nodes: AcsNode[];\n}\n\nexport class AcsParser {\n  private pos = 0;\n  private src = '';\n\n  parse(text: string): AcsGraph {\n    this.src = text.trim();\n    this.pos = 0;\n    return this.parseGraph();\n  }\n\n  private parseGraph(): AcsGraph {\n    this.expect('graph');\n    const name = this.readIdentifier();\n    this.expect('{');\n\n    const graph: AcsGraph = { name, nodes: [] };\n\n    while (!this.peek('}') && this.pos < this.src.length) {\n      this.skipWhitespaceAndComments();\n\n      if (this.peek('mode:')) {\n        this.advance(5);\n        graph.mode = this.readIdentifier() as 'kernel' | 'user';\n      } else if (this.peek('meta:')) {\n        this.advance(5);\n        graph.meta = this.parseMetaDecl();\n      } else if (this.peek('in:')) {\n        this.advance(3);\n        graph.input = this.parseInputDecl();\n      } else if (this.peek('out:')) {\n        this.advance(4);\n        graph.output = this.readIdentifier();\n      } else if (this.peek('let')) {\n        graph.nodes.push(this.parseLet());\n      } else if (this.peek('if')) {\n        graph.nodes.push(this.parseIf());\n      } else if (this.peek('loop')) {\n        graph.nodes.push(this.parseLoop());\n      } else if (this.peek('forEach')) {\n        graph.nodes.push(this.parseForEach());\n      } else if (this.peek('filter')) {\n        graph.nodes.push(this.parseFilter());\n      } else {\n        throw new Error(`ACS parse error at pos ${this.pos}: unexpected \"${this.src.slice(this.pos, this.pos + 20)}\"`);\n      }\n\n      this.skipWhitespaceAndComments();\n    }\n\n    this.expect('}');\n    return graph;\n  }\n\n  private parseLet(): AcsNode {\n    this.expect('let');\n    const id = this.readIdentifier();\n    this.expect('=');\n    this.skipWhitespaceAndComments();\n    if (this.peek('if')) {\n      const ifNode = this.parseIf();\n      ifNode.id = id;\n      return ifNode;\n    }\n    if (this.peek('forEach')) {\n      const forEachNode = this.parseForEach();\n      forEachNode.id = id;\n      return forEachNode;\n    }\n    if (this.peek('loop')) {\n      const loopNode = this.parseLoop();\n      loopNode.id = id;\n      return loopNode;\n    }\n    if (this.peek('filter')) {\n      const filterNode = this.parseFilter();\n      filterNode.id = id;\n      return filterNode;\n    }\n    const atom = this.readIdentifier();\n    const params = this.parseParams();\n    return { type: 'let', id, atom, params };\n  }\n\n  private parseIf(): AcsNode {\n    this.expect('if');\n    this.skipWhitespaceAndComments();\n\n    const savedPos = this.pos;\n    const firstIdent = this.readIdentifier();\n    this.skipWhitespaceAndComments();\n\n    let ref: string;\n    let inlineCondAtom: { atom: string; params: Record<string, any> } | undefined;\n\n    if (this.peek('(')) {\n      const params = this.parseParams();\n      inlineCondAtom = { atom: firstIdent, params };\n      ref = `__inline_cond_${savedPos}`;\n    } else {\n      ref = firstIdent;\n    }\n\n    this.expect('{');\n    const body = this.parseBody();\n    this.expect('}');\n\n    let elseBody: AcsNode[] | undefined;\n    this.skipWhitespaceAndComments();\n    if (this.peek('else')) {\n      this.advance(4);\n      this.expect('{');\n      elseBody = this.parseBody();\n      this.expect('}');\n    }\n\n    const ifNode: AcsNode = { type: 'if', ref, body, elseBody };\n    if (inlineCondAtom) {\n      ifNode.inlineCondAtom = inlineCondAtom;\n    }\n    return ifNode;\n  }\n\n  private parseLoop(): AcsNode {\n    this.expect('loop');\n    let maxIterations: number | undefined;\n    let condKey: string | undefined;\n\n    this.skipWhitespaceAndComments();\n    if (this.peek('max:')) {\n      this.advance(4);\n      maxIterations = this.readNumber();\n    }\n    this.skipWhitespaceAndComments();\n    if (this.peek('cond:')) {\n      this.advance(5);\n      condKey = this.readString() || this.readIdentifier();\n    }\n\n    this.expect('{');\n    const body = this.parseBody();\n    this.expect('}');\n\n    return { type: 'loop', maxIterations, condKey, body };\n  }\n\n  private parseForEach(): AcsNode {\n    this.expect('forEach');\n    const itemKey = this.readIdentifier();\n    let indexKey: string | undefined;\n    this.skipWhitespaceAndComments();\n    if (this.peek(',')) {\n      this.advance(1);\n      indexKey = this.readIdentifier();\n    }\n    this.expect('in');\n    const arrayRef = this.readIdentifier();\n    let maxItems: number | undefined;\n\n    this.skipWhitespaceAndComments();\n    if (this.peek('max:')) {\n      this.advance(4);\n      maxItems = this.readNumber();\n    }\n\n    this.expect('{');\n    const body = this.parseBody();\n    this.expect('}');\n\n    return { type: 'forEach', itemKey, indexKey, arrayRef, maxItems, body };\n  }\n\n  private parseFilter(): AcsNode {\n    this.expect('filter');\n    const itemKey = this.readIdentifier();\n    let indexKey: string | undefined;\n\n    this.skipWhitespaceAndComments();\n    if (this.peek('index:')) {\n      this.advance(6);\n      indexKey = this.readIdentifier();\n    }\n\n    this.expect('in');\n    const arrayRef = this.readIdentifier();\n\n    this.expect('{');\n    const body = this.parseBody();\n    this.expect('}');\n\n    return { type: 'filter', itemKey, indexKey, arrayRef, body };\n  }\n\n  private parseBody(): AcsNode[] {\n    const nodes: AcsNode[] = [];\n    this.skipWhitespaceAndComments();\n\n    while (!this.peek('}') && this.pos < this.src.length) {\n      if (this.peek('let')) nodes.push(this.parseLet());\n      else if (this.peek('if')) nodes.push(this.parseIf());\n      else if (this.peek('loop')) nodes.push(this.parseLoop());\n      else if (this.peek('forEach')) nodes.push(this.parseForEach());\n      else if (this.peek('filter')) nodes.push(this.parseFilter());\n      else break;\n      this.skipWhitespaceAndComments();\n    }\n\n    return nodes;\n  }\n\n  private parseParams(): Record<string, any> {\n    if (!this.peek('(')) return {};\n    this.advance(1); // skip (\n\n    const params: Record<string, any> = {};\n    while (!this.peek(')') && this.pos < this.src.length) {\n      const key = this.readIdentifier();\n      this.expect(':');\n      const value = this.readValue();\n      params[key] = value;\n\n      this.skipWhitespaceAndComments();\n      if (this.peek(',')) this.advance(1);\n      this.skipWhitespaceAndComments();\n    }\n\n    this.expect(')');\n    return params;\n  }\n\n  private parseInputDecl(): Array<{ name: string; type: string }> {\n    if (this.peek('none')) { this.advance(4); return []; }\n    const result: Array<{ name: string; type: string }> = [];\n    while (!this.peek('\\n') && !this.peek('}') && this.pos < this.src.length) {\n      const name = this.readIdentifier();\n      this.expect(':');\n      const type = this.readIdentifier();\n      result.push({ name, type });\n      this.skipWhitespaceAndComments();\n      if (this.peek(',')) this.advance(1);\n      this.skipWhitespaceAndComments();\n    }\n    return result;\n  }\n\n  private parseMetaDecl(): { description?: string; type?: string; category?: string; author?: string } {\n    this.expect('{');\n    const meta: any = {};\n    while (!this.peek('}') && this.pos < this.src.length) {\n      const key = this.readIdentifier();\n      this.expect(':');\n      meta[key] = this.readString() || this.readIdentifier();\n      this.skipWhitespaceAndComments();\n      if (this.peek(',')) this.advance(1);\n      this.skipWhitespaceAndComments();\n    }\n    this.expect('}');\n    return meta;\n  }\n\n  private readValue(): any {\n    this.skipWhitespaceAndComments();\n    if (this.peek('\"')) return this.readString();\n    if (this.peek(\"'\")) return this.readString();\n    if (this.src[this.pos] === '-' || this.src[this.pos] >= '0' && this.src[this.pos] <= '9') return this.readNumber();\n    if (this.peek('true')) { this.advance(4); return true; }\n    if (this.peek('false')) { this.advance(5); return false; }\n    if (this.peek('null')) { this.advance(4); return null; }\n    if (this.peek('{{')) return this.readReference();\n    if (this.peek('{')) return this.readObject();\n    if (this.peek('[')) return this.readArray();\n    return this.readIdentifier();\n  }\n\n  private readReference(): string {\n    const start = this.pos;\n    this.advance(2);\n    const ref = this.readUntil('}}');\n    this.advance(2);\n    return `{{${ref}}}`;\n  }\n\n  private readObject(): Record<string, any> {\n    this.expect('{');\n    const obj: Record<string, any> = {};\n    this.skipWhitespaceAndComments();\n    while (!this.peek('}') && this.pos < this.src.length) {\n      let key: string;\n      if (this.peek('\"') || this.peek(\"'\")) {\n        key = this.readString();\n      } else {\n        key = this.readIdentifier();\n      }\n      this.expect(':');\n      const value = this.readValue();\n      obj[key] = value;\n      this.skipWhitespaceAndComments();\n      if (this.peek(',')) this.advance(1);\n      this.skipWhitespaceAndComments();\n    }\n    this.expect('}');\n    return obj;\n  }\n\n  private readArray(): any[] {\n    this.expect('[');\n    const arr: any[] = [];\n    this.skipWhitespaceAndComments();\n    while (!this.peek(']') && this.pos < this.src.length) {\n      arr.push(this.readValue());\n      this.skipWhitespaceAndComments();\n      if (this.peek(',')) this.advance(1);\n      this.skipWhitespaceAndComments();\n    }\n    this.expect(']');\n    return arr;\n  }\n\n  private skipWhitespaceAndComments(): void {\n    while (this.pos < this.src.length) {\n      if (/\\s/.test(this.src[this.pos])) { this.pos++; continue; }\n      if (this.src[this.pos] === '/' && this.src[this.pos + 1] === '/') {\n        while (this.pos < this.src.length && this.src[this.pos] !== '\\n') this.pos++;\n        continue;\n      }\n      break;\n    }\n  }\n\n  private peek(s: string): boolean {\n    return this.src.slice(this.pos, this.pos + s.length) === s;\n  }\n\n  private expect(s: string): void {\n    this.skipWhitespaceAndComments();\n    if (!this.peek(s)) {\n      throw new Error(`ACS parse error at pos ${this.pos}: expected \"${s}\", got \"${this.src.slice(this.pos, this.pos + 10)}\"`);\n    }\n    this.pos += s.length;\n  }\n\n  private advance(n: number): void {\n    this.pos += n;\n  }\n\n  private readIdentifier(): string {\n    this.skipWhitespaceAndComments();\n    let start = this.pos;\n    while (this.pos < this.src.length && /[a-zA-Z0-9_@\\-/.]/.test(this.src[this.pos])) this.pos++;\n    if (this.pos === start) throw new Error(`ACS parse error at pos ${this.pos}: expected identifier`);\n    return this.src.slice(start, this.pos);\n  }\n\n  private readNumber(): number {\n    this.skipWhitespaceAndComments();\n    let start = this.pos;\n    if (this.src[this.pos] === '-') this.pos++;\n    while (this.pos < this.src.length && /[0-9.]/.test(this.src[this.pos])) this.pos++;\n    return Number(this.src.slice(start, this.pos));\n  }\n\n  private readString(): string {\n    this.skipWhitespaceAndComments();\n    const quote = this.src[this.pos];\n    if (quote !== '\"' && quote !== \"'\") throw new Error(`ACS parse error at pos ${this.pos}: expected string`);\n    this.pos++;\n    let result = '';\n    while (this.pos < this.src.length && this.src[this.pos] !== quote) {\n      if (this.src[this.pos] === '\\\\') {\n        this.pos++;\n        const ch = this.src[this.pos];\n        if (ch === 'n') result += '\\n';\n        else if (ch === 't') result += '\\t';\n        else if (ch === 'r') result += '\\r';\n        else if (ch === '\\\\') result += '\\\\';\n        else if (ch === quote) result += quote;\n        else if (ch === '{') result += '\\\\{';\n        else result += ch;\n      } else {\n        result += this.src[this.pos];\n      }\n      this.pos++;\n    }\n    this.pos++;\n    return result;\n  }\n\n  private readUntil(end: string): string {\n    let result = '';\n    while (this.pos < this.src.length && !this.peek(end)) {\n      result += this.src[this.pos];\n      this.pos++;\n    }\n    return result;\n  }\n}\n\nexport class AcsCompiler {\n  compile(acsGraph: AcsGraph): Graph {\n    const graph: Graph = {\n      order: [],\n      nodes: {},\n    };\n\n    if (acsGraph.mode) graph.mode = acsGraph.mode;\n    if (acsGraph.meta) graph._meta = acsGraph.meta;\n    if (acsGraph.input && acsGraph.input.length > 0) {\n      graph.interface = {\n        input: acsGraph.input.map(i => ({ name: i.name, type: i.type })),\n        output: { type: acsGraph.output || 'void' },\n      };\n    }\n\n    this.compileNodes(acsGraph.nodes, graph);\n\n    return graph;\n  }\n\n  private compileNodes(acsNodes: AcsNode[], graph: Graph): void {\n    for (const node of acsNodes) {\n      switch (node.type) {\n        case 'let': {\n          const graphNode: GraphNode = { atom: node.atom!, ...node.params };\n          graph.order.push(node.id!);\n          graph.nodes[node.id!] = graphNode;\n          break;\n        }\n        case 'if': {\n          if (node.inlineCondAtom) {\n            const condNodeId = node.ref!;\n            const condGraphNode: GraphNode = { atom: node.inlineCondAtom.atom, ...node.inlineCondAtom.params };\n            graph.order.push(condNodeId);\n            graph.nodes[condNodeId] = condGraphNode;\n          }\n\n          let ifNodeId: string;\n          if (node.id) {\n            ifNodeId = node.id;\n          } else {\n            ifNodeId = `if_${node.ref}`;\n            if (graph.nodes[ifNodeId]) {\n              ifNodeId = `if_${node.ref}_${graph.order.length}`;\n            }\n          }\n          const thenGraph = this.compileSubGraph(node.body || []);\n          const elseGraph = node.elseBody ? this.compileSubGraph(node.elseBody) : undefined;\n\n          const graphNode: GraphNode = {\n            atom: 'branch',\n            cond: `{{${node.ref}}}`,\n          };\n          if (thenGraph.order.length > 0 || !elseGraph) graphNode.then = thenGraph;\n          if (elseGraph) graphNode.else = elseGraph;\n\n          graph.order.push(ifNodeId);\n          graph.nodes[ifNodeId] = graphNode;\n          break;\n        }\n        case 'loop': {\n          const loopNodeId = node.id || `loop_${graph.order.length}`;\n          const bodyGraph = this.compileSubGraph(node.body || []);\n\n          const graphNode: GraphNode = {\n            atom: 'loop',\n            nodes: bodyGraph,\n          };\n          if (node.maxIterations) graphNode.maxIterations = node.maxIterations;\n          if (node.condKey) graphNode.condKey = node.condKey;\n\n          graph.order.push(loopNodeId);\n          graph.nodes[loopNodeId] = graphNode;\n          break;\n        }\n        case 'forEach': {\n          const feNodeId = node.id || `forEach_${graph.order.length}`;\n          const bodyGraph = this.compileSubGraph(node.body || []);\n\n          const graphNode: GraphNode = {\n            atom: 'forEach',\n            array: `{{${node.arrayRef}}}`,\n            nodes: bodyGraph,\n            itemKey: node.itemKey,\n          };\n          if (node.indexKey) graphNode.indexKey = node.indexKey;\n          if (node.maxItems) graphNode.maxItems = node.maxItems;\n\n          graph.order.push(feNodeId);\n          graph.nodes[feNodeId] = graphNode;\n          break;\n        }\n        case 'filter': {\n          const fNodeId = node.id || `filter_${graph.order.length}`;\n          const bodyGraph = this.compileSubGraph(node.body || []);\n\n          const graphNode: GraphNode = {\n            atom: 'filter',\n            array: `{{${node.arrayRef}}}`,\n            nodes: bodyGraph,\n            itemKey: node.itemKey,\n          };\n          if (node.indexKey) graphNode.indexKey = node.indexKey;\n\n          graph.order.push(fNodeId);\n          graph.nodes[fNodeId] = graphNode;\n          break;\n        }\n      }\n    }\n  }\n\n  private compileSubGraph(acsNodes: AcsNode[]): Graph {\n    const graph: Graph = { order: [], nodes: {} };\n    this.compileNodes(acsNodes, graph);\n    return graph;\n  }\n}\n\nexport class AcsDecompiler {\n  decompile(graph: Graph, name: string = 'unnamed'): string {\n    const lines: string[] = [];\n    lines.push(`graph ${name} {`);\n\n    if (graph.mode) lines.push(`  mode: ${graph.mode}`);\n    if (graph._meta) {\n      const parts = Object.entries(graph._meta).map(([k, v]) => `${k}: \"${v}\"`).join(', ');\n      lines.push(`  meta: { ${parts} }`);\n    }\n    if (graph.interface) {\n      if (graph.interface.input.length === 0) {\n        lines.push(`  in: none`);\n      } else {\n        const inStr = graph.interface.input.map(i => `${i.name}: ${i.type}`).join(', ');\n        lines.push(`  in: ${inStr}`);\n      }\n      lines.push(`  out: ${graph.interface.output.type}`);\n    }\n\n    lines.push('');\n    for (const nodeId of graph.order) {\n      const node = graph.nodes[nodeId];\n      if (nodeId.startsWith('__inline_cond_') && node.atom !== 'branch') continue;\n      lines.push(...this.decompileNode(nodeId, node, 1, graph.nodes));\n    }\n\n    lines.push('}');\n    return lines.join('\\n');\n  }\n\n  private decompileNode(nodeId: string, node: GraphNode, indent: number, allNodes?: Record<string, GraphNode>): string[] {\n    const prefix = '  '.repeat(indent);\n    const lines: string[] = [];\n\n    if (node.atom === 'branch') {\n      const condRef = this.extractCondRef(node.cond);\n      const isNamedIf = nodeId && !nodeId.startsWith('if_');\n      const ifPrefix = isNamedIf ? `${prefix}let ${nodeId} = ` : '';\n\n      let condStr = condRef || nodeId;\n      if (condRef && condRef.startsWith('__inline_cond_') && allNodes && allNodes[condRef]) {\n        const condNode = allNodes[condRef];\n        const condParams = this.formatParams(condNode);\n        condStr = `${condNode.atom}(${condParams})`;\n        lines.push(`${ifPrefix}if ${condStr} {`);\n      } else {\n        lines.push(`${ifPrefix}if ${condStr} {`);\n      }\n      if (node.then) lines.push(...this.decompileSubGraph(node.then, indent + 1));\n      if (node.else) {\n        lines.push(`${prefix}} else {`);\n        lines.push(...this.decompileSubGraph(node.else, indent + 1));\n      }\n      lines.push(`${prefix}}`);\n    } else if (node.atom === 'loop') {\n      const isNamedLoop = nodeId && !nodeId.startsWith('loop_');\n      const loopPrefix = isNamedLoop ? `${prefix}let ${nodeId} = ` : '';\n      const extras: string[] = [];\n      if (node.maxIterations) extras.push(`max: ${node.maxIterations}`);\n      if (node.condKey) extras.push(`cond: \"${node.condKey}\"`);\n      lines.push(`${loopPrefix}loop ${extras.join(' ')} {`);\n      if (node.nodes) lines.push(...this.decompileSubGraph(node.nodes, indent + 1));\n      lines.push(`${prefix}}`);\n    } else if (node.atom === 'forEach') {\n      const isNamedForEach = nodeId && !nodeId.startsWith('forEach_');\n      const fePrefix = isNamedForEach ? `${prefix}let ${nodeId} = ` : '';\n      const extras: string[] = [];\n      if (node.maxItems) extras.push(`max: ${node.maxItems}`);\n      const idx = node.indexKey ? `, ${node.indexKey}` : '';\n      lines.push(`${fePrefix}forEach ${node.itemKey || 'item'}${idx} in ${this.extractArrayRef(node.array)} ${extras.join(' ')} {`);\n      if (node.nodes) lines.push(...this.decompileSubGraph(node.nodes, indent + 1));\n      lines.push(`${prefix}}`);\n    } else if (node.atom === 'filter') {\n      const isNamedFilter = nodeId && !nodeId.startsWith('filter_');\n      const fPrefix = isNamedFilter ? `${prefix}let ${nodeId} = ` : '';\n      const idx = node.indexKey ? ` index: ${node.indexKey}` : '';\n      lines.push(`${fPrefix}filter ${node.itemKey || 'item'}${idx} in ${this.extractArrayRef(node.array)} {`);\n      if (node.nodes) lines.push(...this.decompileSubGraph(node.nodes, indent + 1));\n      lines.push(`${prefix}}`);\n    } else {\n      const params = this.formatParams(node);\n      lines.push(`${prefix}let ${nodeId} = ${node.atom}(${params})`);\n    }\n\n    return lines;\n  }\n\n  private decompileSubGraph(graph: Graph, indent: number): string[] {\n    const lines: string[] = [];\n    for (const nodeId of graph.order) {\n      if (nodeId.startsWith('__inline_cond_') && graph.nodes[nodeId].atom !== 'branch') continue;\n      lines.push(...this.decompileNode(nodeId, graph.nodes[nodeId], indent, graph.nodes));\n    }\n    return lines;\n  }\n\n  private formatParams(node: GraphNode): string {\n    const SKIP = new Set(['atom', 'nodes', 'then', 'else', 'cond', 'maxIterations', 'itemKey', 'maxItems']);\n    if (node.atom === 'forEach' || node.atom === 'filter') SKIP.add('array');\n    const parts: string[] = [];\n    for (const [key, value] of Object.entries(node)) {\n      if (SKIP.has(key)) continue;\n      parts.push(`${key}: ${this.formatValue(value)}`);\n    }\n    return parts.join(', ');\n  }\n\n  private formatValue(value: any): string {\n    if (typeof value === 'string') {\n      const escaped = value.replace(/\\\\/g, '\\\\\\\\').replace(/\"/g, '\\\\\"').replace(/\\n/g, '\\\\n').replace(/\\r/g, '\\\\r').replace(/\\t/g, '\\\\t');\n      return `\"${escaped}\"`;\n    }\n    if (typeof value === 'number' || typeof value === 'boolean') return String(value);\n    if (value === null) return 'null';\n    if (Array.isArray(value)) return `[${value.map(v => this.formatValue(v)).join(', ')}]`;\n    if (typeof value === 'object') {\n      const parts = Object.entries(value).map(([k, v]) => {\n        const keyStr = /^[a-zA-Z_]\\w*$/.test(k) ? k : `\"${k}\"`;\n        return `${keyStr}: ${this.formatValue(v)}`;\n      });\n      return `{ ${parts.join(', ')} }`;\n    }\n    return String(value);\n  }\n\n  private extractArrayRef(array: any): string {\n    if (typeof array === 'string' && array.startsWith('{{')) {\n      const match = array.match(/^\\{\\{(\\w+)\\}\\}$/);\n      return match ? match[1] : array;\n    }\n    return String(array);\n  }\n\n  private extractCondRef(cond: any): string {\n    if (typeof cond === 'string' && cond.startsWith('{{')) {\n      const match = cond.match(/^\\{\\{(\\w+)(?:\\.(.+?))?\\}\\}$/);\n      return match ? (match[2] ? `${match[1]}.${match[2]}` : match[1]) : String(cond);\n    }\n    return String(cond);\n  }\n}\n\nexport function compileAcs(text: string): Graph {\n  const parser = new AcsParser();\n  const ast = parser.parse(text);\n  const compiler = new AcsCompiler();\n  return compiler.compile(ast);\n}\n\nexport function decompileAcs(graph: Graph, name?: string): string {\n  const decompiler = new AcsDecompiler();\n  return decompiler.decompile(graph, name);\n}\n"]}