@drip-apex/sdk 0.1.0

package/dist/sri.json

@@ -0,0 +1,27 @@
+{
+  "drip.js": {
+    "sha384": "sha384-Um2aSsOgGy30oXzHq054QWAey3e6xnQhUpxi6t0DoBLN/vl7L34IluEEDsVDUvy+",
+    "bytes": 327176,
+    "gzipBytes": 95380
+  },
+  "drip.live.js": {
+    "sha384": "sha384-dP//F37IbyzbnWQ7W/PYVmQVKp+ByihrHT15tpQFISCO10M2C7GI/tmAu7WRmCwi",
+    "bytes": 238320,
+    "gzipBytes": 69619
+  },
+  "drip.heatmap.js": {
+    "sha384": "sha384-h6Jx5DkyjsdiU0XzIc/2AlH2Xu4qQppeOY6cfVQxrRzrFkYl6VP/g6NDFTdwGppy",
+    "bytes": 243757,
+    "gzipBytes": 71115
+  },
+  "drip.debug.js": {
+    "sha384": "sha384-eaOKabQEMuuTio8GrmAj5B1sn4qlTqhw3gO+0u9gTKeWBtYmo0LXfTxBN2nEYsEg",
+    "bytes": 327182,
+    "gzipBytes": 95383
+  },
+  "editor.js": {
+    "sha384": "sha384-WBLo4reMW+GBBHxLB6TpXCsJa2mukHmYMuyqlQpGeMR4OqPSNvNbRgqMXLLDYnr6",
+    "bytes": 106433,
+    "gzipBytes": 31127
+  }
+}

package/dist/types/analytics.d.ts

@@ -0,0 +1,15 @@
+/**
+ * analytics.ts — Automatic pageview and engagement tracking.
+ *
+ * Fires two event types through the existing track() pipeline:
+ *   - "pageview" on every page load / SPA navigation
+ *   - "page_exit" on navigation away / tab close (with duration + scroll depth)
+ */
+type TrackFn = (type: string, data?: Record<string, unknown>) => void;
+/** Clean URL: origin + pathname only (strips query params). */
+export declare function cleanUrl(): string;
+/** Called on every page load / SPA navigation. */
+export declare function onPageEnter(trackFn: TrackFn): void;
+/** Called on SPA navigation away / page unload. */
+export declare function onPageExit(trackFn: TrackFn): void;
+export {};

package/dist/types/antiflicker.d.ts

@@ -0,0 +1,14 @@
+import type { AntiFlickerMode } from "./types";
+export declare function resolveAntiFlickerCss(mode?: AntiFlickerMode, scopedSelectors?: string[], customCss?: string): string | null;
+/**
+ * Apply anti-flicker hiding based on mode.
+ * - "scoped": only hides elements matching provided selectors (preferred).
+ * - "full": hides entire page with opacity:0 (legacy).
+ * - "off": no-op.
+ * Scoped mode is a no-op when no selectors are available.
+ *
+ * Progressive reveal: at 80% of timeout, begins a CSS transition to fade
+ * content in gradually rather than a sudden flash at timeout expiry.
+ */
+export declare function applyAntiFlicker(mode?: AntiFlickerMode, timeoutMs?: number, scopedSelectors?: string[], customCss?: string): void;
+export declare function removeAntiFlicker(): void;

package/dist/types/assignment-store.d.ts

