@replohq/sdk 2.5.0 → 2.7.0

package/cart/checkout-session-actions.d.ts

@@ -0,0 +1,20 @@
+import type { AddCrossSellOutcome, CheckoutAddress, CheckoutUpdateOutcome } from "../gateways/canopy-api";
+/**
+ * Re-quotes an embedded Stripe checkout's shipping for the buyer's address.
+ * Called by `<StripePaymentForm />`; the project comes from the site's own
+ * config, never the browser.
+ */
+export declare function updateCheckoutShippingAction(input: {
+    sessionId: string;
+    address: CheckoutAddress;
+}): Promise<CheckoutUpdateOutcome>;
+/**
+ * Adds one unit of an offered product to an embedded Stripe checkout and
+ * re-quotes its shipping for the new cart, for the address shipping was last
+ * quoted for. Returns what to offer next. Called by
+ * `useCheckoutSession().addCrossSell`.
+ */
+export declare function addCrossSellAction(input: {
+    sessionId: string;
+    variantId: string;
+}): Promise<AddCrossSellOutcome>;

package/cart/checkout-session-actions.js

@@ -0,0 +1,12 @@
+"use server";
+import { getCanopyApiGateway } from "../gateways/canopy-api";
+async function updateCheckoutShippingAction(input) {
+  return await (await getCanopyApiGateway()).updateCheckoutShipping(input);
+}
+async function addCrossSellAction(input) {
+  return await (await getCanopyApiGateway()).addCrossSell(input);
+}
+export {
+  addCrossSellAction,
+  updateCheckoutShippingAction
+};

package/cart/checkout.d.ts

@@ -0,0 +1,110 @@
+import React from "react";
+/** One line of the order, with Stripe's preformatted amounts. */
+export interface CheckoutLineItem {
+    id: string;
+    name: string;
+    quantity: number;
+    imageUrl: string | null;
+    /** Line total, e.g. "$58.00". */
+    total: string;
+}
+/**
+ * The live order behind the form. Amounts are formatted by Stripe in the
+ * session's currency and follow every shipping re-quote and promo code.
+ */
+export interface CheckoutSummary {
+    /** ISO code, e.g. "USD". */
+    currencyCode: string;
+    lineItems: CheckoutLineItem[];
+    subtotal: string;
+    discount: {
+        amount: string;
+        name: string;
+        code: string | null;
+    } | null;
+    /** Null when nothing in the order ships. */
+    shipping: {
+        name: string | null;
+        amount: string;
+        /** e.g. "3–5 business days". */
+        deliveryEstimate: string | null;
+        /**
+         * False until the buyer completes an address: Stripe prices the first
+         * option up front, and the cost can change once the address is quoted.
+         */
+        isQuoted: boolean;
+    } | null;
+    tax: {
+        status: "ready";
+        amount: string;
+    } | {
+        status: "pending";
+    };
+    total: string;
+}
+/** A product offered in the summary, with its price formatted. */
+export interface CheckoutCrossSell {
+    variantId: string;
+    title: string;
+    imageUrl: string | null;
+    /** e.g. "$38.00". */
+    price: string;
+}
+/**
+ * What `useCheckoutSession()` returns. `retry` opens a fresh checkout from
+ * the cart, which also recovers an expired or already-paid session.
+ */
+export type CheckoutState = {
+    status: "loading";
+} | {
+    status: "empty";
+} | {
+    status: "error";
+    message: string;
+    retry: () => void;
+} | {
+    status: "ready";
+    summary: CheckoutSummary;
+    /** True while the shipping cost is being re-quoted for a new address. */
+    isQuotingShipping: boolean;
+    /** Why the last address, add or payment didn't go through, for the buyer. */
+    message: string | null;
+    /** Up to three products to add, none already in the order. */
+    crossSells: CheckoutCrossSell[];
+    /**
+     * Adds one of `crossSells` to the order and re-quotes shipping for it;
+     * the summary and Stripe's form update when it lands. Does nothing
+     * while shipping is being re-quoted or another item is being added.
+     */
+    addCrossSell: (variantId: string) => Promise<void>;
+    /** The cross-sell being added, while it is. */
+    addingCrossSellVariantId: string | null;
+};
+/** The live checkout session, inside `<CheckoutSessionProvider>`. */
+export declare function useCheckoutSession(): CheckoutState;
+/**
+ * Loads the checkout session `createCheckoutSessionAction` opened and shares
+ * it with `<StripePaymentForm />` and `useCheckoutSession()` below it. The
+ * form takes its colors, corner radius and font from the site's design tokens
+ * (`--primary`, `--background`, `--foreground`, `--border`, `--radius`, ...).
+ *
+ * @example
+ *
+ * ```tsx
+ * <CheckoutSessionProvider startCheckoutPath="/checkout">
+ *   <OrderSummary />
+ *   <StripePaymentForm />
+ * </CheckoutSessionProvider>
+ * ```
+ */
+export declare function CheckoutSessionProvider({ startCheckoutPath, children, }: React.PropsWithChildren<{
+    /** The route that starts checkout from the cart (usually "/checkout"); Retry opens it. */
+    startCheckoutPath: string;
+}>): import("react/jsx-runtime").JSX.Element;
+/**
+ * Stripe's contact, shipping-address and payment form, inside
+ * `<CheckoutSessionProvider>`. Each completed address is re-quoted on the
+ * server, so print-on-demand items show their real shipping cost before the
+ * buyer pays. Renders nothing until the session has loaded.
+ */
+export declare function StripePaymentForm(): import("react/jsx-runtime").JSX.Element | null;

