@stxt-lang/core 0.9.0 → 0.10.0

package/out/all.d.ts

@@ -5,6 +5,12 @@ export { Parser } from "./core/Parser";
 export { ParseResult } from "./core/ParseResult";
 export { Line } from "./core/Line";
 export { Constants } from "./core/Constants";
+/**
+ * Version of the STXT specifications (STXT-SPEC, STXT-TREE-SPEC, STXT-SCHEMA-SPEC,
+ * STXT-TEMPLATE-SPEC, STXT-DISCOVERY-SPEC) this library implements, distinct from the version of
+ * the package. Same value as `Constants.SPEC_VERSION`.
+ */
+export declare const SPEC_VERSION: string;
 export { parseLine } from "./core/LineParser";
 export { StringUtils } from "./core/StringUtils";
 export { ParseException } from "./exceptions/ParseException";

package/out/all.js

@@ -3,7 +3,7 @@
 // Anything that should be consumable by third parties (e.g. the VSCode extension)
 // has to be re-exported from here.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscoveryError = exports.DiscoveryResult = exports.DiscoveryResolver = exports.transformTemplateNodeToSchema = exports.toCanonicalJson = exports.toCanonicalTree = exports.IndentStyle = exports.NodeWriter = exports.ConditionalValidator = exports.UnifiedSchemaProvider = exports.transformNodeToSchema = exports.ChildDefinition = exports.NodeDefinition = exports.SchemaValidator = exports.Schema = exports.ValidationException = exports.ParseException = exports.StringUtils = exports.parseLine = exports.Constants = exports.Line = exports.ParseResult = exports.Parser = exports.TextNode = exports.InlineNode = exports.Node = void 0;
+exports.DiscoveryError = exports.DiscoveryResult = exports.DiscoveryResolver = exports.transformTemplateNodeToSchema = exports.toCanonicalJson = exports.toCanonicalTree = exports.IndentStyle = exports.NodeWriter = exports.ConditionalValidator = exports.UnifiedSchemaProvider = exports.transformNodeToSchema = exports.ChildDefinition = exports.NodeDefinition = exports.SchemaValidator = exports.Schema = exports.ValidationException = exports.ParseException = exports.StringUtils = exports.parseLine = exports.SPEC_VERSION = exports.Constants = exports.Line = exports.ParseResult = exports.Parser = exports.TextNode = exports.InlineNode = exports.Node = void 0;
 var Node_1 = require("./core/Node");
 Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return Node_1.Node; } });
 var InlineNode_1 = require("./core/InlineNode");
@@ -18,6 +18,13 @@ var Line_1 = require("./core/Line");
 Object.defineProperty(exports, "Line", { enumerable: true, get: function () { return Line_1.Line; } });
 var Constants_1 = require("./core/Constants");
 Object.defineProperty(exports, "Constants", { enumerable: true, get: function () { return Constants_1.Constants; } });
+const Constants_2 = require("./core/Constants");
+/**
+ * Version of the STXT specifications (STXT-SPEC, STXT-TREE-SPEC, STXT-SCHEMA-SPEC,
+ * STXT-TEMPLATE-SPEC, STXT-DISCOVERY-SPEC) this library implements, distinct from the version of
+ * the package. Same value as `Constants.SPEC_VERSION`.
+ */
+exports.SPEC_VERSION = Constants_2.Constants.SPEC_VERSION;
 var LineParser_1 = require("./core/LineParser");
 Object.defineProperty(exports, "parseLine", { enumerable: true, get: function () { return LineParser_1.parseLine; } });
 var StringUtils_1 = require("./core/StringUtils");

package/out/core/Constants.d.ts