@@ -0,0 +1,30 @@
+import type { Experiment, Variation } from "./types";
+export type PersistedAssignmentRecord = {
+    variationId: string;
+    epoch: number;
+    assignedAt: number;
+};
+type CompactRecord = [string, number, number];
+type CompactStore = Record<string, CompactRecord>;
+declare function assignmentEpoch(experiment: Experiment): number;
+declare function parseStore(raw: string | null): CompactStore;
+declare function serializeStore(store: CompactStore, maxEntries?: number): string;
+export declare function readPersistedAssignments(): Record<string, PersistedAssignmentRecord>;
+export declare function writePersistedAssignments(records: Record<string, PersistedAssignmentRecord>): void;
+export declare function clearPersistedAssignments(): void;
+export declare function prunePersistedAssignments(experiments: Experiment[], records?: Record<string, PersistedAssignmentRecord>): Record<string, PersistedAssignmentRecord>;
+export declare function findPersistedVariation(experiment: Experiment, records?: Record<string, PersistedAssignmentRecord>): {
+    variation: Variation;
+    index: number;
+    record: PersistedAssignmentRecord;
+} | null;
+export declare function persistAssignmentForExperiment(experiment: Experiment, variationId: string, assignedAt?: number): PersistedAssignmentRecord;
+export declare function removePersistedAssignmentsForExperiments(experimentIds: Iterable<string>): void;
+export declare const __assignmentStoreInternals: {
+    STORAGE_KEY: string;
+    COOKIE_NAME: string;
+    assignmentEpoch: typeof assignmentEpoch;
+    parseStore: typeof parseStore;
+    serializeStore: typeof serializeStore;
+};
+export {};

package/dist/types/audit.d.ts

@@ -0,0 +1,9 @@
+import type { InitConfig } from "./types";
+type RuntimeAuditContext = {
+    configSource: string;
+    trackerStarted: boolean;
+    platform: string;
+};
+export declare function isApexScriptSrc(raw: string): boolean;
+export declare function runAuditIfRequested(config: InitConfig, runtime: RuntimeAuditContext): void;
+export {};

package/dist/types/bucket.d.ts

@@ -0,0 +1,2 @@
+export declare function inTrafficAllocation(hashValue: number, allocation?: number): boolean;
+export declare function chooseVariation(hashValue: number, weights: number[]): number;

package/dist/types/bucketing-cleanup.d.ts

@@ -0,0 +1,5 @@
+import type { Experiment } from "./types";
+export declare function cleanupBucketingStorage(experiments: Experiment[], options?: {
+    shopId?: string;
+    retentionDays?: number;
+}): void;

package/dist/types/commerce-gift.d.ts

@@ -0,0 +1,41 @@
+import { type CartAssignment } from "./shopify-cart";
+import type { CommerceOffersSettings } from "./types";
+export type GiftSyncOptions = {
+    /** Per-arm proof from the CURRENT stamped offers plane. Insertion requires
+     * it: config membership alone can cover an assignment whose offers proof
+     * was refused (e.g. shared price+offers experiment with price-only proof),
+     * and the Function would charge that "gift" at full price. */
+    isArmProven?: (assignment: CartAssignment) => boolean;
+    /** A cart mutation invalidates the once-per-page teardown check. */
+    recheckTeardown?: boolean;
+    /** Fail-closed reconciliation after a FAILED stamp sync: privilege-reducing
+     * cleanup only (threshold/currency/orphan removals, quantity normalization)
+     * — never insert, because no fresh proof exists for a new line. */
+    suppressInsertion?: boolean;
+};
+export type PendingGiftChoice = {
+    experimentId: string;
+    threshold: string;
+    options: string[];
+};
+/**
+ * Seed durable insertion records from any cart snapshot that passes through
+ * the SDK (e.g. the /cart/update.js stamp-write response). Marked lines can
+ * only originate from Apex, so seeing one IS the insertion evidence — this is
+ * how a fresh device or a cleared-storage session over a persistent (or
+ * customer-synced) cart rediscovers gifts it must reconcile or tear down.
+ * Returns true when a marked line was found.
+ */
+export declare function noteCartSnapshotForGifts(cart: unknown): boolean;
+export declare function syncGiftWithPurchase(settings: CommerceOffersSettings | undefined, assignments: CartAssignment[], options?: GiftSyncOptions): Promise<void>;
+/** Selects an option previously offered by `apex:gwp:choice`. The next
+ * reconciliation validates the current signed arm/tier before mutating. */
+export declare function selectGiftOption(experimentId: string, variantGid: string): Promise<void>;
+/** Returns live, unanswered gift-choice prompts. This replayable query lets a
+ * chooser mounted after `apex:gwp:choice` was dispatched discover the same
+ * prompt; pass an experiment id to restrict the result. Returned option
+ * arrays are copies and may be safely modified by caller code. */
+export declare function getPendingGiftChoices(experimentId?: string): PendingGiftChoice[];
+export declare const __giftManagerInternals: {
+    reset(): void;
+};

