@marktiderman/genesis-forms 0.2.0 → 0.3.1

package/dist/destinations.js

@@ -0,0 +1,1193 @@
+// src/destinations/types.ts
+var DeliveryError = class extends Error {
+  name = "DeliveryError";
+  retryable;
+  retryAfterSeconds;
+  status;
+  constructor(message, options = {}) {
+    super(message);
+    this.retryable = options.retryable ?? false;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+    this.status = options.status;
+  }
+};
+var REQUEST_TIMEOUT_MS = 1e4;
+var IMF_FIXDATE = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/;
+function retryAfterSeconds(header, fallback = 60, now = Date.now()) {
+  const clamp = (s) => Math.min(86400, Math.max(1, s));
+  if (header) {
+    const trimmed = header.trim();
+    if (/^\d+$/.test(trimmed)) return clamp(Number(trimmed));
+    if (IMF_FIXDATE.test(trimmed)) {
+      const at = Date.parse(trimmed);
+      if (Number.isFinite(at)) return clamp(Math.ceil((at - now) / 1e3));
+    }
+  }
+  return fallback;
+}
+function isRetryableStatus(status) {
+  return status === 408 || status === 425 || status === 429 || status >= 500;
+}
+function httpError(what, response, detail) {
+  const status = response.status;
+  const message = `${what} answered ${status}${detail ? ` (${detail})` : ""}`;
+  if (isRetryableStatus(status)) {
+    return new DeliveryError(message, {
+      retryable: true,
+      retryAfterSeconds: retryAfterSeconds(response.headers.get("retry-after")),
+      status
+    });
+  }
+  return new DeliveryError(message, { retryable: false, status });
+}
+function deliveryFailure(error) {
+  if (error instanceof DeliveryError) {
+    return {
+      ok: false,
+      retryable: error.retryable,
+      error: error.message.slice(0, 500),
+      ...error.retryAfterSeconds !== void 0 ? { retryAfterSeconds: error.retryAfterSeconds } : {},
+      ...error.status !== void 0 ? { status: error.status } : {}
+    };
+  }
+  const name = error instanceof Error ? error.name : "";
+  if (name === "TimeoutError") return { ok: false, retryable: true, error: "Timed out" };
+  if (name === "AbortError") return { ok: false, retryable: true, error: "Aborted" };
+  if (name === "TypeError") return { ok: false, retryable: false, error: "Unexpected error" };
+  return { ok: false, retryable: true, error: "Unexpected error" };
+}
+async function timedFetch(deps, url, init, signal) {
+  const timeout = AbortSignal.timeout(deps.timeoutMs ?? REQUEST_TIMEOUT_MS);
+  const any = AbortSignal.any;
+  const combined = signal ? any ? any([timeout, signal]) : signal.aborted ? signal : timeout : timeout;
+  try {
+    new Request(url, { method: init.method ?? "GET", headers: init.headers ?? {} });
+  } catch {
+    throw new DeliveryError("Invalid request (a header value or the URL is malformed)", { retryable: false });
+  }
+  try {
+    return await (deps.fetch ?? fetch)(url, { ...init, signal: combined });
+  } catch (error) {
+    if (error instanceof Error && error.name === "TypeError") throw new DeliveryError("Network error", { retryable: true });
+    throw error;
+  }
+}
+async function resolveOption(what, option, config) {
+  if (typeof option !== "function") return option;
+  try {
+    return await option(config);
+  } catch (error) {
+    if (error instanceof DeliveryError) throw error;
+    throw new DeliveryError(`${what} could not be resolved`);
+  }
+}
+function discard(response) {
+  try {
+    void response.body?.cancel().catch(() => {
+    });
+  } catch {
+  }
+}
+function configString(config, key, alias) {
+  const raw = config[key] ?? (alias ? config[alias] : void 0);
+  return typeof raw === "string" ? raw.trim() : "";
+}
+function base64url(bytes) {
+  return base64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64(bytes) {
+  const raw = typeof bytes === "string" ? new TextEncoder().encode(bytes) : bytes;
+  let s = "";
+  for (let i = 0; i < raw.length; i++) s += String.fromCharCode(raw[i]);
+  return btoa(s);
+}
+function fromBase64(text) {
+  const bin = atob(text.replace(/-/g, "+").replace(/_/g, "/"));
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+async function sha256Hex(text) {
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+// src/structured.ts
+var isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function intProp(field, name, fallback, floor = 1) {
+  const v = field.props?.[name];
+  return typeof v === "number" && Number.isInteger(v) && v >= floor ? v : fallback;
+}
+function optionalIntProp(field, name, floor = 0) {
+  const v = field.props?.[name];
+  return typeof v === "number" && Number.isInteger(v) && v >= floor ? v : void 0;
+}
+var blank = (v) => typeof v !== "string" || v.trim() === "";
+var blankText = (v) => typeof v === "string" && v.trim() === "";
+var emptyList = (value, isBlank) => value === void 0 || value === null || Array.isArray(value) && value.every(isBlank);
+var plural = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function listLimits(field) {
+  return { min: optionalIntProp(field, "min") ?? 0, max: intProp(field, "max", 10), itemMaxLength: intProp(field, "itemMaxLength", 500) };
+}
+var listItems = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string" && v.trim() !== "") : [];
+var MAX_TABLE_CELL_LENGTH = 2e3;
+function tableColumns(field) {
+  const raw = field.props?.columns;
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const c of raw) {
+    if (!isObject(c) || typeof c.key !== "string" || !c.key || seen.has(c.key)) continue;
+    seen.add(c.key);
+    const column = { key: c.key, label: typeof c.label === "string" ? c.label : c.key };
+    if (c.long === true) column.long = true;
+    out.push(column);
+  }
+  return out;
+}
+function tableLimits(field) {
+  return { minRows: optionalIntProp(field, "minRows") ?? 0, maxRows: intProp(field, "maxRows", 3) };
+}
+var filledRows = (value) => Array.isArray(value) ? value.filter((r) => isObject(r) && Object.values(r).some((c) => !blank(c))) : [];
+var MAX_TIMESTAMP_SECONDS = 86400;
+function formatTimestamp(seconds) {
+  const total = Number.isFinite(seconds) && seconds > 0 ? Math.floor(seconds) : 0;
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = String(total % 60).padStart(2, "0");
+  return h ? `${h}:${String(m).padStart(2, "0")}:${s}` : `${m}:${s}`;
+}
+var isTimestamp = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 && v <= MAX_TIMESTAMP_SECONDS;
+var notesWithText = (value) => Array.isArray(value) ? value.filter((n) => isObject(n) && !blank(n.text)) : [];
+var MAX_HIGHLIGHT_NOTE_LENGTH = 1e3;
+var MAX_HIGHLIGHT_QUOTE_LENGTH = 2e3;
+var HIGHLIGHT_NOTE_MESSAGE = "Add a note to each highlight.";
+var sourceText = (field) => typeof field.props?.text === "string" && field.props.text ? field.props.text : void 0;
+var structuredFieldTypes = [
+  {
+    type: "list",
+    label: "List",
+    category: "text",
+    value: { json: true },
+    // logic.ts `contains` on an array is exact item equality, same as multi-choice, so it is offered.
+    operators: ["contains", "answered", "empty"],
+    a11y: { semantics: "group" },
+    isEmpty: (value) => emptyList(value, blankText),
+    validate: (value, field) => {
+      if (!Array.isArray(value) || !value.every((v) => typeof v === "string")) return "Enter a list of answers.";
+      const { min, max, itemMaxLength } = listLimits(field);
+      if (value.some((v) => v.trim().length > itemMaxLength)) return `Keep each item under ${itemMaxLength} characters.`;
+      const count = listItems(value).length;
+      if (count < min) return `Add at least ${plural(min, "item")}.`;
+      if (count > max) return `Add at most ${plural(max, "item")}.`;
+      return null;
+    },
+    normalize: (value) => Array.isArray(value) ? listItems(value).map((v) => v.trim()) : value,
+    summarize: (value) => listItems(value).map((v) => v.trim()).join("; "),
+    samples: (field) => {
+      const { min, max } = listLimits(field);
+      return [Array.from({ length: Math.min(Math.max(1, min), max) }, (_, i) => `Item ${i + 1}`)];
+    }
+  },
+  {
+    type: "table",
+    label: "Table",
+    category: "advanced",
+    value: { json: true },
+    operators: ["answered", "empty"],
+    a11y: { semantics: "group" },
+    isEmpty: (value) => emptyList(value, (r) => isObject(r) && Object.values(r).every(blankText)),
+    validate: (value, field) => {
+      const columns = tableColumns(field);
+      if (!columns.length) return "This question has no columns.";
+      if (!Array.isArray(value) || !value.every(isObject)) return "Fill in the rows.";
+      const keys = new Set(columns.map((c) => c.key));
+      for (const row of value) {
+        for (const [key, cell] of Object.entries(row)) {
+          if (!keys.has(key)) return "An answer names a column this question doesn't have.";
+          if (typeof cell !== "string") return "Fill in the rows with text.";
+          if (cell.trim().length > MAX_TABLE_CELL_LENGTH) return `Keep each answer under ${MAX_TABLE_CELL_LENGTH} characters.`;
+        }
+      }
+      const { minRows, maxRows } = tableLimits(field);
+      const count = filledRows(value).length;
+      if (count < minRows) return `Fill in at least ${plural(minRows, "row")}.`;
+      if (count > maxRows) return `Fill in at most ${plural(maxRows, "row")}.`;
+      return null;
+    },
+    normalize: (value) => Array.isArray(value) ? filledRows(value).map((row) => {
+      const out = {};
+      for (const [key, cell] of Object.entries(row)) if (typeof cell === "string") out[key] = cell.trim();
+      return out;
+    }) : value,
+    summarize: (value, field) => {
+      const columns = tableColumns(field);
+      return filledRows(value).map((row) => columns.filter((c) => !blank(row[c.key])).map((c) => `${c.label}: ${row[c.key].trim()}`).join(" \xB7 ")).join(" / ");
+    },
+    samples: (field) => {
+      const columns = tableColumns(field);
+      if (!columns.length) return [];
+      const { minRows, maxRows } = tableLimits(field);
+      const row = Object.fromEntries(columns.map((c) => [c.key, "sample"]));
+      return [Array.from({ length: Math.min(Math.max(1, minRows), maxRows) }, () => ({ ...row }))];
+    }
+  },
+  {
+    type: "media-notes",
+    label: "Notes at moments",
+    category: "media",
+    value: { json: true },
+    operators: ["answered", "empty"],
+    a11y: { semantics: "group" },
+    isEmpty: (value) => emptyList(value, (n) => isObject(n) && blankText(n.text)),
+    validate: (value, field) => {
+      if (!Array.isArray(value)) return "Add notes.";
+      const textMaxLength = intProp(field, "textMaxLength", 1e3);
+      for (const note of value) {
+        if (!isObject(note) || typeof note.text !== "string") return "Add notes.";
+        if (!isTimestamp(note.at)) return "Each note needs a time.";
+        if (note.text.trim().length > textMaxLength) return `Keep each note under ${textMaxLength} characters.`;
+      }
+      const maxNotes = intProp(field, "maxNotes", 20);
+      return notesWithText(value).length > maxNotes ? `Add at most ${plural(maxNotes, "note")}.` : null;
+    },
+    normalize: (value) => Array.isArray(value) ? notesWithText(value).map((n) => ({ at: n.at, text: n.text.trim() })).sort((a, b) => a.at - b.at) : value,
+    summarize: (value) => notesWithText(value).map((n) => ({ at: typeof n.at === "number" ? n.at : 0, text: n.text.trim() })).sort((a, b) => a.at - b.at).map((n) => `${formatTimestamp(n.at)} ${n.text}`).join("; "),
+    samples: () => [[{ at: 0, text: "sample" }]]
+  },
+  {
+    type: "text-highlights",
+    label: "Highlights",
+    category: "media",
+    value: { json: true },
+    operators: ["answered", "empty"],
+    a11y: { semantics: "group" },
+    isEmpty: (value) => emptyList(value, () => false),
+    validate: (value, field) => {
+      if (!Array.isArray(value)) return "Highlight a passage.";
+      const maxHighlights = intProp(field, "maxHighlights", 20);
+      if (value.length > maxHighlights) return `Add at most ${plural(maxHighlights, "highlight")}.`;
+      const text = sourceText(field);
+      for (const h of value) {
+        if (!isObject(h) || !Number.isInteger(h.start) || !Number.isInteger(h.end) || typeof h.quote !== "string" || typeof h.note !== "string") {
+          return "Highlight a passage of the text.";
+        }
+        const start = h.start;
+        const end = h.end;
+        if (start < 0 || end <= start || h.quote.length !== end - start) return "Highlight a passage of the text.";
+        if (end - start > MAX_HIGHLIGHT_QUOTE_LENGTH) return `Highlight under ${MAX_HIGHLIGHT_QUOTE_LENGTH} characters at a time.`;
+        if (text !== void 0 && (end > text.length || text.slice(start, end) !== h.quote)) return "A highlight doesn't match the text.";
+        if (h.note.trim() === "") return HIGHLIGHT_NOTE_MESSAGE;
+        if (h.note.trim().length > MAX_HIGHLIGHT_NOTE_LENGTH) return `Keep each note under ${MAX_HIGHLIGHT_NOTE_LENGTH} characters.`;
+      }
+      return null;
+    },
+    normalize: (value) => Array.isArray(value) ? value.filter(isObject).map((h) => ({ start: h.start, end: h.end, quote: h.quote, note: String(h.note).trim() })).sort((a, b) => a.start - b.start || a.end - b.end) : value,
+    summarize: (value) => Array.isArray(value) ? value.filter(isObject).map((h) => `"${String(h.quote)}" \u2014 ${String(h.note).trim()}`).join("; ") : "",
+    samples: (field) => {
+      const text = sourceText(field);
+      if (text === void 0) return [[{ start: 0, end: 6, quote: "sample", note: "sample" }]];
+      const end = Math.min(text.length, 20);
+      return [[{ start: 0, end, quote: text.slice(0, end), note: "sample" }]];
+    }
+  }
+];
+
+// src/fields.ts
+var REGISTRY = /* @__PURE__ */ Symbol.for("@marktiderman/genesis-forms/field-types");
+var globalScope = globalThis;
+var registry = globalScope[REGISTRY] ??= /* @__PURE__ */ new Map();
+function registerFieldType(manifest) {
+  if (!manifest.type) throw new Error("registerFieldType: a field type needs a `type`.");
+  const value = manifest.value;
+  if (!value.json && (typeof value.serialize !== "function" || typeof value.deserialize !== "function")) {
+    throw new Error(
+      `registerFieldType: "${manifest.type}" stores a non-JSON value, so it must provide both serialize and deserialize.`
+    );
+  }
+  registry.set(manifest.type, manifest);
+}
+function getFieldType(type) {
+  return registry.get(type);
+}
+function isEmptyValue(value, field) {
+  const manifest = field ? registry.get(field.type) : void 0;
+  if (manifest?.isEmpty) return manifest.isEmpty(value);
+  if (value === void 0 || value === null) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  return false;
+}
+function isSensitive(block) {
+  return block.kind === "field" && (block.sensitive === true || block.props?.sensitive === true);
+}
+function summarizeValue(value, field) {
+  if (isEmptyValue(value, field)) return "";
+  const manifest = registry.get(field.type);
+  if (manifest?.summarize) return manifest.summarize(value, field);
+  if (Array.isArray(value)) return value.join(", ");
+  return String(value);
+}
+function choiceOptions(field) {
+  const raw = field.props?.options;
+  if (!Array.isArray(raw)) return [];
+  return raw.flatMap(
+    (o) => o && typeof o === "object" && !Array.isArray(o) && typeof o.value === "string" ? [{ value: o.value, label: typeof o.label === "string" ? o.label : void 0 }] : []
+  );
+}
+function optionLabel(field, value) {
+  const option = choiceOptions(field).find((o) => o.value === value);
+  return option?.label ?? value;
+}
+function intRange(field, min, maxDefault) {
+  const max = typeof field.props?.max === "number" ? field.props.max : maxDefault;
+  return { min, max };
+}
+var numberOps = ["eq", "neq", "lt", "lte", "gt", "gte", "in", "answered", "empty"];
+var textOps = ["eq", "neq", "contains", "answered", "empty"];
+function maxLength(field, fallback) {
+  return typeof field.props?.maxLength === "number" ? field.props.maxLength : fallback;
+}
+function textValidate(fallback) {
+  return (value, field) => {
+    if (typeof value !== "string") return "Enter text.";
+    const limit = maxLength(field, fallback);
+    return value.length > limit ? `Keep it under ${limit} characters.` : null;
+  };
+}
+var MAX_EMAIL_LENGTH = 254;
+function isEmailAddress(value) {
+  if (value.length > MAX_EMAIL_LENGTH || /\s/.test(value)) return false;
+  const at = value.indexOf("@");
+  if (at < 1 || value.indexOf("@", at + 1) !== -1) return false;
+  const domain = value.slice(at + 1);
+  return domain.slice(1, -1).includes(".");
+}
+var MAX_PHONE_LENGTH = 32;
+function isPhoneNumber(value) {
+  if (value.length > MAX_PHONE_LENGTH) return false;
+  let digits = 0;
+  for (let i = 0; i < value.length; i++) {
+    const c = value[i];
+    if (c >= "0" && c <= "9") digits++;
+    else if (c === "+") {
+      if (i !== 0) return false;
+    } else if (c !== " " && c !== "-" && c !== "(" && c !== ")" && c !== ".") return false;
+  }
+  return digits >= 7 && digits <= 15;
+}
+var builtins = [
+  {
+    type: "short-text",
+    label: "Short text",
+    category: "text",
+    value: { json: true },
+    operators: textOps,
+    a11y: { semantics: "control" },
+    validate: textValidate(500)
+  },
+  {
+    type: "long-text",
+    label: "Long text",
+    category: "text",
+    value: { json: true },
+    operators: textOps,
+    a11y: { semantics: "control" },
+    validate: textValidate(5e3)
+  },
+  {
+    type: "email",
+    label: "Email",
+    category: "text",
+    value: { json: true },
+    operators: textOps,
+    a11y: { semantics: "control", autocomplete: "email", inputMode: "email" },
+    validate: (value) => typeof value === "string" && isEmailAddress(value.trim()) ? null : "Enter an email address like name@example.com.",
+    normalize: (value) => typeof value === "string" ? value.trim() : value
+  },
+  {
+    type: "phone",
+    label: "Phone",
+    category: "text",
+    value: { json: true },
+    operators: ["eq", "neq", "answered", "empty"],
+    a11y: { semantics: "control", autocomplete: "tel", inputMode: "tel" },
+    validate: (value) => typeof value === "string" && isPhoneNumber(value.trim()) ? null : "Enter a phone number with 7 to 15 digits.",
+    normalize: (value) => typeof value === "string" ? value.trim() : value,
+    summarize: (value) => String(value)
+  },
+  {
+    type: "rating",
+    label: "Rating",
+    category: "scale",
+    value: { json: true },
+    operators: numberOps,
+    a11y: { semantics: "group" },
+    validate: (value, field) => {
+      const { min, max } = intRange(field, 1, 5);
+      return Number.isInteger(value) && value >= min && value <= max ? null : `Choose a rating from ${min} to ${max}.`;
+    },
+    summarize: (value, field) => `${value}/${intRange(field, 1, 5).max}`
+  },
+  {
+    type: "nps",
+    label: "Net Promoter Score",
+    category: "scale",
+    value: { json: true },
+    operators: numberOps,
+    a11y: { semantics: "group" },
+    validate: (value) => Number.isInteger(value) && value >= 0 && value <= 10 ? null : "Choose a score from 0 to 10.",
+    summarize: (value) => `${value}/10`
+  },
+  {
+    type: "single-choice",
+    label: "Single choice",
+    category: "choice",
+    value: { json: true },
+    operators: ["eq", "neq", "in", "answered", "empty"],
+    a11y: { semantics: "group" },
+    validate: (value, field) => typeof value === "string" && choiceOptions(field).some((o) => o.value === value) ? null : "Choose one of the options.",
+    summarize: (value, field) => optionLabel(field, String(value))
+  },
+  {
+    type: "multi-choice",
+    label: "Multiple choice",
+    category: "choice",
+    value: { json: true },
+    operators: ["contains", "answered", "empty"],
+    a11y: { semantics: "group" },
+    validate: (value, field) => {
+      const allowed = new Set(choiceOptions(field).map((o) => o.value));
+      return Array.isArray(value) && value.length <= allowed.size && new Set(value).size === value.length && value.every((v) => typeof v === "string" && allowed.has(v)) ? null : "Choose from the options.";
+    },
+    summarize: (value, field) => Array.isArray(value) ? value.map((v) => optionLabel(field, String(v))).join(", ") : String(value)
+  },
+  {
+    type: "yes-no",
+    label: "Yes / no",
+    category: "choice",
+    value: { json: true },
+    operators: ["eq", "neq", "answered", "empty"],
+    a11y: { semantics: "group" },
+    validate: (value) => typeof value === "boolean" ? null : "Choose yes or no.",
+    summarize: (value) => value ? "Yes" : "No"
+  }
+];
+for (const manifest of [...builtins, ...structuredFieldTypes]) registerFieldType(manifest);
+
+// src/logic.ts
+function own(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key) ? record[key] : void 0;
+}
+function withheld(def, field) {
+  return def.settings?.anonymous === true && field?.identifying === true;
+}
+
+// src/recall.ts
+var TOKEN = /\{\{\s*(field|hidden):([A-Za-z0-9_-]+)\s*(?:\|([^}]*))?\}\}/g;
+function recall(text, scope) {
+  return text.replace(TOKEN, (_match, kind, name, fallback) => {
+    if (kind === "field") {
+      const field = scope.fieldsByKey.get(name);
+      const out2 = field ? summarizeValue(own(scope.values, field.id), field) : "";
+      return out2 || (fallback ?? "").trim();
+    }
+    const value = own(scope.hidden, name);
+    const out = value === void 0 || value === null ? "" : String(value);
+    return out || (fallback ?? "").trim();
+  });
+}
+
+// src/destinations/row.ts
+var SENSITIVE_MASK = "[sensitive]";
+var RESERVED = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function answerCell(field, value) {
+  if (value === void 0 || isEmptyValue(value, field)) return "";
+  if (typeof value === "number") return value;
+  const manifest = getFieldType(field.type);
+  if (manifest?.summarize) return summarizeValue(value, field);
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean") return value ? "Yes" : "No";
+  if (Array.isArray(value) && value.every((v) => typeof v !== "object" || v === null)) {
+    return value.map((v) => String(v)).join(", ");
+  }
+  return JSON.stringify(value);
+}
+function responseRow(submission, definition, options = {}) {
+  const row = {};
+  const columns = [];
+  const set = (key, value) => {
+    if (RESERVED.has(key)) return;
+    if (!Object.prototype.hasOwnProperty.call(row, key)) columns.push(key);
+    row[key] = value;
+  };
+  set("id", submission.id);
+  if (submission.submittedAt !== void 0) set("submitted_at", submission.submittedAt);
+  for (const [key, value] of Object.entries(submission.meta ?? {})) {
+    if (key !== "id" && key !== "submitted_at") set(key, value);
+  }
+  const fields = definition.blocks.filter((b) => b.kind === "field");
+  const fieldsByKey = new Map(fields.map((f) => [f.key, f]));
+  const sensitive = options.sensitive ?? "include";
+  const values = {};
+  for (const field of fields) {
+    const value = own(submission.answers, field.id);
+    if (value === void 0 || withheld(definition, field)) continue;
+    if (isSensitive(field) && sensitive !== "include") continue;
+    values[field.id] = value;
+  }
+  const scope = { fieldsByKey, values, hidden: visibleInputs(submission, definition, sensitive) };
+  const labels = {};
+  for (const field of fields) {
+    if (withheld(definition, field)) continue;
+    if (isSensitive(field) && sensitive === "omit") continue;
+    if (RESERVED.has(field.key)) continue;
+    labels[field.key] = recall(field.label, scope).trim() || field.key;
+    const cell = answerCell(field, own(submission.answers, field.id));
+    set(field.key, isSensitive(field) && sensitive === "mask" && cell !== "" ? SENSITIVE_MASK : cell);
+  }
+  return { row, columns, labels };
+}
+function visibleInputs(submission, definition, sensitive = "include") {
+  const declared = new Map((definition.hidden ?? []).map((h) => [h.name, h]));
+  const out = {};
+  for (const [name, value] of Object.entries({ ...submission.hidden, ...submission.context })) {
+    const input = declared.get(name);
+    if (RESERVED.has(name)) continue;
+    if (input?.identifying && definition.settings?.anonymous === true) continue;
+    if (input?.sensitive && sensitive !== "include") continue;
+    out[name] = value;
+  }
+  return out;
+}
+function escapeFormula(cell) {
+  if (typeof cell !== "string" || cell === "") return cell;
+  const first = cell[0];
+  if (first === "=" || first === "@" || first === "	" || first === "\r") return `'${cell}`;
+  if ((first === "+" || first === "-") && !/^[+-][\d\s().,+-]*$/.test(cell)) return `'${cell}`;
+  return cell;
+}
+
+// src/destinations/email.ts
+var MAX_RECIPIENTS = 50;
+var MAX_SUBJECT_LENGTH = 200;
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function headerSafe(text, max = MAX_SUBJECT_LENGTH) {
+  const flat = text.replace(/[\u0000-\u001f\u007f\u2028\u2029]+/g, " ").replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function isSafeAddress(value) {
+  return typeof value === "string" && isEmailAddress(value) && !/[\u0000-\u001f\u007f<>,;:"()[\]\\]/.test(value);
+}
+function isSafeFrom(value) {
+  const named = /^([^"<>\u0000-\u001f\u007f]{1,100}) <([^<>]+)>$/.exec(value);
+  return named ? isSafeAddress(named[2]) : isSafeAddress(value);
+}
+function emailBody(lines, footer) {
+  const text = lines.map(([k, v]) => `${k}: ${v}`).join("\n") + (footer ? `
+
+${footer}` : "");
+  const font = "font-family:sans-serif;font-size:14px;margin:0 0 12px";
+  const html = lines.map(
+    ([k, v]) => `<p style="${font}"><span style="color:#666">${escapeHtml(k)}</span><br><span style="white-space:pre-wrap">${escapeHtml(String(v))}</span></p>`
+  ).join("") + (footer ? `<p style="font-family:sans-serif;font-size:12px;color:#666">${escapeHtml(footer)}</p>` : "");
+  return { text, html };
+}
+function renderEmail(input) {
+  const { submission, definition, config, row } = input;
+  const lines = [];
+  const fieldKeys = new Set(Object.keys(row.labels));
+  for (const key of row.columns) {
+    if (key === "id") continue;
+    const value = row.row[key];
+    if (value === void 0 || value === "") continue;
+    const label = fieldKeys.has(key) ? row.labels[key] : key === "submitted_at" ? "Submitted" : key;
+    lines.push([label, value]);
+  }
+  const endings = definition.endings ?? [];
+  if (submission.ending && endings.length > 1) {
+    const ending = endings.find((e) => e.id === submission.ending);
+    if (ending) lines.push(["Ending", ending.title]);
+  }
+  if (!lines.length) lines.push(["Answers", "(none)"]);
+  const subject = configString(config, "subject") || `${definition.title || definition.id}: new response`;
+  return { subject, ...emailBody(lines, `Response ${submission.id}`) };
+}
+function recipients(config) {
+  const raw = config["to"];
+  const list = (Array.isArray(raw) ? raw : typeof raw === "string" ? raw.split(",") : []).map(
+    (t) => typeof t === "string" ? t.trim() : t
+  );
+  const to = [...new Set(list.filter(isSafeAddress))];
+  if (to.length !== list.filter((t) => t !== "").length) {
+    throw new DeliveryError("The email destination has an invalid recipient");
+  }
+  if (!to.length) throw new DeliveryError("The email destination has no recipients");
+  if (to.length > MAX_RECIPIENTS) throw new DeliveryError(`The email destination has more than ${MAX_RECIPIENTS} recipients`);
+  return to;
+}
+function replyToAddress(option, input) {
+  if (!option) return void 0;
+  let value;
+  if (typeof option === "function") value = option(input);
+  else {
+    const field = input.definition.blocks.find((b) => b.kind === "field" && b.key === option);
+    value = field ? own(input.submission.answers, field.id) : void 0;
+    if (field?.kind === "field" && field.identifying && input.definition.settings?.anonymous) value = void 0;
+  }
+  const trimmed = typeof value === "string" ? value.trim() : value;
+  return isSafeAddress(trimmed) ? trimmed : void 0;
+}
+async function idempotencyKey(deliveryId, to) {
+  const hex = await sha256Hex([...to].sort().join(","));
+  return `${deliveryId.slice(0, 200)}:${hex.slice(0, 16)}`;
+}
+function emailDestination(options) {
+  return {
+    kind: "email",
+    async deliver(submission, definition, config, deliveryOptions = {}) {
+      try {
+        if (!isSafeFrom(options.from)) throw new DeliveryError("The email destination's from address is invalid");
+        const to = recipients(config);
+        const row = responseRow(submission, definition, { sensitive: options.sensitive ?? "mask" });
+        const input = { submission, definition, config, row };
+        const content = (options.render ?? renderEmail)(input);
+        const replyTo = replyToAddress(options.replyTo, input);
+        await options.provider.send(
+          {
+            from: options.from,
+            to,
+            ...replyTo ? { replyTo } : {},
+            subject: headerSafe(content.subject) || "New response",
+            text: content.text,
+            html: content.html,
+            idempotencyKey: await idempotencyKey(deliveryOptions.deliveryId ?? submission.id, to)
+          },
+          { signal: deliveryOptions.signal }
+        );
+        return { ok: true };
+      } catch (error) {
+        return deliveryFailure(error);
+      }
+    }
+  };
+}
+var RESEND_API = "https://api.resend.com/emails";
+function resendProvider(options) {
+  return {
+    name: "resend",
+    async send(message, { signal }) {
+      if (!options.apiKey) throw new DeliveryError("The Resend API key is not set");
+      const response = await timedFetch(
+        options,
+        options.endpoint ?? RESEND_API,
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${options.apiKey}`,
+            "content-type": "application/json",
+            "idempotency-key": message.idempotencyKey
+          },
+          body: JSON.stringify({
+            from: message.from,
+            to: message.to,
+            subject: message.subject,
+            text: message.text,
+            html: message.html,
+            ...message.replyTo ? { reply_to: message.replyTo } : {}
+          })
+        },
+        signal
+      );
+      if (response.ok) {
+        discard(response);
+        return;
+      }
+      let name;
+      try {
+        const body = await response.json();
+        if (typeof body.name === "string" && /^[a-z_]{1,64}$/.test(body.name)) name = body.name;
+      } catch {
+      }
+      if (response.status === 409 && name === "concurrent_idempotent_requests") {
+        throw new DeliveryError("Resend answered 409 (concurrent_idempotent_requests)", {
+          retryable: true,
+          retryAfterSeconds: 5,
+          status: 409
+        });
+      }
+      throw httpError("Resend", response, name);
+    }
+  };
+}
+
+// src/destinations/google-auth.ts
+var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
+var SHEETS_SCOPE = "https://www.googleapis.com/auth/spreadsheets";
+function pemToPkcs8(pem) {
+  const text = pem.replace(/\\n/g, "\n");
+  if (/-----BEGIN RSA PRIVATE KEY-----/.test(text)) {
+    throw new DeliveryError("The Google private key is PKCS#1; convert it to PKCS#8 (BEGIN PRIVATE KEY)");
+  }
+  const body = text.replace(/-----(BEGIN|END) PRIVATE KEY-----/g, "").replace(/\s+/g, "");
+  return fromBase64(body);
+}
+async function signJwt(claims, privateKeyPem) {
+  let key;
+  try {
+    key = await crypto.subtle.importKey(
+      "pkcs8",
+      pemToPkcs8(privateKeyPem),
+      { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" },
+      false,
+      ["sign"]
+    );
+  } catch (error) {
+    if (error instanceof DeliveryError) throw error;
+    throw new DeliveryError("The Google private key is not a valid PKCS#8 RSA key");
+  }
+  const unsigned = `${base64url(JSON.stringify({ alg: "RS256", typ: "JWT" }))}.${base64url(JSON.stringify(claims))}`;
+  const signature = await crypto.subtle.sign("RSASSA-PKCS1-v1_5", key, new TextEncoder().encode(unsigned));
+  return `${unsigned}.${base64url(new Uint8Array(signature))}`;
+}
+var cache = /* @__PURE__ */ new Map();
+function clearGoogleTokenCache() {
+  cache.clear();
+}
+async function googleAccessToken(account, options = {}) {
+  const { clientEmail, privateKey } = account;
+  if (!clientEmail || !privateKey) throw new DeliveryError("The Google service account email or private key is not set");
+  const scope = options.scope ?? SHEETS_SCOPE;
+  const now = options.now?.() ?? Date.now();
+  const cacheKey = `${clientEmail} ${scope} ${await sha256Hex(privateKey.replace(/\\n/g, "\n").trim())}`;
+  const hit = cache.get(cacheKey);
+  if (hit && hit.expiresAt - 6e4 > now) return hit.token;
+  const iat = Math.floor(now / 1e3);
+  const assertion = await signJwt({ iss: clientEmail, scope, aud: GOOGLE_TOKEN_URL, iat, exp: iat + 3600 }, privateKey);
+  const response = await timedFetch(
+    options,
+    GOOGLE_TOKEN_URL,
+    {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer", assertion }).toString()
+    },
+    options.signal
+  );
+  if (!response.ok) {
+    discard(response);
+    throw httpError("Google token endpoint", response);
+  }
+  const body = await response.json();
+  if (typeof body.access_token !== "string") throw new DeliveryError("Google token endpoint returned no access token", { retryable: true });
+  const ttl = typeof body.expires_in === "number" ? body.expires_in * 1e3 : 36e5;
+  cache.set(cacheKey, { token: body.access_token, expiresAt: now + ttl });
+  return body.access_token;
+}
+
+// src/destinations/sheets.ts
+var SHEETS_API = "https://sheets.googleapis.com/v4/spreadsheets";
+var DEFAULT_SHEET_NAME = "Responses";
+var DEDUPE_WINDOW = 500;
+var HEADER_SCAN_ROWS = 100;
+var HEADER_WRITE_ATTEMPTS = 3;
+function mergeHeader(existing, keys, width = 0) {
+  const header = existing.map((h) => h == null ? "" : String(h));
+  while (header.length < width) header.push("");
+  while (header.length > width && header[header.length - 1] === "") header.pop();
+  for (const key of keys) if (key && !header.includes(key)) header.push(key);
+  return header;
+}
+function rowFor(header, row, escape = false) {
+  return header.map((h) => {
+    const cell = Object.prototype.hasOwnProperty.call(row, h) ? row[h] ?? "" : "";
+    return escape ? escapeFormula(cell) : cell;
+  });
+}
+function columnLetter(index) {
+  let n = index + 1;
+  let s = "";
+  while (n > 0) {
+    const r = (n - 1) % 26;
+    s = String.fromCharCode(65 + r) + s;
+    n = Math.floor((n - 1) / 26);
+  }
+  return s;
+}
+var quoteSheet = (name) => `'${name.replace(/'/g, "''")}'`;
+function readState(raw, spreadsheetId, sheetName) {
+  if (!raw) return null;
+  const header = raw["header"];
+  if (raw["spreadsheet_id"] !== spreadsheetId || raw["sheet_name"] !== sheetName || typeof raw["sheet_id"] !== "number" || !Array.isArray(header) || !header.every((h) => typeof h === "string") || !header.includes("id")) {
+    return null;
+  }
+  return {
+    spreadsheet_id: spreadsheetId,
+    sheet_name: sheetName,
+    sheet_id: raw["sheet_id"],
+    header,
+    columns: typeof raw["columns"] === "number" ? raw["columns"] : header.length,
+    last_row: typeof raw["last_row"] === "number" ? raw["last_row"] : 0
+  };
+}
+var StaleSheetError = class extends DeliveryError {
+};
+function configOf(config) {
+  const spreadsheetId = configString(config, "spreadsheetId", "spreadsheet_id");
+  if (!spreadsheetId) throw new DeliveryError("The sheet destination has no spreadsheetId");
+  if (!/^[A-Za-z0-9_-]{10,200}$/.test(spreadsheetId)) throw new DeliveryError("The sheet destination's spreadsheetId is invalid");
+  const sheetName = configString(config, "sheetName", "sheet_name") || DEFAULT_SHEET_NAME;
+  if (sheetName.length > 100) throw new DeliveryError("The sheet destination's sheetName is too long");
+  return { spreadsheetId, sheetName };
+}
+function sheetsDestination(options) {
+  async function run(items, config, deliveryOptions) {
+    if (!items.length) return { ok: true };
+    const { spreadsheetId, sheetName } = configOf(config);
+    const account = await resolveOption("The sheet destination's account", options.account, config);
+    const signal = deliveryOptions.signal;
+    const token = await googleAccessToken(account, { ...options, signal });
+    const base = `${SHEETS_API}/${encodeURIComponent(spreadsheetId)}`;
+    const escape = options.escapeFormulas === true;
+    const call = async (what, url, init = {}) => {
+      const response = await timedFetch(
+        options,
+        url,
+        { ...init, headers: { authorization: `Bearer ${token}`, "content-type": "application/json" } },
+        signal
+      );
+      if (!response.ok) {
+        discard(response);
+        if (what === "append" && (response.status === 400 || response.status === 404)) {
+          throw new StaleSheetError(`Google Sheets append answered ${response.status}`, { status: response.status });
+        }
+        if (response.status === 403 || response.status === 404) {
+          throw new DeliveryError(
+            `Google Sheets ${what} answered ${response.status}: is the sheet shared with ${account.clientEmail}?`,
+            { status: response.status }
+          );
+        }
+        throw httpError(`Google Sheets ${what}`, response);
+      }
+      return await response.json();
+    };
+    const batchUpdate = (what, requests) => call(what, `${base}:batchUpdate`, {
+      method: "POST",
+      body: JSON.stringify({ requests })
+    });
+    const range = (a1) => `${base}/values/${encodeURIComponent(`${quoteSheet(sheetName)}!${a1}`)}`;
+    const sensitive = options.sensitive ?? "include";
+    const columnKey = (key) => escape ? String(escapeFormula(key)) : key;
+    const rows = items.map((item) => {
+      const { row, columns } = responseRow(item.submission, item.definition, { sensitive });
+      const escaped = {};
+      for (const key of columns) escaped[columnKey(key)] = row[key];
+      return { row: escaped, columns: columns.map(columnKey) };
+    });
+    const keys = [...new Set(rows.flatMap((r) => r.columns))];
+    async function setUp(previous) {
+      const readTabs = async () => {
+        const meta = await call(
+          "read",
+          `${base}?fields=${encodeURIComponent("sheets.properties(sheetId,title,gridProperties.columnCount)")}`
+        );
+        return meta.sheets?.map((s) => s.properties).find((p) => p?.title === sheetName);
+      };
+      let sheet = await readTabs();
+      if (!sheet) {
+        try {
+          const added = await batchUpdate("add tab", [{ addSheet: { properties: { title: sheetName } } }]);
+          sheet = added.replies?.[0]?.addSheet?.properties ?? { sheetId: 0, title: sheetName };
+        } catch (error) {
+          if (!(error instanceof DeliveryError) || error.status !== 400) throw error;
+          sheet = await readTabs();
+          if (!sheet) throw error;
+        }
+      }
+      const readHeader = async () => {
+        const read = await call(
+          "read header",
+          `${range(`A1:ZZZ${HEADER_SCAN_ROWS}`)}?majorDimension=COLUMNS`
+        );
+        const used2 = read.values ?? [];
+        return { used: used2.length, existing: used2.map((column) => column[0] ?? "") };
+      };
+      let columns = sheet.gridProperties?.columnCount ?? 26;
+      let { used, existing } = await readHeader();
+      let header = [];
+      for (let attempt = 0; ; attempt++) {
+        header = mergeHeader(existing, keys, used);
+        if (!header.includes("id")) {
+          if (used) header.push("id");
+          else header.unshift("id");
+        }
+        const changed = header.length !== existing.length || header.some((h, i) => h !== String(existing[i] ?? ""));
+        if (!changed) break;
+        if (attempt >= HEADER_WRITE_ATTEMPTS) {
+          throw new DeliveryError("Google Sheets header kept changing while it was written", { retryable: true });
+        }
+        if (header.length > columns) {
+          await batchUpdate("add columns", [
+            { appendDimension: { sheetId: sheet.sheetId, dimension: "COLUMNS", length: header.length - columns } }
+          ]);
+          columns = header.length;
+        }
+        await call("write header", `${range("A1")}?valueInputOption=RAW`, {
+          method: "PUT",
+          body: JSON.stringify({ values: [header] })
+        });
+        if (existing.length === 0) {
+          await batchUpdate("freeze header", [
+            {
+              updateSheetProperties: {
+                properties: { sheetId: sheet.sheetId, gridProperties: { frozenRowCount: 1 } },
+                fields: "gridProperties.frozenRowCount"
+              }
+            }
+          ]);
+        }
+        ({ used, existing } = await readHeader());
+      }
+      return {
+        spreadsheet_id: spreadsheetId,
+        sheet_name: sheetName,
+        sheet_id: sheet.sheetId,
+        header,
+        columns,
+        last_row: previous?.last_row ?? 0
+      };
+    }
+    let skipped = [];
+    async function append(state2) {
+      let pending = items.map((item, i) => ({ id: item.submission.id, row: rows[i].row }));
+      if (deliveryOptions.redelivery) {
+        const column = columnLetter(state2.header.indexOf("id"));
+        const from = state2.last_row > 0 ? Math.max(2, state2.last_row - DEDUPE_WINDOW) : 2;
+        const ids = await call("read ids", range(`${column}${from}:${column}`));
+        const present = new Set((ids.values ?? []).map((r) => String(r?.[0] ?? "")));
+        skipped = pending.filter((p) => present.has(p.id)).map((p) => p.id);
+        pending = pending.filter((p) => !present.has(p.id));
+      }
+      if (!pending.length) return state2;
+      const result = await call(
+        "append",
+        `${range("A1")}:append?valueInputOption=RAW&insertDataOption=INSERT_ROWS`,
+        { method: "POST", body: JSON.stringify({ values: pending.map((p) => rowFor(state2.header, p.row, escape)) }) }
+      );
+      const last = /![A-Z]+\d+:[A-Z]+(\d+)$/.exec(result.updates?.updatedRange ?? "")?.[1];
+      return { ...state2, last_row: last ? Number(last) : state2.last_row + pending.length };
+    }
+    const cached = readState(deliveryOptions.state, spreadsheetId, sheetName);
+    const fresh = !cached || keys.some((k) => !cached.header.includes(k));
+    let state = fresh ? await setUp(cached) : cached;
+    try {
+      state = await append(state);
+    } catch (error) {
+      if (!(error instanceof StaleSheetError) || fresh) throw error;
+      state = await append(await setUp(cached));
+    }
+    return {
+      ok: true,
+      state,
+      ...skipped.length ? { skipped } : {}
+    };
+  }
+  const guarded = async (...args) => {
+    try {
+      return await run(...args);
+    } catch (error) {
+      return deliveryFailure(error);
+    }
+  };
+  return {
+    kind: "sheet",
+    deliver: (submission, definition, config, deliveryOptions = {}) => guarded([{ submission, definition, deliveryId: deliveryOptions.deliveryId }], config, deliveryOptions),
+    deliverBatch: (items, config, deliveryOptions = {}) => guarded(items, config, deliveryOptions)
+  };
+}
+
+// src/destinations/webhook.ts
+var MIN_SECRET_BYTES = 16;
+var STRICT_BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+function secretKey(secret) {
+  const encoded = secret.startsWith("whsec_") ? secret.slice(6) : secret;
+  if (!encoded || !STRICT_BASE64.test(encoded)) {
+    throw new DeliveryError(
+      "The webhook secret must be base64, optionally prefixed with whsec_ (Standard Webhooks libraries base64-decode it)"
+    );
+  }
+  const bytes = fromBase64(encoded);
+  if (bytes.length < MIN_SECRET_BYTES) throw new DeliveryError(`The webhook secret is shorter than ${MIN_SECRET_BYTES} bytes`);
+  return bytes;
+}
+async function hmacKey(secret, usage) {
+  return crypto.subtle.importKey("raw", secretKey(secret), { name: "HMAC", hash: "SHA-256" }, false, [usage]);
+}
+async function signWebhook(secret, id, timestamp, body) {
+  const key = await hmacKey(secret, "sign");
+  const mac = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${id}.${timestamp}.${body}`));
+  return `v1,${base64(new Uint8Array(mac))}`;
+}
+async function verifyWebhook(input) {
+  const header = (name) => {
+    if (typeof input.headers.get === "function") return input.headers.get(name) ?? "";
+    const raw = input.headers[name];
+    return Array.isArray(raw) ? raw[0] ?? "" : raw ?? "";
+  };
+  const id = header("webhook-id");
+  const timestamp = header("webhook-timestamp");
+  const signatures = header("webhook-signature");
+  if (!id || !/^\d{1,12}$/.test(timestamp) || !signatures) return false;
+  const now = Math.floor((input.now?.() ?? Date.now()) / 1e3);
+  if (Math.abs(now - Number(timestamp)) > (input.toleranceSeconds ?? 300)) return false;
+  let key;
+  try {
+    key = await hmacKey(input.secret, "verify");
+  } catch {
+    return false;
+  }
+  const data = new TextEncoder().encode(`${id}.${timestamp}.${input.body}`);
+  for (const part of signatures.split(" ")) {
+    const [version, value] = part.split(",", 2);
+    if (version !== "v1" || !value) continue;
+    let mac;
+    try {
+      mac = fromBase64(value);
+    } catch {
+      continue;
+    }
+    if (await crypto.subtle.verify("HMAC", key, mac, data)) return true;
+  }
+  return false;
+}
+var PRIVATE_HOSTNAME = /(^|\.)(localhost|local|internal|localdomain|home\.arpa)$/i;
+function isPrivateHost(hostname) {
+  const host = hostname.toLowerCase().replace(/\.$/, "");
+  if (PRIVATE_HOSTNAME.test(host)) return true;
+  const v4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(host);
+  if (v4) return isPrivateV4(v4.slice(1).map(Number));
+  if (host.startsWith("[") && host.endsWith("]")) {
+    const v6 = host.slice(1, -1);
+    if (v6 === "::" || v6 === "::1") return true;
+    const mapped = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(v6);
+    if (mapped) {
+      const hi = parseInt(mapped[1], 16);
+      const lo = parseInt(mapped[2], 16);
+      return isPrivateV4([hi >> 8, hi & 255, lo >> 8, lo & 255]);
+    }
+    const first = parseInt(v6.split(":")[0] || "0", 16);
+    return (first & 65024) === 64512 || (first & 65472) === 65152;
+  }
+  return false;
+}
+function isPrivateV4([a, b]) {
+  return a === 0 || a === 10 || a === 127 || a === 100 && b >= 64 && b <= 127 || a === 169 && b === 254 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168 || a === 198 && (b === 18 || b === 19) || a >= 224;
+}
+function checkWebhookUrl(raw, options = {}) {
+  if (!raw) throw new DeliveryError("The webhook destination has no url");
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw new DeliveryError("The webhook url is not a valid URL");
+  }
+  if (url.protocol !== "https:" && !(options.allowInsecureUrls && url.protocol === "http:")) {
+    throw new DeliveryError("The webhook url must use https");
+  }
+  if (url.username || url.password) throw new DeliveryError("The webhook url must not contain credentials");
+  if (!options.allowPrivateHosts && isPrivateHost(url.hostname)) {
+    throw new DeliveryError("The webhook url points at a private or local address");
+  }
+  return url;
+}
+function webhookPayload(submission, definition, options = {}) {
+  const sensitive = options.sensitive ?? "include";
+  const { row } = responseRow(submission, definition, { sensitive });
+  const answers = {};
+  for (const block of definition.blocks) {
+    if (block.kind !== "field") continue;
+    const field = block;
+    const value = own(submission.answers, field.id);
+    if (value === void 0 || withheld(definition, field)) continue;
+    if (isSensitive(field) && sensitive !== "include") {
+      if (sensitive === "mask") answers[field.id] = "[sensitive]";
+      continue;
+    }
+    answers[field.id] = value;
+  }
+  const inputs = visibleInputs(submission, definition, sensitive);
+  const pick = (source, allowed) => {
+    const out = {};
+    for (const [name, value] of Object.entries(source ?? {})) if (own(allowed, name) !== void 0) out[name] = value;
+    return out;
+  };
+  return {
+    type: options.type ?? "form.submitted",
+    timestamp: new Date(options.now ?? Date.now()).toISOString(),
+    data: {
+      form: { id: definition.id, title: definition.title },
+      submission: {
+        id: submission.id,
+        answers,
+        hidden: pick(submission.hidden, inputs),
+        context: pick(submission.context, inputs),
+        ending: submission.ending ?? null,
+        submittedAt: submission.submittedAt ?? null,
+        meta: { ...submission.meta },
+        tags: [...submission.tags ?? []]
+      },
+      row
+    }
+  };
+}
+function webhookDestination(options) {
+  return {
+    kind: "webhook",
+    async deliver(submission, definition, config, deliveryOptions = {}) {
+      try {
+        const url = checkWebhookUrl(configString(config, "url"), options);
+        const secret = await resolveOption("The webhook secret", options.secret, config);
+        if (!secret) throw new DeliveryError("The webhook secret is not set");
+        const now = options.now?.() ?? Date.now();
+        const id = deliveryOptions.deliveryId ?? submission.id;
+        const timestamp = Math.floor(now / 1e3);
+        const body = JSON.stringify(
+          webhookPayload(submission, definition, { sensitive: options.sensitive, type: options.type, now })
+        );
+        const response = await timedFetch(
+          options,
+          url.toString(),
+          {
+            method: "POST",
+            redirect: "manual",
+            headers: {
+              "content-type": "application/json",
+              "user-agent": "genesis-forms-webhook/1",
+              "webhook-id": id,
+              "webhook-timestamp": String(timestamp),
+              "webhook-signature": await signWebhook(secret, id, timestamp, body)
+            },
+            body
+          },
+          deliveryOptions.signal
+        );
+        discard(response);
+        if (response.status >= 200 && response.status < 300) return { ok: true };
+        if (response.status === 0 || response.status >= 300 && response.status < 400) {
+          throw new DeliveryError(`Webhook answered ${response.status || "a redirect"}: redirects are not followed`, {
+            ...response.status ? { status: response.status } : {}
+          });
+        }
+        throw httpError("Webhook", response);
+      } catch (error) {
+        return deliveryFailure(error);
+      }
+    }
+  };
+}
+
+export { DEDUPE_WINDOW, DEFAULT_SHEET_NAME, DeliveryError, GOOGLE_TOKEN_URL, HEADER_SCAN_ROWS, MAX_RECIPIENTS, REQUEST_TIMEOUT_MS, RESEND_API, SENSITIVE_MASK, SHEETS_API, SHEETS_SCOPE, answerCell, checkWebhookUrl, clearGoogleTokenCache, columnLetter, deliveryFailure, emailBody, emailDestination, escapeFormula, escapeHtml, googleAccessToken, headerSafe, httpError, idempotencyKey, isPrivateHost, isRetryableStatus, isSafeAddress, isSafeFrom, mergeHeader, renderEmail, resendProvider, responseRow, retryAfterSeconds, rowFor, sheetsDestination, signJwt, signWebhook, verifyWebhook, visibleInputs, webhookDestination, webhookPayload };
+//# sourceMappingURL=destinations.js.map
+//# sourceMappingURL=destinations.js.map