package/cart/checkout.js

@@ -0,0 +1,420 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import React from "react";
+import {
+  CheckoutForm,
+  CheckoutFormProvider,
+  useCheckoutForm
+} from "@stripe/react-stripe-js/checkout";
+import { loadStripe } from "@stripe/stripe-js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { parseJsonOrNull } from "../_vendor/replo-utils/lib/json.mjs";
+import * as v from "valibot";
+import { CanopyError } from "../lib/canopy-error";
+import { formatAmount } from "../money";
+import { getCrossSellsAction } from "./checkout-actions";
+import { readSiteCheckoutAppearance } from "./checkout-appearance";
+import {
+  addCrossSellAction,
+  updateCheckoutShippingAction
+} from "./checkout-session-actions";
+class CheckoutUpdateRejectedError extends CanopyError {
+}
+const checkoutConfigSchema = v.object({
+  clientSecret: v.pipe(v.string(), v.nonEmpty()),
+  publishableKey: v.pipe(v.string(), v.nonEmpty()),
+  stripeAccountId: v.pipe(v.string(), v.nonEmpty()),
+  hasLiveShipping: v.pipe(
+    v.nullable(v.string()),
+    v.transform((value) => value === "1")
+  )
+});
+const quotedAddressSchema = v.object({
+  sessionId: v.string(),
+  address: v.object({
+    country: v.string(),
+    line1: v.string(),
+    line2: v.nullable(v.string()),
+    city: v.nullable(v.string()),
+    state: v.nullable(v.string()),
+    postalCode: v.nullable(v.string())
+  })
+});
+const CONFIG_STORAGE_KEY = "replo-checkout";
+const QUOTED_ADDRESS_STORAGE_KEY = "replo-checkout-quoted-address";
+function readStorage(key) {
+  try {
+    return sessionStorage.getItem(key);
+  } catch (error) {
+    console.warn("[Replo] Session storage is unavailable", error);
+    return null;
+  }
+}
+function writeStorage(key, value) {
+  try {
+    if (value === null) {
+      sessionStorage.removeItem(key);
+    } else {
+      sessionStorage.setItem(key, value);
+    }
+  } catch (error) {
+    console.warn("[Replo] Session storage is unavailable", error);
+  }
+}
+function readQuotedAddress(sessionId) {
+  const stored = v.safeParse(
+    quotedAddressSchema,
+    parseJsonOrNull(readStorage(QUOTED_ADDRESS_STORAGE_KEY) ?? "")
+  );
+  return stored.success && stored.output.sessionId === sessionId ? stored.output.address : null;
+}
+function readCheckoutConfig() {
+  const fragment = window.location.hash.slice(1);
+  const isEmpty = new URLSearchParams(fragment).get("empty") === "1";
+  if (isEmpty) {
+    writeStorage(CONFIG_STORAGE_KEY, null);
+  } else if (fragment) {
+    writeStorage(CONFIG_STORAGE_KEY, fragment);
+  }
+  if (fragment) {
+    window.history.replaceState(
+      window.history.state,
+      "",
+      window.location.pathname + window.location.search
+    );
+  }
+  if (isEmpty) {
+    return "empty";
+  }
+  const params = new URLSearchParams(
+    fragment || (readStorage(CONFIG_STORAGE_KEY) ?? "")
+  );
+  const parsed = v.safeParse(checkoutConfigSchema, {
+    clientSecret: params.get("clientSecret"),
+    publishableKey: params.get("publishableKey"),
+    stripeAccountId: params.get("stripeAccountId"),
+    hasLiveShipping: params.get("hasLiveShipping")
+  });
+  return parsed.success ? parsed.output : "missing";
+}
+let loadedCheckout = null;
+function getLoadedCheckout() {
+  const fragment = window.location.hash;
+  if (!loadedCheckout || fragment && fragment !== loadedCheckout.fragment) {
+    const config = readCheckoutConfig();
+    loadedCheckout = {
+      fragment,
+      value: {
+        config,
+        stripe: typeof config === "string" ? null : loadStripe(config.publishableKey, {
+          stripeAccount: config.stripeAccountId
+        }),
+        ...readSiteCheckoutAppearance()
+      }
+    };
+  }
+  return loadedCheckout.value;
+}
+function subscribeToNothing() {
+  return () => void 0;
+}
+const CARD_ONLY_FORM_OPTIONS = {
+  expressCheckout: {
+    paymentMethods: {
+      applePay: "never",
+      googlePay: "never",
+      link: "never",
+      amazonPay: "never",
+      paypal: "never",
+      klarna: "never"
+    }
+  }
+};
+const CheckoutSessionContext = React.createContext({ state: { status: "loading" }, form: null });
+function useCheckoutSession() {
+  return React.useContext(CheckoutSessionContext).state;
+}
+function formatEstimate(estimate) {
+  const minimum = estimate?.minimum ?? null;
+  const maximum = estimate?.maximum ?? null;
+  const unit = maximum?.unit ?? minimum?.unit;
+  if (!unit) {
+    return null;
+  }
+  const label = unit === "business_day" ? "business day" : unit;
+  const range = minimum && maximum && minimum.value !== maximum.value ? `${minimum.value}\u2013${maximum.value}` : String(maximum?.value ?? minimum?.value);
+  const plural = (maximum?.value ?? minimum?.value) === 1 ? "" : "s";
+  return `${range} ${label}${plural}`;
+}
+function toSummary(session, isQuoted) {
+  const discount = session.discountAmounts?.[0] ?? null;
+  const shippingOption = session.shipping?.shippingOption ?? null;
+  return {
+    currencyCode: session.currency.toUpperCase(),
+    lineItems: session.lineItems.map((lineItem) => ({
+      id: lineItem.id,
+      name: lineItem.name,
+      quantity: lineItem.quantity,
+      imageUrl: lineItem.images[0] ?? null,
+      total: lineItem.subtotal.amount
+    })),
+    subtotal: session.total.subtotal.amount,
+    discount: session.total.discount.minorUnitsAmount > 0 ? {
+      amount: `-${session.total.discount.amount}`,
+      name: discount?.displayName ?? "Discount",
+      code: discount?.promotionCode ?? null
+    } : null,
+    shipping: shippingOption ? {
+      name: shippingOption.displayName,
+      amount: session.total.shippingRate.amount,
+      deliveryEstimate: formatEstimate(shippingOption.deliveryEstimate),
+      isQuoted
+    } : null,
+    tax: session.tax.status === "ready" ? { status: "ready", amount: session.total.taxExclusive.amount } : { status: "pending" },
+    total: session.total.total.amount
+  };
+}
+function CheckoutSessionBridge({
+  sessionId,
+  hasLiveShipping,
+  retry,
+  children
+}) {
+  const checkoutState = useCheckoutForm();
+  const queryClient = useQueryClient();
+  const checkout = checkoutState.type === "success" ? checkoutState.checkout : null;
+  const [quotedAddress, setQuotedAddress] = React.useState(() => {
+    return readQuotedAddress(sessionId);
+  });
+  const [formAddress, setFormAddress] = React.useState(quotedAddress);
+  const [message, setMessage] = React.useState(null);
+  const crossSellsQueryKey = ["replo-checkout-cross-sells", sessionId];
+  const { data: crossSellProducts } = useQuery({
+    queryKey: crossSellsQueryKey,
+    queryFn: () => {
+      return getCrossSellsAction({ sessionId, excludeVariantIds: [] });
+    },
+    enabled: checkout !== null,
+    staleTime: Number.POSITIVE_INFINITY
+  });
+  const runServerUpdate = async (update) => {
+    if (!checkout) {
+      throw new CheckoutUpdateRejectedError({
+        message: "Checkout isn't ready"
+      });
+    }
+    const response = {
+      accepted: null,
+      rejection: null
+    };
+    const result = await checkout.runServerUpdate(async () => {
+      const outcome = await update();
+      if (outcome.type === "reject") {
+        response.rejection = outcome.message;
+        throw new CheckoutUpdateRejectedError({ message: outcome.message });
+      }
+      response.accepted = outcome;
+      return outcome;
+    });
+    if (result.type === "error") {
+      throw new CheckoutUpdateRejectedError({
+        message: response.rejection ?? result.error.message
+      });
+    }
+    if (!response.accepted) {
+      throw new CheckoutUpdateRejectedError({
+        message: "Checkout didn't update"
+      });
+    }
+    return response.accepted;
+  };
+  const shippingQuote = useMutation({
+    mutationFn: async (address) => {
+      return await runServerUpdate(() => {
+        return updateCheckoutShippingAction({ sessionId, address });
+      });
+    },
+    onSuccess: (_outcome, address) => {
+      setQuotedAddress(address);
+      writeStorage(
+        QUOTED_ADDRESS_STORAGE_KEY,
+        JSON.stringify({ sessionId, address })
+      );
+      setMessage(null);
+    },
+    onError: (error) => setMessage(error.message)
+  });
+  const crossSellAdd = useMutation({
+    mutationFn: async (variantId) => {
+      return await runServerUpdate(() => {
+        return addCrossSellAction({ sessionId, variantId });
+      });
+    },
+    onSuccess: (outcome) => {
+      queryClient.setQueryData(crossSellsQueryKey, outcome.products);
+      setMessage(null);
+    },
+    onError: (error) => setMessage(error.message)
+  });
+  const handleChange = async (event) => {
+    const address = event.value.shippingAddress?.address;
+    const country = address?.country;
+    const line1 = address?.line1;
+    const shippingAddress = country && line1 ? {
+      country: country.toUpperCase(),
+      line1,
+      line2: address.line2 || null,
+      city: address.city || null,
+      state: address.state || null,
+      postalCode: address.postal_code || null
+    } : null;
+    setFormAddress(shippingAddress);
+    if (!checkout || !shippingAddress || !event.status.shippingAddress?.complete) {
+      return;
+    }
+    const key = JSON.stringify(shippingAddress);
+    if (key === JSON.stringify(quotedAddress) || shippingQuote.isPending && key === JSON.stringify(shippingQuote.variables)) {
+      return;
+    }
+    await shippingQuote.mutateAsync(shippingAddress).catch(() => void 0);
+  };
+  const handleConfirm = async (event) => {
+    if (!checkout) {
+      return;
+    }
+    const result = await checkout.confirm({ formConfirmEvent: event });
+    if (result.type === "error") {
+      setMessage(result.error.message);
+    }
+  };
+  const state = (() => {
+    if (checkout) {
+      return {
+        status: "ready",
+        summary: toSummary(
+          checkout,
+          formAddress !== null && JSON.stringify(formAddress) === JSON.stringify(quotedAddress)
+        ),
+        isQuotingShipping: shippingQuote.isPending,
+        message,
+        crossSells: (crossSellProducts ?? []).map((product) => ({
+          variantId: product.variantId,
+          title: product.title,
+          imageUrl: product.imageUrl,
+          price: formatAmount({
+            amount: product.unitPriceMinor,
+            currencyCode: product.currencyCode
+          })
+        })),
+        addCrossSell: async (variantId) => {
+          if (shippingQuote.isPending || crossSellAdd.isPending) {
+            return;
+          }
+          await crossSellAdd.mutateAsync(variantId).catch(() => void 0);
+        },
+        addingCrossSellVariantId: crossSellAdd.isPending ? crossSellAdd.variables : null
+      };
+    }
+    if (checkoutState.type === "error") {
+      return { status: "error", message: checkoutState.error.message, retry };
+    }
+    return { status: "loading" };
+  })();
+  return /* @__PURE__ */ jsx(
+    CheckoutSessionContext.Provider,
+    {
+      value: {
+        state,
+        form: {
+          hasLiveShipping,
+          onChange: handleChange,
+          onConfirm: handleConfirm
+        }
+      },
+      children
+    }
+  );
+}
+function CheckoutSessionProvider({
+  startCheckoutPath,
+  children
+}) {
+  const loaded = React.useSyncExternalStore(
+    subscribeToNothing,
+    getLoadedCheckout,
+    () => null
+  );
+  const retry = () => {
+    window.location.assign(startCheckoutPath);
+  };
+  if (!loaded || typeof loaded.config === "string" || !loaded.stripe) {
+    const state = loaded?.config === "empty" ? { status: "empty" } : {
+      status: "error",
+      message: "This checkout link is incomplete. Return to your cart and check out again.",
+      retry
+    };
+    return /* @__PURE__ */ jsx(
+      CheckoutSessionContext.Provider,
+      {
+        value: { state: loaded ? state : { status: "loading" }, form: null },
+        children
+      }
+    );
+  }
+  const config = loaded.config;
+  const sessionId = config.clientSecret.split("_secret_")[0] ?? "";
+  const quotedAddress = readQuotedAddress(sessionId);
+  return /* @__PURE__ */ jsx(
+    CheckoutFormProvider,
+    {
+      stripe: loaded.stripe,
+      options: {
+        clientSecret: config.clientSecret,
+        appearance: loaded.appearance,
+        fonts: loaded.fonts,
+        ...quotedAddress ? {
+          defaultValues: {
+            shippingAddress: {
+              address: {
+                country: quotedAddress.country,
+                line1: quotedAddress.line1,
+                line2: quotedAddress.line2,
+                city: quotedAddress.city,
+                state: quotedAddress.state,
+                postal_code: quotedAddress.postalCode
+              }
+            }
+          }
+        } : {}
+      },
+      children: /* @__PURE__ */ jsx(
+        CheckoutSessionBridge,
+        {
+          sessionId,
+          hasLiveShipping: config.hasLiveShipping,
+          retry,
+          children
+        }
+      )
+    }
+  );
+}
+function StripePaymentForm() {
+  const { state, form } = React.useContext(CheckoutSessionContext);
+  if (!form || state.status !== "ready") {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    CheckoutForm,
+    {
+      options: form.hasLiveShipping ? CARD_ONLY_FORM_OPTIONS : void 0,
+      onChange: form.onChange,
+      onConfirm: form.onConfirm
+    }
+  );
+}
+export {
+  CheckoutSessionProvider,
+  StripePaymentForm,
+  useCheckoutSession
+};

