@nodii/onboarding 0.0.1 → 0.1.0

package/dist/controller-BQb62D0N.d.ts

@@ -0,0 +1,177 @@
+import { b as ConsentDocument, a as AcceptanceLevel, c as ConsentPack } from './model-mnjAEtKe.js';
+
+/**
+ * Headless ConsentPack controller (D543 §2/§5).
+ *
+ * Framework-agnostic consent state for the signup flow's consent stage.
+ * Exposes, per document: { doc, accepted, gateSatisfied, evidence } and
+ * enforces the per-document ACCEPTANCE-LEVEL GATE (D543 §2):
+ *
+ *   - checkbox           — accept is enable-able immediately (basic clickwrap).
+ *   - scroll_then_accept — accept is DISABLED until the rendered doc is
+ *                          scrolled to the end (evidence.scrolled_to_end).
+ *   - open_then_accept   — accept is DISABLED until the doc is opened/viewed
+ *                          (evidence.opened).
+ *
+ * The gate is a UX guard (D543 §5: "Client evidence is UX-only; the server
+ * re-validates"). But the controller ENFORCES it locally so a UI cannot
+ * present an accept affordance the gate hasn't unlocked, and so a headless
+ * caller cannot assemble a payload that claims an unsatisfied gate.
+ *
+ * COMPLIANCE-CRITICAL (same discipline as the stepper's consent-fabrication
+ * fix): `accept(key)` is REFUSED when the gate is not yet satisfied, and
+ * `buildConsentPayload()` THROWS if ANY required doc is not accepted at its
+ * gate. The controller NEVER fabricates acceptance or evidence — it only
+ * records what the user genuinely did. `isComplete()` is true only when every
+ * REQUIRED doc is accepted with its gate satisfied.
+ *
+ * Same subscribe/mutate contract as the dynamic stepper so the default
+ * component layer renders it and tenants can build their own UI against the
+ * exported control surface (D543 §5 headless flexibility).
+ */
+
+/**
+ * Evidence for a document's gate. Only the field relevant to the doc's
+ * acceptanceLevel is ever set true — a checkbox doc carries no evidence.
+ * Mirrors the D543 §4 submit `evidence:{scrolled_to_end?, opened?}` — these
+ * two keys stay snake_case (the ONLY snake bits in the consent wire shape).
+ */
+interface ConsentEvidence {
+    scrolled_to_end?: boolean;
+    opened?: boolean;
+}
+/**
+ * Per-document view of the consent state — the framework-agnostic "row model"
+ * a consumer binds their own rendering to (TanStack-style). NO DOM here.
+ */
+interface ConsentDocState {
+    /** The document descriptor (from the spec's consentPack). */
+    doc: ConsentDocument;
+    /** Stable client-side key (docType | custom:<customKey>). */
+    key: string;
+    /** The document's acceptance level, surfaced for convenience. */
+    acceptanceLevel: AcceptanceLevel;
+    /** Whether the document is required, surfaced for convenience. */
+    required: boolean;
+    /**
+     * Whether the acceptance-level GATE is satisfied — i.e. accept is
+     * enable-able. checkbox ⇒ always true; scroll ⇒ scrolled-to-end;
+     * open ⇒ opened.
+     */
+    gateSatisfied: boolean;
+    /** Whether the user has genuinely accepted (only possible past the gate). */
+    accepted: boolean;
+    /** The evidence collected so far (drives gateSatisfied for gated levels). */
+    evidence: ConsentEvidence;
+    /**
+     * Scroll progress in [0,1] for a `scroll_then_accept` doc (0 for other
+     * levels). A consumer's scroll handler feeds this via reportScrollProgress;
+     * reaching ~1 flips gateSatisfied. Purely a UX-progress read (e.g. a
+     * progress bar); the gate itself keys on scrolledToEnd evidence.
+     */
+    scrollProgress: number;
+}
+interface ConsentState {
+    /** All documents in spec order. */
+    documents: ConsentDocState[];
+    /** True iff every REQUIRED doc is accepted with its gate satisfied. */
+    complete: boolean;
+}
+type ConsentStateListener = (state: ConsentState) => void;
+/**
+ * One element of the D543 §4 submit `consent.documents` array — CANONICAL
+ * camelCase (legalDocumentId, versionNo, accepted); `evidence` keys stay
+ * snake_case (scrolled_to_end / opened).
+ */
+interface ConsentSubmitDocument {
+    legalDocumentId: string;
+    versionNo: number;
+    accepted: true;
+    evidence: ConsentEvidence;
+}
+interface ConsentController {
+    getState(): ConsentState;
+    /** True iff there are no documents to consent to (stage is skippable). */
+    isEmpty(): boolean;
+    /** True iff every required doc is accepted with its gate satisfied. */
+    isComplete(): boolean;
+    /**
+     * Alias of isComplete() — TanStack-style ergonomic read: "can the consumer
+     * submit the consent step?" (all required docs accepted at their gate).
+     */
+    canSubmit(): boolean;
+    /**
+     * Whether the given document's gate is satisfied (accept is enable-able).
+     * Unknown key ⇒ false.
+     */
+    isGateSatisfied(key: string): boolean;
+    /**
+     * Report scroll progress in [0,1] for a `scroll_then_accept` doc — the
+     * consumer's OWN scroll handler feeds this (e.g. on its same-origin scroll
+     * container). Ratio ≥ SCROLL_END_THRESHOLD marks scrolled-to-end (opens the
+     * gate); otherwise it just updates scrollProgress for UX. Clamped to [0,1].
+     * No-op for other levels and unknown keys.
+     */
+    reportScrollProgress(key: string, ratio: number): void;
+    /**
+     * Mark a `scroll_then_accept` doc as scrolled to the end (evidence). No-op
+     * for other levels (their gate isn't scroll-driven) and unknown keys.
+     * Equivalent to reportScrollProgress(key, 1).
+     */
+    markScrolledToEnd(key: string): void;
+    /**
+     * Mark an `open_then_accept` doc as opened/viewed (evidence). No-op for
+     * other levels and unknown keys.
+     */
+    markOpened(key: string): void;
+    /**
+     * Set a document's accepted flag. Accepting is REFUSED (accepted stays
+     * false) when the gate is not satisfied — a UI cannot record acceptance a
+     * user could not legitimately give. Unaccepting is always allowed.
+     */
+    setAccepted(key: string, accepted: boolean): void;
+    /**
+     * Build the D543 §4 submit array from the ACTUAL consent state.
+     *
+     * @throws {Error} if any REQUIRED doc is not accepted with its gate
+     *   satisfied — never fabricates acceptance/evidence (compliance-critical).
+     *   Optional docs that were accepted ARE included; optional docs left
+     *   unaccepted are omitted.
+     */
+    buildConsentPayload(): ConsentSubmitDocument[];
+    /**
+     * Swap in a refetched consentPack after 409 consent_stale. For every doc
+     * whose (versionNo, contentHash) CHANGED, acceptance + evidence are
+     * RESET (re-acceptance required — NEVER auto-accept a changed doc, D543 §4
+     * / task §4). Unchanged docs keep their state. Returns the keys whose
+     * consent was reset so the UI can highlight what changed.
+     */
+    applyNewPack(pack: ConsentPack | undefined): string[];
+    subscribe(listener: ConsentStateListener): () => void;
+}
+/**
+ * Scroll ratio at/above which a `scroll_then_accept` doc counts as
+ * scrolled-to-end. Slightly below 1 so sub-pixel rounding on the consumer's
+ * scroll math (scrollTop+clientHeight vs scrollHeight) still opens the gate.
+ */
+declare const SCROLL_END_THRESHOLD = 0.99;
+/** checkbox docs have no gate; gated levels start unsatisfied. */
+declare function initialGateSatisfied(level: AcceptanceLevel): boolean;
+/**
+ * Create a headless consent controller for a spec's consentPack.
+ *
+ * @param pack the spec's `consentPack` (or undefined ⇒ an empty controller;
+ *   the stage is skipped and `isComplete()` / `isEmpty()` are true).
+ *
+ * @example
+ * ```ts
+ * const consent = createConsentController(spec.consentPack);
+ * consent.subscribe(render);
+ * consent.markScrolledToEnd("tos");   // scroll_then_accept gate
+ * consent.setAccepted("tos", true);   // now allowed
+ * const docs = consent.buildConsentPayload(); // throws if any required unmet
+ * ```
+ */
+declare function createConsentController(pack: ConsentPack | undefined): ConsentController;
+
+export { type ConsentController as C, SCROLL_END_THRESHOLD as S, type ConsentDocState as a, type ConsentEvidence as b, type ConsentState as c, type ConsentStateListener as d, type ConsentSubmitDocument as e, createConsentController as f, initialGateSatisfied as i };

