@teamlearners/clawops 0.32.1 → 0.34.0

package/dist/solapi/index.cjs

@@ -0,0 +1,662 @@
+'use strict';
+
+var chunkTVDUOKJD_cjs = require('../chunk-TVDUOKJD.cjs');
+
+// src/solapi/_concurrency.ts
+var DEFAULT_CONCURRENCY = 10;
+async function mapWithConcurrency(items, limit, run) {
+  const results = new Array(items.length);
+  let cursor = 0;
+  const worker = async () => {
+    for (let index = cursor++; index < items.length; index = cursor++) {
+      results[index] = await run(items[index]);
+    }
+  };
+  const workers = Math.min(Math.max(1, limit), items.length);
+  await Promise.all(Array.from({ length: workers }, worker));
+  return results;
+}
+
+// src/solapi/_message-type.ts
+var SMS_MAX_EUCKR_BYTES = 90;
+function euckrByteLength(text) {
+  let bytes = 0;
+  for (const ch of text) bytes += ch.codePointAt(0) < 128 ? 1 : 2;
+  return bytes;
+}
+var normalizePhone = (value) => value.replace(/-/g, "");
+var upperType = (message) => message.type === void 0 ? "" : String(message.type).toUpperCase();
+function clawopsType(message) {
+  const type = upperType(message);
+  if (type === "SMS") return "sms";
+  if (type === "LMS") return "lms";
+  if (message.subject !== void 0 && message.subject !== null && message.subject !== "") {
+    return "lms";
+  }
+  return euckrByteLength(message.text ?? "") > SMS_MAX_EUCKR_BYTES ? "lms" : "sms";
+}
+
+// src/solapi/fallback-text.ts
+var VARIABLE_KEY = /^#\{.+\}$/;
+var LEFTOVER = /#\{[^}]*\}/g;
+var asKey = (key) => VARIABLE_KEY.test(key) ? key : `#{${key}}`;
+function render(content, variables = {}) {
+  let out = content;
+  for (const [key, value] of Object.entries(variables)) {
+    out = out.split(asKey(key)).join(value);
+  }
+  return out;
+}
+var leftovers = (text) => text.match(LEFTOVER) ?? [];
+function templateRef(kakaoOptions) {
+  if (kakaoOptions === null || typeof kakaoOptions !== "object") return {};
+  const options = kakaoOptions;
+  const templateId = typeof options.templateId === "string" ? options.templateId : void 0;
+  let variables;
+  const raw = options.variables;
+  if (raw !== null && typeof raw === "object") {
+    const entries = Object.entries(raw).filter(
+      (entry) => typeof entry[1] === "string"
+    );
+    if (entries.length > 0) variables = Object.fromEntries(entries);
+  }
+  return { templateId, variables };
+}
+var DEFAULT_FALLBACK_FIELD = "clawopsFallbackText";
+async function resolveFallbackText(message, solapi, options = {}) {
+  const field = options.field ?? DEFAULT_FALLBACK_FIELD;
+  const explicit = message.customFields?.[field];
+  if (explicit !== void 0) return finish(explicit, "customFields");
+  const { templateId, variables } = templateRef(message.kakaoOptions);
+  if (templateId !== void 0) {
+    const cache = options.cache;
+    let pending = cache?.get(templateId);
+    if (pending === void 0) {
+      pending = solapi.getKakaoAlimtalkTemplate(templateId).then((template) => template.content);
+      cache?.set(templateId, pending);
+      pending.catch(() => cache?.delete(templateId));
+    }
+    const content = await pending;
+    if (content === void 0) {
+      return { ok: false, reason: "no_template_content", source: "template" };
+    }
+    return finish(render(content, variables), "template");
+  }
+  if (message.text === void 0 || message.text === null) {
+    return { ok: false, reason: "no_text", source: "text" };
+  }
+  return finish(message.text, "text");
+}
+function finish(text, source) {
+  const unresolved = leftovers(text);
+  return unresolved.length > 0 ? { ok: false, reason: "unresolved_variables", unresolved, source } : { ok: true, text, source };
+}
+
+// src/solapi/_fallback.ts
+async function deliverFallback(request, solapi, context) {
+  let resolved;
+  try {
+    resolved = await resolveFallbackText(request.source, solapi, {
+      field: context.field,
+      cache: context.cache
+    });
+  } catch {
+    resolved = { ok: false, reason: "no_template_content", source: "template" };
+  }
+  if (!resolved.ok) return { status: "blocked", reason: resolved };
+  const subject = request.source.subject ?? void 0;
+  try {
+    const created = await context.clawops.messages.create({
+      to: normalizePhone(request.to),
+      from: normalizePhone(request.from),
+      body: resolved.text,
+      type: clawopsType({ text: resolved.text, subject }),
+      subject,
+      idempotencyKey: request.idempotencyKey
+    });
+    return {
+      status: "sent",
+      source: resolved.source,
+      text: resolved.text,
+      messageId: created.messageId
+    };
+  } catch (error) {
+    return { status: "send_failed", source: resolved.source, text: resolved.text, error };
+  }
+}
+
+// src/solapi/sweep.ts
+var FALLBACK_MARKER_FIELD = "clawopsFallback";
+var FALLBACK_MARKER_VALUE = "1";
+var DEFAULT_FALLBACK_CODES = ["3104", "3107", "3102"];
+var DEFAULT_SWEEP_TYPES = ["ATA"];
+var DELIVERY_FAILURE = /^3\d{3}$/;
+var IN_FLIGHT_CODE = "3000";
+var DEFAULT_LOOKBACK_MS = 60 * 60 * 1e3;
+var PAGE_SIZE = 200;
+var MAX_PAGES = 50;
+var firstRecipient = (to) => Array.isArray(to) ? to[0] : to;
+var timeOf = (row) => row.dateUpdated ?? row.dateCreated;
+async function sweepFailedAlimtalk(options) {
+  const targets = new Set(options.on ?? DEFAULT_FALLBACK_CODES);
+  const boundary = new Set(options.cursor?.seen ?? []);
+  const templateCache = options.templateCache ?? /* @__PURE__ */ new Map();
+  const window = options.lookbackMs ?? DEFAULT_LOOKBACK_MS;
+  const startDate = options.cursor ? new Date(options.cursor.updatedAt) : new Date(Date.now() - window);
+  const endDate = new Date(Math.min(Date.now(), startDate.getTime() + window));
+  const candidates = [];
+  const ineligible = [];
+  let scanned = 0;
+  let maxTime = startDate.getTime();
+  let atMax = new Set(boundary);
+  let truncated = false;
+  for (const type of options.types ?? DEFAULT_SWEEP_TYPES) {
+    let startKey;
+    for (let page = 0; page < MAX_PAGES; page += 1) {
+      const response = await options.solapi.getMessages({
+        type,
+        dateType: "UPDATED",
+        startDate,
+        endDate,
+        limit: PAGE_SIZE,
+        startKey
+      });
+      const rows = Object.values(response.messageList ?? {});
+      if (rows.length === 0) break;
+      scanned += rows.length;
+      for (const row of rows) {
+        const at = timeOf(row);
+        const id = row.messageId;
+        if (at && id) {
+          const time = new Date(at).getTime();
+          if (time > maxTime) {
+            maxTime = time;
+            atMax = /* @__PURE__ */ new Set([id]);
+          } else if (time === maxTime) {
+            atMax.add(id);
+          }
+        }
+        if (!id || boundary.has(id)) continue;
+        if (options.skip?.(id)) continue;
+        if (row.customFields?.[FALLBACK_MARKER_FIELD] !== FALLBACK_MARKER_VALUE) continue;
+        const code = String(row.statusCode ?? "");
+        if (code === IN_FLIGHT_CODE || !DELIVERY_FAILURE.test(code)) continue;
+        if (!targets.has(code)) {
+          ineligible.push(row);
+          continue;
+        }
+        candidates.push(row);
+      }
+      startKey = response.nextKey ?? void 0;
+      if (!startKey) break;
+      if (page === MAX_PAGES - 1) truncated = true;
+    }
+  }
+  const deliveries = await mapWithConcurrency(
+    candidates,
+    options.concurrency ?? DEFAULT_CONCURRENCY,
+    async (row) => {
+      const to = firstRecipient(row.to);
+      if (to === void 0) return void 0;
+      return deliverFallback(
+        { source: row, to, from: options.from, idempotencyKey: `solapi:${row.messageId}` },
+        options.solapi,
+        { clawops: options.clawops, field: options.fallbackField, cache: templateCache }
+      );
+    }
+  );
+  const processed = [];
+  let blocked = 0;
+  for (const row of ineligible) {
+    blocked += 1;
+    options.onBlocked?.({
+      messageId: row.messageId ?? "",
+      to: firstRecipient(row.to) ?? "",
+      statusCode: String(row.statusCode ?? ""),
+      ok: false,
+      reason: "code_not_eligible"
+    });
+  }
+  deliveries.forEach((delivery, index) => {
+    const row = candidates[index];
+    const messageId = row.messageId ?? "";
+    const to = firstRecipient(row.to) ?? "";
+    const statusCode = String(row.statusCode ?? "");
+    if (delivery === void 0) return;
+    if (delivery.status !== "sent") {
+      blocked += 1;
+      options.onBlocked?.(
+        delivery.status === "blocked" ? { messageId, to, statusCode, ...delivery.reason } : (
+          // 문구는 만들었는데 ClawOps 가 거절했다. 다음 스윕이 다시 시도하고,
+          // 멱등키가 같아 중복 발송은 되지 않는다
+          { messageId, to, statusCode, ok: false, reason: "send_rejected" }
+        )
+      );
+      return;
+    }
+    processed.push(messageId);
+    options.onFallback?.({
+      messageId,
+      to,
+      statusCode,
+      source: delivery.source,
+      text: delivery.text
+    });
+  });
+  const cursor = truncated ? options.cursor ?? { updatedAt: startDate.toISOString(), seen: [] } : { updatedAt: new Date(maxTime).toISOString(), seen: [...atMax] };
+  return { cursor, scanned, sent: processed.length, blocked, truncated, processed };
+}
+
+// src/solapi/index.ts
+var ZERO_CASH = { requested: 0, replacement: 0, refund: 0, sum: 0 };
+var CHARGE_KEYS = [
+  "sms",
+  "lms",
+  "mms",
+  "ata",
+  "cta",
+  "cti",
+  "nsa",
+  "rcs_sms",
+  "rcs_lms",
+  "rcs_mms",
+  "rcs_tpl"
+];
+var NO_CHARGE = Object.fromEntries(
+  CHARGE_KEYS.map((k) => [k, {}])
+);
+var NO_PROFIT = Object.fromEntries(CHARGE_KEYS.map((k) => [k, 0]));
+var OURS = /* @__PURE__ */ new Set(["SMS", "LMS", "MMS"]);
+var VENDOR_OPTION_FIELDS = [
+  "kakaoOptions",
+  "rcsOptions",
+  "naverOptions",
+  "voiceOptions",
+  "faxOptions"
+];
+var hasVendorOptions = (message) => VENDOR_OPTION_FIELDS.some((field) => message[field] != null);
+var recipientsOf = (to) => Array.isArray(to) ? to : [to];
+var CLAWOPS_FAILURE_STATUS_CODE = "CLAWOPS";
+function normalizeFallback(config) {
+  if (config === void 0 || config === true) return { enabled: true };
+  if (config === false || !config.enabled) return void 0;
+  return config;
+}
+function isMessageNotReceived(error) {
+  return typeof error === "object" && error !== null && "failedMessageList" in error && Array.isArray(error.failedMessageList);
+}
+function assertConfigSupported(config) {
+  if (!config) return;
+  const unsupported = [];
+  if (config.scheduledDate !== void 0) unsupported.push("scheduledDate");
+  if (config.allowDuplicates === false) unsupported.push("allowDuplicates: false");
+  if (unsupported.length > 0) {
+    throw new chunkTVDUOKJD_cjs.SolapiBridgeError(
+      `ClawOps \uB85C \uBCF4\uB0B4\uB294 \uBA54\uC2DC\uC9C0\uC5D0\uB294 ${unsupported.join(", ")} \uB97C \uC801\uC6A9\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uD574\uB2F9 \uC124\uC815\uC774 \uD544\uC694\uD55C \uBC1C\uC1A1\uC740 \uC194\uB77C\uD53C\uB85C \uBCF4\uB0B4\uAC70\uB098 \uD638\uCD9C\uC744 \uBD84\uB9AC\uD558\uC2ED\uC2DC\uC624.`
+    );
+  }
+}
+function makeGroupInfo(base, counts) {
+  if (base) {
+    return {
+      ...base,
+      count: {
+        ...base.count,
+        total: base.count.total + counts.ok + counts.failed,
+        registeredSuccess: base.count.registeredSuccess + counts.ok,
+        registeredFailed: base.count.registeredFailed + counts.failed,
+        sentReplacement: base.count.sentReplacement + counts.replacement
+      }
+    };
+  }
+  const registered = {
+    total: counts.ok + counts.failed,
+    registeredSuccess: counts.ok,
+    registeredFailed: counts.failed
+  };
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    count: {
+      ...registered,
+      sentTotal: 0,
+      sentFailed: 0,
+      sentSuccess: 0,
+      sentPending: 0,
+      sentReplacement: counts.replacement,
+      refund: 0
+    },
+    countForCharge: NO_CHARGE,
+    balance: ZERO_CASH,
+    point: ZERO_CASH,
+    app: { profit: NO_PROFIT, appId: null },
+    log: [],
+    status: "PENDING",
+    allowDuplicates: false,
+    isRefunded: false,
+    accountId: "",
+    masterAccountId: null,
+    apiVersion: "4",
+    // 솔라피 그룹이 아니므로 getGroupMessages 로 조회되지 않는다. 접두사로 구분한다
+    groupId: `CLAWOPS-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
+    price: {},
+    dateCreated: now,
+    dateUpdated: now,
+    scheduledDate: null,
+    dateSent: null,
+    dateCompleted: null
+  };
+}
+function partition(list) {
+  const forSolapi = [];
+  const forClawOps = [];
+  for (const message of list) {
+    const type = upperType(message);
+    if (type !== "" && !OURS.has(type) || hasVendorOptions(message)) {
+      forSolapi.push(message);
+      continue;
+    }
+    if (message.imageId !== void 0) {
+      throw new chunkTVDUOKJD_cjs.SolapiBridgeError(
+        "imageId \uB294 \uC194\uB77C\uD53C\uC5D0 \uC5C5\uB85C\uB4DC\uB41C \uD30C\uC77C ID \uB77C ClawOps \uB85C \uC804\uB2EC\uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. \uC774\uBBF8\uC9C0 \uCCA8\uBD80\uAC00 \uD544\uC694\uD558\uBA74 ClawOps \uC758 mediaUrl \uB85C \uC9C1\uC811 \uBC1C\uC1A1\uD558\uC2ED\uC2DC\uC624."
+      );
+    }
+    for (const to of recipientsOf(message.to)) forClawOps.push({ to, message });
+  }
+  return { forSolapi, forClawOps };
+}
+function fallbackFrom(message) {
+  const kakaoOptions = message?.kakaoOptions;
+  if (!kakaoOptions || kakaoOptions.disableSms === true) return void 0;
+  return message?.from;
+}
+function clawopsFailure(to, from, error) {
+  return {
+    to: normalizePhone(to),
+    from: normalizePhone(from),
+    type: "SMS",
+    statusMessage: error instanceof Error ? error.message : String(error),
+    country: "82",
+    messageId: "",
+    statusCode: CLAWOPS_FAILURE_STATUS_CODE,
+    accountId: ""
+  };
+}
+function buildPlans(messages, fallbackEnabled) {
+  return messages.map((message) => {
+    const kakaoOptions = message.kakaoOptions;
+    if (!kakaoOptions || !fallbackEnabled || kakaoOptions.bms) {
+      return { outgoing: message, source: message };
+    }
+    const fields = message.customFields ?? {};
+    const canMark = FALLBACK_MARKER_FIELD in fields || Object.keys(fields).length < 10;
+    if (!canMark) return { outgoing: message, source: message };
+    const { from: _from, ...rest } = message;
+    let customFields = message.customFields;
+    if (fallbackFrom(message) !== void 0) {
+      customFields = { ...fields, [FALLBACK_MARKER_FIELD]: FALLBACK_MARKER_VALUE };
+    }
+    return {
+      outgoing: {
+        ...rest,
+        ...customFields ? { customFields } : {},
+        kakaoOptions: { ...kakaoOptions, disableSms: true }
+      },
+      source: message
+    };
+  });
+}
+function matchFailures(plans, failures) {
+  const byRecipient = /* @__PURE__ */ new Map();
+  plans.forEach((plan, index) => {
+    for (const to of recipientsOf(plan.outgoing.to)) {
+      const key = normalizePhone(to);
+      const bucket = byRecipient.get(key);
+      if (bucket) bucket.push(index);
+      else byRecipient.set(key, [index]);
+    }
+  });
+  return failures.map((failure) => {
+    const index = byRecipient.get(normalizePhone(failure.to))?.shift();
+    return { failure, plan: index === void 0 ? void 0 : plans[index] };
+  });
+}
+function makeSend(options, fallbackConfig, templateCache) {
+  const fallbackEnabled = fallbackConfig !== void 0;
+  const concurrency = options.concurrency ?? DEFAULT_CONCURRENCY;
+  const viaClawOps = async (to, message, statusMessage = "\uC815\uC0C1 \uC811\uC218") => {
+    const from = normalizePhone(message.from ?? options.from);
+    const type = clawopsType(message);
+    try {
+      const created = await options.clawops.messages.create({
+        to: normalizePhone(to),
+        from,
+        body: message.text ?? "",
+        type,
+        subject: message.subject
+      });
+      return {
+        ok: true,
+        sent: { messageId: created.messageId, statusCode: "2000", statusMessage }
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        failed: {
+          to: normalizePhone(to),
+          from,
+          type: type.toUpperCase(),
+          statusMessage: error instanceof Error ? error.message : String(error),
+          country: "82",
+          messageId: "",
+          statusCode: CLAWOPS_FAILURE_STATUS_CODE,
+          accountId: ""
+        }
+      };
+    }
+  };
+  const runFallbacks = async (plans, failures, solapi) => {
+    const jobs = matchFailures(plans, failures);
+    const deliveries = await mapWithConcurrency(jobs, concurrency, async (job) => {
+      const from = fallbackFrom(job.plan?.source);
+      if (from === void 0) return void 0;
+      return deliverFallback({ source: job.plan.source, to: job.failure.to, from }, solapi, {
+        clawops: options.clawops,
+        field: fallbackConfig?.field,
+        cache: templateCache
+      });
+    });
+    const sent = [];
+    const failed = [];
+    let replacement = 0;
+    let failedCount = 0;
+    deliveries.forEach((delivery, index) => {
+      const { failure } = jobs[index];
+      if (delivery === void 0) {
+        failed.push(failure);
+        return;
+      }
+      if (delivery.status === "blocked") {
+        fallbackConfig?.onBlocked?.({ to: failure.to, ...delivery.reason });
+        failed.push(failure);
+        return;
+      }
+      if (delivery.status === "send_failed") {
+        failed.push(clawopsFailure(failure.to, options.from, delivery.error));
+        failedCount += 1;
+        return;
+      }
+      sent.push({
+        messageId: delivery.messageId,
+        statusCode: "2000",
+        statusMessage: "\uC815\uC0C1 \uC811\uC218(\uB300\uCCB4\uBC1C\uC1A1)"
+      });
+      replacement += 1;
+      fallbackConfig?.onFallback?.({
+        to: failure.to,
+        source: delivery.source,
+        text: delivery.text
+      });
+    });
+    return { sent, failed, replacement, failedCount };
+  };
+  return async (messages, config) => {
+    const list = Array.isArray(messages) ? messages : [messages];
+    const { forSolapi, forClawOps } = partition(list);
+    const sent = [];
+    const failed = [];
+    let replacement = 0;
+    let ourOk = 0;
+    let ourFailed = 0;
+    const willFallback = fallbackEnabled && forSolapi.some((message) => fallbackFrom(message) !== void 0);
+    if (forClawOps.length > 0 || willFallback) assertConfigSupported(config);
+    if (forClawOps.length > 0) {
+      for (const outcome of await mapWithConcurrency(
+        forClawOps,
+        concurrency,
+        (item) => viaClawOps(item.to, item.message)
+      )) {
+        if (outcome.ok) {
+          sent.push(outcome.sent);
+          ourOk += 1;
+        } else {
+          failed.push(outcome.failed);
+          ourFailed += 1;
+        }
+      }
+    }
+    let base = null;
+    if (forSolapi.length > 0) {
+      const solapi = options.solapi;
+      if (!solapi) {
+        throw new chunkTVDUOKJD_cjs.SolapiBridgeError(
+          "\uC54C\uB9BC\uD1A1\xB7RCS \uB97C \uBCF4\uB0B4\uB824\uBA74 solapi \uC778\uC2A4\uD134\uC2A4\uB97C \uB118\uACA8\uC57C \uD569\uB2C8\uB2E4. new ClawOpsMessageService({ solapi: new SolapiMessageService(key, secret), \u2026 })"
+        );
+      }
+      const plans = buildPlans(forSolapi, fallbackEnabled);
+      let solapiFailed = [];
+      try {
+        const response = await solapi.send(
+          plans.map((plan) => plan.outgoing),
+          config
+        );
+        base = response.groupInfo;
+        sent.push(...response.messageList ?? []);
+        solapiFailed = response.failedMessageList;
+      } catch (error) {
+        if (!isMessageNotReceived(error)) throw error;
+        solapiFailed = error.failedMessageList;
+      }
+      if (solapiFailed.length > 0) {
+        if (!fallbackEnabled) {
+          failed.push(...solapiFailed);
+        } else {
+          const result = await runFallbacks(plans, solapiFailed, solapi);
+          sent.push(...result.sent);
+          failed.push(...result.failed);
+          replacement += result.replacement;
+          ourFailed += result.failedCount;
+        }
+      }
+    }
+    return {
+      groupInfo: makeGroupInfo(base, { ok: ourOk, failed: ourFailed, replacement }),
+      messageList: sent,
+      failedMessageList: failed
+    };
+  };
+}
+var NON_METHOD_KEYS = /* @__PURE__ */ new Set(["then", "toJSON", "inspect"]);
+var DEFAULT_SWEEP_INTERVAL_MS = 5 * 60 * 1e3;
+var PROCESSED_LIMIT = 1e4;
+function startSweepLoop(options, sweep, solapi, templateCache) {
+  const processed = /* @__PURE__ */ new Set();
+  let cursor = sweep.initialCursor;
+  let running = false;
+  const tick = async () => {
+    if (running) return;
+    running = true;
+    try {
+      const result = await sweepFailedAlimtalk({
+        clawops: options.clawops,
+        solapi,
+        from: options.from,
+        cursor,
+        lookbackMs: sweep.lookbackMs,
+        on: sweep.on,
+        types: sweep.types,
+        fallbackField: sweep.field,
+        concurrency: options.concurrency,
+        templateCache,
+        skip: (messageId) => processed.has(messageId),
+        onFallback: sweep.onFallback,
+        onBlocked: sweep.onBlocked
+      });
+      cursor = result.cursor;
+      for (const messageId of result.processed) processed.add(messageId);
+      if (processed.size > PROCESSED_LIMIT) {
+        for (const messageId of [...processed].slice(0, processed.size - PROCESSED_LIMIT / 2)) {
+          processed.delete(messageId);
+        }
+      }
+      if (result.scanned > 0) sweep.onCursor?.(result.cursor);
+    } catch (error) {
+      sweep.onError?.(error);
+    } finally {
+      running = false;
+    }
+  };
+  const timer = setInterval(() => void tick(), sweep.intervalMs ?? DEFAULT_SWEEP_INTERVAL_MS);
+  timer.unref?.();
+}
+function create(options) {
+  const fallbackConfig = normalizeFallback(options.fallback);
+  const templateCache = /* @__PURE__ */ new Map();
+  const send = makeSend(options, fallbackConfig, templateCache);
+  if (fallbackConfig?.mode === "sweep") {
+    if (!options.solapi) {
+      throw new chunkTVDUOKJD_cjs.SolapiBridgeError(
+        "mode: 'sweep' \uC740 \uC194\uB77C\uD53C \uB9AC\uD3EC\uD2B8\uB97C \uD6D1\uB294 \uAE30\uB2A5\uC774\uB77C solapi \uC778\uC2A4\uD134\uC2A4\uAC00 \uD544\uC694\uD569\uB2C8\uB2E4. \uBB38\uC790\uB9CC \uBCF4\uB0B8\uB2E4\uBA74 \uC774 \uC124\uC815\uC740 \uD560 \uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4."
+      );
+    }
+    startSweepLoop(options, fallbackConfig, options.solapi, templateCache);
+  }
+  const solapi = options.solapi;
+  const handler = solapi ? {
+    get(instance, property) {
+      if (property === "send") return send;
+      const value = Reflect.get(instance, property, instance);
+      return typeof value === "function" ? value.bind(instance) : value;
+    }
+  } : {
+    get(_instance, property) {
+      if (property === "send") return send;
+      if (typeof property === "symbol" || NON_METHOD_KEYS.has(property)) return void 0;
+      if (property in Object.prototype) {
+        return Reflect.get(Object.prototype, property);
+      }
+      return () => {
+        throw new chunkTVDUOKJD_cjs.SolapiBridgeError(
+          `${String(property)}() \uB294 \uC194\uB77C\uD53C \uAE30\uB2A5\uC785\uB2C8\uB2E4. solapi \uC778\uC2A4\uD134\uC2A4\uB97C \uB118\uACA8\uC8FC\uC138\uC694.`
+        );
+      };
+    }
+  };
+  return new Proxy(solapi ?? {}, handler);
+}
+var ClawOpsMessageService = function(options) {
+  return create(options);
+};
+
+Object.defineProperty(exports, "SolapiBridgeError", {
+  enumerable: true,
+  get: function () { return chunkTVDUOKJD_cjs.SolapiBridgeError; }
+});
+exports.CLAWOPS_FAILURE_STATUS_CODE = CLAWOPS_FAILURE_STATUS_CODE;
+exports.ClawOpsMessageService = ClawOpsMessageService;
+exports.DEFAULT_FALLBACK_CODES = DEFAULT_FALLBACK_CODES;
+exports.DEFAULT_FALLBACK_FIELD = DEFAULT_FALLBACK_FIELD;
+exports.FALLBACK_MARKER_FIELD = FALLBACK_MARKER_FIELD;
+exports.resolveFallbackText = resolveFallbackText;
+exports.sweepFailedAlimtalk = sweepFailedAlimtalk;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map