package/cart/start-stripe-checkout.d.ts

@@ -0,0 +1,40 @@
+import type { CartLineAttribute } from "./cart-types";
+import { CanopyError } from "../lib/canopy-error";
+export declare class StripeCheckoutError extends CanopyError {
+}
+export type StripeCheckoutOutcome = {
+    result: "created";
+    redirectUrl: string;
+} | {
+    result: "restartCheckout";
+    message: string;
+} | {
+    result: "outOfStock";
+    variants: {
+        variantId: string;
+        available: number;
+    }[];
+};
+/**
+ * Opens a Stripe Checkout session for a cart: Stripe's hosted page, or the
+ * site's own `paymentPagePath` page (built on `<CheckoutSessionProvider>`) with
+ * the session in the URL fragment. Canopy answers an embedded request with a
+ * hosted session where it can't serve embedded checkout.
+ */
+export declare function startStripeCheckout({ checkoutAttemptId, lineItems, discountCodes, pageUrl, ui, }: {
+    checkoutAttemptId: string | null;
+    lineItems: {
+        variantId: string;
+        quantity: number;
+        sellingPlanId: string | null;
+        properties: CartLineAttribute[];
+    }[];
+    discountCodes: string[];
+    pageUrl: string;
+    ui: {
+        mode: "hosted";
+    } | {
+        mode: "form";
+        paymentPagePath: string;
+    };
+}): Promise<StripeCheckoutOutcome>;