package/dist/types/commerce-price.d.ts

@@ -0,0 +1,22 @@
+import type { Assignment, CommercePriceSettings } from "./types";
+type PriceAssignmentAuthorization = (assignment: Assignment) => boolean;
+export declare const COMMERCE_PRICE_SELECTORS: string[];
+export declare const COMMERCE_PRICE_EXCLUSIONS: string[];
+/** Whether price teardown has state to restore, disconnect, or cancel. */
+export declare function hasCommercePriceState(): boolean;
+/**
+ * True when a price treatment is assigned AND the page either is eligible now or could
+ * still become eligible (Shopify has not published product metadata yet). The reveal
+ * barrier uses this so a metadata-late PDP cannot flash the ORIGINAL price before the
+ * swap lands. The anti-flicker timeout still caps how long content can stay hidden.
+ */
+export declare function isCommercePriceWorkPending(settings: CommercePriceSettings | undefined, assignments: Assignment[], isAssignmentAuthorized?: PriceAssignmentAuthorization): boolean;
+export declare function isCommercePriceActive(settings: CommercePriceSettings | undefined, assignments: Assignment[], isAssignmentAuthorized?: PriceAssignmentAuthorization): boolean;
+export declare function applyCommercePrice(settings: CommercePriceSettings | undefined, assignments: Assignment[], isCohortStampedOnCart?: () => boolean | "pending", onResolved?: () => void, isAssignmentAuthorized?: PriceAssignmentAuthorization): void;
+/** Revisit a timed-out activation when the in-flight Shopify cart write lands. */
+export declare function notifyCommerceCartStampConfirmed(): void;
+/** Whether a display-only price assignment has produced shopper-visible framing. */
+export declare function isCommercePriceExposureEligible(settings: CommercePriceSettings | undefined, assignment: Assignment): boolean;
+export declare const setCommercePriceExposureListener: (listener: () => void) => void;
+export declare function cleanupCommercePrice(): void;
+export {};

package/dist/types/commerce-shipping.d.ts

@@ -0,0 +1,28 @@
+import type { Assignment, CommerceShippingSettings } from "./types";
+export declare function isShippingCartEligible(experimentId: string): boolean;
+type ShippingVariantLike = {
+    treatment: string;
+    threshold: string | null;
+    target?: {
+        productGids: string[];
+        variantGids: string[];
+    };
+};
+/** Shared exposure classification for the sync loop and the exposure fence.
+ * Treatments prove eligibility on their OWN target; controls mirror the
+ * treatment set — any-targeted for scope (an unscoped sibling keeps the
+ * control universal), every-bound for currency (a thresholdless percent
+ * sibling keeps the control cross-currency eligible). */
+export declare function classifyShippingExposure(variants: Record<string, ShippingVariantLike>, isControl: boolean, ownVariant: ShippingVariantLike | undefined): {
+    eligibilityTarget: {
+        productGids: string[];
+        variantGids: string[];
+    };
+    needsTargetProof: boolean;
+    isCurrencyBound: boolean;
+};
+/** True only after shipping setup or a successful cart read proves eligibility. */
+export declare function isShippingCartEligibilityConfirmed(experimentId: string): boolean;
+export declare function applyCommerceShipping(settings: CommerceShippingSettings | undefined, assignments: Assignment[], onEligibilityConfirmed?: () => void): void;
+export declare function cleanupCommerceShipping(): void;
+export {};

package/dist/types/css.d.ts

@@ -0,0 +1,5 @@
+export declare function injectCss(css: string, experimentId: string, variationId: string): void;
+export declare function injectExperimentCss(css: string, experimentId: string): void;
+export declare function removeCss(experimentId: string, variationId: string): void;
+export declare function injectExternalCss(url: string, experimentId: string, variationId: string): Promise<void>;
+export declare function removeAllCss(): void;

package/dist/types/cwv.d.ts

@@ -0,0 +1,10 @@
+type CwvMetrics = {
+    cls_total: number;
+    cls_after_reveal: number;
+};
+export declare function startCwvMeasurement(disabled?: boolean): void;
+export declare function markCwvReveal(): void;
+export declare function getCwvMetrics(): CwvMetrics;
+export declare function waitForCwvMetrics(): Promise<CwvMetrics | null>;
+export declare function resetCwvMeasurement(): void;
+export {};

