@sayren/store-sdk 0.53.0 → 0.55.0

package/src/schemas/coupon-rules.ts

@@ -1,6 +1,5 @@
 import * as z from "zod";
 import {
-  anyConditionHolds,
   type BirthdateFact,
   birthdateFactOf,
   type ConditionCatalog,
@@ -19,6 +18,7 @@ import {
   conditionIssues,
   conditionRuleSchema,
   evaluateCondition,
+  evaluateConditionNode,
   isConditionGroup,
 } from "./condition-tree";
 
@@ -27,7 +27,8 @@ import {
  *
  * 쿠폰은 세 트리를 갖는다.
  * - `eligibility`(사용 조건): 구매자·주문서·시각. 그룹 중첩 3단까지
- * - `targetRules`(할인 대상): 줄 단위. `{ include, exclude }` 고정 형태 — 포함은 하나라도 맞으면 대상(비면 전 상품), 제외는 하나라도 맞으면 빠지고 포함보다 우선
+ * - `targetTree`(할인 대상, 이슈 #263): 줄 단위. `{ include, exclude }` 각각 조건 그룹(3단) — 포함이 참이면 대상(비면 전 상품), 제외가 참이면 빠지고 포함보다 우선(비면 제외 없음).
+ *   옛 칸 `targetRules`(평평한 「하나라도」 목록)는 `couponTargetTreeFromRules`로 같은 트리가 되고, 응답의 `targetRules`는 트리에서 만든 가장 가까운 값이다
  * - `audience`(발급 대상): 누가 받을 수 있는가. 구매자 사실 값만
  *
  * 기간·한도·혜택·`memberOnly`·중복 정책은 트리 밖 칸이다. 옛 칸(`conditions`·`target`)은 프리셋 변환(`couponRulesFromLegacy`)으로 같은 트리가 된다 —
@@ -424,6 +425,20 @@ export type CouponTargetRules = z.infer<typeof couponTargetRulesSchema>;
 
 export const COUPON_TARGET_RULES_ALL: CouponTargetRules = { include: [], exclude: [] };
 
+/** 할인 대상 트리(이슈 #263) — 포함·제외 각각 조건 그룹(3단, 규칙 50개). 다른 자리와 같은 그룹 형식이다 */
+export const couponTargetTreeSchema = z.strictObject({
+  include: (conditionGroupSchema as z.ZodType<ConditionGroup>).describe(
+    "포함 그룹 — 참인 줄이 대상. 비면 전 상품",
+  ),
+  exclude: (conditionGroupSchema as z.ZodType<ConditionGroup>).describe(
+    "제외 그룹 — 참인 줄은 대상에서 빠진다. 포함보다 우선한다. 비면 제외 없음",
+  ),
+});
+export interface CouponTargetTree {
+  include: ConditionGroup;
+  exclude: ConditionGroup;
+}
+
 export const EMPTY_CONDITION_GROUP: ConditionGroup = { combinator: "and", rules: [] };
 
 /** 사용 조건·발급 대상 트리 */
@@ -464,6 +479,60 @@ export function canonicalizeCouponTargetRules(rules: CouponTargetRules): CouponT
   };
 }
 
+/**
+ * 규칙 1개 이하 그룹은 결합어와 무관하다 — `or`로 고정해 옛 쿠폰의 `{or,[r]}`와 화면이 보낸 `{and,[r]}`를 같은 값으로 본다.
+ * 규칙 없는 하위 그룹은 뺀다 — 빈 그룹은 참으로 평가되므로 남기면 포함 「하나 이상」은 전 상품, 제외는 모든 상품을 뺀다(화면 `treeOf`와 같은 뜻)
+ */
+function canonicalTargetGroup(group: ConditionGroup): ConditionGroup {
+  const rules = group.rules.flatMap((node): ConditionNode[] => {
+    if (!isConditionGroup(node)) return [canonicalizeConditionRule(node)];
+    const child = canonicalTargetGroup(node);
+    return child.rules.length > 0 ? [child] : [];
+  });
+  return { combinator: rules.length <= 1 ? "or" : group.combinator, rules };
+}
+
+/** 할인 대상 트리의 정규형 — 저장·잠금 비교·승인 비교·스냅샷이 같은 함수다 */
+export function canonicalizeCouponTargetTree(tree: CouponTargetTree): CouponTargetTree {
+  return {
+    include: canonicalTargetGroup(tree.include),
+    exclude: canonicalTargetGroup(tree.exclude),
+  };
+}
+
+/** 옛 평평한 목록 → 트리. 「하나라도」가 그대로 `or` 그룹이다(같은 줄 판정) */
+export function couponTargetTreeFromRules(rules: CouponTargetRules): CouponTargetTree {
+  return {
+    include: { combinator: "or", rules: rules.include },
+    exclude: { combinator: "or", rules: rules.exclude },
+  };
+}
+
+/** 그룹이 평평한 「하나라도」 목록으로 같은 뜻인가 — 하위 그룹이 없고 `or`이거나 규칙이 1개 이하 */
+function flatRulesOf(group: ConditionGroup): ConditionRule[] | null {
+  if (group.rules.some(isConditionGroup)) return null;
+  if (group.combinator === "and" && group.rules.length > 1) return null;
+  return group.rules as ConditionRule[];
+}
+
+/**
+ * 트리 → 옛 평평한 목록. 같은 뜻으로 옮길 수 없으면(`모두`에 규칙 2개 이상, 하위 그룹) `rulesOnly: true`이고 목록은
+ * 그룹 최상위 규칙을 평평하게 모은 가장 가까운 값이다
+ */
+export function couponTargetRulesFromTree(tree: CouponTargetTree): {
+  targetRules: CouponTargetRules;
+  rulesOnly: boolean;
+} {
+  const include = flatRulesOf(tree.include);
+  const exclude = flatRulesOf(tree.exclude);
+  const top = (group: ConditionGroup) =>
+    group.rules.filter((node): node is ConditionRule => !isConditionGroup(node));
+  return {
+    targetRules: { include: include ?? top(tree.include), exclude: exclude ?? top(tree.exclude) },
+    rulesOnly: include === null || exclude === null,
+  };
+}
+
 export function canonicalizeCouponStacking(stacking: CouponStacking): CouponStacking {
   return {
     combinesWith: {
@@ -495,7 +564,15 @@ export interface LegacyCouponTarget {
 
 export interface CouponRuleTrees {
   eligibility: ConditionGroup;
+  /** 할인 대상의 옛 평평한 목록 — `targetTree`가 있으면 그 트리에서 만든 가장 가까운 값이다 */
   targetRules: CouponTargetRules;
+  /** 할인 대상 트리(이슈 #263). 없으면 `targetRules`에서 만든다(`couponTargetTreeOf`) — 계산은 트리만 읽는다 */
+  targetTree?: CouponTargetTree;
+}
+
+/** 묶음의 할인 대상 트리 — 트리가 없으면 옛 목록에서 만든다(읽기 한 경로) */
+export function couponTargetTreeOf(trees: Pick<CouponRuleTrees, "targetRules" | "targetTree">) {
+  return trees.targetTree ?? couponTargetTreeFromRules(trees.targetRules);
 }
 
 const inRule = (field: string, ids: readonly string[]): ConditionRule[] =>
@@ -552,6 +629,10 @@ const isFirstOrderRule = (node: ConditionNode): boolean =>
 const isInstantExcludeRule = (rule: ConditionRule) =>
   rule.field === "line.hasInstantDiscount" && rule.operator === "=" && rule.value === true;
 
+const instantExcluded = (exclude: ConditionGroup) =>
+  (exclude.combinator === "or" || exclude.rules.length <= 1) &&
+  exclude.rules.some((node) => !isConditionGroup(node) && isInstantExcludeRule(node));
+
 const isIdRule = (rule: ConditionRule) =>
   (rule.field === "line.productId" || rule.field === "line.categoryId") && rule.operator === "in";
 
@@ -575,9 +656,11 @@ export function legacyFromCouponRules(
           .flatMap((r) => r.value as string[]),
       ),
     ].sort();
-  const { include, exclude } = trees.targetRules;
+  const flat = couponTargetRulesFromTree(couponTargetTreeOf(trees));
+  const { include, exclude } = flat.targetRules;
   const mappedEligibility = nodes.filter((n) => n === minRule || n === firstRule).length;
   const rulesOnly =
+    flat.rulesOnly ||
     mappedEligibility !== trees.eligibility.rules.length ||
     nodes.filter(isMinOrderRule).length > 1 ||
     include.some((r) => !isIdRule(r)) ||
@@ -587,7 +670,8 @@ export function legacyFromCouponRules(
       minOrderAmount: minRule ? (minRule.value as number) : 0,
       firstOrderOnly: Boolean(firstRule),
       memberOnly,
-      stackWithInstantDiscount: !exclude.some(isInstantExcludeRule),
+      // 즉시할인 줄을 모두 빼는 것은 제외가 「하나 이상」(또는 규칙 하나)이고 즉시할인 규칙이 최상위에 있을 때뿐이다 — 「모두」 묶음의 일부면 일부 줄만 빠진다
+      stackWithInstantDiscount: !instantExcluded(couponTargetTreeOf(trees).exclude),
     },
     target: {
       includeProductIds: ids(include, "line.productId"),
@@ -601,11 +685,22 @@ export function legacyFromCouponRules(
 
 // ─── 평가(쿠폰용) ─────────────────────────────────────
 
-/** 줄이 대상인가 — 제외가 포함보다 우선, 포함이 비면 전 상품 */
+/**
+ * 줄이 대상인가(트리) — 제외가 포함보다 우선, 포함이 비면 전 상품, 제외가 비면 제외 없음(빈 그룹 참 규칙을 쓰지 않는다).
+ * 계산(`quotePricing`·최대 조합·대상 상품 판정)은 모두 이 함수를 지난다
+ */
+export function couponTargetTreeMatches(tree: CouponTargetTree, line: CouponLineContext): boolean {
+  if (
+    tree.exclude.rules.length > 0 &&
+    evaluateConditionNode(tree.exclude, COUPON_LINE_CONDITIONS, line)
+  )
+    return false;
+  return evaluateConditionNode(tree.include, COUPON_LINE_CONDITIONS, line);
+}
+
+/** 줄이 대상인가(옛 평평한 목록) — 트리로 바꿔 같은 판정 함수를 지난다 */
 export function couponLineMatches(rules: CouponTargetRules, line: CouponLineContext): boolean {
-  if (anyConditionHolds(rules.exclude, COUPON_LINE_CONDITIONS, line)) return false;
-  if (rules.include.length === 0) return true;
-  return anyConditionHolds(rules.include, COUPON_LINE_CONDITIONS, line);
+  return couponTargetTreeMatches(couponTargetTreeFromRules(rules), line);
 }
 
 /** 사용 조건 실패 사유 — 옛 칸으로 옮겨지는 실패는 옛 코드를 그대로 쓴다 */
@@ -752,6 +847,7 @@ export function couponRuleIssues(input: {
   perMemberUseLimit?: number | null;
   eligibility?: ConditionGroup;
   targetRules?: CouponTargetRules;
+  targetTree?: CouponTargetTree;
   audience?: ConditionGroup;
 }): CouponRuleIssue[] {
   const issues: CouponRuleIssue[] = [];
@@ -785,7 +881,16 @@ export function couponRuleIssues(input: {
       }),
     );
   }
-  if (input.targetRules) {
+  if (input.targetTree) {
+    for (const key of ["include", "exclude"] as const) {
+      push(
+        ["targetTree", key],
+        conditionIssues(input.targetTree[key], COUPON_LINE_CONDITIONS, {
+          allowed: allowedIn("target"),
+        }),
+      );
+    }
+  } else if (input.targetRules) {
     for (const key of ["include", "exclude"] as const) {
       push(
         ["targetRules", key],
@@ -860,9 +965,14 @@ export function couponRuleIssues(input: {
 
 /** 정규형 트리 묶음 */
 export function canonicalizeCouponTrees(trees: CouponRuleTrees): CouponRuleTrees {
+  const eligibility = canonicalizeConditionGroup(trees.eligibility);
+  if (!trees.targetTree)
+    return { eligibility, targetRules: canonicalizeCouponTargetRules(trees.targetRules) };
+  const targetTree = canonicalizeCouponTargetTree(trees.targetTree);
   return {
-    eligibility: canonicalizeConditionGroup(trees.eligibility),
-    targetRules: canonicalizeCouponTargetRules(trees.targetRules),
+    eligibility,
+    targetRules: canonicalizeCouponTargetRules(couponTargetRulesFromTree(targetTree).targetRules),
+    targetTree,
   };
 }
 
@@ -1002,6 +1112,23 @@ export function describeCouponTargetRules(
   return `${include} (${exclude} 제외)`;
 }
 
+/**
+ * 할인 대상 문구(트리) — 「상품 1개 그리고 판매가 30,000원 이상 (즉시할인 상품 제외)」. 포함이 비면 「전 상품」.
+ * 「하나라도」만 쓴 옛 쿠폰은 `describeCouponTargetRules`와 같은 문구다
+ */
+export function describeCouponTargetTree(
+  tree: CouponTargetTree,
+  formatMoney?: (minor: number) => string,
+): string {
+  const flat = couponTargetRulesFromTree(tree);
+  if (!flat.rulesOnly) return describeCouponTargetRules(flat.targetRules, formatMoney);
+  const include = tree.include.rules.length
+    ? describeCouponGroup(tree.include, formatMoney)
+    : "전 상품";
+  if (tree.exclude.rules.length === 0) return include;
+  return `${include} (${describeCouponGroup(tree.exclude, formatMoney)} 제외)`;
+}
+
 /**
  * 스토어프론트 `requirements` — 최상위 `and`면 노드마다 한 줄(그룹은 문구 한 줄), 최상위 `or`면 트리 전체를 한 줄로.
  * `minOrderAmount`(옛 필드)와 같은 원천에서 나온다.

package/src/schemas/coupon.ts

@@ -8,6 +8,7 @@ import {
   couponRulesFromLegacy,
   couponStackingSchema,
   couponTargetRulesSchema,
+  couponTargetTreeSchema,
 } from "./coupon-rules";
 import { currencyCodeSchema } from "./currency";
 import {
@@ -100,7 +101,12 @@ const descriptions = {
     "주면 `conditions`의 최소 주문 금액·첫 구매를 쓰지 않는다(`conditions`에는 `memberOnly`만 둔다). 필드 목록은 `COUPON_CONDITION_FIELDS`",
   targetRules:
     "할인 대상 규칙(이슈 #222) — `include`(하나라도 맞으면 대상, 비면 전 상품)·`exclude`(하나라도 맞으면 제외, 포함보다 우선). " +
-    "주면 `target`과 `conditions.stackWithInstantDiscount`를 쓰지 않는다(즉시할인 제외는 `line.hasInstantDiscount` 규칙)",
+    "주면 `target`과 `conditions.stackWithInstantDiscount`를 쓰지 않는다(즉시할인 제외는 `line.hasInstantDiscount` 규칙). " +
+    "포함·제외를 「모두」나 묶음으로 걸려면 `targetTree`를 쓴다",
+  targetTree:
+    "할인 대상 트리(이슈 #263) — `include`·`exclude` 각각 사용 조건과 같은 그룹 `{ combinator: and|or, rules }`(3단·규칙 50개, 줄 필드만). " +
+    "포함 그룹이 참인 줄이 대상(비면 전 상품), 제외 그룹이 참인 줄은 빠진다(포함보다 우선, 비면 제외 없음). " +
+    "주면 `targetRules`·`target`·`conditions.stackWithInstantDiscount`를 함께 주지 않는다",
   audience:
     "발급 대상 트리(이슈 #222) — 셀러 지급·받기·회원가입 지급에서 누가 받을 수 있는가. 구매자 조건만. 코드 입력형에는 두지 않는다",
   stacking:
@@ -119,6 +125,7 @@ const descriptions = {
 const ruleFields = {
   eligibility: couponConditionTreeSchema.optional().describe(descriptions.eligibility),
   targetRules: couponTargetRulesSchema.optional().describe(descriptions.targetRules),
+  targetTree: couponTargetTreeSchema.optional().describe(descriptions.targetTree),
   audience: couponConditionTreeSchema.optional().describe(descriptions.audience),
   stacking: couponStackingSchema.optional().describe(descriptions.stacking),
   reward: couponRewardSchema.nullable().optional().describe(descriptions.reward),
@@ -145,6 +152,7 @@ export function couponRequestRuleIssues(body: {
   >;
   eligibility?: CouponRuleTrees["eligibility"];
   targetRules?: CouponRuleTrees["targetRules"];
+  targetTree?: CouponRuleTrees["targetTree"];
   audience?: CouponRuleTrees["eligibility"];
   stacking?: { perOrderLimit: number };
   reward?: { type: "TIERED" | "BUY_X_GET_Y" | "POINT" } | null;
@@ -171,6 +179,14 @@ export function couponRequestRuleIssues(body: {
       path: ["target"],
       message: "할인 대상 규칙을 주면 대상 상품·즉시할인 제외는 규칙으로 둡니다",
     });
+  if (
+    body.targetTree &&
+    (body.targetRules || body.target || body.conditions?.stackWithInstantDiscount !== undefined)
+  )
+    issues.push({
+      path: ["targetTree"],
+      message: "할인 대상 트리를 주면 할인 대상 규칙·대상 상품·즉시할인 제외는 트리로 둡니다",
+    });
   const legacy = couponRulesFromLegacy(conditions, {
     includeProductIds: body.target?.includeProductIds ?? [],
     includeCategoryIds: body.target?.includeCategoryIds ?? [],
@@ -184,6 +200,7 @@ export function couponRequestRuleIssues(body: {
       perMemberUseLimit: body.perMemberUseLimit ?? null,
       eligibility: body.eligibility ?? legacy.eligibility,
       targetRules: body.targetRules ?? legacy.targetRules,
+      ...(body.targetTree ? { targetTree: body.targetTree } : {}),
       ...(body.audience ? { audience: body.audience } : {}),
     }),
   );
@@ -445,7 +462,12 @@ export const couponSchema = z.object({
   targetRules: couponTargetRulesSchema
     .optional()
     .describe(
-      "할인 대상 규칙(이슈 #222). 옛 쿠폰은 `target`에서 만든 규칙이다. 서버는 항상 싣는다",
+      "할인 대상 규칙(이슈 #222). 옛 쿠폰은 `target`에서 만든 규칙이다. `targetTree`가 「하나라도」 목록으로 나타나지 않으면 가장 가까운 값이고 `rulesOnly`가 true다. 서버는 항상 싣는다",
+    ),
+  targetTree: couponTargetTreeSchema
+    .optional()
+    .describe(
+      "할인 대상 트리(이슈 #263). 할인 대상의 원천이다. 옛 쿠폰은 `targetRules`에서 만든 트리(「하나 이상」 그룹)다. 서버는 항상 싣는다",
     ),
   audience: couponConditionTreeSchema
     .optional()

package/src/schemas/customer.ts

@@ -1,7 +1,7 @@
 import * as z from "zod";
 import { orderItemStatusSchema, pageQueryShape } from "./common";
 import { strictRequest } from "./strict";
-import { customerUserinfoSchema } from "./userinfo";
+import { customerUserinfoInputSchema, customerUserinfoSchema } from "./userinfo";
 
 /** 구매자 목록 정렬 */
 export const customerSortSchema = z
@@ -222,3 +222,16 @@ export const customerWithdrawalBlockedDetailsSchema = z.object({
 export type CustomerWithdrawalBlockedDetails = z.infer<
   typeof customerWithdrawalBlockedDetailsSchema
 >;
+
+/**
+ * `PATCH /v1/customers/{id}` 본문(이슈 #267) — 셀러가 구매자 생일을 바꾼다. 구매자는 생일을 한 번만 입력하므로 바꾸는 쪽은 셀러다.
+ * 준 클레임만 바뀌고 `null`은 지운다
+ */
+export const updateCustomerRequestSchema = strictRequest(
+  z.object({
+    userinfo: customerUserinfoInputSchema
+      .pick({ birthdate: true })
+      .describe("바꿀 OIDC 클레임 — 지금은 `birthdate`만 받는다"),
+  }),
+);
+export type UpdateCustomerRequest = z.infer<typeof updateCustomerRequestSchema>;

package/src/schemas/product-info.ts

@@ -217,3 +217,40 @@ export const infoSectionLocalizationRequestSchema = z.strictObject({
 });
 
 export type InfoSectionLocalizationRequest = z.infer<typeof infoSectionLocalizationRequestSchema>;
+
+// ── 고시 템플릿 ──────────────────────────────────────────────────
+
+export const MAX_NOTICE_TEMPLATE_NAME = 100;
+
+/**
+ * 고시 템플릿 (이슈 #250) — 자주 쓰는 고시(품목군 + 칸 값)를 이름 붙여 둔다. **적용은 복사다** — 상품의 `notice`에 같은 값을 실어 저장할 뿐
+ * 상품과 연결하지 않는다. 템플릿을 고치거나 지워도 적용한 상품의 고시는 바뀌지 않는다. 이름은 상점 안에서 대소문자·앞뒤 공백을 무시하고 유일하다.
+ */
+export const noticeTemplateSchema = z.object({
+  templateId: z.string(),
+  name: z.string(),
+  schemaId: z.string().describe("품목군 코드"),
+  version: z.number().int().describe("품목군 버전"),
+  values: z.record(z.string(), z.string()).describe("칸 키 → 값. 비운 칸은 없다"),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+});
+
+export type NoticeTemplate = z.infer<typeof noticeTemplateSchema>;
+
+/**
+ * `POST /v1/notice-templates`·`PUT /v1/notice-templates/{templateId}` 본문 — 통째로 바꾼다. 칸 값 규칙은 상품 `notice`와 같다
+ * (법정 문구 칸 400 `INVALID_NOTICE_FIELD`, 없는 품목군 400 `INVALID_INFO_CODE`, 길이 초과 400 `NOTICE_VALUE_TOO_LONG`).
+ * 같은 이름이 있으면 409 `NOTICE_TEMPLATE_NAME_TAKEN`
+ */
+export const noticeTemplateRequestSchema = strictRequest(
+  z.object({
+    name: z.string().trim().min(1).max(MAX_NOTICE_TEMPLATE_NAME),
+    schemaId: productNoticeRequestSchema.shape.schemaId,
+    version: productNoticeRequestSchema.shape.version,
+    values: productNoticeRequestSchema.shape.values,
+  }),
+);
+
+export type NoticeTemplateRequest = z.infer<typeof noticeTemplateRequestSchema>;
+export type NoticeTemplateRequestInput = z.input<typeof noticeTemplateRequestSchema>;

package/src/schemas/promotion.ts

@@ -7,11 +7,15 @@ import {
   type CouponRuleTrees,
   type CouponStacking,
   type CouponTargetRules,
+  type CouponTargetTree,
   couponLineContextOf,
-  couponLineMatches,
   couponRulesFromLegacy,
   couponStackingSchema,
+  couponTargetRulesFromTree,
   couponTargetRulesSchema,
+  couponTargetTreeFromRules,
+  couponTargetTreeMatches,
+  couponTargetTreeSchema,
   couponTimeFactsAt,
   evaluateCouponEligibility,
   pickCouponFacts,
@@ -307,6 +311,11 @@ export const couponRuleSchema = z.object({
     .describe(
       "할인 대상 규칙(이슈 #222). 없으면 `target`·`conditions.stackWithInstantDiscount`에서 만든다",
     ),
+  targetTree: couponTargetTreeSchema
+    .optional()
+    .describe(
+      "할인 대상 트리(이슈 #263). 없으면 `targetRules`(없으면 옛 칸)에서 만든다. 있으면 이것이 원천이고 `targetRules`는 가장 가까운 옛 값이다",
+    ),
   stacking: couponStackingSchema
     .optional()
     .describe("중복 사용 정책(이슈 #222). 없으면 종류별 한 장·서로 결합·적립금과 함께"),
@@ -314,17 +323,22 @@ export const couponRuleSchema = z.object({
 });
 export type CouponRule = z.infer<typeof couponRuleSchema>;
 
-/** 규칙의 트리 — 트리 칸이 없으면 옛 칸에서 만든다(계산은 늘 이 한 경로) */
+/** 규칙의 트리 — 트리 칸이 없으면 옛 칸에서 만든다(계산은 늘 이 한 경로). 할인 대상은 늘 트리(`targetTree`)까지 채운다 */
 export function couponTreesOf(
   rule: Pick<CouponRule, "conditions" | "target"> & {
     eligibility?: ConditionGroup;
     targetRules?: CouponTargetRules;
+    targetTree?: CouponTargetTree;
   },
-): CouponRuleTrees {
+): CouponRuleTrees & { targetTree: CouponTargetTree } {
   const legacy = couponRulesFromLegacy(rule.conditions, rule.target);
+  const targetRules = rule.targetTree
+    ? couponTargetRulesFromTree(rule.targetTree).targetRules
+    : (rule.targetRules ?? legacy.targetRules);
   return {
     eligibility: rule.eligibility ?? legacy.eligibility,
-    targetRules: rule.targetRules ?? legacy.targetRules,
+    targetRules,
+    targetTree: rule.targetTree ?? couponTargetTreeFromRules(targetRules),
   };
 }
 
@@ -609,17 +623,20 @@ export function allocateByWeight(total: number, weights: readonly number[]): num
 
 /** 카테고리 경로(`/a/b/c/`)가 그 카테고리 또는 하위를 가리키는가 */
 /**
- * 줄이 쿠폰 대상인가 — 제외가 포함보다 우선하고, 포함이 비면 전 상품이다. 트리(`targetRules`)가 없으면 옛 칸에서 만든 트리로 본다.
+ * 줄이 쿠폰 대상인가 — 제외가 포함보다 우선하고, 포함이 비면 전 상품이다. 트리(`targetTree`, 없으면 `targetRules`)가 없으면 옛 칸에서 만든 트리로 본다.
  * `quantity`를 생략하면 1로 본다(단가 조건은 금액 ÷ 수량).
  */
 export function isCouponTargetLine(
-  rule: Pick<CouponRule, "target" | "conditions"> & { targetRules?: CouponTargetRules },
+  rule: Pick<CouponRule, "target" | "conditions"> & {
+    targetRules?: CouponTargetRules;
+    targetTree?: CouponTargetTree;
+  },
   line: Pick<PricingLine, "productId" | "categoryPath" | "baseAmount" | "amount"> & {
     quantity?: number;
   },
 ): boolean {
-  return couponLineMatches(
-    couponTreesOf(rule).targetRules,
+  return couponTargetTreeMatches(
+    couponTreesOf(rule).targetTree,
     couponLineContextOf({ ...line, quantity: line.quantity ?? 1 }),
   );
 }
@@ -719,7 +736,7 @@ export function quotePricing(input: PricingInput): PricingResult {
     const eligible = lines.filter((entry) =>
       pinned
         ? pinned.has(entry.line.lineId)
-        : couponLineMatches(trees.targetRules, couponLineContextOf(entry.line)),
+        : couponTargetTreeMatches(trees.targetTree, couponLineContextOf(entry.line)),
     );
     result.eligibleLineIds = eligible.map((entry) => entry.line.lineId);
     if (eligible.length === 0) return "NO_ELIGIBLE_ITEMS";