package/cart/start-stripe-checkout.js

@@ -0,0 +1,75 @@
+import { headers } from "next/headers";
+import { v4 as uuidv4 } from "uuid";
+import { getCanopyApiGateway } from "../gateways/canopy-api";
+import { CanopyError } from "../lib/canopy-error";
+import { REPLO_ATTRIBUTION_PROPERTY } from "./cart-types";
+import { getReturnUrls } from "./return-urls";
+class StripeCheckoutError extends CanopyError {
+}
+async function startStripeCheckout({
+  checkoutAttemptId,
+  lineItems,
+  discountCodes,
+  pageUrl,
+  ui
+}) {
+  const headersList = await headers();
+  const host = headersList.get("host");
+  if (!host) {
+    throw new StripeCheckoutError({ message: "Missing host header" });
+  }
+  const { origin, cancelUrl } = getReturnUrls({
+    host,
+    forwardedHost: headersList.get("x-forwarded-host"),
+    forwardedProto: headersList.get("x-forwarded-proto"),
+    requestOrigin: headersList.get("origin"),
+    pageUrl
+  });
+  const checkoutPage = ui.mode === "form" ? new URL(ui.paymentPagePath, origin) : null;
+  if (checkoutPage && checkoutPage.origin !== origin) {
+    throw new StripeCheckoutError({
+      message: "paymentPagePath must be a path on this site",
+      additionalData: { paymentPagePath: checkoutPage.toString() }
+    });
+  }
+  if (discountCodes.length > 0 || lineItems.some((lineItem) => Boolean(lineItem.sellingPlanId))) {
+    console.warn(
+      "[Replo] Stripe buy now does not support selling plans or discount codes; those options were ignored."
+    );
+  }
+  const outcome = await (await getCanopyApiGateway()).createStripeCheckoutSession({
+    checkoutAttemptId: checkoutAttemptId ?? uuidv4(),
+    lines: lineItems.map((item) => ({
+      variantId: item.variantId,
+      quantity: item.quantity,
+      properties: item.properties.some((property) => {
+        return property.key === REPLO_ATTRIBUTION_PROPERTY.key;
+      }) ? item.properties : [REPLO_ATTRIBUTION_PROPERTY, ...item.properties]
+    })),
+    successUrl: `${origin}/checkout/success`,
+    cancelUrl,
+    uiMode: ui.mode
+  });
+  if (outcome.result !== "created") {
+    return outcome;
+  }
+  const session = outcome.session;
+  if (checkoutPage && session.form) {
+    const { hasLiveShipping, ...config } = session.form;
+    checkoutPage.hash = new URLSearchParams({
+      ...config,
+      ...hasLiveShipping ? { hasLiveShipping: "1" } : {}
+    }).toString();
+    return { result: "created", redirectUrl: checkoutPage.toString() };
+  }
+  if (!session.url) {
+    throw new StripeCheckoutError({
+      message: "Stripe checkout session response has no page to open"
+    });
+  }
+  return { result: "created", redirectUrl: session.url };
+}
+export {
+  StripeCheckoutError,
+  startStripeCheckout
+};

