@usefillo/core 0.1.0

package/dist/index.js

@@ -0,0 +1,976 @@
+// src/types.ts
+var CONTENT_KINDS = ["heading", "paragraph", "divider"];
+function isField(block) {
+  return !CONTENT_KINDS.includes(block.kind);
+}
+
+// src/logic.ts
+function isAnswered(value) {
+  if (value === null || value === void 0) return false;
+  if (typeof value === "string") return value.trim() !== "";
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function evalCondition(cond, data) {
+  const value = data[cond.fieldId];
+  switch (cond.op) {
+    case "answered":
+      return isAnswered(value);
+    case "not_answered":
+      return !isAnswered(value);
+    case "eq":
+      if (Array.isArray(value)) return value.some((v) => v === cond.value);
+      return value === cond.value;
+    case "neq":
+      if (Array.isArray(value)) return !value.some((v) => v === cond.value);
+      return value !== cond.value;
+    case "contains":
+      if (typeof value === "string")
+        return value.toLowerCase().includes(String(cond.value ?? "").toLowerCase());
+      if (Array.isArray(value)) return value.some((v) => v === cond.value);
+      return false;
+    case "gt":
+      return typeof value === "number" && value > Number(cond.value);
+    case "lt":
+      return typeof value === "number" && value < Number(cond.value);
+  }
+}
+function isBlockVisible(block, data) {
+  if (!block.visibleIf || block.visibleIf.length === 0) return true;
+  return block.visibleIf.every((cond) => evalCondition(cond, data));
+}
+function visibleBlocks(page, data) {
+  return page.blocks.filter((b) => isBlockVisible(b, data));
+}
+function allFields(form) {
+  return form.pages.flatMap((p) => p.blocks.filter(isField));
+}
+function visibleFields(form, data) {
+  return form.pages.flatMap((p) => visibleBlocks(p, data).filter(isField));
+}
+
+// src/validation.ts
+import { z } from "zod";
+var fileValueSchema = z.object({
+  fileId: z.string().min(1),
+  name: z.string(),
+  size: z.number().nonnegative(),
+  mime: z.string(),
+  url: z.string().optional()
+});
+function isEmpty(value) {
+  if (value === null || value === void 0) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "boolean") return value === false;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+function validateField(field, value) {
+  if (isEmpty(value)) {
+    return field.required ? "This field is required" : null;
+  }
+  switch (field.kind) {
+    case "short_text":
+    case "long_text": {
+      if (typeof value !== "string") return "Expected text";
+      if (field.maxLength && value.length > field.maxLength)
+        return `Must be at most ${field.maxLength} characters`;
+      const hardCap = field.kind === "long_text" ? 2e4 : 2e3;
+      if (!field.maxLength && value.length > hardCap) return "Answer is too long";
+      return null;
+    }
+    case "email": {
+      const r = z.string().email().safeParse(value);
+      return r.success ? null : "Enter a valid email address";
+    }
+    case "url": {
+      if (typeof value !== "string") return "Enter a valid URL (including https://)";
+      try {
+        const url = new URL(value);
+        if (url.protocol !== "http:" && url.protocol !== "https:") {
+          return "Enter an http(s) URL";
+        }
+      } catch {
+        return "Enter a valid URL (including https://)";
+      }
+      return null;
+    }
+    case "phone": {
+      if (typeof value !== "string" || !/^[+\d][\d\s\-().]{4,}$/.test(value))
+        return "Enter a valid phone number";
+      return null;
+    }
+    case "number": {
+      const n = typeof value === "string" ? Number(value) : value;
+      if (typeof n !== "number" || Number.isNaN(n)) return "Enter a number";
+      if (field.min !== void 0 && n < field.min) return `Must be at least ${field.min}`;
+      if (field.max !== void 0 && n > field.max) return `Must be at most ${field.max}`;
+      return null;
+    }
+    case "select":
+    case "dropdown": {
+      if (typeof value !== "string" || value === "") return "Pick an option";
+      if (field.options.some((o) => o.id === value)) return null;
+      if (field.allowOther && value.length <= 500) return null;
+      return "Pick a valid option";
+    }
+    case "multi_select": {
+      if (!Array.isArray(value)) return "Pick at least one option";
+      const ids = new Set(field.options.map((o) => o.id));
+      const arr = value;
+      let others = 0;
+      for (const v of arr) {
+        if (ids.has(v)) continue;
+        if (field.allowOther !== true || typeof v !== "string" || v.length === 0 || v.length > 500)
+          return "Pick valid options";
+        if (++others > 1) return "Only one 'Other' answer is allowed";
+      }
+      return null;
+    }
+    case "checkbox": {
+      return typeof value === "boolean" ? null : "Invalid value";
+    }
+    case "rating": {
+      const max = field.max ?? 5;
+      const n = typeof value === "string" ? Number(value) : value;
+      if (typeof n !== "number" || !Number.isInteger(n) || n < 1 || n > max)
+        return `Pick a rating between 1 and ${max}`;
+      return null;
+    }
+    case "linear_scale": {
+      const min = field.min ?? 1;
+      const max = field.max ?? 10;
+      const n = typeof value === "string" ? Number(value) : value;
+      if (typeof n !== "number" || !Number.isInteger(n) || n < min || n > max)
+        return `Pick a value between ${min} and ${max}`;
+      return null;
+    }
+    case "ranking": {
+      if (!Array.isArray(value)) return "Drag the options into order";
+      const ids = field.options.map((o) => o.id).sort();
+      const got = [...value].sort();
+      if (ids.length !== got.length || ids.some((id, i) => id !== got[i]))
+        return "Rank every option";
+      return null;
+    }
+    case "matrix": {
+      if (typeof value !== "object" || value === null || Array.isArray(value))
+        return "Answer the grid";
+      const answers = value;
+      const columnIds = new Set(field.columns.map((c) => c.id));
+      const rowIds = new Set(field.rows.map((r) => r.id));
+      for (const [rowId, columnId] of Object.entries(answers)) {
+        if (!rowIds.has(rowId) || !columnIds.has(columnId)) return "Invalid grid answer";
+      }
+      if (field.required && Object.keys(answers).length < field.rows.length)
+        return "Answer every row";
+      return null;
+    }
+    case "signature": {
+      if (typeof value !== "string" || !value.startsWith("data:image/"))
+        return "Sign in the box";
+      return null;
+    }
+    case "hidden": {
+      return typeof value === "string" ? null : "Invalid value";
+    }
+    case "custom": {
+      return null;
+    }
+    case "date": {
+      if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(value))
+        return "Enter a valid date";
+      return null;
+    }
+    case "file_upload": {
+      const r = z.array(fileValueSchema).safeParse(value);
+      if (!r.success) return "Upload did not complete";
+      const maxFiles = field.maxFiles ?? 1;
+      if (r.data.length > maxFiles)
+        return `At most ${maxFiles} file${maxFiles === 1 ? "" : "s"}`;
+      return null;
+    }
+  }
+}
+function validateResponse(form, data) {
+  const fields = visibleFields(form, data);
+  const errors = {};
+  const cleaned = {};
+  for (const field of fields) {
+    const value = normalizeValue(field, data[field.id]);
+    const error = validateField(field, value);
+    if (error) {
+      errors[field.id] = error;
+    } else if (!isEmpty(value)) {
+      cleaned[field.id] = value;
+    }
+  }
+  return { ok: Object.keys(errors).length === 0, errors, data: cleaned };
+}
+function normalizeValue(field, value) {
+  if (value === void 0 || value === null) return value;
+  if (field.kind === "number" && typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    return Number.isNaN(n) ? value : n;
+  }
+  if (field.kind === "rating" && typeof value === "string") {
+    const n = Number(value);
+    return Number.isNaN(n) ? value : n;
+  }
+  if (typeof value === "string") return value.trim();
+  return value;
+}
+
+// src/schema-validation.ts
+import { z as z2 } from "zod";
+var FIELD_KINDS = [
+  "short_text",
+  "long_text",
+  "email",
+  "url",
+  "phone",
+  "number",
+  "select",
+  "multi_select",
+  "dropdown",
+  "checkbox",
+  "rating",
+  "linear_scale",
+  "ranking",
+  "matrix",
+  "signature",
+  "date",
+  "file_upload",
+  "hidden",
+  "custom"
+];
+var CONTENT_KINDS2 = ["heading", "paragraph", "divider"];
+var ALL_KINDS = [...FIELD_KINDS, ...CONTENT_KINDS2];
+var idSchema = z2.string().min(1).max(128);
+var optionSchema = z2.object({ id: idSchema, label: z2.string().max(1e3) }).passthrough();
+var blockSchema = z2.object({
+  id: idSchema,
+  kind: z2.enum(ALL_KINDS),
+  label: z2.string().max(2e3).optional(),
+  options: z2.array(optionSchema).max(200).optional(),
+  rows: z2.array(optionSchema).max(200).optional(),
+  columns: z2.array(optionSchema).max(200).optional()
+}).passthrough();
+var pageSchema = z2.object({
+  id: idSchema,
+  title: z2.string().max(500).optional(),
+  blocks: z2.array(blockSchema).max(500)
+});
+var schemaShape = z2.object({
+  version: z2.literal(1),
+  title: z2.string().max(2e3).optional().default(""),
+  description: z2.string().max(5e3).optional(),
+  pages: z2.array(pageSchema).min(1).max(50),
+  settings: z2.record(z2.unknown()).optional().default({})
+});
+function validateFormSchema(input) {
+  const parsed = schemaShape.safeParse(input);
+  if (!parsed.success) {
+    const first = parsed.error.issues[0];
+    const path = first?.path.join(".");
+    return { ok: false, error: first ? `${path ? `${path}: ` : ""}${first.message}` : "Invalid schema" };
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const page of parsed.data.pages) {
+    for (const block of page.blocks) {
+      if (seen.has(block.id)) {
+        return { ok: false, error: `Duplicate block id: ${block.id}` };
+      }
+      seen.add(block.id);
+    }
+  }
+  return { ok: true, schema: parsed.data };
+}
+
+// src/format.ts
+function assertNever(x) {
+  throw new Error(`Unhandled field kind: ${JSON.stringify(x)}`);
+}
+function formatAnswer(field, value) {
+  if (value === null || value === void 0 || value === "") return "";
+  switch (field.kind) {
+    case "file_upload":
+      return value.map((f) => f.name).join(", ");
+    case "select":
+    case "dropdown":
+      return field.options.find((o) => o.id === value)?.label ?? String(value);
+    case "multi_select":
+      return value.map((id) => field.options.find((o) => o.id === id)?.label ?? id).join(", ");
+    case "ranking":
+      return value.map((id, i) => `${i + 1}. ${field.options.find((o) => o.id === id)?.label ?? id}`).join(", ");
+    case "matrix": {
+      const answers = value;
+      return field.rows.filter((row) => answers[row.id]).map((row) => `${row.label}: ${field.columns.find((c) => c.id === answers[row.id])?.label ?? ""}`).join(", ");
+    }
+    case "signature":
+      return typeof value === "string" && value.startsWith("data:image/") ? "\u270D signed" : "";
+    case "checkbox":
+      return value === true ? "Yes" : "No";
+    case "rating":
+    case "linear_scale":
+    case "number":
+      return typeof value === "number" ? String(value) : String(value);
+    case "short_text":
+    case "long_text":
+    case "email":
+    case "url":
+    case "phone":
+    case "date":
+    case "hidden":
+      return String(value);
+    case "custom":
+      return typeof value === "object" ? JSON.stringify(value) : String(value);
+    default:
+      return assertNever(field);
+  }
+}
+
+// src/ids.ts
+var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+function createId(size = 12) {
+  const bytes = new Uint8Array(size);
+  if (typeof globalThis.crypto !== "undefined") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < size; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  let id = "";
+  for (let i = 0; i < size; i++) id += ALPHABET[bytes[i] % ALPHABET.length];
+  return id;
+}
+
+// src/fields.ts
+var BLOCK_KIND_META = {
+  short_text: { label: "Short text", hint: "Single line answer" },
+  long_text: { label: "Long text", hint: "Multi-line answer" },
+  email: { label: "Email", hint: "Validated email address" },
+  url: { label: "Link", hint: "Validated URL" },
+  phone: { label: "Phone", hint: "Phone number" },
+  number: { label: "Number", hint: "Numeric answer with min/max" },
+  select: { label: "Single choice", hint: "Radio buttons" },
+  multi_select: { label: "Multiple choice", hint: "Checkboxes" },
+  dropdown: { label: "Dropdown", hint: "Select from a list" },
+  checkbox: { label: "Yes / No", hint: "Single checkbox" },
+  rating: { label: "Rating", hint: "1\u20135 stars" },
+  linear_scale: { label: "Linear scale", hint: "1\u201310 with end labels" },
+  ranking: { label: "Ranking", hint: "Order options by preference" },
+  matrix: { label: "Matrix", hint: "Grid of rows \xD7 choices" },
+  signature: { label: "Signature", hint: "Draw to sign" },
+  date: { label: "Date", hint: "Date picker" },
+  file_upload: { label: "File upload", hint: "Huge files, resumable" },
+  hidden: { label: "Hidden field", hint: "Filled from the URL" },
+  custom: { label: "Custom", hint: "Your own component (code only)" },
+  heading: { label: "Heading", hint: "Section title" },
+  paragraph: { label: "Paragraph", hint: "Explanatory text" },
+  divider: { label: "Divider", hint: "Visual break" }
+};
+function createBlock(kind) {
+  const id = createId(8);
+  switch (kind) {
+    case "heading":
+      return { id, kind, text: "Section heading" };
+    case "paragraph":
+      return { id, kind, text: "Add some context for your respondents." };
+    case "divider":
+      return { id, kind };
+    case "select":
+    case "multi_select":
+    case "dropdown":
+      return {
+        id,
+        kind,
+        label: BLOCK_KIND_META[kind].label,
+        options: [
+          { id: createId(6), label: "Option 1" },
+          { id: createId(6), label: "Option 2" }
+        ]
+      };
+    case "rating":
+      return { id, kind, label: "How would you rate it?", max: 5 };
+    case "linear_scale":
+      return {
+        id,
+        kind,
+        label: "How likely are you to recommend us?",
+        min: 1,
+        max: 10,
+        minLabel: "Not likely",
+        maxLabel: "Very likely"
+      };
+    case "ranking":
+      return {
+        id,
+        kind,
+        label: "Rank these options",
+        options: [
+          { id: createId(6), label: "Option 1" },
+          { id: createId(6), label: "Option 2" },
+          { id: createId(6), label: "Option 3" }
+        ]
+      };
+    case "matrix":
+      return {
+        id,
+        kind,
+        label: "Rate each item",
+        rows: [
+          { id: createId(6), label: "Quality" },
+          { id: createId(6), label: "Price" }
+        ],
+        columns: [
+          { id: createId(6), label: "Poor" },
+          { id: createId(6), label: "Fair" },
+          { id: createId(6), label: "Good" }
+        ]
+      };
+    case "signature":
+      return { id, kind, label: "Sign here" };
+    case "hidden":
+      return { id, kind, label: "Hidden field" };
+    case "custom":
+      return { id, kind, label: "Custom field", component: "" };
+    case "file_upload":
+      return { id, kind, label: "Upload a file", maxFiles: 1, maxFileSizeMb: 500 };
+    case "checkbox":
+      return { id, kind, label: "I agree" };
+    default:
+      return { id, kind, label: BLOCK_KIND_META[kind].label };
+  }
+}
+function createEmptyForm(title = "Untitled form") {
+  return {
+    version: 1,
+    title,
+    pages: [{ id: createId(8), blocks: [] }],
+    settings: {
+      submitLabel: "Submit",
+      successTitle: "Thanks!",
+      successMessage: "Your response has been recorded.",
+      showProgress: true
+    }
+  };
+}
+
+// src/draft.ts
+var DRAFT_KINDS = [
+  "short_text",
+  "long_text",
+  "email",
+  "url",
+  "phone",
+  "number",
+  "select",
+  "multi_select",
+  "dropdown",
+  "checkbox",
+  "rating",
+  "linear_scale",
+  "ranking",
+  "matrix",
+  "date",
+  "file_upload",
+  "heading",
+  "paragraph",
+  "divider"
+];
+function str(value, max) {
+  return typeof value === "string" ? value.trim().slice(0, max) : "";
+}
+function clampInt(value, lo, hi, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  const n = Math.round(value);
+  return n < lo ? lo : n > hi ? hi : n;
+}
+function toOptions(labels, fallback) {
+  const cleaned = (Array.isArray(labels) ? labels : []).map((l) => str(l, 200)).filter(Boolean);
+  if (cleaned.length < 2) return fallback;
+  return cleaned.slice(0, 100).map((label) => ({ id: createId(6), label }));
+}
+function assembleBlock(spec) {
+  const kind = spec.kind;
+  if (!DRAFT_KINDS.includes(kind)) return null;
+  const block = createBlock(kind);
+  const label = str(spec.label, 500);
+  if (kind === "heading" || kind === "paragraph") {
+    block.text = str(spec.text, 2e3) || label || block.text;
+    return block;
+  }
+  if (kind === "divider") return block;
+  if (label) block.label = label;
+  if (spec.required) block.required = true;
+  if (spec.placeholder) block.placeholder = str(spec.placeholder, 200);
+  switch (kind) {
+    case "select":
+    case "multi_select":
+    case "dropdown":
+    case "ranking":
+      block.options = toOptions(spec.options, block.options);
+      break;
+    case "rating":
+      block.max = clampInt(spec.max, 3, 10, 5);
+      break;
+    case "linear_scale":
+      block.min = spec.min === 0 ? 0 : 1;
+      block.max = clampInt(spec.max, 2, 10, 10);
+      if (spec.minLabel) block.minLabel = str(spec.minLabel, 100);
+      if (spec.maxLabel) block.maxLabel = str(spec.maxLabel, 100);
+      break;
+    case "number":
+      if (typeof spec.min === "number") block.min = spec.min;
+      if (typeof spec.max === "number") block.max = spec.max;
+      break;
+    case "matrix":
+      block.rows = toOptions(spec.rows, block.rows);
+      block.columns = toOptions(spec.columns, block.columns);
+      break;
+  }
+  return block;
+}
+function assembleForm(spec) {
+  const form = createEmptyForm(str(spec.title, 200) || "Untitled form");
+  const description = str(spec.description, 1e3);
+  if (description) form.description = description;
+  const pages = (Array.isArray(spec.pages) ? spec.pages : []).slice(0, 20).map((page) => ({
+    id: createId(8),
+    title: str(page.title, 200) || void 0,
+    blocks: (Array.isArray(page.fields) ? page.fields : []).slice(0, 100).map(assembleBlock).filter((b) => b !== null)
+  })).filter((page) => page.blocks.length > 0);
+  if (pages.length > 0) form.pages = pages;
+  return form;
+}
+
+// src/client.ts
+var FilloError = class extends Error {
+  constructor(message, status) {
+    super(message);
+    this.status = status;
+    this.name = "FilloError";
+  }
+  status;
+};
+var MAX_CHUNK_RETRIES = 3;
+function makeReporter(totalBytes, options) {
+  return (uploadedBytes) => options.onProgress?.({
+    uploadedBytes,
+    totalBytes,
+    fraction: totalBytes === 0 ? 1 : uploadedBytes / totalBytes
+  });
+}
+var FilloClient = class {
+  /** Server origin this client targets, normalized (no trailing slash). */
+  baseUrl;
+  fetch;
+  /** Publishable workspace key, when configured. */
+  key;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.key = options.key;
+    this.fetch = options.fetch ?? ((...args) => globalThis.fetch(...args));
+  }
+  url(path) {
+    return `${this.baseUrl}/api/v1${path}`;
+  }
+  async json(path, init) {
+    const res = await this.fetch(this.url(path), {
+      ...init,
+      headers: { "Content-Type": "application/json", ...init?.headers }
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      throw new FilloError(body || `Request failed: ${res.status}`, res.status);
+    }
+    return await res.json();
+  }
+  /** Fetch a published form definition by id or slug. */
+  getForm(idOrSlug) {
+    return this.json(`/forms/${encodeURIComponent(idOrSlug)}`);
+  }
+  /**
+   * Upsert a code-defined form into the workspace identified by the client's
+   * publishable key. Returns the canonical form id used for submissions.
+   */
+  syncForm(handle, schema, theme) {
+    if (!this.key) {
+      return Promise.reject(
+        new FilloError("createClient needs a `key` (pk_\u2026) to sync code-defined forms", 401)
+      );
+    }
+    return this.json("/forms/sync", {
+      method: "POST",
+      body: JSON.stringify({ key: this.key, id: handle, schema, theme })
+    });
+  }
+  /** Submit a response. Returns per-field errors instead of throwing on validation failure. */
+  async submit(formId, data, meta) {
+    const res = await this.fetch(this.url(`/forms/${encodeURIComponent(formId)}/responses`), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ data, meta })
+    });
+    if (res.status === 422) {
+      const body2 = await res.json();
+      return { ok: false, errors: body2.errors };
+    }
+    if (!res.ok) {
+      throw new FilloError(`Submit failed: ${res.status}`, res.status);
+    }
+    const body = await res.json();
+    return { ok: true, responseId: body.id };
+  }
+  /**
+   * Open a respondent session for funnel analysis. Fire-and-forget: returns the
+   * session id, or null if tracking is unavailable (never blocks the form).
+   */
+  async startSession(formId, pageCount) {
+    try {
+      const res = await this.fetch(this.url(`/forms/${encodeURIComponent(formId)}/sessions`), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ pageCount })
+      });
+      if (!res.ok) return null;
+      const body = await res.json();
+      return body.id;
+    } catch {
+      return null;
+    }
+  }
+  /** Report progress on a session (furthest page reached, or completion). */
+  reportProgress(sessionId, data) {
+    try {
+      void this.fetch(this.url(`/sessions/${encodeURIComponent(sessionId)}/progress`), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(data),
+        keepalive: true
+      }).catch(() => {
+      });
+    } catch {
+    }
+  }
+  /** Current state of an upload session — used to resume after interruption. */
+  getUploadSession(sessionId) {
+    return this.json(`/uploads/${encodeURIComponent(sessionId)}`);
+  }
+  /**
+   * Resumable chunked upload. Creates (or resumes) a session, streams the file
+   * chunk by chunk with progress callbacks, and finalizes into a FileValue that
+   * goes into the response data. Survives flaky connections: each chunk is
+   * retried, and on repeated failure the true offset is re-queried so no byte
+   * is sent twice or skipped.
+   *
+   * Depending on the form's storage settings the server picks a transport:
+   * Fillo's own chunk protocol, or direct-to-Google-Drive resumable
+   * sessions — in which case the bytes go straight from this browser to the
+   * form owner's Drive and never touch the Fillo server.
+   */
+  async uploadFile(formId, file, options) {
+    const name = file instanceof File ? file.name : "upload.bin";
+    const mime = file.type || "application/octet-stream";
+    let session;
+    if (options.sessionId) {
+      session = await this.getUploadSession(options.sessionId);
+    } else {
+      session = await this.json(
+        `/forms/${encodeURIComponent(formId)}/uploads`,
+        {
+          method: "POST",
+          body: JSON.stringify({
+            fieldId: options.fieldId,
+            fileName: name,
+            size: file.size,
+            mime
+          })
+        }
+      );
+    }
+    if (session.transport?.type === "gdrive") {
+      await this.driveUploadLoop(session, session.transport.uploadUrl, file, options);
+    } else if (session.transport?.type === "s3-put") {
+      await this.s3PutUpload(session.transport.uploadUrl, file, options);
+    } else {
+      await this.formworkUploadLoop(session, file, options);
+    }
+    const done = await this.json(
+      `/uploads/${encodeURIComponent(session.id)}/complete`,
+      { method: "POST" }
+    );
+    if (!done.file) throw new FilloError("Upload completed but no file was returned");
+    return done.file;
+  }
+  async formworkUploadLoop(session, file, options) {
+    let offset = session.uploadedBytes;
+    const report = makeReporter(file.size, options);
+    report(offset);
+    while (offset < file.size) {
+      options.signal?.throwIfAborted();
+      const chunk = file.slice(offset, offset + session.chunkSize);
+      let attempt = 0;
+      for (; ; ) {
+        try {
+          const res = await this.fetch(
+            this.url(`/uploads/${encodeURIComponent(session.id)}/chunk`),
+            {
+              method: "PUT",
+              headers: {
+                "Content-Type": "application/octet-stream",
+                "X-Upload-Offset": String(offset)
+              },
+              body: chunk,
+              signal: options.signal
+            }
+          );
+          if (res.status === 409) {
+            const body2 = await res.json();
+            offset = body2.uploadedBytes;
+            break;
+          }
+          if (!res.ok) throw new FilloError(`Chunk failed: ${res.status}`, res.status);
+          const body = await res.json();
+          offset = body.uploadedBytes;
+          break;
+        } catch (err) {
+          if (options.signal?.aborted) throw err;
+          attempt += 1;
+          if (attempt >= MAX_CHUNK_RETRIES) throw err;
+          await new Promise((r) => setTimeout(r, 500 * 2 ** attempt));
+          const fresh = await this.getUploadSession(session.id);
+          offset = fresh.uploadedBytes;
+        }
+      }
+      report(offset);
+    }
+  }
+  /**
+   * Google Drive resumable protocol: PUT chunks with Content-Range; Drive
+   * answers 308 + a Range header while incomplete, 200/201 when done. On
+   * repeated failure we re-sync through our session endpoint (the server
+   * queries Drive for the authoritative offset).
+   */
+  async driveUploadLoop(session, uploadUrl, file, options) {
+    let offset = session.uploadedBytes;
+    const report = makeReporter(file.size, options);
+    report(offset);
+    while (offset < file.size) {
+      options.signal?.throwIfAborted();
+      const end = Math.min(offset + session.chunkSize, file.size);
+      const chunk = file.slice(offset, end);
+      let attempt = 0;
+      for (; ; ) {
+        try {
+          const res = await this.fetch(uploadUrl, {
+            method: "PUT",
+            headers: {
+              "Content-Range": `bytes ${offset}-${end - 1}/${file.size}`
+            },
+            body: chunk,
+            signal: options.signal
+          });
+          if (res.status === 308) {
+            const range = res.headers.get("Range") ?? res.headers.get("range");
+            const match = range?.match(/bytes=0-(\d+)/);
+            offset = match ? Number(match[1]) + 1 : 0;
+            break;
+          }
+          if (res.ok) {
+            offset = file.size;
+            break;
+          }
+          throw new FilloError(`Drive chunk failed: ${res.status}`, res.status);
+        } catch (err) {
+          if (options.signal?.aborted) throw err;
+          attempt += 1;
+          if (attempt >= MAX_CHUNK_RETRIES) throw err;
+          await new Promise((r) => setTimeout(r, 500 * 2 ** attempt));
+          const fresh = await this.getUploadSession(session.id);
+          offset = fresh.uploadedBytes;
+        }
+      }
+      report(offset);
+    }
+  }
+  /**
+   * S3-compatible single PUT to a presigned URL — bytes go straight to the
+   * bucket. Not resumable (S3 single PUT is atomic), but retried on failure.
+   */
+  async s3PutUpload(uploadUrl, file, options) {
+    const report = makeReporter(file.size, options);
+    report(0);
+    let attempt = 0;
+    for (; ; ) {
+      try {
+        const res = await this.fetch(uploadUrl, {
+          method: "PUT",
+          headers: { "Content-Type": file.type || "application/octet-stream" },
+          body: file,
+          signal: options.signal
+        });
+        if (!res.ok) throw new FilloError(`S3 upload failed: ${res.status}`, res.status);
+        report(file.size);
+        return;
+      } catch (err) {
+        if (options.signal?.aborted) throw err;
+        attempt += 1;
+        if (attempt >= MAX_CHUNK_RETRIES) throw err;
+        await new Promise((r) => setTimeout(r, 500 * 2 ** attempt));
+      }
+    }
+  }
+};
+function createClient(options) {
+  return new FilloClient(options);
+}
+
+// src/define.ts
+function defineForm(def) {
+  return {
+    id: def.id,
+    theme: def.theme,
+    schema: {
+      version: 1,
+      title: def.title ?? "",
+      description: def.description,
+      pages: def.pages,
+      settings: def.settings ?? {}
+    },
+    __formworkCodeForm: true
+  };
+}
+function isCodeForm(form) {
+  return typeof form === "object" && form !== null && "__formworkCodeForm" in form;
+}
+var syncCache = /* @__PURE__ */ new Map();
+function contentHash(input) {
+  let h = 5381;
+  for (let i = 0; i < input.length; i++) h = (h << 5) + h + input.charCodeAt(i) | 0;
+  return (h >>> 0).toString(36);
+}
+function syncCodeForm(client, form) {
+  const content = JSON.stringify(form.schema) + JSON.stringify(form.theme ?? null);
+  const key = `${client.baseUrl}:${client.key}:${form.id}:${contentHash(content)}`;
+  let pending = syncCache.get(key);
+  if (!pending) {
+    pending = client.syncForm(form.id, form.schema, form.theme ?? null);
+    syncCache.set(key, pending);
+    pending.catch(() => syncCache.delete(key));
+  }
+  return pending;
+}
+
+// src/prefill.ts
+function prefillFromParams(form, params) {
+  const data = {};
+  for (const field of allFields(form)) {
+    const raw = field.kind === "hidden" ? params[field.paramName ?? field.id] ?? field.defaultValue : params[field.id];
+    if (raw === void 0 || raw === "") continue;
+    switch (field.kind) {
+      case "number": {
+        const n = Number(raw);
+        if (Number.isNaN(n)) break;
+        if (field.min !== void 0 && n < field.min) break;
+        if (field.max !== void 0 && n > field.max) break;
+        data[field.id] = n;
+        break;
+      }
+      case "rating": {
+        const n = Number(raw);
+        if (Number.isInteger(n) && n >= 1 && n <= (field.max ?? 5)) data[field.id] = n;
+        break;
+      }
+      case "linear_scale": {
+        const n = Number(raw);
+        const min = field.min ?? 1;
+        const max = field.max ?? 10;
+        if (Number.isInteger(n) && n >= min && n <= max) data[field.id] = n;
+        break;
+      }
+      case "checkbox":
+        data[field.id] = raw === "true" || raw === "1" || raw === "yes";
+        break;
+      case "select":
+      case "dropdown": {
+        if (field.options.some((o) => o.id === raw)) data[field.id] = raw;
+        break;
+      }
+      case "multi_select": {
+        const ids = new Set(field.options.map((o) => o.id));
+        const picked = raw.split(",").filter((v) => ids.has(v));
+        if (picked.length > 0) data[field.id] = picked;
+        break;
+      }
+      case "file_upload":
+      case "ranking":
+      case "matrix":
+      case "signature":
+      case "custom":
+        break;
+      // not prefillable from a URL
+      default:
+        data[field.id] = raw;
+    }
+  }
+  return data;
+}
+
+// src/piping.ts
+var TOKEN = /\{\{\s*([\w-]+)\s*\}\}/g;
+function resolveText(text, data, form) {
+  if (!text.includes("{{")) return text;
+  const fields = allFields(form);
+  return text.replace(TOKEN, (_, id) => {
+    const field = fields.find((f) => f.id === id);
+    const value = data[id];
+    if (value === null || value === void 0 || value === "") return "";
+    const label = (optionId) => field && "options" in field ? field.options.find((o) => o.id === optionId)?.label ?? optionId : optionId;
+    if (Array.isArray(value)) return value.map((v) => label(String(v))).join(", ");
+    if (typeof value === "string") return label(value);
+    return String(value);
+  });
+}
+function pipeBlock(block, data, form) {
+  const pipe = (s) => s === void 0 ? s : resolveText(s, data, form);
+  switch (block.kind) {
+    case "heading":
+    case "paragraph":
+      return { ...block, text: resolveText(block.text, data, form) };
+    case "divider":
+      return block;
+    default:
+      return { ...block, label: resolveText(block.label, data, form), description: pipe(block.description) };
+  }
+}
+export {
+  BLOCK_KIND_META,
+  CONTENT_KINDS,
+  DRAFT_KINDS,
+  FilloClient,
+  FilloError,
+  allFields,
+  assembleForm,
+  createBlock,
+  createClient,
+  createEmptyForm,
+  createId,
+  defineForm,
+  formatAnswer,
+  isBlockVisible,
+  isCodeForm,
+  isField,
+  pipeBlock,
+  prefillFromParams,
+  resolveText,
+  syncCodeForm,
+  validateField,
+  validateFormSchema,
+  validateResponse,
+  visibleBlocks,
+  visibleFields
+};