@pagehub/sdk 0.1.0

package/dist/utils/atoms.d.ts.map

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

package/dist/utils/background.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Background image, overlay, and pattern utilities
+ */
+export declare const generatePattern: (props: any) => string;
+export declare const getBackgroundUrl: (props: any, pageMedia?: any[] | null) => any;
+export declare const applyPattern: (prop: any, props: any, settings: any) => any;
+export declare const applyBackgroundImage: (prop: any, props: any, settings: any, pageMedia?: any[] | null) => any;
+export declare const applyLazyBackgroundImage: (prop: any, props: any, settings: any, pageMedia?: any[] | null, lazyRef?: any) => any;
+//# sourceMappingURL=background.d.ts.map

package/dist/utils/background.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"background.d.ts","sourceRoot":"","sources":["../../src/utils/background.ts"],"names":[],"mappings":"AAAA;;GAEG;AAsDH,eAAO,MAAM,eAAe,GAAI,OAAO,GAAG,WA0GzC,CAAC;AAIF,eAAO,MAAM,gBAAgB,GAAI,OAAO,GAAG,EAAE,YAAW,GAAG,EAAE,GAAG,IAAW,QA2B1E,CAAC;AAIF,eAAO,MAAM,YAAY,GAAI,MAAM,GAAG,EAAE,OAAO,GAAG,EAAE,UAAU,GAAG,QAShE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,MAAM,GAAG,EACT,OAAO,GAAG,EACV,UAAU,GAAG,EACb,YAAW,GAAG,EAAE,GAAG,IAAW,QAgC/B,CAAC;AAEF,eAAO,MAAM,wBAAwB,GACnC,MAAM,GAAG,EACT,OAAO,GAAG,EACV,UAAU,GAAG,EACb,YAAW,GAAG,EAAE,GAAG,IAAW,EAC9B,UAAS,GAAU,QA6CpB,CAAC"}

package/dist/utils/breakpointRewrite.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Breakpoint @media threshold rewriter — pure string transformation, safe for
+ * client AND server use.
+ *
+ * Used by:
+ *   - SSR `compileCSS` (compile-css.ts) — applies site `theme.breakpoints` to
+ *     just-compiled Tailwind/DaisyUI output before it ships in the page.
+ *   - Editor `/build` ViewportShell — applies live drag-commit changes to the
+ *     in-page `<style id="tailwind-compiled">` content for instant reactivity
+ *     (no server roundtrip).
+ *
+ * Handles three input forms in compiled CSS:
+ *   - Tailwind rem:  `@media (width >= 48rem)`   (default-state output)
+ *   - Tailwind px:   `@media (width >= 768px)`   (post-rewrite output)
+ *   - DaisyUI px:    `@media (width>=768px)`     (DaisyUI always emits px, no spaces)
+ *
+ * Output is normalized to px for both Tailwind and DaisyUI, so subsequent
+ * deltas need only handle px.
+ */
+export declare const DEFAULT_BREAKPOINTS_PX: {
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+    readonly "2xl": 1536;
+};
+export declare const BP_KEYS: readonly ["sm", "md", "lg", "xl", "2xl"];
+export type BpKey = (typeof BP_KEYS)[number];
+/**
+ * Rewrite from one set of breakpoint values to another. Atomic placeholder pass
+ * prevents stomping when a new value collides with another key's old value.
+ * Returns input unchanged when `from === to` for every key.
+ */
+export declare function rewriteBreakpoints(css: string, fromBps: Record<BpKey, number>, toBps: Record<BpKey, number>): string;
+/**
+ * Editor-only: rewrite `@media (width >= Xpx)` → `@container ph-editor-canvas (width >= Xpx)`
+ * so each canvas frame responds to its OWN container width, not the browser's.
+ *
+ * Must run AFTER rewriteBreakpoints (consumes its px output, not Tailwind's rem).
+ * Handles both Tailwind spaced form and DaisyUI compact form.
+ *
+ * IMPORTANT: do NOT apply for /view, /static, custom domains — public renders
+ * MUST keep `@media`. The editor canvas (#viewport) and any side-by-side
+ * mirrors carry `container-type: inline-size; container-name: ph-editor-canvas`
+ * so this query resolves identically to a browser-width media query for the
+ * single-frame case but per-canvas for dual-frame.
+ */
+export declare function rewriteMediaToContainer(css: string): string;
+/**
+ * Compile-time wrapper: rewrite from defaults to per-site breakpoints.
+ * No-op when `bps` is undefined or every key matches defaults.
+ *
+ * `opts.editor` (Phase 3) — when true, ALSO rewrites `@media` →
+ * `@container ph-editor-canvas` so the editor canvas (and any side-by-side
+ * mirror frame) responds to its own width via CSS container queries instead
+ * of the browser viewport.
+ */
+export declare function applyBreakpointRewrite(css: string, bps?: Record<string, number>, opts?: {
+    editor?: boolean;
+}): string;
+//# sourceMappingURL=breakpointRewrite.d.ts.map

