@longsightgroup/qti3-core 0.11.0 → 0.12.1

package/dist/test-expression-parser.js

@@ -0,0 +1,76 @@
+import { assertNever } from "./assert-never.js";
+import { coerceValue } from "./parser-values.js";
+import { isTestBaseType, testExpressionSyntax } from "./test-expression.js";
+import { checkTestXml, rejectTestXml } from "./test-xml.js";
+import { textContent } from "./xml.js";
+/** Read the single expression owned by a branch or outcome assignment. */
+export function parseTestExpressionChild(node, diagnostics) {
+    const first = node.children[0];
+    if (node.children.length !== 1 || !first) {
+        rejectTestXml(node, diagnostics);
+        return undefined;
+    }
+    return parseTestExpression(first, diagnostics);
+}
+function parseTestExpression(node, diagnostics) {
+    const syntax = testExpressionSyntax.find((entry) => entry.name === node.localName);
+    if (!syntax) {
+        rejectTestXml(node, diagnostics);
+        return undefined;
+    }
+    checkTestXml(node, testExpressionSyntax.map((entry) => entry.name), syntax.attributes, diagnostics, syntax.type === "baseValue");
+    const arityValid = syntax.arity === "oneOrMore" ? node.children.length > 0 : node.children.length === syntax.arity;
+    if (!arityValid) {
+        rejectTestXml(node, diagnostics);
+        return undefined;
+    }
+    const expressions = [];
+    for (const child of node.children) {
+        const parsed = parseTestExpression(child, diagnostics);
+        if (!parsed)
+            return undefined;
+        expressions.push(parsed);
+    }
+    const source = node.source;
+    switch (syntax.type) {
+        case "baseValue": {
+            const baseType = node.attributes["base-type"];
+            if (!isTestBaseType(baseType)) {
+                rejectTestXml(node, diagnostics);
+                return undefined;
+            }
+            return {
+                type: "baseValue",
+                baseType,
+                value: coerceValue(textContent(node), baseType),
+                source,
+            };
+        }
+        case "variable":
+            return { type: "variable", identifier: node.attributes.identifier ?? "", source };
+        case "testVariables":
+            return {
+                type: "testVariables",
+                variableIdentifier: node.attributes["variable-identifier"] ?? "",
+                includeCategory: node.attributes["include-category"],
+                source,
+            };
+        case "sum":
+        case "and":
+        case "or":
+            return { type: syntax.type, expressions, source };
+        case "numericCompare": {
+            const [left, right] = expressions;
+            if (!left || !right)
+                return undefined;
+            return { type: "numericCompare", operator: syntax.operator, left, right, source };
+        }
+        case "not": {
+            const expression = expressions[0];
+            return expression ? { type: "not", expression, source } : undefined;
+        }
+        default:
+            return assertNever(syntax);
+    }
+}
+//# sourceMappingURL=test-expression-parser.js.map

package/dist/test-expression-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-expression-parser.js","sourceRoot":"","sources":["../src/test-expression-parser.ts"],"names":[],"mappings":"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"}

package/dist/test-expression-serializer.d.ts

@@ -0,0 +1,5 @@
+import { type QtiTestExpression } from "./test-expression.js";
+import { type QtiTestResult } from "./test-model.js";
+/** Serialize the closed test expression language without involving item processing. */
+export declare function serializeTestExpression(expression: QtiTestExpression): QtiTestResult<string>;
+//# sourceMappingURL=test-expression-serializer.d.ts.map

package/dist/test-expression-serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-expression-serializer.d.ts","sourceRoot":"","sources":["../src/test-expression-serializer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AACpF,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGlE,uFAAuF;AACvF,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,iBAAiB,GAAG,aAAa,CAAC,MAAM,CAAC,CAG5F"}

package/dist/test-expression-serializer.js

