@stxt-lang/core 0.14.1 → 0.16.0

package/README.md

@@ -1,11 +1,11 @@
 # @stxt-lang/core
 
-Parser and schema validator for **STXT**, an indentation-based structured-text format.
+Parser and schema validator for **STXT**, an indentation-based structured-text language.
 
-STXT is a plain-text format for writing structured, semantic documents: no braces, no closing tags, just indentation. It is designed to be equally readable by humans and by machines, and it comes with an optional schema layer so documents can be validated.
+STXT is a plain-text language for writing structured, semantic documents: no braces, no closing tags, just indentation. It is designed to be equally readable by humans and by machines, and it comes with an optional schema layer so documents can be validated.
 
 - Website and language reference: <https://stxt.dev>
-- VSCode extension: [STXT - Semantic Text](https://marketplace.visualstudio.com/items?itemName=stxt-lang.stxt)
+- VSCode extension: [STXT Language](https://marketplace.visualstudio.com/items?itemName=stxt-lang.stxt)
 - Java implementation: [`dev.stxt:stxt-core`](https://central.sonatype.com/artifact/dev.stxt/stxt-core) on Maven Central
 - Python implementation: [`stxt`](https://pypi.org/project/stxt/) on PyPI
 

package/out/core/InlineNode.js

@@ -66,6 +66,7 @@ class InlineNode extends Node_1.Node {
         if (child.getParent() !== null) {
             throw new RuntimeException_1.RuntimeException("NODE_ALREADY_ATTACHED", `Node '${child.getName()}' already has a parent: detach it first`);
         }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias -- cursor of the ancestor walk, not an alias kept around
         for (let p = this; p !== null; p = p.getParent()) {
             if (p === child) {
                 throw new RuntimeException_1.RuntimeException("NODE_CYCLE", `Node '${child.getName()}' cannot be a child of itself or of one of its descendants`);

package/out/core/LineParser.js

@@ -64,7 +64,7 @@ function parseLine(line, lastNodeBlock, lastLevel, numLine, validate = true) {
         if (lastNodeBlock && level > lastLevel) {
             const text = StringUtils_1.StringUtils.rightTrim(line.substring(pointer + 1));
             // The prefix covering the block level must be homogeneous (spec 10.2, rule 2);
-            // empty lines are always preserved and are exempt from it (spec 10.3)
+            // empty lines are never an error and are exempt from it (spec 10.3)
             if (validate && sawSpace && sawTab && text.length > 0) {
                 throw new ParseException_1.ParseException(numLine, "INDENTATION_MIXED", `Mixed tabs and spaces in indentation`);
             }

package/out/core/NameNamespace.d.ts

@@ -3,11 +3,11 @@ export declare class NameNamespace {
     private readonly name;
     private readonly namespace;
     /**
-     * Creates a resolved name and namespace pair.
-     *
-     * @param name name of the node without the namespace part.
-     * @param namespace resolved namespace (its own or inherited).
-     */
+   * Creates a resolved name and namespace pair.
+   *
+   * @param name name of the node without the namespace part.
+   * @param namespace resolved namespace (its own or inherited).
+   */
     constructor(name: string, namespace: string);
     /** @returns the name of the node, without the namespace part. */
     getName(): string;

package/out/core/NameNamespace.js

@@ -4,11 +4,11 @@ exports.NameNamespace = void 0;
 /** Result of splitting a raw node name into its resolved name and namespace. */
 class NameNamespace {
     /**
-     * Creates a resolved name and namespace pair.
-     *
-     * @param name name of the node without the namespace part.
-     * @param namespace resolved namespace (its own or inherited).
-     */
+   * Creates a resolved name and namespace pair.
+   *
+   * @param name name of the node without the namespace part.
+   * @param namespace resolved namespace (its own or inherited).
+   */
     constructor(name, namespace) {
         this.name = name;
         this.namespace = namespace;

package/out/core/NamespaceValidator.d.ts

@@ -11,13 +11,6 @@ export declare class NamespaceValidator {
      * valid examples: "xxx", "xxx.ddd", "zzz.ttt.ooo", "@xxx", "@xxx.ddd".
      */
     private static readonly NAMESPACE_FORMAT;
-    /**
-     * Validates the format of a namespace.
-     *
-     * @param namespace already normalized namespace to validate; ignored when null or empty.
-     * @param lineNumber line number, for the error message.
-     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
-     */
     /**
      * Tells whether a namespace matches the format, without throwing.
      *
@@ -25,5 +18,12 @@ export declare class NamespaceValidator {
      * @returns true if it matches the format; false when it is null, empty or malformed.
      */
     static isValid(namespace: string | null | undefined): boolean;
+    /**
+     * Validates the format of a namespace.
+     *
+     * @param namespace already normalized namespace to validate; ignored when null or empty.
+     * @param lineNumber line number, for the error message.
+     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
+     */
     static validateNamespaceFormat(namespace: string | null | undefined, lineNumber: number): void;
 }

package/out/core/NamespaceValidator.js

@@ -4,13 +4,6 @@ exports.NamespaceValidator = void 0;
 const ParseException_1 = require("../exceptions/ParseException");
 /** Validates the format of STXT `(a.b.c)` namespaces. */
 class NamespaceValidator {
-    /**
-     * Validates the format of a namespace.
-     *
-     * @param namespace already normalized namespace to validate; ignored when null or empty.
-     * @param lineNumber line number, for the error message.
-     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
-     */
     /**
      * Tells whether a namespace matches the format, without throwing.
      *
@@ -20,6 +13,13 @@ class NamespaceValidator {
     static isValid(namespace) {
         return !!namespace && NamespaceValidator.NAMESPACE_FORMAT.test(namespace);
     }
+    /**
+     * Validates the format of a namespace.
+     *
+     * @param namespace already normalized namespace to validate; ignored when null or empty.
+     * @param lineNumber line number, for the error message.
+     * @throws ParseException with code `INVALID_NAMESPACE` if it does not match the format.
+     */
     static validateNamespaceFormat(namespace, lineNumber) {
         if (!namespace) {
             return;

package/out/core/Parser.d.ts

@@ -100,6 +100,11 @@ export declare class Parser {
      * registered callback fires the same.
      */
     private parseLines;
+    /**
+     * Processes one source line. Errors of this line are collected into the result and the
+     * traversal continues with the next line: returns true to keep going, false when a limit
+     * aborted the parse (its error is already emitted) — parseLines stops on it.
+     */
     private processLine;
     /**
      * Records an error raised while parsing or validating a line. Typed exceptions travel as they

package/out/core/Parser.js

@@ -139,20 +139,18 @@ class Parser {
                 this.emitError(new LimitException_1.LimitException(lineNumber, "LIMIT_INPUT_SIZE_EXCEEDED", `Input larger than ${this.maxInputSize} characters`), result);
                 return;
             }
-            try {
-                this.processLine(line, lineNumber, stack, result);
-            }
-            catch (e) {
-                if (e instanceof LimitException_1.LimitException) {
-                    this.emitError(e, result);
-                    return;
-                }
-                throw e;
+            if (!this.processLine(line, lineNumber, stack, result)) {
+                return; // a limit aborted the parse; its error is already emitted
             }
         }
         // Close every node still open at EOF
         this.closeToLevel(stack, 0, result);
     }
+    /**
+     * Processes one source line. Errors of this line are collected into the result and the
+     * traversal continues with the next line: returns true to keep going, false when a limit
+     * aborted the parse (its error is already emitted) — parseLines stops on it.
+     */
     processLine(lineString, lineNumber, stack, result) {
         try {
             const lastNode = stack.length === 0 ? null : stack[stack.length - 1];
@@ -176,7 +174,7 @@ class Parser {
                 this.observers.forEach(observer => {
                     observer.onComment(lineNumber, lineString);
                 });
-                return;
+                return true;
             }
             const currentLevel = line.level;
             // When we are inside a text node and the level says it is still text,
@@ -188,17 +186,18 @@ class Parser {
                 this.observers.forEach(observer => {
                     observer.onTextLine(textNode, lineNumber, lineString, line);
                 });
-                return;
+                return true;
             }
             // Empty lines are ignored
             if (line.isEmpty()) {
-                return;
+                return true;
             }
             // Nesting limit (spec 11.2): only a node line can open a new level. Comment and
             // block text lines returned above; with the consecutive-level rule this triggers
             // exactly when the first node at level maxNesting opens.
             if (this.maxNesting !== -1 && currentLevel >= this.maxNesting) {
-                throw new LimitException_1.LimitException(lineNumber, "LIMIT_NESTING_EXCEEDED", `Nesting deeper than ${this.maxNesting} levels`);
+                this.emitError(new LimitException_1.LimitException(lineNumber, "LIMIT_NESTING_EXCEEDED", `Nesting deeper than ${this.maxNesting} levels`), result);
+                return false;
             }
             // Close the nodes down to the current level (this "finishes" them: validators and observers run)
             this.closeToLevel(stack, currentLevel, result);
@@ -220,11 +219,9 @@ class Parser {
             stack.push(node);
         }
         catch (e) {
-            if (e instanceof LimitException_1.LimitException) {
-                throw e;
-            }
             this.handleError(e, lineNumber, result);
         }
+        return true;
     }
     /**
      * Records an error raised while parsing or validating a line. Typed exceptions travel as they
@@ -256,7 +253,15 @@ class Parser {
     }
     closeToLevel(stack, targetLevel, result) {
         while (stack.length > targetLevel) {
-            const completed = stack.pop();
+            const completed = stack[stack.length - 1];
+            stack.pop();
+            // A closing block node drops its final empty lines (STXT-SPEC §10.3): they are not
+            // content, only visual separation or an editor's final line breaks. The validators
+            // and observers below already see the trimmed node; onTextLine did fire for these
+            // lines while the block was open, as process observation of the source.
+            if (completed instanceof TextNode_1.TextNode) {
+                completed.removeTrailingEmptyLines();
+            }
             // Hand it over to the validators
             this.validators.forEach(validator => {
                 try {

package/out/core/StringUtils.d.ts

@@ -27,13 +27,6 @@ export declare class StringUtils {
      * @returns the string without trailing blanks; null/undefined is treated as the empty string.
      */
     static rightTrim(s: string | null | undefined): string;
-    /**
-     * Removes every whitespace character of a string.
-     *
-     * @param input string to remove the spaces from.
-     * @returns the string without any whitespace at all.
-     */
-    static cleanSpaces(input: string): string;
     /**
      * Lower-cases a string.
      *

package/out/core/StringUtils.js

@@ -33,16 +33,6 @@ class StringUtils {
     static rightTrim(s) {
         return (s ?? "").replace(this.TRAILING_BLANKS, "");
     }
-    // Used for BASE64 and HEXADECIMAL nodes
-    /**
-     * Removes every whitespace character of a string.
-     *
-     * @param input string to remove the spaces from.
-     * @returns the string without any whitespace at all.
-     */
-    static cleanSpaces(input) {
-        return input.replace(/\s+/g, "");
-    }
     // Used to normalize namespaces
     /**
      * Lower-cases a string.

package/out/core/TextNode.d.ts

@@ -56,6 +56,13 @@ export declare class TextNode extends Node {
     addTextLine(line: string): void;
     /** Removes every text line. */
     clearText(): void;
+    /**
+     * Removes the final empty lines (`""` elements at the end of the lines). The {@link Parser}
+     * calls it when the block closes (STXT-SPEC §10.3: the final empty lines of a block are not
+     * content); it is public because a programmatically built node may want the same
+     * normalization before writing.
+     */
+    removeTrailingEmptyLines(): void;
     getText(): string;
     isTextNode(): boolean;
     private static splitLines;

package/out/core/TextNode.js

@@ -61,6 +61,17 @@ class TextNode extends Node_1.Node {
     clearText() {
         this.lines.length = 0;
     }
+    /**
+     * Removes the final empty lines (`""` elements at the end of the lines). The {@link Parser}
+     * calls it when the block closes (STXT-SPEC §10.3: the final empty lines of a block are not
+     * content); it is public because a programmatically built node may want the same
+     * normalization before writing.
+     */
+    removeTrailingEmptyLines() {
+        while (this.lines.length > 0 && this.lines[this.lines.length - 1] === "") {
+            this.lines.pop();
+        }
+    }
     getText() {
         return this.lines.join("\n");
     }

package/out/discovery/DiscoveryResolver.d.ts

@@ -68,7 +68,7 @@ export declare class DiscoveryResolver {
     private existingUnique;
     private loadLevel;
     private collectFiles;
+    private collectFilesAt;
     private loadFile;
     private loadRootNode;
-    private compile;
 }

package/out/discovery/DiscoveryResolver.js

@@ -4,8 +4,9 @@ exports.DiscoveryResolver = void 0;
 const Parser_1 = require("../core/Parser");
 const StringUtils_1 = require("../core/StringUtils");
 const ParseException_1 = require("../exceptions/ParseException");
+const Schema_1 = require("../schema/Schema");
+const DefinitionCompiler_1 = require("../schema/DefinitionCompiler");
 const SchemaProviderMeta_1 = require("../schema/SchemaProviderMeta");
-const SchemaValidator_1 = require("../schema/SchemaValidator");
 const SchemaParser_1 = require("../schema/SchemaParser");
 const MetaTemplateSchemaProvider_1 = require("../template/MetaTemplateSchemaProvider");
 const TemplateParser_1 = require("../template/TemplateParser");
@@ -17,6 +18,12 @@ const STXT_DIR = ".stxt";
 const STXT_EXTENSION = ".stxt";
 /** Default value of {@link DiscoveryOptions.maxAscent}. */
 const DEFAULT_MAX_ASCENT = 32;
+/**
+ * Maximum depth of the recursive descent through a resolution directory's subtree. An
+ * internal safeguard (STXT-DISCOVERY-SPEC sections 3 and 10) against symlink loops and
+ * pathological trees; not part of the public API.
+ */
+const DEFAULT_MAX_DESCENT = 32;
 /**
  * Reference implementation of STXT-DISCOVERY-SPEC: builds the resolution chain of a
  * document (project ascent, user level, system level, or the `STXT_PATH` override), loads
@@ -135,13 +142,34 @@ class DiscoveryResolver {
         return level;
     }
     // Collects every file under a directory, recursively, sorted by path so that results
-    // and error messages do not depend on the listing order of the file system.
+    // and error messages do not depend on the listing order of the file system. The descent
+    // is bounded by DEFAULT_MAX_DESCENT and tolerant of listing failures (STXT-DISCOVERY-SPEC
+    // sections 3 and 10): a subdirectory that reaches the depth limit or cannot be listed
+    // contributes no files, never an exception. Together with adapters that do not follow
+    // directory symlinks, this stops symlink loops and pathological trees from turning
+    // resolution into unbounded recursion or an escaping error.
     async collectFiles(dir) {
+        return this.collectFilesAt(dir, 0);
+    }
+    async collectFilesAt(dir, depth) {
         const files = [];
-        const entries = [...await this.fs.listDirectory(dir)].sort((a, b) => a.path < b.path ? -1 : 1);
+        // Safeguard against symlink loops and pathological trees (spec section 10): stop
+        // descending once the depth limit is reached.
+        if (depth >= DEFAULT_MAX_DESCENT) {
+            return files;
+        }
+        let entries;
+        try {
+            entries = [...await this.fs.listDirectory(dir)].sort((a, b) => a.path < b.path ? -1 : 1);
+        }
+        catch {
+            // A directory that cannot be listed contributes no files (spec section 3); it
+            // does not stop the resolution of the rest of the level.
+            return files;
+        }
         for (const entry of entries) {
             if (entry.isDirectory) {
-                files.push(...await this.collectFiles(entry.path));
+                files.push(...await this.collectFilesAt(entry.path, depth + 1));
             }
             else {
                 files.push(entry.path);
@@ -179,11 +207,11 @@ class DiscoveryResolver {
         const namespace = node.getNamespace();
         let schema;
         try {
-            if (namespace === "@stxt.template") {
-                schema = this.compile(node, this.templateMeta, TemplateParser_1.transformTemplateNodeToSchema);
+            if (namespace === Schema_1.Schema.TEMPLATE_NAMESPACE) {
+                schema = (0, DefinitionCompiler_1.compileDefinitionNode)(node, this.templateMeta, TemplateParser_1.transformTemplateNodeToSchema);
             }
-            else if (namespace === "@stxt.schema") {
-                schema = this.compile(node, this.schemaMeta, SchemaParser_1.transformNodeToSchema);
+            else if (namespace === Schema_1.Schema.SCHEMA_NAMESPACE) {
+                schema = (0, DefinitionCompiler_1.compileDefinitionNode)(node, this.schemaMeta, SchemaParser_1.transformNodeToSchema);
             }
             else {
                 level.errors.push(new DiscoveryError_1.DiscoveryError(DiscoveryError_1.DiscoveryError.NOT_A_DEFINITION, file, `Root node belongs to '${namespace ?? ""}', not to @stxt.schema or @stxt.template: ${file}`));
@@ -217,15 +245,6 @@ class DiscoveryResolver {
         };
         level.definitions.set(key, definition);
     }
-    // Validates a root node against a meta-schema and transforms it into a Schema,
-    // throwing the first validation error (same policy as UnifiedSchemaProvider).
-    compile(node, meta, transform) {
-        const errors = new SchemaValidator_1.SchemaValidator(meta, true).validate(node);
-        if (errors.length > 0) {
-            throw errors[0];
-        }
-        return transform(node);
-    }
 }
 exports.DiscoveryResolver = DiscoveryResolver;
 //# sourceMappingURL=DiscoveryResolver.js.map

package/out/discovery/DiscoveryResult.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DiscoveryResult = void 0;
 const StringUtils_1 = require("../core/StringUtils");
+const Schema_1 = require("../schema/Schema");
 /**
  * The outcome of resolving a document's definitions (STXT-DISCOVERY-SPEC): the chain of
  * levels, the active definition per namespace (nearest level wins) and every resolution
@@ -34,11 +35,12 @@ class DiscoveryResult {
      * @returns the schema of the namespace, or null if the chain has no definition for it.
      */
     getSchema(namespace) {
-        if (namespace === "@stxt.template") {
-            return this.templateMeta.getSchema(namespace);
+        const key = StringUtils_1.StringUtils.lowerCase(namespace);
+        if (key === Schema_1.Schema.TEMPLATE_NAMESPACE) {
+            return this.templateMeta.getSchema(key);
         }
-        else if (namespace === "@stxt.schema") {
-            return this.schemaMeta.getSchema(namespace);
+        else if (key === Schema_1.Schema.SCHEMA_NAMESPACE) {
+            return this.schemaMeta.getSchema(key);
         }
         return this.getDefinition(namespace)?.schema ?? null;
     }

package/out/exceptions/ParseException.d.ts

@@ -3,7 +3,14 @@
  * carries an UPPERCASE code and the line of the document where it was detected.
  */
 export declare class ParseException extends Error {
-    /** Line number of the document where the error was detected. */
+    /**
+     * Line of an error that has no single source line: it concerns the document as a whole
+     * (`SCHEMA_MULTIPLE_ROOTS`) or a condition with no one line to point at (`NODE_DUPLICATED`,
+     * `CHILD_NOT_DEFINED`). The value 0 is part of the conformance surface (the kit asserts it);
+     * it is not `Node.NO_LINE` (-1), which marks nodes built programmatically, never errors.
+     */
+    static readonly NO_LINE = 0;
+    /** Line number of the document where the error was detected, or {@link ParseException.NO_LINE}. */
     readonly line: number;
     /** Error code in UPPERCASE (e.g. `INVALID_LINE`). */
     readonly code: string;

package/out/exceptions/ParseException.js

@@ -32,4 +32,11 @@ class ParseException extends Error {
     }
 }
 exports.ParseException = ParseException;
+/**
+ * Line of an error that has no single source line: it concerns the document as a whole
+ * (`SCHEMA_MULTIPLE_ROOTS`) or a condition with no one line to point at (`NODE_DUPLICATED`,
+ * `CHILD_NOT_DEFINED`). The value 0 is part of the conformance surface (the kit asserts it);
+ * it is not `Node.NO_LINE` (-1), which marks nodes built programmatically, never errors.
+ */
+ParseException.NO_LINE = 0;
 //# sourceMappingURL=ParseException.js.map

package/out/runtime/Formatter.d.ts

@@ -33,10 +33,10 @@ export interface FormatResult {
  * - A **text line of a block** gets the indentation of the block (its level plus one) in the
  *   requested style, followed by its content; any indentation the line had beyond the block's
  *   is content (STXT-SPEC §10.2, relative indentation is preserved) and is kept exactly. A
- *   blank line of the block is `""` in the content whatever it looks like in the source
- *   (STXT-SPEC §10.3), so it is written with the indentation of the block too: the block reads
- *   as one piece and, at the end of the file, the line is not lost — an empty last line would
- *   be indistinguishable from the final line ending.
+ *   blank line that precedes more block text is `""` in the content whatever it looks like in
+ *   the source (STXT-SPEC §10.3), so it is written with the indentation of the block too: the
+ *   block reads as one piece. The final blank lines of a block are not content (STXT-SPEC
+ *   §10.3: the parser drops them when the block closes) and fall under the next rule.
  * - Every **other line** — a comment, a blank line outside a block, or a line the parse tree
  *   does not describe because of a syntax error — is kept as the author wrote it, except that
  *   its trailing blanks are removed and the whole indentation units at its start are converted

package/out/runtime/Formatter.js

@@ -23,10 +23,10 @@ const NodeWriter_1 = require("./NodeWriter");
  * - A **text line of a block** gets the indentation of the block (its level plus one) in the
  *   requested style, followed by its content; any indentation the line had beyond the block's
  *   is content (STXT-SPEC §10.2, relative indentation is preserved) and is kept exactly. A
- *   blank line of the block is `""` in the content whatever it looks like in the source
- *   (STXT-SPEC §10.3), so it is written with the indentation of the block too: the block reads
- *   as one piece and, at the end of the file, the line is not lost — an empty last line would
- *   be indistinguishable from the final line ending.
+ *   blank line that precedes more block text is `""` in the content whatever it looks like in
+ *   the source (STXT-SPEC §10.3), so it is written with the indentation of the block too: the
+ *   block reads as one piece. The final blank lines of a block are not content (STXT-SPEC
+ *   §10.3: the parser drops them when the block closes) and fall under the next rule.
  * - Every **other line** — a comment, a blank line outside a block, or a line the parse tree
  *   does not describe because of a syntax error — is kept as the author wrote it, except that
  *   its trailing blanks are removed and the whole indentation units at its start are converted
@@ -85,8 +85,11 @@ class Formatter {
         if (node) {
             return Formatter.renderNode(node, line, style);
         }
+        // A final empty line of a block is not content (STXT-SPEC §10.3): the parser removed it
+        // from the node when the block closed, so its index falls beyond the logical lines. It
+        // is kept as any other line: blank, unindented.
         const text = sourceLines.textAt(lineNumber);
-        if (text) {
+        if (text && text.index < text.node.getTextLines().length) {
             return Formatter.indent(text.node.getLevel() + 1, style) + text.line.content;
         }
         return Formatter.convertUnits(StringUtils_1.StringUtils.rightTrim(line), style);
@@ -172,7 +175,10 @@ class SourceLines {
         // Comment lines need no bookkeeping: every line that opens no node is treated alike.
     }
     onTextLine(node, lineNumber, lineString, line) {
-        this.textByLine.set(lineNumber, { node, line });
+        // The line was just appended: its 0-based index in the block is the current last. After
+        // the block closes and drops its final empty lines (STXT-SPEC §10.3), an index beyond
+        // getTextLines() marks the line as a final empty line, not content.
+        this.textByLine.set(lineNumber, { node, line, index: node.getTextLines().length - 1 });
     }
     /**
      * @param lineNumber line number, 1-indexed.
@@ -183,8 +189,9 @@ class SourceLines {
     }
     /**
      * @param lineNumber line number, 1-indexed.
-     * @returns the block node this line is text of and the line already split into indentation
-     *          and content, or undefined if the line is not text of a block.
+     * @returns the block node this line is text of, the line already split into indentation and
+     *          content, and its 0-based index in the block; or undefined if the line is not text
+     *          of a block.
      */
     textAt(lineNumber) {
         return this.textByLine.get(lineNumber);

package/out/runtime/NodeWriter.js

@@ -59,9 +59,17 @@ class NodeWriter {
         }
         if (n instanceof TextNode_1.TextNode) {
             out.push(" >>\n");
-            for (const line of n.getTextLines()) {
+            // Final empty lines are not emitted (STXT-TREE-SPEC 11.1 rule 6): parsing never
+            // produces them (STXT-SPEC 10.3), and on a programmatically built node they would
+            // not survive the round trip.
+            const lines = n.getTextLines();
+            let last = lines.length;
+            while (last > 0 && lines[last - 1] === "") {
+                last--;
+            }
+            for (let i = 0; i < last; i++) {
                 NodeWriter.indent(out, depth + 1, style);
-                out.push(line, "\n");
+                out.push(lines[i], "\n");
             }
         }
         else if (n instanceof InlineNode_1.InlineNode) {

package/out/runtime/UnifiedSchemaProvider.d.ts

@@ -30,9 +30,7 @@ export declare class UnifiedSchemaProvider implements SchemaProvider {
      *         a schema or a template does not validate against its meta-schema.
      */
     addFile(text: string): void;
-    private addTemplateNode;
-    private addSchemaNode;
-    private static throwIfInvalid;
+    private addNode;
     /** Removes every schema and template registered in this provider. */
     clear(): void;
     /** @returns every schema registered in this provider, in registration order. */

package/out/runtime/UnifiedSchemaProvider.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UnifiedSchemaProvider = void 0;
 const Parser_1 = require("../core/Parser");
 const StringUtils_1 = require("../core/StringUtils");
+const Schema_1 = require("../schema/Schema");
+const DefinitionCompiler_1 = require("../schema/DefinitionCompiler");
 const SchemaProviderMeta_1 = require("../schema/SchemaProviderMeta");
 const SchemaParser_1 = require("../schema/SchemaParser");
-const SchemaValidator_1 = require("../schema/SchemaValidator");
 const MetaTemplateSchemaProvider_1 = require("../template/MetaTemplateSchemaProvider");
 const TemplateParser_1 = require("../template/TemplateParser");
 /**
@@ -31,14 +32,13 @@ class UnifiedSchemaProvider {
      */
     getSchema(namespace) {
         const key = StringUtils_1.StringUtils.lowerCase(namespace);
-        if (namespace === "@stxt.template") {
+        if (key === Schema_1.Schema.TEMPLATE_NAMESPACE) {
             return this.templateMeta.getSchema(key);
         }
-        else if (namespace === "@stxt.schema") {
+        else if (key === Schema_1.Schema.SCHEMA_NAMESPACE) {
             return this.schemaMeta.getSchema(key);
         }
-        let result = this.schemas.get(key);
-        return result;
+        return this.schemas.get(key);
     }
     /**
      * Parses a document and registers every schema or template it defines, each one under its own
@@ -53,37 +53,19 @@ class UnifiedSchemaProvider {
         const nodes = parser.parse(text);
         for (const node of nodes) {
             const namespace = node.getNamespace();
-            if (namespace === "@stxt.template") {
-                this.addTemplateNode(node);
+            if (namespace === Schema_1.Schema.TEMPLATE_NAMESPACE) {
+                this.addNode(node, this.templateMeta, TemplateParser_1.transformTemplateNodeToSchema);
             }
-            else if (namespace === "@stxt.schema") {
-                this.addSchemaNode(node);
+            else if (namespace === Schema_1.Schema.SCHEMA_NAMESPACE) {
+                this.addNode(node, this.schemaMeta, SchemaParser_1.transformNodeToSchema);
             }
         }
     }
-    addTemplateNode(node) {
-        // Validate against the meta-schema of templates
-        const schemaValidator = new SchemaValidator_1.SchemaValidator(this.templateMeta, true);
-        UnifiedSchemaProvider.throwIfInvalid(schemaValidator.validate(node));
-        // Transform the template into a schema
-        const schema = (0, TemplateParser_1.transformTemplateNodeToSchema)(node);
-        const key = StringUtils_1.StringUtils.lowerCase(schema.getNamespace());
-        this.schemas.set(key, schema);
-    }
-    addSchemaNode(node) {
-        // Validate against the meta-schema of schemas
-        const schemaValidator = new SchemaValidator_1.SchemaValidator(this.schemaMeta, true);
-        UnifiedSchemaProvider.throwIfInvalid(schemaValidator.validate(node));
-        // Transform the node into a schema
-        const schema = (0, SchemaParser_1.transformNodeToSchema)(node);
-        const key = StringUtils_1.StringUtils.lowerCase(schema.getNamespace());
-        this.schemas.set(key, schema);
-    }
-    // A schema/template that does not validate against its meta-schema must not be loaded
-    static throwIfInvalid(errors) {
-        if (errors.length > 0) {
-            throw errors[0];
-        }
+    // Compiles a definition root through the shared pipeline (see DefinitionCompiler)
+    // and registers it; a definition that does not validate is never registered.
+    addNode(node, meta, transform) {
+        const schema = (0, DefinitionCompiler_1.compileDefinitionNode)(node, meta, transform);
+        this.schemas.set(StringUtils_1.StringUtils.lowerCase(schema.getNamespace()), schema);
     }
     /** Removes every schema and template registered in this provider. */
     clear() {