@longsightgroup/qti3-core 0.9.2 → 0.9.4

package/src/shared-vocabulary-coverage-policy.ts

@@ -48,7 +48,7 @@ export function findSharedVocabularyCoverageViolations(input: {
     supportByClass.set(entry.className, existing);
   }
 
-  const gatedSupportClasses = [...supportByClass.keys()].sort();
+  const gatedSupportClasses = [...supportByClass.keys()].toSorted();
   if (gatedSupportClasses.length === 0) {
     violations.push({ message: "expected at least one enforced shared vocabulary class" });
   }

package/src/shared-vocabulary-generated-families.ts

@@ -122,7 +122,7 @@ function escapeRegExp(value: string): string {
 
 function alternationPattern(values: readonly string[]): string {
   return [...values]
-    .sort((left, right) => right.length - left.length)
+    .toSorted((left, right) => right.length - left.length)
     .map(escapeRegExp)
     .join("|");
 }

package/src/shared-vocabulary-support.ts

@@ -52,7 +52,7 @@ const graphicBrowserTests = [
   "tests/browser/player-graphic.spec.ts",
   "tests/browser/player-graphic-gap-match.spec.ts",
 ];
-const mediaBrowserTests = ["tests/browser/player.spec.ts", ...sharedVocabularyMatrixTests];
+const mediaBrowserTests = ["tests/browser/player-media.spec.ts", ...sharedVocabularyMatrixTests];
 const mediaPlayerFixture =
   "packages/fixtures/packages/sv-matrix/items/media-controls-and-pause.xml";
 const interactionInputWidthFixtures = [
@@ -204,14 +204,14 @@ function registryAttributeSupportProfile(fieldId: string): {
         fixtures: [mediaPlayerFixture],
         tests: mediaBrowserTests,
         notes:
-          "Reflects authored pause-delay values on rendered media assets. Pause timer behavior is covered in tests/browser/player.spec.ts.",
+          "Reflects authored pause-delay values on rendered media assets. Pause timer behavior is covered in tests/browser/player-media.spec.ts.",
       };
     case "media-player-pause-duration":
       return {
         fixtures: [mediaPlayerFixture],
         tests: mediaBrowserTests,
         notes:
-          "Reflects authored pause-duration values on rendered media assets. Pause timer behavior is covered in tests/browser/player.spec.ts.",
+          "Reflects authored pause-duration values on rendered media assets. Pause timer behavior is covered in tests/browser/player-media.spec.ts.",
       };
     default:
       return {

package/src/shared-vocabulary.ts

@@ -73,9 +73,10 @@ export function firstMatchingSharedVocabularyClass<T extends string>(
   classNames: string[],
   tokens: readonly T[],
 ): T | undefined {
-  const tokenSet = new Set<string>(tokens);
   for (const className of classNames) {
-    if (tokenSet.has(className)) return className as T;
+    for (const token of tokens) {
+      if (token === className) return token;
+    }
   }
   return undefined;
 }

package/src/support-evidence.ts

@@ -0,0 +1,107 @@
+import type { QtiInteractionType } from "./types.js";
+
+const coreProcessingTest = "packages/core/src/core.test.ts";
+
+export const browserProcessingTests = ["tests/browser/player-processing.spec.ts"];
+export const browserFeedbackTests = ["tests/browser/player-feedback.spec.ts"];
+export const browserAdaptiveTests = ["tests/browser/player-adaptive.spec.ts"];
+export const browserBodyContentTests = ["tests/browser/player-body-content.spec.ts"];
+export const browserHarnessTests = ["tests/browser/player-harness.spec.ts"];
+export const browserMathmlTests = ["tests/browser/player-mathml.spec.ts"];
+export const browserKeyboardA11yTests = ["tests/browser/player-keyboard-a11y.spec.ts"];
+export const browserLifecycleTests = ["tests/browser/player-lifecycle.spec.ts"];
+
+const templateProcessingBrowserEvidence = [
+  ...browserProcessingTests,
+  ...browserBodyContentTests,
+  ...browserMathmlTests,
+];
+const responseProcessingBrowserEvidence = [
+  ...browserProcessingTests,
+  ...browserFeedbackTests,
+  ...browserAdaptiveTests,
+];
+const randomIntegerBrowserEvidence = browserProcessingTests;
+
+/** Browser evidence bundles keyed by parent processing constructs only. */
+export const processingBrowserEvidence = {
+  "qti-template-processing": templateProcessingBrowserEvidence,
+  "qti-response-processing": responseProcessingBrowserEvidence,
+  "qti-random-integer": randomIntegerBrowserEvidence,
+} as const satisfies Record<string, readonly string[]>;
+
+export type ProcessingBrowserEvidenceName = keyof typeof processingBrowserEvidence;
+
+export const interactionExtraFixtures: Partial<Record<QtiInteractionType, readonly string[]>> = {
+  extendedText: [
+    "packages/fixtures/packages/sv-matrix/items/extended-text-pattern-mask.xml",
+    "packages/fixtures/packages/sv-matrix/items/extended-text-xhtml.xml",
+  ],
+  textEntry: ["packages/fixtures/packages/sv-matrix/items/text-entry-pattern-mask-inline.xml"],
+};
+
+export function browserTestsFor(interactionType: QtiInteractionType): string[] {
+  const base = [
+    "packages/fixtures/src/fixtures.test.ts",
+    "packages/conformance/src/conformance.test.ts",
+    "packages/a11y/src/a11y.test.ts",
+    "tests/browser/player-interaction-sweep.spec.ts",
+  ];
+  const extras: Partial<Record<QtiInteractionType, string[]>> = {
+    associate: browserKeyboardA11yTests,
+    choice: ["tests/browser/player-choice.spec.ts", "tests/browser/player-dom-behavior.spec.ts"],
+    drawing: ["tests/browser/player-graphic.spec.ts"],
+    endAttempt: ["tests/browser/player-dom-behavior.spec.ts", ...browserKeyboardA11yTests],
+    extendedText: [
+      "tests/browser/player-dom-behavior.spec.ts",
+      "tests/browser/player-extended-text-xhtml.spec.ts",
+    ],
+    gapMatch: ["tests/browser/player-gap-match.spec.ts"],
+    graphicAssociate: ["tests/browser/player-graphic.spec.ts"],
+    graphicGapMatch: [
+      "tests/browser/player-graphic-gap-match.spec.ts",
+      "tests/browser/player-graphic.spec.ts",
+    ],
+    graphicOrder: ["tests/browser/player-graphic.spec.ts"],
+    hotspot: ["tests/browser/player-graphic.spec.ts"],
+    hottext: ["tests/browser/player-hottext.spec.ts", "tests/browser/player-dom-behavior.spec.ts"],
+    inlineChoice: ["tests/browser/player-inline-choice.spec.ts"],
+    match: ["tests/browser/player-match.spec.ts", "tests/browser/player-dom-behavior.spec.ts"],
+    media: ["tests/browser/player-media.spec.ts"],
+    order: [...browserKeyboardA11yTests, ...browserLifecycleTests],
+    portableCustom: ["tests/browser/player-portable-custom.spec.ts"],
+    positionObject: ["tests/browser/player-graphic.spec.ts", ...browserKeyboardA11yTests],
+    selectPoint: ["tests/browser/player-graphic.spec.ts"],
+    slider: browserKeyboardA11yTests,
+    textEntry: ["tests/browser/player-dom-behavior.spec.ts"],
+    upload: ["tests/browser/player-dom-behavior.spec.ts"],
+  };
+  return [...base, ...(extras[interactionType] ?? [])];
+}
+
+export function interactionSupportFixtures(interactionType: QtiInteractionType): string[] {
+  return [
+    `packages/fixtures/xml/${interactionType}-reference.xml`,
+    ...(interactionExtraFixtures[interactionType] ?? []),
+  ];
+}
+
+export function interactionSupportTests(interactionType: QtiInteractionType): string[] {
+  if (interactionType === "extendedText" || interactionType === "textEntry") {
+    return [...browserTestsFor(interactionType), "packages/core/src/pattern-mask.test.ts"];
+  }
+  return browserTestsFor(interactionType);
+}
+
+function isProcessingBrowserEvidenceName(
+  qtiName: string,
+): qtiName is ProcessingBrowserEvidenceName {
+  return Object.hasOwn(processingBrowserEvidence, qtiName);
+}
+
+export function processingSupportTests(qtiName: string): string[] {
+  if (!isProcessingBrowserEvidenceName(qtiName)) {
+    return [coreProcessingTest];
+  }
+  return [coreProcessingTest, ...processingBrowserEvidence[qtiName]];
+}

package/src/support.ts

@@ -8,6 +8,13 @@ import type {
   QtiProcessingElementSupport,
   QtiSourceLocation,
 } from "./types.js";
+import {
+  browserFeedbackTests,
+  browserHarnessTests,
+  interactionSupportFixtures,
+  interactionSupportTests,
+  processingBrowserEvidence,
+} from "./support-evidence.js";
 
 export const interactionSupport: QtiInteractionElementSupport[] = [
   entry("qti-associate-interaction", "associate"),
@@ -51,23 +58,36 @@ export const deprecatedInteractionSupport: QtiInteractionElementSupport[] = [
 ];
 
 export const processingSupport: QtiProcessingElementSupport[] = [
-  processingEntry("qti-template-processing", "packages/core/src/core.test.ts", [
-    "packages/fixtures/xml/template-processing-reference.xml",
-    "packages/fixtures/xml/template-content-reference.xml",
-  ]),
-  processingEntry("qti-response-processing", "packages/core/src/core.test.ts", [
-    "packages/fixtures/xml/mapping-processing-reference.xml",
-    "packages/fixtures/xml/generic-match-processing-reference.xml",
-    "packages/fixtures/xml/advanced-processing-reference.xml",
-    "packages/fixtures/xml/adaptive-feedback-reference.xml",
-  ]),
+  processingEntry(
+    "qti-template-processing",
+    "packages/core/src/core.test.ts",
+    [
+      "packages/fixtures/xml/template-processing-reference.xml",
+      "packages/fixtures/xml/random-integer-template-reference.xml",
+      "packages/fixtures/xml/template-content-reference.xml",
+    ],
+    [...processingBrowserEvidence["qti-template-processing"]],
+  ),
+  processingEntry(
+    "qti-response-processing",
+    "packages/core/src/core.test.ts",
+    [
+      "packages/fixtures/xml/mapping-processing-reference.xml",
+      "packages/fixtures/xml/generic-match-processing-reference.xml",
+      "packages/fixtures/xml/advanced-processing-reference.xml",
+      "packages/fixtures/xml/adaptive-feedback-reference.xml",
+    ],
+    [...processingBrowserEvidence["qti-response-processing"]],
+  ),
   processingEntry("qti-set-template-value", "packages/core/src/core.test.ts", [
     "packages/fixtures/xml/template-processing-reference.xml",
+    "packages/fixtures/xml/random-integer-template-reference.xml",
     "packages/fixtures/xml/template-content-reference.xml",
   ]),
   processingEntry("qti-set-default-value", "packages/core/src/core.test.ts"),
   processingEntry("qti-set-correct-response", "packages/core/src/core.test.ts", [
     "packages/fixtures/xml/template-processing-reference.xml",
+    "packages/fixtures/xml/random-integer-template-reference.xml",
   ]),
   processingEntry("qti-template-condition", "packages/core/src/core.test.ts"),
   processingEntry("qti-template-if", "packages/core/src/core.test.ts"),
@@ -119,11 +139,17 @@ export const processingSupport: QtiProcessingElementSupport[] = [
   processingEntry("qti-variable", "packages/core/src/core.test.ts", [
     "packages/fixtures/xml/generic-match-processing-reference.xml",
     "packages/fixtures/xml/template-processing-reference.xml",
+    "packages/fixtures/xml/random-integer-template-reference.xml",
     "packages/fixtures/xml/template-content-reference.xml",
     "packages/fixtures/xml/advanced-processing-reference.xml",
     "packages/fixtures/xml/adaptive-feedback-reference.xml",
   ]),
-  processingEntry("qti-random-integer", "packages/core/src/core.test.ts"),
+  processingEntry(
+    "qti-random-integer",
+    "packages/core/src/core.test.ts",
+    ["packages/fixtures/xml/random-integer-template-reference.xml"],
+    [...processingBrowserEvidence["qti-random-integer"]],
+  ),
   processingEntry("qti-random-float", "packages/core/src/core.test.ts"),
   processingEntry("qti-random", "packages/core/src/core.test.ts"),
   processingEntry("qti-multiple", "packages/core/src/core.test.ts", [
@@ -139,8 +165,11 @@ export const processingSupport: QtiProcessingElementSupport[] = [
   ]),
   processingEntry("qti-sum", "packages/core/src/core.test.ts", [
     "packages/fixtures/xml/template-processing-reference.xml",
+    "packages/fixtures/xml/random-integer-template-reference.xml",
+  ]),
+  processingEntry("qti-product", "packages/core/src/core.test.ts", [
+    "packages/fixtures/xml/random-integer-template-reference.xml",
   ]),
-  processingEntry("qti-product", "packages/core/src/core.test.ts"),
   processingEntry("qti-min", "packages/core/src/core.test.ts"),
   processingEntry("qti-max", "packages/core/src/core.test.ts"),
   processingEntry("qti-subtract", "packages/core/src/core.test.ts"),
@@ -205,9 +234,13 @@ export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
     fixtures: [
       "packages/fixtures/packages/basic-item-player/valid-item-only/items/tolerance-extra-features.xml",
     ],
-    tests: ["packages/core/src/core.test.ts", "packages/core/src/parser-item-metadata.test.ts"],
+    tests: [
+      "packages/core/src/core.test.ts",
+      "packages/core/src/parser-item-metadata.test.ts",
+      ...browserHarnessTests,
+    ],
     notes:
-      "Parsed by parser-item-metadata.ts and validated by validateCatalogInfo. Duplicate containers emit item.child.duplicate.",
+      "Parsed by parser-item-metadata.ts and validated by validateCatalogInfo. Duplicate containers emit item.child.duplicate. Manual harness debugger coverage is in player-harness.spec.ts.",
   },
   {
     qtiName: "qti-stylesheet",
@@ -225,6 +258,7 @@ export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
       "packages/core/src/core.test.ts",
       "packages/core/src/parser-item-metadata.test.ts",
       "tests/browser/player-package.spec.ts",
+      ...browserHarnessTests,
     ],
     notes:
       "Parsed by parser-item-metadata.ts, validated by validateStylesheets, and delivered by the player only when a host resolveStylesheet hook returns a safe resolved stylesheet URL.",
@@ -239,9 +273,13 @@ export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
     render: false,
     process: false,
     fixtures: ["packages/fixtures/src/index.ts"],
-    tests: ["packages/core/src/core.test.ts", "packages/core/src/parser-item-metadata.test.ts"],
+    tests: [
+      "packages/core/src/core.test.ts",
+      "packages/core/src/parser-item-metadata.test.ts",
+      ...browserFeedbackTests,
+    ],
     notes:
-      "Parsed by parser-item-metadata.ts and validated by validateModalFeedback. Player rendering remains out of scope for this metadata slice.",
+      "Parsed by parser-item-metadata.ts and validated by validateModalFeedback. Player renders outcome-gated modal feedback in player-feedback.spec.ts.",
   },
   {
     qtiName: "qti-companion-materials-info",
@@ -258,6 +296,7 @@ export const itemMetadataSupport: QtiItemMetadataElementSupport[] = [
     tests: [
       "packages/core/src/parser-companion-materials.test.ts",
       "packages/core/src/parser-item-metadata.test.ts",
+      ...browserHarnessTests,
     ],
     notes:
       "Parses qti-physical-material text and qti-digital-material file references. Digital materials require non-empty qti-file-href text and may include label, mime-type, and qti-resource-icon metadata. Hosts read resolved materials through createCompanionMaterialsResolution() or player.getCompanionMaterialsResolution().",
@@ -364,33 +403,14 @@ function entry(qtiName: string, interactionType: QtiInteractionType): QtiInterac
     validate: true,
     render: true,
     process: true,
-    fixtures: [`packages/fixtures/xml/${interactionType}-reference.xml`],
-    tests: [
-      "packages/fixtures/src/fixtures.test.ts",
-      "packages/conformance/src/conformance.test.ts",
-      "packages/a11y/src/a11y.test.ts",
-      "tests/browser/player.spec.ts",
-    ],
+    fixtures: interactionSupportFixtures(interactionType),
+    tests: interactionSupportTests(interactionType),
   };
 }
 
 function extendedTextInteractionEntry(): QtiInteractionElementSupport {
   return {
     ...entry("qti-extended-text-interaction", "extendedText"),
-    fixtures: [
-      "packages/fixtures/xml/extendedText-reference.xml",
-      "packages/fixtures/packages/sv-matrix/items/extended-text-pattern-mask.xml",
-      "packages/fixtures/packages/sv-matrix/items/extended-text-xhtml.xml",
-    ],
-    tests: [
-      "packages/fixtures/src/fixtures.test.ts",
-      "packages/conformance/src/conformance.test.ts",
-      "packages/a11y/src/a11y.test.ts",
-      "packages/core/src/pattern-mask.test.ts",
-      "tests/browser/player.spec.ts",
-      "tests/browser/player-dom-behavior.spec.ts",
-      "tests/browser/player-extended-text-xhtml.spec.ts",
-    ],
     notes: "Supports plain and format=xhtml extended text.",
   };
 }
@@ -398,18 +418,6 @@ function extendedTextInteractionEntry(): QtiInteractionElementSupport {
 function textEntryInteractionEntry(): QtiInteractionElementSupport {
   return {
     ...entry("qti-text-entry-interaction", "textEntry"),
-    fixtures: [
-      "packages/fixtures/xml/textEntry-reference.xml",
-      "packages/fixtures/packages/sv-matrix/items/text-entry-pattern-mask-inline.xml",
-    ],
-    tests: [
-      "packages/fixtures/src/fixtures.test.ts",
-      "packages/conformance/src/conformance.test.ts",
-      "packages/a11y/src/a11y.test.ts",
-      "packages/core/src/pattern-mask.test.ts",
-      "tests/browser/player.spec.ts",
-      "tests/browser/player-dom-behavior.spec.ts",
-    ],
     notes: "Supports placeholder-text and pattern-mask on text-entry controls.",
   };
 }
@@ -426,6 +434,7 @@ function processingEntry(
   qtiName: string,
   test: string,
   fixtures: string[] = [],
+  extraTests: string[] = [],
 ): QtiProcessingElementSupport {
   return {
     qtiName,
@@ -437,6 +446,6 @@ function processingEntry(
     render: false,
     process: true,
     fixtures,
-    tests: [test],
+    tests: [test, ...extraTests],
   };
 }

package/src/template-presentation-materializer.ts

@@ -0,0 +1,219 @@
+import {
+  applySourceRangeEdits,
+  parseDeliveryXml,
+  sourceRangeFor,
+  type SourceRangeEdit,
+} from "./delivery-redaction.js";
+import type { QtiDiagnostic, QtiValue } from "./types.js";
+import { qtiValueToString } from "./value-format.js";
+import { descendants, escapeXmlText, type XmlNode } from "./xml.js";
+
+interface TemplateBlockBinding {
+  readonly templateIdentifier: string;
+  readonly identifier: string;
+  readonly value: QtiValue;
+}
+
+export interface QtiTemplatePresentationVariables {
+  readonly outcomes: Record<string, QtiValue>;
+  readonly templateValues: Record<string, QtiValue>;
+  readonly responses?: Record<string, QtiValue> | undefined;
+}
+
+export function materializeTemplatePresentation(
+  xml: string,
+  variables: QtiTemplatePresentationVariables,
+): { ok: true; xml: string } | { ok: false; diagnostics: QtiDiagnostic[] } {
+  const parsed = parseDeliveryXml(xml);
+  if (!parsed.root) return { ok: true, xml };
+
+  const diagnostics: QtiDiagnostic[] = [];
+  const edits: SourceRangeEdit[] = [];
+  const nodes = [parsed.root, ...descendants(parsed.root, () => true)];
+
+  for (const node of nodes) {
+    if (isInsideTemplateContentNode(node)) continue;
+
+    if (node.localName === "qti-printed-variable") {
+      const edit = printedVariableEdit(node, variables, diagnostics);
+      if (edit) edits.push(edit);
+      continue;
+    }
+
+    if (node.localName === "qti-template-block" || node.localName === "qti-template-inline") {
+      const edit = templateContentEdit(xml, node, variables, diagnostics);
+      if (edit) edits.push(edit);
+    }
+  }
+
+  if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+    return { ok: false, diagnostics };
+  }
+
+  return { ok: true, xml: applySourceRangeEdits(xml, edits) };
+}
+
+function printedVariableEdit(
+  node: XmlNode,
+  variables: QtiTemplatePresentationVariables,
+  diagnostics: QtiDiagnostic[],
+): SourceRangeEdit | undefined {
+  const text = resolvePrintedVariableText(node, variables, diagnostics);
+  if (text === undefined) return undefined;
+
+  const range = sourceRangeFor(node)[0];
+  if (!range) {
+    diagnostics.push(unsupportedTemplateMaterializationDiagnostic(node));
+    return undefined;
+  }
+
+  return { ...range, text };
+}
+
+function templateContentEdit(
+  xml: string,
+  node: XmlNode,
+  variables: QtiTemplatePresentationVariables,
+  diagnostics: QtiDiagnostic[],
+): SourceRangeEdit | undefined {
+  const binding = resolveTemplateBlockBinding(node, variables.templateValues, diagnostics);
+  if (!binding) return undefined;
+
+  const range = sourceRangeFor(node)[0];
+  if (!range) {
+    diagnostics.push(unsupportedTemplateMaterializationDiagnostic(node));
+    return undefined;
+  }
+
+  return {
+    ...range,
+    text: isTemplateContentVisible(node, binding.value)
+      ? materializedContentXml(xml, node, variables, diagnostics)
+      : "",
+  };
+}
+
+function resolvePrintedVariableText(
+  node: XmlNode,
+  variables: QtiTemplatePresentationVariables,
+  diagnostics: QtiDiagnostic[],
+): string | undefined {
+  const identifier = node.attributes.identifier;
+  if (!identifier) {
+    diagnostics.push(unsupportedTemplateMaterializationDiagnostic(node));
+    return undefined;
+  }
+
+  const value = resolvePresentationVariable(identifier, variables);
+  if (value === undefined) {
+    diagnostics.push(unsupportedTemplateMaterializationDiagnostic(node));
+    return undefined;
+  }
+
+  return escapeXmlText(qtiValueToString(value));
+}
+
+function resolvePresentationVariable(
+  identifier: string,
+  variables: QtiTemplatePresentationVariables,
+): QtiValue | undefined {
+  return (
+    variables.outcomes[identifier] ??
+    variables.templateValues[identifier] ??
+    variables.responses?.[identifier]
+  );
+}
+
+function resolveTemplateBlockBinding(
+  node: XmlNode,
+  templateValues: Record<string, QtiValue>,
+  diagnostics: QtiDiagnostic[],
+): TemplateBlockBinding | undefined {
+  const templateIdentifier = node.attributes["template-identifier"];
+  const identifier = node.attributes.identifier;
+  if (!templateIdentifier || !identifier || templateValues[templateIdentifier] === undefined) {
+    diagnostics.push(unsupportedTemplateMaterializationDiagnostic(node));
+    return undefined;
+  }
+
+  return { templateIdentifier, identifier, value: templateValues[templateIdentifier] };
+}
+
+function materializedContentXml(
+  xml: string,
+  node: XmlNode,
+  variables: QtiTemplatePresentationVariables,
+  diagnostics: QtiDiagnostic[],
+): string {
+  return node.content
+    .map((child) => {
+      if (typeof child === "string") return escapeXmlText(child);
+      if (child.localName === "qti-printed-variable") {
+        return resolvePrintedVariableText(child, variables, diagnostics) ?? "";
+      }
+      if (child.localName === "qti-template-block" || child.localName === "qti-template-inline") {
+        return materializedNestedTemplateContentXml(xml, child, variables, diagnostics);
+      }
+      return materializedElementXml(xml, child, variables, diagnostics);
+    })
+    .join("");
+}
+
+function materializedNestedTemplateContentXml(
+  xml: string,
+  node: XmlNode,
+  variables: QtiTemplatePresentationVariables,
+  diagnostics: QtiDiagnostic[],
+): string {
+  const binding = resolveTemplateBlockBinding(node, variables.templateValues, diagnostics);
+  if (!binding) return "";
+
+  return isTemplateContentVisible(node, binding.value)
+    ? materializedContentXml(xml, node, variables, diagnostics)
+    : "";
+}
+
+function isTemplateContentVisible(node: XmlNode, value: QtiValue): boolean {
+  const identifier = node.attributes.identifier;
+  const hasIdentifier = Array.isArray(value)
+    ? value.map(String).includes(identifier ?? "")
+    : qtiValueToString(value) === identifier;
+  return node.attributes["show-hide"] === "hide" ? !hasIdentifier : hasIdentifier;
+}
+
+function materializedElementXml(
+  xml: string,
+  node: XmlNode,
+  variables: QtiTemplatePresentationVariables,
+  diagnostics: QtiDiagnostic[],
+): string {
+  if (node.sourceRange.endOffset === undefined || node.endSource === undefined) {
+    diagnostics.push(unsupportedTemplateMaterializationDiagnostic(node));
+    return "";
+  }
+
+  const startTag = xml.slice(node.sourceRange.startOffset, node.sourceRange.startTagEndOffset + 1);
+  const endTag = xml.slice(node.endSource.offset, node.sourceRange.endOffset);
+  return `${startTag}${materializedContentXml(xml, node, variables, diagnostics)}${endTag}`;
+}
+
+function isInsideTemplateContentNode(node: XmlNode): boolean {
+  let parent = node.parent;
+  while (parent) {
+    if (parent.localName === "qti-template-block" || parent.localName === "qti-template-inline") {
+      return true;
+    }
+    parent = parent.parent;
+  }
+  return false;
+}
+
+function unsupportedTemplateMaterializationDiagnostic(node: XmlNode): QtiDiagnostic {
+  return {
+    code: "adaptiveTurn.materialization.unsupported",
+    severity: "error",
+    message: `${node.name} could not be materialized from authoritative template state.`,
+    path: node.source.path,
+    source: node.source,
+  };
+}