@@ -0,0 +1,54 @@
+import { assertNever } from "./assert-never.js";
+import { renderElement } from "./serializer-processing-xml.js";
+import { testExpressionSyntax } from "./test-expression.js";
+import { testFailure } from "./test-model.js";
+import { escapeXmlText } from "./xml.js";
+/** Serialize the closed test expression language without involving item processing. */
+export function serializeTestExpression(expression) {
+    const result = serializeExpression(expression, 0);
+    return result.ok ? { ok: true, value: result.value.join("\n") } : result;
+}
+function serializeExpression(expression, indent) {
+    const syntax = testExpressionSyntax.find((entry) => entry.type === expression.type &&
+        (expression.type !== "numericCompare" ||
+            (entry.type === "numericCompare" && entry.operator === expression.operator)));
+    if (!syntax)
+        return testFailure("expression.unsupported", "Cannot serialize an unsupported test expression.");
+    const attributes = [];
+    let children = [];
+    switch (expression.type) {
+        case "baseValue":
+            return {
+                ok: true,
+                value: renderElement(syntax.name, [["base-type", expression.baseType]], escapeXmlText(String(expression.value)), indent),
+            };
+        case "variable":
+            attributes.push(["identifier", expression.identifier]);
+            break;
+        case "testVariables":
+            attributes.push(["variable-identifier", expression.variableIdentifier], ["include-category", expression.includeCategory]);
+            break;
+        case "sum":
+        case "and":
+        case "or":
+            children = expression.expressions;
+            break;
+        case "numericCompare":
+            children = [expression.left, expression.right];
+            break;
+        case "not":
+            children = [expression.expression];
+            break;
+        default:
+            return assertNever(expression);
+    }
+    const content = [];
+    for (const child of children) {
+        const result = serializeExpression(child, indent + 1);
+        if (!result.ok)
+            return result;
+        content.push(...result.value);
+    }
+    return { ok: true, value: renderElement(syntax.name, attributes, content, indent) };
+}
+//# sourceMappingURL=test-expression-serializer.js.map

package/dist/test-expression-serializer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-expression-serializer.js","sourceRoot":"","sources":["../src/test-expression-serializer.ts"],"names":[],"mappings":"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"}

package/dist/test-expression-validation.d.ts

@@ -0,0 +1,14 @@
+import { type QtiTestBaseType, type QtiTestExpression } from "./test-expression.js";
+import type { QtiDiagnostic, QtiOutcomeDeclaration, QtiValue } from "./types.js";
+/** The declared QTI type of an expression, including its cardinality. */
+export interface TestExpressionType {
+    readonly baseType: QtiTestBaseType;
+    readonly cardinality: "single" | "multiple";
+}
+/** Check scalar literals and defaults against the supported base types. */
+export declare function isTestScalarValue(baseType: string | undefined, value: QtiValue): boolean;
+/** Infer a test expression's QTI type and diagnose invalid operands and scope. */
+export declare function checkTestExpression(expression: QtiTestExpression, declarations: ReadonlyMap<string, QtiOutcomeDeclaration>, categories: ReadonlySet<string>, scope: "outcome" | "branch", diagnostics: QtiDiagnostic[]): TestExpressionType | undefined;
+/** Whether a branch expression has the required single boolean type. */
+export declare function isBoolean(type: TestExpressionType | undefined): boolean;
+//# sourceMappingURL=test-expression-validation.d.ts.map

package/dist/test-expression-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-expression-validation.d.ts","sourceRoot":"","sources":["../src/test-expression-validation.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEjF,yEAAyE;AACzE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,WAAW,EAAE,QAAQ,GAAG,UAAU,CAAC;CAC7C;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,QAAQ,GAAG,OAAO,CAexF;AAED,kFAAkF;AAClF,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,iBAAiB,EAC7B,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,qBAAqB,CAAC,EACxD,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,EAC/B,KAAK,EAAE,SAAS,GAAG,QAAQ,EAC3B,WAAW,EAAE,aAAa,EAAE,GAC3B,kBAAkB,GAAG,SAAS,CAyFhC;AAMD,wEAAwE;AACxE,wBAAgB,SAAS,CAAC,IAAI,EAAE,kBAAkB,GAAG,SAAS,GAAG,OAAO,CAEvE"}

package/dist/test-expression-validation.js

