@superbuilders/incept-renderer 0.1.0 → 0.1.2

package/dist/actions/index.js

@@ -1,202 +1,14 @@
 import { createHash } from 'crypto';
-import 'react';
-import 'clsx';
-import 'tailwind-merge';
-import 'react-dom';
-import 'react/jsx-runtime';
-import '@radix-ui/react-radio-group';
-import '@radix-ui/react-checkbox';
-import 'class-variance-authority';
-import '@radix-ui/react-label';
-import '@radix-ui/react-separator';
-import 'lucide-react';
-import '@dnd-kit/core';
-import '@radix-ui/react-select';
-import '@dnd-kit/sortable';
-import '@dnd-kit/utilities';
+import * as errors from '@superbuilders/errors';
+import * as logger2 from '@superbuilders/slog';
 import { XMLParser } from 'fast-xml-parser';
-import { z as z$1 } from 'zod';
+import { z } from 'zod';
 
 // ../../../../../node_modules/server-only/index.js
 throw new Error(
   "This module cannot be imported from a Client Component module. It should only be used from a Server Component."
 );
 
-// ../../node_modules/@superbuilders/errors/dist/index.js
-function z() {
-  let k2 = [], j2 = this;
-  while (j2 != null) if (k2.push(j2.message), j2.cause instanceof Error) j2 = j2.cause;
-  else break;
-  return k2.join(": ");
-}
-function A(k2) {
-  let j2 = new Error(k2);
-  if (Error.captureStackTrace) Error.captureStackTrace(j2, A);
-  return j2.toString = z, Object.freeze(j2);
-}
-function B(k2, j2) {
-  let x = new Error(j2, { cause: k2 });
-  if (Error.captureStackTrace) Error.captureStackTrace(x, B);
-  return x.toString = z, Object.freeze(x);
-}
-function I(k2) {
-  try {
-    return { data: k2(), error: void 0 };
-  } catch (j2) {
-    return { data: void 0, error: j2 instanceof Error ? j2 : new Error(String(j2)) };
-  }
-}
-
-// ../../node_modules/@superbuilders/slog/dist/index.js
-var b = new ArrayBuffer(8192);
-var K = new Uint8Array(b);
-var Q = new TextEncoder();
-var C = new ArrayBuffer(64);
-var L = new Uint8Array(C);
-var J = { DEBUG: Q.encode(" DEBUG "), INFO: Q.encode(" INFO "), WARN: Q.encode(" WARN "), ERROR: Q.encode(" ERROR "), NEWLINE: Q.encode(`
-`), SPACE: Q.encode(" "), EQUALS: Q.encode("="), SLASH: Q.encode("/"), COLON: Q.encode(":"), NULL: Q.encode("null"), UNDEFINED: Q.encode("undefined"), TRUE: Q.encode("true"), FALSE: Q.encode("false"), QUOTE: Q.encode('"'), BRACKET_OPEN: Q.encode("["), BRACKET_CLOSE: Q.encode("]"), BRACE_OPEN: Q.encode("{"), BRACE_CLOSE: Q.encode("}"), COMMA: Q.encode(","), ZERO: Q.encode("0"), MINUS: Q.encode("-"), DOT: Q.encode(".") };
-var U = new Uint8Array(19);
-var z2 = new Uint8Array(2);
-var V = 0;
-var F = 0;
-var W = 0;
-function j() {
-  let x = Date.now();
-  if (x - V >= 1e3) {
-    let q = new Date(x), D = 0, R = q.getFullYear();
-    U[D++] = 48 + Math.floor(R / 1e3) % 10, U[D++] = 48 + Math.floor(R / 100) % 10, U[D++] = 48 + Math.floor(R / 10) % 10, U[D++] = 48 + R % 10, U[D++] = 47;
-    let N = q.getMonth() + 1;
-    U[D++] = 48 + Math.floor(N / 10), U[D++] = 48 + N % 10, U[D++] = 47;
-    let P = q.getDate();
-    U[D++] = 48 + Math.floor(P / 10), U[D++] = 48 + P % 10, U[D++] = 32;
-    let M = q.getHours();
-    U[D++] = 48 + Math.floor(M / 10), U[D++] = 48 + M % 10, U[D++] = 58;
-    let Z = q.getMinutes();
-    U[D++] = 48 + Math.floor(Z / 10), U[D++] = 48 + Z % 10, U[D++] = 58, F = D;
-    let X = q.getSeconds();
-    z2[0] = 48 + Math.floor(X / 10), z2[1] = 48 + X % 10, W = 2, V = x;
-  }
-}
-var k = 0;
-function H(x, G, q) {
-  let D = 8192 - G;
-  if (D <= 0) return G;
-  let R = Math.min(q.length, D);
-  return x.set(q.subarray(0, R), G), G + R;
-}
-function $(x, G, q) {
-  let D = 8192 - G;
-  if (D <= 0) return G;
-  let R = true, N = q.length;
-  for (let M = 0; M < N; M++) if (q.charCodeAt(M) > 127) {
-    R = false;
-    break;
-  }
-  if (R) {
-    let M = Math.min(N, D);
-    for (let Z = 0; Z < M; Z++) x[G + Z] = q.charCodeAt(Z);
-    return G + M;
-  }
-  let P = Q.encodeInto(q, x.subarray(G));
-  return G + (P.written ?? 0);
-}
-function A2(x, G, q) {
-  if (Number.isNaN(q)) return $(x, G, "NaN");
-  if (q === Number.POSITIVE_INFINITY) return $(x, G, "Infinity");
-  if (q === Number.NEGATIVE_INFINITY) return $(x, G, "-Infinity");
-  let D = G, R = q;
-  if (R < 0) D = H(x, D, J.MINUS), R = -R;
-  if (R === 0) return H(x, D, J.ZERO);
-  if (Number.isInteger(R) && R < Number.MAX_SAFE_INTEGER) {
-    let M = Math.floor(R), Z = 0, X = M;
-    while (X > 0) Z++, X = Math.floor(X / 10);
-    if (D + Z > x.length) return D;
-    let Y = D + Z - 1;
-    while (M > 0) x[Y--] = 48 + M % 10, M = Math.floor(M / 10);
-    return D + Z;
-  }
-  let N = Q.encodeInto(R.toString(), L), P = Math.min(N.written ?? 0, x.length - G);
-  if (P > 0) x.set(L.subarray(0, P), G);
-  return G + P;
-}
-function _(x, G, q) {
-  if (q === null) return H(x, G, J.NULL);
-  if (q === void 0) return H(x, G, J.UNDEFINED);
-  switch (typeof q) {
-    case "string":
-      return $(x, G, q);
-    case "number":
-      return A2(x, G, q);
-    case "boolean":
-      return H(x, G, q ? J.TRUE : J.FALSE);
-    case "bigint":
-      return $(x, G, `${q}`);
-    case "symbol":
-      return $(x, G, String(q));
-    case "function":
-      return $(x, G, `${q}`);
-    case "object": {
-      if (Array.isArray(q)) {
-        let X = H(x, G, J.BRACKET_OPEN), Y = q.length;
-        for (let O = 0; O < Y; O++) {
-          if (O > 0) X = H(x, X, J.COMMA);
-          X = _(x, X, q[O]);
-        }
-        return H(x, X, J.BRACKET_CLOSE);
-      }
-      let N = q.toString;
-      if (typeof N === "function" && N !== Object.prototype.toString) return $(x, G, N.call(q));
-      let P = q, M = H(x, G, J.BRACE_OPEN), Z = true;
-      for (let X in P) if (Object.hasOwn(P, X)) {
-        if (Z === false) M = H(x, M, J.COMMA);
-        M = H(x, M, J.QUOTE), M = $(x, M, X), M = H(x, M, J.QUOTE), M = H(x, M, J.COLON), M = _(x, M, P[X]), Z = false;
-      }
-      return H(x, M, J.BRACE_CLOSE);
-    }
-    default:
-      return $(x, G, `${q}`);
-  }
-}
-function E(x, G, q) {
-  if (!q) return G;
-  let D = G, R = true;
-  for (let N in q) {
-    if (!R) D = H(x, D, J.SPACE);
-    D = $(x, D, N), D = H(x, D, J.EQUALS), D = _(x, D, q[N]), R = false;
-  }
-  return D;
-}
-function I2(x) {
-  let G = K.subarray(0, x);
-  process.stderr.write(G);
-}
-function y(x, G) {
-  if (-4 < k) return;
-  j();
-  let q = 0;
-  if (q = H(K, q, U.subarray(0, F)), q = H(K, q, z2.subarray(0, W)), q = H(K, q, J.DEBUG), q = $(K, q, x), G) q = H(K, q, J.SPACE), q = E(K, q, G);
-  if (q < 8192) q = H(K, q, J.NEWLINE);
-  else {
-    let D = J.NEWLINE[0];
-    if (D !== void 0) K[8191] = D;
-    q = 8192;
-  }
-  I2(q);
-}
-function l(x, G) {
-  if (8 < k) return;
-  j();
-  let q = 0;
-  if (q = H(K, q, U.subarray(0, F)), q = H(K, q, z2.subarray(0, W)), q = H(K, q, J.ERROR), q = $(K, q, x), G) q = H(K, q, J.SPACE), q = E(K, q, G);
-  if (q < 8192) q = H(K, q, J.NEWLINE);
-  else {
-    let D = J.NEWLINE[0];
-    if (D !== void 0) K[8191] = D;
-    q = 8192;
-  }
-  I2(q);
-}
-
 // src/html/sanitize.ts
 var DEFAULT_CONFIG = {
   // HTML content tags
@@ -525,101 +337,101 @@ function serializeVerbatim(node) {
   }).join("");
   return `<${node.tagName}${attrs}>${inner}</${node.tagName}>`;
 }
