@superbuilders/primer-tives 1.1.0 → 1.1.2

package/dist/client/index.js

@@ -1,1085 +0,0 @@
-// src/errors.ts
-import * as errors from "@superbuilders/errors";
-var ErrNetwork = errors.new("network");
-var ErrJsonParse = errors.new("json parse");
-var ErrUnsupportedPci = errors.new("unsupported pci");
-var ErrInvalidAccessToken = errors.new("invalid access token");
-var ErrMalformedAccessToken = errors.new("malformed access token");
-var ErrTokenExpired = errors.new("access token expired");
-var ErrBadRequest = errors.new("bad request");
-var ErrServerError = errors.new("server error");
-var ErrTimeout = errors.new("timeout");
-var ErrForbidden = errors.new("forbidden");
-var ErrNotFound = errors.new("not found");
-var ErrConflict = errors.new("conflict");
-var ErrExternalAuthorityRequired = errors.new("external authority required");
-var ErrRateLimited = errors.new("rate limited");
-var ErrServiceUnavailable = errors.new("service unavailable");
-var ErrNotSerializable = errors.new("PrimerState is live in-memory state and must not be serialized or stored");
-var ErrInvalidSubmission = errors.new("invalid submission");
-var ErrInvalidSecretKey = errors.new("invalid secret key");
-var ErrStudentNotFound = errors.new("student not found");
-var ErrUnsupportedGrade = errors.new("unsupported grade");
-var ErrTimebackUnavailable = errors.new("timeback unavailable");
-// src/contracts/validation.ts
-import { z as z2 } from "zod";
-
-// src/contracts/pci-schemas.ts
-import { z } from "zod";
-var DivisionRemainderPropsSchema = z.object({
-  dividend: z.number(),
-  divisor: z.number()
-});
-var DivisionRemainderSubmissionSchema = z.object({
-  quotient: z.string(),
-  remainder: z.string()
-});
-var FractionOperandSchema = z.object({
-  numerator: z.number(),
-  denominator: z.number()
-});
-var FractionAdditionPropsSchema = z.object({
-  left: FractionOperandSchema,
-  right: FractionOperandSchema
-});
-var FractionAdditionSubmissionSchema = z.object({
-  numerator: z.string(),
-  denominator: z.string()
-});
-
-// src/contracts/validation.ts
-var MatchPairSchema = z2.object({
-  source: z2.string(),
-  target: z2.string()
-});
-var ChoiceSubmissionSchema = z2.object({
-  type: z2.literal("choice"),
-  selectedKeys: z2.array(z2.string())
-});
-var TextEntrySubmissionSchema = z2.object({
-  type: z2.literal("text-entry"),
-  value: z2.string()
-});
-var ExtendedTextSubmissionSchema = z2.object({
-  type: z2.literal("extended-text"),
-  values: z2.array(z2.string()).min(1)
-});
-var OrderSubmissionSchema = z2.object({
-  type: z2.literal("order"),
-  orderedKeys: z2.array(z2.string())
-});
-var MatchSubmissionSchema = z2.object({
-  type: z2.literal("match"),
-  pairs: z2.array(MatchPairSchema)
-});
-var DivisionRemainderPciSubmissionSchema = z2.object({
-  type: z2.literal("portable-custom"),
-  pciId: z2.literal("urn:primer:pci:division-remainder"),
-  value: DivisionRemainderSubmissionSchema
-});
-var FractionAdditionPciSubmissionSchema = z2.object({
-  type: z2.literal("portable-custom"),
-  pciId: z2.literal("urn:primer:pci:fraction-addition"),
-  value: FractionAdditionSubmissionSchema
-});
-var RendererSubmissionSchema = z2.union([
-  ChoiceSubmissionSchema,
-  TextEntrySubmissionSchema,
-  ExtendedTextSubmissionSchema,
-  OrderSubmissionSchema,
-  MatchSubmissionSchema,
-  DivisionRemainderPciSubmissionSchema,
-  FractionAdditionPciSubmissionSchema
-]);
-function invalid(issues) {
-  return { ok: false, issues: Array.isArray(issues) ? issues : [issues] };
-}
-function valid(submission) {
-  return {
-    ok: true,
-    value: submission
-  };
-}
-function duplicates(values, keyOf) {
-  const seen = new Set;
-  const duplicated = new Set;
-  for (const value of values) {
-    const key = keyOf(value);
-    if (seen.has(key)) {
-      duplicated.add(key);
-      continue;
-    }
-    seen.add(key);
-  }
-  return [...duplicated];
-}
-function findUnknownIds(values, choices) {
-  const ids = new Set(choices.map(function getId(choice) {
-    return choice.identifier;
-  }));
-  return values.filter(function isUnknown(value) {
-    return !ids.has(value);
-  });
-}
-function countByIdentifier(pairs, side) {
-  const counts = new Map;
-  for (const pair of pairs) {
-    const key = pair[side];
-    counts.set(key, (counts.get(key) ?? 0) + 1);
-  }
-  return counts;
-}
-function validateUsageBounds(choices, counts, side) {
-  const issues = [];
-  for (const choice of choices) {
-    const count = counts.get(choice.identifier) ?? 0;
-    if (choice.matchMax !== 0 && count > choice.matchMax) {
-      issues.push(`${side} '${choice.identifier}' used ${count} times, max ${choice.matchMax}`);
-    }
-    if (count < choice.matchMin) {
-      issues.push(`${side} '${choice.identifier}' used ${count} times, min ${choice.matchMin}`);
-    }
-  }
-  return issues;
-}
-function pciSubmissionSchema(pciId) {
-  switch (pciId) {
-    case "urn:primer:pci:division-remainder":
-      return DivisionRemainderSubmissionSchema;
-    case "urn:primer:pci:fraction-addition":
-      return FractionAdditionSubmissionSchema;
-  }
-}
-function validateChoiceSubmission(interaction, submission) {
-  if (submission.type !== "choice") {
-    return invalid(`submission type '${submission.type}' does not match interaction type 'choice'`);
-  }
-  const issues = [];
-  if (submission.selectedKeys.length < interaction.minChoices) {
-    issues.push(`need at least ${interaction.minChoices} selections`);
-  }
-  if (submission.selectedKeys.length > interaction.maxChoices) {
-    issues.push(`at most ${interaction.maxChoices} selections`);
-  }
-  const duplicateKeys = duplicates(submission.selectedKeys, function keyOf(value) {
-    return value;
-  });
-  if (duplicateKeys.length > 0) {
-    issues.push("duplicate selections");
-  }
-  const unknownKeys = findUnknownIds(submission.selectedKeys, interaction.options);
-  if (unknownKeys.length > 0) {
-    issues.push(`unknown options: ${unknownKeys.join(", ")}`);
-  }
-  if (issues.length > 0) {
-    return invalid(issues);
-  }
-  return valid(submission);
-}
-function validateTextEntrySubmission(interaction, submission) {
-  if (submission.type !== "text-entry") {
-    return invalid(`submission type '${submission.type}' does not match interaction type 'text-entry'`);
-  }
-  return valid(submission);
-}
-function validateExtendedTextSubmission(interaction, submission) {
-  if (submission.type !== "extended-text") {
-    return invalid(`submission type '${submission.type}' does not match interaction type 'extended-text'`);
-  }
-  const issues = [];
-  if (interaction.cardinality === "single") {
-    if (submission.values.length !== 1) {
-      issues.push("single-cardinality extended-text requires exactly one value");
-    }
-  } else {
-    if (submission.values.length < interaction.minStrings) {
-      issues.push(`need at least ${interaction.minStrings} values`);
-    }
-    if (submission.values.length > interaction.maxStrings) {
-      issues.push(`at most ${interaction.maxStrings} values`);
-    }
-    const duplicateValues = duplicates(submission.values, function keyOf(value) {
-      return value;
-    });
-    if (duplicateValues.length > 0) {
-      issues.push("duplicate values are not allowed for multiple-cardinality extended-text");
-    }
-  }
-  if (issues.length > 0) {
-    return invalid(issues);
-  }
-  return valid(submission);
-}
-function validateOrderSubmission(interaction, submission) {
-  if (submission.type !== "order") {
-    return invalid(`submission type '${submission.type}' does not match interaction type 'order'`);
-  }
-  const issues = [];
-  if (submission.orderedKeys.length < interaction.minChoices) {
-    issues.push(`need at least ${interaction.minChoices} selections`);
-  }
-  if (submission.orderedKeys.length > interaction.maxChoices) {
-    issues.push(`at most ${interaction.maxChoices} selections`);
-  }
-  const duplicateKeys = duplicates(submission.orderedKeys, function keyOf(value) {
-    return value;
-  });
-  if (duplicateKeys.length > 0) {
-    issues.push("duplicate selections");
-  }
-  const unknownKeys = findUnknownIds(submission.orderedKeys, interaction.choices);
-  if (unknownKeys.length > 0) {
-    issues.push(`unknown choices: ${unknownKeys.join(", ")}`);
-  }
-  if (issues.length > 0) {
-    return invalid(issues);
-  }
-  return valid(submission);
-}
-function validateMatchSubmission(interaction, submission) {
-  if (submission.type !== "match") {
-    return invalid(`submission type '${submission.type}' does not match interaction type 'match'`);
-  }
-  const issues = [];
-  if (submission.pairs.length < interaction.minAssociations) {
-    issues.push(`need at least ${interaction.minAssociations} associations`);
-  }
-  if (submission.pairs.length > interaction.maxAssociations) {
-    issues.push(`at most ${interaction.maxAssociations} associations`);
-  }
-  const duplicatePairs = duplicates(submission.pairs, function keyOf(pair) {
-    return `${pair.source}->${pair.target}`;
-  });
-  if (duplicatePairs.length > 0) {
-    issues.push("duplicate associations are not allowed");
-  }
-  const sourceIds = new Set(interaction.sourceChoices.map(function getId(choice) {
-    return choice.identifier;
-  }));
-  const targetIds = new Set(interaction.targetChoices.map(function getId(choice) {
-    return choice.identifier;
-  }));
-  for (const pair of submission.pairs) {
-    if (!sourceIds.has(pair.source)) {
-      issues.push(`unknown source '${pair.source}'`);
-    }
-    if (!targetIds.has(pair.target)) {
-      issues.push(`unknown target '${pair.target}'`);
-    }
-  }
-  const sourceCounts = countByIdentifier(submission.pairs, "source");
-  const targetCounts = countByIdentifier(submission.pairs, "target");
-  issues.push(...validateUsageBounds(interaction.sourceChoices, sourceCounts, "source"));
-  issues.push(...validateUsageBounds(interaction.targetChoices, targetCounts, "target"));
-  if (issues.length > 0) {
-    return invalid(issues);
-  }
-  return valid(submission);
-}
-function validatePortableCustomSubmission(interaction, submission) {
-  if (submission.type !== "portable-custom") {
-    return invalid(`submission type '${submission.type}' does not match interaction type 'portable-custom'`);
-  }
-  if (submission.pciId !== interaction.pciId) {
-    return invalid(`submission PCI '${submission.pciId}' does not match interaction PCI '${interaction.pciId}'`);
-  }
-  const schema = pciSubmissionSchema(interaction.pciId);
-  const result = schema.safeParse(submission.value);
-  if (!result.success) {
-    return invalid(result.error.issues.map(function toIssue(issue) {
-      return issue.message;
-    }));
-  }
-  return valid(submission);
-}
-function validateSubmissionForInteraction(interaction, submission) {
-  switch (interaction.type) {
-    case "choice":
-      return validateChoiceSubmission(interaction, submission);
-    case "text-entry":
-      return validateTextEntrySubmission(interaction, submission);
-    case "extended-text":
-      return validateExtendedTextSubmission(interaction, submission);
-    case "order":
-      return validateOrderSubmission(interaction, submission);
-    case "match":
-      return validateMatchSubmission(interaction, submission);
-    case "portable-custom":
-      return validatePortableCustomSubmission(interaction, submission);
-  }
-}
-function submissionValidationMessage(result) {
-  return result.issues.join("; ");
-}
-// src/client/create.ts
-import * as errors10 from "@superbuilders/errors";
-
-// src/client/transport.ts
-import * as errors2 from "@superbuilders/errors";
-var ADVANCE_PATH = "/api/v0/advance";
-function parseAdvanceErrorBody(body) {
-  if (body.length === 0) {
-    return null;
-  }
-  const parsed = errors2.trySync(function parseJson() {
-    return JSON.parse(body);
-  });
-  if (parsed.error) {
-    return null;
-  }
-  return parsed.data;
-}
-function httpSentinel(status, body) {
-  if (status === 400) {
-    return ErrBadRequest;
-  }
-  if (status === 401) {
-    const parsed = parseAdvanceErrorBody(body);
-    if (parsed?.detail === "token_expired") {
-      return ErrTokenExpired;
-    }
-    return ErrInvalidAccessToken;
-  }
-  if (status === 403) {
-    return ErrForbidden;
-  }
-  if (status === 404) {
-    return ErrNotFound;
-  }
-  if (status === 409) {
-    return ErrConflict;
-  }
-  if (status === 429) {
-    return ErrRateLimited;
-  }
-  if (status === 502 || status === 503 || status === 504) {
-    return ErrServiceUnavailable;
-  }
-  return ErrServerError;
-}
-function isAbortError(err) {
-  if (err instanceof DOMException && err.name === "AbortError") {
-    return true;
-  }
-  if (err instanceof DOMException && err.name === "TimeoutError") {
-    return true;
-  }
-  return false;
-}
-function createTransport(tc) {
-  const fetchFn = tc.fetch ? tc.fetch : globalThis.fetch;
-  const log = tc.log;
-  function transportSignal() {
-    if (tc.abort) {
-      return tc.abort.signal;
-    }
-    return;
-  }
-  async function transport(body) {
-    log?.debug("transport request", {
-      intentKind: body.intent.kind,
-      subject: body.subject
-    });
-    const url = `${tc.origin}${ADVANCE_PATH}`;
-    const fetchResult = await fetchFn(url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${tc.accessToken}`
-      },
-      body: JSON.stringify(body),
-      signal: transportSignal()
-    }).then(function ok(r) {
-      return { ok: true, response: r };
-    }, function fail(err) {
-      return { ok: false, error: err };
-    });
-    if (!fetchResult.ok) {
-      if (isAbortError(fetchResult.error)) {
-        log?.error("transport timeout", {
-          intentKind: body.intent.kind
-        });
-        return { ok: false, error: errors2.wrap(ErrTimeout, fetchResult.error.message) };
-      }
-      log?.error("transport network error", {
-        error: fetchResult.error
-      });
-      return { ok: false, error: errors2.wrap(ErrNetwork, fetchResult.error.message) };
-    }
-    const res = fetchResult.response;
-    if (!res.ok) {
-      const text = await res.text().catch(function fallback() {
-        return "";
-      });
-      const sentinel = res.status === 422 ? ErrUnsupportedPci : httpSentinel(res.status, text);
-      log?.error("transport http error", {
-        status: res.status
-      });
-      return { ok: false, error: errors2.wrap(sentinel, text) };
-    }
-    const jsonResult = await res.json().then(function ok(data) {
-      return { ok: true, data };
-    }, function fail(err) {
-      return { ok: false, error: err };
-    });
-    if (!jsonResult.ok) {
-      log?.error("transport json parse failed", {
-        error: jsonResult.error
-      });
-      return { ok: false, error: errors2.wrap(ErrJsonParse, jsonResult.error.message) };
-    }
-    log?.debug("transport success", {
-      intentKind: body.intent.kind
-    });
-    return { ok: true, data: jsonResult.data };
-  }
-  return transport;
-}
-
-// src/client/session.ts
-import * as errors9 from "@superbuilders/errors";
-
-// src/client/consumed.ts
-function poisonToJSON() {
-  throw ErrNotSerializable;
-}
-
-// src/client/choice-state.ts
-import * as errors3 from "@superbuilders/errors";
-function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices) {
-  let submitPending;
-  let submitKey;
-  let timeoutPending;
-  function beginSubmit(selectedKeys) {
-    const submission = { type: "choice", selectedKeys };
-    const key = JSON.stringify(submission);
-    if (timeoutPending) {
-      return Promise.resolve(ctx.errored(errors3.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    if (submitPending) {
-      if (submitKey === key) {
-        return submitPending;
-      }
-      return Promise.resolve(ctx.errored(errors3.wrap(ErrConflict, "cannot submit a different choice payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    const validation = validateSubmissionForInteraction(interaction, submission);
-    if (!validation.ok) {
-      ctx.log?.error("choice submit invalid", { selectedKeys, issues: validation.issues });
-      return Promise.resolve(ctx.errored(errors3.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
-    }
-    submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
-      submitPending = undefined;
-      submitKey = undefined;
-    });
-    return submitPending;
-  }
-  function beginTimeout() {
-    const intent = { kind: "timeout" };
-    if (submitPending) {
-      return Promise.resolve(ctx.errored(errors3.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
-    }
-    if (timeoutPending) {
-      return timeoutPending;
-    }
-    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
-      timeoutPending = undefined;
-    });
-    return timeoutPending;
-  }
-  return {
-    phase: "interaction",
-    kind: "choice",
-    stimulus,
-    interaction,
-    options,
-    maxChoices,
-    minChoices,
-    submitChoice: beginSubmit,
-    timeout: beginTimeout,
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/extended-text-state.ts
-import * as errors4 from "@superbuilders/errors";
-function extendedTextState(ctx, stimulus, interaction) {
-  if (interaction.cardinality === "single") {
-    let submitText = function(value) {
-      const submission = { type: "extended-text", values: [value] };
-      const key = JSON.stringify(submission);
-      if (timeoutPending2) {
-        return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
-      }
-      if (submitPending2) {
-        if (submitKey2 === key) {
-          return submitPending2;
-        }
-        return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
-      }
-      const validation = validateSubmissionForInteraction(interaction, submission);
-      if (!validation.ok) {
-        ctx.log?.error("extended-text submit invalid", { value, issues: validation.issues });
-        return Promise.resolve(ctx.errored(errors4.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
-      }
-      submitKey2 = key;
-      submitPending2 = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
-        submitPending2 = undefined;
-        submitKey2 = undefined;
-      });
-      return submitPending2;
-    }, timeout2 = function() {
-      const intent = { kind: "timeout" };
-      if (submitPending2) {
-        return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
-      }
-      if (timeoutPending2) {
-        return timeoutPending2;
-      }
-      timeoutPending2 = ctx.execute(intent, "timeout").finally(function clearPending() {
-        timeoutPending2 = undefined;
-      });
-      return timeoutPending2;
-    };
-    let submitPending2;
-    let submitKey2;
-    let timeoutPending2;
-    return {
-      phase: "interaction",
-      kind: "extended-text",
-      cardinality: "single",
-      stimulus,
-      interaction,
-      submitText,
-      timeout: timeout2,
-      toJSON: poisonToJSON
-    };
-  }
-  const multi = interaction;
-  let submitPending;
-  let submitKey;
-  let timeoutPending;
-  function submitTexts(values) {
-    const submission = { type: "extended-text", values };
-    const key = JSON.stringify(submission);
-    if (timeoutPending) {
-      return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    if (submitPending) {
-      if (submitKey === key) {
-        return submitPending;
-      }
-      return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    const validation = validateSubmissionForInteraction(multi, submission);
-    if (!validation.ok) {
-      ctx.log?.error("extended-text submit invalid", { values, issues: validation.issues });
-      return Promise.resolve(ctx.errored(errors4.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
-    }
-    submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
-      submitPending = undefined;
-      submitKey = undefined;
-    });
-    return submitPending;
-  }
-  function timeout() {
-    const intent = { kind: "timeout" };
-    if (submitPending) {
-      return Promise.resolve(ctx.errored(errors4.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
-    }
-    if (timeoutPending) {
-      return timeoutPending;
-    }
-    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
-      timeoutPending = undefined;
-    });
-    return timeoutPending;
-  }
-  return {
-    phase: "interaction",
-    kind: "extended-text",
-    cardinality: "multiple",
-    stimulus,
-    interaction: multi,
-    maxStrings: multi.maxStrings,
-    minStrings: multi.minStrings,
-    submitTexts,
-    timeout,
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/feedback-state.ts
-function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedbackContent, review) {
-  let pending;
-  return {
-    phase: "feedback",
-    stimulus,
-    interaction,
-    submission,
-    isCorrect,
-    feedbackContent,
-    review,
-    advance: function advance() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "observation" }, "observation");
-      return pending;
-    },
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/match-state.ts
-import * as errors5 from "@superbuilders/errors";
-function matchState(ctx, stimulus, interaction) {
-  let submitPending;
-  let submitKey;
-  let timeoutPending;
-  function submitMatch(pairs) {
-    const submission = { type: "match", pairs };
-    const key = JSON.stringify(submission);
-    if (timeoutPending) {
-      return Promise.resolve(ctx.errored(errors5.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    if (submitPending) {
-      if (submitKey === key) {
-        return submitPending;
-      }
-      return Promise.resolve(ctx.errored(errors5.wrap(ErrConflict, "cannot submit a different match payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    const validation = validateSubmissionForInteraction(interaction, submission);
-    if (!validation.ok) {
-      ctx.log?.error("match submit invalid", { pairs, issues: validation.issues });
-      return Promise.resolve(ctx.errored(errors5.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
-    }
-    submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
-      submitPending = undefined;
-      submitKey = undefined;
-    });
-    return submitPending;
-  }
-  function timeout() {
-    const intent = { kind: "timeout" };
-    if (submitPending) {
-      return Promise.resolve(ctx.errored(errors5.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
-    }
-    if (timeoutPending) {
-      return timeoutPending;
-    }
-    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
-      timeoutPending = undefined;
-    });
-    return timeoutPending;
-  }
-  return {
-    phase: "interaction",
-    kind: "match",
-    stimulus,
-    interaction,
-    sourceChoices: interaction.sourceChoices,
-    targetChoices: interaction.targetChoices,
-    minAssociations: interaction.minAssociations,
-    maxAssociations: interaction.maxAssociations,
-    submitMatch,
-    timeout,
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/observation-state.ts
-function observationState(ctx, stimulus) {
-  let pending;
-  return {
-    phase: "observation",
-    stimulus,
-    advance: function advance() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "observation" }, "observation");
-      return pending;
-    },
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/order-state.ts
-import * as errors6 from "@superbuilders/errors";
-function orderState(ctx, stimulus, interaction) {
-  let submitPending;
-  let submitKey;
-  let timeoutPending;
-  function submitOrder(orderedKeys) {
-    const submission = { type: "order", orderedKeys };
-    const key = JSON.stringify(submission);
-    if (timeoutPending) {
-      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    if (submitPending) {
-      if (submitKey === key) {
-        return submitPending;
-      }
-      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit a different order payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    const validation = validateSubmissionForInteraction(interaction, submission);
-    if (!validation.ok) {
-      ctx.log?.error("order submit invalid", { orderedKeys, issues: validation.issues });
-      return Promise.resolve(ctx.errored(errors6.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
-    }
-    submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
-      submitPending = undefined;
-      submitKey = undefined;
-    });
-    return submitPending;
-  }
-  function timeout() {
-    const intent = { kind: "timeout" };
-    if (submitPending) {
-      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
-    }
-    if (timeoutPending) {
-      return timeoutPending;
-    }
-    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
-      timeoutPending = undefined;
-    });
-    return timeoutPending;
-  }
-  return {
-    phase: "interaction",
-    kind: "order",
-    stimulus,
-    interaction,
-    choices: interaction.choices,
-    minChoices: interaction.minChoices,
-    maxChoices: interaction.maxChoices,
-    submitOrder,
-    timeout,
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/pci-state.ts
-import * as errors7 from "@superbuilders/errors";
-function pciInteractionState(ctx, stimulus, interaction) {
-  let submitPending;
-  let submitKey;
-  let timeoutPending;
-  const { pciId, properties } = interaction;
-  function submit(value) {
-    const submission = { type: "portable-custom", pciId, value };
-    const key = JSON.stringify(submission);
-    if (timeoutPending) {
-      return Promise.resolve(ctx.errored(errors7.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    if (submitPending) {
-      if (submitKey === key) {
-        return submitPending;
-      }
-      return Promise.resolve(ctx.errored(errors7.wrap(ErrConflict, "cannot submit a different pci payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    ctx.log?.debug("pci submit", { pciId });
-    submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
-      submitPending = undefined;
-      submitKey = undefined;
-    });
-    return submitPending;
-  }
-  function timeout() {
-    const intent = { kind: "timeout" };
-    if (submitPending) {
-      return Promise.resolve(ctx.errored(errors7.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
-    }
-    if (timeoutPending) {
-      return timeoutPending;
-    }
-    ctx.log?.debug("pci timeout", { pciId });
-    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
-      timeoutPending = undefined;
-    });
-    return timeoutPending;
-  }
-  return {
-    phase: "interaction",
-    kind: "portable-custom",
-    stimulus,
-    interaction,
-    pciId,
-    properties,
-    submit,
-    timeout,
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/text-entry-state.ts
-import * as errors8 from "@superbuilders/errors";
-function textEntryState(ctx, stimulus, interaction) {
-  let submitPending;
-  let submitKey;
-  let timeoutPending;
-  function submitText(value) {
-    const submission = { type: "text-entry", value };
-    const key = JSON.stringify(submission);
-    if (timeoutPending) {
-      return Promise.resolve(ctx.errored(errors8.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    if (submitPending) {
-      if (submitKey === key) {
-        return submitPending;
-      }
-      return Promise.resolve(ctx.errored(errors8.wrap(ErrConflict, "cannot submit a different text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
-    }
-    const validation = validateSubmissionForInteraction(interaction, submission);
-    if (!validation.ok) {
-      ctx.log?.error("text-entry submit invalid", { value, issues: validation.issues });
-      return Promise.resolve(ctx.errored(errors8.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
-    }
-    submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
-      submitPending = undefined;
-      submitKey = undefined;
-    });
-    return submitPending;
-  }
-  function timeout() {
-    const intent = { kind: "timeout" };
-    if (submitPending) {
-      return Promise.resolve(ctx.errored(errors8.wrap(ErrConflict, "cannot timeout while submission is in flight"), "timeout", intent));
-    }
-    if (timeoutPending) {
-      return timeoutPending;
-    }
-    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
-      timeoutPending = undefined;
-    });
-    return timeoutPending;
-  }
-  return {
-    phase: "interaction",
-    kind: "text-entry",
-    stimulus,
-    interaction,
-    submitText,
-    timeout,
-    toJSON: poisonToJSON
-  };
-}
-
-// src/client/session.ts
-var FATAL_SENTINELS = [
-  ErrBadRequest,
-  ErrInvalidAccessToken,
-  ErrTokenExpired,
-  ErrForbidden,
-  ErrNotFound,
-  ErrUnsupportedPci
-];
-function isFatalError(err) {
-  for (const sentinel of FATAL_SENTINELS) {
-    if (errors9.is(err, sentinel)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isRetriableError(err) {
-  return !errors9.is(err, ErrInvalidSubmission);
-}
-function makeSession(sc) {
-  const log = sc.log;
-  function resolve(result) {
-    switch (result.outcome) {
-      case "advanced":
-        return fromAdvanced(result.stimulus, result.interaction);
-      case "submitted":
-        return feedbackState(ctx, result.stimulus, result.interaction, result.submission, result.isCorrect, result.feedbackContent, result.review);
-      case "completed":
-        return { phase: "completed", toJSON: poisonToJSON };
-    }
-  }
-  function errored(error, failedPhase, intent) {
-    let pending;
-    const retriable = isRetriableError(error);
-    const state = {
-      phase: "errored",
-      error,
-      retriable,
-      retry: function retry() {
-        if (!retriable) {
-          log?.debug("retry ignored for non-retriable error", { failedPhase });
-          return Promise.resolve(state);
-        }
-        if (pending) {
-          return pending;
-        }
-        log?.debug("retrying from errored state", { failedPhase });
-        pending = execute(intent, failedPhase);
-        return pending;
-      },
-      toJSON: poisonToJSON
-    };
-    return state;
-  }
-  async function execute(intent, phase) {
-    const body = {
-      supportedPcis: sc.supportedPcis,
-      intent,
-      subject: sc.subject
-    };
-    const result = await sc.transport(body);
-    if (!result.ok) {
-      if (isFatalError(result.error)) {
-        log?.error("fatal transport error", { error: result.error, phase });
-        return { phase: "fatal", error: result.error, retriable: false, toJSON: poisonToJSON };
-      }
-      return errored(result.error, phase, intent);
-    }
-    return resolve(result.data);
-  }
-  function isPciSupported(pciId) {
-    for (const id of sc.supportedPcis) {
-      if (id === pciId) {
-        return true;
-      }
-    }
-    return false;
-  }
-  function fromAdvanced(stimulus, interaction) {
-    if (interaction === null) {
-      return observationState(ctx, stimulus);
-    }
-    if (interaction.type === "portable-custom") {
-      if (!isPciSupported(interaction.pciId)) {
-        log?.error("unsupported pci in frame", { pciId: interaction.pciId });
-        return {
-          phase: "fatal",
-          error: errors9.wrap(ErrUnsupportedPci, `pci '${interaction.pciId}'`),
-          retriable: false,
-          toJSON: poisonToJSON
-        };
-      }
-    }
-    return pendingInteractionState(stimulus, interaction);
-  }
-  function pendingInteractionState(stimulus, interaction) {
-    switch (interaction.type) {
-      case "choice":
-        return choiceState(ctx, stimulus, interaction, interaction.options, interaction.maxChoices, interaction.minChoices);
-      case "text-entry":
-        return textEntryState(ctx, stimulus, interaction);
-      case "extended-text":
-        return extendedTextState(ctx, stimulus, interaction);
-      case "order":
-        return orderState(ctx, stimulus, interaction);
-      case "match":
-        return matchState(ctx, stimulus, interaction);
-      case "portable-custom":
-        return pciInteractionState(ctx, stimulus, interaction);
-    }
-  }
-  const ctx = { log, execute, errored };
-  return { execute };
-}
-
-// src/client/create.ts
-var ACCESS_TOKEN_PREFIX = "eyJ";
-function isMalformedJws(token) {
-  if (!token.startsWith(ACCESS_TOKEN_PREFIX)) {
-    return true;
-  }
-  const dotCount = token.split(".").length - 1;
-  return dotCount !== 2;
-}
-function create(config) {
-  const log = config.logger;
-  if (isMalformedJws(config.accessToken)) {
-    log?.error("malformed access token", { prefix: ACCESS_TOKEN_PREFIX });
-    throw errors10.wrap(ErrMalformedAccessToken, `token must start with '${ACCESS_TOKEN_PREFIX}' and contain two dots`);
-  }
-  const transport = createTransport({
-    accessToken: config.accessToken,
-    supportedPcis: config.supportedPcis,
-    origin: config.origin,
-    fetch: config.fetch,
-    abort: config.abort,
-    log
-  });
-  let startPromise;
-  async function doStart() {
-    log?.debug("start", { subject: config.subject });
-    const s = makeSession({
-      supportedPcis: config.supportedPcis,
-      subject: config.subject,
-      log,
-      transport
-    });
-    return s.execute({ kind: "observation" }, "observation");
-  }
-  return {
-    start() {
-      if (startPromise) {
-        log?.debug("start already called");
-        return startPromise;
-      }
-      startPromise = doStart();
-      return startPromise;
-    }
-  };
-}
-// src/subject.ts
-var SUBJECTS = ["math", "vocabulary", "science"];
-// src/client/content.ts
-function inlinesToPlainText(nodes) {
-  const parts = [];
-  for (const node of nodes) {
-    switch (node.type) {
-      case "text":
-        parts.push(node.value);
-        break;
-      case "italic":
-        parts.push(node.value);
-        break;
-      case "latex":
-        parts.push(node.value);
-        break;
-    }
-  }
-  return parts.join("");
-}
-function blocksToPlainText(blocks) {
-  return blocks.map(function blockText(block) {
-    return inlinesToPlainText(block.children);
-  }).join(`
-`);
-}
-export {
-  inlinesToPlainText,
-  create,
-  blocksToPlainText,
-  SUBJECTS,
-  ErrUnsupportedPci,
-  ErrTokenExpired,
-  ErrTimeout,
-  ErrServiceUnavailable,
-  ErrServerError,
-  ErrRateLimited,
-  ErrNotSerializable,
-  ErrNotFound,
-  ErrNetwork,
-  ErrMalformedAccessToken,
-  ErrJsonParse,
-  ErrInvalidSubmission,
-  ErrInvalidAccessToken,
-  ErrForbidden,
-  ErrConflict,
-  ErrBadRequest
-};
-
-//# debugId=BFF38D60446A9E1864756E2164756E21