@ldclabs/kip-lang 0.4.0 → 2.0.1

package/dist/formatter.js

@@ -38,7 +38,6 @@ class Formatter {
             this.commentIdx++;
         }
     }
-    /** Emit all remaining comments */
     emitRemainingComments() {
         while (this.commentIdx < this.comments.length) {
             this.writeIndent();
@@ -69,650 +68,1045 @@ class Formatter {
             // Separate statements with exactly one blank line.
             if (i > 0)
                 this.newline();
-            // Emit comments that appear before this statement
             this.emitCommentsBefore(stmt.range.start.line);
             this.formatStatement(stmt);
         }
-        // Trailing comments after last statement
         this.emitRemainingComments();
         return this.output.trimEnd() + '\n';
     }
     // ────────────────────────────────────────────────────────────────────
-    //  Statements
+    //  Statement dispatch
     // ────────────────────────────────────────────────────────────────────
     formatStatement(stmt) {
         switch (stmt.kind) {
             case 'FindStatement':
-                return this.formatFind(stmt);
-            case 'UpsertStatement':
-                return this.formatUpsert(stmt);
-            case 'UpdateStatement':
-                return this.formatUpdate(stmt);
-            case 'MergeStatement':
-                return this.formatMerge(stmt);
-            case 'DeleteStatement':
-                return this.formatDelete(stmt);
+                this.formatFind(stmt);
+                break;
+            case 'MutateStatement':
+                this.formatMutate(stmt);
+                break;
             case 'DescribeStatement':
-                return this.formatDescribe(stmt);
+                this.formatDescribe(stmt);
+                break;
+            case 'ListStatement':
+                this.formatList(stmt);
+                break;
             case 'SearchStatement':
-                return this.formatSearch(stmt);
-            case 'ExportStatement':
-                return this.formatExport(stmt);
+                this.formatSearch(stmt);
+                break;
+            case 'VerifyStatement':
+                this.formatVerify(stmt);
+                break;
+            case 'ValidateStatement':
+                this.formatValidate(stmt);
+                break;
+            case 'PreviewStatement':
+                this.formatPreview(stmt);
+                break;
+            case 'HistoryStatement':
+                this.formatHistory(stmt);
+                break;
+            case 'ChangesStatement':
+                this.formatChanges(stmt);
+                break;
+            case 'SnapshotStatement':
+                this.formatSnapshot(stmt);
+                break;
+            case 'ExportCapsuleStatement':
+                this.formatExport(stmt);
+                break;
+            default:
+                this.formatMutationClause(stmt);
+        }
+    }
+    formatMutationClause(stmt) {
+        switch (stmt.kind) {
+            case 'CreateConceptStatement':
+                this.formatCreateConcept(stmt);
+                break;
+            case 'UpsertConceptStatement':
+                this.formatUpsertConcept(stmt);
+                break;
+            case 'EnsurePropositionStatement':
+                this.formatEnsureProposition(stmt);
+                break;
+            case 'AssertStatement':
+                this.formatAssert(stmt);
+                break;
+            case 'CreateEvidenceStatement':
+                this.formatRecordCreate('EVIDENCE', stmt);
+                break;
+            case 'CreateAssertionStatement':
+                this.formatRecordCreate('ASSERTION', stmt);
+                break;
+            case 'CreateActivityStatement':
+                this.formatRecordCreate('ACTIVITY', stmt);
+                break;
+            case 'UpdateStatement':
+                this.formatUpdate(stmt);
+                break;
+            case 'RetractAssertionStatement':
+                this.formatRetract(stmt);
+                break;
+            case 'SupersedeAssertionStatement':
+                this.formatSupersede(stmt);
+                break;
+            case 'CorrectEvidenceStatement':
+                this.formatCorrect(stmt);
+                break;
+            case 'TransitionActivityStatement':
+                this.formatTransition(stmt);
+                break;
+            case 'SetRetentionStatement':
+                this.formatSetRetention(stmt);
+                break;
+            case 'ArchiveStatement':
+                this.formatRemoval('ARCHIVE', stmt);
+                break;
+            case 'TombstoneStatement':
+                this.formatRemoval('TOMBSTONE', stmt);
+                break;
+            case 'PurgeStatement':
+                this.formatPurge(stmt);
+                break;
+            case 'MergeConceptStatement':
+                this.formatMerge(stmt);
+                break;
         }
     }
-    // ── FIND ───────────────────────────────────────────────────────────
+    // ────────────────────────────────────────────────────────────────────
+    //  KQL
+    // ────────────────────────────────────────────────────────────────────
     formatFind(stmt) {
         this.writeIndent();
         this.write('FIND(');
-        if (stmt.projections.length <= 2 &&
-            this.allSimpleExpressions(stmt.projections)) {
-            // Inline
-            this.write(stmt.projections.map((p) => this.exprToString(p, 0)).join(', '));
-        }
-        else {
+        this.write(stmt.projections.map((p) => this.expr(p)).join(', '));
+        this.write(')');
+        this.newline();
+        this.formatWhere(stmt.where, 'WHERE');
+        if (stmt.asOf) {
+            this.writeIndent();
+            this.write(this.asOfToString(stmt.asOf));
             this.newline();
-            this.indentLevel++;
-            for (let i = 0; i < stmt.projections.length; i++) {
-                this.writeIndent();
-                this.write(this.exprToString(stmt.projections[i], 0));
-                if (i < stmt.projections.length - 1) {
-                    this.write(',');
-                }
-                this.newline();
-            }
-            this.indentLevel--;
+        }
+        if (stmt.forTime) {
             this.writeIndent();
+            this.write(`FOR TIME ${this.scalar(stmt.forTime.value)}`);
+            this.newline();
         }
-        this.write(')');
-        this.newline();
-        if (stmt.where) {
-            this.formatWhere(stmt.where);
+        if (stmt.epistemic) {
+            this.writeIndent();
+            this.write('WITH EPISTEMIC ');
+            this.formatObjectBlock(stmt.epistemic.options, false);
+            this.newline();
         }
-        if (stmt.orderBy) {
+        if (stmt.orderBy)
             this.formatOrderBy(stmt.orderBy);
-        }
-        if (stmt.limit) {
+        if (stmt.limit)
             this.formatLimit(stmt.limit);
-        }
-        if (stmt.cursor) {
+        if (stmt.cursor)
             this.formatCursor(stmt.cursor);
-        }
     }
-    // ── UPSERT ─────────────────────────────────────────────────────────
-    formatUpsert(stmt) {
+    formatOrderBy(clause) {
         this.writeIndent();
-        this.write('UPSERT {');
+        this.write('ORDER BY ');
+        this.write(clause.items
+            .map((item) => {
+            const expr = this.expr(item.expression);
+            return item.direction ? `${expr} ${item.direction}` : expr;
+        })
+            .join(', '));
         this.newline();
-        this.indentLevel++;
-        for (let i = 0; i < stmt.blocks.length; i++) {
-            const block = stmt.blocks[i];
-            if (i > 0)
-                this.newline();
-            // Emit comments between blocks
-            this.emitCommentsBefore(block.range.start.line);
-            this.formatUpsertBlock(block);
-        }
-        this.indentLevel--;
+    }
+    formatLimit(clause) {
         this.writeIndent();
-        this.write('}');
+        this.write(`LIMIT ${this.scalar(clause.value)}`);
         this.newline();
-        if (stmt.metadata) {
-            this.formatWithMetadata(stmt.metadata);
-        }
-    }
-    formatUpsertBlock(block) {
-        if (block.kind === 'ConceptBlock') {
-            this.formatConceptBlock(block);
-        }
-        else {
-            this.formatPropositionBlockDef(block);
-        }
     }
-    formatConceptBlock(block) {
+    formatCursor(clause) {
         this.writeIndent();
-        this.write(block.handle ? `CONCEPT ${block.handle} {` : 'CONCEPT {');
+        this.write(`CURSOR ${this.scalar(clause.value)}`);
         this.newline();
-        this.indentLevel++;
-        // Matcher: {type: "...", name: "..."}
-        this.emitCommentsBefore(block.matcher.range.start.line);
+    }
+    asOfToString(clause) {
+        return `AS OF ${clause.basis} ${this.scalar(clause.value)}`;
+    }
+    // ────────────────────────────────────────────────────────────────────
+    //  WHERE
+    // ────────────────────────────────────────────────────────────────────
+    formatWhere(clause, keyword) {
         this.writeIndent();
-        this.write('{');
-        this.write(block.matcher.entries
-            .map((e) => `${this.keyToString(e)}: ${this.exprToString(e.value, 0)}`)
-            .join(', '));
-        this.write('}');
+        this.write(`${keyword} {`);
         this.newline();
-        if (block.expectVersion) {
-            this.emitCommentsBefore(block.expectVersion.range.start.line);
-            this.formatExpectVersion(block.expectVersion);
-        }
-        if (block.setAttributes) {
-            this.emitCommentsBefore(block.setAttributes.range.start.line);
-            this.formatSetAttributes(block.setAttributes);
-        }
-        if (block.setPropositions) {
-            this.emitCommentsBefore(block.setPropositions.range.start.line);
-            this.formatSetPropositions(block.setPropositions);
+        this.indentLevel++;
+        for (const pattern of clause.patterns) {
+            this.emitCommentsBefore(pattern.range.start.line);
+            this.formatWherePattern(pattern);
         }
+        this.emitCommentsBefore(clause.range.end.line);
         this.indentLevel--;
         this.writeIndent();
         this.write('}');
         this.newline();
-        if (block.metadata) {
-            this.formatWithMetadata(block.metadata);
-        }
     }
-    formatPropositionBlockDef(block) {
+    formatNestedBlock(keyword, patterns, endLine) {
         this.writeIndent();
-        this.write('PROPOSITION');
-        if (block.handle)
-            this.write(` ${block.handle}`);
-        this.write(' {');
+        this.write(`${keyword} {`);
         this.newline();
         this.indentLevel++;
-        this.writeIndent();
-        this.write(this.propositionBlockPatternToString(block));
-        this.newline();
-        if (block.expectVersion) {
-            this.emitCommentsBefore(block.expectVersion.range.start.line);
-            this.formatExpectVersion(block.expectVersion);
-        }
-        if (block.setAttributes) {
-            this.emitCommentsBefore(block.setAttributes.range.start.line);
-            this.formatSetAttributes(block.setAttributes);
+        for (const pattern of patterns) {
+            this.emitCommentsBefore(pattern.range.start.line);
+            this.formatWherePattern(pattern);
         }
+        this.emitCommentsBefore(endLine);
         this.indentLevel--;
         this.writeIndent();
         this.write('}');
         this.newline();
-        if (block.metadata) {
-            this.formatWithMetadata(block.metadata);
-        }
     }
-    formatSetAttributes(sa) {
-        this.formatEntryBlock('SET ATTRIBUTES', sa.entries, sa.range, {
-            inlineMax: 3,
-            sort: this.opts.sortAttributes
-        });
-    }
-    formatSetMetadata(sm) {
-        this.formatEntryBlock('SET METADATA', sm.entries, sm.range, {
-            inlineMax: 3,
-            sort: false
-        });
+    formatWherePattern(pattern) {
+        switch (pattern.kind) {
+            case 'ConceptPattern':
+                this.writeIndent();
+                this.write(pattern.variable.name);
+                if (pattern.explicit)
+                    this.write(' CONCEPT');
+                this.write(' ');
+                this.write(this.objectPatternToString(pattern.matcher));
+                this.newline();
+                break;
+            case 'PropositionPattern':
+                this.writeIndent();
+                if (pattern.variable)
+                    this.write(`${pattern.variable.name} `);
+                if (pattern.explicit)
+                    this.write('PROPOSITION ');
+                this.write(this.tupleToString(pattern.tuple));
+                this.newline();
+                break;
+            case 'AssertionPattern':
+            case 'EvidencePattern':
+            case 'ActivityPattern': {
+                const keyword = {
+                    AssertionPattern: 'ASSERTION',
+                    EvidencePattern: 'EVIDENCE',
+                    ActivityPattern: 'ACTIVITY'
+                }[pattern.kind];
+                this.writeIndent();
+                this.write(`${pattern.variable.name} ${keyword} `);
+                this.write(this.objectPatternToString(pattern.matcher));
+                this.newline();
+                break;
+            }
+            case 'StructuralPattern':
+                this.writeIndent();
+                if (pattern.variable)
+                    this.write(`${pattern.variable.name} `);
+                this.write(`STRUCTURAL (${this.term(pattern.subject)}, ${this.symbol(pattern.field)}, ${this.term(pattern.object)})`);
+                this.newline();
+                break;
+            case 'BeliefPattern':
+                this.writeIndent();
+                this.write(`${pattern.variable.name} BELIEF (`);
+                if (pattern.proposition) {
+                    this.write(pattern.proposition.name);
+                }
+                else if (pattern.propositionId) {
+                    this.write(`id: ${this.scalar(pattern.propositionId)}`);
+                }
+                else {
+                    this.write(`${this.term(pattern.subject)}, ${this.predAtom(pattern.predicate)}, ${this.term(pattern.object)}`);
+                }
+                this.write(')');
+                this.newline();
+                break;
+            case 'BeliefSlotPattern':
+                this.writeIndent();
+                this.write(`${pattern.variable.name} BELIEF SLOT (${this.term(pattern.subject)}, ${this.predAtom(pattern.predicate)})`);
+                this.newline();
+                break;
+            case 'FilterClause':
+                this.writeIndent();
+                this.write(`FILTER(${this.expr(pattern.expression)})`);
+                this.newline();
+                break;
+            case 'NotClause':
+                this.formatNestedBlock('NOT', pattern.patterns, pattern.range.end.line);
+                break;
+            case 'OptionalClause':
+                this.formatNestedBlock('OPTIONAL', pattern.patterns, pattern.range.end.line);
+                break;
+            case 'UnionClause':
+                this.formatNestedBlock('UNION', pattern.patterns, pattern.range.end.line);
+                break;
+        }
     }
-    /**
-     * Render a `HEADER { ... }` key/value block. Collapses to a single line when
-     * all values are primitive, there are few of them, and no comment sits inside
-     * the block; otherwise emits one entry per line, preserving interior comments
-     * at their source position. Sorting is skipped whenever interior comments are
-     * present, since reordering would detach comments from their keys.
-     */
-    formatEntryBlock(header, entries, range, opts) {
+    // ────────────────────────────────────────────────────────────────────
+    //  KML
+    // ────────────────────────────────────────────────────────────────────
+    formatMutate(stmt) {
         this.writeIndent();
-        this.write(`${header} {`);
-        if (entries.length === 0) {
-            this.write('}');
-            this.newline();
-            return;
-        }
-        const hasComments = this.hasPendingCommentInRange(range.start.line, range.end.line);
-        const ordered = opts.sort && !hasComments ? this.sortObjectEntries(entries) : entries;
-        const allSimple = ordered.every((e) => this.isSimpleValue(e.value));
-        if (allSimple && ordered.length <= opts.inlineMax && !hasComments) {
-            this.write(' ');
-            this.write(ordered
-                .map((e) => `${this.keyToString(e)}: ${this.exprToString(e.value, 0)}`)
-                .join(', '));
-            this.write(' }');
-            this.newline();
-            return;
-        }
+        this.write('MUTATE {');
         this.newline();
         this.indentLevel++;
-        for (let i = 0; i < ordered.length; i++) {
-            this.emitCommentsBefore(ordered[i].range.start.line);
-            this.formatObjectEntry(ordered[i]);
-            if (i < ordered.length - 1) {
-                this.write(',');
-            }
-            this.newline();
+        for (let i = 0; i < stmt.clauses.length; i++) {
+            const clause = stmt.clauses[i];
+            if (i > 0)
+                this.newline();
+            this.emitCommentsBefore(clause.range.start.line);
+            this.formatMutationClause(clause);
         }
-        this.emitCommentsBefore(range.end.line);
+        this.emitCommentsBefore(stmt.range.end.line);
         this.indentLevel--;
         this.writeIndent();
         this.write('}');
         this.newline();
     }
-    formatExpectVersion(ev) {
-        this.writeIndent();
-        this.write(`EXPECT VERSION ${this.numberOrParameterValueToString(ev.value)}`);
-        this.newline();
-    }
-    formatSetPropositions(sp) {
+    /**
+     * A body clause together with the printer for it. Bodies (CREATE / UPSERT
+     * CONCEPT, CREATE EVIDENCE|ASSERTION|ACTIVITY) hold their clauses in typed
+     * slots, so the source order has to be recovered from the ranges before
+     * printing — a comment written above a clause must come out above that
+     * same clause, and the comment cursor only moves forward.
+     */
+    formatBody(header, endLine, clauses) {
         this.writeIndent();
-        this.write('SET PROPOSITIONS {');
+        this.write(`${header} {`);
         this.newline();
         this.indentLevel++;
-        for (const item of sp.items) {
-            this.emitCommentsBefore(item.range.start.line);
-            this.formatPropositionItem(item);
+        const ordered = [...clauses].sort((a, b) => a.node.range.start.line - b.node.range.start.line ||
+            a.node.range.start.column - b.node.range.start.column);
+        for (const clause of ordered) {
+            this.emitCommentsBefore(clause.node.range.start.line);
+            clause.print();
         }
-        this.emitCommentsBefore(sp.range.end.line);
+        // Comments after the last clause still belong inside the braces.
+        this.emitCommentsBefore(endLine);
         this.indentLevel--;
         this.writeIndent();
         this.write('}');
         this.newline();
     }
-    formatPropositionItem(item) {
-        this.writeIndent();
-        this.write(`("${this.escapeString(item.predicate)}", ${this.endpointToString(item.target)})`);
-        if (item.metadata) {
-            this.write(' ');
-            this.write('WITH METADATA { ');
-            this.write(item.metadata.entries
-                .map((e) => `${this.keyToString(e)}: ${this.exprToString(e.value, 0)}`)
-                .join(', '));
-            this.write(' }');
+    formatCreateConcept(stmt) {
+        const clauses = [];
+        if (stmt.type) {
+            const node = stmt.type;
+            clauses.push({
+                node,
+                print: () => {
+                    this.writeIndent();
+                    this.write(`TYPE ${this.symbol(node.value)}`);
+                    this.newline();
+                }
+            });
         }
-        this.newline();
+        if (stmt.clientKey) {
+            const node = stmt.clientKey;
+            clauses.push({
+                node,
+                print: () => {
+                    this.writeIndent();
+                    this.write(`CLIENT KEY ${this.scalar(node.value)}`);
+                    this.newline();
+                }
+            });
+        }
+        if (stmt.name) {
+            const node = stmt.name;
+            clauses.push({
+                node,
+                print: () => {
+                    this.writeIndent();
+                    this.write(`NAME ${this.scalar(node.value)}`);
+                    this.newline();
+                }
+            });
+        }
+        if (stmt.setFields) {
+            const node = stmt.setFields;
+            clauses.push({
+                node,
+                print: () => this.formatAssignmentClause('SET FIELDS', node.assignments, false)
+            });
+        }
+        if (stmt.setAttributes) {
+            const node = stmt.setAttributes;
+            clauses.push({
+                node,
+                print: () => this.formatAssignmentClause('SET ATTRIBUTES', node.assignments, this.opts.sortAttributes)
+            });
+        }
+        for (const facet of stmt.setFacets) {
+            clauses.push({ node: facet, print: () => this.formatFacet(facet) });
+        }
+        if (stmt.setStructural) {
+            const node = stmt.setStructural;
+            clauses.push({ node, print: () => this.formatStructural(node) });
+        }
+        this.formatBody(`CREATE CONCEPT ${stmt.handle.name}`, stmt.range.end.line, clauses);
+    }
+    formatUpsertConcept(stmt) {
+        const clauses = [];
+        if (stmt.match) {
+            const node = stmt.match;
+            clauses.push({
+                node,
+                print: () => {
+                    this.writeIndent();
+                    this.write('MATCH ');
+                    this.write(this.objectPatternToString(node.pattern));
+                    this.newline();
+                }
+            });
+        }
+        if (stmt.expectVersion) {
+            const node = stmt.expectVersion;
+            clauses.push({
+                node,
+                print: () => {
+                    this.writeIndent();
+                    this.write(`EXPECT VERSION ${this.scalar(node.value)}`);
+                    this.newline();
+                }
+            });
+        }
+        if (stmt.setFields) {
+            const node = stmt.setFields;
+            clauses.push({
+                node,
+                print: () => this.formatAssignmentClause('SET FIELDS', node.assignments, false)
+            });
+        }
+        if (stmt.setAttributes) {
+            const node = stmt.setAttributes;
+            clauses.push({
+                node,
+                print: () => this.formatAssignmentClause('SET ATTRIBUTES', node.assignments, this.opts.sortAttributes)
+            });
+        }
+        for (const facet of stmt.setFacets) {
+            clauses.push({ node: facet, print: () => this.formatFacet(facet) });
+        }
+        if (stmt.unsetAttributes) {
+            const node = stmt.unsetAttributes;
+            clauses.push({ node, print: () => this.formatUnsetAttributes(node) });
+        }
+        for (const facet of stmt.unsetFacets) {
+            clauses.push({ node: facet, print: () => this.formatUnsetFacet(facet) });
+        }
+        if (stmt.setStructural) {
+            const node = stmt.setStructural;
+            clauses.push({ node, print: () => this.formatStructural(node) });
+        }
+        if (stmt.unsetStructural) {
+            const node = stmt.unsetStructural;
+            clauses.push({ node, print: () => this.formatUnsetStructural(node) });
+        }
+        this.formatBody(`UPSERT CONCEPT ${stmt.handle.name}`, stmt.range.end.line, clauses);
     }
-    formatWithMetadata(wm) {
+    formatRecordCreate(keyword, stmt) {
+        const clauses = [];
+        if (stmt.clientKey) {
+            const node = stmt.clientKey;
+            clauses.push({
+                node,
+                print: () => {
+                    this.writeIndent();
+                    this.write(`CLIENT KEY ${this.scalar(node.value)}`);
+                    this.newline();
+                }
+            });
+        }
+        if (stmt.setFields) {
+            const node = stmt.setFields;
+            clauses.push({
+                node,
+                print: () => this.formatAssignmentClause('SET FIELDS', node.assignments, false)
+            });
+        }
+        for (const facet of stmt.setFacets) {
+            clauses.push({ node: facet, print: () => this.formatFacet(facet) });
+        }
+        if (stmt.setStructural) {
+            const node = stmt.setStructural;
+            clauses.push({ node, print: () => this.formatStructural(node) });
+        }
+        this.formatBody(`CREATE ${keyword} ${stmt.handle.name}`, stmt.range.end.line, clauses);
+    }
+    formatEnsureProposition(stmt) {
         this.writeIndent();
-        this.write('WITH METADATA {');
-        if (wm.entries.length === 0) {
-            this.write('}');
-            this.newline();
-            return;
+        this.write('ENSURE PROPOSITION ');
+        if (stmt.handle)
+            this.write(`${stmt.handle.name} `);
+        this.write(this.tupleToString(stmt.tuple));
+        if (stmt.expectVersion) {
+            this.write(` EXPECT VERSION ${this.scalar(stmt.expectVersion.value)}`);
         }
-        // Metadata blocks are conventionally one entry per line.
         this.newline();
-        this.indentLevel++;
-        for (let i = 0; i < wm.entries.length; i++) {
-            this.emitCommentsBefore(wm.entries[i].range.start.line);
-            this.formatObjectEntry(wm.entries[i]);
-            if (i < wm.entries.length - 1) {
-                this.write(',');
-            }
+    }
+    formatAssert(stmt) {
+        this.writeIndent();
+        this.write('ASSERT ');
+        if (stmt.handle)
+            this.write(`${stmt.handle.name} `);
+        this.write(this.tupleToString(stmt.tuple));
+        this.write(' ');
+        this.formatObjectBlock(stmt.assignments, false);
+        if (stmt.superseding) {
             this.newline();
+            this.indentLevel++;
+            this.writeIndent();
+            this.write(`SUPERSEDING ${this.targetRef(stmt.superseding)}`);
+            this.indentLevel--;
         }
-        this.emitCommentsBefore(wm.range.end.line);
-        this.indentLevel--;
-        this.writeIndent();
-        this.write('}');
         this.newline();
     }
-    // ── UPDATE ─────────────────────────────────────────────────────────
     formatUpdate(stmt) {
         this.writeIndent();
-        this.write(`UPDATE ${stmt.target}`);
+        this.write(`UPDATE ${this.targetRef(stmt.target)}`);
         this.newline();
-        if (stmt.setAttributes) {
-            this.formatSetAttributes(stmt.setAttributes);
+        if (stmt.expectVersion) {
+            this.emitCommentsBefore(stmt.expectVersion.range.start.line);
+            this.writeIndent();
+            this.write(`EXPECT VERSION ${this.scalar(stmt.expectVersion.value)}`);
+            this.newline();
+        }
+        for (const action of stmt.actions) {
+            this.emitCommentsBefore(action.range.start.line);
+            this.formatUpdateAction(action);
         }
-        if (stmt.setMetadata) {
-            this.formatSetMetadata(stmt.setMetadata);
+        if (stmt.where) {
+            this.emitCommentsBefore(stmt.where.range.start.line);
+            this.formatWhere(stmt.where, 'WHERE');
         }
-        this.formatWhere(stmt.where);
         if (stmt.limit) {
+            this.emitCommentsBefore(stmt.limit.range.start.line);
             this.formatLimit(stmt.limit);
         }
     }
-    // ── MERGE ──────────────────────────────────────────────────────────
-    formatMerge(stmt) {
-        this.writeIndent();
-        this.write(`MERGE CONCEPT ${stmt.source} INTO ${stmt.target}`);
-        this.newline();
-        this.formatWhere(stmt.where);
-    }
-    // ── DELETE ─────────────────────────────────────────────────────────
-    formatDelete(stmt) {
-        this.writeIndent();
-        if (stmt.deleteType === 'ATTRIBUTES' || stmt.deleteType === 'METADATA') {
-            this.write(`DELETE ${stmt.deleteType} {`);
-            if (stmt.keys) {
-                this.write(stmt.keys.map((k) => `"${this.escapeString(k)}"`).join(', '));
-            }
-            this.write(`} FROM ${stmt.target}`);
-        }
-        else if (stmt.deleteType === 'PROPOSITIONS') {
-            this.write(`DELETE PROPOSITIONS ${stmt.target}`);
-        }
-        else {
-            this.write(`DELETE CONCEPT ${stmt.target} DETACH`);
-        }
-        this.newline();
-        this.formatWhere(stmt.where);
-    }
-    // ── DESCRIBE ───────────────────────────────────────────────────────
-    formatDescribe(stmt) {
-        this.writeIndent();
-        switch (stmt.describeType) {
-            case 'PRIMER':
-                this.write('DESCRIBE PRIMER');
+    formatUpdateAction(action) {
+        switch (action.kind) {
+            case 'SetFieldsClause':
+                this.formatAssignmentClause('SET FIELDS', action.assignments, false);
+                break;
+            case 'SetAttributesClause':
+                this.formatAssignmentClause('SET ATTRIBUTES', action.assignments, this.opts.sortAttributes);
                 break;
-            case 'DOMAINS':
-                this.write('DESCRIBE DOMAINS');
+            case 'SetFacetClause':
+                this.formatFacet(action);
                 break;
-            case 'CONCEPT_TYPES':
-                this.write('DESCRIBE CONCEPT TYPES');
+            case 'UnsetAttributesClause':
+                this.formatUnsetAttributes(action);
                 break;
-            case 'CONCEPT_TYPE':
-                this.write(`DESCRIBE CONCEPT TYPE ${this.quotedOrParameterValueToString(stmt.typeNameValue, stmt.typeName ?? '')}`);
+            case 'UnsetFacetClause':
+                this.formatUnsetFacet(action);
                 break;
-            case 'PROPOSITION_TYPES':
-                this.write('DESCRIBE PROPOSITION TYPES');
+            case 'SetStructuralClause':
+                this.formatStructural(action);
                 break;
-            case 'PROPOSITION_TYPE':
-                this.write(`DESCRIBE PROPOSITION TYPE ${this.quotedOrParameterValueToString(stmt.typeNameValue, stmt.typeName ?? '')}`);
+            case 'UnsetStructuralClause':
+                this.formatUnsetStructural(action);
                 break;
         }
-        if (stmt.limit) {
-            this.write(` LIMIT ${this.limitValueToString(stmt.limit)}`);
+    }
+    formatRetract(stmt) {
+        this.writeIndent();
+        this.write(`RETRACT ASSERTION ${this.targetRef(stmt.target)}`);
+        if (!stmt.where && !stmt.limit && stmt.expectState) {
+            this.write(` EXPECT STATE ${this.scalar(stmt.expectState.value)}`);
+            this.newline();
+            return;
         }
-        if (stmt.cursor) {
-            this.write(` CURSOR ${this.cursorValueToString(stmt.cursor)}`);
+        this.newline();
+        if (stmt.where)
+            this.formatWhere(stmt.where, 'WHERE');
+        if (stmt.limit)
+            this.formatLimit(stmt.limit);
+        if (stmt.expectState) {
+            this.writeIndent();
+            this.write(`EXPECT STATE ${this.scalar(stmt.expectState.value)}`);
+            this.newline();
         }
     }
-    // ── SEARCH ─────────────────────────────────────────────────────────
-    formatSearch(stmt) {
+    formatSupersede(stmt) {
         this.writeIndent();
-        this.write(`SEARCH ${stmt.searchTarget} ${this.quotedOrParameterValueToString(stmt.termValue, stmt.term)}`);
-        if (stmt.withTypeValue || stmt.withType !== undefined) {
-            this.write(` WITH TYPE ${this.quotedOrParameterValueToString(stmt.withTypeValue, stmt.withType ?? '')}`);
+        this.write(`SUPERSEDE ASSERTION ${this.targetRef(stmt.target)} BY ${this.targetRef(stmt.by)}`);
+        if (stmt.expectState) {
+            this.write(` EXPECT STATE ${this.scalar(stmt.expectState.value)}`);
         }
-        if (stmt.modeValue || stmt.mode !== undefined) {
-            this.write(` MODE ${this.quotedOrParameterValueToString(stmt.modeValue, stmt.mode ?? '')}`);
+        this.newline();
+    }
+    formatCorrect(stmt) {
+        this.writeIndent();
+        this.write(`CORRECT EVIDENCE ${this.targetRef(stmt.target)} BY ${this.targetRef(stmt.by)}`);
+        if (stmt.expectState) {
+            this.write(` EXPECT STATE ${this.scalar(stmt.expectState.value)}`);
         }
-        if (stmt.threshold) {
-            this.write(` THRESHOLD ${this.thresholdValueToString(stmt.threshold)}`);
+        this.newline();
+    }
+    formatTransition(stmt) {
+        this.writeIndent();
+        this.write(`TRANSITION ACTIVITY ${this.targetRef(stmt.target)} TO ${this.scalar(stmt.to)}`);
+        this.newline();
+        if (stmt.finalize.length > 0) {
+            this.indentLevel++;
+            for (const clause of stmt.finalize) {
+                this.emitCommentsBefore(clause.range.start.line);
+                if (clause.kind === 'SetFieldsClause') {
+                    this.formatAssignmentClause('SET FIELDS', clause.assignments, false);
+                }
+                else {
+                    this.formatStructural(clause);
+                }
+            }
+            this.indentLevel--;
         }
-        if (stmt.limit) {
-            this.write(` LIMIT ${this.limitValueToString(stmt.limit)}`);
+        if (stmt.expectState) {
+            this.indentLevel++;
+            this.emitCommentsBefore(stmt.expectState.range.start.line);
+            this.writeIndent();
+            this.write(`EXPECT STATE ${this.scalar(stmt.expectState.value)}`);
+            this.newline();
+            this.indentLevel--;
         }
     }
-    // ── EXPORT ─────────────────────────────────────────────────────────
-    formatExport(stmt) {
+    formatSetRetention(stmt) {
         this.writeIndent();
-        this.write(`EXPORT ${stmt.target}`);
+        this.write(`SET RETENTION ${this.targetRef(stmt.target)} `);
+        this.formatObjectBlock(stmt.assignments, false);
         this.newline();
-        this.formatWhere(stmt.where);
-        if (stmt.limit) {
+        if (stmt.where)
+            this.formatWhere(stmt.where, 'WHERE');
+        if (stmt.limit)
             this.formatLimit(stmt.limit);
+        if (stmt.expectVersion) {
+            this.writeIndent();
+            this.write(`EXPECT VERSION ${this.scalar(stmt.expectVersion.value)}`);
+            this.newline();
         }
     }
-    // ── WHERE ──────────────────────────────────────────────────────────
-    formatWhere(where) {
+    formatRemoval(keyword, stmt) {
         this.writeIndent();
-        this.write('WHERE {');
+        this.write(`${keyword} ${this.targetRef(stmt.target)}`);
+        if (!stmt.where && !stmt.limit) {
+            if (stmt.expectState) {
+                this.write(` EXPECT STATE ${this.scalar(stmt.expectState.value)}`);
+            }
+            this.newline();
+            return;
+        }
         this.newline();
+        if (stmt.where)
+            this.formatWhere(stmt.where, 'WHERE');
+        if (stmt.limit)
+            this.formatLimit(stmt.limit);
+        if (stmt.expectState) {
+            this.writeIndent();
+            this.write(`EXPECT STATE ${this.scalar(stmt.expectState.value)}`);
+            this.newline();
+        }
+    }
+    formatPurge(stmt) {
+        this.writeIndent();
+        this.write(`PURGE ${this.targetRef(stmt.target)}`);
+        this.newline();
+        if (stmt.where)
+            this.formatWhere(stmt.where, 'WHERE');
+        if (stmt.limit)
+            this.formatLimit(stmt.limit);
         this.indentLevel++;
-        for (const p of where.patterns) {
-            this.formatWherePattern(p);
+        if (stmt.referencePolicy) {
+            this.writeIndent();
+            this.write(`REFERENCE POLICY ${this.scalar(stmt.referencePolicy)}`);
+            this.newline();
         }
-        this.emitCommentsBefore(where.range.end.line);
-        this.indentLevel--;
         this.writeIndent();
-        this.write('}');
+        this.write(`CONFIRM ${stmt.confirm.value}`);
         this.newline();
+        this.indentLevel--;
     }
-    formatWherePattern(p) {
-        this.emitCommentsBefore(p.range.start.line);
-        switch (p.kind) {
-            case 'ConceptPattern':
-                return this.formatConceptPattern(p);
-            case 'PropositionPattern':
-                return this.formatPropositionPattern(p);
-            case 'FilterClause':
-                return this.formatFilterClause(p);
-            case 'NotClause':
-                return this.formatNotClause(p);
-            case 'OptionalClause':
-                return this.formatOptionalClause(p);
-            case 'UnionClause':
-                return this.formatUnionClause(p);
+    formatMerge(stmt) {
+        this.writeIndent();
+        this.write(`MERGE CONCEPT ${this.targetRef(stmt.source)} INTO ${this.targetRef(stmt.into)}`);
+        this.newline();
+        if (stmt.where)
+            this.formatWhere(stmt.where, 'WHERE');
+        if (stmt.expectVersion) {
+            this.writeIndent();
+            this.write(`EXPECT VERSION ${this.scalar(stmt.expectVersion.value)}`);
+            this.newline();
         }
     }
-    formatConceptPattern(p) {
+    // ────────────────────────────────────────────────────────────────────
+    //  KML clause bodies
+    // ────────────────────────────────────────────────────────────────────
+    formatAssignmentClause(keyword, assignments, sort) {
         this.writeIndent();
-        if (p.variable)
-            this.write(`${p.variable} `);
-        this.write('{');
-        this.write(p.matcher.entries
-            .map((e) => `${this.keyToString(e)}: ${this.exprToString(e.value, 0)}`)
-            .join(', '));
-        this.write('}');
+        this.write(`${keyword} `);
+        this.formatObjectBlock(assignments, sort);
         this.newline();
     }
-    formatPropositionPattern(p) {
+    formatFacet(clause) {
         this.writeIndent();
-        if (p.variable)
-            this.write(`${p.variable} `);
-        this.write(this.propositionPatternToString(p));
+        this.write(`SET FACET ${this.symbol(clause.facet)} `);
+        this.formatObjectBlock(clause.assignments, false);
         this.newline();
     }
-    formatFilterClause(f) {
+    formatUnsetAttributes(clause) {
         this.writeIndent();
-        this.write(`FILTER(${this.exprToString(f.expression, 0)})`);
+        this.write(`UNSET ATTRIBUTES { ${clause.fields.map((f) => this.fieldName(f.name, f.isQuoted)).join(', ')} }`);
         this.newline();
     }
-    formatNotClause(n) {
-        this.formatBlockClause('NOT', n.patterns, n.range.end.line);
-    }
-    formatOptionalClause(o) {
-        this.formatBlockClause('OPTIONAL', o.patterns, o.range.end.line);
-    }
-    formatUnionClause(u) {
-        this.formatBlockClause('UNION', u.patterns, u.range.end.line);
+    formatUnsetFacet(clause) {
+        this.writeIndent();
+        this.write(`UNSET FACET ${this.symbol(clause.facet)} { ${clause.fields.map((f) => this.fieldName(f.name, f.isQuoted)).join(', ')} }`);
+        this.newline();
     }
-    /** Shared rendering for NOT / OPTIONAL / UNION blocks (consistent styling). */
-    formatBlockClause(keyword, patterns, endLine) {
+    formatStructural(clause) {
         this.writeIndent();
-        this.write(`${keyword} {`);
+        this.write('SET STRUCTURAL {');
         this.newline();
         this.indentLevel++;
-        for (const p of patterns) {
-            this.formatWherePattern(p);
+        for (const assignment of clause.assignments) {
+            this.emitCommentsBefore(assignment.range.start.line);
+            this.writeIndent();
+            this.write(`(${this.symbol(assignment.field)}, ${this.expr(assignment.value)})`);
+            if (assignment.options) {
+                this.write(` ${this.objectLiteralToString(assignment.options)}`);
+            }
+            this.newline();
         }
-        this.emitCommentsBefore(endLine);
+        this.emitCommentsBefore(clause.range.end.line);
         this.indentLevel--;
         this.writeIndent();
         this.write('}');
         this.newline();
     }
-    formatOrderBy(ob) {
+    formatUnsetStructural(clause) {
         this.writeIndent();
-        const keys = ob.keys && ob.keys.length > 0
-            ? ob.keys
-            : [{ expression: ob.expression, direction: ob.direction }];
-        this.write(`ORDER BY ${keys
-            .map((key) => `${this.exprToString(key.expression, 0)} ${key.direction}`)
-            .join(', ')}`);
+        this.write('UNSET STRUCTURAL {');
+        this.newline();
+        this.indentLevel++;
+        for (const removal of clause.removals) {
+            this.emitCommentsBefore(removal.range.start.line);
+            this.writeIndent();
+            this.write(`(${this.symbol(removal.field)}, ${this.expr(removal.value)})`);
+            this.newline();
+        }
+        this.emitCommentsBefore(clause.range.end.line);
+        this.indentLevel--;
+        this.writeIndent();
+        this.write('}');
         this.newline();
     }
-    formatLimit(lim) {
+    // ────────────────────────────────────────────────────────────────────
+    //  META
+    // ────────────────────────────────────────────────────────────────────
+    formatDescribe(stmt) {
         this.writeIndent();
-        this.write(`LIMIT ${this.limitValueToString(lim)}`);
+        const words = {
+            PRIMER: 'PRIMER',
+            PROTOCOL: 'PROTOCOL',
+            EXECUTION_CONTEXT: 'EXECUTION CONTEXT',
+            CAPABILITIES: 'CAPABILITIES',
+            SPACE: 'SPACE',
+            SCHEMA_ENVIRONMENT: 'SCHEMA ENVIRONMENT',
+            PACKAGE: 'PACKAGE',
+            TYPE: 'TYPE',
+            PREDICATE: 'PREDICATE',
+            FACET: 'FACET',
+            STRUCTURAL_FIELD: 'STRUCTURAL FIELD',
+            COMPATIBILITY: 'COMPATIBILITY',
+            ERROR: 'ERROR',
+            TRANSACTION: 'TRANSACTION',
+            TRANSACTION_BY_IDEMPOTENCY_KEY: 'TRANSACTION BY IDEMPOTENCY KEY',
+            SNAPSHOT: 'SNAPSHOT',
+            CAPSULE: 'CAPSULE',
+            EPISTEMIC_POLICY: 'EPISTEMIC POLICY',
+            PROJECTION_CAPABILITY: 'PROJECTION CAPABILITY',
+            TRUST: 'TRUST',
+            ACCESS: 'ACCESS'
+        };
+        this.write(`DESCRIBE ${words[stmt.target]}`);
+        if (stmt.target === 'COMPATIBILITY' && stmt.from && stmt.to) {
+            this.write(` FROM ${this.scalar(stmt.from)} TO ${this.scalar(stmt.to)}`);
+        }
+        else if (stmt.value) {
+            this.write(` ${this.scalar(stmt.value)}`);
+        }
+        if (stmt.mode)
+            this.write(` MODE ${this.scalar(stmt.mode)}`);
+        if (stmt.asOf)
+            this.write(` ${this.asOfToString(stmt.asOf)}`);
+        if (stmt.with)
+            this.write(` WITH ${this.objectLiteralToString(stmt.with)}`);
         this.newline();
     }
-    formatCursor(cur) {
+    formatList(stmt) {
         this.writeIndent();
-        this.write(`CURSOR ${this.cursorValueToString(cur)}`);
+        const words = {
+            SPACES: 'SPACES',
+            SCHEMA_PACKAGES: 'SCHEMA PACKAGES',
+            TYPES: 'TYPES',
+            PREDICATES: 'PREDICATES',
+            FACETS: 'FACETS',
+            STRUCTURAL_FIELDS: 'STRUCTURAL FIELDS',
+            EPISTEMIC_POLICIES: 'EPISTEMIC POLICIES'
+        };
+        this.write(`LIST ${words[stmt.target]}`);
+        if (stmt.status)
+            this.write(` STATUS ${this.scalar(stmt.status)}`);
+        if (stmt.limit)
+            this.write(` LIMIT ${this.scalar(stmt.limit.value)}`);
+        if (stmt.cursor)
+            this.write(` CURSOR ${this.scalar(stmt.cursor.value)}`);
         this.newline();
     }
-    // ────────────────────────────────────────────────────────────────────
-    //  Expression → string (depth-aware for nested indentation)
-    // ────────────────────────────────────────────────────────────────────
-    exprToString(expr, depth) {
-        switch (expr.kind) {
-            case 'VariableRef':
-                return expr.name;
-            case 'ParameterRef':
-                return expr.name;
-            case 'DotExpression':
-                return `${this.exprToString(expr.object, depth)}.${expr.property}`;
-            case 'StringLiteral':
-                return expr.value;
-            case 'NumberLiteral':
-                return expr.raw;
-            case 'BooleanLiteral':
-                return String(expr.value);
-            case 'NullLiteral':
-                return 'null';
-            case 'ArrayLiteral':
-                return this.arrayToString(expr, depth);
-            case 'ObjectLiteral':
-                return this.objectToString(expr, depth);
-            case 'BinaryExpression':
-                return `${this.exprToString(expr.left, depth)} ${expr.operator} ${this.exprToString(expr.right, depth)}`;
-            case 'UnaryExpression':
-                return `${expr.operator}${this.exprToString(expr.operand, depth)}`;
-            case 'FunctionCallExpr':
-                if (expr.name === 'DISTINCT' && expr.args.length === 1) {
-                    return `DISTINCT ${this.exprToString(expr.args[0], depth)}`;
-                }
-                return `${expr.name}(${expr.args.map((a) => this.exprToString(a, depth)).join(', ')})`;
+    formatSearch(stmt) {
+        this.writeIndent();
+        this.write(`SEARCH ${stmt.searchKind} ${this.scalar(stmt.term)}`);
+        if (stmt.withType)
+            this.write(` WITH TYPE ${this.scalar(stmt.withType)}`);
+        if (stmt.withPredicate) {
+            this.write(` WITH PREDICATE ${this.scalar(stmt.withPredicate)}`);
         }
+        if (stmt.mode)
+            this.write(` MODE ${this.scalar(stmt.mode)}`);
+        if (stmt.threshold)
+            this.write(` THRESHOLD ${this.scalar(stmt.threshold)}`);
+        if (stmt.asOfSeq)
+            this.write(` AS OF SEQ ${this.scalar(stmt.asOfSeq)}`);
+        if (stmt.limit)
+            this.write(` LIMIT ${this.scalar(stmt.limit.value)}`);
+        if (stmt.cursor)
+            this.write(` CURSOR ${this.scalar(stmt.cursor.value)}`);
+        this.newline();
+    }
+    formatVerify(stmt) {
+        const words = {
+            CAPSULE: 'CAPSULE',
+            SCHEMA_PACKAGE: 'SCHEMA PACKAGE',
+            RECEIPT: 'RECEIPT',
+            BLOB: 'BLOB',
+            CHECKPOINT: 'CHECKPOINT'
+        };
+        this.writeIndent();
+        this.write(`VERIFY ${words[stmt.target]} ${this.scalar(stmt.value)}`);
+        this.newline();
     }
-    arrayToString(arr, depth) {
-        if (arr.elements.length === 0)
-            return '[]';
-        const inner = arr.elements.map((e) => this.exprToString(e, depth + 1));
-        const singleLine = `[${inner.join(', ')}]`;
-        if (singleLine.length <= 80 && !inner.some((s) => s.includes('\n'))) {
-            return singleLine;
+    formatValidate(stmt) {
+        const words = {
+            KQL: 'KQL',
+            KML: 'KML',
+            CAPSULE: 'CAPSULE',
+            SCHEMA_PACKAGE: 'SCHEMA PACKAGE',
+            IMPORT_PLAN: 'IMPORT PLAN'
+        };
+        this.writeIndent();
+        this.write(`VALIDATE ${words[stmt.target]} ${this.scalar(stmt.value)}`);
+        if (stmt.options) {
+            this.write(` WITH ${this.objectLiteralToString(stmt.options)}`);
         }
-        const baseIndent = this.indentAt(this.indentLevel + depth);
-        const innerIndent = this.indentAt(this.indentLevel + depth + 1);
-        return `[\n${inner.map((s) => `${innerIndent}${s}`).join(',\n')}\n${baseIndent}]`;
+        this.newline();
     }
-    objectToString(obj, depth) {
-        if (obj.entries.length === 0)
-            return '{}';
-        const entries = obj.entries.map((e) => `${this.keyToString(e)}: ${this.exprToString(e.value, depth + 1)}`);
-        const singleLine = `{${entries.join(', ')}}`;
-        if (singleLine.length <= 80 && !entries.some((s) => s.includes('\n'))) {
-            return singleLine;
+    formatPreview(stmt) {
+        this.writeIndent();
+        if (stmt.target === 'KML') {
+            this.write(`PREVIEW KML ${this.scalar(stmt.value)}`);
+        }
+        else {
+            this.write(`PREVIEW IMPORT CAPSULE ${this.scalar(stmt.value)} INTO ${this.scalar(stmt.into)}`);
         }
-        const baseIndent = this.indentAt(this.indentLevel + depth);
-        const innerIndent = this.indentAt(this.indentLevel + depth + 1);
-        return `{\n${entries.map((s) => `${innerIndent}${s}`).join(',\n')}\n${baseIndent}}`;
+        this.newline();
+    }
+    formatHistory(stmt) {
+        this.writeIndent();
+        this.write(`HISTORY ${stmt.target}`);
+        if (stmt.value)
+            this.write(` ${this.scalar(stmt.value)}`);
+        if (stmt.fromSeq)
+            this.write(` FROM SEQ ${this.scalar(stmt.fromSeq)}`);
+        if (stmt.toSeq)
+            this.write(` TO SEQ ${this.scalar(stmt.toSeq)}`);
+        if (stmt.limit)
+            this.write(` LIMIT ${this.scalar(stmt.limit.value)}`);
+        if (stmt.cursor)
+            this.write(` CURSOR ${this.scalar(stmt.cursor.value)}`);
+        this.newline();
+    }
+    formatChanges(stmt) {
+        this.writeIndent();
+        const keyword = stmt.mode === 'SINCE' ? 'SINCE' : 'AFTER SEQ';
+        this.write(`CHANGES ${keyword} ${this.scalar(stmt.value)}`);
+        if (stmt.limit)
+            this.write(` LIMIT ${this.scalar(stmt.limit.value)}`);
+        this.newline();
     }
-    formatObjectEntry(entry) {
+    formatSnapshot(stmt) {
         this.writeIndent();
-        const valStr = this.exprToString(entry.value, 0);
-        this.write(`${this.keyToString(entry)}: ${valStr}`);
+        this.write('SNAPSHOT');
+        if (stmt.asOf)
+            this.write(` ${this.asOfToString(stmt.asOf)}`);
+        this.newline();
+    }
+    formatExport(stmt) {
+        this.writeIndent();
+        this.write(`EXPORT CAPSULE ${this.targetRef(stmt.target)}`);
+        this.newline();
+        this.formatWhere(stmt.where, 'WHERE');
+        if (stmt.options) {
+            this.writeIndent();
+            this.write(`WITH ${this.objectLiteralToString(stmt.options)}`);
+            this.newline();
+        }
+        if (stmt.asOf) {
+            this.writeIndent();
+            this.write(this.asOfToString(stmt.asOf));
+            this.newline();
+        }
     }
     // ────────────────────────────────────────────────────────────────────
-    //  Helpers
+    //  Objects
     // ────────────────────────────────────────────────────────────────────
-    keyToString(entry) {
-        if (entry.isQuoted) {
-            return `"${this.escapeString(entry.key)}"`;
+    /**
+     * Emits `{...}` on one line when it is short and comment-free, otherwise
+     * one entry per line. A block holding a comment always stays multi-line, so
+     * the comment keeps the key it was written against.
+     */
+    formatObjectBlock(object, sort) {
+        const entries = object.entries;
+        if (entries.length === 0) {
+            this.write('{}');
+            return;
         }
-        return entry.key;
-    }
-    endpointToString(ep) {
-        switch (ep.kind) {
-            case 'VariableRef':
-                return ep.name;
-            case 'ConceptPattern': {
-                const entries = ep.matcher.entries
-                    .map((e) => `${this.keyToString(e)}: ${this.exprToString(e.value, 0)}`)
-                    .join(', ');
-                const prefix = ep.variable ? `${ep.variable} ` : '';
-                return `${prefix}{${entries}}`;
-            }
-            case 'PropositionPattern': {
-                const prefix = ep.variable ? `${ep.variable} ` : '';
-                return `${prefix}${this.propositionPatternToString(ep)}`;
-            }
-            default:
-                return '?unknown';
+        const hasComments = this.hasPendingCommentInRange(object.range.start.line, object.range.end.line);
+        const inline = this.objectLiteralToString(object, sort);
+        if (!hasComments &&
+            inline.length + this.indentLevel * this.opts.indentSize <= 78 &&
+            !inline.includes('\n')) {
+            this.write(inline);
+            return;
         }
-    }
-    propositionBlockPatternToString(block) {
-        if (block.id) {
-            return `(id: ${this.idValueToString(block.id)})`;
+        const ordered = sort && !hasComments ? this.sortObjectEntries(entries) : entries;
+        this.write('{');
+        this.newline();
+        this.indentLevel++;
+        for (let i = 0; i < ordered.length; i++) {
+            const entry = ordered[i];
+            this.emitCommentsBefore(entry.range.start.line);
+            this.writeIndent();
+            this.write(`${this.fieldName(entry.key, entry.isQuoted)}: ${this.expr(entry.value)}`);
+            if (i < ordered.length - 1)
+                this.write(',');
+            this.newline();
         }
-        return `(${this.endpointToString(block.subject)}, ${this.predicateToString(block.predicate)}, ${this.endpointToString(block.object)})`;
+        this.emitCommentsBefore(object.range.end.line);
+        this.indentLevel--;
+        this.writeIndent();
+        this.write('}');
     }
-    propositionPatternToString(pattern) {
-        if (pattern.id) {
-            return `(id: ${this.idValueToString(pattern.id)})`;
-        }
-        return `(${this.endpointToString(pattern.subject)}, ${this.predicateToString(pattern.predicate)}, ${this.endpointToString(pattern.object)})`;
+    objectLiteralToString(object, sort = false) {
+        if (object.entries.length === 0)
+            return '{}';
+        const entries = sort ? this.sortObjectEntries(object.entries) : object.entries;
+        const inner = entries
+            .map((e) => `${this.fieldName(e.key, e.isQuoted)}: ${this.expr(e.value)}`)
+            .join(', ');
+        return `{${inner}}`;
     }
-    idValueToString(id) {
-        if (!id)
-            return '""';
-        if (id.kind === 'StringLiteral')
-            return id.value;
-        return id.name;
+    objectPatternToString(pattern) {
+        if (pattern.members.length === 0)
+            return '{}';
+        const inner = pattern.members
+            .map((e) => `${this.fieldName(e.key, e.isQuoted)}: ${this.expr(e.value)}`)
+            .join(', ');
+        return `{${inner}}`;
     }
-    predicateToString(pred) {
-        if (pred.kind === 'PredicateVariable') {
-            return pred.name;
-        }
-        if (pred.kind === 'PredicateLiteral') {
-            let s = `"${this.escapeString(pred.value)}"`;
-            if (pred.hopRange) {
-                if (pred.hopRange.max === undefined) {
-                    s += `{${pred.hopRange.min},}`;
-                }
-                else if (pred.hopRange.max === pred.hopRange.min) {
-                    s += `{${pred.hopRange.min}}`;
-                }
-                else {
-                    s += `{${pred.hopRange.min},${pred.hopRange.max}}`;
-                }
-            }
-            return s;
-        }
-        // Alternation
-        return pred.predicates.map((p) => this.predicateToString(p)).join(' | ');
+    sortObjectEntries(entries) {
+        // Alphabetical by key (attributes are an unordered map in KIP).
+        return [...entries].sort((a, b) => a.key.localeCompare(b.key));
     }
-    limitValueToString(lim) {
-        return this.numberOrParameterValueToString(lim.value);
+    fieldName(key, isQuoted) {
+        return isQuoted ? `"${this.escapeString(key)}"` : key;
     }
-    thresholdValueToString(threshold) {
-        return this.numberOrParameterValueToString(threshold.value);
+    // ────────────────────────────────────────────────────────────────────
+    //  Terms and expressions
+    // ────────────────────────────────────────────────────────────────────
+    tupleToString(tuple) {
+        if (tuple.id)
+            return `(id: ${this.scalar(tuple.id)})`;
+        return `(${this.term(tuple.subject)}, ${this.predicate(tuple.predicate)}, ${this.term(tuple.object)})`;
     }
-    numberOrParameterValueToString(value) {
-        if (value.kind === 'NumberLiteral')
-            return value.raw;
-        return value.name;
+    term(term) {
+        if (term.kind === 'ObjectPattern')
+            return this.objectPatternToString(term);
+        if (term.kind === 'PropositionTuple')
+            return this.tupleToString(term);
+        return this.expr(term);
     }
-    cursorValueToString(cur) {
-        if (cur.value.kind === 'StringLiteral')
-            return cur.value.value;
-        return cur.value.name;
+    predicate(expr) {
+        return expr.atoms
+            .map((atom) => {
+            const base = this.predAtom(atom.atom);
+            if (!atom.quantifier)
+                return base;
+            const q = atom.quantifier;
+            if (!q.hasComma)
+                return `${base}{${q.min}}`;
+            return q.max === undefined
+                ? `${base}{${q.min},}`
+                : `${base}{${q.min},${q.max}}`;
+        })
+            .join(' | ');
     }
-    quotedOrParameterValueToString(value, fallback) {
-        if (value?.kind === 'StringLiteral')
-            return value.value;
-        if (value?.kind === 'ParameterRef')
-            return value.name;
-        return fallback.startsWith(':')
-            ? fallback
-            : `"${this.escapeString(fallback)}"`;
+    predAtom(atom) {
+        return this.expr(atom);
     }
-    sortObjectEntries(entries) {
-        // Alphabetical by key (attributes are an unordered map in KIP).
-        return [...entries].sort((a, b) => a.key.localeCompare(b.key));
+    symbol(symbol) {
+        return symbol.kind === 'ParameterRef' ? symbol.name : symbol.value;
     }
-    isSimpleValue(expr) {
-        return (expr.kind === 'StringLiteral' ||
-            expr.kind === 'NumberLiteral' ||
-            expr.kind === 'BooleanLiteral' ||
-            expr.kind === 'NullLiteral' ||
-            expr.kind === 'VariableRef' ||
-            expr.kind === 'ParameterRef');
+    scalar(value) {
+        return this.expr(value);
     }
-    allSimpleExpressions(exprs) {
-        return exprs.every((e) => e.kind === 'VariableRef' ||
-            e.kind === 'DotExpression' ||
-            e.kind === 'FunctionCallExpr');
+    targetRef(ref) {
+        return this.expr(ref);
+    }
+    expr(expr) {
+        switch (expr.kind) {
+            case 'StringLiteral':
+                return expr.value;
+            case 'NumberLiteral':
+                return expr.raw;
+            case 'BooleanLiteral':
+                return expr.value ? 'true' : 'false';
+            case 'NullLiteral':
+                return 'null';
+            case 'VariableRef':
+                return expr.name;
+            case 'ParameterRef':
+                return expr.name;
+            case 'FieldAccess':
+                return (expr.base.name +
+                    expr.steps
+                        .map((step) => step.kind === 'DotStep' ? `.${step.name}` : `[${step.key.value}]`)
+                        .join(''));
+            case 'FunctionCallExpr':
+                return `${expr.name.toUpperCase()}(${expr.args.map((a) => this.expr(a)).join(', ')})`;
+            case 'AggregateExpr':
+                return `${expr.name}(${expr.distinct ? 'DISTINCT ' : ''}${this.expr(expr.argument)})`;
+            case 'BinaryExpression':
+                return `${this.expr(expr.left)} ${expr.operator} ${this.expr(expr.right)}`;
+            case 'UnaryExpression':
+                return `${expr.operator}${this.expr(expr.operand)}`;
+            case 'ArrayLiteral':
+                return `[${expr.elements.map((e) => this.expr(e)).join(', ')}]`;
+            case 'ObjectLiteral':
+                return this.objectLiteralToString(expr);
+            case 'ObjectPattern':
+                return this.objectPatternToString(expr);
+            case 'PropositionTuple':
+                return this.tupleToString(expr);
+        }
     }
     escapeString(s) {
         return s
@@ -722,9 +1116,6 @@ class Formatter {
             .replace(/\t/g, '\\t')
             .replace(/\r/g, '\\r');
     }
-    indentAt(level) {
-        return ' '.repeat(level * this.opts.indentSize);
-    }
     indent() {
         return ' '.repeat(this.indentLevel * this.opts.indentSize);
     }