Google Forms scripts and response triggers

/**
 * @typedef {'alias'|'route'|'mapsPage'|'mapsNote'|'automationPage'|'automationNote'|'checkPage'|'check'} WorkshopItemKey
 */
/**
 * @typedef {'TEXT'|'MULTIPLE_CHOICE'|'PAGE_BREAK'|'PARAGRAPH_TEXT'} WorkshopItemType
 */
/**
 * @typedef {{key: WorkshopItemKey, type: WorkshopItemType, title: string}} WorkshopItemDefinition
 */
/**
 * @typedef {{
 *   phase: string,
 *   formTitle: string,
 *   formId: string,
 *   itemIds: {[key: string]: number},
 *   pendingItem: string,
 *   triggerState: string,
 *   triggerId: string,
 *   responseIds: string[]
 * }} WorkshopState
 */

const WORKSHOP = {
  setupConfirmation: '', // CREATE ONE PRIVATE WORKSHOP FORM
  installConfirmation: '', // INSTALL ONE WORKSHOP TRIGGER
  recoveryFormId: '',
  recoveryItemId: null,
  recoveryConfirmation: '',
  responseId: '',
  removeTriggerConfirmation: '',
};

const WORKSHOP_STATE_KEY = 'forms-workflows.v1';
const WORKSHOP_HANDLER = 'recordWorkshopSubmit';
const MAX_WORKSHOP_RECEIPTS = 5;
/** @type {WorkshopItemDefinition[]} */
const WORKSHOP_ITEMS = [
  { key: 'alias', type: 'TEXT', title: 'Practice alias, not your real name' },
  { key: 'route', type: 'MULTIPLE_CHOICE', title: 'Which workshop did you try?' },
  { key: 'mapsPage', type: 'PAGE_BREAK', title: 'Maps lab feedback' },
  { key: 'mapsNote', type: 'PARAGRAPH_TEXT', title: 'One useful maps idea' },
  { key: 'automationPage', type: 'PAGE_BREAK', title: 'Automation lab feedback' },
  { key: 'automationNote', type: 'PARAGRAPH_TEXT', title: 'One useful automation idea' },
  { key: 'checkPage', type: 'PAGE_BREAK', title: 'A one-point practice check' },
  { key: 'check', type: 'MULTIPLE_CHOICE', title: 'What should happen before a script sends an email?' },
];
const MAPS_CHOICE = 'Maps lab';
const AUTOMATION_CHOICE = 'Automation lab';
const CORRECT_CHECK = 'Review the recipient and content';
const INCORRECT_CHECK = 'Keep retrying until something is sent';

