@synap-core/sdk 1.1.0 → 1.3.0

package/dist/public.cjs

@@ -0,0 +1,627 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/public/index.ts
+var public_exports = {};
+__export(public_exports, {
+  SITE_MAX_LIMIT: () => SITE_MAX_LIMIT,
+  SITE_MAX_OFFSET: () => SITE_MAX_OFFSET,
+  SITE_MAX_SORT_KEYS: () => SITE_MAX_SORT_KEYS,
+  SITE_PUBLISHED_AT_SORT: () => SITE_PUBLISHED_AT_SORT,
+  UNAVAILABLE_TITLE: () => UNAVAILABLE_TITLE,
+  captchaSatisfied: () => captchaSatisfied,
+  createPublicClient: () => createPublicClient,
+  formatPublicValue: () => formatPublicValue,
+  initialValues: () => initialValues,
+  loadErrorMessage: () => loadErrorMessage,
+  pageQuery: () => pageQuery,
+  parseInlines: () => parseInlines,
+  parsePageParam: () => parsePageParam,
+  parseSafeMarkdown: () => parseSafeMarkdown,
+  safeHref: () => safeHref,
+  submitFailure: () => submitFailure,
+  submitWaitRemaining: () => submitWaitRemaining,
+  toCollectionPageModel: () => toCollectionPageModel,
+  toFieldModels: () => toFieldModels,
+  toRecordViewModel: () => toRecordViewModel,
+  toSharePageModel: () => toSharePageModel,
+  toSubmission: () => toSubmission,
+  validate: () => validate
+});
+module.exports = __toCommonJS(public_exports);
+
+// src/public/client.ts
+var SITE_MAX_OFFSET = 1e4;
+var SITE_MAX_LIMIT = 100;
+var SITE_MAX_SORT_KEYS = 3;
+var SITE_PUBLISHED_AT_SORT = "publishedAt";
+var HONEYPOT_KEY = "hp";
+var MAX_TICKET_WAIT_MS = 1e4;
+var MAX_INVALID_KEYS = 100;
+var MAX_KEY_LENGTH = 200;
+function waitMs(form) {
+  const n = form?.minSubmitMs;
+  return typeof n === "number" && Number.isFinite(n) && n > 0 ? Math.min(n, MAX_TICKET_WAIT_MS) : 0;
+}
+function parse422(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const b = body;
+  if (b.retry === true) return { retry: true };
+  if (!Array.isArray(b.invalid)) return null;
+  return {
+    fields: b.invalid.filter((k) => typeof k === "string" && k.length <= MAX_KEY_LENGTH).slice(0, MAX_INVALID_KEYS)
+  };
+}
+var DOORS_DISABLED_CODE = "public_doors_disabled";
+function isDoorsDisabledBody(body) {
+  return typeof body === "object" && body !== null && body.code === DOORS_DISABLED_CODE;
+}
+function classify(status, body) {
+  if (status === 404) return "not_found";
+  if (status === 429) return "rate_limited";
+  if (status === 403 && isDoorsDisabledBody(body)) return "doors_disabled";
+  return "server";
+}
+function classifySite(status, body) {
+  if (status === 400) return "bad_request";
+  if (status === 502 || status === 503 || status === 504) return "pod_unreachable";
+  return classify(status, body);
+}
+var MAX_RETRY_AFTER_SEC = 86400;
+function retryAfterSec(res) {
+  const raw = res.headers.get("retry-after")?.trim();
+  if (!raw) return void 0;
+  let sec;
+  if (/^\d+$/.test(raw)) {
+    sec = Number(raw);
+  } else {
+    const at = Date.parse(raw);
+    if (Number.isNaN(at)) return void 0;
+    sec = Math.ceil((at - Date.now()) / 1e3);
+  }
+  return Math.min(Math.max(0, sec), MAX_RETRY_AFTER_SEC);
+}
+function fail(error, res) {
+  const sec = error === "rate_limited" && res ? retryAfterSec(res) : void 0;
+  return sec === void 0 ? { ok: false, error } : { ok: false, error, retryAfterSec: sec };
+}
+async function readBody(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+function segment(raw) {
+  if (typeof raw !== "string" || raw === "" || raw === "." || raw === "..") return null;
+  return encodeURIComponent(raw);
+}
+var SORT_TERM = /^(-?)([A-Za-z][A-Za-z0-9_]{0,63})$/;
+function collectionSearch(q) {
+  const params = [];
+  if (q?.offset !== void 0) {
+    if (!Number.isInteger(q.offset) || q.offset < 0 || q.offset > SITE_MAX_OFFSET) return null;
+    params.push(`offset=${q.offset}`);
+  }
+  if (q?.limit !== void 0) {
+    if (!Number.isInteger(q.limit) || q.limit < 0) return null;
+    params.push(`limit=${Math.min(SITE_MAX_LIMIT, Math.max(1, q.limit))}`);
+  }
+  if (q?.sort !== void 0) {
+    const terms = typeof q.sort === "string" ? q.sort.split(",") : [...q.sort];
+    if (terms.length > SITE_MAX_SORT_KEYS) return null;
+    const keys = /* @__PURE__ */ new Set();
+    for (const term of terms) {
+      const m = SORT_TERM.exec(term);
+      if (!m || keys.has(m[2])) return null;
+      keys.add(m[2]);
+    }
+    if (terms.length > 0) params.push(`sort=${terms.join(",")}`);
+  }
+  return params.length > 0 ? `?${params.join("&")}` : "";
+}
+function createPublicClient(opts) {
+  const base = `${opts.podUrl.replace(/\/+$/, "")}/api/hub/public`;
+  const doFetch = () => {
+    const f = opts.fetch ?? globalThis.fetch;
+    if (!f) throw new Error("No fetch available: pass `fetch` to createPublicClient");
+    return f;
+  };
+  const url = (resource, token) => `${base}/${resource}/${encodeURIComponent(token)}`;
+  async function send(target, init) {
+    try {
+      return await doFetch()(target, {
+        method: init.method,
+        credentials: "omit",
+        headers: init.method === "POST" ? { "Content-Type": "application/json" } : init.ifNoneMatch ? { Accept: "application/json", "If-None-Match": init.ifNoneMatch } : { Accept: "application/json" },
+        ...init.body !== void 0 ? { body: init.body } : {}
+      });
+    } catch {
+      return null;
+    }
+  }
+  async function getJson(resource, token) {
+    const res = await send(url(resource, token), { method: "GET" });
+    if (!res) return { ok: false, error: "network" };
+    if (res.status !== 200) return fail(classify(res.status, await readBody(res)), res);
+    try {
+      return { ok: true, data: await res.json() };
+    } catch {
+      return { ok: false, error: "server" };
+    }
+  }
+  async function siteRead(path, ifNoneMatch) {
+    if (path === null) return { ok: false, error: "not_found" };
+    const revalidate = typeof ifNoneMatch === "string" && ifNoneMatch !== "" ? ifNoneMatch : void 0;
+    const res = await send(`${base}/sites/${path}`, { method: "GET", ifNoneMatch: revalidate });
+    if (!res) return { ok: false, error: "pod_unreachable" };
+    const etag = res.headers.get("etag");
+    if (res.status === 304 && revalidate !== void 0) {
+      return { ok: true, notModified: true, etag: etag ?? revalidate };
+    }
+    if (res.status !== 200) return fail(classifySite(res.status, await readBody(res)), res);
+    try {
+      return { ok: true, data: await res.json(), etag };
+    } catch {
+      return { ok: false, error: "server" };
+    }
+  }
+  function getSite(siteToken, opts2) {
+    return siteRead(segment(siteToken), opts2?.ifNoneMatch);
+  }
+  async function listCollection(siteToken, key, query) {
+    const token = segment(siteToken);
+    const k = segment(key);
+    if (token === null || k === null) return { ok: false, error: "not_found" };
+    const search = collectionSearch(query);
+    if (search === null) return { ok: false, error: "bad_request" };
+    return siteRead(`${token}/collections/${k}${search}`, query?.ifNoneMatch);
+  }
+  function getRecord(siteToken, key, slugOrPublicId, opts2) {
+    const parts = [segment(siteToken), segment(key), segment(slugOrPublicId)];
+    const path = parts.every((p) => p !== null) ? `${parts[0]}/collections/${parts[1]}/${parts[2]}` : null;
+    return siteRead(path, opts2?.ifNoneMatch);
+  }
+  const sleep = opts.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  async function postOnce(token, input, ticket) {
+    const body = {
+      fields: input.fields,
+      [HONEYPOT_KEY]: ""
+    };
+    if (ticket !== void 0) body.ticket = ticket;
+    if (input.captchaToken !== void 0) body.captchaToken = input.captchaToken;
+    if (input.idempotencyKey !== void 0) body.idempotencyKey = input.idempotencyKey;
+    const res = await send(url("forms", token), {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+    const done = (result) => ({ retry: false, result });
+    if (!res) return done({ ok: false, error: "network" });
+    if (res.status === 202) return done({ ok: true, received: true });
+    if (res.status === 422) {
+      let parsed = null;
+      try {
+        parsed = parse422(await res.json());
+      } catch {
+        parsed = null;
+      }
+      if (!parsed) return done({ ok: false, error: "server" });
+      if ("retry" in parsed) return { retry: true };
+      return done({ ok: false, error: "invalid", fields: parsed.fields });
+    }
+    if (res.status === 503) return done({ ok: false, error: "unavailable" });
+    if (res.status === 429) return done(fail("rate_limited", res));
+    if (res.status === 403 && isDoorsDisabledBody(await readBody(res))) {
+      return done({ ok: false, error: "doors_disabled" });
+    }
+    return done({ ok: false, error: "server" });
+  }
+  return {
+    readShare: (token) => getJson("shares", token),
+    getForm: (token) => getJson("forms", token),
+    async submitForm(token, input) {
+      const first = await postOnce(token, input, input.ticket);
+      if (!first.retry) return first.result;
+      const fresh = await getJson("forms", token);
+      if (!fresh.ok) return { ok: false, error: "retry" };
+      await sleep(waitMs(fresh.data));
+      const second = await postOnce(token, input, fresh.data.ticket);
+      return second.retry ? { ok: false, error: "retry" } : second.result;
+    },
+    getSite,
+    listCollection,
+    getRecord
+  };
+}
+
+// src/public/form-model.ts
+var INPUT_TYPE = {
+  text: "text",
+  richtext: "text",
+  email: "email",
+  phone: "tel",
+  url: "url",
+  number: "number",
+  boolean: "text",
+  date: "date",
+  enum: "text"
+};
+function controlFor(type) {
+  if (type === "richtext") return "textarea";
+  if (type === "enum") return "select";
+  if (type === "boolean") return "checkbox";
+  return "input";
+}
+function toFieldModels(form) {
+  return form.fields.map((f) => ({
+    key: f.key,
+    label: f.label,
+    help: f.help,
+    required: f.required === true,
+    control: controlFor(f.type),
+    inputType: INPUT_TYPE[f.type],
+    options: f.constraints?.enum ?? [],
+    maxLength: f.constraints?.maxLength,
+    min: f.constraints?.min,
+    max: f.constraints?.max
+  }));
+}
+function initialValues(fields) {
+  return Object.fromEntries(fields.map((f) => [f.key, f.control === "checkbox" ? false : ""]));
+}
+function validate(fields, values) {
+  const errors = {};
+  for (const f of fields) {
+    const v = values[f.key];
+    if (f.control === "checkbox") {
+      if (f.required && v !== true) errors[f.key] = "Required";
+      continue;
+    }
+    const s = typeof v === "string" ? v.trim() : "";
+    if (s === "") {
+      if (f.required) errors[f.key] = "Required";
+      continue;
+    }
+    if (f.maxLength !== void 0 && s.length > f.maxLength) {
+      errors[f.key] = `At most ${f.maxLength} characters`;
+    } else if (f.control === "select" && f.options.length > 0 && !f.options.includes(s)) {
+      errors[f.key] = "Pick one of the options";
+    } else if (f.inputType === "email" && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(s)) {
+      errors[f.key] = "Enter a valid email";
+    } else if (f.inputType === "number") {
+      const n = Number(s);
+      if (!Number.isFinite(n)) errors[f.key] = "Enter a number";
+      else if (f.min !== void 0 && n < f.min) errors[f.key] = `At least ${f.min}`;
+      else if (f.max !== void 0 && n > f.max) errors[f.key] = `At most ${f.max}`;
+    }
+  }
+  return errors;
+}
+function toSubmission(fields, values) {
+  const out = {};
+  for (const f of fields) {
+    const v = values[f.key];
+    if (f.control === "checkbox") {
+      out[f.key] = v === true;
+      continue;
+    }
+    const s = typeof v === "string" ? v.trim() : "";
+    if (s === "") continue;
+    out[f.key] = f.inputType === "number" ? Number(s) : s;
+  }
+  return out;
+}
+function captchaSatisfied(form, captchaToken) {
+  return !form.captcha.required || captchaToken !== null && captchaToken !== "";
+}
+function loadErrorMessage(error) {
+  switch (error) {
+    case "not_found":
+      return "This form isn't available.";
+    case "rate_limited":
+      return "Too many requests. Try again in a minute.";
+    case "doors_disabled":
+      return "This form isn't accepting responses right now.";
+    case "network":
+      return "We couldn't reach the server. Check your connection.";
+    case "server":
+      return "Something went wrong loading this form.";
+  }
+}
+function submitFailure(res, fields) {
+  const none = { fieldErrors: {}, retryable: false, refreshForm: false };
+  switch (res.error) {
+    case "invalid": {
+      const known = new Set(fields.map((f) => f.key));
+      const fieldErrors = Object.fromEntries(
+        res.fields.filter((k) => known.has(k)).map((k) => [k, "Check this answer."])
+      );
+      const n = Object.keys(fieldErrors).length;
+      return {
+        ...none,
+        fieldErrors,
+        message: n > 0 ? "Some answers need another look. Your message was not sent." : "We couldn't read that as a message. Reload the page and try again."
+      };
+    }
+    case "retry":
+      return {
+        ...none,
+        retryable: true,
+        refreshForm: true,
+        message: "That was sent a little too fast. Your message was not sent; try again."
+      };
+    case "unavailable":
+      return {
+        ...none,
+        retryable: true,
+        message: "We couldn't save your message just now. It was not sent; try again."
+      };
+    case "rate_limited":
+      return { ...none, message: "Too many attempts. Try again in a minute." };
+    case "doors_disabled":
+      return {
+        ...none,
+        message: "This form isn't accepting responses right now. Your message was not sent."
+      };
+    case "network":
+      return {
+        ...none,
+        retryable: true,
+        message: "We couldn't reach the server. Your message was not sent."
+      };
+    case "server":
+      return { ...none, message: "Something went wrong. Your message was not sent." };
+  }
+}
+function submitWaitRemaining(minSubmitMs, loadedAt, now) {
+  const wait = Number.isFinite(minSubmitMs) && minSubmitMs > 0 ? minSubmitMs : 0;
+  return Math.max(0, loadedAt + wait - now);
+}
+
+// src/public/safe-markdown.ts
+var SAFE_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "mailto:"]);
+function safeHref(raw) {
+  let url;
+  try {
+    url = new URL(raw.trim());
+  } catch {
+    return null;
+  }
+  return SAFE_PROTOCOLS.has(url.protocol) ? url.href : null;
+}
+var INLINE = /\*\*([^*]+)\*\*|\[([^\]]+)\]\(((?:[^()\s]|\([^()\s]*\))+)\)/g;
+function parseInlines(text) {
+  const out = [];
+  let last = 0;
+  for (const m of text.matchAll(INLINE)) {
+    const at = m.index ?? 0;
+    if (at > last) out.push({ type: "text", text: text.slice(last, at) });
+    if (m[1] !== void 0) {
+      out.push({ type: "strong", text: m[1] });
+    } else {
+      const href = safeHref(m[3]);
+      out.push(href ? { type: "link", text: m[2], href } : { type: "text", text: m[2] });
+    }
+    last = at + m[0].length;
+  }
+  if (last < text.length) out.push({ type: "text", text: text.slice(last) });
+  return out;
+}
+var HEADING = /^(#{1,6})\s+(.*)$/;
+var BULLET = /^\s*[-*]\s+(.*)$/;
+var ORDERED = /^\s*\d+[.)]\s+(.*)$/;
+var FENCE = /^\s*(```|~~~)/;
+function parseSafeMarkdown(source) {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const blocks = [];
+  let para = [];
+  let list = null;
+  const flush = () => {
+    if (para.length) blocks.push({ type: "paragraph", inlines: parseInlines(para.join(" ")) });
+    para = [];
+    if (list) blocks.push({ type: "list", ...list });
+    list = null;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fence = line.match(FENCE);
+    if (fence) {
+      flush();
+      const code = [];
+      i++;
+      while (i < lines.length && !lines[i].trimStart().startsWith(fence[1])) code.push(lines[i++]);
+      blocks.push({ type: "code", text: code.join("\n") });
+      continue;
+    }
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+    const heading = line.match(HEADING);
+    if (heading) {
+      flush();
+      const level = heading[1].length;
+      blocks.push({ type: "heading", level, inlines: parseInlines(heading[2]) });
+      continue;
+    }
+    const bullet = line.match(BULLET);
+    const ordered = bullet ? null : line.match(ORDERED);
+    if (bullet || ordered) {
+      const isOrdered = ordered !== null;
+      if (para.length || list && list.ordered !== isOrdered) flush();
+      if (!list) list = { ordered: isOrdered, items: [] };
+      list.items.push(parseInlines((bullet ?? ordered)[1]));
+      continue;
+    }
+    if (list) flush();
+    para.push(line.trim());
+  }
+  flush();
+  return blocks;
+}
+
+// src/public/site-model.ts
+var GROUPING = { useGrouping: "min2" };
+var ISO_DATE = /^(\d{4})-(\d{2})-(\d{2})$/;
+var ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d{1,9})?)?(Z|[+-]\d{2}:\d{2})$/;
+function isCalendarDay(s) {
+  const m = ISO_DATE.exec(s);
+  if (!m) return false;
+  const d = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])));
+  return d.toISOString().slice(0, 10) === s;
+}
+function formatPublicValue(value, opts = {}) {
+  const locale = opts.locale ?? "en";
+  if (typeof value === "boolean") return value ? opts.labels?.yes ?? "Yes" : opts.labels?.no ?? "No";
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? new Intl.NumberFormat(locale, GROUPING).format(value) : String(value);
+  }
+  if (isCalendarDay(value)) {
+    return new Intl.DateTimeFormat(locale, { dateStyle: "medium", timeZone: "UTC" }).format(
+      /* @__PURE__ */ new Date(`${value}T00:00:00Z`)
+    );
+  }
+  if (ISO_DATE_TIME.test(value)) {
+    const at = new Date(value);
+    if (!Number.isNaN(at.getTime())) {
+      return new Intl.DateTimeFormat(locale, {
+        dateStyle: "medium",
+        timeStyle: "short",
+        timeZone: opts.timeZone ?? "UTC"
+      }).format(at);
+    }
+  }
+  return value;
+}
+var MAX_PAGE_PARAM = 1e6;
+function parsePageParam(raw) {
+  if (raw === void 0 || raw === null || raw === "") return 1;
+  if (Array.isArray(raw)) return null;
+  if (!/^[1-9]\d*$/.test(raw)) return null;
+  const n = Number(raw);
+  return n <= MAX_PAGE_PARAM ? n : null;
+}
+function pageQuery(page, pageSize) {
+  if (!Number.isInteger(page) || page < 1) return null;
+  const limit = Math.min(SITE_MAX_LIMIT, Math.max(1, Math.floor(pageSize) || 1));
+  const offset = (page - 1) * limit;
+  return offset <= SITE_MAX_OFFSET ? { offset, limit } : null;
+}
+function toCollectionPageModel(page, opts) {
+  const pageSize = Math.max(1, page.limit);
+  const current = Math.floor(Math.max(0, page.offset) / pageSize) + 1;
+  const reachable = Math.floor(SITE_MAX_OFFSET / pageSize) + 1;
+  const pageCount = Math.max(1, Math.min(Math.ceil(page.total / pageSize), reachable));
+  const param = opts.param ?? "page";
+  const sep = opts.basePath.includes("?") ? "&" : "?";
+  const link = (n) => ({
+    page: n,
+    href: n === 1 ? opts.basePath : `${opts.basePath}${sep}${param}=${n}`,
+    current: n === current
+  });
+  const window = Math.max(0, Math.floor(opts.window ?? 1));
+  const shown = /* @__PURE__ */ new Set([1, pageCount]);
+  for (let n = current - window; n <= current + window; n++) {
+    if (n >= 1 && n <= pageCount) shown.add(n);
+  }
+  const pages = [];
+  let last = 0;
+  for (const n of [...shown].sort((a, b) => a - b)) {
+    if (n - last === 2) pages.push({ kind: "page", ...link(n - 1) });
+    else if (n - last > 2) pages.push({ kind: "gap", key: `gap-${last}` });
+    pages.push({ kind: "page", ...link(n) });
+    last = n;
+  }
+  const count = page.items.length;
+  const from = count > 0 ? page.offset + 1 : 0;
+  return {
+    items: page.items,
+    total: page.total,
+    page: current,
+    pageCount,
+    pageSize,
+    from,
+    to: count > 0 ? page.offset + count : 0,
+    empty: page.total === 0,
+    outOfRange: page.total > 0 && count === 0,
+    prev: current > 1 ? link(Math.min(current - 1, pageCount)) : null,
+    next: current < pageCount ? link(current + 1) : null,
+    pages
+  };
+}
+function toRecordViewModel(record, opts = {}) {
+  return {
+    title: record.title ?? null,
+    publicId: record.publicId,
+    slug: record.slug,
+    properties: Object.entries(record.properties ?? {}).map(([key, value]) => ({
+      key,
+      value: formatPublicValue(value, opts)
+    })),
+    blocks: record.body ? parseSafeMarkdown(record.body.content) : [],
+    publishedOn: record.publishedOn
+  };
+}
+
+// src/public/share-model.ts
+var UNAVAILABLE_TITLE = "This link isn't available";
+function isRetryable(error) {
+  return error === "network" || error === "rate_limited" || error === "server";
+}
+function toSharePageModel(result, opts = {}) {
+  if (!result.ok) return { kind: "unavailable", retryable: isRetryable(result.error) };
+  const share = result.data;
+  return {
+    kind: "share",
+    title: share.title ?? null,
+    properties: Object.entries(share.properties ?? {}).map(([key, value]) => ({
+      key,
+      value: formatPublicValue(value, opts)
+    })),
+    blocks: share.body ? parseSafeMarkdown(share.body.content) : [],
+    publishedOn: share.publishedOn
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SITE_MAX_LIMIT,
+  SITE_MAX_OFFSET,
+  SITE_MAX_SORT_KEYS,
+  SITE_PUBLISHED_AT_SORT,
+  UNAVAILABLE_TITLE,
+  captchaSatisfied,
+  createPublicClient,
+  formatPublicValue,
+  initialValues,
+  loadErrorMessage,
+  pageQuery,
+  parseInlines,
+  parsePageParam,
+  parseSafeMarkdown,
+  safeHref,
+  submitFailure,
+  submitWaitRemaining,
+  toCollectionPageModel,
+  toFieldModels,
+  toRecordViewModel,
+  toSharePageModel,
+  toSubmission,
+  validate
+});
+//# sourceMappingURL=public.cjs.map