@picked/client 0.0.1-dev.1789541668638 → 0.0.1-next.1

package/dist/types/form/create-form.d.ts

@@ -1,153 +0,0 @@
-/** @file Creates form instances that wire field evaluation, validation, and submission. */
-import { type EventCallable, type Store } from 'effector';
-import type { Field, FieldValue } from '../entities/field/field';
-import type { ExperienceInstance } from '../entities/experience-instance/experience-instance';
-import type { ValidationError } from '../entities/response/response';
-import type { Picked } from '../picked';
-import { type ErrorCallback, type SubmitCallback, type SubmitEventWithCurrentTarget, type SuccessCallback } from './create-submit-pipeline';
-export type FormField = Field & {
-    value: FieldValue | undefined;
-    /** Validation error for this field, or undefined if valid. */
-    error: ValidationError | undefined;
-    touched: boolean;
-    /** HTML-safe attributes to spread onto an input element. */
-    props: {
-        id: string;
-        name: string;
-        key: string;
-        value: FieldValue | undefined;
-        type: 'text' | 'number' | 'checkbox';
-        required: boolean;
-        placeholder: string | undefined;
-        oninput: (e: Event) => void;
-        onchange: (e: Event) => void;
-        onblur: (e: Event) => void;
-    };
-};
-/**
- * Dependencies that framework wrappers inject into createForm.
- * Replaces Svelte's getPicked()/getExperience() context calls.
- */
-export interface CreateFormDeps {
-    client: Picked;
-    experienceInstance: ExperienceInstance;
-}
-/**
- * Return type for createForm().
- * Provides form handlers, reactive stores, and callback registration.
- */
-export interface FormInstance<TFieldKeys extends string = string> {
-    /** Form element props (bind to a form element). */
-    form: {
-        /** HTML-safe attributes to spread onto a form element. */
-        props: {
-            onsubmit: EventCallable<SubmitEventWithCurrentTarget>;
-        };
-        /** Flat list of all current validation errors — derived from fieldErrors. */
-        errors: Store<ValidationError[]>;
-        /** Reactive store indicating if form is currently submitting. */
-        submitting: Store<boolean>;
-        /** Register callbacks to transform/validate data before submission. Returns unsubscribe. */
-        onBeforeSubmit: (callback: SubmitCallback<TFieldKeys>) => () => void;
-        /** Register callbacks to run on successful form submission. Returns unsubscribe. */
-        onSuccess: (callback: SuccessCallback<TFieldKeys>) => () => void;
-        /** Register callbacks to run on form validation errors. Returns unsubscribe. */
-        onError: (callback: ErrorCallback) => () => void;
-    };
-    /** Reactive store of fields with current values, errors, touched state, and event handlers. */
-    fields: Store<FormField[]>;
-}
-/**
- * Extracts the current value from a form input event.
- *
- * @param {Event} e - The DOM event from an input, select, or textarea element.
- * @returns {FieldValue | undefined} The field value, or undefined if the event target is not a recognised form element.
- * @example
- * ```ts
- * input.addEventListener('input', (e) => {
- *   const value = getEventValue(e)
- * })
- * ```
- */
-export declare function getEventValue(e: Event): FieldValue | undefined;
-/**
- * Extracts the staged value for a field from a form event. For a multi-value
- * checkbox group, toggles the clicked option's value into or out of
- * `currentValue` rather than reading the DOM — under React-controlled
- * checkboxes, reconciliation reverts `el.checked` to match the prop before
- * the change event fires, so any DOM-based read returns the pre-toggle
- * state. For `<select multiple>`, reads `el.selectedOptions` (React does
- * not race the change event there). Falls back to {@link getEventValue}
- * for single-value fields and unrelated targets.
- *
- * For multi-checkbox events other than `change`: returns `undefined` for
- * `input` so the caller skips dispatch (both `input` and `change` fire on a
- * single click; only `change` should toggle, otherwise the toggle would run
- * twice and cancel out). Returns `currentValue` (coerced to an array) for
- * any non-change event so the caller can still dispatch — keeping
- * touched-tracking and required-validation on `blur` working.
- *
- * Not re-exported from the form barrel; intended for use by the form's own
- * field handlers and for direct unit testing.
- *
- * @param {Event} e - The DOM event from a form input.
- * @param {Field} field - The field whose handler received the event.
- * @param {FieldValue | undefined} currentValue - The field's currently staged or committed value.
- * @returns {FieldValue | undefined} The value to stage, or undefined if the caller should skip dispatch.
- * @example
- * ```ts
- * input.addEventListener('change', (e) => {
- *   const value = getStagedEventValue(e, field, field.value)
- * })
- * ```
- */
-export declare function getStagedEventValue(e: Event, field: Field, currentValue: FieldValue | undefined): FieldValue | undefined;
-/**
- * Builds a DOM event handler that derives the next staged value via
- * {@link getStagedEventValue} and dispatches the given event-callable when
- * the helper returns a defined value. Skips dispatch if the helper returns
- * undefined (e.g. `input` events on multi-select checkboxes, where dispatch
- * is owned by the change event to avoid double-toggling).
- *
- * Not re-exported from the form barrel; intended for use by `createForm`
- * and for direct unit testing.
- *
- * @param {Field} field - The field bound to the handler.
- * @param {FieldValue | undefined} value - The field's currently staged or committed value.
- * @param {EventCallable<{ fieldKey: string; value: FieldValue }>} dispatch - The event-callable to fire when the helper returns a value.
- * @returns {(e: Event) => void} The handler to attach to a DOM event.
- * @example
- * ```ts
- * const onChange = createFieldHandler(field, value, fieldChangeEvent)
- * ```
- */
-export declare function createFieldHandler(field: Field, value: FieldValue | undefined, dispatch: EventCallable<{
-    fieldKey: string;
-    value: FieldValue;
-}>): (e: Event) => void;
-/**
- * Creates a form instance tied to a set of field keys.
- * Handles field evaluation, form submission, data transformation,
- * validation, event bus tracking, and step navigation.
- *
- * Framework-agnostic — framework wrappers (Svelte, React) inject
- * client and experienceInstance via the deps parameter and handle
- * callback cleanup lifecycle.
- *
- * @param {CreateFormDeps} deps - Client and experience instance injected by the framework wrapper.
- * @param {string} formId - Unique identifier for this form instance.
- * @param {Store<string>} title - Reactive store holding the form/step title.
- * @param {Store<string[]>} fieldKeys - Reactive store of field keys that belong to this form.
- * @returns {FormInstance} A form instance with reactive field stores, submission handlers, and callback registration.
- * @example
- * ```ts
- * const form = createForm(
- *   { client, experienceInstance },
- *   'lead-capture',
- *   $title,
- *   $fieldKeys,
- * )
- * ```
- */
-export declare function createForm(deps: CreateFormDeps, formId: string, title: Store<string>, fieldKeys: Store<string[]>): FormInstance;
-//# sourceMappingURL=create-form.d.ts.map

