@shoppexio/builder-contracts 0.1.0 → 0.1.2

package/dist/preview-protocol.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preview-protocol.d.ts","sourceRoot":"","sources":["../src/preview-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;kBAYxB,CAAC;AACZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMhC,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;;;kBAM5B,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;kBAMnC,CAAC;AAEZ,eAAO,MAAM,gCAAgC;;kBAIlC,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAK/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,0BAA0B;;;kBAK5B,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;kBAK9B,CAAC;AAEZ,eAAO,MAAM,gCAAgC;;;;kBAMlC,CAAC;AAEZ,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;kBAMrC,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAKhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"preview-protocol.d.ts","sourceRoot":"","sources":["../src/preview-protocol.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;kBAYxB,CAAC;AACZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAMhC,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;;;kBAM5B,CAAC;AAEZ,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;kBAMnC,CAAC;AAEZ,eAAO,MAAM,gCAAgC;;kBAIlC,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;EAA8B,CAAC;AACjE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,sCAAsC;;;;;;kBAKxC,CAAC;AAEZ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAM/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE,eAAO,MAAM,gCAAgC;;;;;;kBAQlC,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;;;;kBAa5B,CAAC;AAEZ,eAAO,MAAM,4BAA4B;;;kBAK9B,CAAC;AAEZ,eAAO,MAAM,gCAAgC;;;;kBAMlC,CAAC;AAEZ,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;kBAMrC,CAAC;AAEZ,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0B5B,CAAC;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;kBAOnB,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,8BAA8B;;;;;;;;;;kBAOhC,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,kCAAkC;;;;;;;;;;kBAOpC,CAAC;AAEZ;;;;GAIG;AACH,eAAO,MAAM,qCAAqC;;;;;;kBAQvC,CAAC;AAEZ,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAUhC,CAAC;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/preview-protocol.js

@@ -39,16 +39,47 @@ export const PreviewRequestReadyMessageSchema = z
     type: z.literal('REQUEST_READY'),
 })
     .strict();
+export const InteractionModeSchema = z.enum(['edit', 'preview']);
+/**
+ * Dashboard tells the runtime which interaction mode is active:
+ *  - "edit" (default) intercepts clicks for selection.
+ *  - "preview" lets the storefront react to clicks/links normally so
+ *    a merchant can test buy-now flows or anchor links.
+ */
+export const PreviewSetInteractionModeMessageSchema = z
+    .object({
+    type: z.literal('SET_INTERACTION_MODE'),
+    mode: InteractionModeSchema,
+})
+    .strict();
 export const PreviewMessageSchema = z.discriminatedUnion('type', [
     PreviewApplyStateMessageSchema,
     PreviewReloadMessageSchema,
     PreviewSelectElementMessageSchema,
     PreviewRequestReadyMessageSchema,
+    PreviewSetInteractionModeMessageSchema,
 ]);
+export const PreviewBootstrapOkResponseSchema = z
+    .object({
+    type: z.literal('BOOTSTRAP_OK'),
+    revision: z.number().int().nonnegative(),
+    shopSlug: z.string().min(1),
+    shopId: z.string().min(1),
+    artifactStale: z.boolean().optional(),
+})
+    .strict();
 export const PreviewReadyResponseSchema = z
     .object({
     type: z.literal('READY'),
     revision: z.number().int().nonnegative(),
+    health: z
+        .object({
+        reactMounted: z.literal(true),
+        builderRuntimeProvider: z.literal(true),
+        protocolVersion: z.literal(2),
+    })
+        .strict()
+        .optional(),
 })
     .strict();
 export const PreviewAppliedResponseSchema = z
@@ -71,9 +102,90 @@ export const PreviewElementClickedResponseSchema = z
     selection: BuilderSelectionSchema,
 })
     .strict();