function setupWorkshopForm() {
  if (WORKSHOP.setupConfirmation !== 'CREATE ONE PRIVATE WORKSHOP FORM') {
    throw new Error('Read the setup and effects, then supply the exact setup confirmation.');
  }
  withWorkshopLock_(() => {
    let state = readWorkshopState_();
    if (!state) {
      state = {
        phase: 'CREATE_UNCERTAIN',
        formTitle: 'Book workshop practice [' + Utilities.getUuid() + ']',
        formId: '',
        itemIds: {},
        pendingItem: '',
        triggerState: 'NONE',
        triggerId: '',
        responseIds: [],
      };
      saveWorkshopState_(state); // Intent before creating any form.
      const created = FormApp.create(state.formTitle, false); // Explicitly unpublished.
      state.formId = created.getId();
      state.phase = 'BUILDING';
      saveWorkshopState_(state); // Identity before configuring or adding items.
    }
    if (state.phase === 'CREATE_UNCERTAIN') {
      throw new Error('Form creation is uncertain. Inspect the state and confirm the existing identity.');
    }
    const form = openWorkshopForm_(state);
    if (state.phase === 'READY') {
      checkWorkshopItems_(form, state, 0);
      console.log(JSON.stringify({ action: 'REUSED_READY_FORM', formId: state.formId }));
      return;
    }
    requireUnpublishedWorkshop_(form);
    if (state.pendingItem) {
      throw new Error('An item append is uncertain: ' + state.pendingItem + '. Do not append again.');
    }
    checkWorkshopItems_(form, state, 0);
    form.setAcceptingResponses(false);
    form.setIsQuiz(true);
    form.setCollectEmail(false);
    form.setAllowResponseEdits(false);
    form.setLimitOneResponsePerUser(false);
    form.setPublishingSummary(false);
    form.setShuffleQuestions(false);
    form.setProgressBar(true);
    form.setDescription('Fictional workshop practice only. No names, email addresses or live feedback.');
    form.setConfirmationMessage('Your practice response is saved. No email is sent by this project.');

    for (const definition of WORKSHOP_ITEMS) {
      if (Object.prototype.hasOwnProperty.call(state.itemIds, definition.key)) continue;
      state.pendingItem = definition.key;
      saveWorkshopState_(state); // Each append has its own intent and ID checkpoint.
      const item = appendWorkshopItem_(form, definition.type);
      state.itemIds[definition.key] = item.getId();
      state.pendingItem = '';
      saveWorkshopState_(state); // Save before setting the item's title or options.
    }
    const items = checkWorkshopItems_(form, state, 0);
    for (let index = 0; index < WORKSHOP_ITEMS.length; index++) {
      items[index].setTitle(WORKSHOP_ITEMS[index].title);
    }
    configureWorkshopQuestions_(form, state);
    state.phase = 'READY';
    saveWorkshopState_(state);
    console.log(JSON.stringify({ action: 'SETUP_READY', formId: state.formId, editUrl: form.getEditUrl(), items: 8 }));
  });
}

function inspectWorkshopProject() {
  const state = readWorkshopState_();
  console.log(JSON.stringify({ savedState: state }));
  if (!state || !state.formId) return;
  const form = openWorkshopForm_(state);
  const items = form.getItems(); // All items, not a paginated API. Use only this small new form.
  if (items.length > WORKSHOP_ITEMS.length) throw new Error('More than eight items exist. Stop and inspect the form.');
  console.log(JSON.stringify({
    formId: state.formId,
    editUrl: form.getEditUrl(),
    published: form.isPublished(),
    acceptingResponses: form.isAcceptingResponses(),
    quiz: form.isQuiz(),
    collectingEmail: form.collectsEmail(),
    responseEditing: form.canEditResponse(),
    items: items.map((/** @type {FormApp.Item} */ item) => ({ id: item.getId(), type: String(item.getType()), title: item.getTitle() })),
    currentUserTriggers: ScriptApp.getProjectTriggers().map((trigger) => ({
      id: trigger.getUniqueId(),
      handler: trigger.getHandlerFunction(),
      sourceId: trigger.getTriggerSourceId(),
      eventType: String(trigger.getEventType()),
    })),
  }));
}

function adoptWorkshopForm() {
  withWorkshopLock_(() => {
    const state = requireWorkshopState_();
    if (state.phase !== 'CREATE_UNCERTAIN') throw new Error('No unknown form identity is awaiting adoption.');
    const id = WORKSHOP.recoveryFormId;
    if (!isWorkshopId_(id) || WORKSHOP.recoveryConfirmation !== 'ADOPT FORM ' + id + ' FOR ' + state.formTitle) {
      throw new Error('Inspect your new form and its ownership, then supply its ID and exact ADOPT FORM confirmation.');
    }
    const form = FormApp.openById(id);
    requireUnpublishedWorkshop_(form);
    if (form.getTitle() !== state.formTitle || form.getItems().length !== 0 || form.getDestinationId()) {
      throw new Error('Candidate must be the inspected empty unpublished form from this attempt. Names alone are not proof.');
    }
    // The human confirmation establishes provenance/ownership; FormApp has no owner getter.
    state.formId = form.getId();
    state.phase = 'BUILDING';
    saveWorkshopState_(state);
    console.log(JSON.stringify({ action: 'FORM_ID_ADOPTED', formId: state.formId }));
  });
}