package/dist/types/form/create-form.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-form.d.ts","sourceRoot":"","sources":["../../../src/form/create-form.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAC3F,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,KAAK,EAEX,MAAM,UAAU,CAAA;AACjB,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qDAAqD,CAAA;AAC7F,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAA;AACpE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAGvC,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,4BAA4B,EACjC,KAAK,eAAe,EACrB,MAAM,0BAA0B,CAAA;AAEjC,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG;IAC9B,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;IAC7B,8DAA8D;IAC9D,KAAK,EAAE,eAAe,GAAG,SAAS,CAAA;IAClC,OAAO,EAAE,OAAO,CAAA;IAChB,4DAA4D;IAC5D,KAAK,EAAE;QACL,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,GAAG,EAAE,MAAM,CAAA;QACX,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;QAC7B,IAAI,EAAE,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAA;QACpC,QAAQ,EAAE,OAAO,CAAA;QACjB,WAAW,EAAE,MAAM,GAAG,SAAS,CAAA;QAC/B,OAAO,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAA;QAC3B,QAAQ,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAA;QAC5B,MAAM,EAAE,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAAA;KAC3B,CAAA;CACF,CAAA;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,kBAAkB,EAAE,kBAAkB,CAAA;CACvC;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,UAAU,SAAS,MAAM,GAAG,MAAM;IAC9D,mDAAmD;IACnD,IAAI,EAAE;QACJ,0DAA0D;QAC1D,KAAK,EAAE;YACL,QAAQ,EAAE,aAAa,CAAC,4BAA4B,CAAC,CAAA;SACtD,CAAA;QACD,6EAA6E;QAC7E,MAAM,EAAE,KAAK,CAAC,eAAe,EAAE,CAAC,CAAA;QAChC,iEAAiE;QACjE,UAAU,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;QAC1B,4FAA4F;QAC5F,cAAc,EAAE,CAAC,QAAQ,EAAE,cAAc,CAAC,UAAU,CAAC,KAAK,MAAM,IAAI,CAAA;QACpE,oFAAoF;QACpF,SAAS,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC,UAAU,CAAC,KAAK,MAAM,IAAI,CAAA;QAChE,gFAAgF;QAChF,OAAO,EAAE,CAAC,QAAQ,EAAE,aAAa,KAAK,MAAM,IAAI,CAAA;KACjD,CAAA;IACD,+FAA+F;IAC/F,MAAM,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC,CAAA;CAC3B;AAED;;;;;;;;;;;GAWG;AAEH,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,GAAG,UAAU,GAAG,SAAS,CAW9D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,KAAK,EACR,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,UAAU,GAAG,SAAS,GACnC,UAAU,GAAG,SAAS,CAaxB;AAyCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,UAAU,GAAG,SAAS,EAC7B,QAAQ,EAAE,aAAa,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAAC,GAC/D,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI,CAOpB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,EACpB,SAAS,EAAE,KAAK,CAAC,MAAM,EAAE,CAAC,GACzB,YAAY,CAoKd"}