package/dist/utils/breakpointRewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breakpointRewrite.d.ts","sourceRoot":"","sources":["../../src/utils/breakpointRewrite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,sBAAsB;;;;;;CAMzB,CAAC;AAEX,eAAO,MAAM,OAAO,0CAA2C,CAAC;AAChE,MAAM,MAAM,KAAK,GAAG,CAAC,OAAO,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC;AAE7C;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,EAC9B,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAC3B,MAAM,CAuDR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAQ3D;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,MAAM,EACX,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,IAAI,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAE,GAC1B,MAAM,CAqBR"}

package/dist/utils/buildInlineCopyAssistantOpenState.d.ts

@@ -0,0 +1,32 @@
+import { AssistantScope } from './atoms';
+type CraftQueryLike = {
+    node: (id: string) => {
+        get: () => {
+            data?: {
+                custom?: {
+                    displayName?: string;
+                };
+                displayName?: string;
+                name?: string;
+            };
+        } | null | undefined;
+    };
+};
+/**
+ * Payload for `AssistantOpenAtom` when opening the assistant from inline Text (wand / context menu).
+ * Kept in SDK so TextEditor context menu and host `InlineCopyAssistantButton` stay aligned.
+ */
+export declare function buildInlineCopyAssistantOpenState(query: CraftQueryLike, textNodeId: string): {
+    nodeId?: string;
+    mode: "edit";
+    assistantScope: AssistantScope;
+    promptHint: string;
+    freshChat: boolean;
+    revealPanel: boolean;
+    contextNode?: {
+        id: string;
+        displayName: string;
+    };
+};
+export {};
+//# sourceMappingURL=buildInlineCopyAssistantOpenState.d.ts.map

package/dist/utils/buildInlineCopyAssistantOpenState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildInlineCopyAssistantOpenState.d.ts","sourceRoot":"","sources":["../../src/utils/buildInlineCopyAssistantOpenState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C,KAAK,cAAc,GAAG;IACpB,IAAI,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK;QACpB,GAAG,EAAE,MACD;YAAE,IAAI,CAAC,EAAE;gBAAE,MAAM,CAAC,EAAE;oBAAE,WAAW,CAAC,EAAE,MAAM,CAAA;iBAAE,CAAC;gBAAC,WAAW,CAAC,EAAE,MAAM,CAAC;gBAAC,IAAI,CAAC,EAAE,MAAM,CAAA;aAAE,CAAA;SAAE,GACrF,IAAI,GACJ,SAAS,CAAC;KACf,CAAC;CACH,CAAC;AAEF;;;GAGG;AACH,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,cAAc,EACrB,UAAU,EAAE,MAAM,GACjB;IACD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,cAAc,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC;CACnD,CAmBA"}

package/dist/utils/cdn.d.ts

@@ -0,0 +1,40 @@
+/**
+ * CDN Configuration Utility
+ * Cloudflare Images delivery URLs — shared between SDK standalone and app.
+ *
+ * When running inside the app (via tsconfig path to this module), the app sets env vars via
+ * process.env.NEXT_PUBLIC_*. When running standalone SDK, Vite env vars are used.
+ */
+/**
+ * Configure CDN settings at runtime (called by PageHub.init).
+ * Values provided here override environment variables.
+ */
+export declare function configureCdn(opts: {
+    accountHash?: string;
+    baseUrl?: string;
+    variant?: string;
+}): void;
+/**
+ * Get the full CDN URL for a media item
+ */
+export declare function getCdnUrl(mediaId: string, options?: {
+    width?: number;
+    height?: number;
+    fit?: string;
+    format?: string;
+    quality?: number;
+}): string;
+/**
+ * Generate srcset attribute for responsive images
+ */
+export declare function generateSrcSet(mediaId: string, widths?: number[], options?: {
+    fit?: string;
+    format?: string;
+    quality?: number;
+}): string;
+export declare function inferFixedSizesFromClassName(className: string | undefined, parentClassName?: string | undefined): string | null;
+/**
+ * Generate sizes attribute for responsive images
+ */
+export declare function generateSizes(breakpoints?: Record<string, string>): string;
+//# sourceMappingURL=cdn.d.ts.map

