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

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"}

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

@@ -1,50 +0,0 @@
-import type { Plugin } from '../../entities/plugin/plugin';
-/**
- * Watches the document for `childList` mutations and reconciles experiences
- * whose declared target selectors match newly added DOM subtrees. Each
- * matching experience runs through its per-experience `shouldInitialiseFx`,
- * and on `true` is handed to its `initialiseFx(undefined)`.
- *
- * Scope: lazy-mounted target hosts that arrive after the initial bulk init
- * in `picked.ts`. Route-driven re-initialisation (decisionLogic depending
- * on `location.pathname`, lifecycle event re-fires, plugin start hooks)
- * is the responsibility of `singlePageAppPlugin`, which calls
- * `client.start()` on history events. Pair the two plugins to cover both.
- *
- * Pipeline:
- *  - Each experience's `configStore.watch()` pushes its trimmed selectors
- *    into a reactive `Store<Map<id, string[]>>`. Empty / whitespace-only
- *    selectors are filtered out.
- *  - A single `MutationObserver` collects `Element` instances from
- *    `childList.addedNodes` across one animation frame, then fires a
- *    single `mutationObserved` event carrying the collected elements.
- *  - `sample` filters registered experiences to those whose selectors
- *    match at least one added element via `el.matches` or
- *    `el.querySelector`. Malformed selectors are skipped per-experience
- *    without poisoning the rest of the batch. The matched array is
- *    routed straight into `reconcileMatchedFx` via `sample.target`.
- *  - `reconcileMatchedFx` invokes each experience's
- *    `shouldInitialiseFx`, and on `true` its `initialiseFx(undefined)`.
- *    `initialiseFx` is idempotent: tagged target elements are skipped
- *    on subsequent passes.
- *
- * Setup is deferred until `document.body` is parsed, so SDKs loaded from
- * `<head>` without `defer` (the standard Shopify-theme / GTM-template
- * pattern) still install once the body becomes available.
- *
- * No-ops outside browser environments and on partial-DOM runtimes that
- * lack `MutationObserver` or `requestAnimationFrame`. `MutationObserver`
- * does not cross shadow root or iframe boundaries, so experiences whose
- * target lives inside a shadow tree or a cross-origin frame are not
- * reconciled by this plugin.
- *
- * @returns {Plugin} The plugin.
- * @example
- * ```typescript
- * createClient({
- *   plugins: [domObserverPlugin()]
- * })
- * ```
- */
-export declare const domObserverPlugin: () => Plugin;
-//# sourceMappingURL=plugin.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../src/plugins/dom-observer/plugin.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AAK1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,iBAAiB,QAAO,MAiBpC,CAAA"}

package/dist/types/plugins/dynamic-experiences/hash.d.ts