package/dist/types/form/create-submit-pipeline.d.ts

@@ -1,116 +0,0 @@
-/** @file Submit pipeline for form instances — manages lifecycle, validation, and navigation. */
-import { type Event, type EventCallable, type Store } from 'effector';
-import type { ExperienceInstance } from '../entities/experience-instance/experience-instance';
-import type { ExperienceStep } from '../entities/step/step';
-import type { Field } from '../entities/field/field';
-import type { ValidationError } from '../entities/response/response';
-import type { Picked } from '../picked';
-import type { FieldValueFor } from '../schema-registry';
-export type SubmitEventWithCurrentTarget = SubmitEvent & {
-    currentTarget: EventTarget & HTMLFormElement;
-};
-/**
- * Callback fired after a successful commit, receiving the committed `data` keyed by
- * the step's field ids.
- *
- * The `data` value type is a schema-typed *view* over runtime-`FieldValue` data — the
- * same soundness posture as `getField`/`getByFieldKey`. The registry narrows each field
- * id to its declared value type, but the values are not runtime-validated against it. The
- * default `TFieldIds = string` resolves to `Record<string, FieldValue>`, so untyped
- * consumers keep the broad value type.
- */
-export type SuccessCallback<TFieldIds extends string = string> = (options: {
-    data: {
-        [P in TFieldIds]: FieldValueFor<P>;
-    };
-    stopNavigation: EventCallable<void>;
-}) => void | Promise<void>;
-export type ErrorCallback = (errors: ValidationError[]) => void | Promise<void>;
-/**
- * Callback fired before commit, receiving the parsed `data` keyed by the step's field
- * ids and optionally returning a transformed copy.
- *
- * The `data` value type is a schema-typed *view* over runtime-`FieldValue` data — the
- * same soundness posture as `getField`/`getByFieldKey`. The registry narrows each field
- * id to its declared value type, but the values are not runtime-validated against it. The
- * default `TFieldIds = string` resolves to `Record<string, FieldValue>`, so untyped
- * consumers keep the broad value type.
- */
-export type SubmitCallback<TFieldIds extends string = string> = (data: {
-    [P in TFieldIds]: FieldValueFor<P>;
-}) => {
-    [P in TFieldIds]: FieldValueFor<P>;
-} | void | Promise<{
-    [P in TFieldIds]: FieldValueFor<P>;
-} | void>;
-/**
- * Latest-wins submit callback slots accepted by the framework adapters.
- *
- * Declared here so `@picked/react` and `@picked/svelte` share one shape rather
- * than each defining its own. Passing callbacks as options is the recommended
- * style in both adapters: the callbacks arrive as arguments, so there is no
- * registration lifecycle for a consumer to get wrong, and re-rendering with a new
- * inline function simply replaces the previous one.
- *
- * @example createForm(id, title, keys, { onSuccess: ({ data }) => track(data) })
- */
-export interface FormCallbackOptions<TFieldKeys extends string = string> {
-    onBeforeSubmit?: SubmitCallback<TFieldKeys>;
-    onSuccess?: SuccessCallback<TFieldKeys>;
-    onError?: ErrorCallback;
-}
-export interface SubmitPipelineConfig {
-    client: Picked;
-    experienceInstance: ExperienceInstance;
-    formId: string;
-    title: Store<string>;
-    stepStore: Store<ExperienceStep | null>;
-    fieldsStore: Store<Field[]>;
-    goToNextStep: EventCallable<void>;
-}
-export interface SubmitPipeline {
-    submitEvent: EventCallable<SubmitEventWithCurrentTarget>;
-    isFormSubmitting: Store<boolean>;
-    onBeforeSubmit: (callback: SubmitCallback) => () => void;
-    onSuccess: (callback: SuccessCallback) => () => void;
-    onError: (callback: ErrorCallback) => () => void;
-    /**
-     * Fired when a submit attempt starts — callers use this to clear validation state.
-     * Separating this from `submitEvent` keeps the pipeline decoupled from the
-     * validation module's internal stores.
-     */
-    submitStarted: Event<void>;
-    /**
-     * Fired when commit returns validation errors — callers write these to
-     * `fieldErrorsStore` in the validation module.
-     */
-    validationErrorsReceived: Event<ValidationError[]>;
-}
-/**
- * Creates the submit pipeline for a form instance.
- *
- * Manages the full lifecycle of a form submission, including emitting event bus
- * calls, running data-transform callbacks, committing responses, running
- * success/error callbacks, and navigating to the next step.
- *
- * Returns coordination events (`submitStarted`, `validationErrorsReceived`) that the
- * caller wires to the validation module to keep validation state in sync without
- * the pipeline needing direct access to validation stores.
- *
- * @param {SubmitPipelineConfig} config - The submit pipeline configuration.
- * @param {Picked} config.client - The Picked client instance.
- * @param {ExperienceInstance} config.experienceInstance - The experience instance.
- * @param {string} config.formId - The form identifier.
- * @param {Store<string>} config.title - Store containing the form title.
- * @param {Store<ExperienceStep | null>} config.stepStore - Store containing the current step.
- * @param {Store<Field[]>} config.fieldsStore - Store containing the form fields.
- * @param {EventCallable<void>} config.goToNextStep - Event to trigger navigation to the next step.
- * @returns {SubmitPipeline} The submit pipeline with events, stores, and callback registration.
- * @example
- * ```ts
- * const pipeline = createSubmitPipeline(config)
- * pipeline.onSuccess(({ data }) => console.log(data))
- * ```
- */
-export declare function createSubmitPipeline({ client, experienceInstance, formId, title, stepStore, fieldsStore, goToNextStep, }: SubmitPipelineConfig): SubmitPipeline;
-//# sourceMappingURL=create-submit-pipeline.d.ts.map