package/dist/utils/cdn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../../src/utils/cdn.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAgCH;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,QAI9F;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACjG,MAAM,CAmBR;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,MAAM,GAAE,MAAM,EAA4D,EAC1E,OAAO,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAChE,MAAM,CASR;AAaD,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,GACnC,MAAM,GAAG,IAAI,CAgBf;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,WAAW,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GAAG,MAAM,CAU9E"}

package/dist/utils/cloneState.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @pagehub/sdk — Clone helpers extracted from main app
+ *
+ * These handle linked/cloned component prop syncing.
+ * Stripped of Recoil dependencies and editor-only UI components.
+ */
+export declare const setClonedProps: (props: any, query: any, exclude?: string[]) => any;
+export declare const getClonedState: (props: any, state: any) => {
+    enabled: any;
+    masterProps?: undefined;
+    masterChildren?: undefined;
+} | {
+    enabled: any;
+    masterProps: any;
+    masterChildren: any;
+};
+//# sourceMappingURL=cloneState.d.ts.map

package/dist/utils/cloneState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloneState.d.ts","sourceRoot":"","sources":["../../src/utils/cloneState.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AAEH,eAAO,MAAM,cAAc,GAAI,OAAO,GAAG,EAAE,OAAO,GAAG,EAAE,UAAS,MAAM,EAAO,QAoE5E,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,OAAO,GAAG,EAAE,OAAO,GAAG;;;;;;;;CAapD,CAAC"}

package/dist/utils/component/componentCanvas.d.ts

@@ -0,0 +1,51 @@
+export type CanvasPos = {
+    x: number;
+    y: number;
+};
+/** Both dims optional — when undefined the slot auto-fits the component's
+ *  natural rendered size in that dimension. Drag the corresponding edge to
+ *  commit a fixed value. */
+export type CanvasSize = {
+    w?: number;
+    h?: number;
+};
+export declare const CANVAS_MIN_W = 200;
+export declare const CANVAS_MIN_H = 80;
+export type CanvasAnnotation = {
+    id: string;
+    x: number;
+    y: number;
+    text: string;
+    kind: "label" | "title";
+};
+export declare const COMPONENT_CANVAS_TYPE = "componentCanvas";
+export declare const CANVAS_GRID_STEP = 20;
+export declare const CANVAS_SLOT_W = 480;
+export declare const CANVAS_SLOT_H = 360;
+export declare const CANVAS_SLOT_GAP = 96;
+/** Gap between the master card and its state cards in canvas isolation mode. */
+export declare const CANVAS_STATE_GAP = 12;
+export declare function snapToGrid(v: number, step?: number): number;
+/** Prop key on `props.custom` that stores per-card position. The list canvas
+ *  and the isolation canvas track positions independently — moving the master
+ *  card in isolation must NOT shift its slot in the list view, and vice versa. */
+export type CanvasPosKey = "canvasPos" | "canvasIsolatePos";
+/** Read canvasPos from a component container's props.custom, or compute a deterministic 4-col auto-layout slot. */
+export declare function getComponentCanvasPos(containerId: string, query: any, index: number, posKey?: CanvasPosKey): CanvasPos;
+/** Read canvasSize from a component container's props.custom. Width defaults to
+ *  CANVAS_SLOT_W; height is left undefined when never set so the slot auto-fits. */
+export declare function getComponentCanvasSize(containerId: string, query: any): CanvasSize;
+/** Default position for a state card in canvas isolation mode: stacked
+ *  vertically to the right of the master card. Master width is read from its
+ *  saved canvasSize (defaults to CANVAS_SLOT_W). State cards persist their
+ *  own canvasPos on first render via ComponentCanvasItem's auto-write effect,
+ *  so this only governs the initial layout — moving the master later does
+ *  NOT reposition already-placed state cards. */
+export declare function getStateNodeDefaultPos(masterId: string, stateIndex: number, query: any): CanvasPos;
+/** Find the singleton ComponentCanvas container under ROOT, or return null if not present. */
+export declare function findComponentCanvasNode(query: any): string | null;
+/** Get annotations array from canvas node's props (always returns an array). */
+export declare function getCanvasAnnotations(canvasId: string, query: any): CanvasAnnotation[];
+/** List in-site component containers (ROOT children with props.type === "component"). Skips hidden by default. */
+export declare function listComponentContainers(query: any, includeHidden?: boolean): string[];
+//# sourceMappingURL=componentCanvas.d.ts.map