function adoptWorkshopItem() {
  withWorkshopLock_(() => {
    const state = requireWorkshopState_();
    if (state.phase !== 'BUILDING' || !state.pendingItem) throw new Error('No uncertain item append is awaiting adoption.');
    const form = openWorkshopForm_(state);
    requireUnpublishedWorkshop_(form);
    const items = checkWorkshopItems_(form, state, 1);
    const candidate = items[items.length - 1];
    const definition = WORKSHOP_ITEMS[items.length - 1];
    if (definition.key !== state.pendingItem || candidate.getId() !== WORKSHOP.recoveryItemId ||
        WORKSHOP.recoveryConfirmation !== 'ADOPT ITEM ' + candidate.getId() + ' AS ' + state.pendingItem) {
      throw new Error('Inspect the one unrecorded appended item and supply its exact ID and ADOPT ITEM confirmation.');
    }
    state.itemIds[state.pendingItem] = candidate.getId();
    state.pendingItem = '';
    saveWorkshopState_(state);
    console.log(JSON.stringify({ action: 'ITEM_ID_ADOPTED', itemId: candidate.getId() }));
  });
}

function installWorkshopTrigger() {
  if (WORKSHOP.installConfirmation !== 'INSTALL ONE WORKSHOP TRIGGER') {
    throw new Error('Inspect the ready form and supply the exact trigger-install confirmation.');
  }
  withWorkshopLock_(() => {
    const state = requireReadyWorkshop_();
    if (state.triggerState === 'REMOVED') throw new Error('This exercise trigger was retired. Do not reset its history.');
    const form = openWorkshopForm_(state);
    requireUnpublishedWorkshop_(form); // Prevent submission during installation/checkpointing.
    checkWorkshopItems_(form, state, 0);
    requireWorkshopResponseSettings_(form);
    const triggers = ScriptApp.getProjectTriggers();
    if (triggers.length > 1 || (triggers.length === 1 && !isWorkshopTrigger_(triggers[0], state))) {
      throw new Error('This private project must contain only the one matching Forms trigger. Inspect; do not bulk-delete.');
    }
    if (triggers.length === 1) {
      const id = triggers[0].getUniqueId();
      if (state.triggerId && state.triggerId !== id) throw new Error('Saved and current trigger IDs differ. Stop and reconcile.');
      if (state.triggerState !== 'READY') {
        state.triggerId = id;
        state.triggerState = 'READY';
        saveWorkshopState_(state);
      }
      console.log(JSON.stringify({ action: 'REUSED_TRIGGER', triggerId: id }));
      return;
    }
    if (state.triggerState !== 'NONE') throw new Error('Previously attempted trigger is missing. Do not blindly install another.');
    state.triggerState = 'CREATE_UNCERTAIN';
    saveWorkshopState_(state);
    const trigger = ScriptApp.newTrigger(WORKSHOP_HANDLER).forForm(form).onFormSubmit().create();
    state.triggerId = trigger.getUniqueId();
    state.triggerState = 'READY';
    saveWorkshopState_(state);
    console.log(JSON.stringify({ action: 'TRIGGER_READY', triggerId: state.triggerId }));
  });
}

/**
 * @param {{response: FormApp.FormResponse, source: FormApp.Form, triggerUid: string|number}} e
 * @returns {void}
 */
function recordWorkshopSubmit(e) {
  if (!e || !e.response || typeof e.response.getItemResponses !== 'function' ||
      !e.source || typeof e.source.getId !== 'function' || e.triggerUid === undefined) {
    throw new Error('This handler needs the installed Forms submit event, not editor Run or a Sheets event.');
  }
  const responseId = e.response.getId();
  if (typeof responseId !== 'string' || !isWorkshopId_(responseId)) {
    throw new Error('No submitted response ID is available.');
  }
  // Preserve an ID for manual retrieval even if recording below fails. Never log the whole event.
  console.log(JSON.stringify({ receivedResponseId: responseId }));
  withWorkshopLock_(() => {
    const state = requireReadyWorkshop_();
    if (state.triggerState !== 'READY' || String(e.triggerUid) !== state.triggerId || e.source.getId() !== state.formId) {
      throw new Error('Submission source or trigger does not match this user\'s saved project.');
    }
    requireWorkshopResponseSettings_(e.source);
    rememberWorkshopResponse_(state, e.response);
  });
}