package/dist/types/data-layer-normalize.d.ts

@@ -0,0 +1 @@
+export declare function normalizeDataLayerEntry(item: unknown): Record<string, unknown> | null;

package/dist/types/debug.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Debug console for Drip SDK.
+ *
+ * Project-configured debug console. By default debug is off; the snippet can
+ * enable it for a specific request, query parameter, or user id.
+ */
+import type { DebugSettings } from "./types";
+declare function tokenMatches(value: string | null, token?: string): boolean;
+declare function isExpired(expiresAt?: string | null): boolean;
+export declare function configureDebug(settings?: DebugSettings, userId?: string | null, options?: {
+    storageAllowed?: boolean;
+}): boolean;
+export declare function isDebugEnabled(): boolean;
+export declare function debugLog(category: string, message: string, data?: unknown): void;
+export declare function debugWarn(category: string, message: string, data?: unknown): void;
+export declare function debugGroup(label: string): void;
+export declare function debugGroupEnd(): void;
+/** @internal — exposed for unit testing only. Tree-shaken from production build. */
+export declare const __test: {
+    isExpired: typeof isExpired;
+    tokenMatches: typeof tokenMatches;
+};
+export {};

package/dist/types/define.d.ts

@@ -0,0 +1,87 @@
+/**
+ * defineExperiment — typed experiment definitions with validation.
+ *
+ * Usage:
+ *   const hero = defineExperiment({
+ *     slug: "hero-banner-v2",
+ *     name: "Hero Banner V2",
+ *     variations: [
+ *       { id: "control", weight: 0.5, mutations: [], isControl: true },
+ *       { id: "variant-a", weight: 0.5, mutations: [{ selector: ".hero h1", action: "text", text: "New headline" }] },
+ *     ],
+ *     targeting: { url: [{ type: "simple", pattern: "/" }] },
+ *     goals: [{ id: "cta-click", type: "click", selector: ".hero-cta" }],
+ *   });
+ */
+import type { Experiment, Mutation, Targeting } from "./types";
+export interface ExperimentDefinition {
+    /** Unique slug for GitOps upsert. Required for code-first experiments. */
+    slug: string;
+    /** Human-readable name. */
+    name: string;
+    /** Traffic allocation percentage (0–1). Default: 1. */
+    trafficAllocation?: number;
+    /** Targeting rules. */
+    targeting?: Targeting;
+    /** Hash attribute override (default: visitor cookie). */
+    hashAttribute?: string;
+    /** Variation definitions. At least two required. */
+    variations: VariationDefinition[];
+    /** Goal definitions for conversion tracking. */
+    goals?: GoalDefinition[];
+}
+export interface VariationDefinition {
+    /** Variation identifier (used as slug within the experiment). */
+    id: string;
+    /** Display name. Falls back to id if omitted. */
+    name?: string;
+    /** Traffic weight (0–1). All weights should sum to 1. */
+    weight: number;
+    /** DOM mutations to apply. Default: []. */
+    mutations?: Mutation[];
+    /** Optional typed value returned by feature-flag helpers. */
+    value?: unknown;
+    /** Custom CSS injected when this variation is active. */
+    css?: string;
+    /** Custom JavaScript executed when this variation is active. */
+    js?: string;
+    /** Reset JavaScript executed on SPA navigation away. */
+    resetJs?: string;
+    /** External CSS artifact URL loaded when this variation is active. */
+    externalCssUrl?: string;
+    /** External JS artifact URL loaded when this variation is active. */
+    externalJsUrl?: string;
+    /** Mark as control variation. Exactly one variation should be control. */
+    isControl?: boolean;
+}
+export interface GoalDefinition {
+    /** Goal identifier (used as slug). */
+    id: string;
+    /** Goal type. */
+    type: "click" | "pageview" | "custom" | "revenue";
+    /** CSS selector for click/element goals. */
+    selector?: string;
+    /** URL pattern for pageview goals. */
+    urlPattern?: string;
+    /** Only count once per session. Default: false. */
+    countOnce?: boolean;
+}
+export declare class ExperimentDefinitionError extends Error {
+    readonly issues: string[];
+    constructor(slug: string, issues: string[]);
+}
+/**
+ * Define a typed, validated experiment configuration.
+ *
+ * Returns a frozen Experiment object ready for use with `init({ experiments: [...] })`.
+ * Throws `ExperimentDefinitionError` if the definition is invalid.
+ */
+export declare function defineExperiment(def: ExperimentDefinition): Experiment & {
+    slug: string;
+};
+/**
+ * Define multiple experiments at once. Validates all, throws on first invalid.
+ */
+export declare function defineExperiments(defs: ExperimentDefinition[]): Array<Experiment & {
+    slug: string;
+}>;