package/dist/utils/component/componentCanvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentCanvas.d.ts","sourceRoot":"","sources":["../../../src/utils/component/componentCanvas.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,SAAS,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD;;4BAE4B;AAC5B,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,eAAO,MAAM,YAAY,MAAM,CAAC;AAChC,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,qBAAqB,oBAAoB,CAAC;AACvD,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,eAAO,MAAM,eAAe,KAAK,CAAC;AAClC,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAInC,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE,MAAyB,GAAG,MAAM,CAE7E;AAED;;kFAEkF;AAClF,MAAM,MAAM,YAAY,GAAG,WAAW,GAAG,kBAAkB,CAAC;AAE5D,mHAAmH;AACnH,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,GAAG,EACV,KAAK,EAAE,MAAM,EACb,MAAM,GAAE,YAA0B,GACjC,SAAS,CAqBX;AAED;oFACoF;AACpF,wBAAgB,sBAAsB,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,UAAU,CAUlF;AAED;;;;;iDAKiD;AACjD,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,GAAG,GACT,SAAS,CA0BX;AAED,8FAA8F;AAC9F,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,GAAG,IAAI,CAajE;AAED,gFAAgF;AAChF,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,gBAAgB,EAAE,CAQrF;AAED,kHAAkH;AAClH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,GAAG,EAAE,aAAa,UAAQ,GAAG,MAAM,EAAE,CAYnF"}

package/dist/utils/component/componentIsolation.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Canvas-scoped isolation. Distinct from `IsolateAtom` (which is page-scoped).
+ *
+ * `null` = list mode (all components visible on the canvas).
+ * `<containerId>` = isolation mode (only that component visible, others hidden).
+ *
+ * Reset to `null` when:
+ *  - The user clicks the "Exit isolation" pill on the canvas surface.
+ *  - The user toggles the View switcher to leave canvas mode.
+ *  - The isolated component is deleted.
+ */
+export declare const CanvasIsolateAtom: import('@zedux/atoms').AtomTemplate<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, import('@zedux/atoms').AtomTemplateBase<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, import('@zedux/atoms').AtomInstance<{
+    State: import('@zedux/atoms').PromiseState<string>;
+    Params: [];
+    Exports: Record<string, never>;
+    Store: import('@zedux/core').Store<import('@zedux/atoms').PromiseState<string>>;
+    Promise: Promise<string>;
+}, any>>>>;
+type Mode = "page" | "canvas";
+interface ApplyOpts {
+    mode: Mode;
+    /** Only meaningful in canvas mode. Container ID of the isolated component, or null for list. */
+    canvasIsolate?: string | null;
+}
+/**
+ * Sets `hidden` on every direct ROOT child according to the current editor mode.
+ *
+ * Page mode:
+ *  - header / footer / page → visible
+ *  - component / componentCanvas → hidden
+ *
+ * Canvas list mode (`canvasIsolate == null`):
+ *  - header / footer / page → hidden
+ *  - component / componentCanvas → visible
+ *
+ * Canvas isolation mode (`canvasIsolate === <containerId>`):
+ *  - header / footer / page → hidden
+ *  - component → visible only when nodeId === canvasIsolate
+ *  - componentCanvas → hidden (annotations are a list-mode concept)
+ *
+ * Idempotent. Safe to call from mount effects + on every state change.
+ */
+export declare function applyCanvasVisibility(query: any, actions: any, { mode, canvasIsolate }: ApplyOpts): void;
+export {};
+//# sourceMappingURL=componentIsolation.d.ts.map

package/dist/utils/component/componentIsolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentIsolation.d.ts","sourceRoot":"","sources":["../../../src/utils/component/componentIsolation.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;UAA6C,CAAC;AAE5E,KAAK,IAAI,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE9B,UAAU,SAAS;IACjB,IAAI,EAAE,IAAI,CAAC;IACX,gGAAgG;IAChG,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,GAAG,EACV,OAAO,EAAE,GAAG,EACZ,EAAE,IAAI,EAAE,aAAoB,EAAE,EAAE,SAAS,GACxC,IAAI,CA2DN"}