function recordSelectedWorkshopResponse() {
  if (!isWorkshopId_(WORKSHOP.responseId)) throw new Error('Set responseId to an inspected ID from this form\'s log or saved records.');
  withWorkshopLock_(() => {
    const state = requireReadyWorkshop_();
    const form = openWorkshopForm_(state);
    requireWorkshopResponseSettings_(form);
    rememberWorkshopResponse_(state, form.getResponse(WORKSHOP.responseId));
  });
}

function inspectWorkshopResponses() {
  const state = requireReadyWorkshop_();
  const form = openWorkshopForm_(state);
  requireWorkshopResponseSettings_(form);
  const ids = WORKSHOP.responseId ? [WORKSHOP.responseId] : state.responseIds;
  if (ids.some((id) => !isWorkshopId_(id))) throw new Error('Supply a response ID, not an edit-response URL.');
  for (const id of ids) {
    const response = form.getResponse(id); // At most five direct lookups, never getResponses().
    console.log(JSON.stringify(summarizeWorkshopResponse_(state, response)));
  }
  console.log(JSON.stringify({ responsesInspected: ids.length, recordedResponses: state.responseIds.length }));
}

function removeWorkshopTrigger() {
  withWorkshopLock_(() => {
    const state = requireReadyWorkshop_();
    if (!state.triggerId || WORKSHOP.removeTriggerConfirmation !== 'REMOVE TRIGGER ' + state.triggerId) {
      throw new Error('Supply the exact REMOVE TRIGGER confirmation for the saved ID.');
    }
    const trigger = ScriptApp.getProjectTriggers().find((candidate) => candidate.getUniqueId() === state.triggerId);
    if (trigger) {
      if (!isWorkshopTrigger_(trigger, state)) throw new Error('The identified trigger no longer matches. Stop.');
      ScriptApp.deleteTrigger(trigger); // Only the explicitly confirmed trigger; never form data.
    }
    if (state.triggerState !== 'REMOVED') {
      state.triggerState = 'REMOVED';
      saveWorkshopState_(state);
    }
    console.log(JSON.stringify({ action: 'TRIGGER_REMOVED', triggerId: state.triggerId }));
  });
}

/**
 * @param {FormApp.Form} form
 * @param {WorkshopState} state
 * @returns {void}
 */
function configureWorkshopQuestions_(form, state) {
  const alias = requireWorkshopItem_(form, state.itemIds.alias).asTextItem();
  alias.setRequired(true).setPoints(0).setHelpText('Use Comet or Cedar. This is not identity verification.');
  requireWorkshopItem_(form, state.itemIds.mapsNote).asParagraphTextItem()
    .setRequired(true).setPoints(0).setHelpText('One short fictional sentence. No personal information.');
  requireWorkshopItem_(form, state.itemIds.automationNote).asParagraphTextItem()
    .setRequired(true).setPoints(0).setHelpText('One short fictional sentence. No personal information.');
  const mapsPage = requireWorkshopItem_(form, state.itemIds.mapsPage).asPageBreakItem();
  const automationPage = requireWorkshopItem_(form, state.itemIds.automationPage).asPageBreakItem();
  const checkPage = requireWorkshopItem_(form, state.itemIds.checkPage).asPageBreakItem();
  const route = requireWorkshopItem_(form, state.itemIds.route).asMultipleChoiceItem();
  route.setRequired(true).setPoints(0).showOtherOption(false).setChoices([
    route.createChoice(MAPS_CHOICE, mapsPage),
    route.createChoice(AUTOMATION_CHOICE, automationPage),
  ]);
  mapsPage.setGoToPage(FormApp.PageNavigationType.CONTINUE);
  // This break controls the END of the preceding Maps page, not the Automation page.
  automationPage.setGoToPage(checkPage);
  checkPage.setGoToPage(FormApp.PageNavigationType.CONTINUE);
  const check = requireWorkshopItem_(form, state.itemIds.check).asMultipleChoiceItem();
  check.setRequired(true).setPoints(1).showOtherOption(false).setChoices([
    check.createChoice(CORRECT_CHECK, true),
    check.createChoice(INCORRECT_CHECK, false),
  ]);
  check.setFeedbackForCorrect(FormApp.createFeedback().setText('Correct. Review the actual recipient and content before sending.').build());
  check.setFeedbackForIncorrect(FormApp.createFeedback().setText('An uncertain send must be inspected, not blindly repeated.').build());
}