package/dist/types/devtools.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Drip SDK Devtools Overlay
+ *
+ * Enable via: `?drip_devtools=1`, `?drip_debug=1`, or `localStorage.drip_devtools=1`
+ *
+ * Renders a draggable panel (shadow DOM) showing:
+ * - Active experiments and assignments
+ * - Targeting evaluation results
+ * - Event log (assignments, mutations, goals, tracking)
+ * - Force variation controls
+ * - Performance timings
+ */
+import type { Assignment, Experiment, SdkDiagnostics } from "./types";
+export interface DevtoolsEvent {
+    ts: number;
+    type: string;
+    label: string;
+    detail?: Record<string, unknown>;
+}
+export declare function logDevtoolsEvent(type: string, label: string, detail?: Record<string, unknown>): void;
+export declare function subscribeDevtoolsEvents(listener: (event: DevtoolsEvent) => void): () => void;
+export declare function isDevtoolsEnabled(): boolean;
+interface MountOptions {
+    experiments: Experiment[];
+    assignments: Assignment[];
+    diagnostics?: SdkDiagnostics | null;
+    forceMap: Record<string, string> | null;
+    onForceVariation: (experimentId: string, variationId: string) => void;
+}
+export declare function mountDevtools(opts: MountOptions): void;
+export declare function unmountDevtools(): void;
+export {};

package/dist/types/dom-trigger.d.ts

@@ -0,0 +1,3 @@
+type DomChangeObserver = () => void;
+export declare function observeDomChanges(observer: DomChangeObserver, debounceMs?: number): () => void;
+export {};

package/dist/types/editor/api.d.ts

@@ -0,0 +1,37 @@
+import type { ActiveEditorSession, ClaimedEditorCommand, EditorArtifacts, EditorVariation } from "./types";
+export declare class EditorApiError extends Error {
+    readonly status: number;
+    readonly payload?: (Record<string, unknown> | null) | undefined;
+    constructor(message: string, status: number, payload?: (Record<string, unknown> | null) | undefined);
+}
+type FetchLike = typeof fetch;
+export declare class EditorApi {
+    private readonly apiOrigin;
+    private readonly session;
+    private readonly fetchImpl;
+    constructor(apiOrigin: string, session: ActiveEditorSession, fetchImpl?: FetchLike);
+    private url;
+    private request;
+    loadArtifacts(variationId: string): Promise<{
+        variation: EditorVariation;
+        artifacts: EditorArtifacts;
+    }>;
+    saveArtifacts(variationId: string, artifacts: EditorArtifacts, expectedPriorHash: string): Promise<{
+        artifactHash: string;
+        reviewStatus: string | null;
+        warningIssues: Array<{
+            code?: string;
+            message?: string;
+        }>;
+        artifacts: EditorArtifacts;
+    }>;
+    extendSession(): Promise<string | null>;
+    revoke(): Promise<void>;
+    claimCommands(limit?: number): Promise<ClaimedEditorCommand[]>;
+    completeCommand(commandId: string, completion: {
+        result: Record<string, unknown>;
+    } | {
+        error: string;
+    }): Promise<void>;
+}
+export {};

package/dist/types/editor/artifacts.d.ts

