@superbuilders/primer-tives 0.4.0 → 0.6.0

package/dist/index.js

@@ -1,12 +1,14 @@
 // src/client.ts
-import * as errors8 from "@superbuilders/errors";
+import * as errors10 from "@superbuilders/errors";
 
 // 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 ErrInvalidPublishableKey = errors.new("invalid publishable key");
+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");
@@ -17,7 +19,6 @@ 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 ErrMalformedPublishableKey = errors.new("malformed publishable key");
 
 // src/transport.ts
 import * as errors2 from "@superbuilders/errors";
@@ -27,7 +28,7 @@ function httpSentinel(status) {
     return ErrBadRequest;
   }
   if (status === 401) {
-    return ErrInvalidPublishableKey;
+    return ErrInvalidAccessToken;
   }
   if (status === 403) {
     return ErrForbidden;
@@ -66,15 +67,15 @@ function createTransport(tc) {
   }
   async function transport(body) {
     log?.debug("transport request", {
-      studentId: body.studentId,
-      intentKind: body.intent.kind
+      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.publishableKey}`
+        Authorization: `Bearer ${tc.accessToken}`
       },
       body: JSON.stringify(body),
       signal: transportSignal()
@@ -86,13 +87,11 @@ function createTransport(tc) {
     if (!fetchResult.ok) {
       if (isAbortError(fetchResult.error)) {
         log?.error("transport timeout", {
-          studentId: body.studentId,
           intentKind: body.intent.kind
         });
         return { ok: false, error: errors2.wrap(ErrTimeout, fetchResult.error.message) };
       }
       log?.error("transport network error", {
-        studentId: body.studentId,
         error: fetchResult.error
       });
       return { ok: false, error: errors2.wrap(ErrNetwork, fetchResult.error.message) };
@@ -104,7 +103,6 @@ function createTransport(tc) {
       });
       const sentinel = res.status === 422 ? ErrUnsupportedPci : httpSentinel(res.status);
       log?.error("transport http error", {
-        studentId: body.studentId,
         status: res.status
       });
       return { ok: false, error: errors2.wrap(sentinel, text) };
@@ -116,13 +114,11 @@ function createTransport(tc) {
     });
     if (!jsonResult.ok) {
       log?.error("transport json parse failed", {
-        studentId: body.studentId,
         error: jsonResult.error
       });
       return { ok: false, error: errors2.wrap(ErrJsonParse, jsonResult.error.message) };
     }
     log?.debug("transport success", {
-      studentId: body.studentId,
       intentKind: body.intent.kind
     });
     return { ok: true, data: jsonResult.data };
@@ -131,7 +127,7 @@ function createTransport(tc) {
 }
 
 // src/session.ts
-import * as errors7 from "@superbuilders/errors";
+import * as errors9 from "@superbuilders/errors";
 
 // src/consumed.ts
 function poisonToJSON() {
@@ -173,7 +169,45 @@ function validateChoiceSubmission(log, selectedKeys, options, maxChoices, minCho
   return null;
 }
 function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices) {
-  let pending;
+  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 validationError = validateChoiceSubmission(ctx.log, selectedKeys, options, maxChoices, minChoices);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "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",
@@ -182,27 +216,8 @@ function choiceState(ctx, stimulus, interaction, options, maxChoices, minChoices
     options,
     maxChoices,
     minChoices,
-    submitChoice: function submitChoice(selectedKeys) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateChoiceSubmission(ctx.log, selectedKeys, options, maxChoices, minChoices);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "choice", selectedKeys }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "choice", selectedKeys } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitChoice: beginSubmit,
+    timeout: beginTimeout,
     toJSON: poisonToJSON
   };
 }
@@ -222,66 +237,107 @@ function validateExtendedTextSubmission(log, values, minStrings, maxStrings) {
 }
 function extendedTextState(ctx, stimulus, interaction) {
   if (interaction.cardinality === "single") {
-    let pending2;
+    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 }));
+      }
+      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: function submitText(value) {
-        if (pending2) {
-          return pending2;
-        }
-        pending2 = ctx.execute({ kind: "interaction", submission: { type: "extended-text", values: [value] } }, "interaction");
-        return pending2;
-      },
-      timeout: function timeout() {
-        if (pending2) {
-          return pending2;
-        }
-        pending2 = ctx.execute({ kind: "timeout" }, "timeout");
-        return pending2;
-      },
+      submitText,
+      timeout: timeout2,
       toJSON: poisonToJSON
     };
   }
-  let pending;
+  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 validationError = validateExtendedTextSubmission(ctx.log, values, multi.minStrings, multi.maxStrings);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "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,
-    maxStrings: interaction.maxStrings,
-    minStrings: interaction.minStrings,
-    submitTexts: function submitTexts(values) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateExtendedTextSubmission(ctx.log, values, interaction.minStrings, interaction.maxStrings);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "extended-text", values }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "extended-text", values } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    interaction: multi,
+    maxStrings: multi.maxStrings,
+    minStrings: multi.minStrings,
+    submitTexts,
+    timeout,
     toJSON: poisonToJSON
   };
 }
 
 // src/feedback-state.ts
-function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedbackContent, correctAnswer) {
+function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedbackContent, review) {
   let pending;
   return {
     phase: "feedback",
@@ -290,7 +346,7 @@ function feedbackState(ctx, stimulus, interaction, submission, isCorrect, feedba
     submission,
     isCorrect,
     feedbackContent,
-    correctAnswer,
+    review,
     advance: function advance() {
       if (pending) {
         return pending;
@@ -391,7 +447,45 @@ function validateMatchSubmission(log, pairs, sourceChoices, targetChoices, minAs
   return null;
 }
 function matchState(ctx, stimulus, interaction) {
-  let pending;
+  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 validationError = validateMatchSubmission(ctx.log, pairs, interaction.sourceChoices, interaction.targetChoices, interaction.minAssociations, interaction.maxAssociations);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "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",
@@ -401,27 +495,8 @@ function matchState(ctx, stimulus, interaction) {
     targetChoices: interaction.targetChoices,
     minAssociations: interaction.minAssociations,
     maxAssociations: interaction.maxAssociations,
-    submitMatch: function submitMatch(pairs) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateMatchSubmission(ctx.log, pairs, interaction.sourceChoices, interaction.targetChoices, interaction.minAssociations, interaction.maxAssociations);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "match", pairs }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "match", pairs } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitMatch,
+    timeout,
     toJSON: poisonToJSON
   };
 }
@@ -478,7 +553,45 @@ function validateOrderSubmission(log, orderedKeys, choices, minChoices, maxChoic
   return null;
 }
 function orderState(ctx, stimulus, interaction) {
-  let pending;
+  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 validationError = validateOrderSubmission(ctx.log, orderedKeys, interaction.choices, interaction.minChoices, interaction.maxChoices);
+    if (validationError) {
+      return Promise.resolve(ctx.errored(validationError, "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",
@@ -487,51 +600,52 @@ function orderState(ctx, stimulus, interaction) {
     choices: interaction.choices,
     minChoices: interaction.minChoices,
     maxChoices: interaction.maxChoices,
-    submitOrder: function submitOrder(orderedKeys) {
-      if (pending) {
-        return pending;
-      }
-      const validationError = validateOrderSubmission(ctx.log, orderedKeys, interaction.choices, interaction.minChoices, interaction.maxChoices);
-      if (validationError) {
-        return Promise.resolve(ctx.errored(validationError, "interaction", {
-          kind: "interaction",
-          submission: { type: "order", orderedKeys }
-        }));
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "order", orderedKeys } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitOrder,
+    timeout,
     toJSON: poisonToJSON
   };
 }
 
 // src/pci-state.ts
+import * as errors7 from "@superbuilders/errors";
 function pciInteractionState(ctx, stimulus, interaction) {
-  let pending;
+  let submitPending;
+  let submitKey;
+  let timeoutPending;
   const { pciId, properties } = interaction;
   function submit(value) {
-    if (pending) {
-      return pending;
+    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 });
-    const submission = { type: "portable-custom", pciId, value };
-    pending = ctx.execute({ kind: "interaction", submission }, "interaction");
-    return pending;
+    submitKey = key;
+    submitPending = ctx.execute({ kind: "interaction", submission }, "interaction").finally(function clearPending() {
+      submitPending = undefined;
+      submitKey = undefined;
+    });
+    return submitPending;
   }
   function timeout() {
-    if (pending) {
-      return pending;
+    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 });
-    pending = ctx.execute({ kind: "timeout" }, "timeout");
-    return pending;
+    timeoutPending = ctx.execute(intent, "timeout").finally(function clearPending() {
+      timeoutPending = undefined;
+    });
+    return timeoutPending;
   }
   return {
     phase: "interaction",
@@ -547,27 +661,50 @@ function pciInteractionState(ctx, stimulus, interaction) {
 }
 
 // src/text-entry-state.ts
+import * as errors8 from "@superbuilders/errors";
 function textEntryState(ctx, stimulus, interaction) {
-  let pending;
+  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 }));
+    }
+    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: function submitText(value) {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "interaction", submission: { type: "text-entry", value } }, "interaction");
-      return pending;
-    },
-    timeout: function timeout() {
-      if (pending) {
-        return pending;
-      }
-      pending = ctx.execute({ kind: "timeout" }, "timeout");
-      return pending;
-    },
+    submitText,
+    timeout,
     toJSON: poisonToJSON
   };
 }
@@ -575,19 +712,23 @@ function textEntryState(ctx, stimulus, interaction) {
 // src/session.ts
 var FATAL_SENTINELS = [
   ErrBadRequest,
-  ErrInvalidPublishableKey,
+  ErrInvalidAccessToken,
+  ErrTokenExpired,
   ErrForbidden,
   ErrNotFound,
   ErrUnsupportedPci
 ];
 function isFatalError(err) {
   for (const sentinel of FATAL_SENTINELS) {
-    if (errors7.is(err, sentinel)) {
+    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) {
@@ -595,18 +736,23 @@ function makeSession(sc) {
       case "advanced":
         return fromAdvanced(result.stimulus, result.interaction);
       case "submitted":
-        return feedbackState(ctx, result.stimulus, result.interaction, result.submission, result.isCorrect, result.feedbackContent, result.correctAnswer);
+        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;
-    return {
+    const retriable = isRetriableError(error);
+    const state = {
       phase: "errored",
       error,
-      failedPhase,
+      retriable,
       retry: function retry() {
+        if (!retriable) {
+          log?.debug("retry ignored for non-retriable error", { failedPhase });
+          return Promise.resolve(state);
+        }
         if (pending) {
           return pending;
         }
@@ -616,18 +762,19 @@ function makeSession(sc) {
       },
       toJSON: poisonToJSON
     };
+    return state;
   }
   async function execute(intent, phase) {
     const body = {
-      studentId: sc.studentId,
       supportedPcis: sc.supportedPcis,
-      intent
+      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, toJSON: poisonToJSON };
+        return { phase: "fatal", error: result.error, retriable: false, toJSON: poisonToJSON };
       }
       return errored(result.error, phase, intent);
     }
@@ -650,7 +797,8 @@ function makeSession(sc) {
         log?.error("unsupported pci in frame", { pciId: interaction.pciId });
         return {
           phase: "fatal",
-          error: errors7.wrap(ErrUnsupportedPci, `pci '${interaction.pciId}'`),
+          error: errors9.wrap(ErrUnsupportedPci, `pci '${interaction.pciId}'`),
+          retriable: false,
           toJSON: poisonToJSON
         };
       }
@@ -678,15 +826,22 @@ function makeSession(sc) {
 }
 
 // src/client.ts
-var PK_PREFIX = "pk_";
+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 (!config.publishableKey.startsWith(PK_PREFIX)) {
-    log?.error("malformed publishable key", { prefix: PK_PREFIX });
-    throw errors8.wrap(ErrMalformedPublishableKey, `key must start with '${PK_PREFIX}'`);
+  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({
-    publishableKey: config.publishableKey,
+    accessToken: config.accessToken,
     supportedPcis: config.supportedPcis,
     origin: config.origin,
     fetch: config.fetch,
@@ -694,27 +849,29 @@ function create(config) {
     log
   });
   let startPromise;
-  async function doStart(studentId) {
-    log?.debug("start", { studentId });
+  async function doStart() {
+    log?.debug("start", { subject: config.subject });
     const s = makeSession({
-      studentId,
       supportedPcis: config.supportedPcis,
+      subject: config.subject,
       log,
       transport
     });
     return s.execute({ kind: "observation" }, "observation");
   }
   return {
-    start(studentId) {
+    start() {
       if (startPromise) {
         log?.debug("start already called");
         return startPromise;
       }
-      startPromise = doStart(studentId);
+      startPromise = doStart();
       return startPromise;
     }
   };
 }
+// src/subject.ts
+var SUBJECTS = ["math", "vocabulary"];
 // src/content.ts
 function inlinesToPlainText(nodes) {
   const parts = [];
@@ -743,7 +900,9 @@ export {
   inlinesToPlainText,
   create,
   blocksToPlainText,
+  SUBJECTS,
   ErrUnsupportedPci,
+  ErrTokenExpired,
   ErrTimeout,
   ErrServiceUnavailable,
   ErrServerError,
@@ -751,14 +910,14 @@ export {
   ErrNotSerializable,
   ErrNotFound,
   ErrNetwork,
-  ErrMalformedPublishableKey,
+  ErrMalformedAccessToken,
   ErrJsonParse,
   ErrInvalidSubmission,
-  ErrInvalidPublishableKey,
+  ErrInvalidAccessToken,
   ErrForbidden,
   ErrConflict,
   ErrBadRequest,
   ADVANCE_PATH
 };
 
-//# debugId=FEF5C86C2285295364756E2164756E21
+//# debugId=7D25EB69305CCB9264756E2164756E21