/**
 * @param {FormApp.Form} form
 * @param {number} id
 * @returns {FormApp.Item}
 */
function requireWorkshopItem_(form, id) {
  const item = form.getItemById(id);
  if (item === null) throw new Error('A recorded item is missing. Stop and inspect the form.');
  return item;
}

/**
 * @param {FormApp.Form} form
 * @param {WorkshopItemType} type
 * @returns {FormApp.Item}
 */
function appendWorkshopItem_(form, type) {
  switch (type) {
    case 'TEXT': return form.addTextItem();
    case 'MULTIPLE_CHOICE': return form.addMultipleChoiceItem();
    case 'PAGE_BREAK': return form.addPageBreakItem();
    case 'PARAGRAPH_TEXT': return form.addParagraphTextItem();
    default: throw new Error('Unsupported workshop item type.');
  }
}

/**
 * @param {FormApp.Form} form
 * @param {WorkshopState} state
 * @param {number} extra
 * @returns {FormApp.Item[]}
 */
function checkWorkshopItems_(form, state, extra) {
  const items = form.getItems();
  const knownCount = Object.keys(state.itemIds).length;
  if (items.length !== knownCount + extra || items.length > WORKSHOP_ITEMS.length) {
    throw new Error('Unexpected item count. Inspect saved and actual IDs; never append to compensate.');
  }
  for (let index = 0; index < items.length; index += 1) {
    const definition = WORKSHOP_ITEMS[index];
    if (items[index].getType() !== workshopItemType_(definition.type) ||
        (index < knownCount && items[index].getId() !== state.itemIds[definition.key])) {
      throw new Error('Item order, type or saved ID changed at ' + definition.key + '. Stop.');
    }
  }
  return items;
}

/**
 * @param {WorkshopItemType} type
 * @returns {FormApp.ItemType}
 */
function workshopItemType_(type) {
  switch (type) {
    case 'TEXT': return FormApp.ItemType.TEXT;
    case 'MULTIPLE_CHOICE': return FormApp.ItemType.MULTIPLE_CHOICE;
    case 'PAGE_BREAK': return FormApp.ItemType.PAGE_BREAK;
    case 'PARAGRAPH_TEXT': return FormApp.ItemType.PARAGRAPH_TEXT;
  }
}

/**
 * @param {WorkshopState} state
 * @returns {FormApp.Form}
 */
function openWorkshopForm_(state) {
  if (!state.formId) throw new Error('No confirmed form ID is saved. Reconcile creation first.');
  const form = FormApp.openById(state.formId);
  if (!form.supportsAdvancedResponderPermissions() || form.getTitle() !== state.formTitle || form.getDestinationId()) {
    throw new Error('The saved form has unsupported publishing, a changed title or a linked destination. Inspect it.');
  }
  return form;
}

/**
 * @param {FormApp.Form} form
 * @returns {void}
 */
function requireUnpublishedWorkshop_(form) {
  if (!form.supportsAdvancedResponderPermissions() || form.isPublished()) {
    throw new Error('Setup requires the original unpublished practice form. No legacy publication fallback is provided.');
  }
}

/**
 * @param {FormApp.Form} form
 * @returns {void}
 */
function requireWorkshopResponseSettings_(form) {
  if (!form.isQuiz() || form.collectsEmail() || form.canEditResponse() || form.isPublishingSummary() || form.getDestinationId()) {
    throw new Error('Keep quiz mode on, email collection/response editing/results summary off, and no linked Sheet.');
  }
}

/**
 * @param {ScriptApp.Trigger} trigger
 * @param {WorkshopState} state
 * @returns {boolean}
 */