package/dist/types/form/create-submit-pipeline.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create-submit-pipeline.d.ts","sourceRoot":"","sources":["../../../src/form/create-submit-pipeline.ts"],"names":[],"mappings":"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"}

package/dist/types/form/get-step-fields.d.ts

@@ -1,19 +0,0 @@
-/** @file Step field evaluation — resolves field and option visibility conditions. */
-import type { Field } from '../entities/field/field';
-import type { Picked } from '../picked';
-import { evaluateRuleLogic } from '../utils/rules-logic';
-/**
- * Evaluates field and option conditions, returning only the fields that should be visible.
- *
- * @template T
- * @param {Picked} client - The Picked client instance for condition evaluation.
- * @param {T[]} fields - The fields to filter by their conditions.
- * @param {Parameters<typeof evaluateRuleLogic>[2]} [context] - Optional context object passed to the rule evaluator.
- * @returns {Promise<T[]>} The filtered array of visible fields with conditional options resolved.
- * @example
- * ```typescript
- * const visibleFields = await getStepFields(client, step.fields, { cartTotal: 50 })
- * ```
- */
-export declare function getStepFields<T extends Field>(client: Picked, fields: T[], context?: Parameters<typeof evaluateRuleLogic>[2]): Promise<T[]>;
-//# sourceMappingURL=get-step-fields.d.ts.map

package/dist/types/form/get-step-fields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-step-fields.d.ts","sourceRoot":"","sources":["../../../src/form/get-step-fields.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AA8CxD;;;;;;;;;;;;GAYG;AACH,wBAAsB,aAAa,CAAC,CAAC,SAAS,KAAK,EACjD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,CAAC,EAAE,EACX,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC,CAAC,CAAC,GAChD,OAAO,CAAC,CAAC,EAAE,CAAC,CAoDd"}

package/dist/types/form/index.d.ts

@@ -1,11 +0,0 @@
-/** @file Public surface of `@picked/client/form`. */
-export { buildResponsesFromFormData } from './build-responses';
-export { getStepFields } from './get-step-fields';
-export { createFieldEvaluator } from './create-field-evaluator';
-export { createFieldValidation } from './create-field-validation';
-export type { FieldValidation } from './create-field-validation';
-export { createSubmitPipeline } from './create-submit-pipeline';
-export type { SubmitPipelineConfig, SubmitPipeline, SubmitEventWithCurrentTarget, SuccessCallback, ErrorCallback, SubmitCallback, FormCallbackOptions, } from './create-submit-pipeline';
-export { createForm, getEventValue } from './create-form';
-export type { CreateFormDeps, FormField, FormInstance } from './create-form';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/form/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/form/index.ts"],"names":[],"mappings":"AAAA,qDAAqD;AACrD,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAA;AAC9D,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACjE,YAAY,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AAC/D,YAAY,EACV,oBAAoB,EACpB,cAAc,EACd,4BAA4B,EAC5B,eAAe,EACf,aAAa,EACb,cAAc,EACd,mBAAmB,GACpB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AACzD,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,eAAe,CAAA"}