@@ -1,5 +1,12 @@
 /** Characters and sizes fixed by STXT-SPEC that the parser and the writer share. */
 export declare class Constants {
+    /**
+     * Version of the STXT specifications (STXT-SPEC, STXT-TREE-SPEC, STXT-SCHEMA-SPEC,
+     * STXT-TEMPLATE-SPEC, STXT-DISCOVERY-SPEC) this library implements. It is distinct from the
+     * version of the package: the package may be released many times against the same
+     * specification version.
+     */
+    static readonly SPEC_VERSION: string;
     /** Character that opens a comment line. */
     static readonly COMMENT_CHAR: string;
     /** Number of spaces that make up one indentation level. */

package/out/core/Constants.js

@@ -5,6 +5,13 @@ exports.Constants = void 0;
 class Constants {
 }
 exports.Constants = Constants;
+/**
+ * Version of the STXT specifications (STXT-SPEC, STXT-TREE-SPEC, STXT-SCHEMA-SPEC,
+ * STXT-TEMPLATE-SPEC, STXT-DISCOVERY-SPEC) this library implements. It is distinct from the
+ * version of the package: the package may be released many times against the same
+ * specification version.
+ */
+Constants.SPEC_VERSION = "1.0";
 /** Character that opens a comment line. */
 Constants.COMMENT_CHAR = "#";
 /** Number of spaces that make up one indentation level. */

package/out/core/LineParser.d.ts

@@ -16,7 +16,7 @@ import { Line } from "./Line";
  * @param numLine line number, for the error messages.
  * @param validate false to split the line without enforcing the indentation rules.
  * @returns the line already split into indentation and content.
- * @throws ParseException with code `MIXED_INDENTATION`, `INVALID_NUMBER_SPACES` or
+ * @throws ParseException with code `INDENTATION_MIXED`, `INDENTATION_SPACES_NOT_VALID` or
  *         `INDENTATION_LEVEL_NOT_VALID` if the indentation is not valid.
  */
 export declare function parseLine(line: string, lastNodeBlock: boolean, lastLevel: number, numLine: number, validate?: boolean): Line;

package/out/core/LineParser.js

@@ -22,7 +22,7 @@ const Line_1 = require("./Line");
  * @param numLine line number, for the error messages.
  * @param validate false to split the line without enforcing the indentation rules.
  * @returns the line already split into indentation and content.
- * @throws ParseException with code `MIXED_INDENTATION`, `INVALID_NUMBER_SPACES` or
+ * @throws ParseException with code `INDENTATION_MIXED`, `INDENTATION_SPACES_NOT_VALID` or
  *         `INDENTATION_LEVEL_NOT_VALID` if the indentation is not valid.
  */
 function parseLine(line, lastNodeBlock, lastLevel, numLine, validate = true) {
@@ -66,7 +66,7 @@ function parseLine(line, lastNodeBlock, lastLevel, numLine, validate = true) {
             // 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)
             if (validate && sawSpace && sawTab && text.length > 0) {
-                throw new ParseException_1.ParseException(numLine, "MIXED_INDENTATION", `Mixed tabs and spaces in indentation`);
+                throw new ParseException_1.ParseException(numLine, "INDENTATION_MIXED", `Mixed tabs and spaces in indentation`);
             }
             return new Line_1.Line(level, text, false, true, pointer);
         }
@@ -83,11 +83,11 @@ function parseLine(line, lastNodeBlock, lastLevel, numLine, validate = true) {
     }
     // Tabs and spaces mixed in the indentation (spec 8.1 and 8.3)
     if (validate && sawSpace && sawTab) {
-        throw new ParseException_1.ParseException(numLine, "MIXED_INDENTATION", `Mixed tabs and spaces in indentation`);
+        throw new ParseException_1.ParseException(numLine, "INDENTATION_MIXED", `Mixed tabs and spaces in indentation`);
     }
     // Indentation with spaces that is not a multiple of 4
     if (validate && spaces > 0) {
-        throw new ParseException_1.ParseException(numLine, "INVALID_NUMBER_SPACES", `There are ${spaces} spaces before node`);
+        throw new ParseException_1.ParseException(numLine, "INDENTATION_SPACES_NOT_VALID", `There are ${spaces} spaces before node`);
     }
     // Validate the level (spec 11.3). Comments included (spec 9): lastLevel is the level of the
     // last NODE, a comment never becomes the reference.

package/out/core/NamespaceValidator.d.ts

@@ -18,5 +18,12 @@ export declare class NamespaceValidator {
      * @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.
+     *
+     * @param namespace already normalized namespace to check.
+     * @returns true if it matches the format; false when it is null, empty or malformed.
+     */
+    static isValid(namespace: string | null | undefined): boolean;
     static validateNamespaceFormat(namespace: string | null | undefined, lineNumber: number): void;
 }

package/out/core/NamespaceValidator.js

@@ -11,6 +11,15 @@ class NamespaceValidator {
      * @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.
+     *
+     * @param namespace already normalized namespace to check.
+     * @returns true if it matches the format; false when it is null, empty or malformed.
+     */
+    static isValid(namespace) {
+        return !!namespace && NamespaceValidator.NAMESPACE_FORMAT.test(namespace);
+    }
     static validateNamespaceFormat(namespace, lineNumber) {
         if (!namespace) {
             return;

package/out/core/NodeCreator.js

@@ -49,7 +49,7 @@ function createNode(lineIndent, lineNumber) {
         value = line.substring(nodeIndex + Constants_1.Constants.SEP_NODE.length);
     }
     if (textNode && StringUtils_1.StringUtils.trim(value).length > 0) {
-        throw new ParseException_1.ParseException(lineNumber, "INLINE_VALUE_NOT_VALID", `Line not valid: ${line}`);
+        throw new ParseException_1.ParseException(lineNumber, "BLOCK_VALUE_NOT_ALLOWED", `Line not valid: ${line}`);
     }
     // The namespace the line declares, if any (empty when it inherits)
     const nameNamespace = NameNamespaceParser_1.NameNamespaceParser.parse(name, null, lineNumber, line);

package/out/core/Parser.d.ts

@@ -41,6 +41,11 @@ export declare class Parser {
      */
     parseResult(content: string): ParseResult;
     private processLine;
+    /**
+     * Records an error raised while parsing or validating a line. Typed exceptions travel as they
+     * are; anything else is wrapped under the code `UNEXPECTED_ERROR` (as a ValidationException
+     * when it was raised by a validator, so that the subtype still tells the phase apart).
+     */
     private handleError;
     private closeToLevel;
     private removeUTF8BOM;

package/out/core/Parser.js

@@ -6,6 +6,7 @@ const LineParser_1 = require("./LineParser");
 const NodeCreator_1 = require("./NodeCreator");
 const ParseResult_1 = require("./ParseResult");
 const ParseException_1 = require("../exceptions/ParseException");
+const ValidationException_1 = require("../exceptions/ValidationException");
 /**
  * Line-by-line STXT parsing engine. It knows nothing about schemas: semantic validation is
  * plugged in through {@link Parser.registerValidator} and {@link Parser.registerObserver}.
@@ -145,17 +146,20 @@ class Parser {
             this.handleError(e, lineNumber, result);
         }
     }
-    handleError(e, line, result, errorCode = "UNEXPECTED_ERROR", unknownErrorCode = "UNKNOWN_ERROR") {
+    /**
+     * Records an error raised while parsing or validating a line. Typed exceptions travel as they
+     * are; anything else is wrapped under the code `UNEXPECTED_ERROR` (as a ValidationException
+     * when it was raised by a validator, so that the subtype still tells the phase apart).
+     */
+    handleError(e, line, result, validating = false) {
         if (e instanceof ParseException_1.ParseException) {
             result.addError(e);
         }
-        else if (e instanceof Error) {
-            // Turn generic errors into a ParseException
-            result.addError(new ParseException_1.ParseException(line, errorCode, e.message));
-        }
         else {
-            // Unknown error
-            result.addError(new ParseException_1.ParseException(line, unknownErrorCode, String(e)));
+            const message = e instanceof Error ? e.message : String(e);
+            result.addError(validating
+                ? new ValidationException_1.ValidationException(line, "UNEXPECTED_ERROR", message)
+                : new ParseException_1.ParseException(line, "UNEXPECTED_ERROR", message));
         }
     }
     closeToLevel(stack, targetLevel, result) {
@@ -170,7 +174,7 @@ class Parser {
                     });
                 }
                 catch (e) {
-                    this.handleError(e, completed.getLine(), result, "VALIDATION_ERROR", "UNKNOWN_VALIDATION_ERROR");
+                    this.handleError(e, completed.getLine(), result, true);
                 }
             });
             // Hand it over to the observers

package/out/exceptions/ParseException.d.ts

@@ -15,6 +15,12 @@ export declare class ParseException extends Error {
      * @param message descriptive message.
      */
     constructor(line: number, code: string, message: string);
-    /** @returns a readable representation of the error, with its line and its code. */
+    /**
+     * The string form carries the frame that `message` deliberately leaves out: `message` is only
+     * the description, and the code and the line are separate fields that whoever formats output
+     * composes. Same framing in every port since 0.10.0.
+     *
+     * @returns `[CODE] line N: message`.
+     */
     toString(): string;
 }

package/out/exceptions/ParseException.js

@@ -20,9 +20,15 @@ class ParseException extends Error {
         this.code = code;
         Object.setPrototypeOf(this, ParseException.prototype);
     }
-    /** @returns a readable representation of the error, with its line and its code. */
+    /**
+     * The string form carries the frame that `message` deliberately leaves out: `message` is only
+     * the description, and the code and the line are separate fields that whoever formats output
+     * composes. Same framing in every port since 0.10.0.
+     *
+     * @returns `[CODE] line N: message`.
+     */
     toString() {
-        return `${this.name} [line=${this.line}, code=${this.code}]: ${this.message}`;
+        return `[${this.code}] line ${this.line}: ${this.message}`;
     }
 }
 exports.ParseException = ParseException;

package/out/exceptions/RuntimeException.d.ts

@@ -15,6 +15,11 @@ export declare class RuntimeException extends Error {
     constructor(code: string, message: string);
     /** @returns the error code in UPPERCASE. */
     getCode(): string;
-    /** @returns a readable representation of the error, with its code. */
+    /**
+     * The string form carries the frame that `message` deliberately leaves out; same framing in
+     * every port since 0.10.0.
+     *
+     * @returns `[CODE] message`.
+     */
     toString(): string;
 }

package/out/exceptions/RuntimeException.js

@@ -23,10 +23,14 @@ class RuntimeException extends Error {
     getCode() {
         return this.code;
     }
-    /** @returns a readable representation of the error, with its code. */
+    /**
+     * The string form carries the frame that `message` deliberately leaves out; same framing in
+     * every port since 0.10.0.
+     *
+     * @returns `[CODE] message`.
+     */
     toString() {
-        const message = this.message;
-        return `${this.name}[${this.code}]${message ? `: ${message}` : ""}`;
+        return `[${this.code}] ${this.message}`;
     }
 }
 exports.RuntimeException = RuntimeException;

package/out/schema/NodeDefinition.d.ts

@@ -45,7 +45,7 @@ export declare class NodeDefinition {
      * Adds the definition of an expected child.
      *
      * @param childDefinition definition of the child to add.
-     * @throws ValidationException with code `CHILD_DEF_ALREADY_DEFINED` if a definition for that child already existed.
+     * @throws ValidationException with code `CHILD_DUPLICATED` if a definition for that child already existed.
      */
     addChildDefinition(childDefinition: ChildDefinition): void;
     /**

package/out/schema/NodeDefinition.js

@@ -67,12 +67,12 @@ class NodeDefinition {
      * Adds the definition of an expected child.
      *
      * @param childDefinition definition of the child to add.
-     * @throws ValidationException with code `CHILD_DEF_ALREADY_DEFINED` if a definition for that child already existed.
+     * @throws ValidationException with code `CHILD_DUPLICATED` if a definition for that child already existed.
      */
     addChildDefinition(childDefinition) {
         const qname = childDefinition.getQualifiedName();
         if (this.children.has(qname)) {
-            throw new ValidationException_1.ValidationException(0, "CHILD_DEF_ALREADY_DEFINED", `Exists a previous node definition with: ${qname}`);
+            throw new ValidationException_1.ValidationException(0, "CHILD_DUPLICATED", `Exists a previous node definition with: ${qname}`);
         }
         this.children.set(qname, childDefinition);
     }

package/out/schema/Schema.d.ts

@@ -28,7 +28,7 @@ export declare class Schema {
      * Adds the definition of a node to this schema.
      *
      * @param nodeDefinition node definition to add.
-     * @throws ValidationException with code `NODE_DEF_ALREADY_DEFINED` if there already was a node definition with the same name.
+     * @throws ValidationException with code `NODE_DUPLICATED` if there already was a node definition with the same name.
      */
     addNodeDefinition(nodeDefinition: NodeDefinition): void;
     /** @returns the namespace this schema applies to. */

package/out/schema/Schema.js

@@ -37,12 +37,12 @@ class Schema {
      * Adds the definition of a node to this schema.
      *
      * @param nodeDefinition node definition to add.
-     * @throws ValidationException with code `NODE_DEF_ALREADY_DEFINED` if there already was a node definition with the same name.
+     * @throws ValidationException with code `NODE_DUPLICATED` if there already was a node definition with the same name.
      */
     addNodeDefinition(nodeDefinition) {
         const qname = nodeDefinition.getCanonicalName();
         if (this.nodes.has(qname)) {
-            throw new ValidationException_1.ValidationException(0, "NODE_DEF_ALREADY_DEFINED", `Exists a previous node definition with: ${qname}`);
+            throw new ValidationException_1.ValidationException(0, "NODE_DUPLICATED", `Exists a previous node definition with: ${qname}`);
         }
         this.nodes.set(qname, nodeDefinition);
     }

package/out/schema/SchemaParser.d.ts

@@ -5,6 +5,7 @@ import { Node } from "../core/Node";
  *
  * @param node root node of the schema document, `Schema (@stxt.schema): ...`.
  * @returns the schema the document defines.
- * @throws ValidationException if the document is not a valid `@stxt.schema` one.
+ * @throws ValidationException with `SCHEMA_ROOT_NOT_VALID`, `SCHEMA_NAMESPACE_EMPTY`, `SCHEMA_NODE_NOT_INLINE`
+ *         or the code of the first rule of the schema language the document breaks, if the document is not a valid `@stxt.schema` one.
  */
 export declare function transformNodeToSchema(node: Node): Schema;

package/out/schema/SchemaParser.js

@@ -6,7 +6,8 @@ const NodeDefinition_1 = require("./NodeDefinition");
 const ChildDefinition_1 = require("./ChildDefinition");
 const InlineNode_1 = require("../core/InlineNode");
 const ValidationException_1 = require("../exceptions/ValidationException");
-const RuntimeException_1 = require("../exceptions/RuntimeException");
+const NamespaceValidator_1 = require("../core/NamespaceValidator");
+const StringUtils_1 = require("../core/StringUtils");
 const NameNamespaceParser_1 = require("../core/NameNamespaceParser");
 const TypeRegistry_1 = require("./TypeRegistry");
 /**
@@ -14,7 +15,8 @@ const TypeRegistry_1 = require("./TypeRegistry");
  *
  * @param node root node of the schema document, `Schema (@stxt.schema): ...`.
  * @returns the schema the document defines.
- * @throws ValidationException if the document is not a valid `@stxt.schema` one.
+ * @throws ValidationException with `SCHEMA_ROOT_NOT_VALID`, `SCHEMA_NAMESPACE_EMPTY`, `SCHEMA_NODE_NOT_INLINE`
+ *         or the code of the first rule of the schema language the document breaks, if the document is not a valid `@stxt.schema` one.
  */
 function transformNodeToSchema(node) {
     // Node name
@@ -22,12 +24,20 @@ function transformNodeToSchema(node) {
     const namespaceSchema = node.getNamespace();
     // Get the name and the namespace
     if (nodeName !== "schema" || namespaceSchema !== Schema_1.Schema.SCHEMA_NAMESPACE) {
-        throw new ValidationException_1.ValidationException(node.getLine(), "NOT_STXT_SCHEMA", `Expected schema(${Schema_1.Schema.SCHEMA_NAMESPACE}) but got ${nodeName}(${namespaceSchema})`);
+        throw new ValidationException_1.ValidationException(node.getLine(), "SCHEMA_ROOT_NOT_VALID", `Expected schema(${Schema_1.Schema.SCHEMA_NAMESPACE}) but got ${nodeName}(${namespaceSchema})`);
     }
     const root = inline(node);
+    // The target namespace: required, and with a valid format
+    const targetNamespace = StringUtils_1.StringUtils.lowerCase(root.getValue());
+    if (!targetNamespace || targetNamespace.trim().length === 0) {
+        throw new ValidationException_1.ValidationException(root.getLine(), "SCHEMA_NAMESPACE_EMPTY", "Schema namespace is empty");
+    }
+    if (!NamespaceValidator_1.NamespaceValidator.isValid(targetNamespace)) {
+        throw new ValidationException_1.ValidationException(root.getLine(), "SCHEMA_ROOT_NOT_VALID", `Schema namespace not valid: ${targetNamespace}`);
+    }
     // Get the description
     const descrip = root.getChild("description")?.getText();
-    const schema = new Schema_1.Schema(root.getValue(), root.getLine(), descrip);
+    const schema = new Schema_1.Schema(targetNamespace, root.getLine(), descrip);
     // Used to check that every child is defined
     const allNames = new Set();
     // Get the nodes
@@ -55,7 +65,7 @@ function inline(node) {
     if (node instanceof InlineNode_1.InlineNode) {
         return node;
     }
-    throw new ValidationException_1.ValidationException(node.getLine(), "INVALID_SCHEMA", `Node '${node.getName()}' must be inline in a schema`);
+    throw new ValidationException_1.ValidationException(node.getLine(), "SCHEMA_NODE_NOT_INLINE", `Node '${node.getName()}' must be inline in a schema`);
 }
 /** Builds the definition of a node from a `Node:` entry of the schema document. */
 function createFrom(node, namespace) {
@@ -82,14 +92,19 @@ function createFrom(node, namespace) {
     let valuesNodes = n.getChildrenByName("values");
     if (valuesNodes && valuesNodes.length > 0) {
         if (type !== "ENUM") {
-            throw new ValidationException_1.ValidationException(n.getLine(), "VALUES_ONLY_SUPPORTED_BY_ENUM", `Values only supported for type ENUM, not for type ${type}`);
+            throw new ValidationException_1.ValidationException(n.getLine(), "VALUES_NOT_ALLOWED_FOR_TYPE", `Values only supported for type ENUM, not for type ${type}`);
         }
         if (valuesNodes.length > 1) {
-            throw new RuntimeException_1.RuntimeException("INVALID_SIZE_VALUES", `Unexpected number of values: ${valuesNodes.length}`);
+            throw new ValidationException_1.ValidationException(valuesNodes[1].getLine(), "VALUES_DUPLICATED", `Node '${n.getValue()}' defines 'Values' ${valuesNodes.length} times`);
         }
         const valuesNode = valuesNodes[0];
         const values = inline(valuesNode).getChildrenByName("value");
         for (const v of values) {
+            // An empty Value: is a schema error (STXT-SCHEMA-SPEC 7.2, condition 14 of section 13):
+            // an enumeration whose only valid value is the empty string makes no sense
+            if (v.getText().length === 0) {
+                throw new ValidationException_1.ValidationException(v.getLine(), "VALUE_EMPTY", "Value of ENUM cannot be empty");
+            }
             result.addValue(v.getText(), v.getLine());
         }
         // For the final ENUM check
@@ -97,7 +112,7 @@ function createFrom(node, namespace) {
     }
     // Look at the enum
     if (type === "ENUM" && (!valuesNodes || valuesNodes.length === 0)) {
-        throw new ValidationException_1.ValidationException(n.getLine(), "VALUES_EMPTY_FOR_ENUM", "ENUM Type must include values");
+        throw new ValidationException_1.ValidationException(n.getLine(), "VALUES_REQUIRED", "ENUM Type must include values");
     }
     return result;
 }
@@ -126,7 +141,7 @@ function getInteger(node, name) {
     const raw = n.getText();
     const parsed = Number.parseInt(raw, 10);
     if (Number.isNaN(parsed)) {
-        throw new ValidationException_1.ValidationException(node.getLine(), "INVALID_INTEGER", `Integer not valid: ${raw}`);
+        throw new ValidationException_1.ValidationException(node.getLine(), "CARDINALITY_NOT_VALID", `Integer not valid: ${raw}`);
     }
     return parsed;
 }

package/out/schema/SchemaProviderMemory.d.ts

@@ -28,7 +28,8 @@ export declare class SchemaProviderMemory implements SchemaProvider {
      * own namespace.
      *
      * @param txt text of the `@stxt.schema` document.
-     * @throws ParseException or ValidationException if the document is not a valid schema.
+     * @throws ParseException or ValidationException if the document is not a valid schema; in
+     *         particular `SCHEMA_MULTIPLE_ROOTS` if it does not hold exactly one root node.
      */
     addSchema(txt: string): void;
     /** Removes every schema registered in this provider (the parent one is left untouched). */

package/out/schema/SchemaProviderMemory.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SchemaProviderMemory = void 0;
 const Parser_1 = require("../core/Parser");
 const StringUtils_1 = require("../core/StringUtils");
+const ValidationException_1 = require("../exceptions/ValidationException");
 const SchemaParser_1 = require("./SchemaParser");
 const SchemaProviderMeta_1 = require("./SchemaProviderMeta");
 const SchemaValidator_1 = require("./SchemaValidator");
@@ -47,11 +48,16 @@ class SchemaProviderMemory {
      * own namespace.
      *
      * @param txt text of the `@stxt.schema` document.
-     * @throws ParseException or ValidationException if the document is not a valid schema.
+     * @throws ParseException or ValidationException if the document is not a valid schema; in
+     *         particular `SCHEMA_MULTIPLE_ROOTS` if it does not hold exactly one root node.
      */
     addSchema(txt) {
         const parser = new Parser_1.Parser();
-        const node = parser.parse(txt)[0];
+        const nodes = parser.parse(txt);
+        if (nodes.length !== 1) {
+            throw new ValidationException_1.ValidationException(0, "SCHEMA_MULTIPLE_ROOTS", `A schema document must hold exactly 1 root node, got ${nodes.length}`);
+        }
+        const node = nodes[0];
         // A schema that does not validate against its meta-schema must not be
         // registered (same policy as UnifiedSchemaProvider/DiscoveryResolver)
         const schemaValidator = new SchemaValidator_1.SchemaValidator(new SchemaProviderMeta_1.SchemaProviderMeta(), true);

package/out/schema/SchemaValidator.js

@@ -65,7 +65,7 @@ class SchemaValidator {
         const schemaNode = schema.getNodeDefinition(node.getCanonicalName());
         if (!schemaNode) {
             const error = `NOT EXIST NODE ${node.getCanonicalName()} for namespace ${schema.getNamespace()}`;
-            errors.push(new ValidationException_1.ValidationException(node.getLine(), "NODE_NOT_EXIST_IN_SCHEMA", error));
+            errors.push(new ValidationException_1.ValidationException(node.getLine(), "NODE_NOT_DEFINED_IN_SCHEMA", error));
             return errors;
         }
         errors.push(...SchemaValidator.validateValue(schemaNode, node));
@@ -93,7 +93,7 @@ class SchemaValidator {
         const nodeType = nodeDef.getType();
         const validator = TypeRegistry_1.TypeRegistry.get(nodeType);
         if (!validator) {
-            errors.push(new ValidationException_1.ValidationException(node.getLine(), "TYPE_NOT_SUPPORTED", `Node type not supported: ${nodeType}`));
+            errors.push(new ValidationException_1.ValidationException(node.getLine(), "TYPE_NOT_VALID", `Node type not supported: ${nodeType}`));
             return errors;
         }
         try {
@@ -104,10 +104,10 @@ class SchemaValidator {
                 errors.push(e);
             }
             else if (e instanceof Error) {
-                errors.push(new ValidationException_1.ValidationException(node.getLine(), "VALIDATION_ERROR", e.message));
+                errors.push(new ValidationException_1.ValidationException(node.getLine(), "UNEXPECTED_ERROR", e.message));
             }
             else {
-                errors.push(new ValidationException_1.ValidationException(node.getLine(), "UNKNOWN_VALIDATION_ERROR", String(e)));
+                errors.push(new ValidationException_1.ValidationException(node.getLine(), "UNEXPECTED_ERROR", String(e)));
             }
         }
         return errors;
@@ -135,14 +135,14 @@ class SchemaValidator {
         const min = childDef.getMin(); // number | null
         const max = childDef.getMax(); // number | null
         if (min !== null && childCount < min) {
-            errors.push(new ValidationException_1.ValidationException(node.getLine(), "INVALID_NUMBER", `${childCount} nodes of '${childDef.getQualifiedName()}' and min is ${min}`));
+            errors.push(new ValidationException_1.ValidationException(node.getLine(), "TOO_FEW_CHILDREN", `${childCount} nodes of '${childDef.getQualifiedName()}' and min is ${min}`));
         }
         if (max !== null && childCount > max) {
             // Error on the parent
-            errors.push(new ValidationException_1.ValidationException(node.getLine(), "INVALID_NUMBER", `${childCount} nodes of '${childDef.getQualifiedName()}' and max is ${max}`));
+            errors.push(new ValidationException_1.ValidationException(node.getLine(), "TOO_MANY_CHILDREN", `${childCount} nodes of '${childDef.getQualifiedName()}' and max is ${max}`));
             // Error on each child node beyond the allowed maximum
             for (const child of children) {
-                errors.push(new ValidationException_1.ValidationException(child.getLine(), "INVALID_NUMBER", `Too many '${childDef.getQualifiedName()}' nodes: found ${childCount}, max is ${max}`));
+                errors.push(new ValidationException_1.ValidationException(child.getLine(), "TOO_MANY_CHILDREN", `Too many '${childDef.getQualifiedName()}' nodes: found ${childCount}, max is ${max}`));
             }
         }
         return errors;

package/out/schema/TypeRegistry.js

@@ -47,7 +47,7 @@ class TypeRegistry {
     static register(instance) {
         const name = instance.getName();
         if (this.REGISTRY.has(name)) {
-            throw new RuntimeException_1.RuntimeException("DUPLICATED_TYPE", `Type already defined: ${name}`);
+            throw new RuntimeException_1.RuntimeException("TYPE_DUPLICATED", `Type already defined: ${name}`);
         }
         this.REGISTRY.set(name, instance);
     }

package/out/schema/type/BASE64.d.ts

@@ -1,3 +1,12 @@
 import { Type } from "../Type";
+/**
+ * STXT-SCHEMA-SPEC 9.5: standard Base64 (not URL-safe), padding optional, no leftover bits,
+ * never empty. The check is a regular expression plus the leftover-bits rule, never the
+ * platform decoder, which silently ignores characters outside the alphabet.
+ *
+ * @param value value already stripped of blanks.
+ * @returns whether it is valid Base64.
+ */
+export declare function isValidBase64(value: string): boolean;
 /** `BASE64` type: checks that the content is valid Base64. */
 export declare const BASE64: Type;

package/out/schema/type/BASE64.js

@@ -1,29 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BASE64 = void 0;
+exports.isValidBase64 = isValidBase64;
 const ValidationException_1 = require("../../exceptions/ValidationException");
 const binaryValue_1 = require("./binaryValue");
+/** Standard alphabet of RFC 4648 section 4, used to check the leftover bits of the last character. */
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/**
+ * Shape of a Base64 value (STXT-SCHEMA-SPEC 9.5): groups of four characters of the standard
+ * alphabet, with an optional final group of two or three characters whose `=` padding may be
+ * omitted. The empty string matches here and is rejected separately.
+ */
+const SHAPE = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}(?:==)?|[A-Za-z0-9+/]{3}=?)?$/;
+/**
+ * STXT-SCHEMA-SPEC 9.5: standard Base64 (not URL-safe), padding optional, no leftover bits,
+ * never empty. The check is a regular expression plus the leftover-bits rule, never the
+ * platform decoder, which silently ignores characters outside the alphabet.
+ *
+ * @param value value already stripped of blanks.
+ * @returns whether it is valid Base64.
+ */
+function isValidBase64(value) {
+    if (value.length === 0 || !SHAPE.test(value)) {
+        return false;
+    }
+    const data = value.replace(/=+$/, "");
+    const rest = data.length % 4;
+    if (rest === 0) {
+        return true;
+    }
+    // The last character encodes 6 bits; with 2 characters 4 of them are leftover, with 3, 2 of them.
+    const last = ALPHABET.indexOf(data.charAt(data.length - 1));
+    const mask = rest === 2 ? 0x0f : 0x03;
+    return (last & mask) === 0;
+}
 /** `BASE64` type: checks that the content is valid Base64. */
 exports.BASE64 = {
     getName() {
         return "BASE64";
     },
     validate(ndef, n) {
-        const raw = (0, binaryValue_1.binaryValue)(n);
-        try {
-            // Try to decode it
-            const buf = Buffer.from(raw, "base64");
-            // Re-encode to check consistency
-            // (this keeps partially valid strings out)
-            const reencoded = buf.toString("base64");
-            // Normalize the padding before comparing
-            const normalizedInput = raw.replace(/=+$/, "");
-            const normalizedReencoded = reencoded.replace(/=+$/, "");
-            if (normalizedInput !== normalizedReencoded) {
-                throw new ValidationException_1.ValidationException(n.getLine(), "INVALID_VALUE", `Node '${n.getName()}' Invalid Base64`);
-            }
-        }
-        catch {
+        if (!isValidBase64((0, binaryValue_1.binaryValue)(n))) {
             throw new ValidationException_1.ValidationException(n.getLine(), "INVALID_VALUE", `Node '${n.getName()}' Invalid Base64`);
         }
     },

package/out/schema/type/DATE.d.ts

@@ -1,2 +1,2 @@
-/** `DATE` type: checks the `YYYY-MM-DD` format. */
+/** `DATE` type: `YYYY-MM-DD`, an existing date of the proleptic Gregorian calendar (STXT-SCHEMA-SPEC 9.4). */
 export declare const DATE: import("../Type").Type;

package/out/schema/type/DATE.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DATE = void 0;
-const regexType_1 = require("./regexType");
-/** `DATE` type: checks the `YYYY-MM-DD` format. */
-exports.DATE = (0, regexType_1.regexType)("DATE", /^\d{4}-\d{2}-\d{2}$/, "Invalid date");
+const rangeType_1 = require("./rangeType");
+const dateTime_1 = require("./dateTime");
+/** `DATE` type: `YYYY-MM-DD`, an existing date of the proleptic Gregorian calendar (STXT-SCHEMA-SPEC 9.4). */
+exports.DATE = (0, rangeType_1.rangeType)("DATE", /^(\d{4})-(\d{2})-(\d{2})$/, m => (0, dateTime_1.isValidDate)(Number(m[1]), Number(m[2]), Number(m[3])), "Invalid date");
 //# sourceMappingURL=DATE.js.map