-var QtiCardinalitySchema = z$1.enum(["single", "multiple", "ordered"]);
-var QtiBaseTypeSchema = z$1.enum(["identifier", "string", "float", "integer", "boolean", "directedPair", "pair"]);
-var SimpleChoiceSchema = z$1.object({
-  identifier: z$1.string().min(1),
-  contentHtml: z$1.string(),
+var QtiCardinalitySchema = z.enum(["single", "multiple", "ordered"]);
+var QtiBaseTypeSchema = z.enum(["identifier", "string", "float", "integer", "boolean", "directedPair", "pair"]);
+var SimpleChoiceSchema = z.object({
+  identifier: z.string().min(1),
+  contentHtml: z.string(),
   // Allows "" for empty or image-only content
-  inlineFeedbackHtml: z$1.string().optional()
+  inlineFeedbackHtml: z.string().optional()
   // Optional per-choice feedback (qti-feedback-inline)
 });
-var InlineChoiceSchema = z$1.object({
-  identifier: z$1.string().min(1),
-  contentHtml: z$1.string()
+var InlineChoiceSchema = z.object({
+  identifier: z.string().min(1),
+  contentHtml: z.string()
 });
-var ChoiceInteractionCoreSchema = z$1.object({
-  responseIdentifier: z$1.string().min(1),
-  shuffle: z$1.boolean(),
-  minChoices: z$1.number().int().min(0),
-  maxChoices: z$1.number().int().min(1),
-  promptHtml: z$1.string(),
-  choices: z$1.array(SimpleChoiceSchema).min(1)
+var ChoiceInteractionCoreSchema = z.object({
+  responseIdentifier: z.string().min(1),
+  shuffle: z.boolean(),
+  minChoices: z.number().int().min(0),
+  maxChoices: z.number().int().min(1),
+  promptHtml: z.string(),
+  choices: z.array(SimpleChoiceSchema).min(1)
 });
-var ChoiceInteractionSchema = ChoiceInteractionCoreSchema.extend({ type: z$1.literal("choiceInteraction") });
-var InlineChoiceInteractionCoreSchema = z$1.object({
-  responseIdentifier: z$1.string().min(1),
-  shuffle: z$1.boolean(),
-  choices: z$1.array(InlineChoiceSchema).min(1)
+var ChoiceInteractionSchema = ChoiceInteractionCoreSchema.extend({ type: z.literal("choiceInteraction") });
+var InlineChoiceInteractionCoreSchema = z.object({
+  responseIdentifier: z.string().min(1),
+  shuffle: z.boolean(),
+  choices: z.array(InlineChoiceSchema).min(1)
 });
 var InlineChoiceInteractionSchema = InlineChoiceInteractionCoreSchema.extend({
-  type: z$1.literal("inlineChoiceInteraction")
+  type: z.literal("inlineChoiceInteraction")
 });
-var TextEntryInteractionCoreSchema = z$1.object({
-  responseIdentifier: z$1.string().min(1),
-  expectedLength: z$1.number().int().min(0).optional(),
-  placeholderText: z$1.string().optional(),
-  patternMask: z$1.string().optional()
+var TextEntryInteractionCoreSchema = z.object({
+  responseIdentifier: z.string().min(1),
+  expectedLength: z.number().int().min(0).optional(),
+  placeholderText: z.string().optional(),
+  patternMask: z.string().optional()
 });
 var TextEntryInteractionSchema = TextEntryInteractionCoreSchema.extend({
-  type: z$1.literal("textEntryInteraction")
+  type: z.literal("textEntryInteraction")
 });
-var OrderInteractionCoreSchema = z$1.object({
-  responseIdentifier: z$1.string().min(1),
-  shuffle: z$1.boolean(),
-  minChoices: z$1.number().int().min(0),
-  maxChoices: z$1.number().int().min(0).optional(),
+var OrderInteractionCoreSchema = z.object({
+  responseIdentifier: z.string().min(1),
+  shuffle: z.boolean(),
+  minChoices: z.number().int().min(0),
+  maxChoices: z.number().int().min(0).optional(),
   // 0 or undefined usually means "all"
-  orientation: z$1.enum(["vertical", "horizontal"]),
-  promptHtml: z$1.string(),
-  choices: z$1.array(SimpleChoiceSchema).min(1)
+  orientation: z.enum(["vertical", "horizontal"]),
+  promptHtml: z.string(),
+  choices: z.array(SimpleChoiceSchema).min(1)
 });
 var OrderInteractionSchema = OrderInteractionCoreSchema.extend({
-  type: z$1.literal("orderInteraction")
+  type: z.literal("orderInteraction")
 });
-var GapTextSchema = z$1.object({
-  identifier: z$1.string().min(1),
-  contentHtml: z$1.string(),
-  matchMax: z$1.number().int().min(0)
+var GapTextSchema = z.object({
+  identifier: z.string().min(1),
+  contentHtml: z.string(),
+  matchMax: z.number().int().min(0)
   // 0 = unlimited
 });
-var GapSchema = z$1.object({
-  identifier: z$1.string().min(1)
+var GapSchema = z.object({
+  identifier: z.string().min(1)
 });
-var GapMatchInteractionCoreSchema = z$1.object({
-  responseIdentifier: z$1.string().min(1),
-  shuffle: z$1.boolean(),
-  gapTexts: z$1.array(GapTextSchema).min(1),
+var GapMatchInteractionCoreSchema = z.object({
+  responseIdentifier: z.string().min(1),
+  shuffle: z.boolean(),
+  gapTexts: z.array(GapTextSchema).min(1),
   // Draggable source tokens
-  gaps: z$1.array(GapSchema).min(1),
+  gaps: z.array(GapSchema).min(1),
   // Drop target placeholders
-  contentHtml: z$1.string()
+  contentHtml: z.string()
   // HTML content with gap placeholders
 });
 var GapMatchInteractionSchema = GapMatchInteractionCoreSchema.extend({
-  type: z$1.literal("gapMatchInteraction")
+  type: z.literal("gapMatchInteraction")
 });
-var AssociableChoiceSchema = z$1.object({
-  identifier: z$1.string().min(1),
-  matchMax: z$1.number().int().min(0),
+var AssociableChoiceSchema = z.object({
+  identifier: z.string().min(1),
+  matchMax: z.number().int().min(0),
   // 0 = unlimited uses
-  contentHtml: z$1.string()
+  contentHtml: z.string()
 });
-var MatchInteractionCoreSchema = z$1.object({
-  responseIdentifier: z$1.string().min(1),
-  shuffle: z$1.boolean(),
-  maxAssociations: z$1.number().int().min(0),
+var MatchInteractionCoreSchema = z.object({
+  responseIdentifier: z.string().min(1),
+  shuffle: z.boolean(),
+  maxAssociations: z.number().int().min(0),
   // 0 = unlimited total associations
-  sourceChoices: z$1.array(AssociableChoiceSchema).min(1),
+  sourceChoices: z.array(AssociableChoiceSchema).min(1),
   // First <qti-simple-match-set>
-  targetChoices: z$1.array(AssociableChoiceSchema).min(1),
+  targetChoices: z.array(AssociableChoiceSchema).min(1),
   // Second <qti-simple-match-set>
-  promptHtml: z$1.string()
+  promptHtml: z.string()
 });
 var MatchInteractionSchema = MatchInteractionCoreSchema.extend({
-  type: z$1.literal("matchInteraction")
+  type: z.literal("matchInteraction")
 });
-var AnyInteractionSchema = z$1.discriminatedUnion("type", [
+var AnyInteractionSchema = z.discriminatedUnion("type", [
   ChoiceInteractionSchema,
   InlineChoiceInteractionSchema,
   TextEntryInteractionSchema,
@@ -627,149 +439,149 @@ var AnyInteractionSchema = z$1.discriminatedUnion("type", [
   GapMatchInteractionSchema,
   MatchInteractionSchema
 ]);
-var CorrectResponseSchema = z$1.object({
-  values: z$1.array(z$1.string().min(1)).min(1)
+var CorrectResponseSchema = z.object({
+  values: z.array(z.string().min(1)).min(1)
 });
-var ResponseDeclarationSchema = z$1.object({
-  identifier: z$1.string().min(1),
+var ResponseDeclarationSchema = z.object({
+  identifier: z.string().min(1),
   cardinality: QtiCardinalitySchema,
   baseType: QtiBaseTypeSchema,
   correctResponse: CorrectResponseSchema,
   // Optional response mapping for map-response processing (used for summed feedback/score)
-  mapping: z$1.object({
-    defaultValue: z$1.number().default(0),
-    lowerBound: z$1.number().optional(),
-    upperBound: z$1.number().optional(),
-    entries: z$1.array(
-      z$1.object({
-        key: z$1.string().min(1),
-        value: z$1.number()
+  mapping: z.object({
+    defaultValue: z.number().default(0),
+    lowerBound: z.number().optional(),
+    upperBound: z.number().optional(),
+    entries: z.array(
+      z.object({
+        key: z.string().min(1),
+        value: z.number()
       })
     )
   }).optional()
 });
-var OutcomeDefaultValueSchema = z$1.object({
-  value: z$1.string()
+var OutcomeDefaultValueSchema = z.object({
+  value: z.string()
 });
-var OutcomeDeclarationSchema = z$1.object({
-  identifier: z$1.string().min(1),
+var OutcomeDeclarationSchema = z.object({
+  identifier: z.string().min(1),
   cardinality: QtiCardinalitySchema,
   baseType: QtiBaseTypeSchema,
   defaultValue: OutcomeDefaultValueSchema.optional()
 });
-var FeedbackBlockSchema = z$1.object({
-  outcomeIdentifier: z$1.string().min(1),
-  identifier: z$1.string().min(1),
-  showHide: z$1.enum(["show", "hide"]).default("show"),
-  contentHtml: z$1.string()
+var FeedbackBlockSchema = z.object({
+  outcomeIdentifier: z.string().min(1),
+  identifier: z.string().min(1),
+  showHide: z.enum(["show", "hide"]).default("show"),
+  contentHtml: z.string()
 });
-var StimulusBlockSchema = z$1.object({
-  type: z$1.literal("stimulus"),
-  html: z$1.string()
+var StimulusBlockSchema = z.object({
+  type: z.literal("stimulus"),
+  html: z.string()
 });
-var RichStimulusBlockSchema = z$1.object({
-  type: z$1.literal("richStimulus"),
-  html: z$1.string(),
-  inlineEmbeds: z$1.record(z$1.string(), InlineChoiceInteractionSchema),
-  textEmbeds: z$1.record(z$1.string(), TextEntryInteractionSchema)
+var RichStimulusBlockSchema = z.object({
+  type: z.literal("richStimulus"),
+  html: z.string(),
+  inlineEmbeds: z.record(z.string(), InlineChoiceInteractionSchema),
+  textEmbeds: z.record(z.string(), TextEntryInteractionSchema)
 });
-var InteractionBlockSchema = z$1.object({
-  type: z$1.literal("interaction"),
+var InteractionBlockSchema = z.object({
+  type: z.literal("interaction"),
   interaction: AnyInteractionSchema
 });
-var ItemBodySchema = z$1.object({
-  contentBlocks: z$1.array(z$1.union([StimulusBlockSchema, RichStimulusBlockSchema, InteractionBlockSchema])).min(1),
-  feedbackBlocks: z$1.array(FeedbackBlockSchema)
+var ItemBodySchema = z.object({
+  contentBlocks: z.array(z.union([StimulusBlockSchema, RichStimulusBlockSchema, InteractionBlockSchema])).min(1),
+  feedbackBlocks: z.array(FeedbackBlockSchema)
 });
-var BaseRuleSchema = z$1.object({
-  type: z$1.literal("setOutcomeValue"),
-  identifier: z$1.string(),
-  value: z$1.string()
+var BaseRuleSchema = z.object({
+  type: z.literal("setOutcomeValue"),
+  identifier: z.string(),
+  value: z.string()
 });
-var MatchConditionSchema = z$1.object({
-  type: z$1.literal("match"),
-  variable: z$1.string(),
-  correct: z$1.literal(true)
+var MatchConditionSchema = z.object({
+  type: z.literal("match"),
+  variable: z.string(),
+  correct: z.literal(true)
   // Match against correct response
 });
-var MatchValueConditionSchema = z$1.object({
-  type: z$1.literal("matchValue"),
-  variable: z$1.string(),
+var MatchValueConditionSchema = z.object({
+  type: z.literal("matchValue"),
+  variable: z.string(),
   // The response identifier from <qti-variable>
-  value: z$1.string()
+  value: z.string()
   // The target value from <qti-base-value>
 });
-var StringMatchConditionSchema = z$1.object({
-  type: z$1.literal("stringMatch"),
-  variable: z$1.string(),
-  value: z$1.string(),
-  caseSensitive: z$1.boolean()
+var StringMatchConditionSchema = z.object({
+  type: z.literal("stringMatch"),
+  variable: z.string(),
+  value: z.string(),
+  caseSensitive: z.boolean()
 });
-var MemberConditionSchema = z$1.object({
-  type: z$1.literal("member"),
-  variable: z$1.string(),
-  value: z$1.string()
+var MemberConditionSchema = z.object({
+  type: z.literal("member"),
+  variable: z.string(),
+  value: z.string()
 });
-var EqualMapResponseConditionSchema = z$1.object({
-  type: z$1.literal("equalMapResponse"),
-  variable: z$1.string(),
+var EqualMapResponseConditionSchema = z.object({
+  type: z.literal("equalMapResponse"),
+  variable: z.string(),
   // The response identifier from <qti-map-response>
-  value: z$1.string()
+  value: z.string()
   // The target sum value from <qti-base-value>
 });
-var AndConditionSchema = z$1.object({
-  type: z$1.literal("and"),
-  conditions: z$1.array(z$1.lazy(() => AnyConditionSchema))
+var AndConditionSchema = z.object({
+  type: z.literal("and"),
+  conditions: z.array(z.lazy(() => AnyConditionSchema))
 });
-var OrConditionSchema = z$1.object({
-  type: z$1.literal("or"),
-  conditions: z$1.array(z$1.lazy(() => AnyConditionSchema))
+var OrConditionSchema = z.object({
+  type: z.literal("or"),
+  conditions: z.array(z.lazy(() => AnyConditionSchema))
 });
-var NotConditionSchema = z$1.object({
-  type: z$1.literal("not"),
-  condition: z$1.lazy(() => AnyConditionSchema)
+var NotConditionSchema = z.object({
+  type: z.literal("not"),
+  condition: z.lazy(() => AnyConditionSchema)
 });
-var AnyConditionSchema = z$1.union([
+var AnyConditionSchema = z.union([
   MatchConditionSchema,
   MatchValueConditionSchema,
   StringMatchConditionSchema,
   MemberConditionSchema,
-  z$1.lazy(() => AndConditionSchema),
-  z$1.lazy(() => OrConditionSchema),
-  z$1.lazy(() => NotConditionSchema),
+  z.lazy(() => AndConditionSchema),
+  z.lazy(() => OrConditionSchema),
+  z.lazy(() => NotConditionSchema),
   EqualMapResponseConditionSchema
 ]);
-var ConditionBranchSchema = z$1.object({
+var ConditionBranchSchema = z.object({
   condition: AnyConditionSchema.optional(),
-  actions: z$1.array(BaseRuleSchema),
-  nestedRules: z$1.array(z$1.lazy(() => ResponseRuleSchema)).optional()
+  actions: z.array(BaseRuleSchema),
+  nestedRules: z.array(z.lazy(() => ResponseRuleSchema)).optional()
 });
-var ResponseRuleSchema = z$1.union([
-  z$1.object({
-    type: z$1.literal("condition"),
-    branches: z$1.array(ConditionBranchSchema)
+var ResponseRuleSchema = z.union([
+  z.object({
+    type: z.literal("condition"),
+    branches: z.array(ConditionBranchSchema)
   }),
-  z$1.object({
-    type: z$1.literal("action"),
+  z.object({
+    type: z.literal("action"),
     action: BaseRuleSchema
   })
 ]);
-var ScoringRuleSchema = z$1.object({
-  responseIdentifier: z$1.string().min(1),
-  correctScore: z$1.number(),
-  incorrectScore: z$1.number()
+var ScoringRuleSchema = z.object({
+  responseIdentifier: z.string().min(1),
+  correctScore: z.number(),
+  incorrectScore: z.number()
 });
-var ResponseProcessingSchema = z$1.object({
-  rules: z$1.array(ResponseRuleSchema),
+var ResponseProcessingSchema = z.object({
+  rules: z.array(ResponseRuleSchema),
   scoring: ScoringRuleSchema
 });
-var AssessmentItemSchema = z$1.object({
-  identifier: z$1.string().min(1),
-  title: z$1.string().min(1),
-  timeDependent: z$1.boolean(),
-  xmlLang: z$1.string().min(1),
-  responseDeclarations: z$1.array(ResponseDeclarationSchema).min(1),
-  outcomeDeclarations: z$1.array(OutcomeDeclarationSchema).min(1),
+var AssessmentItemSchema = z.object({
+  identifier: z.string().min(1),
+  title: z.string().min(1),
+  timeDependent: z.boolean(),
+  xmlLang: z.string().min(1),
+  responseDeclarations: z.array(ResponseDeclarationSchema).min(1),
+  outcomeDeclarations: z.array(OutcomeDeclarationSchema).min(1),
   itemBody: ItemBodySchema,
   responseProcessing: ResponseProcessingSchema
 });
@@ -801,7 +613,7 @@ function normalizeNode(rawNode) {
   if (textContent != null) {
     return coerceString(textContent);
   }
-  const tagName = Object.keys(rawNode).find((k2) => k2 !== ":@");
+  const tagName = Object.keys(rawNode).find((k) => k !== ":@");
   if (!tagName) return "";
   const attrsValue = rawNode[":@"];
   const attrs = isRecord(attrsValue) ? attrsValue : {};
@@ -1059,12 +871,12 @@ function extractResponseDeclarations(rootChildren) {
     const cardinalityRaw = coerceString(node.attrs.cardinality);
     const cardinalityResult = QtiCardinalitySchema.safeParse(cardinalityRaw);
     if (!cardinalityResult.success) {
-      throw A(`invalid cardinality '${cardinalityRaw}' in response declaration`);
+      throw errors.new(`invalid cardinality '${cardinalityRaw}' in response declaration`);
     }
     const baseTypeRaw = coerceString(node.attrs["base-type"]);
     const baseTypeResult = QtiBaseTypeSchema.safeParse(baseTypeRaw);
     if (!baseTypeResult.success) {
-      throw A(`invalid base-type '${baseTypeRaw}' in response declaration`);
+      throw errors.new(`invalid base-type '${baseTypeRaw}' in response declaration`);
     }
     return {
       identifier: coerceString(node.attrs.identifier),
@@ -1084,12 +896,12 @@ function extractOutcomeDeclarations(rootChildren) {
     const cardinalityRaw = coerceString(node.attrs.cardinality);
     const cardinalityResult = QtiCardinalitySchema.safeParse(cardinalityRaw);
     if (!cardinalityResult.success) {
-      throw A(`invalid cardinality '${cardinalityRaw}' in outcome declaration`);
+      throw errors.new(`invalid cardinality '${cardinalityRaw}' in outcome declaration`);
     }
     const baseTypeRaw = coerceString(node.attrs["base-type"]);
     const baseTypeResult = QtiBaseTypeSchema.safeParse(baseTypeRaw);
     if (!baseTypeResult.success) {
-      throw A(`invalid base-type '${baseTypeRaw}' in outcome declaration`);
+      throw errors.new(`invalid base-type '${baseTypeRaw}' in outcome declaration`);
     }
     return {
       identifier: coerceString(node.attrs.identifier),
@@ -1306,23 +1118,23 @@ function extractResponseProcessing(rootChildren) {
 }
 function parseAssessmentItemXml(xml) {
   if (!xml || typeof xml !== "string") {
-    throw A("xml input must be a non-empty string");
+    throw errors.new("xml input must be a non-empty string");
   }
   const parser = createXmlParser();
-  const parseResult = I(() => {
+  const parseResult = errors.trySync(() => {
     return parser.parse(xml, true);
   });
   if (parseResult.error) {
-    throw B(parseResult.error, "xml parse");
+    throw errors.wrap(parseResult.error, "xml parse");
   }
   const raw = parseResult.data;
   if (!Array.isArray(raw)) {
-    throw A("expected xml parser to output an array for preserveOrder");
+    throw errors.new("expected xml parser to output an array for preserveOrder");
   }
   const normalizedTree = raw.map(normalizeNode).filter((n) => typeof n !== "string");
   const rootNode = normalizedTree.find((n) => n.tagName.endsWith("assessment-item"));
   if (!rootNode) {
-    throw A("qti assessment item not found in xml document");
+    throw errors.new("qti assessment item not found in xml document");
   }
   const rootChildren = rootNode.children.filter((c) => typeof c !== "string");
   const itemBodyNode = rootChildren.find((n) => n.tagName === "qti-item-body");
@@ -1394,204 +1206,32 @@ function parseAssessmentItemXml(xml) {
   const validation = AssessmentItemSchema.safeParse(normalizedItem);
   if (!validation.success) {
     const errorDetails = validation.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`).join("; ");
-    throw A(`qti item validation: ${errorDetails}`);
+    throw errors.new(`qti item validation: ${errorDetails}`);
   }
   return validation.data;
 }
 
-// src/evaluator.ts
-function normalizeString(str, caseSensitive) {
-  const s = (str ?? "").trim();
-  return caseSensitive ? s : s.toLowerCase();
-}
-function checkCondition(condition, item, responses, responseResults) {
-  if (condition.type === "and") {
-    const results = condition.conditions.map((c) => checkCondition(c, item, responses, responseResults));
-    const allTrue = results.every((r) => r === true);
-    y("qti evaluator: checking AND condition", {
-      numConditions: condition.conditions.length,
-      results,
-      allTrue
-    });
-    return allTrue;
-  }
-  if (condition.type === "or") {
-    const results = condition.conditions.map((c) => checkCondition(c, item, responses, responseResults));
-    const anyTrue = results.some((r) => r === true);
-    y("qti evaluator: checking OR condition", {
-      numConditions: condition.conditions.length,
-      results,
-      anyTrue
-    });
-    return anyTrue;
-  }
-  if (condition.type === "not") {
-    const result = checkCondition(condition.condition, item, responses, responseResults);
-    y("qti evaluator: checking NOT condition", { result, negated: !result });
-    return !result;
-  }
-  if (condition.type === "match") {
-    const result = responseResults[condition.variable];
-    y("qti evaluator: checking match condition", {
-      variable: condition.variable,
-      isCorrect: result,
-      matches: result === true
-    });
-    return result === true;
-  }
-  if (condition.type === "matchValue") {
-    const userResponse = responses[condition.variable];
-    let userValues;
-    if (Array.isArray(userResponse)) {
-      userValues = userResponse;
-    } else if (userResponse) {
-      userValues = [userResponse];
-    } else {
-      userValues = [];
-    }
-    const matches = userValues.includes(condition.value);
-    y("qti evaluator: checking matchValue condition", {
-      variable: condition.variable,
-      targetValue: condition.value,
-      userValues,
-      matches
-    });
-    return matches;
-  }
-  if (condition.type === "stringMatch") {
-    const userResponse = responses[condition.variable];
-    const val = Array.isArray(userResponse) ? userResponse[0] : userResponse;
-    if (!val) return false;
-    const u = normalizeString(String(val), condition.caseSensitive);
-    const t = normalizeString(condition.value, condition.caseSensitive);
-    const matches = u === t;
-    y("qti evaluator: checking stringMatch", {
-      variable: condition.variable,
-      caseSensitive: condition.caseSensitive,
-      matches
-    });
-    return matches;
-  }
-  if (condition.type === "member") {
-    const userResponse = responses[condition.variable];
-    let userValues;
-    if (Array.isArray(userResponse)) {
-      userValues = userResponse;
-    } else if (userResponse) {
-      userValues = [userResponse];
-    } else {
-      userValues = [];
-    }
-    const matches = userValues.includes(condition.value);
-    y("qti evaluator: checking member", {
-      variable: condition.variable,
-      target: condition.value,
-      userValues,
-      matches
-    });
-    return matches;
-  }
-  if (condition.type === "equalMapResponse") {
-    const responseId = condition.variable;
-    const userResponse = responses[responseId];
-    const responseDecl = item.responseDeclarations.find((rd) => rd.identifier === responseId);
-    if (!userResponse || !responseDecl?.mapping) return false;
-    const userValues = Array.isArray(userResponse) ? userResponse : [userResponse];
-    const valueMap = new Map(responseDecl.mapping.entries.map((e) => [e.key, e.value]));
-    let sum = 0;
-    for (const val of userValues) {
-      sum += valueMap.get(val) ?? responseDecl.mapping.defaultValue;
-    }
-    const target = Number(condition.value);
-    const diff = Math.abs(sum - target);
-    const matches = diff < 1e-4;
-    y("qti evaluator: checking equalMapResponse", {
-      responseId,
-      userValues,
-      sum,
-      target: condition.value,
-      matches
-    });
-    return matches;
-  }
-  return false;
-}
-function evaluateRule(rule, item, responses, responseResults) {
-  const feedbackIds = [];
-  if (rule.type === "action") {
-    const action = rule.action;
-    if (action.type === "setOutcomeValue" && (action.identifier === "FEEDBACK__OVERALL" || action.identifier === "FEEDBACK__PEDAGOGY" || action.identifier === "FEEDBACK")) {
-      y("qti evaluator: executing action", { id: action.identifier, value: action.value });
-      feedbackIds.push(action.value);
-    }
-    return feedbackIds;
-  }
-  if (rule.type === "condition") {
-    for (const branch of rule.branches) {
-      const isMatch = branch.condition ? checkCondition(branch.condition, item, responses, responseResults) : true;
-      y("qti evaluator: evaluating branch", {
-        hasCondition: !!branch.condition,
-        isMatch
-      });
-      if (isMatch) {
-        const feedbackActions = branch.actions.filter(
-          (r) => r.type === "setOutcomeValue" && (r.identifier === "FEEDBACK__OVERALL" || r.identifier === "FEEDBACK__PEDAGOGY" || r.identifier === "FEEDBACK")
-        );
-        for (const action of feedbackActions) {
-          feedbackIds.push(action.value);
-        }
-        if (branch.nestedRules) {
-          for (const nested of branch.nestedRules) {
-            const nestedIds = evaluateRule(nested, item, responses, responseResults);
-            feedbackIds.push(...nestedIds);
-          }
-        }
-        break;
-      }
-    }
-  }
-  return feedbackIds;
-}
-function evaluateFeedbackIdentifiers(item, responses, responseResults) {
-  const processing = item.responseProcessing;
-  if (!processing) {
-    y("qti evaluator: no response processing found");
-    return [];
-  }
-  y("qti evaluator: starting evaluation", {
-    numRules: processing.rules.length,
-    responseResults
-  });
-  const allFeedbackIds = [];
-  for (const rule of processing.rules) {
-    const ids = evaluateRule(rule, item, responses, responseResults);
-    allFeedbackIds.push(...ids);
-  }
-  y("qti evaluator: selected feedback identifiers", { feedbackIds: allFeedbackIds });
-  return allFeedbackIds;
-}
-
 // src/actions/internal/display.ts
 function shuffleArray(items) {
   const arr = items.slice();
   for (let i = arr.length - 1; i > 0; i--) {
-    const j2 = Math.floor(Math.random() * (i + 1));
+    const j = Math.floor(Math.random() * (i + 1));
     const vi = arr[i];
-    const vj = arr[j2];
+    const vj = arr[j];
     if (vi === void 0 || vj === void 0) {
       continue;
     }
     arr[i] = vj;
-    arr[j2] = vi;
+    arr[j] = vi;
   }
   return arr;
 }
 function buildDisplayModelFromXml(qtiXml) {
-  y("qti build display model", {});
-  const parseResult = I(() => parseAssessmentItemXml(qtiXml));
+  logger2.debug("qti build display model", {});
+  const parseResult = errors.trySync(() => parseAssessmentItemXml(qtiXml));
   if (parseResult.error) {
-    l("qti parse failed", { error: parseResult.error });
-    throw B(parseResult.error, "qti parse");
+    logger2.error("qti parse failed", { error: parseResult.error });
+    throw errors.wrap(parseResult.error, "qti parse");
   }
   const item = parseResult.data;
   const shape = {};
@@ -1748,17 +1388,187 @@ function buildDisplayModelFromXml(qtiXml) {
 async function buildDisplayModel(qtiXml) {
   return buildDisplayModelFromXml(qtiXml);
 }
+function normalizeString(str, caseSensitive) {
+  const s = (str ?? "").trim();
+  return caseSensitive ? s : s.toLowerCase();
+}
+function checkCondition(condition, item, responses, responseResults) {
+  if (condition.type === "and") {
+    const results = condition.conditions.map((c) => checkCondition(c, item, responses, responseResults));
+    const allTrue = results.every((r) => r === true);
+    logger2.debug("qti evaluator: checking AND condition", {
+      numConditions: condition.conditions.length,
+      results,
+      allTrue
+    });
+    return allTrue;
+  }
+  if (condition.type === "or") {
+    const results = condition.conditions.map((c) => checkCondition(c, item, responses, responseResults));
+    const anyTrue = results.some((r) => r === true);
+    logger2.debug("qti evaluator: checking OR condition", {
+      numConditions: condition.conditions.length,
+      results,
+      anyTrue
+    });
+    return anyTrue;
+  }
+  if (condition.type === "not") {
+    const result = checkCondition(condition.condition, item, responses, responseResults);
+    logger2.debug("qti evaluator: checking NOT condition", { result, negated: !result });
+    return !result;
+  }
+  if (condition.type === "match") {
+    const result = responseResults[condition.variable];
+    logger2.debug("qti evaluator: checking match condition", {
+      variable: condition.variable,
+      isCorrect: result,
+      matches: result === true
+    });
+    return result === true;
+  }
+  if (condition.type === "matchValue") {
+    const userResponse = responses[condition.variable];
+    let userValues;
+    if (Array.isArray(userResponse)) {
+      userValues = userResponse;
+    } else if (userResponse) {
+      userValues = [userResponse];
+    } else {
+      userValues = [];
+    }
+    const matches = userValues.includes(condition.value);
+    logger2.debug("qti evaluator: checking matchValue condition", {
+      variable: condition.variable,
+      targetValue: condition.value,
+      userValues,
+      matches
+    });
+    return matches;
+  }
+  if (condition.type === "stringMatch") {
+    const userResponse = responses[condition.variable];
+    const val = Array.isArray(userResponse) ? userResponse[0] : userResponse;
+    if (!val) return false;
+    const u = normalizeString(String(val), condition.caseSensitive);
+    const t = normalizeString(condition.value, condition.caseSensitive);
+    const matches = u === t;
+    logger2.debug("qti evaluator: checking stringMatch", {
+      variable: condition.variable,
+      caseSensitive: condition.caseSensitive,
+      matches
+    });
+    return matches;
+  }
+  if (condition.type === "member") {
+    const userResponse = responses[condition.variable];
+    let userValues;
+    if (Array.isArray(userResponse)) {
+      userValues = userResponse;
+    } else if (userResponse) {
+      userValues = [userResponse];
+    } else {
+      userValues = [];
+    }
+    const matches = userValues.includes(condition.value);
+    logger2.debug("qti evaluator: checking member", {
+      variable: condition.variable,
+      target: condition.value,
+      userValues,
+      matches
+    });
+    return matches;
+  }
+  if (condition.type === "equalMapResponse") {
+    const responseId = condition.variable;
+    const userResponse = responses[responseId];
+    const responseDecl = item.responseDeclarations.find((rd) => rd.identifier === responseId);
+    if (!userResponse || !responseDecl?.mapping) return false;
+    const userValues = Array.isArray(userResponse) ? userResponse : [userResponse];
+    const valueMap = new Map(responseDecl.mapping.entries.map((e) => [e.key, e.value]));
+    let sum = 0;
+    for (const val of userValues) {
+      sum += valueMap.get(val) ?? responseDecl.mapping.defaultValue;
+    }
+    const target = Number(condition.value);
+    const diff = Math.abs(sum - target);
+    const matches = diff < 1e-4;
+    logger2.debug("qti evaluator: checking equalMapResponse", {
+      responseId,
+      userValues,
+      sum,
+      target: condition.value,
+      matches
+    });
+    return matches;
+  }
+  return false;
+}
+function evaluateRule(rule, item, responses, responseResults) {
+  const feedbackIds = [];
+  if (rule.type === "action") {
+    const action = rule.action;
+    if (action.type === "setOutcomeValue" && (action.identifier === "FEEDBACK__OVERALL" || action.identifier === "FEEDBACK__PEDAGOGY" || action.identifier === "FEEDBACK")) {
+      logger2.debug("qti evaluator: executing action", { id: action.identifier, value: action.value });
+      feedbackIds.push(action.value);
+    }
+    return feedbackIds;
+  }
+  if (rule.type === "condition") {
+    for (const branch of rule.branches) {
+      const isMatch = branch.condition ? checkCondition(branch.condition, item, responses, responseResults) : true;
+      logger2.debug("qti evaluator: evaluating branch", {
+        hasCondition: !!branch.condition,
+        isMatch
+      });
+      if (isMatch) {
+        const feedbackActions = branch.actions.filter(
+          (r) => r.type === "setOutcomeValue" && (r.identifier === "FEEDBACK__OVERALL" || r.identifier === "FEEDBACK__PEDAGOGY" || r.identifier === "FEEDBACK")
+        );
+        for (const action of feedbackActions) {
+          feedbackIds.push(action.value);
+        }
+        if (branch.nestedRules) {
+          for (const nested of branch.nestedRules) {
+            const nestedIds = evaluateRule(nested, item, responses, responseResults);
+            feedbackIds.push(...nestedIds);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return feedbackIds;
+}
+function evaluateFeedbackIdentifiers(item, responses, responseResults) {
+  const processing = item.responseProcessing;
+  if (!processing) {
+    logger2.debug("qti evaluator: no response processing found");
+    return [];
+  }
+  logger2.debug("qti evaluator: starting evaluation", {
+    numRules: processing.rules.length,
+    responseResults
+  });
+  const allFeedbackIds = [];
+  for (const rule of processing.rules) {
+    const ids = evaluateRule(rule, item, responses, responseResults);
+    allFeedbackIds.push(...ids);
+  }
+  logger2.debug("qti evaluator: selected feedback identifiers", { feedbackIds: allFeedbackIds });
+  return allFeedbackIds;
+}
 
 // src/actions/internal/validate.ts
 function validateResponsesFromXml(qtiXml, responses) {
-  y("qti validate secure", {});
-  const parseResult = I(() => parseAssessmentItemXml(qtiXml));
+  logger2.debug("qti validate secure", {});
+  const parseResult = errors.trySync(() => parseAssessmentItemXml(qtiXml));
   if (parseResult.error) {
-    l("qti parse failed during validate", { error: parseResult.error });
-    throw B(parseResult.error, "qti parse");
+    logger2.error("qti parse failed during validate", { error: parseResult.error });
+    throw errors.wrap(parseResult.error, "qti parse");
   }
   const item = parseResult.data;
-  y("qti validate: parsed item", {
+  logger2.debug("qti validate: parsed item", {
     title: item.title,
     responseCount: Object.keys(responses).length
   });
@@ -1772,7 +1582,7 @@ function validateResponsesFromXml(qtiXml, responses) {
     if (user == null) {
       allCorrect = false;
       responseCorrectness[respId] = false;
-      y("qti validate: missing response", { responseId: respId });
+      logger2.debug("qti validate: missing response", { responseId: respId });
       continue;
     }
     const userVals = Array.isArray(user) ? user.filter((v) => typeof v === "string") : [user];
@@ -1780,7 +1590,7 @@ function validateResponsesFromXml(qtiXml, responses) {
     let isCorrect = false;
     if (rd.cardinality === "ordered") {
       isCorrect = userVals.length === correctVals.length && userVals.every((val, index) => val === correctVals[index]);
-      y("qti validate: ordered check", {
+      logger2.debug("qti validate: ordered check", {
         responseId: respId,
         userVals,
         correctVals,
@@ -1790,7 +1600,7 @@ function validateResponsesFromXml(qtiXml, responses) {
       const correctSet2 = new Set(correctVals);
       const userSet = new Set(userVals);
       isCorrect = userSet.size === correctSet2.size && [...userSet].every((v) => correctSet2.has(v));
-      y("qti validate: directedPair check", {
+      logger2.debug("qti validate: directedPair check", {
         responseId: respId,
         userVals,
         correctVals,
@@ -1808,7 +1618,7 @@ function validateResponsesFromXml(qtiXml, responses) {
           });
         }
       }
-      y("qti validate: numeric check", {
+      logger2.debug("qti validate: numeric check", {
         responseId: respId,
         baseType: rd.baseType,
         userVal: userVals[0],
@@ -1818,7 +1628,7 @@ function validateResponsesFromXml(qtiXml, responses) {
     } else if (rd.cardinality === "single") {
       const userVal = userVals[0];
       isCorrect = userVal != null && correctVals.includes(userVal);
-      y("qti validate: single cardinality check", {
+      logger2.debug("qti validate: single cardinality check", {
         responseId: respId,
         userVal,
         correctVals,
@@ -1828,7 +1638,7 @@ function validateResponsesFromXml(qtiXml, responses) {
       const correctSet2 = new Set(correctVals);
       const userSet = new Set(userVals);
       isCorrect = userSet.size === correctSet2.size && [...userSet].every((v) => correctSet2.has(v));
-      y("qti validate: multiple cardinality check", {
+      logger2.debug("qti validate: multiple cardinality check", {
         responseId: respId,
         userVals,
         correctVals,
@@ -1837,7 +1647,7 @@ function validateResponsesFromXml(qtiXml, responses) {
     }
     if (!isCorrect) allCorrect = false;
     responseCorrectness[respId] = isCorrect;
-    y("qti validate: evaluated response", {
+    logger2.debug("qti validate: evaluated response", {
       responseId: respId,
       selected: userVals,
       isCorrect
@@ -1861,7 +1671,7 @@ function validateResponsesFromXml(qtiXml, responses) {
         isCorrect: allCorrect,
         messageHtml: feedbackHtmlParts.join("")
       };
-      y("qti validate: overall feedback via response processing rules", {
+      logger2.debug("qti validate: overall feedback via response processing rules", {
         isCorrect: allCorrect,
         feedbackIds: feedbackIdentifiers,
         numBlocks: feedbackHtmlParts.length
@@ -1874,7 +1684,7 @@ function validateResponsesFromXml(qtiXml, responses) {
     );
     if (fallbackBlock) {
       overallFeedback = { isCorrect: allCorrect, messageHtml: sanitizeHtml(fallbackBlock.contentHtml) };
-      y("qti validate: overall feedback via fallback block", {
+      logger2.debug("qti validate: overall feedback via fallback block", {
         isCorrect: allCorrect,
         blockId: fallbackBlock.identifier
       });