@@ -0,0 +1,101 @@
+import { assertNever } from "./assert-never.js";
+import { isTestBaseType, testExpressionSyntax, } from "./test-expression.js";
+/** Check scalar literals and defaults against the supported base types. */
+export function isTestScalarValue(baseType, value) {
+    if (baseType === undefined)
+        return false;
+    switch (baseType) {
+        case "integer":
+            return typeof value === "number" && Number.isSafeInteger(value);
+        case "float":
+            return typeof value === "number" && Number.isFinite(value);
+        case "boolean":
+            return typeof value === "boolean";
+        case "string":
+        case "identifier":
+            return typeof value === "string";
+        default:
+            return false;
+    }
+}
+/** Infer a test expression's QTI type and diagnose invalid operands and scope. */
+export function checkTestExpression(expression, declarations, categories, scope, diagnostics) {
+    const reject = (code, message) => {
+        diagnostics.push({
+            code: `test.${code}`,
+            severity: "error",
+            message,
+            source: expression.source,
+        });
+    };
+    const check = (child) => checkTestExpression(child, declarations, categories, scope, diagnostics);
+    if (!testExpressionSyntax.some((syntax) => syntax.type === expression.type)) {
+        reject("expression.unsupported", "Expression is outside the supported test execution profile.");
+        return undefined;
+    }
+    switch (expression.type) {
+        case "baseValue":
+            if (!isTestScalarValue(expression.baseType, expression.value)) {
+                reject("expression.value", "Expression values must match a supported scalar base type.");
+                return undefined;
+            }
+            return { baseType: expression.baseType, cardinality: "single" };
+        case "variable": {
+            const declaration = declarations.get(expression.identifier);
+            if (!declaration || !isTestBaseType(declaration.baseType)) {
+                reject("expression.variable", "Test expression references an undeclared or unsupported outcome.");
+                return undefined;
+            }
+            return { baseType: declaration.baseType, cardinality: "single" };
+        }
+        case "testVariables":
+            if (scope === "branch")
+                reject("branch.scope", "Test-variable aggregation belongs in outcome processing, not a branch rule.");
+            if (expression.variableIdentifier !== "SCORE" ||
+                (expression.includeCategory !== undefined && !categories.has(expression.includeCategory)))
+                reject("expression.testVariables", "This test profile aggregates item SCORE values from declared categories.");
+            return { baseType: "float", cardinality: "multiple" };
+        case "sum": {
+            const operands = expression.expressions.map(check);
+            if (!operands.length || operands.some((type) => !isNumeric(type)))
+                reject("expression.sum", "Test sums require numeric operands.");
+            return {
+                baseType: operands.every((type) => type?.baseType === "integer") ? "integer" : "float",
+                cardinality: "single",
+            };
+        }
+        case "numericCompare": {
+            const left = check(expression.left);
+            const right = check(expression.right);
+            if (!testExpressionSyntax.some((syntax) => syntax.type === "numericCompare" && syntax.operator === expression.operator))
+                reject("expression.compare", "Unsupported test comparison operator.");
+            if (!isNumeric(left) ||
+                left?.cardinality !== "single" ||
+                !isNumeric(right) ||
+                right?.cardinality !== "single")
+                reject("expression.compare", "Test comparisons require two scalar numbers.");
+            return { baseType: "boolean", cardinality: "single" };
+        }
+        case "and":
+        case "or": {
+            const operands = expression.expressions.map(check);
+            if (!operands.length || operands.some((type) => !isBoolean(type)))
+                reject("expression.boolean", "Test logic requires boolean operands.");
+            return { baseType: "boolean", cardinality: "single" };
+        }
+        case "not":
+            if (!isBoolean(check(expression.expression)))
+                reject("expression.boolean", "Test logic requires a boolean operand.");
+            return { baseType: "boolean", cardinality: "single" };
+        default:
+            return assertNever(expression);
+    }
+}
+function isNumeric(type) {
+    return type?.baseType === "integer" || type?.baseType === "float";
+}
+/** Whether a branch expression has the required single boolean type. */
+export function isBoolean(type) {
+    return type?.baseType === "boolean" && type.cardinality === "single";
+}
+//# sourceMappingURL=test-expression-validation.js.map

package/dist/test-expression-validation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-expression-validation.js","sourceRoot":"","sources":["../src/test-expression-validation.ts"],"names":[],"mappings":"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"}

package/dist/test-expression.d.ts

