@buygent/cli 0.3.0

package/dist/extension/content/coupang.js

@@ -0,0 +1,914 @@
+(() => {
+  // extension/protocol.ts
+  var BUYGENT_PROTOCOL_VERSION = 1;
+  var BUYGENT_NATIVE_HOST_NAME = "com.buygent.host";
+  var EXTENSION_ORDER_CHECKPOINT_PREFIX = "buygentOrderCheckpoint:";
+  var NATIVE_HOST_SOCKET_FILENAME = `${BUYGENT_NATIVE_HOST_NAME}.sock`;
+  var createEnvelope = (type, payload, options) => ({
+    protocolVersion: BUYGENT_PROTOCOL_VERSION,
+    type,
+    messageId: options.messageId,
+    ...options.requestId ? { requestId: options.requestId } : {},
+    sentAt: options.sentAt ?? new Date().toISOString(),
+    source: options.source,
+    payload
+  });
+  var createErrorEnvelope = (payload, options) => createEnvelope("error", payload, options);
+  var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+  var decodeEnvelope = (raw, options = {}) => {
+    const fallback = {
+      source: options.source ?? "native-host",
+      messageId: options.messageId ?? `protocol_${Date.now()}`,
+      requestId: options.requestId,
+      sentAt: options.sentAt
+    };
+    if (!isRecord(raw)) {
+      return {
+        ok: false,
+        error: createErrorEnvelope({
+          code: "invalid_envelope",
+          message: "Expected a JSON object envelope."
+        }, fallback)
+      };
+    }
+    if (raw.protocolVersion !== BUYGENT_PROTOCOL_VERSION) {
+      return {
+        ok: false,
+        error: createErrorEnvelope({
+          code: "unsupported_protocol_version",
+          message: `Unsupported protocolVersion: ${String(raw.protocolVersion ?? "missing")}`,
+          details: {
+            supportedProtocolVersion: BUYGENT_PROTOCOL_VERSION
+          }
+        }, fallback)
+      };
+    }
+    if (typeof raw.type !== "string" || typeof raw.messageId !== "string" || typeof raw.sentAt !== "string" || typeof raw.source !== "string") {
+      return {
+        ok: false,
+        error: createErrorEnvelope({
+          code: "invalid_envelope",
+          message: "Envelope must include type, messageId, sentAt, and source fields."
+        }, fallback)
+      };
+    }
+    return {
+      ok: true,
+      envelope: raw
+    };
+  };
+  var TERMINAL_ORDER_STATES = new Set(["aborted", "completed_dry_run"]);
+  var isTerminalOrderState = (state) => TERMINAL_ORDER_STATES.has(state);
+  var getOrderCheckpointStorageKey = (orderId) => `${EXTENSION_ORDER_CHECKPOINT_PREFIX}${orderId}`;
+
+  // extension/selector-config.ts
+  var BUNDLED_COUPANG_SELECTOR_CONFIG = {
+    version: "coupang.v2",
+    platform: "coupang",
+    generatedAt: "2026-05-02T00:00:00.000Z",
+    selectors: {
+      loginIndicators: [
+        "a[href*='mycoupang']",
+        ".my-coupang",
+        ".header-my-coupang",
+        "[data-testid='header-my-coupang']"
+      ],
+      loggedOutIndicators: [
+        "a[href*='login.coupang.com']",
+        "a[href*='/login/login.pang']",
+        "button[aria-label*='로그인']"
+      ],
+      productTitle: [
+        "h1.prod-buy-header__title",
+        ".prod-buy-header__title",
+        "h1[class*='title']",
+        "[data-testid='product-title']",
+        "meta[property='og:title']"
+      ],
+      productPrice: [
+        ".total-price strong",
+        ".prod-sale-price .total-price strong",
+        ".price-value",
+        "[class*='price'] strong"
+      ],
+      optionGroup: [
+        {
+          container: "[data-testid='product-option-selector']",
+          items: "button, [role='button'], option",
+          label: "[data-testid='option-label'], .title, label, strong"
+        },
+        {
+          container: ".prod-option",
+          items: "button, [role='button'], option",
+          label: ".title, label, strong"
+        },
+        {
+          container: "select[class*='option'], .prod-option select",
+          items: "option",
+          label: "label, strong, .title"
+        },
+        {
+          container: "select[name*='quantity'], select[id*='quantity']",
+          items: "option",
+          label: "label, strong, .title"
+        }
+      ],
+      buyNowButton: [
+        "button.prod-buy-btn",
+        "button[aria-label*='바로구매']",
+        "[data-testid='buy-now-button']",
+        "[data-cy='buy-now-button']",
+        "[data-automation-id='buy-now-button']"
+      ],
+      addToCartButton: [
+        "button.prod-cart-btn",
+        "button[aria-label*='장바구니']",
+        "[data-testid='add-to-cart-button']",
+        "[data-cy='add-to-cart-button']"
+      ],
+      cartCheckoutButton: [
+        "[data-testid='cart-order-button']",
+        "[data-cy='cart-order-button']",
+        "[data-automation-id='cart-order-button']"
+      ],
+      checkoutTotal: [
+        ".order-sheet .total-price strong",
+        "[data-testid='payment-total'] strong",
+        ".final-payment-price strong",
+        ".price-area strong"
+      ]
+    }
+  };
+
+  // extension/content/coupang-probe.ts
+  var PRODUCT_URL_PATTERN = /\/vp\/products\/(\d+)/u;
+  var LOGIN_URL_PATTERN = /login\.coupang\.com|\/login\//u;
+  var CART_URL_PATTERN = /cart\.coupang\.com|\/cartView/u;
+  var CHECKOUT_URL_PATTERN = /checkout\.coupang\.com|\/order-form|\/payment/u;
+  var normalizeText = (value) => value?.replace(/\s+/gu, " ").trim() ?? "";
+  var extractKrwAmount = (value) => {
+    const digits = value?.replace(/[^\d]/gu, "") ?? "";
+    return digits ? Number.parseInt(digits, 10) : undefined;
+  };
+  var toSelectorGroup = (selectors) => ({ anyOf: selectors });
+  var getSelectorConfig = (selectorConfig) => selectorConfig ?? BUNDLED_COUPANG_SELECTOR_CONFIG;
+  var detectCoupangPageKind = (url, dom, selectorConfig) => {
+    const config = getSelectorConfig(selectorConfig);
+    if (LOGIN_URL_PATTERN.test(url)) {
+      return "login";
+    }
+    if (PRODUCT_URL_PATTERN.test(url)) {
+      return "product";
+    }
+    if (CART_URL_PATTERN.test(url) || dom.hasAny(toSelectorGroup(config.selectors.cartCheckoutButton))) {
+      return "cart";
+    }
+    if (CHECKOUT_URL_PATTERN.test(url) || dom.hasAny(toSelectorGroup(config.selectors.checkoutTotal))) {
+      return "checkout";
+    }
+    if (/www\.coupang\.com\/?$/u.test(url)) {
+      return "home";
+    }
+    return "unknown";
+  };
+  var detectCoupangSessionState = (url, dom, selectorConfig) => {
+    const config = getSelectorConfig(selectorConfig);
+    if (dom.hasAny(toSelectorGroup(config.selectors.loginIndicators))) {
+      return "logged-in";
+    }
+    const bodyText = normalizeText(dom.bodyText);
+    if (/마이쿠팡|주문목록|쿠페이/u.test(bodyText)) {
+      return "logged-in";
+    }
+    if (LOGIN_URL_PATTERN.test(url) || dom.hasAny(toSelectorGroup(config.selectors.loggedOutIndicators))) {
+      return "logged-out";
+    }
+    if (/로그인|회원가입/u.test(bodyText)) {
+      return "logged-out";
+    }
+    return "unknown";
+  };
+  var buildCoupangProbe = (url, dom, observedAtOrOptions) => {
+    const observedAt = typeof observedAtOrOptions === "string" ? observedAtOrOptions : observedAtOrOptions?.observedAt ?? new Date().toISOString();
+    const selectorConfig = typeof observedAtOrOptions === "string" ? undefined : observedAtOrOptions?.selectorConfig;
+    const config = getSelectorConfig(selectorConfig);
+    const pageKind = detectCoupangPageKind(url, dom, config);
+    const sessionState = detectCoupangSessionState(url, dom, config);
+    const title = normalizeText(dom.title) || "Coupang";
+    const productId = PRODUCT_URL_PATTERN.exec(url)?.[1];
+    const productTitle = normalizeText(dom.queryText(toSelectorGroup(config.selectors.productTitle))) || undefined;
+    const priceText = normalizeText(dom.queryText(toSelectorGroup(config.selectors.productPrice))) || undefined;
+    const priceKrw = extractKrwAmount(priceText);
+    const buyNowAvailable = dom.hasAny(toSelectorGroup(config.selectors.buyNowButton)) || /바로구매/u.test(normalizeText(dom.bodyText));
+    const cartCheckoutAvailable = dom.hasAny(toSelectorGroup(config.selectors.cartCheckoutButton));
+    const checkoutTotalText = normalizeText(dom.queryText(toSelectorGroup(config.selectors.checkoutTotal))) || undefined;
+    const checkoutTotalKrw = extractKrwAmount(checkoutTotalText);
+    return {
+      platform: "coupang",
+      url,
+      title,
+      pageKind,
+      sessionState,
+      loggedIn: sessionState === "logged-in",
+      selectorsVersion: config.version,
+      observedAt,
+      ...pageKind === "product" || productTitle || priceText || productId ? {
+        product: {
+          ...productId ? { productId } : {},
+          ...productTitle ? { title: productTitle } : {},
+          ...priceText ? { priceText } : {},
+          ...typeof priceKrw === "number" ? { priceKrw } : {},
+          buyNowAvailable,
+          cartCheckoutAvailable
+        }
+      } : {},
+      ...pageKind === "checkout" || checkoutTotalText || typeof checkoutTotalKrw === "number" ? {
+        checkout: {
+          ...checkoutTotalText ? { totalPriceText: checkoutTotalText } : {},
+          ...typeof checkoutTotalKrw === "number" ? { totalPriceKrw: checkoutTotalKrw } : {}
+        }
+      } : {}
+    };
+  };
+  var createDocumentProbeAdapter = (document2) => ({
+    title: document2.title,
+    bodyText: document2.body?.innerText ?? document2.body?.textContent ?? "",
+    hasAny(group) {
+      return group.anyOf.some((selector) => {
+        const element = document2.querySelector(selector);
+        if (!element) {
+          return false;
+        }
+        if (element instanceof HTMLMetaElement) {
+          return Boolean(normalizeText(element.content));
+        }
+        return Boolean(normalizeText(element.textContent) || element instanceof HTMLElement);
+      });
+    },
+    queryText(group) {
+      for (const selector of group.anyOf) {
+        const element = document2.querySelector(selector);
+        if (!element) {
+          continue;
+        }
+        if (element instanceof HTMLMetaElement) {
+          const content = normalizeText(element.content);
+          if (content) {
+            return content;
+          }
+        }
+        const text = normalizeText(element.textContent);
+        if (text) {
+          return text;
+        }
+      }
+      return;
+    }
+  });
+
+  // extension/content/coupang-option-selection.ts
+  var SOLD_OUT_PATTERN = /품절|sold\s*out|out\s*of\s*stock/u;
+  var SIZE_PATTERN = /사이즈|size/u;
+  var COLOR_PATTERN = /색상|컬러|color/u;
+  var QUANTITY_PATTERN = /수량|개수|qty|quantity/u;
+  var DISABLED_CLASS_PATTERN = /disabled|soldout|sold-out|unavailable|gray|grey/u;
+  var wait = async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  };
+  var toArray = (value) => value ? [...value] : [];
+  var getText = (element) => normalizeText(element?.textContent ?? (typeof element?.value === "string" ? element.value : ""));
+  var getAttribute = (element, name) => element.getAttribute(name) ?? undefined;
+  var isElementAvailable = (element) => {
+    const text = getText(element);
+    const className = typeof element.className === "string" ? element.className : "";
+    const ariaDisabled = getAttribute(element, "aria-disabled");
+    return !element.hidden && !element.disabled && ariaDisabled !== "true" && !DISABLED_CLASS_PATTERN.test(className) && !SOLD_OUT_PATTERN.test(text);
+  };
+  var isElementSelected = (element) => {
+    if (element.selected) {
+      return true;
+    }
+    const ariaSelected = getAttribute(element, "aria-selected");
+    const ariaPressed = getAttribute(element, "aria-pressed");
+    const ariaChecked = getAttribute(element, "aria-checked");
+    const className = typeof element.className === "string" ? element.className : "";
+    return ariaSelected === "true" || ariaPressed === "true" || ariaChecked === "true" || /selected|active|checked|current|on/u.test(className);
+  };
+  var inferGroupKind = (label, choices) => {
+    const normalizedLabel = normalizeText(label);
+    if (QUANTITY_PATTERN.test(normalizedLabel)) {
+      return "quantity";
+    }
+    if (COLOR_PATTERN.test(normalizedLabel)) {
+      return "color";
+    }
+    if (SIZE_PATTERN.test(normalizedLabel)) {
+      return "size";
+    }
+    if (choices.every((choice) => /^\d+$/u.test(choice.value))) {
+      return "quantity";
+    }
+    return "unknown";
+  };
+  var parseMinimumQuantity = (choices) => {
+    const numericValues = choices.map((choice) => Number.parseInt(choice.value.replace(/[^\d]/gu, ""), 10)).filter((value) => Number.isInteger(value) && value > 0);
+    if (numericValues.length === 0) {
+      return;
+    }
+    return Math.min(...numericValues);
+  };
+  var toGroupKey = (kind, label, index) => `${kind}:${normalizeText(label)?.toLowerCase() || `group-${index}`}`;
+  var activateElement = async (element) => {
+    const tagName = element.tagName?.toUpperCase();
+    if (tagName === "OPTION") {
+      const parent = element.parentElement;
+      if (parent && typeof element.value === "string") {
+        parent.value = element.value;
+        if (typeof parent.dispatchEvent === "function") {
+          parent.dispatchEvent(new Event("change", { bubbles: true }));
+        }
+        await wait(50);
+        return;
+      }
+    }
+    if (typeof element.click === "function") {
+      element.click();
+      await wait(50);
+      return;
+    }
+    throw new Error("options_dom_unrecognized");
+  };
+  var createChoice = (element) => ({
+    value: getText(element),
+    available: isElementAvailable(element),
+    selected: isElementSelected(element),
+    async activate() {
+      await activateElement(element);
+    }
+  });
+  var detectGroups = (root, selectorConfig) => {
+    const seen = new Set;
+    const groups = [];
+    selectorConfig.selectors.optionGroup.forEach((selectorGroup, configIndex) => {
+      const containers = toArray(root.querySelectorAll(selectorGroup.container));
+      containers.forEach((container, containerIndex) => {
+        if (seen.has(container)) {
+          return;
+        }
+        seen.add(container);
+        const choices = toArray(container.querySelectorAll(selectorGroup.items)).map((element) => createChoice(element)).filter((choice) => choice.value.length > 0);
+        if (choices.length === 0) {
+          return;
+        }
+        const label = selectorGroup.label ? getText(container.querySelector(selectorGroup.label)) || undefined : undefined;
+        const kind = inferGroupKind(label, choices);
+        groups.push({
+          key: toGroupKey(kind, label, configIndex * 100 + containerIndex),
+          kind,
+          label,
+          required: true,
+          minimumQuantity: kind === "quantity" ? parseMinimumQuantity(choices) : undefined,
+          choices
+        });
+      });
+    });
+    return groups;
+  };
+  var findPreferredValue = (group, preferences, existingPlan) => {
+    const fromExisting = existingPlan?.groups.find((candidate) => candidate.key === group.key)?.desiredValue;
+    if (fromExisting) {
+      return fromExisting;
+    }
+    if (!preferences) {
+      return;
+    }
+    const candidates = [group.key, group.kind, normalizeText(group.label).toLowerCase()].filter((value) => value.length > 0);
+    for (const candidate of candidates) {
+      const preferred = preferences[candidate];
+      if (typeof preferred === "string" && preferred.trim().length > 0) {
+        return preferred.trim();
+      }
+    }
+    return;
+  };
+  var chooseDesiredValue = (group, preferences, existingPlan) => {
+    const availableChoices = group.choices.filter((choice) => choice.available);
+    if (availableChoices.length === 0) {
+      throw new Error("options_unavailable");
+    }
+    if (group.kind === "quantity") {
+      const minimumQuantity = group.minimumQuantity ?? 1;
+      const matchingQuantity = availableChoices.find((choice) => {
+        const numericValue = Number.parseInt(choice.value.replace(/[^\d]/gu, ""), 10);
+        return Number.isInteger(numericValue) && numericValue >= minimumQuantity;
+      });
+      return matchingQuantity?.value ?? availableChoices[0].value;
+    }
+    const preferredValue = findPreferredValue(group, preferences, existingPlan);
+    if (preferredValue) {
+      const preferred = availableChoices.find((choice) => normalizeText(choice.value).toLowerCase() === normalizeText(preferredValue).toLowerCase());
+      if (preferred) {
+        return preferred.value;
+      }
+    }
+    return availableChoices[0].value;
+  };
+  var toPlanGroup = (group, preferences, existingPlan) => {
+    const desiredValue = chooseDesiredValue(group, preferences, existingPlan);
+    const selected = group.choices.find((choice) => choice.selected && normalizeText(choice.value).toLowerCase() === normalizeText(desiredValue).toLowerCase());
+    return {
+      key: group.key,
+      kind: group.kind,
+      ...group.label ? { label: group.label } : {},
+      required: group.required,
+      desiredValue,
+      ...selected ? { selectedValue: selected.value } : {},
+      availableValues: group.choices.filter((choice) => choice.available).map((choice) => choice.value),
+      status: selected ? "selected" : "pending",
+      ...typeof group.minimumQuantity === "number" ? { minimumQuantity: group.minimumQuantity } : {}
+    };
+  };
+  var applyPlanGroup = async (detectedGroup, planGroup) => {
+    const desiredValue = normalizeText(planGroup.desiredValue).toLowerCase();
+    const matchingChoice = detectedGroup.choices.find((choice) => normalizeText(choice.value).toLowerCase() === desiredValue);
+    if (!matchingChoice || !matchingChoice.available) {
+      throw new Error("options_unavailable");
+    }
+    if (!matchingChoice.selected) {
+      await matchingChoice.activate();
+    }
+    return {
+      ...planGroup,
+      selectedValue: matchingChoice.value,
+      status: "selected"
+    };
+  };
+  var buildSelectionRequired = (root) => /옵션을\s*선택|필수\s*옵션|선택해\s*주세요/u.test(getText(root));
+  var createOptionSelectionRuntime = (root, selectorConfig) => ({
+    requiresSelection() {
+      if (buildSelectionRequired(root)) {
+        return true;
+      }
+      return detectGroups(root, selectorConfig).length > 0;
+    },
+    buildSelectionPlan(input) {
+      const detectedGroups = detectGroups(root, selectorConfig);
+      if (detectedGroups.length === 0) {
+        if (buildSelectionRequired(root)) {
+          throw new Error("options_dom_unrecognized");
+        }
+        return {
+          generatedAt: new Date().toISOString(),
+          ...input?.preferences ? { preferences: input.preferences } : {},
+          groups: []
+        };
+      }
+      return {
+        generatedAt: new Date().toISOString(),
+        ...input?.preferences ? { preferences: input.preferences } : {},
+        groups: detectedGroups.map((group) => toPlanGroup(group, input?.preferences, input?.existingPlan))
+      };
+    },
+    async applySelectionPlan(plan) {
+      if (plan.groups.length === 0) {
+        return plan;
+      }
+      const liveGroups = detectGroups(root, selectorConfig);
+      if (liveGroups.length === 0) {
+        throw new Error("options_dom_unrecognized");
+      }
+      const updatedGroups = [];
+      for (const planGroup of plan.groups) {
+        const detectedGroup = liveGroups.find((candidate) => candidate.key === planGroup.key) ?? liveGroups.find((candidate) => candidate.kind === planGroup.kind && normalizeText(candidate.label) === normalizeText(planGroup.label));
+        if (!detectedGroup) {
+          throw new Error("options_dom_unrecognized");
+        }
+        updatedGroups.push(await applyPlanGroup(detectedGroup, planGroup));
+      }
+      return {
+        ...plan,
+        groups: updatedGroups
+      };
+    }
+  });
+  var createDocumentOptionSelectionRuntime = (document2, selectorConfig) => createOptionSelectionRuntime({
+    querySelector(selector) {
+      return document2.querySelector(selector);
+    },
+    querySelectorAll(selector) {
+      return document2.querySelectorAll(selector);
+    },
+    textContent: document2.body?.innerText ?? document2.body?.textContent ?? ""
+  }, selectorConfig);
+
+  // extension/content/order-state.ts
+  var chromeApi = globalThis.chrome;
+  var storageArea = chromeApi?.storage?.session ?? chromeApi?.storage?.local;
+  var ORDER_TRANSITIONS = {
+    idle: ["navigating", "aborted"],
+    navigating: ["product_loaded", "aborted"],
+    product_loaded: ["selecting_options", "aborted"],
+    selecting_options: ["option_selected", "aborted"],
+    option_selected: ["cart_added", "aborted"],
+    cart_added: ["checkout_loaded", "aborted"],
+    checkout_loaded: ["awaiting_user_confirm", "completed_dry_run", "aborted"],
+    awaiting_user_confirm: ["completed_dry_run", "aborted"],
+    aborted: [],
+    completed_dry_run: []
+  };
+  var createInitialCheckpoint = (request, observedAt = new Date().toISOString()) => ({
+    orderId: request.orderId,
+    platform: request.platform,
+    state: "idle",
+    productUrl: request.productUrl,
+    ...typeof request.maxPriceKrw === "number" ? { maxPriceKrw: request.maxPriceKrw } : {},
+    ...typeof request.tabId === "number" ? { tabId: request.tabId } : {},
+    dryRun: request.dryRun,
+    observedAt
+  });
+  var transitionOrderCheckpoint = (current, nextState, patch = {}, observedAt = new Date().toISOString()) => {
+    if (current.state !== nextState && !ORDER_TRANSITIONS[current.state].includes(nextState)) {
+      throw new Error(`Invalid order transition: ${current.state} -> ${nextState}`);
+    }
+    return {
+      ...current,
+      ...patch,
+      state: nextState,
+      observedAt
+    };
+  };
+  var createStorageArea = () => storageArea;
+  var readOrderCheckpoint = async (storage, orderId) => {
+    const key = getOrderCheckpointStorageKey(orderId);
+    const stored = await storage.get(key);
+    return stored[key];
+  };
+  var writeOrderCheckpoint = async (storage, checkpoint) => {
+    const { resumeState: _resumeState, ...persisted } = checkpoint;
+    await storage.set({
+      [getOrderCheckpointStorageKey(checkpoint.orderId)]: persisted
+    });
+    return persisted;
+  };
+  var resumeOrderCheckpoint = async (storage, request, observedAt = new Date().toISOString()) => {
+    const existing = await readOrderCheckpoint(storage, request.orderId);
+    if (existing) {
+      return existing;
+    }
+    const created = createInitialCheckpoint(request, observedAt);
+    await writeOrderCheckpoint(storage, created);
+    return created;
+  };
+  var toRuntimeFailureReason = (error) => error instanceof Error ? error.message : typeof error === "string" ? error : "The Coupang dry-run flow failed unexpectedly.";
+  var createAbortedOrderCheckpoint = (checkpoint, reason, observedAt = new Date().toISOString()) => transitionOrderCheckpoint(checkpoint, "aborted", {
+    reason,
+    detail: reason,
+    lastError: reason
+  }, observedAt);
+
+  // extension/content/coupang-order.ts
+  var COUPANG_CART_URL = "https://cart.coupang.com/cartView.pang";
+  var BUTTON_LIKE_SELECTOR = 'button, a, [role="button"], label';
+  var wait2 = async (ms) => {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  };
+  var checkpointPatchFromProbe = (request, checkpoint, probe) => ({
+    productUrl: request.productUrl,
+    pageUrl: probe.url,
+    ...probe.product?.title ? { productTitle: probe.product.title } : {},
+    ...typeof probe.product?.priceKrw === "number" ? { priceKrw: probe.product.priceKrw } : {},
+    ...probe.checkout?.totalPriceText ? { totalPriceText: probe.checkout.totalPriceText } : {},
+    ...typeof probe.checkout?.totalPriceKrw === "number" ? { totalPriceKrw: probe.checkout.totalPriceKrw } : {},
+    ...probe.selectorsVersion ? { selectorsVersion: probe.selectorsVersion } : {},
+    ...typeof request.maxPriceKrw === "number" ? { maxPriceKrw: request.maxPriceKrw } : {},
+    ...typeof checkpoint.tabId === "number" ? { tabId: checkpoint.tabId } : {},
+    dryRun: request.dryRun
+  });
+  var persistAndEmitStatus = async (dependencies, checkpoint) => {
+    const persisted = await dependencies.persistCheckpoint(checkpoint);
+    await dependencies.emitStatus(persisted);
+    return persisted;
+  };
+  var abortOrder = async (dependencies, checkpoint, message) => {
+    const aborted = createAbortedOrderCheckpoint(checkpoint, message);
+    return await persistAndEmitStatus(dependencies, aborted);
+  };
+  var runCoupangDryRunFlow = async (dependencies) => {
+    const { adapter, request } = dependencies;
+    let checkpoint = dependencies.initialCheckpoint;
+    try {
+      while (true) {
+        const probe = adapter.probe();
+        const patch = checkpointPatchFromProbe(request, checkpoint, probe);
+        switch (checkpoint.state) {
+          case "idle": {
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "navigating", {
+              ...patch,
+              detail: "Navigating to Coupang product page."
+            }));
+            if (adapter.getUrl() !== request.productUrl) {
+              await adapter.navigate(request.productUrl);
+              return checkpoint;
+            }
+            continue;
+          }
+          case "navigating": {
+            if (!probe.loggedIn) {
+              return await abortOrder(dependencies, checkpoint, "Coupang login is required before starting a dry-run order.");
+            }
+            if (probe.pageKind !== "product") {
+              if (adapter.getUrl() !== request.productUrl) {
+                await adapter.navigate(request.productUrl);
+              }
+              return checkpoint;
+            }
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "product_loaded", {
+              ...patch,
+              detail: "Loaded product context from the Coupang product page."
+            }));
+            continue;
+          }
+          case "product_loaded": {
+            if (!probe.loggedIn) {
+              return await abortOrder(dependencies, checkpoint, "Coupang login is required before continuing.");
+            }
+            if (typeof request.maxPriceKrw === "number" && typeof probe.product?.priceKrw === "number" && probe.product.priceKrw > request.maxPriceKrw) {
+              return await abortOrder(dependencies, checkpoint, `Product price ${probe.product.priceKrw} KRW exceeds the maxPriceKrw guardrail of ${request.maxPriceKrw}.`);
+            }
+            const selectionPlan = adapter.buildSelectionPlan({
+              existingPlan: checkpoint.selectionPlan,
+              preferences: request.selectionPreferences
+            });
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "selecting_options", {
+              ...patch,
+              selectionPlan,
+              detail: adapter.requiresOptionSelection() ? "Preparing required product option selections." : "Checking whether product options need to be selected."
+            }));
+            continue;
+          }
+          case "selecting_options": {
+            const selectionPlan = adapter.buildSelectionPlan({
+              existingPlan: checkpoint.selectionPlan,
+              preferences: request.selectionPreferences
+            });
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "selecting_options", {
+              ...patch,
+              selectionPlan,
+              detail: "Selecting product options for the dry-run."
+            }));
+            const appliedPlan = await adapter.applySelectionPlan(selectionPlan);
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "option_selected", {
+              ...patch,
+              selectionPlan: appliedPlan,
+              detail: appliedPlan.groups.length > 0 ? "Selected product options for the dry-run." : "No product option selection was required for this dry-run."
+            }));
+            continue;
+          }
+          case "option_selected": {
+            await adapter.addToCart();
+            await wait2(400);
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "cart_added", {
+              ...patch,
+              detail: "Added the product to the cart."
+            }));
+            await adapter.navigate(COUPANG_CART_URL);
+            return checkpoint;
+          }
+          case "cart_added": {
+            if (probe.pageKind !== "cart" && probe.pageKind !== "checkout") {
+              await adapter.navigate(COUPANG_CART_URL);
+              return checkpoint;
+            }
+            if (probe.pageKind === "cart") {
+              await adapter.selectCartItems();
+              await adapter.startCheckout();
+              return checkpoint;
+            }
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "checkout_loaded", {
+              ...patch,
+              detail: "Reached the Coupang checkout page."
+            }));
+            await dependencies.emitCheckpoint(checkpoint);
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "awaiting_user_confirm", {
+              ...patch,
+              detail: "Dry-run reached checkout and is awaiting future approval wiring."
+            }));
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "completed_dry_run", {
+              ...patch,
+              detail: "Dry-run completed at the checkout checkpoint without submitting payment."
+            }));
+            return checkpoint;
+          }
+          case "checkout_loaded": {
+            await dependencies.emitCheckpoint(checkpoint);
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "awaiting_user_confirm", {
+              detail: checkpoint.detail ?? "Checkout checkpoint reached."
+            }));
+            continue;
+          }
+          case "awaiting_user_confirm": {
+            checkpoint = await persistAndEmitStatus(dependencies, transitionOrderCheckpoint(checkpoint, "completed_dry_run", {
+              detail: checkpoint.detail ?? "Dry-run complete."
+            }));
+            return checkpoint;
+          }
+          case "aborted":
+          case "completed_dry_run":
+            return checkpoint;
+        }
+      }
+    } catch (error) {
+      if (!isTerminalOrderState(checkpoint.state)) {
+        await abortOrder(dependencies, checkpoint, toRuntimeFailureReason(error));
+      }
+      throw error;
+    }
+  };
+  var isVisible = (element) => {
+    const candidate = element;
+    if (candidate.hidden) {
+      return false;
+    }
+    const style = typeof window !== "undefined" && typeof window.getComputedStyle === "function" ? window.getComputedStyle(candidate) : undefined;
+    const rect = typeof candidate.getBoundingClientRect === "function" ? candidate.getBoundingClientRect() : undefined;
+    return !candidate.hasAttribute?.("hidden") && style?.display !== "none" && style?.visibility !== "hidden" && style?.opacity !== "0" && (rect ? rect.width > 0 && rect.height > 0 : true);
+  };
+  var queryFirstVisibleBySelectorGroup = (document2, selectors) => {
+    for (const selector of selectors) {
+      const match = document2.querySelector(selector);
+      if (match && isVisible(match)) {
+        return match;
+      }
+    }
+    return;
+  };
+  var queryFirstVisibleByText = (document2, pattern, selector = BUTTON_LIKE_SELECTOR) => {
+    const elements = document2.querySelectorAll(selector);
+    for (const element of elements) {
+      if (!isVisible(element)) {
+        continue;
+      }
+      const text = normalizeText(element.textContent ?? "");
+      if (text && pattern.test(text)) {
+        return element;
+      }
+    }
+    return;
+  };
+  var clickElement = async (element, errorMessage) => {
+    if (!element) {
+      throw new Error(errorMessage);
+    }
+    element.click();
+    await wait2(250);
+  };
+  var createDocumentOrderRuntimeAdapter = (document2, location, selectorConfig = BUNDLED_COUPANG_SELECTOR_CONFIG) => {
+    const optionRuntime = createDocumentOptionSelectionRuntime(document2, selectorConfig);
+    return {
+      getUrl: () => location.href,
+      async navigate(url) {
+        if (location.href !== url) {
+          location.href = url;
+          await wait2(50);
+        }
+      },
+      probe() {
+        return buildCoupangProbe(location.href, createDocumentProbeAdapter(document2), { selectorConfig });
+      },
+      requiresOptionSelection() {
+        return optionRuntime.requiresSelection();
+      },
+      buildSelectionPlan(input) {
+        return optionRuntime.buildSelectionPlan(input);
+      },
+      async applySelectionPlan(plan) {
+        return await optionRuntime.applySelectionPlan(plan);
+      },
+      async addToCart() {
+        const button = queryFirstVisibleBySelectorGroup(document2, selectorConfig.selectors.addToCartButton) ?? queryFirstVisibleByText(document2, /장바구니\s*담기|카트\s*담기/u);
+        await clickElement(button, "Unable to find the Coupang add-to-cart button.");
+      },
+      async selectCartItems() {
+        const selectAll = queryFirstVisibleByText(document2, /전체\s*선택/u);
+        if (!selectAll) {
+          return;
+        }
+        const ariaChecked = selectAll.getAttribute("aria-checked");
+        if (selectAll instanceof HTMLInputElement && selectAll.checked) {
+          return;
+        }
+        if (ariaChecked === "true") {
+          return;
+        }
+        await clickElement(selectAll, "Unable to toggle the Coupang cart selection state.");
+      },
+      async startCheckout() {
+        const button = queryFirstVisibleBySelectorGroup(document2, selectorConfig.selectors.cartCheckoutButton) ?? queryFirstVisibleByText(document2, /^주문하기$/u);
+        await clickElement(button, "Unable to find the Coupang cart order button.");
+      }
+    };
+  };
+
+  // extension/content/coupang.ts
+  var createRequestId = () => globalThis.crypto?.randomUUID?.() ?? `req_${Date.now()}_${Math.random().toString(16).slice(2)}`;
+  var sendBackgroundEnvelope = async (envelope) => {
+    try {
+      await chrome.runtime.sendMessage(envelope);
+    } catch {}
+  };
+  var resolveSelectorConfig = (selectorConfig) => selectorConfig?.config ?? BUNDLED_COUPANG_SELECTOR_CONFIG;
+  var createProbeResponse = (message) => {
+    try {
+      return createEnvelope("coupang:probe-result", {
+        probe: buildCoupangProbe(window.location.href, createDocumentProbeAdapter(document), {
+          selectorConfig: resolveSelectorConfig(message.payload.selectorConfig)
+        })
+      }, {
+        source: "extension:content",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      });
+    } catch (error) {
+      return createErrorEnvelope({
+        code: "internal_error",
+        message: error instanceof Error ? error.message : "Failed to inspect the Coupang page."
+      }, {
+        source: "extension:content",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      });
+    }
+  };
+  var runOrder = async (message) => {
+    const storage = createStorageArea();
+    if (!storage) {
+      throw new Error("chrome.storage.session is unavailable in the Coupang content script.");
+    }
+    const checkpoint = await resumeOrderCheckpoint(storage, message.payload, message.sentAt);
+    const emit = async (type, nextCheckpoint) => {
+      await sendBackgroundEnvelope(createEnvelope(type, nextCheckpoint, {
+        source: "extension:content",
+        messageId: createRequestId(),
+        requestId: message.messageId
+      }));
+    };
+    await runCoupangDryRunFlow({
+      request: message.payload,
+      initialCheckpoint: checkpoint,
+      adapter: createDocumentOrderRuntimeAdapter(document, window.location, resolveSelectorConfig(message.payload.selectorConfig)),
+      persistCheckpoint: async (nextCheckpoint) => await writeOrderCheckpoint(storage, nextCheckpoint),
+      emitStatus: async (nextCheckpoint) => await emit("order:status", nextCheckpoint),
+      emitCheckpoint: async (nextCheckpoint) => await emit("order:checkpoint", nextCheckpoint)
+    });
+  };
+  var createAck = (message) => createEnvelope("content:ack", {
+    orderId: message.payload.orderId,
+    ok: true
+  }, {
+    source: "extension:content",
+    messageId: createRequestId(),
+    requestId: message.messageId
+  });
+  chrome.runtime.onMessage.addListener((rawMessage, _sender, sendResponse) => {
+    const decoded = decodeEnvelope(rawMessage, {
+      source: "extension:content",
+      messageId: createRequestId()
+    });
+    if (!decoded.ok) {
+      sendResponse(decoded.error);
+      return false;
+    }
+    const message = decoded.envelope;
+    if (message.type === "coupang:probe") {
+      sendResponse(createProbeResponse(message));
+      return false;
+    }
+    if (message.type === "order:start" || message.type === "order:resume") {
+      runOrder(message).catch(async (error) => {
+        const reason = error instanceof Error ? error.message : "Failed to run the Coupang dry-run order flow.";
+        await sendBackgroundEnvelope(createErrorEnvelope({
+          code: "internal_error",
+          message: reason,
+          details: {
+            orderId: message.payload.orderId,
+            reason
+          }
+        }, {
+          source: "extension:content",
+          messageId: createRequestId(),
+          requestId: message.requestId ?? message.messageId
+        }));
+      });
+      sendResponse(createAck(message));
+      return false;
+    }
+    return false;
+  });
+  sendBackgroundEnvelope(createEnvelope("content:ready", {
+    platform: "coupang",
+    url: window.location.href
+  }, {
+    source: "extension:content",
+    messageId: createRequestId()
+  }));
+})();