@superbuilders/primer-tives 5.0.4 → 6.0.0

package/dist/client/index.js

@@ -6284,6 +6284,8 @@ var ErrNoRoutableContent = errors.new("no routable content");
 var ErrNoActiveFrame = errors.new("no active frame");
 var ErrFrameAlreadyAnswered = errors.new("frame already answered");
 var ErrSessionStateConflict = errors.new("session state conflict");
+// src/grade-level.ts
+var GRADE_LEVELS = ["K", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12"];
 // src/contracts/content.ts
 function inlinesToPlainText(nodes) {
   const parts = [];
@@ -6594,33 +6596,6 @@ function findUnknownIds(values, choices) {
     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 issues2 = [];
-  for (const choice of choices) {
-    const maybeCount = counts.get(choice.identifier);
-    const count = maybeCount === undefined ? 0 : maybeCount;
-    if (choice.matchMax !== 0 && count > choice.matchMax) {
-      issues2.push(`${side} '${choice.identifier}' used ${count} times, max ${choice.matchMax}`);
-    }
-    if (count < choice.matchMin) {
-      issues2.push(`${side} '${choice.identifier}' used ${count} times, min ${choice.matchMin}`);
-    }
-  }
-  return issues2;
-}
 function pciSubmissionSchema(pciId) {
   switch (pciId) {
     case "urn:primer:pci:fraction-input":
@@ -6714,6 +6689,18 @@ function validateMatch(interaction, submission) {
   if (duplicatePairs.length > 0) {
     issues2.push("duplicate associations are not allowed");
   }
+  const duplicateSources = duplicates(submission.pairs, function keyOf(pair) {
+    return pair.source;
+  });
+  if (duplicateSources.length > 0) {
+    issues2.push(`duplicate sources: ${duplicateSources.join(", ")}`);
+  }
+  const duplicateTargets = duplicates(submission.pairs, function keyOf(pair) {
+    return pair.target;
+  });
+  if (duplicateTargets.length > 0) {
+    issues2.push(`duplicate targets: ${duplicateTargets.join(", ")}`);
+  }
   const sourceIds = new Set(interaction.sourceChoices.map(function getId(choice) {
     return choice.identifier;
   }));
@@ -6728,10 +6715,6 @@ function validateMatch(interaction, submission) {
       issues2.push(`unknown target '${pair.target}'`);
     }
   }
-  const sourceCounts = countByIdentifier(submission.pairs, "source");
-  const targetCounts = countByIdentifier(submission.pairs, "target");
-  issues2.push(...validateUsageBounds(interaction.sourceChoices, sourceCounts, "source"));
-  issues2.push(...validateUsageBounds(interaction.targetChoices, targetCounts, "target"));
   return issues2;
 }
 function validatePortableCustom(interaction, submission) {
@@ -7263,6 +7246,7 @@ function pendingLogin(config) {
 function signInRequiredState(config) {
   return {
     phase: "sign-in-required",
+    journey: config.journey,
     login: pendingLogin(config),
     toJSON: poisonToJSON
   };
@@ -7270,32 +7254,210 @@ function signInRequiredState(config) {
 function signInFailedState(config) {
   return {
     phase: "sign-in-failed",
+    journey: config.journey,
     error: config.error,
     login: pendingLogin(config),
     toJSON: poisonToJSON
   };
 }
-function authUnavailableState(error) {
+function authUnavailableState(error, journey) {
   return {
     phase: "auth-unavailable",
+    journey,
     error,
     toJSON: poisonToJSON
   };
 }
-function authConfigInvalidState(error) {
+function authConfigInvalidState(error, journey) {
   return {
     phase: "auth-config-invalid",
+    journey,
     error,
     toJSON: poisonToJSON
   };
 }
 
+// src/client/journey.ts
+var ONBOARDING_JOURNEY = {
+  mode: "onboarding"
+};
+var GRADE_LEVEL_SET = new Set(GRADE_LEVELS);
+var FORBIDDEN_JOURNEY_KEYS = new Set([
+  "id",
+  "Id",
+  "uuid",
+  "handle",
+  "cursor",
+  "delta",
+  "standard",
+  "prerequisite",
+  "theme",
+  "area",
+  "map",
+  "remaining",
+  "completedFrames",
+  "totalFrames",
+  "accuracy",
+  "normalizedProgress",
+  "progressValue",
+  "mastery",
+  "threshold",
+  "placement",
+  "routingTarget",
+  "instructional",
+  "frameId"
+]);
+function isGradeLevel(value) {
+  return GRADE_LEVEL_SET.has(value);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function containsNull(value) {
+  if (value === null) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      if (containsNull(item)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (isRecord2(value)) {
+    for (const key in value) {
+      if (containsNull(value[key])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function forbiddenJourneyKey(value) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      const found = forbiddenJourneyKey(item);
+      if (found !== null) {
+        return found;
+      }
+    }
+    return null;
+  }
+  if (!isRecord2(value)) {
+    return null;
+  }
+  for (const key in value) {
+    if (FORBIDDEN_JOURNEY_KEYS.has(key)) {
+      return key;
+    }
+    const found = forbiddenJourneyKey(value[key]);
+    if (found !== null) {
+      return found;
+    }
+  }
+  return null;
+}
+function readString(value, key) {
+  const field = value[key];
+  if (typeof field !== "string") {
+    return null;
+  }
+  if (field.trim().length === 0) {
+    return null;
+  }
+  return field;
+}
+function readGradeLevel(value) {
+  const level = readString(value, "level");
+  if (level === null) {
+    return null;
+  }
+  if (!isGradeLevel(level)) {
+    return null;
+  }
+  return level;
+}
+function parseProgress(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const done = value.done;
+  const total = value.total;
+  if (typeof done !== "number" || typeof total !== "number") {
+    return null;
+  }
+  if (!Number.isInteger(done) || !Number.isInteger(total)) {
+    return null;
+  }
+  if (done < 0 || total < 0 || done > total) {
+    return null;
+  }
+  return { done, total };
+}
+function parseGradeWithLevel(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const level = readGradeLevel(value);
+  const progress = parseProgress(value.progress);
+  if (level === null || progress === null) {
+    return null;
+  }
+  return { level, progress };
+}
+function parseTitledProgress(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  const title = readString(value, "title");
+  const progress = parseProgress(value.progress);
+  if (title === null || progress === null) {
+    return null;
+  }
+  return { title, progress };
+}
+function parseJourney(value) {
+  if (!isRecord2(value)) {
+    return { ok: false, reason: "journey_not_object" };
+  }
+  if (containsNull(value)) {
+    return { ok: false, reason: "journey_contains_null" };
+  }
+  const forbidden = forbiddenJourneyKey(value);
+  if (forbidden !== null) {
+    return { ok: false, reason: `journey_forbidden_key:${forbidden}` };
+  }
+  const mode = value.mode;
+  if (mode === "onboarding") {
+    return { ok: true, journey: ONBOARDING_JOURNEY };
+  }
+  if (mode === "complete") {
+    const grade = parseGradeWithLevel(value.grade);
+    const course = parseTitledProgress(value.course);
+    if (grade === null || course === null) {
+      return { ok: false, reason: "journey_complete_invalid" };
+    }
+    return { ok: true, journey: { mode, grade, course } };
+  }
+  if (mode === "learning" || mode === "practice" || mode === "support") {
+    const grade = parseGradeWithLevel(value.grade);
+    const course = parseTitledProgress(value.course);
+    const lesson = parseTitledProgress(value.lesson);
+    if (grade === null || course === null || lesson === null) {
+      return { ok: false, reason: "journey_active_invalid" };
+    }
+    return { ok: true, journey: { mode, grade, course, lesson } };
+  }
+  return { ok: false, reason: "journey_mode_invalid" };
+}
+
 // src/client/session.ts
 import * as errors11 from "@superbuilders/errors";
 
 // src/client/choice-state.ts
 import * as errors5 from "@superbuilders/errors";
-function choiceState(ctx, body, stimulus, interaction, options, maxChoices, minChoices, feedback) {
+function choiceState(ctx, journey, body, stimulus, interaction, options, maxChoices, minChoices, feedback) {
   let submitPending;
   let submitKey;
   let timeoutPending;
@@ -7339,6 +7501,7 @@ function choiceState(ctx, body, stimulus, interaction, options, maxChoices, minC
   return {
     phase: "interaction",
     kind: "choice",
+    journey,
     body,
     stimulus,
     interaction,
@@ -7354,27 +7517,37 @@ function choiceState(ctx, body, stimulus, interaction, options, maxChoices, minC
 
 // src/client/extended-text-state.ts
 import * as errors6 from "@superbuilders/errors";
-function extendedTextState(ctx, body, stimulus, interaction, feedback) {
+function extendedTextIntent(submission, nextSubmissionRole) {
+  if (nextSubmissionRole === "revision") {
+    return { kind: "interaction", submission, submissionRole: "revision" };
+  }
+  return { kind: "interaction", submission };
+}
+function extendedTextState(ctx, journey, body, stimulus, interaction, feedback, options = {}) {
   if (interaction.cardinality === "single") {
     let submitText = function(value) {
-      const submission = { type: "extended-text", values: [value] };
+      const submission = {
+        type: "extended-text",
+        values: [value]
+      };
+      const intent = extendedTextIntent(submission, options.nextSubmissionRole);
       const key = JSON.stringify(submission);
       if (timeoutPending2) {
-        return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+        return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", intent));
       }
       if (submitPending2) {
         if (submitKey2 === key) {
           return submitPending2;
         }
-        return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+        return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", intent));
       }
       const validation = validateSubmissionForInteraction(interaction, submission);
       if (!validation.ok) {
         ctx.logger.error({ value, issues: validation.issues }, "extended-text submit invalid");
-        return Promise.resolve(ctx.errored(errors6.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
+        return Promise.resolve(ctx.errored(errors6.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", intent));
       }
       submitKey2 = key;
-      submitPending2 = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending2 = ctx.execute(intent, "interaction").finally(function clearPending() {
         submitPending2 = undefined;
         submitKey2 = undefined;
       });
@@ -7399,10 +7572,12 @@ function extendedTextState(ctx, body, stimulus, interaction, feedback) {
       phase: "interaction",
       kind: "extended-text",
       cardinality: "single",
+      journey,
       body,
       stimulus,
       interaction,
       feedback,
+      initialValue: options.initialValue,
       submitText,
       timeout: timeout2,
       toJSON: poisonToJSON
@@ -7413,24 +7588,28 @@ function extendedTextState(ctx, body, stimulus, interaction, feedback) {
   let submitKey;
   let timeoutPending;
   function submitTexts(values) {
-    const submission = { type: "extended-text", values };
+    const submission = {
+      type: "extended-text",
+      values
+    };
+    const intent = extendedTextIntent(submission, options.nextSubmissionRole);
     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 }));
+      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", intent));
     }
     if (submitPending) {
       if (submitKey === key) {
         return submitPending;
       }
-      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+      return Promise.resolve(ctx.errored(errors6.wrap(ErrConflict, "cannot submit a different extended-text payload while submit is in flight"), "interaction", intent));
     }
     const validation = validateSubmissionForInteraction(multi, submission);
     if (!validation.ok) {
       ctx.logger.error({ values, issues: validation.issues }, "extended-text submit invalid");
-      return Promise.resolve(ctx.errored(errors6.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
+      return Promise.resolve(ctx.errored(errors6.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", intent));
     }
     submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+    submitPending = ctx.execute(intent, "interaction").finally(function clearPending() {
       submitPending = undefined;
       submitKey = undefined;
     });
@@ -7453,10 +7632,12 @@ function extendedTextState(ctx, body, stimulus, interaction, feedback) {
     phase: "interaction",
     kind: "extended-text",
     cardinality: "multiple",
+    journey,
     body,
     stimulus,
     interaction: multi,
     feedback,
+    initialValues: options.initialValues,
     maxStrings: multi.maxStrings,
     minStrings: multi.minStrings,
     submitTexts,
@@ -7476,25 +7657,27 @@ function createAdvance(ctx) {
     return pending;
   };
 }
-function submittedFeedbackState(ctx, body, stimulus, interaction, submission, assessmentOutcome, feedbackContent, review) {
+function submittedFeedbackState(ctx, journey, body, stimulus, interaction, submission, isCorrect, feedbackContent, review) {
   return {
     phase: "feedback",
     feedbackKind: "submitted",
+    journey,
     body,
     stimulus,
     interaction,
     submission,
-    assessmentOutcome,
+    isCorrect,
     feedbackContent,
     review,
     advance: createAdvance(ctx),
     toJSON: poisonToJSON
   };
 }
-function timedOutFeedbackState(ctx, body, stimulus, interaction, feedbackContent) {
+function timedOutFeedbackState(ctx, journey, body, stimulus, interaction, feedbackContent) {
   return {
     phase: "feedback",
     feedbackKind: "timedOut",
+    journey,
     body,
     stimulus,
     interaction,
@@ -7506,7 +7689,7 @@ function timedOutFeedbackState(ctx, body, stimulus, interaction, feedbackContent
 
 // src/client/match-state.ts
 import * as errors7 from "@superbuilders/errors";
-function matchState(ctx, body, stimulus, interaction, feedback) {
+function matchState(ctx, journey, body, stimulus, interaction, feedback) {
   let submitPending;
   let submitKey;
   let timeoutPending;
@@ -7550,6 +7733,7 @@ function matchState(ctx, body, stimulus, interaction, feedback) {
   return {
     phase: "interaction",
     kind: "match",
+    journey,
     body,
     stimulus,
     interaction,
@@ -7565,10 +7749,11 @@ function matchState(ctx, body, stimulus, interaction, feedback) {
 }
 
 // src/client/observation-state.ts
-function observationState(ctx, body, stimulus) {
+function observationState(ctx, journey, body, stimulus) {
   let pending;
   return {
     phase: "observation",
+    journey,
     body,
     stimulus,
     advance: function advance() {
@@ -7584,7 +7769,7 @@ function observationState(ctx, body, stimulus) {
 
 // src/client/order-state.ts
 import * as errors8 from "@superbuilders/errors";
-function orderState(ctx, body, stimulus, interaction, feedback) {
+function orderState(ctx, journey, body, stimulus, interaction, feedback) {
   let submitPending;
   let submitKey;
   let timeoutPending;
@@ -7628,6 +7813,7 @@ function orderState(ctx, body, stimulus, interaction, feedback) {
   return {
     phase: "interaction",
     kind: "order",
+    journey,
     body,
     stimulus,
     interaction,
@@ -7643,7 +7829,7 @@ function orderState(ctx, body, stimulus, interaction, feedback) {
 
 // src/client/pci-state.ts
 import * as errors9 from "@superbuilders/errors";
-function pciInteractionState(ctx, body, stimulus, interaction, feedback) {
+function pciInteractionState(ctx, journey, body, stimulus, interaction, feedback) {
   let submitPending;
   let submitKey;
   let timeoutPending;
@@ -7685,6 +7871,7 @@ function pciInteractionState(ctx, body, stimulus, interaction, feedback) {
   return {
     phase: "interaction",
     kind: "portable-custom",
+    journey,
     body,
     stimulus,
     interaction,
@@ -7699,29 +7886,39 @@ function pciInteractionState(ctx, body, stimulus, interaction, feedback) {
 
 // src/client/text-entry-state.ts
 import * as errors10 from "@superbuilders/errors";
-function textEntryState(ctx, body, stimulus, interaction, feedback) {
+function textEntryIntent(submission, nextSubmissionRole) {
+  if (nextSubmissionRole === "revision") {
+    return { kind: "interaction", submission, submissionRole: "revision" };
+  }
+  return { kind: "interaction", submission };
+}
+function textEntryState(ctx, journey, body, stimulus, interaction, feedback, options = {}) {
   let submitPending;
   let submitKey;
   let timeoutPending;
   function submitText(value) {
-    const submission = { type: "text-entry", value };
+    const submission = {
+      type: "text-entry",
+      value
+    };
+    const intent = textEntryIntent(submission, options.nextSubmissionRole);
     const key = JSON.stringify(submission);
     if (timeoutPending) {
-      return Promise.resolve(ctx.errored(errors10.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", { kind: "interaction", submission }));
+      return Promise.resolve(ctx.errored(errors10.wrap(ErrConflict, "cannot submit while timeout is in flight"), "interaction", intent));
     }
     if (submitPending) {
       if (submitKey === key) {
         return submitPending;
       }
-      return Promise.resolve(ctx.errored(errors10.wrap(ErrConflict, "cannot submit a different text payload while submit is in flight"), "interaction", { kind: "interaction", submission }));
+      return Promise.resolve(ctx.errored(errors10.wrap(ErrConflict, "cannot submit a different text payload while submit is in flight"), "interaction", intent));
     }
     const validation = validateSubmissionForInteraction(interaction, submission);
     if (!validation.ok) {
       ctx.logger.error({ value, issues: validation.issues }, "text-entry submit invalid");
-      return Promise.resolve(ctx.errored(errors10.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", { kind: "interaction", submission }));
+      return Promise.resolve(ctx.errored(errors10.wrap(ErrInvalidSubmission, submissionValidationMessage(validation)), "interaction", intent));
     }
     submitKey = key;
-    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+    submitPending = ctx.execute(intent, "interaction").finally(function clearPending() {
       submitPending = undefined;
       submitKey = undefined;
     });
@@ -7743,10 +7940,12 @@ function textEntryState(ctx, body, stimulus, interaction, feedback) {
   return {
     phase: "interaction",
     kind: "text-entry",
+    journey,
     body,
     stimulus,
     interaction,
     feedback,
+    initialValue: options.initialValue,
     submitText,
     timeout,
     toJSON: poisonToJSON
@@ -7781,29 +7980,43 @@ function isRetriableError(err) {
 }
 function makeSession(sc) {
   const logger = sc.logger;
-  function resolve(result) {
+  let latestJourney = ONBOARDING_JOURNEY;
+  function advancedPreservedSubmission(result, intent) {
+    if (result.outcome !== "advanced") {
+      return;
+    }
+    if (result.frame.feedback === null) {
+      return;
+    }
+    if (intent.kind !== "interaction") {
+      return;
+    }
+    if (intent.submission.type === "text-entry" || intent.submission.type === "extended-text") {
+      return intent.submission;
+    }
+    return;
+  }
+  function resolve(result, intent) {
+    latestJourney = result.journey;
     switch (result.outcome) {
-      case "advanced":
-        return fromAdvanced(result.frame.body, result.frame.stimulus, result.frame.interaction, result.frame.feedback);
+      case "advanced": {
+        const preservedSubmission = advancedPreservedSubmission(result, intent);
+        const nextSubmissionRole = preservedSubmission === undefined ? undefined : "revision";
+        return fromAdvanced(result.journey, result.frame.body, result.frame.stimulus, result.frame.interaction, result.frame.feedback, preservedSubmission, nextSubmissionRole);
+      }
       case "submitted": {
         const interaction = result.frame.interaction;
         if (interaction === null) {
           logger.error("submitted result without interaction");
           return {
             phase: "fatal",
+            journey: result.journey,
             error: errors11.wrap(ErrBadRequest, "submitted result missing interaction"),
             retriable: false,
             toJSON: poisonToJSON
           };
         }
-        if (result.assessmentOutcome.value === "revisionRequested") {
-          const feedback = {
-            assessmentOutcome: result.assessmentOutcome,
-            feedbackContent: result.feedbackContent
-          };
-          return fromAdvanced(result.frame.body, result.frame.stimulus, interaction, feedback);
-        }
-        return submittedFeedbackState(ctx, result.frame.body, result.frame.stimulus, interaction, result.submission, result.assessmentOutcome, result.feedbackContent, result.review);
+        return submittedFeedbackState(ctx, result.journey, result.frame.body, result.frame.stimulus, interaction, result.submission, result.isCorrect, result.feedbackContent, result.review);
       }
       case "timedOut": {
         const interaction = result.frame.interaction;
@@ -7811,15 +8024,16 @@ function makeSession(sc) {
           logger.error("timed out result without interaction");
           return {
             phase: "fatal",
+            journey: result.journey,
             error: errors11.wrap(ErrBadRequest, "timed out result missing interaction"),
             retriable: false,
             toJSON: poisonToJSON
           };
         }
-        return timedOutFeedbackState(ctx, result.frame.body, result.frame.stimulus, interaction, result.feedbackContent);
+        return timedOutFeedbackState(ctx, result.journey, result.frame.body, result.frame.stimulus, interaction, result.feedbackContent);
       }
       case "completed":
-        return { phase: "completed", toJSON: poisonToJSON };
+        return { phase: "completed", journey: result.journey, toJSON: poisonToJSON };
     }
   }
   function errored(error, failedPhase, intent) {
@@ -7827,6 +8041,7 @@ function makeSession(sc) {
     if (!retriable) {
       return {
         phase: "errored",
+        journey: latestJourney,
         error,
         retriable: false,
         toJSON: poisonToJSON
@@ -7835,6 +8050,7 @@ function makeSession(sc) {
     let pending;
     const state = {
       phase: "errored",
+      journey: latestJourney,
       error,
       retriable: true,
       retry: function retry() {
@@ -7853,17 +8069,19 @@ function makeSession(sc) {
     logger.debug({
       phase,
       intentKind: intent.kind,
-      subject: sc.subject
+      subject: sc.subject,
+      mode: sc.mode
     }, "session execute");
     const body = {
       subject: sc.subject,
+      mode: sc.mode,
       intent
     };
     const result = await sc.transport(body);
     if (!result.ok) {
       if ((errors11.is(result.error, ErrTokenExpired) || errors11.is(result.error, ErrInvalidAccessToken)) && sc.reauthenticate !== null) {
         logger.warn({ phase, intentKind: intent.kind }, "session token rejected");
-        return sc.reauthenticate(result.error);
+        return sc.reauthenticate(result.error, latestJourney);
       }
       if (isFatalError(result.error)) {
         logger.error({
@@ -7873,6 +8091,7 @@ function makeSession(sc) {
         }, "fatal transport error");
         return {
           phase: "fatal",
+          journey: latestJourney,
           error: result.error,
           retriable: false,
           toJSON: poisonToJSON
@@ -7885,7 +8104,7 @@ function makeSession(sc) {
       }, "retriable transport error");
       return errored(result.error, phase, intent);
     }
-    const next = resolve(result.data);
+    const next = resolve(result.data, intent);
     logger.debug({
       phase,
       intentKind: intent.kind,
@@ -7902,50 +8121,75 @@ function makeSession(sc) {
     }
     return false;
   }
-  function fromAdvanced(body, stimulus, interaction, feedback) {
+  function fromAdvanced(journey, body, stimulus, interaction, feedback, preservedSubmission, nextSubmissionRole) {
     if (interaction === null) {
-      return observationState(ctx, body, stimulus);
+      return observationState(ctx, journey, body, stimulus);
     }
     if (interaction.type === "portable-custom") {
       if (!isPciSupported(interaction.pciId)) {
         logger.error({ pciId: interaction.pciId }, "unsupported pci in frame");
         return {
           phase: "fatal",
+          journey,
           error: errors11.wrap(ErrUnsupportedPci, `pci '${interaction.pciId}'`),
           retriable: false,
           toJSON: poisonToJSON
         };
       }
     }
-    return pendingInteractionState(body, stimulus, interaction, feedback);
+    return pendingInteractionState(journey, body, stimulus, interaction, feedback, preservedSubmission, nextSubmissionRole);
   }
-  function extendedTextInteractionState(body, stimulus, interaction, feedback) {
+  function extendedTextInteractionState(journey, body, stimulus, interaction, feedback, preservedSubmission, nextSubmissionRole) {
     if (!("cardinality" in interaction)) {
       logger.error("extended-text interaction is unsupported");
       return {
         phase: "fatal",
+        journey,
         error: errors11.wrap(ErrBadRequest, "extended-text interaction unsupported"),
         retriable: false,
         toJSON: poisonToJSON
       };
     }
     const extendedInteraction = interaction;
-    return extendedTextState(ctx, body, stimulus, extendedInteraction, feedback);
+    if (preservedSubmission?.type === "extended-text") {
+      if (extendedInteraction.cardinality === "single") {
+        const [initialValue] = preservedSubmission.values;
+        return extendedTextState(ctx, journey, body, stimulus, extendedInteraction, feedback, {
+          initialValue,
+          nextSubmissionRole
+        });
+      }
+      return extendedTextState(ctx, journey, body, stimulus, extendedInteraction, feedback, {
+        initialValues: preservedSubmission.values,
+        nextSubmissionRole
+      });
+    }
+    return extendedTextState(ctx, journey, body, stimulus, extendedInteraction, feedback, {
+      nextSubmissionRole
+    });
   }
-  function pendingInteractionState(body, stimulus, interaction, feedback) {
+  function pendingInteractionState(journey, body, stimulus, interaction, feedback, preservedSubmission, nextSubmissionRole) {
     switch (interaction.type) {
       case "choice":
-        return choiceState(ctx, body, stimulus, interaction, interaction.options, interaction.maxChoices, interaction.minChoices, feedback);
+        return choiceState(ctx, journey, body, stimulus, interaction, interaction.options, interaction.maxChoices, interaction.minChoices, feedback);
       case "text-entry":
-        return textEntryState(ctx, body, stimulus, interaction, feedback);
+        if (preservedSubmission?.type === "text-entry") {
+          return textEntryState(ctx, journey, body, stimulus, interaction, feedback, {
+            initialValue: preservedSubmission.value,
+            nextSubmissionRole
+          });
+        }
+        return textEntryState(ctx, journey, body, stimulus, interaction, feedback, {
+          nextSubmissionRole
+        });
       case "extended-text":
-        return extendedTextInteractionState(body, stimulus, interaction, feedback);
+        return extendedTextInteractionState(journey, body, stimulus, interaction, feedback, preservedSubmission, nextSubmissionRole);
       case "order":
-        return orderState(ctx, body, stimulus, interaction, feedback);
+        return orderState(ctx, journey, body, stimulus, interaction, feedback);
       case "match":
-        return matchState(ctx, body, stimulus, interaction, feedback);
+        return matchState(ctx, journey, body, stimulus, interaction, feedback);
       case "portable-custom":
-        return pciInteractionState(ctx, body, stimulus, interaction, feedback);
+        return pciInteractionState(ctx, journey, body, stimulus, interaction, feedback);
     }
   }
   const ctx = { logger, execute, errored };
@@ -7956,11 +8200,21 @@ function makeSession(sc) {
 import * as errors12 from "@superbuilders/errors";
 
 // src/version.ts
-var SDK_VERSION = "5.0.4";
+var SDK_VERSION = "6.0.0";
 var NPM_PACKAGE_URL = "https://www.npmjs.com/package/@superbuilders/primer-tives";
 
 // src/client/transport.ts
 var ADVANCE_PATH = "/api/v0/advance";
+function readNumberField(value, key) {
+  if (!(key in value)) {
+    return;
+  }
+  const v = Reflect.get(value, key);
+  if (typeof v !== "number") {
+    return;
+  }
+  return v;
+}
 function readStringField(value, key) {
   if (!(key in value)) {
     return;
@@ -7994,9 +8248,9 @@ function parseAdvanceErrorBody(body) {
   if (detail !== undefined) {
     result.detail = detail;
   }
-  const minimumSdkVersion = readStringField(raw, "minimumSdkVersion");
-  if (minimumSdkVersion !== undefined) {
-    result.minimumSdkVersion = minimumSdkVersion;
+  const minimumSdkMajor = readNumberField(raw, "minimumSdkMajor");
+  if (minimumSdkMajor !== undefined) {
+    result.minimumSdkMajor = minimumSdkMajor;
   }
   const receivedSdkVersion = readStringField(raw, "receivedSdkVersion");
   if (receivedSdkVersion !== undefined) {
@@ -8069,22 +8323,24 @@ function buildSdkUpgradeRequiredError(sentinel, text, logger) {
   if (parsed === null) {
     logger.error({
       receivedSdkVersion: null,
-      minimumSdkVersion: "<unknown>",
+      minimumSdkMajor: "<unknown>",
       upgradeUrl: NPM_PACKAGE_URL
     }, "sdk upgrade required");
-    const message2 = `<missing> < <unknown>; bump @superbuilders/primer-tives at ${NPM_PACKAGE_URL}`;
+    const message2 = `major < <unknown>; bump @superbuilders/primer-tives at ${NPM_PACKAGE_URL}`;
     return errors12.wrap(sentinel, message2);
   }
-  const minimumSdkVersion = parsed.minimumSdkVersion === undefined ? "<unknown>" : parsed.minimumSdkVersion;
+  let minimumSdkMajor = "<unknown>";
+  if (parsed.minimumSdkMajor !== undefined) {
+    minimumSdkMajor = String(parsed.minimumSdkMajor);
+  }
   const receivedSdkVersion = parsed.receivedSdkVersion === undefined ? null : parsed.receivedSdkVersion;
-  const receivedDisplay = receivedSdkVersion === null ? "<missing>" : receivedSdkVersion;
   const upgradeUrl = parsed.upgradeUrl === undefined ? NPM_PACKAGE_URL : parsed.upgradeUrl;
   logger.error({
     receivedSdkVersion,
-    minimumSdkVersion,
+    minimumSdkMajor,
     upgradeUrl
   }, "sdk upgrade required");
-  const message = `${receivedDisplay} < ${minimumSdkVersion}; bump @superbuilders/primer-tives at ${upgradeUrl}`;
+  const message = `major < ${minimumSdkMajor}; bump @superbuilders/primer-tives at ${upgradeUrl}`;
   return errors12.wrap(sentinel, message);
 }
 function isAbortError(err) {
@@ -8109,7 +8365,8 @@ function createTransport(tc) {
   async function transport(body) {
     logger.debug({
       intentKind: body.intent.kind,
-      subject: body.subject
+      subject: body.subject,
+      mode: body.mode
     }, "transport request");
     const fetchResult = await fetchFn(advanceUrl, {
       method: "POST",
@@ -8168,10 +8425,17 @@ function createTransport(tc) {
       }, "transport json parse failed");
       return { ok: false, error: errors12.wrap(ErrJsonParse, jsonResult.error.message) };
     }
+    const journeyResult = parseJourney(jsonResult.data.journey);
+    if (!journeyResult.ok) {
+      logger.error({
+        reason: journeyResult.reason
+      }, "transport journey parse failed");
+      return { ok: false, error: errors12.wrap(ErrBadRequest, journeyResult.reason) };
+    }
     logger.debug({
       intentKind: body.intent.kind
     }, "transport success");
-    return { ok: true, data: jsonResult.data };
+    return { ok: true, data: { ...jsonResult.data, journey: journeyResult.journey } };
   }
   return transport;
 }
@@ -8205,15 +8469,16 @@ function primerAuthOrigin(authOrigin, origin) {
 async function startRuntime(config, resolved) {
   let reauthenticate = null;
   if (resolved.clearCachedAccessToken !== undefined) {
-    reauthenticate = function reauthenticateManagedAuth(error) {
+    reauthenticate = function reauthenticateManagedAuth(error, journey) {
       resolved.clearCachedAccessToken?.();
-      return Promise.resolve(makeSignInFailedState(config, error));
+      return Promise.resolve(makeSignInFailedState(config, error, journey));
     };
   }
   const transport = createTransport({
     accessToken: resolved.accessToken,
     publishableKey: config.publishableKey,
     subject: config.subject,
+    mode: config.mode,
     origin: config.origin,
     fetch: config.fetch,
     abort: config.abort,
@@ -8221,6 +8486,7 @@ async function startRuntime(config, resolved) {
   });
   const session = makeSession({
     subject: config.subject,
+    mode: config.mode,
     supportedPcis: config.supportedPcis,
     logger: config.logger,
     transport,
@@ -8230,13 +8496,15 @@ async function startRuntime(config, resolved) {
 }
 function makeSignInRequiredState(config) {
   return signInRequiredState({
+    journey: ONBOARDING_JOURNEY,
     login: function login() {
       return loginAndStart(config);
     }
   });
 }
-function makeSignInFailedState(config, error) {
+function makeSignInFailedState(config, error, journey) {
   return signInFailedState({
+    journey,
     error,
     login: function login() {
       return loginAndStart(config);
@@ -8250,13 +8518,13 @@ async function loginAndStart(config) {
     logger: config.logger
   });
   if (result.kind === "auth-unavailable") {
-    return authUnavailableState(result.error);
+    return authUnavailableState(result.error, ONBOARDING_JOURNEY);
   }
   if (result.kind === "auth-config-invalid") {
-    return authConfigInvalidState(result.error);
+    return authConfigInvalidState(result.error, ONBOARDING_JOURNEY);
   }
   if (result.kind === "sign-in-failed") {
-    return makeSignInFailedState(config, result.error);
+    return makeSignInFailedState(config, result.error, ONBOARDING_JOURNEY);
   }
   return startRuntime(config, {
     accessToken: result.accessToken,
@@ -8271,6 +8539,7 @@ async function start(options) {
     publishableKey: options.publishableKey,
     origin,
     authOrigin: primerAuthOrigin(options.authOrigin, origin),
+    mode: options.mode,
     fetch: options.fetch,
     abort: options.abort,
     logger,
@@ -8286,13 +8555,14 @@ async function start(options) {
   if (accessToken.kind === "fatal") {
     return {
       phase: "fatal",
+      journey: ONBOARDING_JOURNEY,
       error: accessToken.error,
       retriable: false,
       toJSON: poisonToJSON
     };
   }
   if (accessToken.kind === "auth-unavailable") {
-    return authUnavailableState(accessToken.error);
+    return authUnavailableState(accessToken.error, ONBOARDING_JOURNEY);
   }
   if (accessToken.kind === "missing") {
     return makeSignInRequiredState(config);
@@ -8303,4 +8573,4 @@ export {
   start
 };
 
-//# debugId=B9AA7CC48F32D77C64756E2164756E21
+//# debugId=E581CF63700F9E9F64756E2164756E21