@rebuy/rebuy 3.26.0 → 3.28.0

package/dist/schema/checkout-and-beyond/index.mjs

@@ -1,5 +1,5 @@
 // src/schema/widgets/checkout-and-beyond/banner.ts
-import { z as z20 } from "zod";
+import { z as z21 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/common.ts
 var freezeEnum = (values) => Object.freeze(Object.fromEntries(values.map((v) => [v, v])));
@@ -108,6 +108,8 @@ var languageKeys = [
   "zh"
 ];
 var LanguageKey = freezeEnum(languageKeys);
+var layoutFrames = ["callout", "offer-content"];
+var LayoutFrame = freezeEnum(layoutFrames);
 var mutatorEvents = ["item_added", "quantity_changed", "variant_selected"];
 var MutatorEvent = freezeEnum(mutatorEvents);
 var objectFits = ["cover", "contain"];
@@ -152,6 +154,7 @@ var sectionTypes = [
   "progressBar",
   "quantity",
   "reviews",
+  "separator",
   "text",
   "variants"
 ];
@@ -205,11 +208,11 @@ var widgetTypes = [
 var WidgetType = freezeEnum(widgetTypes);
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
-import { v7 as uuidv712 } from "uuid";
-import { z as z19 } from "zod";
+import { v7 as uuidv713 } from "uuid";
+import { z as z20 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/button.ts
 import { v7 as uuidv73 } from "uuid";
@@ -1358,35 +1361,46 @@ var CABReviewsSection = z16.object({
   name: z16.string().optional(),
   sectionId: z16.uuid().default(() => uuidv710()),
   sectionType: z16.literal(SectionType.reviews).default(SectionType.reviews),
-  size: z16.enum(reviewsSizes).default(ReviewsSize.default)
+  size: z16.enum(reviewsSizes).default(ReviewsSize.default),
+  strokeColor: z16.string().default("#fadb14"),
+  strokeWidth: z16.number().nonnegative().default(0)
 });
 
-// src/schema/widgets/checkout-and-beyond/variants.ts
-import { slice } from "es-toolkit/compat";
+// src/schema/widgets/checkout-and-beyond/separator.ts
 import { v7 as uuidv711 } from "uuid";
 import { z as z17 } from "zod";
-var CABVariantsSection = z17.object({
+var CABSeparatorSection = z17.object({
   ...CABVariableFields,
-  hideOutOfStockVariants: z17.boolean().default(false),
-  name: z17.string().optional(),
   sectionId: z17.uuid().default(() => uuidv711()),
-  sectionType: z17.literal(SectionType.variants).default(SectionType.variants),
-  selector: z17.enum(slice(variantSelectors, 0, 3)).default(VariantSelector.menu),
-  variantMode: z17.enum(variantModes).default(VariantMode.multiple)
+  sectionType: z17.literal(SectionType.separator).default(SectionType.separator)
+});
+
+// src/schema/widgets/checkout-and-beyond/variants.ts
+import { slice } from "es-toolkit/compat";
+import { v7 as uuidv712 } from "uuid";
+import { z as z18 } from "zod";
+var CABVariantsSection = z18.object({
+  ...CABVariableFields,
+  hideOutOfStockVariants: z18.boolean().default(false),
+  name: z18.string().optional(),
+  sectionId: z18.uuid().default(() => uuidv712()),
+  sectionType: z18.literal(SectionType.variants).default(SectionType.variants),
+  selector: z18.enum(slice(variantSelectors, 0, 3)).default(VariantSelector.menu),
+  variantMode: z18.enum(variantModes).default(VariantMode.multiple)
 });
 
 // src/schema/widgets/checkout-and-beyond/shared.ts
-var CABBorder = z18.object({
-  radius: z18.enum(borderRadii).default(BorderRadius.base),
-  style: z18.enum(borderStyles).default(BorderStyle.none),
-  width: z18.enum(borderWidths).default(BorderWidth.base)
+var CABBorder = z19.object({
+  radius: z19.enum(borderRadii).default(BorderRadius.base),
+  style: z19.enum(borderStyles).default(BorderStyle.none),
+  width: z19.enum(borderWidths).default(BorderWidth.base)
 }).default({
   radius: BorderRadius.base,
   style: BorderStyle.none,
   width: BorderWidth.base
 });
-var CABSection = z18.lazy(
-  () => z18.discriminatedUnion("sectionType", [
+var CABSection = z19.lazy(
+  () => z19.discriminatedUnion("sectionType", [
     CABBannerSection,
     CABButtonSection,
     CABCarouselSection,
@@ -1402,46 +1416,57 @@ var CABSection = z18.lazy(
     CABProgressBarSection,
     CABQuantitySection,
     CABReviewsSection,
+    CABSeparatorSection,
     CABTextSection,
     CABVariantsSection
   ])
 );
 
 // src/schema/widgets/checkout-and-beyond/layout.ts
-var GridItem = z19.union([z19.literal("auto"), z19.literal("fill"), z19.string().regex(/^\d+%$/), z19.number()]);
-var CABLayoutSection = z19.object({
+var GridItem = z20.union([z20.literal("auto"), z20.literal("fill"), z20.string().regex(/^\d+%$/), z20.number()]);
+var CABLayoutWrapping = z20.object({
+  breakAt: z20.number().positive(),
+  maxPerLine: z20.number().int().positive()
+});
+var CABLayoutSection = z20.object({
   ...CABVariableFields,
-  alignment: z19.object({
-    horizontal: z19.enum(horizontalAlignments).default(HorizontalAlignment.start),
-    vertical: z19.enum(verticalAlignments).default(VerticalAlignment.top)
+  alignment: z20.object({
+    horizontal: z20.enum(horizontalAlignments).default(HorizontalAlignment.start),
+    vertical: z20.enum(verticalAlignments).default(VerticalAlignment.top)
   }).default({
     horizontal: HorizontalAlignment.start,
     vertical: VerticalAlignment.top
   }),
-  border: z19.lazy(() => CABBorder),
-  buttonField: z19.enum(buttonFields).optional(),
-  direction: z19.enum(directions).default(Direction.rows),
-  grid: z19.object({
-    columns: z19.union([z19.array(GridItem), z19.undefined()]).default(() => ["auto"]),
-    rows: z19.union([z19.array(GridItem), z19.undefined()]).default(() => ["auto"])
+  border: z20.lazy(() => CABBorder),
+  buttonField: z20.enum(buttonFields).optional(),
+  direction: z20.enum(directions).default(Direction.rows),
+  /**
+   * Platform chrome around the section, not a layout behavior: `callout` is a subdued box with block borders
+   * (the legacy post-purchase callout banner), `offer-content` the post-purchase offer's own content card.
+   */
+  frame: z20.enum(layoutFrames).optional(),
+  grid: z20.object({
+    columns: z20.union([z20.array(GridItem), z20.undefined()]).default(() => ["auto"]),
+    rows: z20.union([z20.array(GridItem), z20.undefined()]).default(() => ["auto"])
   }).default({ columns: ["auto"], rows: ["auto"] }).optional(),
-  name: z19.string().optional(),
-  padding: z19.enum(spacings).default(Spacing.none),
-  sectionId: z19.uuid().default(() => uuidv712()),
-  sections: z19.union([z19.array(z19.lazy(() => CABSection)), z19.strictObject({}).transform(() => [])]).default(() => []),
-  sectionType: z19.literal(SectionType.layout).default(SectionType.layout),
-  spacing: z19.enum(spacings).default(Spacing.base),
+  name: z20.string().optional(),
+  padding: z20.enum(spacings).default(Spacing.none),
+  sectionId: z20.uuid().default(() => uuidv713()),
+  sections: z20.union([z20.array(z20.lazy(() => CABSection)), z20.strictObject({}).transform(() => [])]).default(() => []),
+  sectionType: z20.literal(SectionType.layout).default(SectionType.layout),
+  spacing: z20.enum(spacings).default(Spacing.base),
   /** Fire-and-forget impression pixel POSTed once when the section is shown (e.g. a Monetize offer view). */
-  viewUrl: z19.string().optional(),
-  width: z19.number().default(100)
+  viewUrl: z20.string().optional(),
+  width: z20.number().default(100),
+  wrapping: CABLayoutWrapping.optional()
 });
 
 // src/schema/widgets/checkout-and-beyond/banner.ts
-var CABBannerSection = z20.lazy(
+var CABBannerSection = z21.lazy(
   () => CABLayoutSection.omit({ sectionType: true }).extend({
-    buttonField: z20.enum(buttonFields).optional(),
-    color: z20.enum(bannerColors).default("info"),
-    dismissible: z20.boolean().default(true),
+    buttonField: z21.enum(buttonFields).optional(),
+    color: z21.enum(bannerColors).default("info"),
+    dismissible: z21.boolean().default(true),
     /**
      * The `s-banner` heading — localized content (a buyer can see a merchant-composed banner). Absent OR
      * blank ⇒ no heading; the renderer emits no heading slot for `''` rather than an empty one.
@@ -1457,8 +1482,8 @@ var CABBannerSection = z20.lazy(
      * not a 500. Nothing emits `heading` yet; the first converter that maps merchant banner copy into it
      * either strips first or teaches `normalizeTextContent` to strip this field.
      */
-    heading: z20.record(z20.string(), z20.string().refine(checkForHTML, NO_HTML)).optional(),
-    sectionType: z20.literal(SectionType.banner).default(SectionType.banner)
+    heading: z21.record(z21.string(), z21.string().refine(checkForHTML, NO_HTML)).optional(),
+    sectionType: z21.literal(SectionType.banner).default(SectionType.banner)
   })
 );
 
@@ -1695,7 +1720,7 @@ var OFFER_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-import { z as z21 } from "zod";
+import { z as z22 } from "zod";
 
 // src/schema/widgets/checkout-and-beyond/uiLabels.ts
 var UI_LABELS = {
@@ -1715,8 +1740,8 @@ var UI_LABELS = {
 };
 
 // src/schema/widgets/checkout-and-beyond/root.ts
-var localized = (fallback) => z21.record(z21.string(), z21.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
-var CABUILabels = z21.object({
+var localized = (fallback) => z22.record(z22.string(), z22.string()).default(() => ({ ...fallback })).transform((labels) => Object.keys(labels).length > 0 ? labels : { ...fallback });
+var CABUILabels = z22.object({
   currentPage: localized(UI_LABELS.currentPage),
   guest: localized(UI_LABELS.guest),
   loadingOptions: localized(UI_LABELS.loadingOptions),
@@ -1741,37 +1766,37 @@ var CABUILabels = z21.object({
   subscriptionOptions: { ...UI_LABELS.subscriptionOptions },
   updating: { ...UI_LABELS.updating }
 }));
-var TargetArea = z21.object({
-  fill: z21.boolean().optional(),
-  flip: z21.enum(["both", "horizontal", "vertical"]).optional(),
-  icon: z21.string(),
-  label: z21.string(),
-  width: z21.string()
+var TargetArea = z22.object({
+  fill: z22.boolean().optional(),
+  flip: z22.enum(["both", "horizontal", "vertical"]).optional(),
+  icon: z22.string(),
+  label: z22.string(),
+  width: z22.string()
 }).default(targetAreas[EditorMode.checkoutExtension][1]);
-var CABTracking = z21.object({
-  enableAttribution: z21.boolean().nullish().transform((value) => value ?? true),
-  enableSource: z21.boolean().nullish().transform((value) => value ?? true),
-  enableWidget: z21.boolean().nullish().transform((value) => value ?? true)
+var CABTracking = z22.object({
+  enableAttribution: z22.boolean().nullish().transform((value) => value ?? true),
+  enableSource: z22.boolean().nullish().transform((value) => value ?? true),
+  enableWidget: z22.boolean().nullish().transform((value) => value ?? true)
 }).nullish().transform((value) => value ?? { enableAttribution: true, enableSource: true, enableWidget: true });
-var CABExperiment = z21.object({
-  elementId: z21.number(),
-  experimentId: z21.number(),
-  experimentType: z21.string(),
-  selectedId: z21.number()
+var CABExperiment = z22.object({
+  elementId: z22.number(),
+  experimentId: z22.number(),
+  experimentType: z22.string(),
+  selectedId: z22.number()
 });
 var CABRootSection = CABLayoutSection.extend({
-  editorMode: z21.enum(editorModes).default(EditorMode.checkoutExtension),
+  editorMode: z22.enum(editorModes).default(EditorMode.checkoutExtension),
   experiment: CABExperiment.optional(),
   // Same rule as CABTracking above: the v1 converters pass raw legacy `previewMode` through, so a
   // `null` must fall back rather than throw the widget; malformed values still throw.
-  previewMode: z21.boolean().nullish().transform((value) => value ?? false),
-  storeId: z21.number().nullable().default(null),
+  previewMode: z22.boolean().nullish().transform((value) => value ?? false),
+  storeId: z22.number().nullable().default(null),
   targetArea: TargetArea.nullable(),
   tracking: CABTracking,
-  type: z21.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
+  type: z22.enum(widgetTypes).default(WidgetType.ui_extension_content_block),
   uiLabels: CABUILabels,
-  version: z21.literal(2).default(2),
-  widgetId: z21.number().nullable().default(null)
+  version: z22.literal(2).default(2),
+  widgetId: z22.number().nullable().default(null)
 });
 
 // src/schema/widgets/checkout-and-beyond/switchLabels.ts
@@ -1915,6 +1940,7 @@ export {
   CABImageSectionFields,
   CABIntegrations,
   CABLayoutSection,
+  CABLayoutWrapping,
   CABMonetizeAds,
   CABMonetizeSection,
   CABNumberVariable,
@@ -1932,6 +1958,7 @@ export {
   CABRuleset,
   CABRulesetEntry,
   CABSection,
+  CABSeparatorSection,
   CABTextSection,
   CABTextTier,
   CABTextVariable,
@@ -1966,6 +1993,7 @@ export {
   IconTone,
   InlineTextSizeName,
   LanguageKey,
+  LayoutFrame,
   MutatorEvent,
   NO_HTML,
   OFFER_LABELS,
@@ -2044,6 +2072,7 @@ export {
   isTextType,
   isVariantsType,
   languageKeys,
+  layoutFrames,
   mutatorEvents,
   objectFits,
   offersDirections,

package/dist/schema/index.d.ts

@@ -2,7 +2,13 @@ export * from './cabShopConfig';
 export * from './metadata';
 export * from './offerProduct';
 export * from './postPurchaseEligibility';
+export * from './postPurchaseExitPolicy';
 export * from './postPurchaseIdentity';
+export * from './postPurchaseOrderDecision';
+export * from './postPurchasePolicy';
+export * from './postPurchaseSelection';
+export * from './postPurchaseSession';
+export * from './postPurchaseSessionClose';
 export * from './postPurchaseShadow';
 export * from './postPurchaseSkipTrace';
 export * from './product';

package/dist/schema/postPurchaseEligibility.d.ts

@@ -5,8 +5,8 @@ import { z } from 'zod';
  * — that half is Offer/product-specific and stays out of this Slice. Only the skip-reason vocabulary a
  * skip trace records travels with the Decision contract.
  */
-export declare const PostPurchaseSkipReason: z.ZodEnum<{
+export declare const PostPurchaseSkipReasonSchema: z.ZodEnum<{
     empty: "empty";
     "no-eligible-subscription": "no-eligible-subscription";
 }>;
-export type PostPurchaseSkipReason = z.infer<typeof PostPurchaseSkipReason>;
+export type PostPurchaseSkipReason = z.infer<typeof PostPurchaseSkipReasonSchema>;

package/dist/schema/postPurchaseExitPolicy.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+/**
+ * Whether an additional delay applies when the session's client leaves after close, and why — projected
+ * from the admitted purchase's snapshot when one exists, else from the selected Flow. `unavailable` when
+ * neither could be resolved; a failed projection never undoes closure or blocks the purchase it followed.
+ *
+ * Both branches are `.strict()`: a producer that resolved a real delay but mis-set `status` must get a
+ * 4xx, not have `delayMs`/`source` silently stripped down to a bare `{ status: 'unavailable' }`.
+ */
+export declare const ExitPolicySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"unavailable">;
+}, z.core.$strict>, z.ZodObject<{
+    delayMs: z.ZodNumber;
+    source: z.ZodEnum<{
+        admitted: "admitted";
+        "selected-flow": "selected-flow";
+    }>;
+    status: z.ZodLiteral<"available">;
+}, z.core.$strict>], "status">;
+export type ExitPolicy = z.infer<typeof ExitPolicySchema>;

package/dist/schema/postPurchaseIdentity.d.ts

@@ -1,11 +1,14 @@
 import { z } from 'zod';
 export declare const PostPurchaseTimestampSchema: z.ZodNumber;
 export declare const PostPurchaseOrderIdSchema: z.ZodString;
+/** Expects a pre-lowercased domain — Shopify shop slugs are always lowercase, so this doesn't normalize case. */
 export declare const ShopifyDomainSchema: z.ZodString;
 export declare const DecideRequestSchema: z.ZodObject<{
     checkoutToken: z.ZodString;
     shop: z.ZodString;
 }, z.core.$strip>;
+/** Shared with any post-purchase contract that carries the id of the app that opened it. */
+export declare const PostPurchaseAppIdSchema: z.ZodString;
 /** A Decision entry: which Flow and node in its tree, which Split (widgetTraffic share) and Widget won. */
 export declare const DecisionEntrySchema: z.ZodObject<{
     blockId: z.ZodNumber;
@@ -16,3 +19,9 @@ export declare const DecisionEntrySchema: z.ZodObject<{
     widgetId: z.ZodNumber;
     widgetTraffic: z.ZodNumber;
 }, z.core.$strip>;
+export type DecideRequest = z.infer<typeof DecideRequestSchema>;
+export type DecisionEntry = z.infer<typeof DecisionEntrySchema>;
+export type PostPurchaseAppId = z.infer<typeof PostPurchaseAppIdSchema>;
+export type PostPurchaseOrderId = z.infer<typeof PostPurchaseOrderIdSchema>;
+export type PostPurchaseTimestamp = z.infer<typeof PostPurchaseTimestampSchema>;
+export type ShopifyDomain = z.infer<typeof ShopifyDomainSchema>;

package/dist/schema/postPurchaseOrderDecision.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+/** Which side may still write this order's session-decision row: the session that claimed it first, or the release-authority sweep once nothing claims it. */
+export declare const OrderDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    owner: z.ZodLiteral<"session">;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    owner: z.ZodLiteral<"release">;
+    sessionId: z.ZodNull;
+}, z.core.$strip>], "owner">;
+export type OrderDecision = z.infer<typeof OrderDecisionSchema>;

package/dist/schema/postPurchasePolicy.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const HoldSettingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    durationMinutes: z.ZodNumber;
+    enabled: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+    durationMinutes: z.ZodNull;
+    enabled: z.ZodLiteral<false>;
+}, z.core.$strip>], "enabled">;
+/** What the shop and its Flow each configure for the post-purchase hold, before either is applied. */
+export declare const TimingSettingsSchema: z.ZodObject<{
+    flowHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        durationMinutes: z.ZodNumber;
+        enabled: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        durationMinutes: z.ZodNull;
+        enabled: z.ZodLiteral<false>;
+    }, z.core.$strip>], "enabled">;
+    shopHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        durationMinutes: z.ZodNumber;
+        enabled: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        durationMinutes: z.ZodNull;
+        enabled: z.ZodLiteral<false>;
+    }, z.core.$strip>], "enabled">;
+}, z.core.$strip>;
+/**
+ * The hold resolved for one session, captured once and never recomputed: the shop hold overrides the
+ * Flow hold, which overrides the native (order-only) deadline. `sessionDeadline` still takes the earlier
+ * of the estimated native deadline and `startedAt + durationMinutes`, so a configured hold only ever
+ * shortens the window, never extends it past the native estimate.
+ *
+ * The refine below enforces that precedence rather than merely documenting it: `source` and
+ * `durationMinutes` must match whichever hold the shop-over-flow-over-native rule actually selects, so a
+ * snapshot claiming `source: 'flow'` while the shop hold is enabled — or carrying a duration under
+ * `source: 'native'` — can't parse. Since a resolved snapshot is captured once and never recomputed, a
+ * contradictory one would otherwise stay durable for the session's whole lifetime.
+ */
+export declare const SessionPolicySchema: z.ZodObject<{
+    flowHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        durationMinutes: z.ZodNumber;
+        enabled: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        durationMinutes: z.ZodNull;
+        enabled: z.ZodLiteral<false>;
+    }, z.core.$strip>], "enabled">;
+    shopHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        durationMinutes: z.ZodNumber;
+        enabled: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+        durationMinutes: z.ZodNull;
+        enabled: z.ZodLiteral<false>;
+    }, z.core.$strip>], "enabled">;
+    durationMinutes: z.ZodNullable<z.ZodNumber>;
+    source: z.ZodEnum<{
+        shop: "shop";
+        flow: "flow";
+        native: "native";
+    }>;
+}, z.core.$strip>;
+export type HoldSetting = z.infer<typeof HoldSettingSchema>;
+export type TimingSettings = z.infer<typeof TimingSettingsSchema>;
+export type SessionPolicy = z.infer<typeof SessionPolicySchema>;

package/dist/schema/postPurchaseSelection.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+/**
+ * Selection evidence only — a distinct issuer and purpose from Shopify's own post-purchase token or from
+ * purchase admission, so a selection claim can never be replayed as either.
+ */
+export declare const SelectionClaimsSchema: z.ZodObject<{
+    checkoutToken: z.ZodString;
+    shop: z.ZodString;
+    appId: z.ZodString;
+    entry: z.ZodObject<{
+        blockId: z.ZodNumber;
+        blockIndex: z.ZodString;
+        blockParentIndex: z.ZodString;
+        flowId: z.ZodNumber;
+        sectionId: z.ZodNumber;
+        widgetId: z.ZodNumber;
+        widgetTraffic: z.ZodNumber;
+    }, z.core.$strip>;
+    iss: z.ZodLiteral<"rebuy-api">;
+    purpose: z.ZodLiteral<"post-purchase-selection">;
+}, z.core.$strip>;
+/** What starts a session: the checkout identity, plus a selection token carried forward from `shouldRender`. */
+export declare const SessionStartRequestSchema: z.ZodObject<{
+    checkoutToken: z.ZodString;
+    shop: z.ZodString;
+    selectionToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type SelectionClaims = z.infer<typeof SelectionClaimsSchema>;
+export type SessionStartRequest = z.infer<typeof SessionStartRequestSchema>;

package/dist/schema/postPurchaseSession.d.ts

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+/** One checkout's session identity — the Decide identity plus which app opened it. */
+export declare const SessionIdentitySchema: z.ZodObject<{
+    checkoutToken: z.ZodString;
+    shop: z.ZodString;
+    appId: z.ZodString;
+}, z.core.$strip>;
+/** The order this session anchors to, and the source its native-deadline estimate came from. */
+export declare const SessionOrderTimingSchema: z.ZodObject<{
+    nativeDeadline: z.ZodNumber;
+    orderCreatedAt: z.ZodNumber;
+    orderId: z.ZodString;
+    timingSource: z.ZodLiteral<"shopify-order-created-at">;
+}, z.core.$strip>;
+/**
+ * A session once every field that gates rendering — order anchor, entry, policy, deadline — is set. The
+ * three refines enforce the only ordering that makes a session coherent: it can't start before the order
+ * it anchors to was created, its resolved deadline can't sit before the moment it started, and — per the
+ * "only ever shortens the window" invariant `postPurchasePolicy.ts` documents — that deadline can never
+ * exceed the native (order-only) one.
+ */
+export declare const ReadySessionTimingSchema: z.ZodObject<{
+    nativeDeadline: z.ZodNumber;
+    orderCreatedAt: z.ZodNumber;
+    orderId: z.ZodString;
+    timingSource: z.ZodLiteral<"shopify-order-created-at">;
+    deadline: z.ZodNumber;
+    entry: z.ZodObject<{
+        blockId: z.ZodNumber;
+        blockIndex: z.ZodString;
+        blockParentIndex: z.ZodString;
+        flowId: z.ZodNumber;
+        sectionId: z.ZodNumber;
+        widgetId: z.ZodNumber;
+        widgetTraffic: z.ZodNumber;
+    }, z.core.$strip>;
+    policySnapshot: z.ZodObject<{
+        flowHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            durationMinutes: z.ZodNumber;
+            enabled: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+            durationMinutes: z.ZodNull;
+            enabled: z.ZodLiteral<false>;
+        }, z.core.$strip>], "enabled">;
+        shopHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            durationMinutes: z.ZodNumber;
+            enabled: z.ZodLiteral<true>;
+        }, z.core.$strip>, z.ZodObject<{
+            durationMinutes: z.ZodNull;
+            enabled: z.ZodLiteral<false>;
+        }, z.core.$strip>], "enabled">;
+        durationMinutes: z.ZodNullable<z.ZodNumber>;
+        source: z.ZodEnum<{
+            shop: "shop";
+            flow: "flow";
+            native: "native";
+        }>;
+    }, z.core.$strip>;
+    startedAt: z.ZodNumber;
+}, z.core.$strip>;
+/** The `/session/start` response: not purchase admission, just the recorded native timing. */
+export declare const SessionStartResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        phase: z.ZodLiteral<"render">;
+        serverNow: z.ZodNumber;
+        session: z.ZodObject<{
+            nativeDeadline: z.ZodNumber;
+            orderCreatedAt: z.ZodNumber;
+            orderId: z.ZodString;
+            timingSource: z.ZodLiteral<"shopify-order-created-at">;
+            deadline: z.ZodNumber;
+            entry: z.ZodObject<{
+                blockId: z.ZodNumber;
+                blockIndex: z.ZodString;
+                blockParentIndex: z.ZodString;
+                flowId: z.ZodNumber;
+                sectionId: z.ZodNumber;
+                widgetId: z.ZodNumber;
+                widgetTraffic: z.ZodNumber;
+            }, z.core.$strip>;
+            policySnapshot: z.ZodObject<{
+                flowHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    durationMinutes: z.ZodNumber;
+                    enabled: z.ZodLiteral<true>;
+                }, z.core.$strip>, z.ZodObject<{
+                    durationMinutes: z.ZodNull;
+                    enabled: z.ZodLiteral<false>;
+                }, z.core.$strip>], "enabled">;
+                shopHold: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    durationMinutes: z.ZodNumber;
+                    enabled: z.ZodLiteral<true>;
+                }, z.core.$strip>, z.ZodObject<{
+                    durationMinutes: z.ZodNull;
+                    enabled: z.ZodLiteral<false>;
+                }, z.core.$strip>], "enabled">;
+                durationMinutes: z.ZodNullable<z.ZodNumber>;
+                source: z.ZodEnum<{
+                    shop: "shop";
+                    flow: "flow";
+                    native: "native";
+                }>;
+            }, z.core.$strip>;
+            startedAt: z.ZodNumber;
+        }, z.core.$strip>;
+        workflowPhase: z.ZodLiteral<"start">;
+    }, z.core.$strip>;
+    successful: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type ReadySessionTiming = z.infer<typeof ReadySessionTimingSchema>;
+export type SessionIdentity = z.infer<typeof SessionIdentitySchema>;
+export type SessionOrderTiming = z.infer<typeof SessionOrderTimingSchema>;
+export type SessionStartResponse = z.infer<typeof SessionStartResponseSchema>;

package/dist/schema/postPurchaseSessionClose.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/** The durable record of when a session ended — recording closure, never undoing admitted work. */
+export declare const SessionClosureSchema: z.ZodObject<{
+    closedAt: z.ZodNumber;
+    status: z.ZodLiteral<"closed">;
+}, z.core.$strip>;
+/**
+ * `/session/close` needs only the checkout identity that opened the session, not the app id — `.strict()`
+ * so an app id (or any other unknown field) on this public, unauthenticated surface is a 4xx, matching
+ * `SessionStartRequestSchema`, rather than being silently stripped.
+ */
+export declare const SessionCloseRequestSchema: z.ZodObject<{
+    checkoutToken: z.ZodString;
+    shop: z.ZodString;
+}, z.core.$strict>;
+export declare const SessionCloseResponseSchema: z.ZodObject<{
+    data: z.ZodObject<{
+        closedAt: z.ZodNumber;
+        status: z.ZodLiteral<"closed">;
+    }, z.core.$strip>;
+    successful: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type SessionClosure = z.infer<typeof SessionClosureSchema>;
+export type SessionCloseRequest = z.infer<typeof SessionCloseRequestSchema>;
+export type SessionCloseResponse = z.infer<typeof SessionCloseResponseSchema>;