@@ -0,0 +1,99 @@
+import type { QtiSourceLocation } from "./types.js";
+/** Scalar types supported by deterministic test outcome processing. */
+export type QtiTestBaseType = "integer" | "float" | "boolean" | "string" | "identifier";
+/** Test expressions form a closed language, independent of item processing. */
+export type QtiTestExpression = ({
+    readonly type: "baseValue";
+    readonly baseType: QtiTestBaseType;
+    readonly value: number | boolean | string;
+} | {
+    readonly type: "variable";
+    readonly identifier: string;
+} | {
+    readonly type: "testVariables";
+    readonly variableIdentifier: string;
+    readonly includeCategory?: string | undefined;
+} | {
+    readonly type: "sum";
+    readonly expressions: readonly QtiTestExpression[];
+} | {
+    readonly type: "and";
+    readonly expressions: readonly QtiTestExpression[];
+} | {
+    readonly type: "or";
+    readonly expressions: readonly QtiTestExpression[];
+} | {
+    readonly type: "numericCompare";
+    readonly operator: "gt" | "gte" | "lt" | "lte";
+    readonly left: QtiTestExpression;
+    readonly right: QtiTestExpression;
+} | {
+    readonly type: "not";
+    readonly expression: QtiTestExpression;
+}) & {
+    readonly source?: QtiSourceLocation | undefined;
+};
+/** XML names, AST variants, arities and attributes owned by the test language. */
+export declare const testExpressionSyntax: readonly [{
+    readonly name: "qti-base-value";
+    readonly type: "baseValue";
+    readonly arity: 0;
+    readonly attributes: readonly ["base-type"];
+}, {
+    readonly name: "qti-variable";
+    readonly type: "variable";
+    readonly arity: 0;
+    readonly attributes: readonly ["identifier"];
+}, {
+    readonly name: "qti-test-variables";
+    readonly type: "testVariables";
+    readonly arity: 0;
+    readonly attributes: readonly ["variable-identifier", "include-category"];
+}, {
+    readonly name: "qti-sum";
+    readonly type: "sum";
+    readonly arity: "oneOrMore";
+    readonly attributes: readonly [];
+}, {
+    readonly name: "qti-gt";
+    readonly type: "numericCompare";
+    readonly operator: "gt";
+    readonly arity: 2;
+    readonly attributes: readonly [];
+}, {
+    readonly name: "qti-gte";
+    readonly type: "numericCompare";
+    readonly operator: "gte";
+    readonly arity: 2;
+    readonly attributes: readonly [];
+}, {
+    readonly name: "qti-lt";
+    readonly type: "numericCompare";
+    readonly operator: "lt";
+    readonly arity: 2;
+    readonly attributes: readonly [];
+}, {
+    readonly name: "qti-lte";
+    readonly type: "numericCompare";
+    readonly operator: "lte";
+    readonly arity: 2;
+    readonly attributes: readonly [];
+}, {
+    readonly name: "qti-and";
+    readonly type: "and";
+    readonly arity: "oneOrMore";
+    readonly attributes: readonly [];
+}, {
+    readonly name: "qti-or";
+    readonly type: "or";
+    readonly arity: "oneOrMore";
+    readonly attributes: readonly [];
+}, {
+    readonly name: "qti-not";
+    readonly type: "not";
+    readonly arity: 1;
+    readonly attributes: readonly [];
+}];
+/** Refine a supported test scalar type without accepting item-only base types. */
+export declare function isTestBaseType(value: string | undefined): value is QtiTestBaseType;
+//# sourceMappingURL=test-expression.d.ts.map

package/dist/test-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-expression.d.ts","sourceRoot":"","sources":["../src/test-expression.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD,uEAAuE;AACvE,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,YAAY,CAAC;AAExF,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG,CAC5B;IACE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC;CAC3C,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC1D;IACE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/C,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAA;CAAE,GAC5E;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,iBAAiB,EAAE,CAAA;CAAE,GAC3E;IACE,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;IAC/C,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;CACnC,GACD;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAA;CAAE,CACnE,GAAG;IAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAA;CAAE,CAAC;AAExD,kFAAkF;AAClF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuB9B,CAAC;AAEJ,kFAAkF;AAClF,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,KAAK,IAAI,eAAe,CAQlF"}

package/dist/test-expression.js