@@ -0,0 +1,15 @@
+import type { Mutation } from "../types";
+import { type EditorArtifacts } from "./types";
+export declare function upsertMutation(artifacts: EditorArtifacts, mutation: Mutation): EditorArtifacts;
+export declare function removeSelectorMutations(artifacts: EditorArtifacts, selector: string): EditorArtifacts;
+export declare function removeMutationAt(artifacts: EditorArtifacts, index: number): EditorArtifacts;
+export declare class ArtifactHistory {
+    private undoStack;
+    private redoStack;
+    push(current: EditorArtifacts): void;
+    undo(current: EditorArtifacts): EditorArtifacts | null;
+    redo(current: EditorArtifacts): EditorArtifacts | null;
+    reset(): void;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+}

package/dist/types/editor/command-runtime.d.ts

@@ -0,0 +1,48 @@
+import { EditorApi } from "./api";
+import type { EditorController } from "./controller";
+import type { ClaimedEditorCommand } from "./types";
+export type EditorCommandResult = {
+    ok: boolean;
+    [key: string]: unknown;
+};
+type CommandExecution = {
+    result: EditorCommandResult;
+    afterAcknowledge?: () => void;
+};
+type NavigationActions = {
+    navigate(url: string): void;
+    reload(): void;
+    back(): void;
+    forward(): void;
+};
+export declare class EditorCommandExecutor {
+    private readonly controller;
+    private readonly navigation;
+    private readonly consoleLogs;
+    private readonly networkLogs;
+    private restoreConsole;
+    private performanceObserver;
+    constructor(controller: EditorController, navigation?: NavigationActions);
+    start(): void;
+    stop(): void;
+    execute(command: ClaimedEditorCommand): Promise<CommandExecution>;
+    private snapshot;
+    private click;
+    private type;
+    private selectElement;
+    private waitFor;
+    private networkProbe;
+    private evaluateReadonly;
+}
+export declare class EditorCommandPoller {
+    private readonly api;
+    private readonly executor;
+    private running;
+    private timer;
+    private polling;
+    constructor(api: EditorApi, executor: EditorCommandExecutor);
+    start(): void;
+    stop(): void;
+    private poll;
+}
+export {};

package/dist/types/editor/controller.d.ts

@@ -0,0 +1,97 @@
+import { EditorApi } from "./api";
+import { DevicePreview } from "./device-preview";
+import { type ActiveEditorSession, type EditorArtifacts, type EditorDeviceState, type EditorState } from "./types";
+export type ArtifactCommandAudit = {
+    ok: boolean;
+    mutationAudit: Array<{
+        index: number;
+        selector: string;
+        action: string;
+        beforeCount: number;
+        afterCount: number;
+        effectVerified: boolean;
+        error: string | null;
+    }>;
+    generatedSelectors: string[];
+    generatedVisibility: Array<{
+        selector: string;
+        count: number;
+        visibleCount: number;
+        matches: Array<{
+            text: string;
+            visible: boolean;
+        }>;
+    }>;
+    visibleGeneratedCount: number;
+    hiddenEffectVerifiedCount: number;
+    networkRequired: boolean;
+    customJsDeferred: boolean;
+    error?: string;
+    repairHint?: string;
+};
+export declare class EditorController {
+    readonly session: ActiveEditorSession;
+    readonly apiOrigin: string;
+    private readonly api;
+    private readonly reload;
+    private state;
+    private readonly listeners;
+    private readonly history;
+    private visualContext;
+    private devicePreview;
+    private saveTimer;
+    private saveQueue;
+    private revision;
+    private variationRequest;
+    private readonly cleanups;
+    constructor(session: ActiveEditorSession, apiOrigin: string, api?: EditorApi, reload?: () => void);
+    getState(): EditorState;
+    subscribe(listener: (state: EditorState) => void): () => void;
+    initialize(): Promise<void>;
+    selectVariation(variationId: string): Promise<void>;
+    setPickerActive(active: boolean): void;
+    selectElement(element: Element, selector: string): void;
+    clearSelection(): void;
+    clearSelectedElement(): void;
+    removeSelector(selector: string): void;
+    removeMutation(index: number): void;
+    restoreArtifacts(artifacts: EditorArtifacts): void;
+    extendSession(): Promise<string | null>;
+    resolveConflict(choice: "mine" | "theirs"): Promise<void>;
+    toggleArtifacts(enabled: boolean): void;
+    setDock(dock: "top" | "bottom"): void;
+    setText(value: string): void;
+    setImageSource(value: string): void;
+    setStyle(name: string, value: string): void;
+    hideSelected(): void;
+    removeSelected(): void;
+    setCustomCss(value: string): void;
+    setCustomJs(value: string): void;
+    applyCustomJs(): void;
+    undo(): void;
+    redo(): void;
+    attachDevicePreview(devicePreview: DevicePreview): void;
+    setDeviceState(deviceState: EditorDeviceState): void;
+    openDevicePreview(): void;
+    closeDevicePreview(): void;
+    addCleanup(cleanup: () => void): () => void;
+    applyCommandArtifacts(artifacts: EditorArtifacts): ArtifactCommandAudit;
+    saveNow(): Promise<void>;
+    private performSave;
+    exit(): Promise<void>;
+    destroy(): void;
+    private mutateSelected;
+    private commit;
+    private replaceFromHistory;
+    private applyVisualArtifacts;
+    private scheduleSave;
+    private cancelSave;
+    private patch;
+    private emit;
+    private selectorElements;
+    private selectorCount;
+    private isVisible;
+    private verifyMutationEffect;
+    private runCleanups;
+    private withTimeout;
+}