package/dist/types/lifecycle/condition-selection.d.ts

@@ -1,146 +0,0 @@
-/**
- * @file Memoized condition evaluator plus a reactive condition-results store.
- *
- * The results store is keyed by a stable, key-order-independent hash of the rule, so the
- * server's selection (`serialize`) and the client's hydration share results without
- * re-evaluating. A cache hit reads synchronously (driving SSR render and the first
- * client paint); a miss evaluates asynchronously and writes the result back, which
- * propagates reactively to subscribers. Conditions that reference an action are exempt from the
- * cache: they re-evaluate on every call so the action's side effect runs each time.
- */
-import { type Store } from 'effector';
-import type { Condition } from '../entities/condition/condition';
-import type { LogicObject, LogicRule, LogicValue } from '../logic-engine';
-import type { Picked } from '../picked';
-/** A condition rule that may be json-logic, a raw logic value, or unset. */
-type ConditionRule = LogicRule | LogicValue | undefined;
-/**
- * Produces a stable, key-order-independent string hash of a logic rule for use as a cache key.
- *
- * Object keys are sorted recursively, arrays preserve their order, and `undefined` is
- * normalised to `null`. Equivalent rules with reordered keys hash identically; rules that
- * differ in any value or array order hash differently.
- *
- * @param {ConditionRule} rule - The rule to hash.
- * @returns {string} A deterministic string key for the rule.
- * @example
- * hashRule({ '==': [1, 1] }) // '{"==":[1,1]}'
- */
-export declare function hashRule(rule: ConditionRule): string;
-/**
- * Reactive store of memoized condition-evaluation results, keyed by rule hash.
- */
-export interface ConditionResults {
-    /** Reactive store mapping rule hashes to their boolean evaluation result. */
-    store: Store<Record<string, boolean>>;
-    /** Writes a single hash-to-result entry into the store. */
-    set: (payload: {
-        hash: string;
-        result: boolean;
-    }) => void;
-    /** Bulk-seeds the store from a snapshot of hash-to-result entries, such as the server snapshot. */
-    seed: (results: Record<string, boolean>) => void;
-    /** Synchronously reads the current result for a key, or `undefined` when absent. */
-    peek: (hash: string) => boolean | undefined;
-    /** Clears every stored result (for example between server `serialize` calls on a reused client). */
-    reset: () => void;
-}
-/**
- * Creates a reactive condition-results store keyed by rule hash, mirroring the entity-index
- * factory pattern.
- *
- * @returns {ConditionResults} A condition-results store with set, seed, peek, and reset.
- * @example
- * const results = createConditionResults()
- * results.set({ hash: 'h1', result: true })
- * results.peek('h1') // true
- */
-export declare function createConditionResults(): ConditionResults;
-/**
- * Determines whether a rule references an action anywhere in its tree.
- *
- * Actions are injected into the evaluation context under the `actions` namespace and invoked via
- * `{ invoke: [{ var: 'actions.<key>' }] }`. Because actions have side effects, a rule that
- * references one cannot be memoised: its result must be re-resolved on every evaluation so the
- * side effect re-runs.
- *
- * @param {unknown} value - The rule fragment to inspect.
- * @returns {boolean} True when the fragment references the `actions` namespace anywhere.
- * @example
- * ruleReferencesAction({ invoke: [{ var: 'actions.track' }] }) // true
- */
-export declare function ruleReferencesAction(value: unknown): boolean;
-/**
- * Extracts the keys of every composed condition reference (`{ var: 'conditions.<key>' }`) found
- * anywhere in a rule tree.
- *
- * @param {unknown} value - The rule fragment to inspect.
- * @returns {string[]} The referenced condition keys (duplicates possible; callers dedupe).
- * @example
- * extractConditionKeys({ invoke: [{ var: 'conditions.is-home' }] }) // ['is-home']
- */
-export declare function extractConditionKeys(value: unknown): string[];
-/**
- * Determines whether a rule references an action directly, or transitively through composed
- * condition references by walking into each referenced condition's logic. Rules that reach an action
- * must bypass the result cache so the action's side effect re-runs on every evaluation.
- *
- * @param {unknown} value - The rule fragment to inspect.
- * @param {Record<string, Condition>} conditionsByKey - All available conditions indexed by key.
- * @param {Set<string>} [visited] - Condition keys already inspected; guards against reference cycles.
- * @returns {boolean} True when an action is reachable directly or through a composed condition.
- * @example
- * ruleReferencesActionDeep({ invoke: [{ var: 'conditions.b' }] }, conditionsByKey)
- */
-export declare function ruleReferencesActionDeep(value: unknown, conditionsByKey: Record<string, Condition>, visited?: Set<string>): boolean;
-/**
- * Evaluates a condition rule with memoization against the client's `conditionResults` store.
- *
- * Every rule (including `undefined`/`null`, empty, and boolean gates) is hashed and its result
- * cached, so callers can read it synchronously via `conditionResults.peek(hashRule(rule))` (which
- * `<ExperienceSlot>` relies on for slot selection, such as an experience with no condition). A cache hit
- * returns the stored value; a miss resolves the gate (evaluating non-empty logic rules via
- * `evaluateRuleLogic`), writes the result back to the store (propagating reactively), and returns it.
- *
- * Rules that reference an action (a `var` under the `actions` namespace) are never read from or
- * written to the cache: actions have side effects that must re-run on every evaluation, so caching
- * their result would suppress those effects.
- *
- * @param {Picked} client - The Picked client providing the evaluation context and results store.
- * @param {ConditionRule} rule - The condition rule to evaluate.
- * @param {object} [options] - Optional evaluation options.
- * @param {LogicObject} [options.context] - Context overrides merged into the evaluation (e.g. URL location).
- * @returns {Promise<boolean>} Whether the condition resolves truthy.
- * @example
- * const active = await evaluateConditionMemo(client, { '==': [1, 1] })
- */
-export declare function evaluateConditionMemo(client: Picked, rule: ConditionRule, options?: {
-    context?: LogicObject;
-}): Promise<boolean>;
-/**
- * Determines whether an experience is active by AND-ing the optional client precondition, the
- * optional client condition, and the experience's own condition through the memoized evaluator.
- *
- * This is the DOM-free analogue of `shouldInitialiseFx` used for slot-based and server-side
- * selection: each unset gate is treated as passing.
- *
- * @param {Picked} client - The Picked client providing the evaluation context and results store.
- * @param {object} experience - The experience to test.
- * @param {LogicRule | LogicValue} [experience.condition] - The experience's decision logic.
- * @param {object} [options] - Optional gate inputs.
- * @param {LogicObject} [options.context] - Context overrides merged into every evaluation.
- * @param {LogicRule | LogicValue} [options.precondition] - The client-level precondition gate.
- * @param {LogicRule | LogicValue} [options.condition] - The client-level condition gate.
- * @returns {Promise<boolean>} Whether the experience is active for the given context.
- * @example
- * const active = await isExperienceActive(client, { condition: exp.condition }, { context })
- */
-export declare function isExperienceActive(client: Picked, experience: {
-    condition?: LogicRule | LogicValue;
-}, options?: {
-    context?: LogicObject;
-    precondition?: LogicRule | LogicValue;
-    condition?: LogicRule | LogicValue;
-}): Promise<boolean>;
-export {};
-//# sourceMappingURL=condition-selection.d.ts.map