@@ -0,0 +1,28 @@
+/** XML names, AST variants, arities and attributes owned by the test language. */
+export const testExpressionSyntax = [
+    { name: "qti-base-value", type: "baseValue", arity: 0, attributes: ["base-type"] },
+    { name: "qti-variable", type: "variable", arity: 0, attributes: ["identifier"] },
+    {
+        name: "qti-test-variables",
+        type: "testVariables",
+        arity: 0,
+        attributes: ["variable-identifier", "include-category"],
+    },
+    { name: "qti-sum", type: "sum", arity: "oneOrMore", attributes: [] },
+    { name: "qti-gt", type: "numericCompare", operator: "gt", arity: 2, attributes: [] },
+    { name: "qti-gte", type: "numericCompare", operator: "gte", arity: 2, attributes: [] },
+    { name: "qti-lt", type: "numericCompare", operator: "lt", arity: 2, attributes: [] },
+    { name: "qti-lte", type: "numericCompare", operator: "lte", arity: 2, attributes: [] },
+    { name: "qti-and", type: "and", arity: "oneOrMore", attributes: [] },
+    { name: "qti-or", type: "or", arity: "oneOrMore", attributes: [] },
+    { name: "qti-not", type: "not", arity: 1, attributes: [] },
+];
+/** Refine a supported test scalar type without accepting item-only base types. */
+export function isTestBaseType(value) {
+    return (value === "integer" ||
+        value === "float" ||
+        value === "boolean" ||
+        value === "string" ||
+        value === "identifier");
+}
+//# sourceMappingURL=test-expression.js.map

package/dist/test-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-expression.js","sourceRoot":"","sources":["../src/test-expression.ts"],"names":[],"mappings":"AA8BA,kFAAkF;AAClF,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,WAAW,CAAC,EAAE;IAClF,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,YAAY,CAAC,EAAE;IAChF;QACE,IAAI,EAAE,oBAAoB;QAC1B,IAAI,EAAE,eAAe;QACrB,KAAK,EAAE,CAAC;QACR,UAAU,EAAE,CAAC,qBAAqB,EAAE,kBAAkB,CAAC;KACxD;IACD,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,EAAE;IACpE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;IACpF,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;IACtF,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;IACpF,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;IACtF,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,EAAE;IACpE,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,EAAE,EAAE;IAClE,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE;CAOzD,CAAC;AAEJ,kFAAkF;AAClF,MAAM,UAAU,cAAc,CAAC,KAAyB;IACtD,OAAO,CACL,KAAK,KAAK,SAAS;QACnB,KAAK,KAAK,OAAO;QACjB,KAAK,KAAK,SAAS;QACnB,KAAK,KAAK,QAAQ;QAClB,KAAK,KAAK,YAAY,CACvB,CAAC;AACJ,CAAC"}

package/dist/test-model.d.ts

@@ -0,0 +1,62 @@
+import type { QtiDiagnostic, QtiOutcomeDeclaration } from "./types.js";
+import type { QtiTestBaseType, QtiTestExpression } from "./test-expression.js";
+/** An ordered branch evaluated after the section's final item submission. */
+export interface QtiTestBranch {
+    readonly target: string;
+    readonly expression: QtiTestExpression;
+}
+/** A fixed item reference; categories participate in test-variable aggregation. */
+export interface QtiTestItemRef {
+    readonly identifier: string;
+    readonly href: string;
+    readonly categories: readonly string[];
+}
+/** A flat section in the supported linear, individually submitted test profile. */
+export interface QtiTestSection {
+    readonly identifier: string;
+    readonly title: string;
+    readonly items: readonly QtiTestItemRef[];
+    readonly branches: readonly QtiTestBranch[];
+}
+/** Framework-neutral QTI test definition. Validation establishes executable support. */
+export interface QtiTestDefinition {
+    readonly identifier: string;
+    readonly title: string;
+    readonly partIdentifier: string;
+    readonly sections: readonly QtiTestSection[];
+    readonly outcomeDeclarations: readonly QtiOutcomeDeclaration[];
+    readonly outcomeProcessing: readonly QtiTestOutcomeRule[];
+}
+/** Sequential assignment of a test expression to a declared test outcome. */
+export interface QtiTestOutcomeRule {
+    readonly type: "setOutcomeValue";
+    readonly identifier: string;
+    readonly expression: QtiTestExpression;
+}
+type ExecutableSection = QtiTestSection & {
+    readonly items: readonly [QtiTestItemRef, ...QtiTestItemRef[]];
+};
+type ExecutableOutcome = Readonly<QtiOutcomeDeclaration> & {
+    readonly cardinality: "single";
+    readonly baseType: QtiTestBaseType;
+    readonly defaultValue: number | boolean | string | null;
+};
+declare const executableTest: unique symbol;
+/** A test checked for supported expressions, unique identifiers and forward routing. */
+export type QtiExecutableTest = Omit<QtiTestDefinition, "sections" | "outcomeDeclarations"> & {
+    readonly [executableTest]: true;
+    readonly sections: readonly [ExecutableSection, ...ExecutableSection[]];
+    readonly outcomeDeclarations: readonly ExecutableOutcome[];
+};
+/** Typed failure channel shared by test construction, parsing and transitions. */
+export type QtiTestResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly diagnostics: readonly QtiDiagnostic[];
+};
+/** Construct a safe test diagnostic without including submitted content. */
+export declare function testFailure(code: string, message: string): QtiTestResult<never>;
+export {};
+//# sourceMappingURL=test-model.d.ts.map