+export const PreviewErrorResponseSchema = z
+    .object({
+    type: z.literal('PREVIEW_ERROR'),
+    revision: z.number().int().nonnegative().optional(),
+    message: z.string().min(1),
+    stack: z.string().optional(),
+    source: z.enum(['bootstrap', 'error', 'unhandledrejection']).optional(),
+    phase: z.enum(['bootstrap', 'runtime']).optional(),
+    diagnostics: z
+        .object({
+        name: z.string().optional(),
+        filename: z.string().optional(),
+        lineno: z.number().optional(),
+        colno: z.number().optional(),
+        href: z.string().optional(),
+        referrer: z.string().optional(),
+        parentOrigin: z.string().optional(),
+        previewMode: z.string().optional(),
+        userAgent: z.string().optional(),
+        localStorage: z.enum(['available', 'blocked', 'unknown']).optional(),
+        sessionStorage: z.enum(['available', 'blocked', 'unknown']).optional(),
+        historyScrollRestoration: z.enum(['available', 'blocked', 'unknown']).optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+/**
+ * Geometry of a block inside the preview iframe, expressed in the iframe's
+ * own coordinate space (viewport-relative). The dashboard converts these
+ * coordinates to its own overlay layer when positioning the floating
+ * toolbar / drag handle / insert affordances.
+ */
+export const PreviewRectSchema = z
+    .object({
+    top: z.number().finite(),
+    left: z.number().finite(),
+    width: z.number().finite(),
+    height: z.number().finite(),
+})
+    .strict();
+export const PreviewBlockRectResponseSchema = z
+    .object({
+    type: z.literal('BLOCK_RECT'),
+    revision: z.number().int().nonnegative().optional(),
+    blockId: z.string().min(1),
+    rect: PreviewRectSchema.nullable(),
+})
+    .strict();
+/**
+ * Preview reports a gap between two consecutive blocks that the user is
+ * hovering. The dashboard renders a "+" insert affordance there. When
+ * the user moves away from any gap, `index` is null.
+ */
+export const PreviewInserterHoverResponseSchema = z
+    .object({
+    type: z.literal('INSERTER_HOVER'),
+    revision: z.number().int().nonnegative().optional(),
+    index: z.number().int().nonnegative().nullable(),
+    rect: PreviewRectSchema.nullable(),
+})
+    .strict();
+/**
+ * Inline-edit commit. The runtime captures contenteditable text on
+ * blur/Enter and sends the result back to the dashboard, which writes
+ * it to the corresponding block/content path through the store.
+ */
+export const PreviewInlineEditCommitResponseSchema = z
+    .object({
+    type: z.literal('INLINE_EDIT_COMMIT'),
+    revision: z.number().int().nonnegative().optional(),
+    blockId: z.string().min(1),
+    contentPath: z.string().min(1),
+    value: z.string(),
+})
+    .strict();
 export const PreviewResponseSchema = z.discriminatedUnion('type', [
+    PreviewBootstrapOkResponseSchema,
     PreviewReadyResponseSchema,
     PreviewAppliedResponseSchema,
     PreviewApplyFailedResponseSchema,
     PreviewElementClickedResponseSchema,
+    PreviewErrorResponseSchema,
+    PreviewBlockRectResponseSchema,
+    PreviewInserterHoverResponseSchema,
+    PreviewInlineEditCommitResponseSchema,
 ]);

package/dist/preview-session-resolve.d.ts

@@ -0,0 +1,115 @@
+import * as z from 'zod/v4';
+export declare const BuilderPreviewResolveDataSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    shopId: z.ZodString;
+    shopSlug: z.ZodString;
+    themeId: z.ZodString;
+    artifactPrefix: z.ZodString;
+    builderSettings: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        revision: z.ZodNumber;
+        theme: z.ZodObject<{
+            content: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            layout: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    type: z.ZodString;
+                    variant: z.ZodOptional<z.ZodString>;
+                    visible: z.ZodDefault<z.ZodBoolean>;
+                    settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    style_overrides: z.ZodOptional<z.ZodType<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown, z.core.$ZodTypeInternals<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown>>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>>>;
+            style_slots: z.ZodDefault<z.ZodType<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown, z.core.$ZodTypeInternals<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown>>>;
+            pages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                title: z.ZodString;
+                slug: z.ZodString;
+                visible: z.ZodDefault<z.ZodBoolean>;
+                layout: z.ZodDefault<z.ZodObject<{
+                    blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        type: z.ZodString;
+                        variant: z.ZodOptional<z.ZodString>;
+                        visible: z.ZodDefault<z.ZodBoolean>;
+                        settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        style_overrides: z.ZodOptional<z.ZodType<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown, z.core.$ZodTypeInternals<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown>>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>;
+                seo: z.ZodOptional<z.ZodObject<{
+                    title: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>>;
+            terms: z.ZodDefault<z.ZodObject<{
+                termsOfService: z.ZodOptional<z.ZodString>;
+                privacyPolicy: z.ZodOptional<z.ZodString>;
+                refundPolicy: z.ZodOptional<z.ZodString>;
+                imprint: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    artifactStale: z.ZodOptional<z.ZodBoolean>;
+    sourceRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type BuilderPreviewResolveData = z.infer<typeof BuilderPreviewResolveDataSchema>;
+export declare const BuilderPreviewResolveResponseSchema: z.ZodObject<{
+    status: z.ZodNumber;
+    data: z.ZodNullable<z.ZodObject<{
+        sessionId: z.ZodString;
+        shopId: z.ZodString;
+        shopSlug: z.ZodString;
+        themeId: z.ZodString;
+        artifactPrefix: z.ZodString;
+        builderSettings: z.ZodObject<{
+            version: z.ZodLiteral<2>;
+            revision: z.ZodNumber;
+            theme: z.ZodObject<{
+                content: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                layout: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+                    blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        type: z.ZodString;
+                        variant: z.ZodOptional<z.ZodString>;
+                        visible: z.ZodDefault<z.ZodBoolean>;
+                        settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        style_overrides: z.ZodOptional<z.ZodType<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown, z.core.$ZodTypeInternals<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown>>>;
+                    }, z.core.$strict>>>;
+                }, z.core.$strict>>>;
+                style_slots: z.ZodDefault<z.ZodType<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown, z.core.$ZodTypeInternals<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown>>>;
+                pages: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    title: z.ZodString;
+                    slug: z.ZodString;
+                    visible: z.ZodDefault<z.ZodBoolean>;
+                    layout: z.ZodDefault<z.ZodObject<{
+                        blocks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                            id: z.ZodString;
+                            type: z.ZodString;
+                            variant: z.ZodOptional<z.ZodString>;
+                            visible: z.ZodDefault<z.ZodBoolean>;
+                            settings: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            style_overrides: z.ZodOptional<z.ZodType<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown, z.core.$ZodTypeInternals<Partial<Record<import("./style-slots.ts").StyleSlotId, import("./style-slots.ts").StyleSlotValue>>, unknown>>>;
+                        }, z.core.$strict>>>;
+                    }, z.core.$strict>>;
+                    seo: z.ZodOptional<z.ZodObject<{
+                        title: z.ZodOptional<z.ZodString>;
+                        description: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>>;
+                }, z.core.$strict>>>;
+                terms: z.ZodDefault<z.ZodObject<{
+                    termsOfService: z.ZodOptional<z.ZodString>;
+                    privacyPolicy: z.ZodOptional<z.ZodString>;
+                    refundPolicy: z.ZodOptional<z.ZodString>;
+                    imprint: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        artifactStale: z.ZodOptional<z.ZodBoolean>;
+        sourceRevision: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type BuilderPreviewResolveResponse = z.infer<typeof BuilderPreviewResolveResponseSchema>;
+export declare function parseBuilderPreviewResolveResponse(value: unknown): BuilderPreviewResolveResponse | null;
+//# sourceMappingURL=preview-session-resolve.d.ts.map

package/dist/preview-session-resolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-session-resolve.d.ts","sourceRoot":"","sources":["../src/preview-session-resolve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAWjC,CAAC;AAEZ,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAExF,eAAO,MAAM,mCAAmC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtC,CAAC;AAEX,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mCAAmC,CAAC,CAAC;AAEhG,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,OAAO,GACb,6BAA6B,GAAG,IAAI,CAGtC"}

package/dist/preview-session-resolve.js

@@ -0,0 +1,25 @@
+import * as z from 'zod/v4';
+import { BuilderSettingsSchema } from "./builder-settings.js";
+export const BuilderPreviewResolveDataSchema = z
+    .object({
+    sessionId: z.string().min(1),
+    shopId: z.string().min(1),
+    shopSlug: z.string().min(1),
+    themeId: z.string().min(1),
+    artifactPrefix: z.string().min(1),
+    builderSettings: BuilderSettingsSchema,
+    artifactStale: z.boolean().optional(),
+    sourceRevision: z.string().nullable().optional(),
+})
+    .strict();
+export const BuilderPreviewResolveResponseSchema = z
+    .object({
+    status: z.number(),
+    data: BuilderPreviewResolveDataSchema.nullable(),
+    error: z.string().nullable().optional(),
+})
+    .strip();
+export function parseBuilderPreviewResolveResponse(value) {
+    const parsed = BuilderPreviewResolveResponseSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}

package/dist/preview-trusted-origins.d.ts

@@ -0,0 +1,4 @@
+export declare const TRUSTED_PREVIEW_PARENT_ORIGINS: readonly ["https://app.shoppex.io", "https://dashboard.shoppex.io", "https://dashboard.shoppex.test", "https://shoppex-dashboard.vercel.app", "http://localhost:3000", "http://127.0.0.1:3000"];
+export type TrustedPreviewParentOrigin = (typeof TRUSTED_PREVIEW_PARENT_ORIGINS)[number];
+export declare function isTrustedPreviewParentOrigin(origin: string): boolean;
+//# sourceMappingURL=preview-trusted-origins.d.ts.map

package/dist/preview-trusted-origins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-trusted-origins.d.ts","sourceRoot":"","sources":["../src/preview-trusted-origins.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,8BAA8B,iMAOjC,CAAC;AAEX,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEzF,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAuBpE"}

package/dist/preview-trusted-origins.js

@@ -0,0 +1,28 @@
+export const TRUSTED_PREVIEW_PARENT_ORIGINS = [
+    'https://app.shoppex.io',
+    'https://dashboard.shoppex.io',
+    'https://dashboard.shoppex.test',
+    'https://shoppex-dashboard.vercel.app',
+    'http://localhost:3000',
+    'http://127.0.0.1:3000',
+];
+export function isTrustedPreviewParentOrigin(origin) {
+    if (TRUSTED_PREVIEW_PARENT_ORIGINS.includes(origin)) {
+        return true;
+    }
+    try {
+        const url = new URL(origin);
+        const hostname = url.hostname.toLowerCase();
+        const isHttp = url.protocol === 'http:' || url.protocol === 'https:';
+        return (isHttp
+            && (hostname === 'dashboard.shoppex.test'
+                || hostname === 'localhost'
+                || hostname === '127.0.0.1'
+                || hostname === '::1'
+                || hostname === '[::1]'
+                || hostname.endsWith('.localhost')));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/storefront-initial-data-html.d.ts

@@ -0,0 +1,17 @@
+import type { PreviewBootPayload } from './preview-boot.ts';
+export declare const HTML_INITIAL_BLOCK_PATTERN: RegExp;
+export declare const LEGACY_HTML_INITIAL_PATTERN: RegExp;
+export type InitialDataScriptMatch = {
+    json: string;
+};
+export declare function stripAllInitialDataScripts(html: string): string;
+export declare function findInitialDataScriptJson(html: string): InitialDataScriptMatch | null;
+export declare function findInitialDataPayload(html: string): Record<string, unknown> | null;
+export declare function countInitialDataScripts(html: string): number;
+export declare function buildPlainInitialDataScript(initialData: Record<string, unknown>): string;
+export declare function buildWrappedStorefrontInitialDataScript(serialized: string, deployedThemeEntryPathPattern: RegExp): string;
+export declare function injectPlainInitialDataBeforeHeadClose(html: string, script: string): string;
+export declare function injectPreviewInitialData(html: string, payload: PreviewBootPayload): string;
+export declare function assertSingleInitialDataScript(html: string, expectedSlug: string): void;
+export declare function safeJson(value: unknown): string;
+//# sourceMappingURL=storefront-initial-data-html.d.ts.map

package/dist/storefront-initial-data-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storefront-initial-data-html.d.ts","sourceRoot":"","sources":["../src/storefront-initial-data-html.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAG5D,eAAO,MAAM,0BAA0B,QAC8K,CAAC;AAEtN,eAAO,MAAM,2BAA2B,QACuB,CAAC;AAOhE,MAAM,MAAM,sBAAsB,GAAG;IACnC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/D;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,sBAAsB,GAAG,IAAI,CAYrF;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAWnF;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK5D;AAED,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAExF;AAED,wBAAgB,uCAAuC,CACrD,UAAU,EAAE,MAAM,EAClB,6BAA6B,EAAE,MAAM,GACpC,MAAM,CAOR;AAED,wBAAgB,qCAAqC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK1F;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,MAAM,CAK1F;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAmBtF;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE/C"}

package/dist/storefront-initial-data-html.js

@@ -0,0 +1,83 @@
+import { mergePreviewBootIntoInitialData } from "./preview-boot.js";
+export const HTML_INITIAL_BLOCK_PATTERN = /<!--shoppex-initial-data:start--><script>\(function\(\)\{[\s\S]*?window\.__SHOPPEX_INITIAL__=([\s\S]*?)(?=;\}\)\(\);<\/script><!--shoppex-initial-data:end-->);\}\)\(\);<\/script><!--shoppex-initial-data:end-->/;
+export const LEGACY_HTML_INITIAL_PATTERN = /<script>\s*window\.__SHOPPEX_INITIAL__=([\s\S]*?)<\/script>/;
+const HTML_INITIAL_BLOCK_GLOBAL_PATTERN = new RegExp(HTML_INITIAL_BLOCK_PATTERN.source, 'g');
+const LEGACY_HTML_INITIAL_GLOBAL_PATTERN = new RegExp(LEGACY_HTML_INITIAL_PATTERN.source, 'g');
+const CLOSING_HEAD_PATTERN = /<\/head>/i;
+export function stripAllInitialDataScripts(html) {
+    return html
+        .replace(HTML_INITIAL_BLOCK_GLOBAL_PATTERN, '')
+        .replace(LEGACY_HTML_INITIAL_GLOBAL_PATTERN, '');
+}
+export function findInitialDataScriptJson(html) {
+    const blockMatch = html.match(HTML_INITIAL_BLOCK_PATTERN);
+    if (blockMatch?.[1]) {
+        return { json: blockMatch[1] };
+    }
+    const legacyMatch = html.match(LEGACY_HTML_INITIAL_PATTERN);
+    if (legacyMatch?.[1]) {
+        return { json: legacyMatch[1] };
+    }
+    return null;
+}
+export function findInitialDataPayload(html) {
+    const match = findInitialDataScriptJson(html);
+    if (!match) {
+        return null;
+    }
+    try {
+        return JSON.parse(match.json.replace(/;\s*$/, ''));
+    }
+    catch {
+        return null;
+    }
+}
+export function countInitialDataScripts(html) {
+    const blockMatches = html.match(HTML_INITIAL_BLOCK_GLOBAL_PATTERN)?.length ?? 0;
+    const stripped = html.replace(HTML_INITIAL_BLOCK_GLOBAL_PATTERN, '');
+    const legacyMatches = stripped.match(LEGACY_HTML_INITIAL_GLOBAL_PATTERN)?.length ?? 0;
+    return blockMatches + legacyMatches;
+}
+export function buildPlainInitialDataScript(initialData) {
+    return `<script>window.__SHOPPEX_INITIAL__=${safeJson(initialData)};</script>`;
+}
+export function buildWrappedStorefrontInitialDataScript(serialized, deployedThemeEntryPathPattern) {
+    return [
+        '<!--shoppex-initial-data:start--><script>(function(){',
+        'if(typeof window!=="undefined"){var path=window.location.pathname||"";',
+        `if(${deployedThemeEntryPathPattern}.test(path)){window.__SHOPPEX_DEPLOYED_THEME_ARTIFACT_PATH__=path;window.history.replaceState(window.history.state,"","/"+window.location.search+window.location.hash);}}`,
+        `window.__SHOPPEX_INITIAL__=${serialized};})();</script><!--shoppex-initial-data:end-->`,
+    ].join('');
+}
+export function injectPlainInitialDataBeforeHeadClose(html, script) {
+    if (CLOSING_HEAD_PATTERN.test(html)) {
+        return html.replace(CLOSING_HEAD_PATTERN, `${script}\n</head>`);
+    }
+    return `${script}\n${html}`;
+}
+export function injectPreviewInitialData(html, payload) {
+    const withoutScripts = stripAllInitialDataScripts(html);
+    const initialData = mergePreviewBootIntoInitialData(payload);
+    const script = buildPlainInitialDataScript(initialData);
+    return injectPlainInitialDataBeforeHeadClose(withoutScripts, script);
+}
+export function assertSingleInitialDataScript(html, expectedSlug) {
+    const count = countInitialDataScripts(html);
+    if (count !== 1) {
+        throw new Error(`Expected exactly one initial-data script, found ${count}`);
+    }
+    const payload = findInitialDataPayload(html);
+    const store = payload?.store;
+    const slug = typeof store === 'object' && store !== null && !Array.isArray(store)
+        ? store.slug
+        : null;
+    if (typeof slug !== 'string' || slug.trim().length === 0) {
+        throw new Error('Initial-data script is missing store.slug');
+    }
+    if (slug.trim() !== expectedSlug) {
+        throw new Error(`Initial-data slug mismatch: expected ${expectedSlug}, got ${slug}`);
+    }
+}
+export function safeJson(value) {
+    return JSON.stringify(value).replace(/</g, '\\u003c');
+}

package/dist/storefront-typography-fonts.d.ts

@@ -0,0 +1,18 @@
+export type StorefrontCuratedFont = {
+    value: string;
+    label: string;
+    stack: string;
+};
+export declare const STOREFRONT_SYSTEM_FONTS: Set<string>;
+export declare const STOREFRONT_CURATED_FONTS: StorefrontCuratedFont[];
+export declare function resolvePrimaryFontFamilyName(raw: unknown): string | null;
+export declare function resolveCuratedFontValue(raw: unknown, fallback: string): string;
+export declare function curatedFontOptionsForValue(value: string): StorefrontCuratedFont[];
+export declare function findStorefrontCuratedFont(value: string): StorefrontCuratedFont | undefined;
+export declare function isValidGoogleFontFamily(value: unknown): value is string;
+export declare function buildStorefrontGoogleFontHref(family: string): string;
+export declare function getStorefrontGoogleFontHrefs(input: {
+    bodyFont?: unknown;
+    headingFont?: unknown;
+}): string[];
+//# sourceMappingURL=storefront-typography-fonts.d.ts.map

package/dist/storefront-typography-fonts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storefront-typography-fonts.d.ts","sourceRoot":"","sources":["../src/storefront-typography-fonts.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,eAAO,MAAM,uBAAuB,aAA6C,CAAC;AAElF,eAAO,MAAM,wBAAwB,EAAE,qBAAqB,EAwB3D,CAAC;AAIF,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAoBxE;AAED,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,qBAAqB,EAAE,CAajF;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS,CAE1F;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAIvE;AAED,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGpE;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE;IAClD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GAAG,MAAM,EAAE,CAYX"}

package/dist/storefront-typography-fonts.js

@@ -0,0 +1,89 @@
+export const STOREFRONT_SYSTEM_FONTS = new Set(['Arial', 'Georgia', 'System UI']);
+export const STOREFRONT_CURATED_FONTS = [
+    { value: 'Inter', label: 'Inter', stack: 'Inter, system-ui, sans-serif' },
+    { value: 'Geist', label: 'Geist', stack: 'Geist, system-ui, sans-serif' },
+    { value: 'Manrope', label: 'Manrope', stack: 'Manrope, system-ui, sans-serif' },
+    {
+        value: 'Plus Jakarta Sans',
+        label: 'Plus Jakarta Sans',
+        stack: '"Plus Jakarta Sans", system-ui, sans-serif',
+    },
+    { value: 'DM Sans', label: 'DM Sans', stack: '"DM Sans", system-ui, sans-serif' },
+    {
+        value: 'Space Grotesk',
+        label: 'Space Grotesk',
+        stack: '"Space Grotesk", system-ui, sans-serif',
+    },
+    { value: 'Sora', label: 'Sora', stack: 'Sora, system-ui, sans-serif' },
+    {
+        value: 'IBM Plex Sans',
+        label: 'IBM Plex Sans',
+        stack: '"IBM Plex Sans", system-ui, sans-serif',
+    },
+    { value: 'Arial', label: 'Arial', stack: 'Arial, sans-serif' },
+    { value: 'Georgia', label: 'Georgia', stack: 'Georgia, serif' },
+    { value: 'System UI', label: 'System UI', stack: 'system-ui, sans-serif' },
+];
+const GOOGLE_FONT_FAMILY_PATTERN = /^[A-Za-z0-9 +\-_]+$/;
+export function resolvePrimaryFontFamilyName(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return null;
+    const exact = STOREFRONT_CURATED_FONTS.find((font) => font.value === trimmed || font.stack === trimmed);
+    if (exact)
+        return exact.value;
+    const prefix = STOREFRONT_CURATED_FONTS.find((font) => trimmed.startsWith(`${font.value},`));
+    if (prefix)
+        return prefix.value;
+    const quoted = trimmed.match(/^["'](.+?)["']/);
+    if (quoted?.[1]) {
+        return quoted[1].trim() || null;
+    }
+    const primary = trimmed.split(',')[0]?.trim();
+    return primary && primary.length > 0 ? primary : null;
+}
+export function resolveCuratedFontValue(raw, fallback) {
+    return resolvePrimaryFontFamilyName(raw) ?? fallback;
+}
+export function curatedFontOptionsForValue(value) {
+    if (STOREFRONT_CURATED_FONTS.some((font) => font.value === value)) {
+        return STOREFRONT_CURATED_FONTS;
+    }
+    return [
+        ...STOREFRONT_CURATED_FONTS,
+        {
+            value,
+            label: value,
+            stack: value.includes(',') ? value : `${value}, system-ui, sans-serif`,
+        },
+    ];
+}
+export function findStorefrontCuratedFont(value) {
+    return curatedFontOptionsForValue(value).find((font) => font.value === value);
+}
+export function isValidGoogleFontFamily(value) {
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    return trimmed.length > 0 && trimmed.length <= 60 && GOOGLE_FONT_FAMILY_PATTERN.test(trimmed);
+}
+export function buildStorefrontGoogleFontHref(family) {
+    const familyParam = family.trim().replace(/\s+/g, '+');
+    return `https://fonts.googleapis.com/css2?family=${familyParam}:wght@400;500;600;700&display=swap`;
+}
+export function getStorefrontGoogleFontHrefs(input) {
+    const families = new Set();
+    for (const raw of [input.bodyFont, input.headingFont]) {
+        const family = resolvePrimaryFontFamilyName(raw);
+        if (!family)
+            continue;
+        if (STOREFRONT_SYSTEM_FONTS.has(family))
+            continue;
+        if (!isValidGoogleFontFamily(family))
+            continue;
+        families.add(family);
+    }
+    return [...families].map((family) => buildStorefrontGoogleFontHref(family));
+}