function isWorkshopTrigger_(trigger, state) {
  return trigger.getHandlerFunction() === WORKSHOP_HANDLER &&
    trigger.getTriggerSource() === ScriptApp.TriggerSource.FORMS &&
    trigger.getEventType() === ScriptApp.EventType.ON_FORM_SUBMIT &&
    trigger.getTriggerSourceId() === state.formId;
}

/**
 * @param {WorkshopState} state
 * @param {FormApp.FormResponse} response
 * @returns {{responseId: string, submittedAt: string, branch: string, feedbackCharacters: number, practiceAnswerMatchesKey: boolean, observedQuizScore: number|string}}
 */
function summarizeWorkshopResponse_(state, response) {
  const id = response.getId();
  const timestamp = response.getTimestamp();
  if (typeof id !== 'string' || !isWorkshopId_(id) || !timestamp || !Number.isFinite(timestamp.getTime())) {
    throw new Error('A submitted response with its own ID and timestamp is required.');
  }
  /** @type {Map<string, {value: string, itemResponse: FormApp.ItemResponse}>} */
  const answers = new Map();
  const itemResponses = response.getItemResponses();
  if (itemResponses.length > 5) throw new Error('Unexpected response structure; this project has five questions.');
  for (const itemResponse of itemResponses) {
    const item = itemResponse.getItem();
    const definition = WORKSHOP_ITEMS.find((candidate) => state.itemIds[candidate.key] === item.getId());
    if (!definition || definition.type === 'PAGE_BREAK' || item.getType() !== FormApp.ItemType[definition.type] || answers.has(definition.key)) {
      throw new Error('Unknown, repeated or changed question identity in the response.');
    }
    const value = itemResponse.getResponse();
    if (typeof value !== 'string') throw new Error('These questions return strings; do not flatten a checkbox or grid response.');
    answers.set(definition.key, { value: value, itemResponse: itemResponse });
  }
  const text = (/** @type {string} */ key) => {
    const answer = answers.get(key);
    return answer ? answer.value : '';
  };
  const branch = text('route');
  if (!text('alias').trim() || ![MAPS_CHOICE, AUTOMATION_CHOICE].includes(branch) ||
      ![CORRECT_CHECK, INCORRECT_CHECK].includes(text('check'))) {
    throw new Error('Required practice answers are absent or outside the supplied choices.');
  }
  const noteKey = branch === MAPS_CHOICE ? 'mapsNote' : 'automationNote';
  const otherKey = branch === MAPS_CHOICE ? 'automationNote' : 'mapsNote';
  if (!text(noteKey).trim() || text(otherKey).trim()) throw new Error('Response does not match one completed feedback branch.');
  const checkAnswer = answers.get('check');
  if (!checkAnswer) throw new Error('The practice check answer is absent.');
  const rawScore = checkAnswer.itemResponse.getScore();
  return {
    responseId: id,
    submittedAt: timestamp.toISOString(),
    branch: branch,
    feedbackCharacters: text(noteKey).length,
    practiceAnswerMatchesKey: text('check') === CORRECT_CHECK,
    observedQuizScore: typeof rawScore === 'number' && Number.isFinite(rawScore) ? rawScore : 'not_available',
  };
}

/**
 * @param {WorkshopState} state
 * @param {FormApp.FormResponse} response
 * @returns {void}
 */
function rememberWorkshopResponse_(state, response) {
  const summary = summarizeWorkshopResponse_(state, response);
  if (state.responseIds.includes(summary.responseId)) {
    console.log(JSON.stringify({ action: 'ALREADY_RECORDED', responseId: summary.responseId }));
    return;
  }
  if (state.responseIds.length >= MAX_WORKSHOP_RECEIPTS) {
    throw new Error('Five response IDs are already recorded. The submitted response remains in Forms; stop further practice submissions.');
  }
  state.responseIds.push(summary.responseId);
  saveWorkshopState_(state);
  console.log(JSON.stringify({ action: 'RESPONSE_RECORDED', summary: summary }));
}

function requireWorkshopState_() {
  const state = readWorkshopState_();
  if (!state) throw new Error('Run the deliberate setup first. No saved project exists for this user.');
  return state;
}