package/dist/utils/component/componentStateNodes.d.ts

@@ -0,0 +1,29 @@
+/** React component displayNames that show up on the canvas as "inherent
+ *  components" — surfaces interactive widgets anywhere in the page as cards
+ *  without needing to wrap them in a `type === "component"` Container. */
+export declare const INHERENT_COMPONENT_DISPLAYNAMES: Set<string>;
+export type StateNodeKind = "modal" | "show-hide" | "tab" | "css-hidden";
+export interface StateNodeRef {
+    nodeId: string;
+    kind: StateNodeKind;
+    /** First trigger that pointed at this state node (for show-hide / modal). */
+    triggerNodeId?: string;
+}
+/**
+ * Walk the entire CraftJS tree from ROOT and return every node whose
+ * displayName is in {@link INHERENT_COMPONENT_DISPLAYNAMES} — Dropdown.
+ * These are surfaced as canvas cards alongside user-created
+ * `type === "component"` Containers so the user doesn't have to wrap each
+ * interactive widget in a component to design its states.
+ *
+ * Skips:
+ *  - nodes inside `type === "component"` containers (already covered by
+ *    that component's master/state cards),
+ *  - nodes inside other inherent components (a Dropdown inside a Modal is
+ *    surfaced via the Modal's state cards, not as its own list-mode card).
+ */
+export declare function findInherentComponentNodes(query: any): string[];
+/** BFS from componentRootId, collect every descendant node id that is itself
+ *  a state subtree. Stops at nested `type === "component"` boundaries. */
+export declare function findStateNodes(componentRootId: string, query: any): StateNodeRef[];
+//# sourceMappingURL=componentStateNodes.d.ts.map

package/dist/utils/component/componentStateNodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentStateNodes.d.ts","sourceRoot":"","sources":["../../../src/utils/component/componentStateNodes.ts"],"names":[],"mappings":"AAmBA;;0EAE0E;AAC1E,eAAO,MAAM,+BAA+B,aAAoB,CAAC;AAEjE,MAAM,MAAM,aAAa,GAAG,OAAO,GAAG,WAAW,GAAG,KAAK,GAAG,YAAY,CAAC;AAEzE,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,aAAa,CAAC;IACpB,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,EAAE,CA6C/D;AAED;0EAC0E;AAC1E,wBAAgB,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,YAAY,EAAE,CAiIlF"}

package/dist/utils/component/componentUtils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Utility functions for managing linked components
+ */
+/**
+ * Recursively set belongsTo relationship on all nodes in a cloned tree
+ * Maps each cloned node to its corresponding master node
+ */
+export declare const setRecursiveBelongsTo: (clonedNodeId: string, masterNodeId: string, query: any, actions: any, additionalProps?: (clonedNodeId: string, prop: any) => void) => void;
+/**
+ * Check if a node or any of its ancestors is a fully linked component
+ * Returns true if the node belongs to a master component
+ */
+export declare const checkIfAncestorLinked: (nodeId: string, query: any) => boolean;
+/**
+ * Get the linked master node if this node or any ancestor is linked
+ * Returns the node that contains belongsTo info, or null
+ */
+export declare const getLinkedAncestorNode: (nodeId: string, query: any) => any;
+//# sourceMappingURL=componentUtils.d.ts.map

package/dist/utils/component/componentUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"componentUtils.d.ts","sourceRoot":"","sources":["../../../src/utils/component/componentUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAChC,cAAc,MAAM,EACpB,cAAc,MAAM,EACpB,OAAO,GAAG,EACV,SAAS,GAAG,EACZ,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,KAAK,IAAI,SA0B5D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,EAAE,OAAO,GAAG,KAAG,OAalE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,EAAE,OAAO,GAAG,KAAG,GAalE,CAAC"}

package/dist/utils/component/liveComponentRegistry.d.ts

@@ -0,0 +1,5 @@
+export declare function registerLiveComponent(id: string, el: HTMLElement | null): void;
+export declare function getLiveComponent(id: string): HTMLElement | null;
+/** Subscribe to add/remove events for a single container ID. Returns unsub. */
+export declare function subscribeLive(id: string, fn: () => void): () => void;
+//# sourceMappingURL=liveComponentRegistry.d.ts.map