package/dist/types/lifecycle/condition-selection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"condition-selection.d.ts","sourceRoot":"","sources":["../../../src/lifecycle/condition-selection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAA2B,KAAK,KAAK,EAAE,MAAM,UAAU,CAAA;AAE9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACzE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAOvC,4EAA4E;AAC5E,KAAK,aAAa,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAAA;AA6CvD;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,MAAM,CAEpD;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6EAA6E;IAC7E,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACrC,2DAA2D;IAC3D,GAAG,EAAE,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,KAAK,IAAI,CAAA;IACzD,mGAAmG;IACnG,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IAChD,oFAAoF;IACpF,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAAG,SAAS,CAAA;IAC3C,oGAAoG;IACpG,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAmFD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAEzD;AAoDD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAe5D;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAgB7D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EAC1C,OAAO,GAAE,GAAG,CAAC,MAAM,CAAa,GAC/B,OAAO,CAqBT;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,WAAW,CAAA;CAAE,GAClC,OAAO,CAAC,OAAO,CAAC,CAuBlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE;IAAE,SAAS,CAAC,EAAE,SAAS,GAAG,UAAU,CAAA;CAAE,EAClD,OAAO,CAAC,EAAE;IACR,OAAO,CAAC,EAAE,WAAW,CAAA;IACrB,YAAY,CAAC,EAAE,SAAS,GAAG,UAAU,CAAA;IACrC,SAAS,CAAC,EAAE,SAAS,GAAG,UAAU,CAAA;CACnC,GACA,OAAO,CAAC,OAAO,CAAC,CAYlB"}