function requireReadyWorkshop_() {
  const state = requireWorkshopState_();
  if (state.phase !== 'READY') throw new Error('Finish or reconcile setup before working with triggers or responses.');
  return state;
}

function readWorkshopState_() {
  const raw = PropertiesService.getUserProperties().getProperty(WORKSHOP_STATE_KEY);
  if (raw === null) return null;
  /** @type {WorkshopState} */
  let state;
  try { state = JSON.parse(raw); }
  catch (error) { throw new Error('Saved state is invalid JSON. Preserve it; do not reset it.'); }
  const invalid = () => { throw new Error('Saved state is invalid. Preserve the form, item, trigger and response IDs.'); };
  if (!state || !['CREATE_UNCERTAIN', 'BUILDING', 'READY'].includes(state.phase) ||
      typeof state.formTitle !== 'string' || !/^Book workshop practice \[[0-9a-f-]{36}\]$/i.test(state.formTitle) ||
      typeof state.formId !== 'string' || !state.itemIds || typeof state.itemIds !== 'object' || Array.isArray(state.itemIds) ||
      typeof state.pendingItem !== 'string' || !['NONE', 'CREATE_UNCERTAIN', 'READY', 'REMOVED'].includes(state.triggerState) ||
      typeof state.triggerId !== 'string' || !Array.isArray(state.responseIds) || state.responseIds.length > MAX_WORKSHOP_RECEIPTS) invalid();
  const count = Object.keys(state.itemIds).length;
  if (count > WORKSHOP_ITEMS.length || WORKSHOP_ITEMS.slice(0, count).some((item) => !Number.isInteger(state.itemIds[item.key])) ||
      new Set(Object.values(state.itemIds)).size !== count ||
      (state.pendingItem && (count >= WORKSHOP_ITEMS.length || state.pendingItem !== WORKSHOP_ITEMS[count].key)) ||
      state.responseIds.some((id) => !isWorkshopId_(id)) || new Set(state.responseIds).size !== state.responseIds.length) invalid();
  if (state.phase === 'CREATE_UNCERTAIN' ? state.formId !== '' || count !== 0 || state.pendingItem !== '' : !isWorkshopId_(state.formId)) invalid();
  if (state.phase === 'READY' && (count !== WORKSHOP_ITEMS.length || state.pendingItem)) invalid();
  if (['READY', 'REMOVED'].includes(state.triggerState) ? !isWorkshopId_(state.triggerId) : state.triggerId !== '') invalid();
  if (state.phase !== 'READY' && (state.triggerState !== 'NONE' || state.responseIds.length)) invalid();
  return state;
}

/**
 * @param {WorkshopState} state
 * @returns {void}
 */
function saveWorkshopState_(state) {
  const text = JSON.stringify(state);
  if (Utilities.newBlob(text).getBytes().length > 8000) throw new Error('Saved state exceeds the practice allowance. Do not erase history.');
  PropertiesService.getUserProperties().setProperty(WORKSHOP_STATE_KEY, text);
}

/**
 * @param {function(): void} operation
 * @returns {void}
 */
function withWorkshopLock_(operation) {
  const lock = LockService.getUserLock();
  if (!lock.tryLock(1000)) throw new Error('Another execution holds this user lock. Inspect its result before repeating work.');
  try { operation(); }
  finally { lock.releaseLock(); }
}

/**
 * @param {string} value
 * @returns {boolean}
 */
function isWorkshopId_(value) {
  return typeof value === 'string' && value.length > 0 && value.length <= 1024 && !/\s/.test(value);
}

{
  "timeZone": "Etc/UTC",
  "dependencies": {},
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "oauthScopes": [
    "https://www.googleapis.com/auth/forms",
    "https://www.googleapis.com/auth/script.scriptapp"
  ]
}

[
  {
    "alias": "Comet",
    "route": "Maps lab",
    "mapsNote": "Map labels made the route clear.",
    "check": "Review the recipient and content"
  },
  {
    "alias": "Cedar",
    "route": "Automation lab",
    "automationNote": "The checkpoint example was useful.",
    "check": "Keep retrying until something is sent"
  }
]