package/{chunk-TTEBDCWT.mjs → chunk-4YTXURVN.mjs}

@@ -1,6 +1,6 @@
 import { CONTENT_SEO_VALUE_KEYS, CONTENT_RELATED_VALUE_STORAGE_KEY, CONTENT_PRIVATE_VALUE_KEYS, LEGACY_CONTENT_ENTRY_STATUSES, isContentPrivateValueKey, getContentFieldValueSchema } from './chunk-RQ76VK3L.mjs';
-import { MapCache_default, getAllKeysIn_default, identity_default, isIndex_default, assignValue_default, keys_default, Stack_default, isLength_default, isArguments_default, getTag_default, isBuffer_default, isTypedArray_default, eq_default, Uint8Array_default, getAllKeys_default } from './chunk-XWWFRIXV.mjs';
-import { Symbol_default, isArray_default, isObject_default, isObjectLike_default, baseGetTag_default } from './chunk-ZPDXVFCR.mjs';
+import { MapCache_default, getAllKeysIn_default, identity_default, isIndex_default, assignValue_default, keys_default, Stack_default, isLength_default, isArguments_default, getTag_default, isBuffer_default, isTypedArray_default, eq_default, Uint8Array_default, getAllKeys_default } from './chunk-N4WC2Z43.mjs';
+import { Symbol_default, isArray_default, isObject_default, isObjectLike_default, baseGetTag_default } from './chunk-JBCOJHZN.mjs';
 import { stringify, parseDocument } from 'yaml';
 import * as z2 from 'zod';
 

package/{chunk-O4QBR4QC.mjs → chunk-DMJ5VUD6.mjs}

@@ -1,5 +1,5 @@
-import { isString_default, isNumber_default } from './chunk-OPKMOW43.mjs';
-import { isObject_default } from './chunk-ZPDXVFCR.mjs';
+import { isString_default, isNumber_default } from './chunk-GNIXARC7.mjs';
+import { isObject_default } from './chunk-JBCOJHZN.mjs';
 
 var has = Object.prototype.hasOwnProperty;
 function dequal(foo, bar) {