package/dist/utils/component/liveComponentRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"liveComponentRegistry.d.ts","sourceRoot":"","sources":["../../../src/utils/component/liveComponentRegistry.ts"],"names":[],"mappings":"AA8BA,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,GAAG,IAAI,GAAG,IAAI,CAW9E;AAED,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAE/D;AAED,+EAA+E;AAC/E,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAapE"}

package/dist/utils/compressionAsync.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Async lz-utf8 compression/decompression via Web Worker.
+ * Falls back to synchronous on the main thread if Workers are unavailable (SSR, old browsers).
+ */
+/**
+ * Compress a JSON string to base64-encoded lz-utf8.
+ * Uses Web Worker if available, synchronous fallback otherwise.
+ */
+export declare function compressAsync(json: string): Promise<string>;
+/**
+ * Decompress a base64-encoded lz-utf8 string back to the original string.
+ * Uses Web Worker if available, synchronous fallback otherwise.
+ */
+export declare function decompressAsync(compressed: string): Promise<string>;
+/** Terminate the worker (cleanup on unmount). */
+export declare function terminateCompressionWorker(): void;
+//# sourceMappingURL=compressionAsync.d.ts.map

package/dist/utils/compressionAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compressionAsync.d.ts","sourceRoot":"","sources":["../../src/utils/compressionAsync.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA8EH;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAE3D;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEnE;AAED,iDAAiD;AACjD,wBAAgB,0BAA0B,IAAI,IAAI,CAKjD"}

package/dist/utils/conditions/clientScript.d.ts

@@ -0,0 +1,2 @@
+export declare const CONDITION_EVAL_CHUNK: string;
+//# sourceMappingURL=clientScript.d.ts.map

package/dist/utils/conditions/clientScript.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientScript.d.ts","sourceRoot":"","sources":["../../../src/utils/conditions/clientScript.ts"],"names":[],"mappings":"AAwCA,eAAO,MAAM,oBAAoB,QA4I/B,CAAC"}

