@superbuilders/primer-tives 1.1.2 → 1.1.4

package/dist/client/index.js

@@ -0,0 +1,1074 @@
+// 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/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(`
+`);
+}
+// 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 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];
+    const currentCount = counts.get(key);
+    if (currentCount === undefined) {
+      counts.set(key, 1);
+      continue;
+    }
+    counts.set(key, currentCount + 1);
+  }
+  return counts;
+}
+function validateUsageBounds(choices, counts, side) {
+  const issues = [];
+  for (const choice of choices) {
+    const maybeCount = counts.get(choice.identifier);
+    const count = maybeCount === undefined ? 0 : maybeCount;
+    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;
+  }
+  const exhaustiveCheck = pciId;
+  return exhaustiveCheck;
+}
+function typeMismatch(interactionType, submissionType) {
+  return `submission type '${submissionType}' does not match interaction type '${interactionType}'`;
+}
+function buildResult(submission, issues) {
+  if (issues.length > 0) {
+    return { ok: false, issues };
+  }
+  return { ok: true, value: submission };
+}
+function validateChoice(interaction, submission) {
+  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(", ")}`);
+  }
+  return issues;
+}
+function validateExtendedText(interaction, submission) {
+  const issues = [];
+  if (interaction.cardinality === "single") {
+    if (submission.values.length !== 1) {
+      issues.push("single-cardinality extended-text requires exactly one value");
+    }
+    return issues;
+  }
+  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");
+  }
+  return issues;
+}
+function validateOrder(interaction, submission) {
+  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(", ")}`);
+  }
+  return issues;
+}
+function validateMatch(interaction, submission) {
+  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"));
+  return issues;
+}
+function validatePortableCustom(interaction, submission) {
+  if (submission.pciId !== interaction.pciId) {
+    return [
+      `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 result.error.issues.map(function toIssue(issue) {
+      return issue.message;
+    });
+  }
+  return [];
+}
+function validateSubmissionForInteraction(interaction, submission) {
+  switch (interaction.type) {
+    case "choice":
+      if (submission.type !== "choice") {
+        return { ok: false, issues: [typeMismatch(interaction.type, submission.type)] };
+      }
+      return buildResult(submission, validateChoice(interaction, submission));
+    case "text-entry":
+      if (submission.type !== "text-entry") {
+        return { ok: false, issues: [typeMismatch(interaction.type, submission.type)] };
+      }
+      return { ok: true, value: submission };
+    case "extended-text":
+      if (submission.type !== "extended-text") {
+        return { ok: false, issues: [typeMismatch(interaction.type, submission.type)] };
+      }
+      return buildResult(submission, validateExtendedText(interaction, submission));
+    case "order":
+      if (submission.type !== "order") {
+        return { ok: false, issues: [typeMismatch(interaction.type, submission.type)] };
+      }
+      return buildResult(submission, validateOrder(interaction, submission));
+    case "match":
+      if (submission.type !== "match") {
+        return { ok: false, issues: [typeMismatch(interaction.type, submission.type)] };
+      }
+      return buildResult(submission, validateMatch(interaction, submission));
+    case "portable-custom":
+      if (submission.type !== "portable-custom") {
+        return { ok: false, issues: [typeMismatch(interaction.type, submission.type)] };
+      }
+      return buildResult(submission, validatePortableCustom(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 isAdvanceErrorBody(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if ("error" in value && value.error !== undefined && typeof value.error !== "string") {
+    return false;
+  }
+  if ("detail" in value && value.detail !== undefined && typeof value.detail !== "string") {
+    return false;
+  }
+  return true;
+}
+function parseAdvanceErrorBody(body) {
+  if (body.length === 0) {
+    return null;
+  }
+  const parsed = errors2.trySync(function parseJson() {
+    return JSON.parse(body);
+  });
+  if (parsed.error) {
+    return null;
+  }
+  if (!isAdvanceErrorBody(parsed.data)) {
+    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;
+    }
+  };
+}
+export {
+  create
+};
+
+//# debugId=FDB6BAAD7743405564756E2164756E21