package/dist/types/lifecycle/lifecycle.d.ts

@@ -1,48 +0,0 @@
-/** @file Lifecycle module — owns the SDK start chain as an effector event graph. */
-import { type Effect, type EventCallable, type StoreWritable } from 'effector';
-import type { Picked } from '../picked';
-import type { LogicRule } from '../logic-engine';
-/** Discrete stages of the SDK lifecycle. */
-export type LifecycleStage = 'idle' | 'starting' | 'ready' | 'failed';
-/** A logic-engine gate rule, a literal boolean override, or `undefined` to indicate no gate is configured. */
-type GateConfig = LogicRule | boolean | undefined;
-/** Public effector units exposed by the lifecycle module. */
-interface Lifecycle {
-    /** Public trigger — fires the start chain. `await allSettled(start, { scope })` resolves once the chain has fully settled. */
-    start: EventCallable<void>;
-    /** Reactive store of the readiness flag. */
-    readyStore: StoreWritable<boolean>;
-    /** Reactive store of the precondition-gate result (`undefined` until `start` is fired). */
-    preconditionPassedStore: StoreWritable<boolean | undefined>;
-    /** Reactive store of the condition-gate result (`undefined` until `start` is fired). */
-    conditionPassedStore: StoreWritable<boolean | undefined>;
-    /** Reactive store of the current lifecycle stage. */
-    lifecycleStageStore: StoreWritable<LifecycleStage>;
-    /** Event — registers a plugin onStart hook effect. */
-    registerPluginStartHook: EventCallable<Effect<void, void, Error>>;
-    /** Event — sets the precondition gate rule (called once during construction). */
-    setPrecondition: EventCallable<GateConfig>;
-    /** Event — sets the condition gate rule (called once during construction). */
-    setCondition: EventCallable<GateConfig>;
-}
-/**
- * Creates the lifecycle module for a Picked client. Owns the start chain as an effector
- * event graph: `start` triggers a fan-out of effects (plugin hooks, domInteractive)
- * whose `.done` events drive the next phases via `sample`.
- *
- * @param {object} params - Factory params.
- * @param {Picked} params.client - The Picked client instance.
- * @returns {Lifecycle} The lifecycle module exposing public events and read-only reactive stores.
- * @example
- * ```typescript
- * const lifecycle = createLifecycle({ client })
- * lifecycle.setPrecondition(myRule)
- * lifecycle.start()
- * await allSettled(lifecycle.start, { scope })
- * ```
- */
-export declare function createLifecycle(params: {
-    client: Picked;
-}): Lifecycle;
-export {};
-//# sourceMappingURL=lifecycle.d.ts.map

package/dist/types/lifecycle/lifecycle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycle.d.ts","sourceRoot":"","sources":["../../../src/lifecycle/lifecycle.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,OAAO,EAOL,KAAK,MAAM,EACX,KAAK,aAAa,EAElB,KAAK,aAAa,EACnB,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAMhD,4CAA4C;AAC5C,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAA;AAErE,8GAA8G;AAC9G,KAAK,UAAU,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAA;AAEjD,6DAA6D;AAC7D,UAAU,SAAS;IACjB,8HAA8H;IAC9H,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,CAAA;IAE1B,4CAA4C;IAC5C,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;IAClC,2FAA2F;IAC3F,uBAAuB,EAAE,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;IAC3D,wFAAwF;IACxF,oBAAoB,EAAE,aAAa,CAAC,OAAO,GAAG,SAAS,CAAC,CAAA;IACxD,qDAAqD;IACrD,mBAAmB,EAAE,aAAa,CAAC,cAAc,CAAC,CAAA;IAElD,sDAAsD;IACtD,uBAAuB,EAAE,aAAa,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,CAAC,CAAC,CAAA;IAEjE,iFAAiF;IACjF,eAAe,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAC1C,8EAA8E;IAC9E,YAAY,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CACxC;AAuOD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAErE"}

package/dist/types/lifecycle/rules-logic.d.ts