package/dist/dynamic/index.d.ts

@@ -0,0 +1,235 @@
+import { z } from 'zod/v3';
+import { c as SpecStep, S as SpecField, T as TerminalStage, a as OnboardingSpec } from '../model-ESLSEbi0.js';
+import { c as ConsentState, C as ConsentController, e as ConsentSubmitDocument } from '../controller-BQb62D0N.js';
+export { a as ConsentDocState, b as ConsentEvidence, d as ConsentStateListener, S as SCROLL_END_THRESHOLD, f as createConsentController, i as initialGateSatisfied } from '../controller-BQb62D0N.js';
+import { FieldError } from '../form/index.js';
+import '../model-mnjAEtKe.js';
+import '../schema-BrXb9gnh.js';
+
+/**
+ * Spec → Zod validator derivation (D540 §3).
+ *
+ * Turns arbitrary SpecField descriptors from the served spec into Zod
+ * schemas for CLIENT-side UX validation. The server re-validates
+ * authoritatively (D540 §2) — client validation is a convenience layer,
+ * so the derivation is deliberately conservative:
+ *
+ *   - Known `type`s map to typed schemas (see FIELD TYPE MAP below).
+ *   - An UNKNOWN type falls back to z.string() (never blocks a field the
+ *     server knows how to validate).
+ *   - Known `validation` keys are applied (minLength, maxLength, min, max,
+ *     pattern, format:"email"). Unknown validation keys are IGNORED
+ *     client-side — the server enforces them.
+ *   - `required:false` fields accept undefined AND "" (an empty input is
+ *     "not provided").
+ *   - select/radio values must be one of `options`; multiselect values
+ *     must be a subset.
+ *
+ * FIELD TYPE MAP:
+ *   text | textarea | tel | (unknown) → string
+ *   email                             → string().email()
+ *   number                            → coerce.number (DOM inputs are strings)
+ *   checkbox | boolean                → boolean
+ *   select | radio                    → string ∈ options
+ *   multiselect                       → string[] ⊆ options
+ *   date                              → string, parseable as a date
+ */
+
+/** Extract the comparable value of an option entry ({value}, {key}, or scalar). */
+declare function optionValue(option: unknown): string;
+/**
+ * Derive the full Zod schema for one SpecField.
+ * Optional fields accept undefined and "" ("not provided" in a form UI).
+ * Required fields additionally reject "" for string-typed inputs.
+ */
+declare function deriveFieldSchema(field: SpecField): z.ZodTypeAny;
+/**
+ * Derive a STRICT Zod object schema for one step's fields — unknown answer
+ * keys within the step are rejected (mirrors the server's authoritative
+ * re-validation posture; a stale client must not silently carry fields the
+ * spec no longer defines).
+ */
+declare function deriveStepSchema(step: SpecStep): z.ZodObject<Record<string, z.ZodTypeAny>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+/**
+ * Derive the STRICT schema for the complete answers object across all
+ * steps (used at submit time and by the 409-stale re-validation).
+ */
+declare function deriveAnswersSchema(steps: SpecStep[]): z.ZodObject<Record<string, z.ZodTypeAny>, "strict", z.ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>;
+
+/**
+ * Headless dynamic signup stepper (D540 §1/§3).
+ *
+ * The steps are GENERATED from the served spec: fields bucket by `stage`
+ * server-side → the spec's forms.signup.steps array. More configured
+ * fields ⇒ more steps. The final `activation` stage carries the
+ * service-selection inputs feeding the existing terminal-stage guards.
+ *
+ * Framework-agnostic: same subscribe/mutate contract as the Phase-1
+ * contact-form state. The default component layer renders it; framework
+ * integrations can wrap it.
+ *
+ * 409 spec_stale flow (D540 reject-stale): the CALLER (widget/submit
+ * orchestration) refetches the spec on OnboardingSpecStaleError and calls
+ * `applyNewSpec(newSpec)`. The stepper re-validates every answer against
+ * the NEW derived schema, DROPS answers whose fields no longer exist,
+ * marks `specStale: true`, and repositions to the first step with errors —
+ * the user re-confirms; the SDK NEVER silently auto-resubmits.
+ */
+
+type StepperStatus = "editing" | "submitting" | "success" | "error";
+interface SignupConsent {
+    tosAccepted: boolean;
+    privacyAccepted: boolean;
+}
+interface SignupCredentials {
+    email: string;
+    displayName: string;
+    organisationName: string;
+    subdomain: string;
+}
+interface SignupStepperState {
+    /** Zero-based index of the current step. */
+    stepIndex: number;
+    stepCount: number;
+    currentStep: SpecStep | null;
+    /** Answers keyed by field key (only keys defined by the active spec). */
+    answers: Record<string, unknown>;
+    /** Derived from serviceSelection-flagged answers (see buildSubmitPayload). */
+    selectedServices: string[];
+    /** Validation errors for the CURRENT step (or full-form at submit). */
+    errors: FieldError[];
+    /** Credential/consent errors (submit-time). */
+    accountErrors: FieldError[];
+    consent: SignupConsent;
+    credentials: SignupCredentials;
+    status: StepperStatus;
+    serverError: string | null;
+    /** True after a 409-stale spec swap until the user re-validates. */
+    specStale: boolean;
+    /** The specVersion currently driving the form (echoed on submit). */
+    specVersion: string;
+    /** Set on success from the submit response. */
+    terminalStage: TerminalStage | null;
+    /**
+     * D543 ConsentPack state (per-document acceptance + gates). Empty
+     * (documents:[]) when the spec serves no consentPack — the consent stage is
+     * then skipped and does not gate the submit.
+     */
+    consentState: ConsentState;
+    /**
+     * True after a 409 consent_stale swap until the user re-accepts the changed
+     * docs. Distinct from specStale — a doc-version bump does not necessarily
+     * change the form fields, and the banner copy differs.
+     */
+    consentStale: boolean;
+    /** Keys of the consent docs whose acceptance was reset by the last swap. */
+    staleConsentKeys: string[];
+    /** Consent-stage errors (submit-time; e.g. a required doc not accepted). */
+    consentErrors: FieldError[];
+}
+type SignupStepperListener = (state: SignupStepperState) => void;
+interface SignupStepperControl {
+    getState(): SignupStepperState;
+    setAnswer(key: string, value: unknown): void;
+    setConsent(consent: Partial<SignupConsent>): void;
+    setCredentials(credentials: Partial<SignupCredentials>): void;
+    /**
+     * The headless ConsentPack controller (D543 §5). Exposed so the default
+     * component layer AND fully custom tenant UIs drive the SAME state: mark
+     * scroll/open evidence, set acceptance, read per-doc gate status. The
+     * stepper subscribes to it internally so consent mutations re-emit stepper
+     * state (consentState/consentStale) to the widget.
+     */
+    readonly consent: ConsentController;
+    /** Validate ONLY the current step. Returns true when clean. */
+    validateStep(): boolean;
+    /** Validate current step; advance when clean. Returns true if advanced. */
+    next(): boolean;
+    back(): void;
+    isFirstStep(): boolean;
+    isLastStep(): boolean;
+    /**
+     * Full-form validation: every step's answers + credentials + consent.
+     * Populates errors/accountErrors. Returns true when submittable.
+     */
+    validateAll(): boolean;
+    /**
+     * The submit payload body (minus botToken, which the transport attaches).
+     * Call ONLY after validateAll() returns true.
+     *
+     * D543 §4: `consent.documents` is the per-doc consent array built from the
+     * ACTUAL consent state (omitted when the spec serves no consentPack). The
+     * booleans stay as the derived convenience. THROWS if any required consent
+     * doc is not accepted at its gate (never fabricates acceptance).
+     */
+    buildSubmitPayload(): {
+        specVersion: string;
+        answers: Record<string, unknown>;
+        selectedServices?: string[];
+        consent: {
+            tosAccepted: true;
+            privacyAccepted: true;
+            documents?: ConsentSubmitDocument[];
+        };
+        credentials: {
+            email: string;
+            displayName?: string;
+        };
+        organisationName?: string;
+        subdomain: string;
+    };
+    /**
+     * Swap in a refetched spec after 409 spec_stale. Drops answers for
+     * removed fields, re-validates the rest, marks specStale, repositions
+     * to the first step with errors. ALSO swaps the consentPack (a spec bump
+     * may carry new doc versions) — changed docs require re-acceptance. NEVER
+     * auto-resubmits.
+     */
+    applyNewSpec(spec: OnboardingSpec): void;
+    /** Clear the specStale flag once the user has re-confirmed. */
+    acknowledgeSpecStale(): void;
+    /**
+     * Swap in the refetched spec's consentPack after 409 consent_stale (D543
+     * §4). Resets acceptance for docs whose version/hash changed (re-acceptance
+     * required — NEVER auto-accept a changed doc), marks consentStale, records
+     * which keys were reset. NEVER auto-resubmits.
+     */
+    applyNewConsentPack(spec: OnboardingSpec): void;
+    /** Clear the consentStale flag once the user has re-accepted. */
+    acknowledgeConsentStale(): void;
+    setSubmitting(): void;
+    setSuccess(terminalStage: TerminalStage): void;
+    setError(message: string): void;
+    /**
+     * Reset to the pristine initial state against the CURRENT spec: step 0,
+     * status "editing", answers/credentials/consent/errors cleared. This is
+     * the only transition back OUT of "success"/"error"; the widget's reset()
+     * relies on it (otherwise a post-success keystroke would re-emit
+     * status "success" and re-hide the form).
+     */
+    reset(): void;
+    subscribe(listener: SignupStepperListener): () => void;
+}
+/**
+ * Create a headless stepper for the spec's signup form.
+ *
+ * @example
+ * ```ts
+ * const spec = await fetchOnboardingSpec({ baseUrl, onboarder });
+ * const stepper = createSignupStepper(spec);
+ * stepper.subscribe(render);
+ * stepper.setAnswer("company_name", "ACME");
+ * if (stepper.next()) { ... }
+ * ```
+ */
+declare function createSignupStepper(spec: OnboardingSpec): SignupStepperControl;
+
+export { ConsentController, ConsentState, ConsentSubmitDocument, type SignupConsent, type SignupCredentials, type SignupStepperControl, type SignupStepperListener, type SignupStepperState, type StepperStatus, createSignupStepper, deriveAnswersSchema, deriveFieldSchema, deriveStepSchema, optionValue };