package/dist/types/editor/device-preview.d.ts

@@ -0,0 +1,23 @@
+import type { EditorArtifacts, EditorDeviceState } from "./types";
+export type DevicePreviewSize = {
+    width: number;
+    height: number;
+};
+export declare class DevicePreview {
+    private readonly frame;
+    private readonly onState;
+    private context;
+    private hiddenChildren;
+    private timer;
+    private artifacts;
+    constructor(frame: HTMLIFrameElement, onState: (state: EditorDeviceState) => void);
+    open(artifacts: EditorArtifacts): void;
+    update(artifacts: EditorArtifacts, enabled?: boolean): void;
+    close(notify?: boolean): void;
+    private handleLoad;
+    private readDocument;
+    private apply;
+    private hideStorePage;
+    private blocked;
+    private restoreStorePage;
+}

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

@@ -0,0 +1,9 @@
+import type { EditorLaunchHint } from "../editor-bootstrap";
+import type { ActiveEditorSession } from "./types";
+export type { ActiveEditorSession } from "./types";
+declare function cleanupActiveEditor(): void;
+export declare function start(launch: EditorLaunchHint): Promise<boolean>;
+export declare function getActiveEditorSession(): ActiveEditorSession | null;
+export declare const __test: {
+    reset: typeof cleanupActiveEditor;
+};

package/dist/types/editor/operator.d.ts

@@ -0,0 +1,39 @@
+import type { ActiveEditorSession, EditorArtifacts } from "./types";
+export type EditorOperatorMessage = {
+    role: "user" | "assistant";
+    content: string;
+};
+export type EditorOperatorSelectedElement = {
+    selector: string;
+    tag?: string;
+    textPreview?: string;
+    alternatives?: string[];
+};
+export type EditorOperatorResult = {
+    artifacts: EditorArtifacts;
+    explanation: string;
+    artifactCount: number;
+    mergeStrategy: "append" | "replace";
+};
+export declare function redactEditorContextUrl(value: string, baseUrl?: string): string;
+export declare function collectEditorDomContext(documentLike?: Document): string;
+export declare function mergeEditorOperatorArtifacts(input: {
+    current: EditorArtifacts;
+    generatedMutations: unknown;
+    generatedCss: unknown;
+    generatedJs: unknown;
+    mergeStrategy: unknown;
+}): EditorArtifacts;
+export declare function runEditorOperatorTurn(input: {
+    apiOrigin: string;
+    session: ActiveEditorSession;
+    variationId: string;
+    prompt: string;
+    artifacts: EditorArtifacts;
+    conversation: EditorOperatorMessage[];
+    pageContext?: string;
+    signal?: AbortSignal;
+    selectedElement?: EditorOperatorSelectedElement | null;
+    documentLike?: Document;
+    fetchImpl?: typeof fetch;
+}): Promise<EditorOperatorResult>;