@@ -1,25 +0,0 @@
-/** @file Effector effect that evaluates a json-logic rule against the client's reactive state. */
-import { type Effect } from 'effector';
-import type { LogicObject, LogicRule } from '../logic-engine';
-import type { Picked } from '../picked';
-/** Parameters for `evaluateRuleLogicFx` — the rule to evaluate and an optional context override. */
-export interface EvaluateRuleLogicParams {
-    rule: LogicRule;
-    context?: LogicObject;
-}
-/**
- * Creates an effector effect that evaluates a json-logic rule against the client's reactive state. The effect uses `attach({ source })` so all reads are scope-aware and reactive — no `.getState()` calls.
- *
- * @param {object} params - Factory params.
- * @param {Picked} params.client - The Picked client instance whose stores back the evaluation context.
- * @returns {Effect<EvaluateRuleLogicParams, unknown, Error>} An effect that evaluates a rule and resolves to the result.
- * @example
- * ```typescript
- * const evaluateRuleLogicFx = createEvaluateRuleLogicFx({ client })
- * const result = await evaluateRuleLogicFx({ rule: someRule, context: { extra: 'data' } })
- * ```
- */
-export declare function createEvaluateRuleLogicFx(params: {
-    client: Picked;
-}): Effect<EvaluateRuleLogicParams, unknown, Error>;
-//# sourceMappingURL=rules-logic.d.ts.map

package/dist/types/lifecycle/rules-logic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"rules-logic.d.ts","sourceRoot":"","sources":["../../../src/lifecycle/rules-logic.ts"],"names":[],"mappings":"AAAA,kGAAkG;AAClG,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,UAAU,CAAA;AAG9C,OAAO,KAAK,EAAgB,WAAW,EAAE,SAAS,EAAc,MAAM,iBAAiB,CAAA;AAEvF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AAEvC,oGAAoG;AACpG,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,CAAC,EAAE,WAAW,CAAA;CACtB;AAyID;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE;IAChD,MAAM,EAAE,MAAM,CAAA;CACf,GAAG,MAAM,CAAC,uBAAuB,EAAE,OAAO,EAAE,KAAK,CAAC,CAElD"}

package/dist/types/lifecycle/state-snapshot.d.ts

@@ -1,38 +0,0 @@
-/** @file State snapshot store — derives an immutable `StateSnapshot` from the client's reactive entity stores via `combine`. */
-import { type Store } from 'effector';
-import type { Picked } from '../picked';
-import type { Field, FieldValue } from '../entities/field/field';
-/** Immutable snapshot of the current client state, suitable for passing to user-supplied predicates, actions, and rule evaluators. */
-export interface StateSnapshot {
-    client: Picked;
-    location?: Window['location'];
-    document?: Window['document'];
-    sessionStorage?: Window['sessionStorage'];
-    localStorage?: Window['localStorage'];
-    responses: {
-        fieldKey: string;
-        value: FieldValue | undefined;
-    }[];
-    fields: Field[];
-}
-/**
- * Creates a reactive store that always reflects the current client state — responses, fields, browser globals, and the client reference.
- *
- * Consumers reading the snapshot inside an effect should use `attach({ source: stateSnapshotStore })` rather than `.getState()` so reads remain scope-aware and reactive.
- *
- * @param {object} params - Factory params.
- * @param {Picked} params.client - The Picked client instance to derive the snapshot from.
- * @returns {Store<StateSnapshot>} A derived store of the current state snapshot.
- * @example
- * ```typescript
- * const stateSnapshotStore = createStateSnapshotStore({ client })
- * const evaluateFx = attach({
- *   source: stateSnapshotStore,
- *   effect: (snapshot, rule) => evaluate(snapshot, rule),
- * })
- * ```
- */
-export declare function createStateSnapshotStore(params: {
-    client: Picked;
-}): Store<StateSnapshot>;
-//# sourceMappingURL=state-snapshot.d.ts.map

package/dist/types/lifecycle/state-snapshot.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state-snapshot.d.ts","sourceRoot":"","sources":["../../../src/lifecycle/state-snapshot.ts"],"names":[],"mappings":"AAAA,gIAAgI;AAChI,OAAO,EAAW,KAAK,KAAK,EAAE,MAAM,UAAU,CAAA;AAE9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAA;AACvC,OAAO,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEhE,sIAAsI;AACtI,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC,CAAA;IAC7B,cAAc,CAAC,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAA;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC,cAAc,CAAC,CAAA;IACrC,SAAS,EAAE;QACT,QAAQ,EAAE,MAAM,CAAA;QAChB,KAAK,EAAE,UAAU,GAAG,SAAS,CAAA;KAC9B,EAAE,CAAA;IACH,MAAM,EAAE,KAAK,EAAE,CAAA;CAChB;AA4BD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,KAAK,CAAC,aAAa,CAAC,CAEzF"}

package/dist/types/plugins/dom-observer/index.d.ts

@@ -1,3 +0,0 @@
-/** @file Public entrypoint for the dom-observer plugin. */
-export { domObserverPlugin } from './plugin';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/plugins/dom-observer/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/dom-observer/index.ts"],"names":[],"mappings":"AAAA,2DAA2D;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA"}