package/dist/dynamic/index.js

@@ -0,0 +1,6 @@
+import '../chunk-JFDQZ3AC.js';
+export { createSignupStepper, deriveAnswersSchema, deriveFieldSchema, deriveStepSchema, optionValue } from '../chunk-KQTS47FC.js';
+export { SCROLL_END_THRESHOLD, createConsentController, initialGateSatisfied } from '../chunk-AZE3NPSY.js';
+import '../chunk-U56GQITG.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/dynamic/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/errors-vJkye4a0.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Error taxonomy for the onboarding submit client.
+ *
+ * Maps HTTP status codes and server error bodies to typed errors:
+ *   403 bot_challenge_failed  → OnboardingBotChallengeError
+ *   409 spec_stale (SUBMIT)   → OnboardingSpecStaleError  (submit endpoint only,
+ *                               body { error:true, code:"spec_stale",
+ *                               currentSpecVersion })
+ *   409 (other / LEADS)       → OnboardingConflictError    (generic conflict)
+ *   429                       → OnboardingRateLimitError
+ *   5xx                       → OnboardingServerError (retryable)
+ *   network / timeout         → OnboardingNetworkError
+ */
+type OnboardingErrorKind = "bot_challenge_failed" | "spec_stale" | "spec_invalid" | "consent_stale" | "consent_incomplete" | "subdomain_taken" | "conflict" | "rate_limited" | "server_error" | "network_error" | "validation_error";
+declare class OnboardingError extends Error {
+    readonly kind: OnboardingErrorKind;
+    readonly statusCode: number | null;
+    constructor(kind: OnboardingErrorKind, message: string, statusCode?: number | null);
+}
+declare class OnboardingBotChallengeError extends OnboardingError {
+    constructor(message?: string);
+}
+/**
+ * A 409 that is NOT spec_stale. On the /leads path there is no spec_stale
+ * concept (the payload carries no specVersion); on /submit, a 409 that
+ * lacks `code:"spec_stale"` also lands here. Distinct from
+ * OnboardingSpecStaleError so headless consumers switching on `kind` get the
+ * correct diagnosis (a generic conflict, e.g. a D538 same-key concurrent
+ * race) rather than a "form has been updated, refresh" recovery message.
+ */
+declare class OnboardingConflictError extends OnboardingError {
+    constructor(statusCode?: number, message?: string);
+}
+declare class OnboardingSubdomainTakenError extends OnboardingError {
+    constructor();
+}
+declare class OnboardingRateLimitError extends OnboardingError {
+    readonly retryAfterSeconds: number | null;
+    constructor(retryAfterSeconds?: number | null);
+}
+/**
+ * A /submit 409 whose body carries `code:"spec_stale"` (D540 reject-stale).
+ * The PINNED body shape (confirmed against the crm intake) is exactly:
+ *   { error: true, code: "spec_stale", currentSpecVersion: string }
+ * The version is read ONLY from `currentSpecVersion` — no field hedging.
+ * Submit-endpoint only; /leads 409s are OnboardingConflictError.
+ */
+declare class OnboardingSpecStaleError extends OnboardingError {
+    readonly currentSpecVersion: string;
+    constructor(currentSpecVersion: string);
+}
+/**
+ * A /submit 409 whose body carries `code:"consent_stale"` (D543 §4 —
+ * SIBLING to spec_stale). Raised when a required legal document's live
+ * version/content_hash changed between spec-fetch and submit, so the echoed
+ * consent no longer matches the live version.
+ *
+ * PINNED body shape (D543 §4, mirroring spec_stale):
+ *   { error: true, code: "consent_stale", staleDocuments?: [...] }
+ * where each staleDocuments entry identifies a changed doc so the caller can
+ * tell the user WHICH docs changed. The caller refetches the spec and
+ * REQUIRES re-acceptance of the changed docs — the SDK NEVER auto-accepts a
+ * changed doc (D543 §4). Submit-endpoint only.
+ */
+interface StaleConsentDocument {
+    /** The server registry id of the changed doc (D543 §3 legal_documents.id). */
+    legalDocumentId?: string;
+    /** doc_type of the changed doc, when the server includes it. */
+    docType?: string;
+    /** The new live version_no, when the server includes it. */
+    currentVersionNo?: number;
+}
+declare class OnboardingConsentStaleError extends OnboardingError {
+    /**
+     * The documents the server reports as changed (may be empty when the
+     * server does not enumerate them — the caller then refetches + diffs).
+     */
+    readonly staleDocuments: StaleConsentDocument[];
+    constructor(staleDocuments?: StaleConsentDocument[]);
+}
+/**
+ * A /submit 400 whose body carries `code:"consent_incomplete"` (D543 §4).
+ * The server's authoritative re-validation found a required live document
+ * that was missing, not accepted, or whose evidence did not satisfy its
+ * acceptance_level gate. Distinct from a generic 422 so headless consumers
+ * switching on `kind` route the user back to the consent step specifically.
+ */
+declare class OnboardingConsentIncompleteError extends OnboardingError {
+    constructor(message?: string);
+}
+declare class OnboardingServerError extends OnboardingError {
+    constructor(statusCode: number, message?: string);
+}
+declare class OnboardingNetworkError extends OnboardingError {
+    constructor(cause?: unknown);
+}
+declare class OnboardingValidationError extends OnboardingError {
+    constructor(message: string);
+}
+/**
+ * The spec endpoint returned a body that does not conform to the LOCKED
+ * D540 §1 response shape. This is a server-side contract violation — the
+ * SDK refuses to render a form from a malformed spec (a half-parsed spec
+ * could silently drop required fields).
+ */
+declare class OnboardingSpecInvalidError extends OnboardingError {
+    constructor(detail: string);
+}
+
+export { OnboardingBotChallengeError as O, type StaleConsentDocument as S, OnboardingConflictError as a, OnboardingConsentIncompleteError as b, OnboardingConsentStaleError as c, OnboardingError as d, type OnboardingErrorKind as e, OnboardingNetworkError as f, OnboardingRateLimitError as g, OnboardingServerError as h, OnboardingSpecInvalidError as i, OnboardingSpecStaleError as j, OnboardingSubdomainTakenError as k, OnboardingValidationError as l };

