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

package/dist/types/picked.d.ts

@@ -1,433 +1,236 @@
-/** @file Picked client — the main entry point for the Picked SDK. */
-import { type Effect, type EventCallable, type Store, type StoreWritable } from 'effector';
-import type { ExperienceContentResponse, ProjectConfig } from '@picked/delivery-api-client';
-import { type Experience, type LaunchExperienceOptions } from './entities/experience/experience';
-import { type Plugin, type PluginConfigIndex } from './entities/plugin/plugin';
-import { type CreateClientOptions } from './client';
-import { type AdaptedComponent } from './entities/component/component';
-import { type Framework } from './entities/framework/framework';
-import { logger } from './utils/logger';
-import { type StateSnapshot } from './lifecycle/state-snapshot';
-import { type EvaluateRuleLogicParams } from './lifecycle/rules-logic';
-import { type ConditionResults } from './lifecycle/condition-selection';
-import { type LifecycleStage } from './lifecycle/lifecycle';
-import type { Predicate } from './entities/predicate/predicate';
-import type { Feature } from './entities/feature/feature';
-import { type EventBusPayload, type EventHistoryStore } from './utils/events';
-import type { Field } from './entities/field/field';
-import type { ExperienceStep } from './entities/step/step';
-import type { Content, ContentDataPatch } from './entities/content/content';
-import type { ContentLoader } from './plugins/dynamic-experiences/types';
-import type { Action } from './entities/action/action';
-import { type Condition } from './entities/condition/condition';
-import { type StartTiming } from './utils/user-timing';
-import { type ClientTelemetry } from './utils/client-telemetry';
-import type { SessionEntity } from './entities/session/session';
-/**
- * Provenance metadata describing where the Picked client's project config and
- * content came from. Set by `dynamicExperiencesPlugin` when the Vite plugin's
- * virtual data module is available; remains `null` otherwise.
- */
-export interface PickedDataSource {
-    /** `'build'` when build-mode prefetch JSON was used, `'dev'` when the dev-mode runtime fetch was used. */
-    mode: 'dev' | 'build';
-    /** ISO 8601 timestamp from the manifest. `null` in dev mode where no manifest is written. */
-    fetchedAt: string | null;
-    /** The `versionId` recorded by the source, when known. */
-    projectVersionId: string | null;
-    /** The `workspaceId` recorded by the source, when known. */
-    workspaceId: string | null;
-}
+import { Experience } from './entities/experience/experience';
+import { Plugin, PluginConfigIndex } from './entities/plugin/plugin';
+import { CreateClientOptions } from './client';
+import { AdaptableComponents, AdaptedComponent } from './entities/component/component';
+import { Framework } from './entities/framework/framework';
+import { StateSnapshot } from './utils/state-snaphot';
+import { Predicate } from './entities/predicate/predicate';
+import { Feature } from './entities/feature/feature';
+import { Field } from './entities/field/field';
 export declare class Picked {
-    static readonly logger: typeof logger;
+    static readonly logger: (level: "log" | "warn" | "info" | "error", ...args: Parameters<Console["log"]>) => void;
     private readonly options;
-    /**
-     * Provenance metadata for the data backing this client. Populated by
-     * `dynamicExperiencesPlugin` when the Vite plugin's virtual data module is
-     * resolvable; remains `null` when the SDK is using the runtime API path.
-     */
-    dataSource: PickedDataSource | null;
-    /**
-     * `versionId` of the SSR snapshot this client was seeded from, set by the framework
-     * providers' `seedFromSnapshot`. `null` when no snapshot was seeded — a browser-only client,
-     * or a route that rendered without one.
-     */
-    seededVersionId: string | null;
-    /**
-     * Set when a resolved project config disagrees with the seeded snapshot's `versionId`. The
-     * snapshot stays authoritative (it is what the server rendered the markup from) and the
-     * resolved config is dropped, so this records the divergence rather than hiding it.
-     */
-    versionSkew: {
-        seeded: string;
-        resolved: string;
-    } | null;
-    /**
-     * Content fetcher selected by `dynamicExperiencesPlugin`'s resolution chain. Called
-     * by each experience's `prepareExperienceContentFx` (fired in parallel with
-     * `initialiseFx` by the per-experience sample graph). `undefined` when no plugin
-     * has registered one yet.
-     */
-    contentLoader?: ContentLoader;
-    /**
-     * Origins allowed to push live-preview content patches into this page, issued by the API on the
-     * preview surface and set by `dynamicExperiencesPlugin`. `null` until the project config
-     * resolves, and on every non-preview surface — the preview receiver treats that as "trust
-     * nobody" and stays closed.
-     */
-    previewEmbedderOrigins: string[] | null;
-    /** Config of every registered plugin, keyed by name in registration order. */
-    readonly plugins: PluginConfigIndex;
-    /** This client's telemetry hooks. */
-    readonly telemetry: ClientTelemetry;
-    private readonly dataProviders;
-    readonly eventBus: EventCallable<EventBusPayload>;
-    readonly events: EventHistoryStore;
+    isReady: boolean;
+    private project?;
+    private readonly plugins;
+    readonly eventBus: import('effector').EventCallable<import('.').EventBusPayload>;
+    readonly organizationId: string;
     readonly projectId: string;
     readonly apiUrl: string;
-    readonly dashboardUrl: string;
-    readonly documentationSiteUrl: string;
-    readonly session: SessionEntity;
-    /** This client's User Timing entries for its own start chain. */
-    readonly performance: StartTiming;
-    readonly searchParams: import(".").PickedSearchParams;
+    readonly searchParams: import('./utils/search-params').PickedSearchParams;
     readonly history: {
-        push: EventCallable<{
+        push: import('effector').EventCallable<{
             experienceId: string;
-            node: import(".").ExperienceNode;
+            node: import('.').ExperienceNode;
         }>;
-        replace: EventCallable<{
+        replace: import('effector').EventCallable<{
             experienceId: string;
-            node: import(".").ExperienceNode;
+            node: import('.').ExperienceNode;
         }>;
-        back: EventCallable<{
+        back: import('effector').EventCallable<{
             experienceId?: string;
         }>;
-        restore: EventCallable<{
-            entries: import(".").HistoryEntry[];
+        restore: import('effector').EventCallable<{
+            entries: import('.').HistoryEntry[];
         }>;
-        entriesStore: Store<import(".").HistoryEntry[]>;
+        entriesStore: import('effector').Store<import('.').HistoryEntry[]>;
     };
     readonly components: {
-        register: EventCallable<{
-            name: string;
-            component: AdaptedComponent;
-        }>;
-        getByName: (name: string) => Store<{
+        register: (name: string, component: AdaptedComponent) => void;
+        getByName: (name: string) => import('effector').Store<{
             name: string;
             component: AdaptedComponent;
         } | undefined>;
-        listStore: Store<{
+        listStore: import('effector').Store<{
             name: string;
             component: AdaptedComponent<string, unknown>;
-            frameworkStore: Store<Framework | undefined>;
+            frameworkStore: import('effector').Store<Framework | undefined>;
         }[]>;
     };
     readonly experienceInstances: {
-        spawn: (experience: import(".").ExperienceStore, target: HTMLElement, options?: LaunchExperienceOptions) => void;
-        getByExperienceKey: (key: Experience['key']) => Store<import(".").ExperienceInstance[]>;
-        getByExperienceId: (id: Experience['id']) => Store<import(".").ExperienceInstance[]>;
-        listStore: Store<import(".").ExperienceInstance[]>;
+        spawn: (experience: import('.').ExperienceStore, target: HTMLElement) => void;
+        getByExperienceId: (id: Experience["id"]) => import('effector').Store<{
+            experienceId: string;
+            configStore: import('effector').Store<{
+                type: string;
+                name: string;
+                decisionLogic: import('./logic-engine').LogicRule | undefined;
+                targetSelectors: import('.').ExperienceTarget[];
+            }>;
+            target: HTMLElement | undefined;
+            componentStore: import('effector').Store<{
+                name: string;
+                component: AdaptedComponent<string, unknown>;
+                frameworkStore: import('effector').Store<Framework | undefined>;
+            } | undefined>;
+            stateStore: import('effector').StoreWritable<"transitioning" | "ready">;
+            isOpenStore: import('effector').StoreWritable<boolean>;
+            open: import('effector').EventCallable<void>;
+            close: import('effector').EventCallable<void>;
+            toggleOpen: import('effector').EventCallable<void>;
+            setOpen: import('effector').EventCallable<boolean>;
+            treeStore: import('effector').Store<{
+                steps: import('.').ExperienceStep[];
+                nodes: import('.').ExperienceNode[];
+                edges: import('.').ExperienceEdge[];
+                conditionals: import('.').ExperienceConditional[];
+            }>;
+            currentNodeStore: import('effector').Store<import('.').ExperienceNode | null>;
+            currentStepStore: import('effector').Store<import('.').ExperienceStep | null>;
+            nextReachableStepNodesStore: import('effector').Store<import('.').ExperienceNode[]>;
+            stepsToOriginStore: import('effector').Store<number[]>;
+            stepsToLeafStore: import('effector').Store<number[]>;
+            goToNextStep: import('effector').EventCallable<void>;
+            goToPreviousStep: import('effector').EventCallable<void>;
+            goToStepById: import('effector').EventCallable<string>;
+            stepsHistoryStore: import('effector').Store<import('.').HistoryEntry[]>;
+        }[]>;
+        listStore: import('effector').Store<{
+            experienceId: string;
+            configStore: import('effector').Store<{
+                type: string;
+                name: string;
+                decisionLogic: import('./logic-engine').LogicRule | undefined;
+                targetSelectors: import('.').ExperienceTarget[];
+            }>;
+            target: HTMLElement | undefined;
+            componentStore: import('effector').Store<{
+                name: string;
+                component: AdaptedComponent<string, unknown>;
+                frameworkStore: import('effector').Store<Framework | undefined>;
+            } | undefined>;
+            stateStore: import('effector').StoreWritable<"transitioning" | "ready">;
+            isOpenStore: import('effector').StoreWritable<boolean>;
+            open: import('effector').EventCallable<void>;
+            close: import('effector').EventCallable<void>;
+            toggleOpen: import('effector').EventCallable<void>;
+            setOpen: import('effector').EventCallable<boolean>;
+            treeStore: import('effector').Store<{
+                steps: import('.').ExperienceStep[];
+                nodes: import('.').ExperienceNode[];
+                edges: import('.').ExperienceEdge[];
+                conditionals: import('.').ExperienceConditional[];
+            }>;
+            currentNodeStore: import('effector').Store<import('.').ExperienceNode | null>;
+            currentStepStore: import('effector').Store<import('.').ExperienceStep | null>;
+            nextReachableStepNodesStore: import('effector').Store<import('.').ExperienceNode[]>;
+            stepsToOriginStore: import('effector').Store<number[]>;
+            stepsToLeafStore: import('effector').Store<number[]>;
+            goToNextStep: import('effector').EventCallable<void>;
+            goToPreviousStep: import('effector').EventCallable<void>;
+            goToStepById: import('effector').EventCallable<string>;
+            stepsHistoryStore: import('effector').Store<import('.').HistoryEntry[]>;
+        }[]>;
     };
     readonly experiences: {
-        register: EventCallable<Experience>;
-        get: (id: Experience['id']) => Store<import(".").ExperienceStore | undefined>;
-        getById: (id: Experience['id']) => Store<import(".").ExperienceStore | undefined>;
-        getByKey: (key: Experience['key']) => Store<import(".").ExperienceStore | undefined>;
-        launch: Effect<{
-            key: string;
-            options?: LaunchExperienceOptions;
-        } | {
+        register: (experience: Experience) => void;
+        getById: (id: Experience["id"]) => import('effector').Store<{
             id: string;
-            options?: LaunchExperienceOptions;
-        }, void, Error>;
-        open: Effect<{
-            key: string;
-            options?: import("./exports").OpenExperienceOptions;
-        } | {
+            configStore: import('effector').Store<{
+                type: string;
+                name: string;
+                decisionLogic: import('./logic-engine').LogicRule | undefined;
+                targetSelectors: import('.').ExperienceTarget[];
+            }>;
+            treeStore: import('effector').Store<{
+                steps: import('.').ExperienceStep[];
+                nodes: import('.').ExperienceNode[];
+                edges: import('.').ExperienceEdge[];
+                conditionals: import('.').ExperienceConditional[];
+            }>;
+            componentStore: import('effector').Store<{
+                name: string;
+                component: AdaptedComponent<string, unknown>;
+                frameworkStore: import('effector').Store<Framework | undefined>;
+            } | undefined>;
+            merge: import('effector').EventCallable<{
+                experience: Partial<Experience>;
+                strategy: "override";
+            }>;
+        } | undefined>;
+        listStore: import('effector').Store<{
             id: string;
-            options?: import("./exports").OpenExperienceOptions;
-        }, void, Error>;
-        listStore: Store<import(".").ExperienceStore[]>;
-        initialiseExperiencesFx: Effect<void, void, Error>;
+            configStore: import('effector').Store<{
+                type: string;
+                name: string;
+                decisionLogic: import('./logic-engine').LogicRule | undefined;
+                targetSelectors: import('.').ExperienceTarget[];
+            }>;
+            treeStore: import('effector').Store<{
+                steps: import('.').ExperienceStep[];
+                nodes: import('.').ExperienceNode[];
+                edges: import('.').ExperienceEdge[];
+                conditionals: import('.').ExperienceConditional[];
+            }>;
+            componentStore: import('effector').Store<{
+                name: string;
+                component: AdaptedComponent<string, unknown>;
+                frameworkStore: import('effector').Store<Framework | undefined>;
+            } | undefined>;
+            merge: import('effector').EventCallable<{
+                experience: Partial<Experience>;
+                strategy: "override";
+            }>;
+        }[]>;
     };
     readonly frameworks: {
-        register: EventCallable<{
-            name: string;
-            framework: Framework;
-        }>;
-        getByName: (name: string) => Store<Framework | undefined>;
-        listStore: Store<Framework[]>;
+        register: (name: string, framework: Framework) => void;
+        getByName: (name: string) => import('effector').Store<Framework | undefined>;
+        listStore: import('effector').Store<Framework[]>;
     };
     readonly predicates: {
-        register: EventCallable<{
+        register: (name: string, predicate: Predicate) => void;
+        getByName: (name: string) => import('effector').Store<{
             name: string;
             predicate: Predicate;
-        }>;
-        getByName: (name: string) => Store<Predicate | undefined>;
-        listStore: Store<{
+        } | undefined>;
+        listStore: import('effector').Store<{
             name: string;
             predicate: Predicate;
         }[]>;
-        getEvokablePredicate: (predicateName: string) => Store<() => ReturnType<Predicate>>;
     };
     readonly features: {
-        register: EventCallable<{
-            id: string;
-            feature: Feature;
-        }>;
-        getById: (id: string) => Store<import(".").FeatureBucket | undefined>;
-        getByName: (name: string) => Store<import(".").FeatureIndexItem | undefined>;
-        listStore: Store<import(".").FeatureBucket[]>;
-        getEvokableFeature: (featureName: string) => Store<() => Promise<import(".").FeatureBucketValue>>;
-        getFeatureResult: <K extends string>(featureName: K) => Store<import(".").FeatureResult<import("./schema-registry").FeatureValueFor<K>> | undefined>;
-    };
-    readonly conditions: {
-        register: (condition: Condition) => void;
-        getById: (id: Condition['id']) => Store<Condition | null>;
-        getByKey: (key: Condition['key']) => Store<Condition | null>;
-        listStore: Store<Condition[]>;
-        indexStore: StoreWritable<{
-            [id: string]: Condition;
-        }>;
+        register: (id: string, feature: Feature) => void;
+        getByName: (name: string) => import('effector').Store<import('.').FeatureIndexItem | undefined>;
+        listStore: import('effector').Store<import('.').FeatureBucket[]>;
     };
     readonly fields: {
         register: (field: Field) => void;
-        update: (key: import(".").FieldBase['key'], updates: Partial<Field>) => void;
-        getById: (id: import(".").FieldBase['id']) => Store<Field | null>;
-        getByKey: (key: import(".").FieldBase['key']) => Store<Field | null>;
-        listStore: Store<Field[]>;
-        getByName: (name: import(".").FieldBase['name']) => Store<Field | null>;
+        getById: (id: import('.').FieldBase["id"]) => import('effector').Store<Field | null>;
+        listStore: import('effector').Store<Field[]>;
+        getByName: (name: import('.').FieldBase["name"]) => import('effector').Store<Field | null>;
     };
     readonly responses: {
-        register: {
-            (fieldKey: Field['key'], response: import(".").Response): void;
-            (payload: Record<Field['key'], import(".").Response>, response?: never): void;
-        };
-        clearAll: EventCallable<void>;
-        clear: EventCallable<string>;
-        commit: <T extends import(".").CommitResponses>(responsesToCommit: T & import(".").ValidateResponses<T>) => Promise<{
-            errors: import(".").ValidationError[];
-        }>;
-        getResponsesToCommit: <T extends import(".").CommitResponses>(responsesToCommit: T & import(".").ValidateResponses<T>) => Promise<{
-            responsesToCommit: import(".").CommitResponses;
-            validationErrors: import(".").ValidationError[];
+        register: (fieldId: Field["id"], response: import('.').Response) => void;
+        clearAll: import('effector').EventCallable<void>;
+        clear: import('effector').EventCallable<string>;
+        commit: (responsesToCommit: import('.').CommitResponses) => Promise<{
+            errors: import('.').ValidationError[];
         }>;
-        listStore: Store<{
-            fieldKey: string;
-            value: import(".").FieldValue;
+        listStore: import('effector').Store<{
+            fieldId: string;
+            value: import('.').FieldValue | undefined;
         }[]>;
-        getAllStore: Store<{
-            [fieldKey: string]: import(".").FieldValue;
-        }>;
-        getByFieldId: (id: Field['id']) => Store<import(".").FieldValue>;
-        getByFieldKey: <K extends string>(key: K) => Store<import("./schema-registry").FieldValueFor<K>>;
-        getByFieldName: (fieldName: Field['name']) => Store<import(".").FieldValue>;
-    };
-    readonly steps: {
-        register: (step: ExperienceStep) => void;
-        getById: (id: ExperienceStep['id']) => Store<ExperienceStep | null>;
-        getByKey: (key: ExperienceStep['key']) => Store<ExperienceStep | null>;
-        listStore: Store<ExperienceStep[]>;
-        indexStore: StoreWritable<{
-            [id: string]: ExperienceStep;
-        }>;
-    };
-    readonly contents: {
-        register: (content: Content) => void;
-        patch: (id: string, apply: ContentDataPatch) => void;
-        getById: (id: Content['id']) => Store<Content | null>;
-        listStore: Store<Content[]>;
-        indexStore: StoreWritable<{
-            [id: string]: Content;
-        }>;
-    };
-    readonly actions: {
-        register: EventCallable<{
-            key: string;
-            action: Action;
+        getAllStore: import('effector').Store<{
+            [fieldId: string]: import('.').FieldValue;
         }>;
-        getByKey: (key: string) => Store<Action | undefined>;
-        listStore: Store<import(".").ActionIndexItem[]>;
-        getEvokableAction: (actionKey: string, options?: {
-            experience: import(".").ExperienceInstance;
-        }) => Store<() => ReturnType<Action>>;
+        getByFieldId: (fieldId: Field["id"]) => import('effector').Store<import('.').FieldValue>;
+        getByFieldName: (fieldName: Field["name"]) => import('effector').Store<import('.').FieldValue>;
     };
-    /**
-     * Memoized condition-evaluation results keyed by rule hash. Populated by the
-     * server `serialize` selection and the memoized evaluator (`evaluateConditionMemo`),
-     * and seeded on the client from the SSR snapshot so first paint reuses the server's
-     * selection without re-evaluating.
-     */
-    readonly conditionResults: ConditionResults;
-    readonly stateSnapshotStore: Store<StateSnapshot>;
-    readonly evaluateRuleLogicFx: Effect<EvaluateRuleLogicParams, unknown, Error>;
-    /** Public trigger — fires the start chain. `await allSettled(client.start, { scope })` resolves once the chain has fully settled. */
-    readonly start: EventCallable<void>;
-    /** Reactive store of the readiness flag. */
-    readonly readyStore: StoreWritable<boolean>;
-    /** Reactive store of the precondition-gate result (`undefined` until `start` is fired). */
-    readonly preconditionPassedStore: StoreWritable<boolean | undefined>;
-    /** Reactive store of the condition-gate result (`undefined` until `start` is fired). */
-    readonly conditionPassedStore: StoreWritable<boolean | undefined>;
-    /** Reactive store of the current lifecycle stage. */
-    readonly lifecycleStageStore: StoreWritable<LifecycleStage>;
-    private readonly lifecycle;
-    /**
-     * Effect that interpolates a template string against the latest responses plus a caller-supplied context. Source is `responses.listStore` so renders are scope-aware and pick up the latest committed responses without `.getState()`.
-     *
-     * @example
-     * ```typescript
-     * const greeting = await client.renderStringFx({ template: 'Hi {{name}}', context: { name: 'Mae' } })
-     * ```
-     */
-    readonly renderStringFx: Effect<{
-        template: string;
-        context?: Record<string, unknown>;
-    }, string, Error>;
     constructor(options: CreateClientOptions);
-    /**
-     * Resolves the data provider backing a given preview token, building it once per token.
-     *
-     * @param {string | undefined} previewToken - Preview token for the caller, when there is one.
-     * @returns {Promise<PickedDataProvider>} The provider for that token.
-     * @example
-     * const provider = await client.dataProviderFor(undefined)
-     */
-    private dataProviderFor;
-    /**
-     * Resolves this project's configuration.
-     *
-     * Reads the build-time bundle when one registered itself, and the Picked API otherwise. A
-     * preview token forces the API, because preview renders unpublished data no bundle can hold.
-     * Deduplicated per token, so several callers in one request cost one resolution.
-     *
-     * @param {object} [options] - Per-call resolution inputs.
-     * @param {string} [options.previewToken] - Preview token, forcing a live read.
-     * @param {AbortSignal} [options.signal] - Signal applied to an API read.
-     * @returns {Promise<ProjectConfig>} The project configuration.
-     * @throws {Error} When the configuration cannot be resolved from any source.
-     * @example
-     * const config = await client.getProjectConfig()
-     */
-    getProjectConfig(options?: {
-        previewToken?: string;
-        signal?: AbortSignal;
-    }): Promise<ProjectConfig>;
-    /**
-     * Resolves one experience's CMS content, from the same source as the configuration.
-     *
-     * @param {{ id: string; key: string }} experience - The experience to resolve content for.
-     * @param {string} experience.id - Experience id, which keys bundled content.
-     * @param {string} experience.key - Experience key, for a content loader that prefers it.
-     * @param {object} [options] - Per-call resolution inputs.
-     * @param {string} [options.previewToken] - Preview token, forcing a live read.
-     * @param {AbortSignal} [options.signal] - Deadline for this call's API read, if it makes one.
-     * @returns {Promise<ExperienceContentResponse | null>} The content, or `null` when it has none.
-     * @example
-     * const content = await client.getExperienceContent({ id: 'exp_1', key: 'promo' })
-     */
-    getExperienceContent(experience: {
-        id: string;
-        key: string;
-    }, options?: {
-        previewToken?: string;
-        signal?: AbortSignal;
-    }): Promise<ExperienceContentResponse | null>;
-    /**
-     * Lazily starts the preview channel when this frame is a live-preview session: the outbound
-     * bridge, which reports the frame's URL to the dashboard, and the inbound receiver, which applies
-     * the dashboard's content patches.
-     *
-     * Both load from a single dynamic `import()` so there is one code-split point and neither reaches
-     * production bundles. Failures are swallowed so client creation never depends on the preview
-     * channel, and the receiver refuses every message until the API issues an origin allowlist, so
-     * starting it before the project config resolves is safe.
-     *
-     * @returns {void} Nothing.
-     * @example
-     * this.maybeStartPreviewChannel()
-     */
-    private maybeStartPreviewChannel;
-    registerFramework: (framework: Framework) => void;
-    registerComponent: (name: string, component: AdaptedComponent) => void;
-    registerPlugin: (plugin: Plugin) => void;
-    registerFeature: (name: string, feature: Feature) => void;
-    registerPredicate: (name: string, predicate: Predicate) => void;
-    registerCondition: (condition: Condition) => void;
-    registerField: (field: Field) => void;
-    registerStep: (step: ExperienceStep) => void;
-    registerContent: (content: Content) => void;
-    /**
-     * Applies path-addressed replacements to a registered content record, leaving every untouched
-     * branch of the blob shared by reference so only the affected subtree re-renders.
-     *
-     * A no-op when no record with `id` is registered — the record's base blob comes from
-     * `contentLoader`, and a patch that arrives first must not fabricate one.
-     *
-     * Takes a transform rather than a list of path ops so the path parser and the spine-rebuilding
-     * walk stay out of this module's import graph — they belong to the lazily-loaded preview channel.
-     * Build one with `applyContentOps` from `@picked/client/preview`.
-     *
-     * @param {string} id - The content record id to patch.
-     * @param {ContentDataPatch} apply - Transform producing the next `data` blob.
-     * @returns {void} Nothing.
-     * @example
-     * ```typescript
-     * client.patchContent('c1', (data) => ({ ...data, headline: 'Hello' }))
-     * ```
-     */
-    patchContent: (id: string, apply: ContentDataPatch) => void;
-    registerAction: (key: string, action: Action) => void;
-    registerExperience: (experience: Experience) => void;
-    /**
-     * Launches an experience by ID.
-     *
-     * @param experienceId - The experience id to launch.
-     * @param options - Optional launch options.
-     * @example
-     * ```typescript
-     * await client.launchExperienceById('exp-1')
-     * ```
-     */
-    launchExperienceById: (experienceId: string, options?: LaunchExperienceOptions) => Promise<void>;
-    /**
-     * Launches an experience by Key.
-     *
-     * @param experienceKey - The experience key to launch.
-     * @param options - Optional launch options.
-     * @example
-     * ```typescript
-     * await client.launchExperienceByKey('exp-1')
-     * ```
-     */
-    launchExperienceByKey: (experienceKey: string, options?: LaunchExperienceOptions) => Promise<void>;
-    /**
-     * Opens an experience by ID.
-     *
-     * @param experienceId - The experience ID to open.
-     * @example
-     * ```typescript
-     * await client.openExperienceById('exp-1')
-     * ```
-     */
-    openExperienceById: (experienceId: string) => Promise<void>;
-    /**
-     * Opens an experience by Key.
-     *
-     * @param experienceKey - The experience Key to open.
-     * @example
-     * ```typescript
-     * await client.openExperienceById('exp-1')
-     * ```
-     */
-    openExperienceByKey: (experienceKey: string) => Promise<void>;
+    start(): void;
+    registerFramework(framework: Framework): void;
+    registerComponent(name: keyof AdaptableComponents, component: AdaptedComponent): void;
+    registerPlugin(plugin: Plugin): void;
+    registerFeature(name: string, feature: Feature): void;
+    registerPredicate(name: string, predicate: Predicate): void;
+    registerField(field: Field): void;
+    registerExperience(experience: Experience): void;
+    getStateSnapshot(): StateSnapshot;
+    launchExperienceById(experienceId: string): Promise<void>;
     private setupPlugins;
     private setupFeatures;
     private setupPredicates;
-    private setupActions;
-    private setupFields;
-    private setupComponents;
-    getPluginConfig: (pluginName: string) => PluginConfigIndex[string] | Record<string, unknown>;
+    getPluginConfig(pluginName: string): PluginConfigIndex[string] | Record<string, unknown>;
 }
 //# sourceMappingURL=picked.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"picked.d.ts","sourceRoot":"","sources":["../../src/picked.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"picked.d.ts","sourceRoot":"","sources":["../../src/picked.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,UAAU,EAIhB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,iBAAiB,EAAe,MAAM,0BAA0B,CAAA;AAC3F,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EAGtB,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAEL,KAAK,SAAS,EAEf,MAAM,gCAAgC,CAAA;AAGvC,OAAO,EAAuB,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAC/E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gCAAgC,CAAA;AAE/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AAMzD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAQnD,qBAAa,MAAM;IACjB,MAAM,CAAC,QAAQ,CAAC,MAAM,0FAAS;IAC/B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAE7C,OAAO,UAAQ;IAEf,OAAO,CAAC,OAAO,CAAC,CAAS;IAEzB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAwB;IAEhD,SAAgB,QAAQ,gEAAmB;IAC3C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IAEvB,QAAQ,CAAC,YAAY,qDAAoB;IAEzC,QAAQ,CAAC,OAAO;;;;;;;;;;;;;;;;MAAkB;IAElC,QAAQ,CAAC,UAAU;;;;;;;;;;;MAAyC;IAC5D,QAAQ,CAAC,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAkD;IAC9E,QAAQ,CAAC,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAA0C;IAC9D,QAAQ,CAAC,UAAU;;;;MAAyC;IAC5D,QAAQ,CAAC,UAAU;;;;;;;;;;MAAyC;IAC5D,QAAQ,CAAC,QAAQ;;;;MAAuB;IACxC,QAAQ,CAAC,MAAM;;;;;MAAqB;IACpC,QAAQ,CAAC,SAAS;;;;;;;;;;;;;;;;MAAwC;gBAE9C,OAAO,EAAE,mBAAmB;IAgBxC,KAAK,IAAI,IAAI;IA8Bb,iBAAiB,CAAC,SAAS,EAAE,SAAS;IAItC,iBAAiB,CAAC,IAAI,EAAE,MAAM,mBAAmB,EAAE,SAAS,EAAE,gBAAgB;IAI9E,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAIpC,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO;IAI9C,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS;IAIpD,aAAa,CAAC,KAAK,EAAE,KAAK;IAI1B,kBAAkB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAQhD,gBAAgB,IAAI,aAAa;IAI3B,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAqB/D,OAAO,CAAC,YAAY;IA6BpB,OAAO,CAAC,aAAa;IA0CrB,OAAO,CAAC,eAAe;IAgBvB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,iBAAiB,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAGzF"}