@@ -1,105 +0,0 @@
-/** @file Deterministic, independent per-feature bucket allocation for A/B testing. */
-/**
- * FNV-1a 32-bit hash.
- * Deterministic, fast, well-distributed for short strings.
- *
- * @param {string} input - String to hash.
- * @returns {number} Unsigned 32-bit hash.
- * @example
- * ```typescript
- * fnv1a32('sess_1:winter-sale')
- * ```
- */
-export declare function fnv1a32(input: string): number;
-/**
- * Deterministic dice roll for A/B testing.
- *
- * Returns a value 0–99 that is stable for a given session and feature. Seeding
- * on the feature as well as the session keeps flags independent of one another:
- * two flags at weight 50 each take half of sessions, and a quarter of sessions
- * land in both. Independence rests on the avalanche in {@link fmix32}, not on
- * the seed alone.
- *
- * The feature version keys the stored bucket rather than the roll, so
- * publishing a new version re-runs `decide` against the current weight and an
- * unchanged weight keeps the same audience.
- *
- * This is the boolean path's input. A multi-variant feature does not roll once
- * and look the result up; {@link allocateVariant} scores each arm on its own
- * seed. One roll per feature is still what keeps features independent of one
- * another, per ADR-0018.
- *
- * @param {string} sessionId - Current session id, stable across page loads.
- * @param {string} featureId - Feature the roll is for.
- * @returns {number} A value in the range 0 to 99.
- * @example
- * ```typescript
- * const diceRoll = featureDiceRoll('sess_1', 'winter-sale')
- * ```
- */
-export declare function featureDiceRoll(sessionId: string, featureId: string): number;
-/**
- * Whether the given dice roll falls within the feature's weight.
- *
- * Widening a weight admits sessions the narrower weight excluded and never
- * evicts one already inside, so a rollout can ratchet up without re-bucketing
- * anyone. The roll is per feature, so this describes one feature's own weight
- * changing over time; two features at the same weight overlap by chance.
- *
- * @param {number} diceRoll - Roll from {@link featureDiceRoll}, 0–99.
- * @param {number} weight - Feature weight, 0–100.
- * @returns {boolean} Whether the session is allocated to the feature.
- * @example
- * ```typescript
- * isAllocated(42, 50) // true
- * ```
- */
-export declare function isAllocated(diceRoll: number, weight: number): boolean;
-/** The fields {@link allocateVariant} needs from an arm. */
-export interface AllocatableVariant {
-    key: string;
-    weight: number;
-}
-/**
- * Picks the arm a session lands in, scoring each arm independently.
- *
- * Each arm is hashed on its own key and scored against its own weight, and the
- * highest score wins. An arm's score therefore depends on nothing but the
- * session, the feature and that arm's own weight, which is what gives the two
- * properties an author is entitled to assume:
- *
- * - Editing one arm's weight moves sessions only into or out of that arm. Two
- *   arms the author did not touch never trade sessions with each other.
- * - Widening an arm only admits sessions and never evicts one already inside,
- *   the same ratchet {@link isAllocated} gives the boolean path. Narrowing is
- *   its mirror.
- *
- * Neither holds for cumulative ranges, where an arm's interval depends on every
- * arm ordered before it, so a boundary shift upstream drags unrelated arms
- * across it.
- *
- * Scores are compared, never summed, so the result is invariant under scaling
- * every weight by the same factor: `1:1:2` and `10:10:20` allocate identically.
- * Ties break on the key so that the arms' arrival order cannot matter — nothing
- * in the delivery pipeline promises one.
- *
- * The chosen arm is returned whole rather than by key, so a caller reading its
- * value needs no second lookup — and cannot resolve a duplicate key to a
- * different arm than the one scored.
- *
- * @template T
- * @param {string} sessionId - Current session id, stable across page loads.
- * @param {string} featureKey - Feature being allocated.
- * @param {readonly T[]} variants - The feature's arms, in any order.
- * @returns {T | null} The chosen arm, or null when the set decides nobody.
- * @example
- * ```typescript
- * // 'hero-b' takes three sessions in four; 'false' takes the fourth.
- * allocateVariant('sess_1', 'hero', [
- *   { key: 'hero-b', weight: 3 },
- *   { key: 'false', weight: 1 },
- * ])
- * ```
- */
-export declare function allocateVariant<T extends AllocatableVariant>(sessionId: string, featureKey: string, variants: readonly T[]): T | null;
-//# sourceMappingURL=hash.d.ts.map

package/dist/types/plugins/dynamic-experiences/hash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../src/plugins/dynamic-experiences/hash.ts"],"names":[],"mappings":"AAAA,sFAAsF;AAEtF;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAY7C;AA8BD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAUrE;AAED,4DAA4D;AAC5D,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;CACf;AA4CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,kBAAkB,EAC1D,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,SAAS,CAAC,EAAE,GACrB,CAAC,GAAG,IAAI,CAmBV"}

package/dist/types/plugins/dynamic-experiences/index.d.ts

@@ -1,7 +0,0 @@
-/** @file Public exports for the dynamic-experiences plugin (project config + per-experience content resolution). */
-export { dynamicExperiencesPlugin, fetchExperienceContent, fetchProject } from './plugin';
-export { createClientHeaders, fetchSchema } from '@picked/delivery-api-client';
-export { registerPickedBundle } from '../../data-source/registry';
-export type * from './types';
-export type { ApiExperienceStep, ContentBlob, ExperienceContentResponse, FetchProjectOptions, ProjectConfig, ProjectConfigExperience, ProjectConfigFeature, ProjectConfigNode, } from '@picked/delivery-api-client';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/plugins/dynamic-experiences/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/plugins/dynamic-experiences/index.ts"],"names":[],"mappings":"AAAA,oHAAoH;AACpH,OAAO,EAAE,wBAAwB,EAAE,sBAAsB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGzF,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAI9E,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACjE,mBAAmB,SAAS,CAAA;AAI5B,YAAY,EACV,iBAAiB,EACjB,WAAW,EACX,yBAAyB,EACzB,mBAAmB,EACnB,aAAa,EACb,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,GAClB,MAAM,6BAA6B,CAAA"}