package/dist/form/index.d.ts

@@ -0,0 +1,64 @@
+import { C as ContactFormValues } from '../schema-BrXb9gnh.js';
+export { L as LeadsWirePayload, c as contactFormSchema, l as leadsWireSchema, v as validateContactForm, a as validateLeadsPayload } from '../schema-BrXb9gnh.js';
+import 'zod/v3';
+
+/**
+ * Headless form state manager for the contact form.
+ *
+ * Designed to be framework-agnostic — callers supply a change callback
+ * and call the returned mutators. The widget layer uses this internally;
+ * framework integrations (React, Vue, etc.) can wrap it in their own hooks.
+ */
+
+interface FieldError {
+    path: string;
+    message: string;
+}
+type FormStatus = "idle" | "submitting" | "success" | "error";
+interface ContactFormState {
+    values: ContactFormValues;
+    /** Per-field validation errors from the last validate() call. */
+    errors: FieldError[];
+    /** Cross-field / server error message. */
+    serverError: string | null;
+    status: FormStatus;
+    /** True if values have been touched at least once. */
+    dirty: boolean;
+}
+type ContactFormStateListener = (state: ContactFormState) => void;
+interface ContactFormControl {
+    /** Current snapshot of form state. */
+    getState(): ContactFormState;
+    /** Update a single field value and re-validate if dirty. */
+    setValue<K extends keyof ContactFormValues>(field: K, value: ContactFormValues[K]): void;
+    /**
+     * Run full client-side validation. Returns true if valid.
+     * Also marks the form dirty so future setValue calls auto-validate.
+     */
+    validate(): boolean;
+    /** Mark the form as submitting. Called by the submit client. */
+    setSubmitting(): void;
+    /** Mark the form as successfully submitted. */
+    setSuccess(): void;
+    /** Set a server-side error (e.g. 429 rate limited). */
+    setError(message: string): void;
+    /** Reset to initial idle state. */
+    reset(): void;
+    /** Subscribe to state changes. Returns unsubscribe function. */
+    subscribe(listener: ContactFormStateListener): () => void;
+}
+/**
+ * Create a new headless contact form state controller.
+ *
+ * @example
+ * ```ts
+ * const form = createContactFormState();
+ * form.subscribe((state) => renderUI(state));
+ * form.setValue("name", "Alice");
+ * const valid = form.validate();
+ * if (valid) await submitContact(form.getState().values, botToken);
+ * ```
+ */
+declare function createContactFormState(): ContactFormControl;
+
+export { type ContactFormControl, type ContactFormState, type ContactFormStateListener, ContactFormValues, type FieldError, type FormStatus, createContactFormState };

package/dist/form/index.js

@@ -0,0 +1,5 @@
+import '../chunk-JFIONONR.js';
+export { createContactFormState } from '../chunk-U6AXKGYQ.js';
+export { contactFormSchema, leadsWireSchema, validateContactForm, validateLeadsPayload } from '../chunk-SIMLMQPT.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/form/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}