package/dist/utils/conditions/computedState.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Computed state bindings — derived registry entries declared on a Container.
+ *
+ * A node lists `computedStateBindings: ComputedStateBinding[]` and on every
+ * relevant input-state change, the SDK runs the named compute function and
+ * writes the result to the output state key. Replaces ad-hoc imperative JS
+ * handlers (e.g. the PDP variant chip's 1800-char inline state machine) with
+ * declarative, author-visible primitives.
+ *
+ * Built-in compute types (added per use-case; new types live behind a
+ * discriminated union so the editor can offer a typed picker):
+ *
+ *   - `variant-match`           — matches the current axis selections
+ *                                 against a JSON variant map; emits the
+ *                                 matched variant as JSON, or "" when
+ *                                 incomplete / no match.
+ *   - `variant-axis-availability` — for one axis, emits a comma-separated
+ *                                 list of values whose corresponding
+ *                                 variant would be unavailable given the
+ *                                 currently-selected OTHER axes.
+ *   - `all-truthy`              — emits "on" iff every input key is truthy
+ *                                 (non-null, non-empty); else "".
+ *   - `first-truthy`            — emits the value of the first truthy input
+ *                                 key; "" when all are empty.
+ *   - `join`                    — concatenates input values with a separator.
+ *
+ * Reactivity: Container subscribes to all `from` keys via `useStateValue` and
+ * runs the computer on every change. Results are written with
+ * `lastWriter: "computed"` so the ESC stack skips them and inspector tooling
+ * can distinguish derived from author-written entries.
+ */
+export type ComputedStateCompute = 
+/**
+ * variant-match: read each axis selection from state and emit the matched
+ * variant as JSON. `axes` may be a string array OR a CSV string
+ * (`"Size,Color"`) — the runtime splits CSV. `axisKeyTemplate` builds the
+ * input state key for each axis (e.g. `"pdp:{{item.id}}:axis:%axis%"`,
+ * where `%axis%` is replaced with each axis name). When `axes` /
+ * `axisKeyTemplate` resolve from item context, the binding evaluates per
+ * iteration of the parent repeater.
+ */
+{
+    type: "variant-match";
+    variantMap: string;
+    axes: string[] | string;
+    axisKeyTemplate: string;
+}
+/**
+ * variant-axis-availability: for ONE axis, emit a comma-separated list of
+ * candidate values that have NO in-stock variant given the currently-
+ * selected OTHER axes. Pair with `state contains` operator on each chip's
+ * stateModifiers to gate "unavailable" styling.
+ */
+ | {
+    type: "variant-axis-availability";
+    variantMap: string;
+    axis: string;
+    otherAxes: string[] | string;
+    axisKeyTemplate: string;
+} | {
+    type: "all-truthy";
+} | {
+    type: "first-truthy";
+} | {
+    type: "join";
+    separator?: string;
+};
+export interface ComputedStateBinding {
+    /** Output state key. Anchor tokens supported. Also supports `{{item.X}}`
+     *  for per-iteration outputs. */
+    key: string;
+    /** Input state keys to subscribe to. Anchor + item tokens supported.
+     *  Optional for `variant-match` / `variant-axis-availability` where the
+     *  runtime derives inputs from `axisKeyTemplate` × axes. */
+    from?: string[];
+    /** Computation. Discriminated union — editor picker offers each type. */
+    compute: ComputedStateCompute;
+}
+interface ComputeRunCtx {
+    /** Resolve `{{item.X}}` (and any other) tokens against the current item context. */
+    interp: (raw: string) => string;
+}
+export declare function runComputedState(binding: ComputedStateBinding, ctx: ComputeRunCtx): string;
+/**
+ * Build a stable snapshot string of every input that affects a binding's
+ * output. Container's effect uses this as its dep so we re-run on real input
+ * change instead of every render. Inputs covered:
+ *   - declared `from` keys (after interp)
+ *   - axis state keys for `variant-match` / `variant-axis-availability`
+ *     (derived from `axisKeyTemplate × axes`)
+ *   - the interpolated `variantMap` literal (so swapping products refires)
+ * Cheap: just key=value joins, no JSON.stringify of the binding shape.
+ */
+export declare function computeBindingInputSnapshot(binding: ComputedStateBinding, interp: (raw: string) => string): string;
+export declare function computeBindingsSnapshot(bindings: ComputedStateBinding[] | undefined, interp: (raw: string) => string): string;
+/**
+ * Apply all bindings on a node — read inputs from registry, run computers,
+ * write outputs. Caller is responsible for invoking on every relevant tick.
+ *
+ * `interp` is the SDK's variable-interpolation function (typically the
+ * caller's bound `replaceVariables(_, query, item, anchors)` or a thin
+ * `{{item.X}}` walker). It runs against `binding.key`, every `binding.from`,
+ * and every interpolatable field inside `binding.compute`.
+ */
+export declare function applyComputedStateBindings(bindings: ComputedStateBinding[] | undefined, interp: (raw: string) => string): void;
+export {};
+//# sourceMappingURL=computedState.d.ts.map

package/dist/utils/conditions/computedState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedState.d.ts","sourceRoot":"","sources":["../../../src/utils/conditions/computedState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAIH,MAAM,MAAM,oBAAoB;AAC9B;;;;;;;;GAQG;AACD;IACE,IAAI,EAAE,eAAe,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;CACzB;AACH;;;;;GAKG;GACD;IACE,IAAI,EAAE,2BAA2B,CAAC;IAClC,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;CACzB,GACD;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,GACxB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC,MAAM,WAAW,oBAAoB;IACnC;qCACiC;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ;;gEAE4D;IAC5D,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,yEAAyE;IACzE,OAAO,EAAE,oBAAoB,CAAC;CAC/B;AAuCD,UAAU,aAAa;IACrB,oFAAoF;IACpF,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;CACjC;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,EAAE,aAAa,GAAG,MAAM,CA8E1F;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,oBAAoB,EAC7B,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAC9B,MAAM,CAgCR;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,SAAS,EAC5C,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAC9B,MAAM,CAGR;AAED;;;;;;;;GAQG;AACH,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,oBAAoB,EAAE,GAAG,SAAS,EAC5C,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,GAC9B,IAAI,CASN"}

package/dist/utils/conditions/context.d.ts

@@ -0,0 +1,6 @@
+import { ConditionContext } from './types';
+/** Build a ConditionContext for client-side (viewer/editor) use. */
+export declare function buildClientContext(rootProps: any, item?: Record<string, any> | null, anchors?: Readonly<Record<string, string>> | undefined): ConditionContext;
+/** Build a ConditionContext for static rendering (no window, no live data). */
+export declare function buildStaticContext(rootProps: Record<string, any> | null, item?: Record<string, any> | null, connectorData?: ConditionContext["connectorData"], anchors?: Readonly<Record<string, string>> | undefined): ConditionContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/utils/conditions/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../../src/utils/conditions/context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,oEAAoE;AACpE,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,GAAG,EACd,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAW,EACvC,OAAO,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAqB,GAChE,gBAAgB,CAYlB;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAI,EACrC,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,IAAW,EACvC,aAAa,GAAE,gBAAgB,CAAC,eAAe,CAAQ,EACvD,OAAO,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAAG,SAAqB,GAChE,gBAAgB,CAYlB"}

package/dist/utils/conditions/evaluate.d.ts

@@ -0,0 +1,12 @@
+import { Condition, ConditionContext, ConditionGroup } from './types';
+/**
+ * Evaluate a single condition against a context.
+ * Returns `true` (met), `false` (not met), or `null` (can't evaluate — e.g. URL params in static).
+ */
+export declare function evaluateSingleCondition(cond: Condition, ctx: ConditionContext): boolean | null;
+/**
+ * Evaluate condition groups (OR between groups, AND/OR within each group).
+ * Groups are the Elementor-style "condition group" model.
+ */
+export declare function evaluateConditionGroups(groups: ConditionGroup[], ctx: ConditionContext): boolean | null;
+//# sourceMappingURL=evaluate.d.ts.map

package/dist/utils/conditions/evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate.d.ts","sourceRoot":"","sources":["../../../src/utils/conditions/evaluate.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAChB,cAAc,EAGf,MAAM,SAAS,CAAC;AA+CjB;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,gBAAgB,GAAG,OAAO,GAAG,IAAI,CA8H9F;AA8BD;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,cAAc,EAAE,EACxB,GAAG,EAAE,gBAAgB,GACpB,OAAO,GAAG,IAAI,CAWhB"}

package/dist/utils/conditions/stateBuiltinModifiers.d.ts

@@ -0,0 +1,3 @@
+import { ComponentModifier } from '../../define/types';
+export declare const BUILTIN_STATE_MODIFIERS: Record<string, ComponentModifier[]>;
+//# sourceMappingURL=stateBuiltinModifiers.d.ts.map

package/dist/utils/conditions/stateBuiltinModifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateBuiltinModifiers.d.ts","sourceRoot":"","sources":["../../../src/utils/conditions/stateBuiltinModifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAE5D,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAuFvE,CAAC"}

package/dist/utils/conditions/stateModifiers.d.ts

@@ -0,0 +1,23 @@
+import { ConditionContext, ConditionGroup } from './types';
+export interface StateBinding {
+    conditions: ConditionGroup[];
+    /** Modifier names — looked up against the node's available modifiers. */
+    modifiers: string[];
+}
+/**
+ * Append classes for matching state bindings onto a base className. ONLY
+ * applies on a confirmed `true` evaluation. Indeterminate (`null`) and
+ * `false` are both treated as "don't apply" — opposite of visibility's
+ * graceful-degrade-to-shown, because for STYLING we'd rather render the
+ * baseline than flash active classes before state is written. (e.g. tab
+ * buttons paint inactive on first render until the user clicks one.)
+ *
+ * Modifier lookup reads from a viewer-safe registry (`BUILTIN_STATE_MODIFIERS`)
+ * — the full `BUILTIN_COMPONENT_DEFS` array transitively pulls every
+ * `.craft.tsx` file (and its editor toolbar imports) into the viewer
+ * bundle, which we explicitly want to avoid. Reading `Component.craft.toolbar.modifiers`
+ * also doesn't work outside the editor because viewer routes use
+ * `processForViewer` which never calls `attachCraft`.
+ */
+export declare function applyStateModifiers(className: string, bindings: StateBinding[] | undefined, ctx: ConditionContext, componentName: string, rootProps: any): string;
+//# sourceMappingURL=stateModifiers.d.ts.map

package/dist/utils/conditions/stateModifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateModifiers.d.ts","sourceRoot":"","sources":["../../../src/utils/conditions/stateModifiers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAKH,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEhE,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,cAAc,EAAE,CAAC;IAC7B,yEAAyE;IACzE,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAQD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,YAAY,EAAE,GAAG,SAAS,EACpC,GAAG,EAAE,gBAAgB,EACrB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,GAAG,GACb,MAAM,CAyBR"}