package/dist/test-model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-model.d.ts","sourceRoot":"","sources":["../src/test-model.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAE/E,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;CACxC;AAED,mFAAmF;AACnF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAED,mFAAmF;AACnF,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,SAAS,cAAc,EAAE,CAAC;IAC1C,QAAQ,CAAC,QAAQ,EAAE,SAAS,aAAa,EAAE,CAAC;CAC7C;AAED,wFAAwF;AACxF,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;IAC7C,QAAQ,CAAC,mBAAmB,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC/D,QAAQ,CAAC,iBAAiB,EAAE,SAAS,kBAAkB,EAAE,CAAC;CAC3D;AAED,6EAA6E;AAC7E,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;CACxC;AAED,KAAK,iBAAiB,GAAG,cAAc,GAAG;IACxC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,cAAc,EAAE,GAAG,cAAc,EAAE,CAAC,CAAC;CAChE,CAAC;AACF,KAAK,iBAAiB,GAAG,QAAQ,CAAC,qBAAqB,CAAC,GAAG;IACzD,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,CAAC;CACzD,CAAC;AAEF,OAAO,CAAC,MAAM,cAAc,EAAE,OAAO,MAAM,CAAC;AAE5C,wFAAwF;AACxF,MAAM,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,EAAE,UAAU,GAAG,qBAAqB,CAAC,GAAG;IAC5F,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;IAChC,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,iBAAiB,EAAE,GAAG,iBAAiB,EAAE,CAAC,CAAC;IACxE,QAAQ,CAAC,mBAAmB,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC5D,CAAC;AAEF,kFAAkF;AAClF,MAAM,MAAM,aAAa,CAAC,CAAC,IACvB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACxC;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,aAAa,EAAE,CAAA;CAAE,CAAC;AAE3E,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,aAAa,CAAC,KAAK,CAAC,CAE/E"}

package/dist/test-model.js

@@ -0,0 +1,5 @@
+/** Construct a safe test diagnostic without including submitted content. */
+export function testFailure(code, message) {
+    return { ok: false, diagnostics: [{ code: `test.${code}`, severity: "error", message }] };
+}
+//# sourceMappingURL=test-model.js.map

package/dist/test-model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-model.js","sourceRoot":"","sources":["../src/test-model.ts"],"names":[],"mappings":"AAgEA,4EAA4E;AAC5E,MAAM,UAAU,WAAW,CAAC,IAAY,EAAE,OAAe;IACvD,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,IAAI,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;AAC5F,CAAC"}

package/dist/test-parser.d.ts

@@ -0,0 +1,13 @@
+import { type QtiExecutableTest, type QtiTestResult } from "./test-model.js";
+/** Whether a test requires runtime selection rather than ordinary fixed navigation. */
+export type QtiTestExecution = {
+    readonly kind: "fixed";
+} | {
+    readonly kind: "sequenced";
+    readonly test: QtiExecutableTest;
+};
+/** Classify sequencing on the parsed tree and reject unsupported executable routes. */
+export declare function parseQtiTestExecution(xml: string): QtiTestResult<QtiTestExecution>;
+/** Parse the supported executable test profile; never silently ignore routing features. */
+export declare function parseQtiTest(xml: string): QtiTestResult<QtiExecutableTest>;
+//# sourceMappingURL=test-parser.d.ts.map

package/dist/test-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-parser.d.ts","sourceRoot":"","sources":["../src/test-parser.ts"],"names":[],"mappings":"AAOA,OAAO,EAEL,KAAK,iBAAiB,EAGtB,KAAK,aAAa,EAEnB,MAAM,iBAAiB,CAAC;AAGzB,uFAAuF;AACvF,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,CAAC;AAErE,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAC,gBAAgB,CAAC,CAMlF;AAED,2FAA2F;AAC3F,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,aAAa,CAAC,iBAAiB,CAAC,CAG1E"}