@kimdaegyu/babmukdang-shared 2.0.2 → 2.0.4

package/dist/index.cjs

@@ -5,7 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -168,8 +167,13 @@ __export(domain_exports, {
   MealPlanDecisionStageTypeSchema: () => MealPlanDecisionStageTypeSchema,
   MealPlanDecisionTaskKeySchema: () => MealPlanDecisionTaskKeySchema,
   MealPlanDecisionTaskProgressSchema: () => MealPlanDecisionTaskProgressSchema,
-  MealPlanDecisionTaskReadyRequestSchema: () => MealPlanDecisionTaskReadyRequestSchema,
   MealPlanDecisionTaskStatusSchema: () => MealPlanDecisionTaskStatusSchema,
+  MealPlanDecisionVoteSocketAckSchema: () => MealPlanDecisionVoteSocketAckSchema,
+  MealPlanDecisionVoteSocketErrorSchema: () => MealPlanDecisionVoteSocketErrorSchema,
+  MealPlanDecisionVoteSocketEvent: () => MealPlanDecisionVoteSocketEvent,
+  MealPlanDecisionVoteSocketFailureAckSchema: () => MealPlanDecisionVoteSocketFailureAckSchema,
+  MealPlanDecisionVoteSocketPayloadSchema: () => MealPlanDecisionVoteSocketPayloadSchema,
+  MealPlanDecisionVoteSocketSuccessAckSchema: () => MealPlanDecisionVoteSocketSuccessAckSchema,
   MealPlanGuestParticipantSchema: () => MealPlanGuestParticipantSchema,
   MealPlanGuestSessionQuerySchema: () => MealPlanGuestSessionQuerySchema,
   MealPlanGuestSessionResponseSchema: () => MealPlanGuestSessionResponseSchema,
@@ -343,10 +347,7 @@ var import_zod7 = require("zod");
 var import_zod = require("zod");
 var isoDateRegex = /^\d{4}-\d{2}-\d{2}$/;
 var ISODateStringSchema = import_zod.z.string().regex(isoDateRegex, "Expected ISO date string in YYYY-MM-DD format");
-var ISODateTimeStringSchema = import_zod.z.string().datetime({
-  offset: true,
-  message: "Expected ISO datetime string"
-});
+var ISODateTimeStringSchema = import_zod.z.string().datetime({ offset: true, message: "Expected ISO datetime string" });
 var TimeHHmmStringSchema = import_zod.z.string().regex(/^\d{2}:\d{2}$/, "Expected time string in HH:mm format");
 
 // src/domain/common/schema/id.schema.ts
@@ -393,14 +394,11 @@ var PageMetaSchema = import_zod3.z.object({
   hasNext: import_zod3.z.boolean(),
   hasPrevious: import_zod3.z.boolean()
 });
-var PageResponseSchema = /* @__PURE__ */ __name((item) => import_zod3.z.object({
+var PageResponseSchema = (item) => import_zod3.z.object({
   items: import_zod3.z.array(item),
   meta: PageMetaSchema
-}), "PageResponseSchema");
-var SortDirectionSchema = import_zod3.z.enum([
-  "asc",
-  "desc"
-]);
+});
+var SortDirectionSchema = import_zod3.z.enum(["asc", "desc"]);
 
 // src/domain/member/member.schema.ts
 var import_zod5 = require("zod");
@@ -417,24 +415,10 @@ var UploadPresignImageRequestSchema = import_zod4.default.object({
 });
 
 // src/domain/member/member.schema.ts
-var MemberRoleSchema = import_zod5.z.enum([
-  "USER",
-  "ADMIN"
-]);
-var LocationConsentStatusSchema = import_zod5.z.enum([
-  "UNKNOWN",
-  "GRANTED",
-  "DENIED"
-]);
-var OnboardingStatusSchema = import_zod5.z.enum([
-  "REQUIRED",
-  "COMPLETED"
-]);
-var PermissionKindSchema = import_zod5.z.enum([
-  "LOCATION",
-  "NOTIFICATION",
-  "CAMERA"
-]);
+var MemberRoleSchema = import_zod5.z.enum(["USER", "ADMIN"]);
+var LocationConsentStatusSchema = import_zod5.z.enum(["UNKNOWN", "GRANTED", "DENIED"]);
+var OnboardingStatusSchema = import_zod5.z.enum(["REQUIRED", "COMPLETED"]);
+var PermissionKindSchema = import_zod5.z.enum(["LOCATION", "NOTIFICATION", "CAMERA"]);
 var PermissionStatusSchema = import_zod5.z.enum([
   "UNKNOWN",
   "PROMPT",
@@ -443,12 +427,7 @@ var PermissionStatusSchema = import_zod5.z.enum([
   "LIMITED",
   "UNSUPPORTED"
 ]);
-var PermissionPlatformSchema = import_zod5.z.enum([
-  "WEB",
-  "IOS",
-  "ANDROID",
-  "UNKNOWN"
-]);
+var PermissionPlatformSchema = import_zod5.z.enum(["WEB", "IOS", "ANDROID", "UNKNOWN"]);
 var DevicePermissionSnapshotSchema = import_zod5.z.object({
   kind: PermissionKindSchema,
   status: PermissionStatusSchema,
@@ -522,7 +501,9 @@ var UpdateProfileRequestSchema = import_zod5.z.object({
   bio: import_zod5.z.string().max(500).nullable()
 });
 var UpdatePreferenceRequestSchema = MemberFoodPreferenceSchema;
-var CompleteOnboardingRequestSchema = UpdateProfileRequestSchema.merge(UpdatePreferenceRequestSchema);
+var CompleteOnboardingRequestSchema = UpdateProfileRequestSchema.merge(
+  UpdatePreferenceRequestSchema
+);
 var OnboardingDraftSchema = import_zod5.z.object({
   username: import_zod5.z.string().min(1).max(50).optional(),
   profileImageUrl: import_zod5.z.string().url().nullable().optional(),
@@ -563,11 +544,7 @@ var KakaoPlaceRawSchema = import_zod6.z.object({
 });
 
 // src/domain/article/article.schema.ts
-var ArticleSortBySchema = import_zod7.z.enum([
-  "createdAt",
-  "likeCount",
-  "commentCount"
-]);
+var ArticleSortBySchema = import_zod7.z.enum(["createdAt", "likeCount", "commentCount"]);
 var ArticleListQuerySchema = PageQuerySchema.extend({
   sortBy: ArticleSortBySchema.optional().default("createdAt"),
   direction: SortDirectionSchema.optional().default("desc")
@@ -644,7 +621,7 @@ var SignupResponseSchema = import_zod8.z.object({
 });
 
 // src/domain/common/contracts/api.ts
-var import_zod28 = require("zod");
+var import_zod30 = require("zod");
 
 // src/domain/common/schema/cache-invalidation.schema.ts
 var import_zod9 = require("zod");
@@ -692,10 +669,7 @@ var CacheInvalidationEventSchema = import_zod9.z.object({
   type: import_zod9.z.literal("cache.invalidate"),
   entity: CacheInvalidationEntitySchema,
   action: CacheInvalidationActionSchema,
-  id: import_zod9.z.union([
-    import_zod9.z.string(),
-    import_zod9.z.number()
-  ]).optional(),
+  id: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional(),
   keys: import_zod9.z.array(CacheInvalidationKeySchema).min(1),
   occurredAt: import_zod9.z.string().datetime()
 });
@@ -703,77 +677,36 @@ var CacheInvalidationEventSchema = import_zod9.z.object({
 // src/domain/common/schema/envelope.schema.ts
 var import_zod10 = require("zod");
 var NoContentSchema = import_zod10.z.null();
-var ApiSuccessSchema = /* @__PURE__ */ __name((data) => import_zod10.z.object({
+var ApiSuccessSchema = (data) => import_zod10.z.object({
   success: import_zod10.z.literal(true),
   code: import_zod10.z.number().int(),
   message: import_zod10.z.string(),
   data
-}), "ApiSuccessSchema");
+});
 var ApiFailureSchema = import_zod10.z.object({
   success: import_zod10.z.literal(false),
   status: import_zod10.z.number().int(),
   code: import_zod10.z.string(),
   message: import_zod10.z.string()
 });
-var ApiResponseSchema = /* @__PURE__ */ __name((data) => import_zod10.z.union([
-  ApiSuccessSchema(data),
-  ApiFailureSchema
-]), "ApiResponseSchema");
+var ApiResponseSchema = (data) => import_zod10.z.union([ApiSuccessSchema(data), ApiFailureSchema]);
 var CreatedEntityIdResponseSchema = import_zod10.z.discriminatedUnion("entity", [
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("article"),
-    id: ArticleIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("comment"),
-    id: CommentIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("subscription"),
-    id: SubscriptionIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("coupon"),
-    id: CouponIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("mealPlan"),
-    id: MealPlanIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("mealPlanInvite"),
-    id: MealPlanInviteIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("mealPlanJoinRequest"),
-    id: MealPlanJoinRequestIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("mealPlanChangeRequest"),
-    id: MealPlanChangeRequestIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("mealPlanShareLink"),
-    id: MealPlanShareLinkIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("mealPlanChatMessage"),
-    id: MealPlanChatMessageIdSchema
-  }),
-  import_zod10.z.object({
-    entity: import_zod10.z.literal("mealGroup"),
-    id: MealGroupIdSchema
-  })
+  import_zod10.z.object({ entity: import_zod10.z.literal("article"), id: ArticleIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("comment"), id: CommentIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("subscription"), id: SubscriptionIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("coupon"), id: CouponIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("mealPlan"), id: MealPlanIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("mealPlanInvite"), id: MealPlanInviteIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("mealPlanJoinRequest"), id: MealPlanJoinRequestIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("mealPlanChangeRequest"), id: MealPlanChangeRequestIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("mealPlanShareLink"), id: MealPlanShareLinkIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("mealPlanChatMessage"), id: MealPlanChatMessageIdSchema }),
+  import_zod10.z.object({ entity: import_zod10.z.literal("mealGroup"), id: MealGroupIdSchema })
 ]);
 
 // src/domain/friend/friend.schema.ts
 var import_zod11 = require("zod");
-var FriendRequestStatusSchema = import_zod11.z.enum([
-  "PENDING",
-  "ACCEPTED",
-  "REJECTED",
-  "CANCELED"
-]);
+var FriendRequestStatusSchema = import_zod11.z.enum(["PENDING", "ACCEPTED", "REJECTED", "CANCELED"]);
 var FriendMealAvailabilitySchema = import_zod11.z.object({
   isHungry: import_zod11.z.boolean(),
   mealProposalAllowed: import_zod11.z.boolean(),
@@ -806,18 +739,11 @@ var MealStatusResponseSchema = import_zod12.z.object({
   updatedAt: ISODateStringSchema,
   secondsToAutoOff: import_zod12.z.number().int().min(0)
 });
-var MealStatusActionSchema = import_zod12.z.enum([
-  "ARTICLE_UPLOAD",
-  "SET_MANNUALY"
-]);
+var MealStatusActionSchema = import_zod12.z.enum(["ARTICLE_UPLOAD", "SET_MANNUALY"]);
 var UpdateMealStatusRequestSchema = import_zod12.z.object({
   action: MealStatusActionSchema.optional().default("SET_MANNUALY")
 });
-var MealStatusSchema = import_zod12.z.enum([
-  "ALL",
-  "HUNGRY",
-  "NOT_HUNGRY"
-]);
+var MealStatusSchema = import_zod12.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
 var FriendMealQuerySchema = import_zod12.z.object({
   status: MealStatusSchema.optional().default("ALL")
 });
@@ -828,57 +754,176 @@ var FriendMealItemResponseSchema = MemberCoreSchema.extend({
 });
 
 // src/domain/meal-plan/meal-plan.schema.ts
-var import_zod18 = require("zod");
+var import_zod19 = require("zod");
 
 // src/domain/meal-plan/meal-plan-decision.schema.ts
+var import_zod14 = require("zod");
+
+// src/domain/food/food.schema.ts
 var import_zod13 = require("zod");
-var MealPlanLatitudeSchema = import_zod13.z.number().brand();
-var MealPlanLongitudeSchema = import_zod13.z.number().brand();
-var MealPlanLocationCandidateIdSchema = import_zod13.z.string().min(1).brand();
-var MealPlanMenuCandidateIdSchema = import_zod13.z.string().min(1).brand();
-var MealPlanDecisionStageIdSchema = import_zod13.z.string().uuid().brand();
-var MealPlanVoteIdSchema = import_zod13.z.string().uuid().brand();
-var MealPlanLocationCandidateSourceSchema = import_zod13.z.enum([
+var FoodGranularitySchema = import_zod13.z.enum(["main_dish", "side_dish", "beverage", "sauce"]);
+var CuisineTagSchema = import_zod13.z.enum([
+  "korean",
+  "western",
+  "chinese",
+  "japanese",
+  "mexican",
+  "indian",
+  "asian",
+  "snack",
+  "dessert",
+  "beverage",
+  "unknown"
+]);
+var FoodResolvedMatchSourceSchema = import_zod13.z.enum(["category", "alias", "lexical", "semantic"]);
+var FoodCodeManifestImageSchema = import_zod13.z.object({
+  src: import_zod13.z.string().min(1),
+  avifSrcset: import_zod13.z.string().min(1).optional(),
+  thumbhashDataURL: import_zod13.z.string().min(1).optional(),
+  aspectRatio: import_zod13.z.number().positive().optional()
+});
+var FoodCodeManifestItemSchema = import_zod13.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  aliases: import_zod13.z.array(import_zod13.z.string().min(1)).default([]),
+  parentCategory: import_zod13.z.string().min(1),
+  cuisineTags: import_zod13.z.array(CuisineTagSchema).default([]),
+  categoryTags: import_zod13.z.array(import_zod13.z.string().min(1)).default([]),
+  semanticTags: import_zod13.z.array(import_zod13.z.string().min(1)).default([]),
+  granularity: FoodGranularitySchema,
+  searchable: import_zod13.z.boolean(),
+  recommendable: import_zod13.z.boolean(),
+  previewEnabled: import_zod13.z.boolean(),
+  imageUrl: import_zod13.z.string().min(1).nullable().optional(),
+  image: FoodCodeManifestImageSchema.nullable().optional(),
+  popularity: import_zod13.z.number().nonnegative().optional(),
+  source: import_zod13.z.enum(["foodname", "manual", "foodai", "legacy"]).optional()
+});
+var FoodCodeManifestSchema = import_zod13.z.object({
+  version: import_zod13.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  taxonomyVersion: import_zod13.z.string().min(1),
+  etag: import_zod13.z.string().min(1).optional(),
+  items: import_zod13.z.array(FoodCodeManifestItemSchema),
+  categoryIndex: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.array(FoodCodeSchema)),
+  aliasIndex: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.array(FoodCodeSchema)).optional()
+});
+var FoodImageIndexItemSchema = import_zod13.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  imageUrl: import_zod13.z.string().min(1).nullable(),
+  image: FoodCodeManifestImageSchema.nullable(),
+  source: import_zod13.z.enum(["foodname", "manual", "foodai", "legacy"]).optional()
+});
+var FoodImageIndexManifestSchema = import_zod13.z.object({
+  version: import_zod13.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  taxonomyVersion: import_zod13.z.string().min(1),
+  items: import_zod13.z.array(FoodImageIndexItemSchema)
+});
+var ResolvedFoodCodeSchema = import_zod13.z.object({
+  code: FoodCodeSchema,
+  label: FoodLabelSchema,
+  matchedBy: FoodResolvedMatchSourceSchema,
+  score: import_zod13.z.number(),
+  granularity: FoodGranularitySchema,
+  imageUrl: import_zod13.z.string().min(1).nullable().optional()
+});
+var BooleanQuerySchema = import_zod13.z.preprocess((value) => {
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return value;
+}, import_zod13.z.boolean());
+var FoodResolveQuerySchema = import_zod13.z.object({
+  q: import_zod13.z.string().default(""),
+  limit: import_zod13.z.coerce.number().int().min(1).max(100).optional().default(30),
+  recommendableOnly: BooleanQuerySchema.optional().default(true)
+});
+var FoodSearchQuerySchema = import_zod13.z.object({
+  q: import_zod13.z.string().default(""),
+  limit: import_zod13.z.coerce.number().int().min(1).max(100).optional().default(20)
+});
+var FoodResolveResponseSchema = import_zod13.z.object({
+  query: import_zod13.z.string(),
+  items: import_zod13.z.array(ResolvedFoodCodeSchema)
+});
+var FoodSearchResponseSchema = FoodResolveResponseSchema;
+var FoodAiClassMappingStatusSchema = import_zod13.z.enum([
+  "exact",
+  "broad",
+  "narrow",
+  "merged",
+  "ignored",
+  "review_required"
+]);
+var AiClassFoodCodeMappingSchema = import_zod13.z.object({
+  classId: import_zod13.z.number().int().nonnegative(),
+  aiLabel: import_zod13.z.string().min(1),
+  aiAliases: import_zod13.z.array(import_zod13.z.string().min(1)).default([]),
+  representativeCode: FoodCodeSchema.nullable(),
+  candidateCodes: import_zod13.z.array(FoodCodeSchema).default([]),
+  mappingStatus: FoodAiClassMappingStatusSchema,
+  granularity: FoodGranularitySchema,
+  searchable: import_zod13.z.boolean(),
+  recommendable: import_zod13.z.boolean(),
+  reason: import_zod13.z.string().min(1).optional()
+});
+var AiClassToFoodCodeMapManifestSchema = import_zod13.z.object({
+  version: import_zod13.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema,
+  modelTaxonomyVersion: import_zod13.z.string().min(1),
+  serviceTaxonomyVersion: import_zod13.z.string().min(1),
+  classes: import_zod13.z.array(AiClassFoodCodeMappingSchema)
+});
+
+// src/domain/meal-plan/meal-plan-decision.schema.ts
+var MealPlanLatitudeSchema = import_zod14.z.number().brand();
+var MealPlanLongitudeSchema = import_zod14.z.number().brand();
+var MealPlanLocationCandidateIdSchema = import_zod14.z.string().min(1).brand();
+var MealPlanMenuCandidateIdSchema = import_zod14.z.string().min(1).brand();
+var MealPlanDecisionStageIdSchema = import_zod14.z.string().uuid().brand();
+var MealPlanVoteIdSchema = import_zod14.z.string().uuid().brand();
+var MealPlanLocationCandidateSourceSchema = import_zod14.z.enum([
   "manual",
+  "map-marker",
   "midpoint",
+  "user-location",
   "search",
   "recent-place",
   "fallback"
 ]);
-var MealPlanLocationCandidateSchema = import_zod13.z.object({
+var MealPlanLocationCandidateSchema = import_zod14.z.object({
   locationId: MealPlanLocationCandidateIdSchema,
-  placeName: import_zod13.z.string().min(1),
+  placeName: import_zod14.z.string().min(1),
   lat: MealPlanLatitudeSchema,
   lng: MealPlanLongitudeSchema,
-  address: import_zod13.z.string().default(""),
+  address: import_zod14.z.string().default(""),
   source: MealPlanLocationCandidateSourceSchema.default("manual"),
   createdBy: MemberIdSchema.optional(),
   createdAt: ISODateTimeStringSchema.optional()
 });
-var MealPlanMenuCandidateSourceSchema = import_zod13.z.enum([
+var MealPlanMenuCandidateSourceSchema = import_zod14.z.enum([
   "external-recommendation",
   "prefer-menu",
   "recent-menu",
   "fallback",
   "manual-search"
 ]);
-var MealPlanMenuCandidateSchema = import_zod13.z.object({
+var MealPlanMenuCandidateSchema = import_zod14.z.object({
   menuCandidateId: MealPlanMenuCandidateIdSchema,
   menu: FoodSchema,
   source: MealPlanMenuCandidateSourceSchema,
-  score: import_zod13.z.number().default(0),
+  score: import_zod14.z.number().default(0),
+  imageUrl: import_zod14.z.string().min(1).nullable().default(null),
+  image: FoodCodeManifestImageSchema.nullable().default(null),
   createdAt: ISODateTimeStringSchema
 });
 var MealPlanRestaurantCandidateSchema = RestaurantSchema.extend({
   candidateId: RestaurantIdSchema.optional(),
-  source: import_zod13.z.enum([
-    "search",
-    "fallback",
-    "manual"
-  ]).optional(),
+  source: import_zod14.z.enum(["search", "fallback", "manual"]).optional(),
   createdAt: ISODateTimeStringSchema.optional()
 });
-var MealPlanDecisionStageTypeSchema = import_zod13.z.enum([
+var MealPlanDecisionStageTypeSchema = import_zod14.z.enum([
   "DATE",
   "TIME",
   "AREA",
@@ -886,108 +931,90 @@ var MealPlanDecisionStageTypeSchema = import_zod13.z.enum([
   "RESTAURANT",
   "FINAL_CONFIRMATION"
 ]);
-var MealPlanDecisionStageStatusSchema = import_zod13.z.enum([
+var MealPlanDecisionStageStatusSchema = import_zod14.z.enum([
   "OPEN",
   "COMPLETED",
   "REOPENED"
 ]);
-var MealPlanRestaurantSearchStatusSchema = import_zod13.z.enum([
+var MealPlanRestaurantSearchStatusSchema = import_zod14.z.enum([
   "IDLE",
   "PENDING",
   "READY",
   "FAILED",
   "STALE"
 ]);
-var MealPlanRestaurantSearchStateSchema = import_zod13.z.object({
-  searchKey: import_zod13.z.string().min(1).nullable(),
+var MealPlanRestaurantSearchStateSchema = import_zod14.z.object({
+  searchKey: import_zod14.z.string().min(1).nullable(),
   status: MealPlanRestaurantSearchStatusSchema,
   startedAt: ISODateTimeStringSchema.nullable(),
   completedAt: ISODateTimeStringSchema.nullable(),
-  version: import_zod13.z.number().int().min(0),
-  candidateCount: import_zod13.z.number().int().min(0),
-  errorMessage: import_zod13.z.string().nullable().default(null)
+  version: import_zod14.z.number().int().min(0),
+  candidateCount: import_zod14.z.number().int().min(0),
+  errorMessage: import_zod14.z.string().nullable().default(null)
 });
-var MealPlanDecisionStageMetadataSchema = import_zod13.z.object({
+var MealPlanDecisionStageMetadataSchema = import_zod14.z.object({
   restaurantSearch: MealPlanRestaurantSearchStateSchema.optional()
-}).catchall(import_zod13.z.unknown());
-var MealPlanVoteTypeSchema = import_zod13.z.enum([
+}).catchall(import_zod14.z.unknown());
+var MealPlanVoteTypeSchema = import_zod14.z.enum([
   "PICK",
   "EXCLUDE",
   "PREFER",
   "READY"
 ]);
-var MealPlanDecisionCandidateSchema = import_zod13.z.discriminatedUnion("stageType", [
-  import_zod13.z.object({
-    stageType: import_zod13.z.literal("DATE"),
-    value: ISODateStringSchema
-  }),
-  import_zod13.z.object({
-    stageType: import_zod13.z.literal("TIME"),
-    value: TimeHHmmStringSchema
-  }),
-  import_zod13.z.object({
-    stageType: import_zod13.z.literal("AREA"),
-    value: MealPlanLocationCandidateSchema
-  }),
-  import_zod13.z.object({
-    stageType: import_zod13.z.literal("MENU"),
-    value: MealPlanMenuCandidateSchema
-  }),
-  import_zod13.z.object({
-    stageType: import_zod13.z.literal("RESTAURANT"),
-    value: MealPlanRestaurantCandidateSchema
-  }),
-  import_zod13.z.object({
-    stageType: import_zod13.z.literal("FINAL_CONFIRMATION"),
-    value: import_zod13.z.literal("READY")
-  })
+var MealPlanDecisionCandidateSchema = import_zod14.z.discriminatedUnion("stageType", [
+  import_zod14.z.object({ stageType: import_zod14.z.literal("DATE"), value: ISODateStringSchema }),
+  import_zod14.z.object({ stageType: import_zod14.z.literal("TIME"), value: TimeHHmmStringSchema }),
+  import_zod14.z.object({ stageType: import_zod14.z.literal("AREA"), value: MealPlanLocationCandidateSchema }),
+  import_zod14.z.object({ stageType: import_zod14.z.literal("MENU"), value: MealPlanMenuCandidateSchema }),
+  import_zod14.z.object({ stageType: import_zod14.z.literal("RESTAURANT"), value: MealPlanRestaurantCandidateSchema }),
+  import_zod14.z.object({ stageType: import_zod14.z.literal("FINAL_CONFIRMATION"), value: import_zod14.z.literal("READY") })
 ]);
-var MealPlanVoteSchema = import_zod13.z.object({
+var MealPlanVoteSchema = import_zod14.z.object({
   voteId: MealPlanVoteIdSchema,
   voterId: MemberIdSchema.nullable(),
-  guestId: import_zod13.z.string().min(1).nullable(),
+  guestId: import_zod14.z.string().min(1).nullable(),
   voteType: MealPlanVoteTypeSchema,
   candidate: MealPlanDecisionCandidateSchema,
   createdAt: ISODateTimeStringSchema
 });
-var MealPlanDecisionStageResponseSchema = import_zod13.z.object({
+var MealPlanDecisionStageResponseSchema = import_zod14.z.object({
   stageId: MealPlanDecisionStageIdSchema,
   stageType: MealPlanDecisionStageTypeSchema,
   status: MealPlanDecisionStageStatusSchema,
-  candidates: import_zod13.z.array(MealPlanDecisionCandidateSchema),
-  votes: import_zod13.z.array(MealPlanVoteSchema),
+  candidates: import_zod14.z.array(MealPlanDecisionCandidateSchema),
+  votes: import_zod14.z.array(MealPlanVoteSchema),
   selectedCandidate: MealPlanDecisionCandidateSchema.nullable(),
   metadata: MealPlanDecisionStageMetadataSchema.nullable().default(null),
   openedAt: ISODateTimeStringSchema,
   completedAt: ISODateTimeStringSchema.nullable(),
   reopenedAt: ISODateTimeStringSchema.nullable()
 });
-var CreateMealPlanVoteRequestSchema = import_zod13.z.object({
+var CreateMealPlanVoteRequestSchema = import_zod14.z.object({
   voteType: MealPlanVoteTypeSchema,
   candidate: MealPlanDecisionCandidateSchema
 });
-var CompleteMealPlanDecisionStageRequestSchema = import_zod13.z.object({
+var CompleteMealPlanDecisionStageRequestSchema = import_zod14.z.object({
   selectedCandidate: MealPlanDecisionCandidateSchema
 });
-var MealPlanChangeRequestStatusSchema = import_zod13.z.enum([
+var MealPlanChangeRequestStatusSchema = import_zod14.z.enum([
   "PENDING",
   "ACCEPTED",
   "REJECTED",
   "CANCELLED"
 ]);
-var CreateMealPlanChangeRequestSchema = import_zod13.z.object({
+var CreateMealPlanChangeRequestSchema = import_zod14.z.object({
   stageType: MealPlanDecisionStageTypeSchema,
-  reason: import_zod13.z.string().min(1).max(500),
+  reason: import_zod14.z.string().min(1).max(500),
   proposedCandidate: MealPlanDecisionCandidateSchema.optional()
 });
-var MealPlanChangeRequestSummarySchema = import_zod13.z.object({
+var MealPlanChangeRequestSummarySchema = import_zod14.z.object({
   changeRequestId: MealPlanChangeRequestIdSchema,
   stageType: MealPlanDecisionStageTypeSchema,
   status: MealPlanChangeRequestStatusSchema,
-  reason: import_zod13.z.string(),
+  reason: import_zod14.z.string(),
   requestedAt: ISODateTimeStringSchema
 });
-var MealPlanDecisionTaskKeySchema = import_zod13.z.enum([
+var MealPlanDecisionTaskKeySchema = import_zod14.z.enum([
   "SCHEDULE_DATE",
   "SCHEDULE_TIME",
   "LOCATION_CANDIDATE",
@@ -999,14 +1026,13 @@ var MealPlanDecisionTaskKeySchema = import_zod13.z.enum([
   "RESTAURANT_PICK",
   "FINAL_CONFIRMATION"
 ]);
-var MealPlanDecisionTaskStatusSchema = import_zod13.z.enum([
+var MealPlanDecisionTaskStatusSchema = import_zod14.z.enum([
   "LOCKED",
   "OPEN",
-  "READY",
   "RESOLVED",
   "STALE"
 ]);
-var MealPlanDecisionFinalFieldSchema = import_zod13.z.enum([
+var MealPlanDecisionFinalFieldSchema = import_zod14.z.enum([
   "date",
   "time",
   "meetingAt",
@@ -1014,82 +1040,72 @@ var MealPlanDecisionFinalFieldSchema = import_zod13.z.enum([
   "menu",
   "restaurant"
 ]);
-var MealPlanDecisionSnapshotStatusSchema = import_zod13.z.enum([
+var MealPlanDecisionSnapshotStatusSchema = import_zod14.z.enum([
   "CANDIDATE",
   "PROVISIONAL",
   "FINAL",
   "STALE"
 ]);
-var MealPlanDecisionReasonSchema = import_zod13.z.enum([
+var MealPlanDecisionReasonSchema = import_zod14.z.enum([
   "COMMON_SCHEDULE",
   "TOP_VOTED_LOCATION",
   "TOP_PICKED_MENU",
   "TOP_PICKED_RESTAURANT",
   "OWNER_CONFIRMED",
-  "TASK_ALL_READY",
   "MANUAL_SELECTION"
 ]);
-var MealPlanDecisionActorTypeSchema = import_zod13.z.enum([
-  "MEMBER",
-  "GUEST",
-  "SYSTEM"
-]);
-var MealPlanDecisionSnapshotSchema = import_zod13.z.object({
-  snapshotId: import_zod13.z.string().uuid(),
-  mealPlanId: import_zod13.z.string().uuid(),
+var MealPlanDecisionActorTypeSchema = import_zod14.z.enum(["MEMBER", "GUEST", "SYSTEM"]);
+var MealPlanDecisionSnapshotSchema = import_zod14.z.object({
+  snapshotId: import_zod14.z.string().uuid(),
+  mealPlanId: import_zod14.z.string().uuid(),
   field: MealPlanDecisionFinalFieldSchema,
-  value: import_zod13.z.unknown(),
+  value: import_zod14.z.unknown(),
   status: MealPlanDecisionSnapshotStatusSchema,
   reason: MealPlanDecisionReasonSchema,
-  score: import_zod13.z.number().nullable().default(null),
-  sourceEvent: import_zod13.z.string().min(1),
+  score: import_zod14.z.number().nullable().default(null),
+  sourceEvent: import_zod14.z.string().min(1),
   sourceActorType: MealPlanDecisionActorTypeSchema,
   sourceMemberId: MemberIdSchema.nullable(),
-  sourceGuestId: import_zod13.z.string().min(1).nullable(),
-  sourceParticipantId: import_zod13.z.string().uuid().nullable(),
-  sourceVersion: import_zod13.z.number().int().min(0),
-  dependencyHash: import_zod13.z.string().min(1),
-  dependencyFields: import_zod13.z.array(MealPlanDecisionFinalFieldSchema),
+  sourceGuestId: import_zod14.z.string().min(1).nullable(),
+  sourceParticipantId: import_zod14.z.string().uuid().nullable(),
+  sourceVersion: import_zod14.z.number().int().min(0),
+  dependencyHash: import_zod14.z.string().min(1),
+  dependencyFields: import_zod14.z.array(MealPlanDecisionFinalFieldSchema),
   createdAt: ISODateTimeStringSchema,
   staleAt: ISODateTimeStringSchema.nullable()
 });
-var MealPlanDecisionTaskProgressSchema = import_zod13.z.object({
+var MealPlanDecisionTaskProgressSchema = import_zod14.z.object({
   taskKey: MealPlanDecisionTaskKeySchema,
   status: MealPlanDecisionTaskStatusSchema,
-  readyCount: import_zod13.z.number().int().min(0),
-  participantCount: import_zod13.z.number().int().min(0),
-  blockers: import_zod13.z.array(import_zod13.z.string()).default([]),
+  blockers: import_zod14.z.array(import_zod14.z.string()).default([]),
   updatedAt: ISODateTimeStringSchema
 });
-var MealPlanDecisionProgressSchema = import_zod13.z.object({
-  mealPlanId: import_zod13.z.string().uuid(),
-  status: import_zod13.z.string().min(1),
-  tasks: import_zod13.z.array(MealPlanDecisionTaskProgressSchema),
-  final: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()),
-  provisional: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()),
-  snapshots: import_zod13.z.array(MealPlanDecisionSnapshotSchema),
-  version: import_zod13.z.number().int().min(0),
+var MealPlanDecisionProgressSchema = import_zod14.z.object({
+  mealPlanId: import_zod14.z.string().uuid(),
+  status: import_zod14.z.string().min(1),
+  tasks: import_zod14.z.array(MealPlanDecisionTaskProgressSchema),
+  final: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()),
+  provisional: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.unknown()),
+  snapshots: import_zod14.z.array(MealPlanDecisionSnapshotSchema),
+  version: import_zod14.z.number().int().min(0),
   updatedAt: ISODateTimeStringSchema
 });
-var MealPlanDecisionTaskReadyRequestSchema = import_zod13.z.object({
-  isReady: import_zod13.z.boolean()
-});
-var ReopenMealPlanDecisionTaskRequestSchema = import_zod13.z.object({
-  reason: import_zod13.z.string().max(500).optional()
+var ReopenMealPlanDecisionTaskRequestSchema = import_zod14.z.object({
+  reason: import_zod14.z.string().max(500).optional()
 });
-var ConfirmMealPlanDecisionSnapshotRequestSchema = import_zod13.z.object({
-  snapshotId: import_zod13.z.string().uuid()
+var ConfirmMealPlanDecisionSnapshotRequestSchema = import_zod14.z.object({
+  snapshotId: import_zod14.z.string().uuid()
 });
 
 // src/domain/meal-plan/meal-plan-participant.schema.ts
-var import_zod14 = require("zod");
-var MealPlanParticipantIdSchema = import_zod14.z.string().uuid().brand();
-var MealPlanParticipantRoleSchema = import_zod14.z.enum([
+var import_zod15 = require("zod");
+var MealPlanParticipantIdSchema = import_zod15.z.string().uuid().brand();
+var MealPlanParticipantRoleSchema = import_zod15.z.enum([
   "OWNER",
   "FRIEND",
   "GUEST"
 ]);
-var MealPlanParticipantStatusSchema = import_zod14.z.enum([
+var MealPlanParticipantStatusSchema = import_zod15.z.enum([
   "INVITED",
   "REQUESTED",
   "JOINED",
@@ -1098,17 +1114,17 @@ var MealPlanParticipantStatusSchema = import_zod14.z.enum([
   "LEFT",
   "REMOVED"
 ]);
-var MealPlanJoinSourceSchema = import_zod14.z.enum([
+var MealPlanJoinSourceSchema = import_zod15.z.enum([
   "OWNER",
   "FRIEND_INVITE",
   "LINK_GUEST",
   "NEARBY_FRIENDS"
 ]);
-var MealPlanGuestParticipantSchema = import_zod14.z.object({
-  guestId: import_zod14.z.string().min(1),
-  nickname: import_zod14.z.string().min(1).max(50)
+var MealPlanGuestParticipantSchema = import_zod15.z.object({
+  guestId: import_zod15.z.string().min(1),
+  nickname: import_zod15.z.string().min(1).max(50)
 });
-var MealPlanParticipantResponseSchema = import_zod14.z.object({
+var MealPlanParticipantResponseSchema = import_zod15.z.object({
   participantId: MealPlanParticipantIdSchema,
   mealPlanId: MealPlanIdSchema,
   member: MemberCoreSchema.nullable(),
@@ -1119,66 +1135,66 @@ var MealPlanParticipantResponseSchema = import_zod14.z.object({
   joinedAt: ISODateTimeStringSchema.nullable(),
   readyAt: ISODateTimeStringSchema.nullable()
 });
-var CreateMealPlanParticipantRequestSchema = import_zod14.z.object({
+var CreateMealPlanParticipantRequestSchema = import_zod15.z.object({
   memberId: MemberIdSchema.optional(),
-  guestNickname: import_zod14.z.string().min(1).max(50).optional(),
+  guestNickname: import_zod15.z.string().min(1).max(50).optional(),
   source: MealPlanJoinSourceSchema
 });
 
 // src/domain/meal-plan/meal-plan-invite.schema.ts
-var import_zod15 = require("zod");
-var MealPlanInviteStatusSchema = import_zod15.z.enum([
+var import_zod16 = require("zod");
+var MealPlanInviteStatusSchema = import_zod16.z.enum([
   "PENDING",
   "ACCEPTED",
   "DECLINED",
   "CANCELLED",
   "EXPIRED"
 ]);
-var CreateMealPlanInviteRequestSchema = import_zod15.z.object({
+var CreateMealPlanInviteRequestSchema = import_zod16.z.object({
   inviteeId: MemberIdSchema,
-  message: import_zod15.z.string().max(500).default("")
+  message: import_zod16.z.string().max(500).default("")
 });
-var MealPlanInviteSummarySchema = import_zod15.z.object({
+var MealPlanInviteSummarySchema = import_zod16.z.object({
   inviteId: MealPlanInviteIdSchema,
   mealPlanId: MealPlanIdSchema,
   inviter: MemberCoreSchema,
   invitee: MemberCoreSchema,
   status: MealPlanInviteStatusSchema,
-  message: import_zod15.z.string().max(500),
+  message: import_zod16.z.string().max(500),
   createdAt: ISODateTimeStringSchema,
   respondedAt: ISODateTimeStringSchema.nullable()
 });
-var MealPlanInviteListResponseSchema = import_zod15.z.array(MealPlanInviteSummarySchema);
-var SendMealPlanInviteResponseSchema = import_zod15.z.object({
+var MealPlanInviteListResponseSchema = import_zod16.z.array(MealPlanInviteSummarySchema);
+var SendMealPlanInviteResponseSchema = import_zod16.z.object({
   inviteId: MealPlanInviteIdSchema
 });
 
 // src/domain/meal-plan/meal-plan-nearby-friend.schema.ts
-var import_zod16 = require("zod");
-var MealPlanNearbyFriendExposureIdSchema = import_zod16.z.string().uuid().brand();
-var MealPlanNearbyFriendExposureStatusSchema = import_zod16.z.enum([
+var import_zod17 = require("zod");
+var MealPlanNearbyFriendExposureIdSchema = import_zod17.z.string().uuid().brand();
+var MealPlanNearbyFriendExposureStatusSchema = import_zod17.z.enum([
   "OPEN",
   "CLOSED",
   "EXPIRED"
 ]);
-var MealPlanNearbyFriendExposureNotificationStatusSchema = import_zod16.z.enum([
+var MealPlanNearbyFriendExposureNotificationStatusSchema = import_zod17.z.enum([
   "PENDING",
   "SENT",
   "PARTIAL",
   "FAILED",
   "SKIPPED"
 ]);
-var ExposeMealPlanToNearbyFriendsRequestSchema = import_zod16.z.object({
-  radiusMeters: import_zod16.z.number().int().min(100).max(5e3).default(1e3),
+var ExposeMealPlanToNearbyFriendsRequestSchema = import_zod17.z.object({
+  radiusMeters: import_zod17.z.number().int().min(100).max(5e3).default(1e3),
   expiresAt: ISODateTimeStringSchema.optional()
 });
-var NearbyFriendExposureEligibilitySchema = import_zod16.z.object({
-  canExpose: import_zod16.z.boolean(),
+var NearbyFriendExposureEligibilitySchema = import_zod17.z.object({
+  canExpose: import_zod17.z.boolean(),
   locationConsentStatus: LocationConsentStatusSchema,
-  nearbyMealPlanExposureAllowed: import_zod16.z.boolean(),
-  mealSuggestionAllowed: import_zod16.z.boolean(),
-  hasLastKnownLocation: import_zod16.z.boolean(),
-  missingRequirements: import_zod16.z.array(import_zod16.z.enum([
+  nearbyMealPlanExposureAllowed: import_zod17.z.boolean(),
+  mealSuggestionAllowed: import_zod17.z.boolean(),
+  hasLastKnownLocation: import_zod17.z.boolean(),
+  missingRequirements: import_zod17.z.array(import_zod17.z.enum([
     "LOCATION_PERMISSION",
     "SERVICE_LOCATION_CONSENT",
     "NEARBY_EXPOSURE_TOGGLE",
@@ -1186,7 +1202,7 @@ var NearbyFriendExposureEligibilitySchema = import_zod16.z.object({
     "LAST_KNOWN_LOCATION"
   ]))
 });
-var MealPlanNearbyFriendRejectionReasonSchema = import_zod16.z.enum([
+var MealPlanNearbyFriendRejectionReasonSchema = import_zod17.z.enum([
   "NOT_FRIEND",
   "BLOCKED",
   "LOCATION_CONSENT_REQUIRED",
@@ -1195,79 +1211,79 @@ var MealPlanNearbyFriendRejectionReasonSchema = import_zod16.z.enum([
   "MEAL_SUGGESTION_DISABLED",
   "NOT_HUNGRY"
 ]);
-var MealPlanNearbyFriendRejectionSummarySchema = import_zod16.z.object({
+var MealPlanNearbyFriendRejectionSummarySchema = import_zod17.z.object({
   reason: MealPlanNearbyFriendRejectionReasonSchema,
-  count: import_zod16.z.number().int().min(0)
+  count: import_zod17.z.number().int().min(0)
 });
-var ExposeMealPlanToNearbyFriendsResponseSchema = import_zod16.z.object({
+var ExposeMealPlanToNearbyFriendsResponseSchema = import_zod17.z.object({
   mealPlanId: MealPlanIdSchema,
   exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
-  exposedFriendCount: import_zod16.z.number().int().min(0),
-  rejectedFriendCount: import_zod16.z.number().int().min(0),
+  exposedFriendCount: import_zod17.z.number().int().min(0),
+  rejectedFriendCount: import_zod17.z.number().int().min(0),
   notificationStatus: MealPlanNearbyFriendExposureNotificationStatusSchema,
-  rejectionSummary: import_zod16.z.array(MealPlanNearbyFriendRejectionSummarySchema)
+  rejectionSummary: import_zod17.z.array(MealPlanNearbyFriendRejectionSummarySchema)
 });
-var MealPlanNearbyFriendExposureSummarySchema = import_zod16.z.object({
+var MealPlanNearbyFriendExposureSummarySchema = import_zod17.z.object({
   exposureId: MealPlanNearbyFriendExposureIdSchema,
   exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema.nullable(),
   mealPlanId: MealPlanIdSchema,
   status: MealPlanNearbyFriendExposureStatusSchema,
-  radiusMeters: import_zod16.z.number().int().min(100),
-  exposedFriendCount: import_zod16.z.number().int().min(0),
+  radiusMeters: import_zod17.z.number().int().min(100),
+  exposedFriendCount: import_zod17.z.number().int().min(0),
   openedAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema.nullable(),
   closedAt: ISODateTimeStringSchema.nullable()
 });
-var MealPlanNearbyFriendExposureBatchSummarySchema = import_zod16.z.object({
+var MealPlanNearbyFriendExposureBatchSummarySchema = import_zod17.z.object({
   exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
   mealPlanId: MealPlanIdSchema,
   status: MealPlanNearbyFriendExposureStatusSchema,
-  radiusMeters: import_zod16.z.number().int().min(100),
-  exposedFriendCount: import_zod16.z.number().int().min(0),
-  rejectedFriendCount: import_zod16.z.number().int().min(0),
-  rejectionSummary: import_zod16.z.array(MealPlanNearbyFriendRejectionSummarySchema),
+  radiusMeters: import_zod17.z.number().int().min(100),
+  exposedFriendCount: import_zod17.z.number().int().min(0),
+  rejectedFriendCount: import_zod17.z.number().int().min(0),
+  rejectionSummary: import_zod17.z.array(MealPlanNearbyFriendRejectionSummarySchema),
   notificationStatus: MealPlanNearbyFriendExposureNotificationStatusSchema,
   notificationSentAt: ISODateTimeStringSchema.nullable(),
   openedAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema.nullable(),
   closedAt: ISODateTimeStringSchema.nullable()
 });
-var MealPlanJoinRequestStatusSchema = import_zod16.z.enum([
+var MealPlanJoinRequestStatusSchema = import_zod17.z.enum([
   "PENDING",
   "ACCEPTED",
   "REJECTED",
   "CANCELLED"
 ]);
-var CreateMealPlanJoinRequestSchema = import_zod16.z.object({
-  message: import_zod16.z.string().max(500).default("")
+var CreateMealPlanJoinRequestSchema = import_zod17.z.object({
+  message: import_zod17.z.string().max(500).default("")
 });
-var MealPlanJoinRequestSummarySchema = import_zod16.z.object({
+var MealPlanJoinRequestSummarySchema = import_zod17.z.object({
   joinRequestId: MealPlanJoinRequestIdSchema,
   mealPlanId: MealPlanIdSchema,
   requester: MemberCoreSchema,
   status: MealPlanJoinRequestStatusSchema,
-  message: import_zod16.z.string().max(500),
+  message: import_zod17.z.string().max(500),
   requestedAt: ISODateTimeStringSchema,
   respondedAt: ISODateTimeStringSchema.nullable()
 });
-var NearbyFriendMealPlanSummarySchema = import_zod16.z.object({
+var NearbyFriendMealPlanSummarySchema = import_zod17.z.object({
   mealPlanId: MealPlanIdSchema,
   owner: MemberCoreSchema,
-  title: import_zod16.z.string(),
-  participantCount: import_zod16.z.number().int().min(1),
-  distanceMeters: import_zod16.z.number().int().min(0),
+  title: import_zod17.z.string(),
+  participantCount: import_zod17.z.number().int().min(1),
+  distanceMeters: import_zod17.z.number().int().min(0),
   exposedAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema.nullable(),
   joinRequestStatus: MealPlanJoinRequestStatusSchema.nullable().default(null)
 });
 
 // src/domain/meal-plan/meal-plan-chat.schema.ts
-var import_zod17 = require("zod");
-var MealPlanChatMessageKindSchema = import_zod17.z.enum([
+var import_zod18 = require("zod");
+var MealPlanChatMessageKindSchema = import_zod18.z.enum([
   "USER",
   "SYSTEM"
 ]);
-var MealPlanSystemMessageKindSchema = import_zod17.z.enum([
+var MealPlanSystemMessageKindSchema = import_zod18.z.enum([
   "PARTICIPANT_JOINED",
   "PARTICIPANT_READY",
   "PARTICIPANT_REMOVED",
@@ -1276,39 +1292,41 @@ var MealPlanSystemMessageKindSchema = import_zod17.z.enum([
   "CONFIRMED",
   "RECORD_NEEDED"
 ]);
-var MealPlanChatSystemPayloadSchema = import_zod17.z.object({
+var MealPlanChatSystemPayloadSchema = import_zod18.z.object({
   kind: MealPlanSystemMessageKindSchema
-}).catchall(import_zod17.z.unknown());
-var MealPlanChatMessageListResponseSchema = import_zod17.z.array(import_zod17.z.lazy(() => MealPlanChatMessageResponseSchema));
-var MealPlanChatRoomSummarySchema = import_zod17.z.object({
+}).catchall(import_zod18.z.unknown());
+var MealPlanChatMessageListResponseSchema = import_zod18.z.array(
+  import_zod18.z.lazy(() => MealPlanChatMessageResponseSchema)
+);
+var MealPlanChatRoomSummarySchema = import_zod18.z.object({
   chatRoomId: MealPlanChatRoomIdSchema,
   mealPlanId: MealPlanIdSchema,
-  messageCount: import_zod17.z.number().int().min(0),
+  messageCount: import_zod18.z.number().int().min(0),
   lastMessageAt: ISODateTimeStringSchema.nullable(),
   createdAt: ISODateTimeStringSchema
 });
-var SendMealPlanChatMessageRequestSchema = import_zod17.z.object({
-  message: import_zod17.z.string().min(1).max(500)
+var SendMealPlanChatMessageRequestSchema = import_zod18.z.object({
+  message: import_zod18.z.string().min(1).max(500)
 });
-var MealPlanChatMessageResponseSchema = import_zod17.z.object({
+var MealPlanChatMessageResponseSchema = import_zod18.z.object({
   messageId: MealPlanChatMessageIdSchema,
   chatRoomId: MealPlanChatRoomIdSchema,
   sender: MemberCoreSchema.nullable(),
-  guestId: import_zod17.z.string().min(1).nullable(),
-  guestNickname: import_zod17.z.string().min(1).nullable(),
+  guestId: import_zod18.z.string().min(1).nullable(),
+  guestNickname: import_zod18.z.string().min(1).nullable(),
   kind: MealPlanChatMessageKindSchema,
-  message: import_zod17.z.string().min(1).max(1e3),
+  message: import_zod18.z.string().min(1).max(1e3),
   systemPayload: MealPlanChatSystemPayloadSchema.nullable(),
   createdAt: ISODateTimeStringSchema
 });
-var MealPlanSystemMessageSchema = import_zod17.z.object({
+var MealPlanSystemMessageSchema = import_zod18.z.object({
   kind: MealPlanSystemMessageKindSchema,
-  message: import_zod17.z.string().min(1),
+  message: import_zod18.z.string().min(1),
   createdAt: ISODateTimeStringSchema
 });
 
 // src/domain/meal-plan/meal-plan.schema.ts
-var MealPlanStatusSchema = import_zod18.z.enum([
+var MealPlanStatusSchema = import_zod19.z.enum([
   "DRAFT",
   "RECOMMENDING",
   "GATHERING",
@@ -1320,78 +1338,74 @@ var MealPlanStatusSchema = import_zod18.z.enum([
   "RECORDED",
   "CANCELLED"
 ]);
-var MealPlanChannelSchema = import_zod18.z.enum([
+var MealPlanChannelSchema = import_zod19.z.enum([
   "OWNER_ONLY",
   "FRIEND_INVITE",
   "LINK_GUEST",
   "NEARBY_FRIENDS"
 ]);
-var MealPlanRecommendationContextSchema = import_zod18.z.object({
+var MealPlanRecommendationContextSchema = import_zod19.z.object({
   mealDate: ISODateStringSchema.optional(),
   mealTime: TimeHHmmStringSchema.optional(),
   area: MealPlanLocationCandidateSchema.optional(),
-  preferredMenuCategories: import_zod18.z.array(import_zod18.z.string().min(1)).default([]),
-  excludedMenuCategories: import_zod18.z.array(import_zod18.z.string().min(1)).default([]),
-  candidateMenuCategories: import_zod18.z.array(import_zod18.z.string().min(1)).default([]),
-  budgetMin: import_zod18.z.number().int().min(0).optional(),
-  budgetMax: import_zod18.z.number().int().min(0).optional(),
-  memo: import_zod18.z.string().max(500).optional()
-});
-var CreateMealPlanRequestSchema = import_zod18.z.object({
-  title: import_zod18.z.string().min(1).max(100).optional(),
-  channels: import_zod18.z.array(MealPlanChannelSchema).default([
-    "OWNER_ONLY"
-  ]),
+  preferredMenuCategories: import_zod19.z.array(import_zod19.z.string().min(1)).default([]),
+  excludedMenuCategories: import_zod19.z.array(import_zod19.z.string().min(1)).default([]),
+  candidateMenuCategories: import_zod19.z.array(import_zod19.z.string().min(1)).default([]),
+  budgetMin: import_zod19.z.number().int().min(0).optional(),
+  budgetMax: import_zod19.z.number().int().min(0).optional(),
+  memo: import_zod19.z.string().max(500).optional()
+});
+var CreateMealPlanRequestSchema = import_zod19.z.object({
+  title: import_zod19.z.string().min(1).max(100).optional(),
+  channels: import_zod19.z.array(MealPlanChannelSchema).default(["OWNER_ONLY"]),
   recommendationContext: MealPlanRecommendationContextSchema.optional()
 });
-var CreateMealPlanResponseSchema = import_zod18.z.object({
+var CreateMealPlanResponseSchema = import_zod19.z.object({
   mealPlanId: MealPlanIdSchema
 });
 var UpdateMealPlanContextRequestSchema = MealPlanRecommendationContextSchema.partial();
-var MealPlanViewerRoleSchema = import_zod18.z.enum([
+var MealPlanViewerRoleSchema = import_zod19.z.enum([
   "OWNER",
   "FRIEND",
   "GUEST",
   "NONE"
 ]);
-var MealPlanViewerPermissionsSchema = import_zod18.z.object({
-  canView: import_zod18.z.boolean(),
-  canInviteFriends: import_zod18.z.boolean(),
-  canManageParticipants: import_zod18.z.boolean(),
-  canCreateShareLink: import_zod18.z.boolean(),
-  canExposeNearbyFriends: import_zod18.z.boolean(),
-  canVote: import_zod18.z.boolean(),
-  canChat: import_zod18.z.boolean(),
-  canReadyMealPlan: import_zod18.z.boolean(),
-  canReadyDecisionTask: import_zod18.z.boolean(),
-  canRequestChange: import_zod18.z.boolean(),
-  canReopenDecisionTask: import_zod18.z.boolean(),
-  canConfirmDecisionSnapshot: import_zod18.z.boolean(),
-  canConfirmMealPlan: import_zod18.z.boolean(),
-  canCompleteMealPlan: import_zod18.z.boolean(),
-  canRecordMealPlan: import_zod18.z.boolean(),
-  canCancelMealPlan: import_zod18.z.boolean()
-});
-var MealPlanResponseSchema = import_zod18.z.object({
+var MealPlanViewerPermissionsSchema = import_zod19.z.object({
+  canView: import_zod19.z.boolean(),
+  canInviteFriends: import_zod19.z.boolean(),
+  canManageParticipants: import_zod19.z.boolean(),
+  canCreateShareLink: import_zod19.z.boolean(),
+  canExposeNearbyFriends: import_zod19.z.boolean(),
+  canVote: import_zod19.z.boolean(),
+  canChat: import_zod19.z.boolean(),
+  canReadyMealPlan: import_zod19.z.boolean(),
+  canRequestChange: import_zod19.z.boolean(),
+  canReopenDecisionTask: import_zod19.z.boolean(),
+  canConfirmDecisionSnapshot: import_zod19.z.boolean(),
+  canConfirmMealPlan: import_zod19.z.boolean(),
+  canCompleteMealPlan: import_zod19.z.boolean(),
+  canRecordMealPlan: import_zod19.z.boolean(),
+  canCancelMealPlan: import_zod19.z.boolean()
+});
+var MealPlanResponseSchema = import_zod19.z.object({
   mealPlanId: MealPlanIdSchema,
   owner: MemberCoreSchema,
-  title: import_zod18.z.string().nullable(),
+  title: import_zod19.z.string().nullable(),
   status: MealPlanStatusSchema,
-  channels: import_zod18.z.array(MealPlanChannelSchema),
-  participants: import_zod18.z.array(MealPlanParticipantResponseSchema),
-  pendingInvites: import_zod18.z.array(MealPlanInviteSummarySchema),
-  pendingJoinRequests: import_zod18.z.array(MealPlanJoinRequestSummarySchema),
-  decisionStages: import_zod18.z.array(MealPlanDecisionStageResponseSchema),
+  channels: import_zod19.z.array(MealPlanChannelSchema),
+  participants: import_zod19.z.array(MealPlanParticipantResponseSchema),
+  pendingInvites: import_zod19.z.array(MealPlanInviteSummarySchema),
+  pendingJoinRequests: import_zod19.z.array(MealPlanJoinRequestSummarySchema),
+  decisionStages: import_zod19.z.array(MealPlanDecisionStageResponseSchema),
   decisionProgress: MealPlanDecisionProgressSchema.nullable(),
   viewerRole: MealPlanViewerRoleSchema,
   viewerParticipantStatus: MealPlanParticipantStatusSchema.nullable(),
   viewerPermissions: MealPlanViewerPermissionsSchema,
-  viewerTaskReadyMap: import_zod18.z.record(MealPlanDecisionTaskKeySchema, import_zod18.z.boolean()),
   selectedDate: ISODateStringSchema.nullable(),
   selectedTime: TimeHHmmStringSchema.nullable(),
   selectedArea: MealPlanLocationCandidateSchema.nullable(),
   selectedRestaurant: RestaurantSchema.nullable(),
-  selectedMenuCategory: import_zod18.z.string().nullable(),
+  selectedMenuCategory: import_zod19.z.string().nullable(),
   chatRoom: MealPlanChatRoomSummarySchema.nullable(),
   confirmedAt: ISODateTimeStringSchema.nullable(),
   lockedAt: ISODateTimeStringSchema.nullable(),
@@ -1400,36 +1414,31 @@ var MealPlanResponseSchema = import_zod18.z.object({
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema
 });
-var MyMealPlanGroupSchema = import_zod18.z.enum([
-  "DECIDING",
-  "UPCOMING",
-  "RECORD_NEEDED",
-  "PAST"
-]);
-var MyMealPlanListItemSchema = import_zod18.z.object({
+var MyMealPlanGroupSchema = import_zod19.z.enum(["DECIDING", "UPCOMING", "RECORD_NEEDED", "PAST"]);
+var MyMealPlanListItemSchema = import_zod19.z.object({
   mealPlanId: MealPlanIdSchema,
   group: MyMealPlanGroupSchema,
-  title: import_zod18.z.string(),
+  title: import_zod19.z.string(),
   status: MealPlanStatusSchema,
-  channels: import_zod18.z.array(MealPlanChannelSchema),
-  participantCount: import_zod18.z.number().int().min(1),
+  channels: import_zod19.z.array(MealPlanChannelSchema),
+  participantCount: import_zod19.z.number().int().min(1),
   selectedDate: ISODateStringSchema.nullable(),
   selectedTime: TimeHHmmStringSchema.nullable(),
-  selectedAreaName: import_zod18.z.string().nullable(),
-  selectedRestaurantName: import_zod18.z.string().nullable(),
-  primaryAction: import_zod18.z.object({
-    label: import_zod18.z.string(),
-    href: import_zod18.z.string()
+  selectedAreaName: import_zod19.z.string().nullable(),
+  selectedRestaurantName: import_zod19.z.string().nullable(),
+  primaryAction: import_zod19.z.object({
+    label: import_zod19.z.string(),
+    href: import_zod19.z.string()
   }),
   updatedAt: ISODateTimeStringSchema
 });
-var MyMealPlanListResponseSchema = import_zod18.z.object({
-  deciding: import_zod18.z.array(MyMealPlanListItemSchema),
-  upcoming: import_zod18.z.array(MyMealPlanListItemSchema),
-  recordNeeded: import_zod18.z.array(MyMealPlanListItemSchema),
-  past: import_zod18.z.array(MyMealPlanListItemSchema)
+var MyMealPlanListResponseSchema = import_zod19.z.object({
+  deciding: import_zod19.z.array(MyMealPlanListItemSchema),
+  upcoming: import_zod19.z.array(MyMealPlanListItemSchema),
+  recordNeeded: import_zod19.z.array(MyMealPlanListItemSchema),
+  past: import_zod19.z.array(MyMealPlanListItemSchema)
 });
-var MealPlanNotificationKindSchema = import_zod18.z.enum([
+var MealPlanNotificationKindSchema = import_zod19.z.enum([
   "MEAL_PLAN_INVITE_RECEIVED",
   "MEAL_PLAN_INVITE_ACCEPTED",
   "MEAL_PLAN_JOIN_REQUESTED",
@@ -1441,27 +1450,27 @@ var MealPlanNotificationKindSchema = import_zod18.z.enum([
   "MEAL_PLAN_LOCKED",
   "MEAL_PLAN_RECORD_NEEDED"
 ]);
-var MealPlanNotificationPriorityChannelSchema = import_zod18.z.enum([
+var MealPlanNotificationPriorityChannelSchema = import_zod19.z.enum([
   "HOME",
   "NOTIFICATION_INBOX",
   "FCM_PUSH",
   "LIVE_ACTIVITY"
 ]);
-var MealPlanLiveActivityBehaviorSchema = import_zod18.z.enum([
+var MealPlanLiveActivityBehaviorSchema = import_zod19.z.enum([
   "NONE",
   "START_OR_UPDATE",
   "UPDATE",
   "END"
 ]);
-var MealPlanNotificationPriorityPolicyItemSchema = import_zod18.z.object({
+var MealPlanNotificationPriorityPolicyItemSchema = import_zod19.z.object({
   kind: MealPlanNotificationKindSchema,
-  priority: import_zod18.z.number().int().min(0),
-  homePriority: import_zod18.z.number().int().min(0),
-  inboxPriority: import_zod18.z.number().int().min(0),
-  fcmPriority: import_zod18.z.number().int().min(0),
-  liveActivityPriority: import_zod18.z.number().int().min(0),
+  priority: import_zod19.z.number().int().min(0),
+  homePriority: import_zod19.z.number().int().min(0),
+  inboxPriority: import_zod19.z.number().int().min(0),
+  fcmPriority: import_zod19.z.number().int().min(0),
+  liveActivityPriority: import_zod19.z.number().int().min(0),
   liveActivityBehavior: MealPlanLiveActivityBehaviorSchema,
-  foregroundToast: import_zod18.z.boolean()
+  foregroundToast: import_zod19.z.boolean()
 });
 var MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES = {
   MEAL_PLAN_JOIN_REQUESTED: {
@@ -1565,248 +1574,255 @@ var MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES = {
     foregroundToast: false
   }
 };
-var MealPlanNotificationSchema = import_zod18.z.object({
-  notificationId: import_zod18.z.string().min(1),
+var MealPlanNotificationSchema = import_zod19.z.object({
+  notificationId: import_zod19.z.string().min(1),
   kind: MealPlanNotificationKindSchema,
   mealPlanId: MealPlanIdSchema,
-  deepLink: import_zod18.z.string().min(1),
-  title: import_zod18.z.string().min(1),
-  message: import_zod18.z.string().min(1),
+  deepLink: import_zod19.z.string().min(1),
+  title: import_zod19.z.string().min(1),
+  message: import_zod19.z.string().min(1),
   createdAt: ISODateTimeStringSchema,
   readAt: ISODateTimeStringSchema.nullable()
 });
 
+// src/domain/meal-plan/meal-plan.socket.ts
+var import_zod20 = require("zod");
+var MealPlanDecisionVoteSocketEvent = "mealPlan:decision:vote";
+var MealPlanDecisionVoteSocketPayloadSchema = CreateMealPlanVoteRequestSchema.extend({
+  mealPlanId: MealPlanIdSchema,
+  stageId: MealPlanDecisionStageIdSchema,
+  guestSessionToken: import_zod20.z.string().min(1).optional()
+});
+var MealPlanDecisionVoteSocketErrorSchema = import_zod20.z.object({
+  code: import_zod20.z.string().min(1),
+  message: import_zod20.z.string().min(1)
+});
+var MealPlanDecisionVoteSocketSuccessAckSchema = import_zod20.z.object({
+  ok: import_zod20.z.literal(true),
+  mealPlan: MealPlanResponseSchema
+});
+var MealPlanDecisionVoteSocketFailureAckSchema = import_zod20.z.object({
+  ok: import_zod20.z.literal(false),
+  error: MealPlanDecisionVoteSocketErrorSchema
+});
+var MealPlanDecisionVoteSocketAckSchema = import_zod20.z.discriminatedUnion("ok", [
+  MealPlanDecisionVoteSocketSuccessAckSchema,
+  MealPlanDecisionVoteSocketFailureAckSchema
+]);
+
 // src/domain/meal-plan/meal-plan-share-link.schema.ts
-var import_zod19 = require("zod");
-var CreateMealPlanShareLinkRequestSchema = import_zod19.z.object({
+var import_zod21 = require("zod");
+var CreateMealPlanShareLinkRequestSchema = import_zod21.z.object({
   expiresAt: ISODateTimeStringSchema.optional(),
-  guestJoinEnabled: import_zod19.z.boolean().default(true)
+  guestJoinEnabled: import_zod21.z.boolean().default(true)
 });
-var MealPlanShareLinkSummarySchema = import_zod19.z.object({
+var MealPlanShareLinkSummarySchema = import_zod21.z.object({
   shareLinkId: MealPlanShareLinkIdSchema,
   mealPlanId: MealPlanIdSchema,
   token: MealPlanShareLinkTokenSchema,
-  url: import_zod19.z.string().url(),
+  url: import_zod21.z.string().url(),
   expiresAt: ISODateTimeStringSchema,
-  guestJoinEnabled: import_zod19.z.boolean(),
+  guestJoinEnabled: import_zod21.z.boolean(),
   createdAt: ISODateTimeStringSchema
 });
-var MealPlanSharePreviewResponseSchema = import_zod19.z.object({
+var MealPlanSharePreviewResponseSchema = import_zod21.z.object({
   mealPlanId: MealPlanIdSchema,
   token: MealPlanShareLinkTokenSchema,
-  title: import_zod19.z.string(),
-  ownerName: import_zod19.z.string(),
-  participantCount: import_zod19.z.number().int().min(1),
+  title: import_zod21.z.string(),
+  ownerName: import_zod21.z.string(),
+  participantCount: import_zod21.z.number().int().min(1),
   expiresAt: ISODateTimeStringSchema,
-  guestJoinEnabled: import_zod19.z.boolean()
+  guestJoinEnabled: import_zod21.z.boolean()
 });
-var JoinMealPlanGuestRequestSchema = import_zod19.z.object({
-  nickname: import_zod19.z.string().min(1).max(50),
-  password: import_zod19.z.string().min(1).max(100).optional()
+var JoinMealPlanGuestRequestSchema = import_zod21.z.object({
+  nickname: import_zod21.z.string().min(1).max(50),
+  password: import_zod21.z.string().min(1).max(100).optional()
 });
-var JoinMealPlanGuestResponseSchema = import_zod19.z.object({
+var JoinMealPlanGuestResponseSchema = import_zod21.z.object({
   mealPlanId: MealPlanIdSchema,
-  guestId: import_zod19.z.string().min(1),
-  sessionToken: import_zod19.z.string().min(1)
+  guestId: import_zod21.z.string().min(1),
+  sessionToken: import_zod21.z.string().min(1)
 });
-var MealPlanGuestSessionQuerySchema = import_zod19.z.object({
-  sessionToken: import_zod19.z.string().min(1)
+var MealPlanGuestSessionQuerySchema = import_zod21.z.object({
+  sessionToken: import_zod21.z.string().min(1)
 });
-var MealPlanGuestSessionResponseSchema = import_zod19.z.object({
+var MealPlanGuestSessionResponseSchema = import_zod21.z.object({
   mealPlan: MealPlanResponseSchema,
   token: MealPlanShareLinkTokenSchema,
-  guestId: import_zod19.z.string().min(1),
-  nickname: import_zod19.z.string().min(1).max(50),
-  sessionToken: import_zod19.z.string().min(1)
+  guestId: import_zod21.z.string().min(1),
+  nickname: import_zod21.z.string().min(1).max(50),
+  sessionToken: import_zod21.z.string().min(1)
 });
 
 // src/domain/meal-plan/meal-group.schema.ts
-var import_zod20 = require("zod");
-var MealGroupMemberRoleSchema = import_zod20.z.enum([
+var import_zod22 = require("zod");
+var MealGroupMemberRoleSchema = import_zod22.z.enum([
   "OWNER",
   "MEMBER"
 ]);
-var MealGroupMemberSchema = import_zod20.z.object({
+var MealGroupMemberSchema = import_zod22.z.object({
   member: MemberCoreSchema,
   role: MealGroupMemberRoleSchema,
   joinedAt: ISODateTimeStringSchema
 });
-var MealGroupResponseSchema = import_zod20.z.object({
+var MealGroupResponseSchema = import_zod22.z.object({
   mealGroupId: MealGroupIdSchema,
-  name: import_zod20.z.string().min(1).max(50),
+  name: import_zod22.z.string().min(1).max(50),
   owner: MemberCoreSchema,
-  profileImageUrl: import_zod20.z.string().url().nullable(),
-  members: import_zod20.z.array(MealGroupMemberSchema),
-  recentMealPlanIds: import_zod20.z.array(MealPlanIdSchema),
+  profileImageUrl: import_zod22.z.string().url().nullable(),
+  members: import_zod22.z.array(MealGroupMemberSchema),
+  recentMealPlanIds: import_zod22.z.array(MealPlanIdSchema),
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema
 });
-var CreateMealGroupRequestSchema = import_zod20.z.object({
-  name: import_zod20.z.string().min(1).max(50),
-  memberIds: import_zod20.z.array(import_zod20.z.number().int().positive()).min(1),
-  profileImageUrl: import_zod20.z.string().url().nullable().optional(),
+var CreateMealGroupRequestSchema = import_zod22.z.object({
+  name: import_zod22.z.string().min(1).max(50),
+  memberIds: import_zod22.z.array(import_zod22.z.number().int().positive()).min(1),
+  profileImageUrl: import_zod22.z.string().url().nullable().optional(),
   sourceMealPlanId: MealPlanIdSchema.optional()
 });
-var StartMealPlanFromGroupRequestSchema = import_zod20.z.object({
-  title: import_zod20.z.string().min(1).max(100).optional()
+var StartMealPlanFromGroupRequestSchema = import_zod22.z.object({
+  title: import_zod22.z.string().min(1).max(100).optional()
 });
-var AddMealGroupMemberRequestSchema = import_zod20.z.object({
-  memberId: import_zod20.z.number().int().positive(),
+var AddMealGroupMemberRequestSchema = import_zod22.z.object({
+  memberId: import_zod22.z.number().int().positive(),
   role: MealGroupMemberRoleSchema.default("MEMBER")
 });
-var UpdateMealGroupMemberRoleRequestSchema = import_zod20.z.object({
+var UpdateMealGroupMemberRoleRequestSchema = import_zod22.z.object({
   role: MealGroupMemberRoleSchema
 });
 var MealGroupHistoryItemSchema = MyMealPlanListItemSchema.extend({});
-var MealGroupPreferenceSummarySchema = import_zod20.z.object({
+var MealGroupPreferenceSummarySchema = import_zod22.z.object({
   mealGroupId: MealGroupIdSchema,
-  frequentMenuCategories: import_zod20.z.array(import_zod20.z.object({
-    label: import_zod20.z.string(),
-    count: import_zod20.z.number().int().min(0)
-  })),
-  frequentRestaurants: import_zod20.z.array(import_zod20.z.object({
-    restaurantName: import_zod20.z.string(),
-    count: import_zod20.z.number().int().min(0)
-  })),
-  recentMenuCategories: import_zod20.z.array(import_zod20.z.string()),
-  recommendationContext: import_zod20.z.object({
-    preferredMenuCategories: import_zod20.z.array(import_zod20.z.string()),
-    excludedMenuCategories: import_zod20.z.array(import_zod20.z.string()),
-    candidateMenuCategories: import_zod20.z.array(import_zod20.z.string())
+  frequentMenuCategories: import_zod22.z.array(import_zod22.z.object({ label: import_zod22.z.string(), count: import_zod22.z.number().int().min(0) })),
+  frequentRestaurants: import_zod22.z.array(import_zod22.z.object({ restaurantName: import_zod22.z.string(), count: import_zod22.z.number().int().min(0) })),
+  recentMenuCategories: import_zod22.z.array(import_zod22.z.string()),
+  recommendationContext: import_zod22.z.object({
+    preferredMenuCategories: import_zod22.z.array(import_zod22.z.string()),
+    excludedMenuCategories: import_zod22.z.array(import_zod22.z.string()),
+    candidateMenuCategories: import_zod22.z.array(import_zod22.z.string())
   })
 });
-var MealGroupHistoryResponseSchema = import_zod20.z.array(MealGroupHistoryItemSchema);
+var MealGroupHistoryResponseSchema = import_zod22.z.array(MealGroupHistoryItemSchema);
 
 // src/domain/meal-plan/meal-plan-home-map.schema.ts
-var import_zod21 = require("zod");
-var HomeMealPlanActionKindSchema = import_zod21.z.enum([
+var import_zod23 = require("zod");
+var HomeMealPlanActionKindSchema = import_zod23.z.enum([
   "CONTINUE_DECISION",
   "TODAY_UPCOMING",
   "RECORD_NEEDED",
   "RESPOND_JOIN_REQUEST",
   "NOTIFICATION_FOLLOW_UP"
 ]);
-var HomeMealPlanActionCardSchema = import_zod21.z.object({
-  actionId: import_zod21.z.string().min(1),
+var HomeMealPlanActionCardSchema = import_zod23.z.object({
+  actionId: import_zod23.z.string().min(1),
   kind: HomeMealPlanActionKindSchema,
-  priority: import_zod21.z.number().int().min(0),
-  title: import_zod21.z.string().min(1),
-  description: import_zod21.z.string().min(1),
-  primaryAction: import_zod21.z.object({
-    label: import_zod21.z.string().min(1),
-    href: import_zod21.z.string().min(1)
+  priority: import_zod23.z.number().int().min(0),
+  title: import_zod23.z.string().min(1),
+  description: import_zod23.z.string().min(1),
+  primaryAction: import_zod23.z.object({
+    label: import_zod23.z.string().min(1),
+    href: import_zod23.z.string().min(1)
   }),
   mealPlan: MyMealPlanListItemSchema.nullable(),
   joinRequest: MealPlanJoinRequestSummarySchema.nullable(),
   notification: MealPlanNotificationSchema.nullable().default(null)
 });
-var HomeMealPlanDashboardResponseSchema = import_zod21.z.object({
+var HomeMealPlanDashboardResponseSchema = import_zod23.z.object({
   generatedAt: ISODateTimeStringSchema,
-  inProgress: import_zod21.z.array(MyMealPlanListItemSchema),
-  today: import_zod21.z.array(MyMealPlanListItemSchema),
-  recordNeeded: import_zod21.z.array(MyMealPlanListItemSchema),
-  pendingJoinRequests: import_zod21.z.array(MealPlanJoinRequestSummarySchema),
-  unreadNotifications: import_zod21.z.array(MealPlanNotificationSchema).default([]),
-  nextActions: import_zod21.z.array(HomeMealPlanActionCardSchema)
-});
-var MealMapLayerSchema = import_zod21.z.enum([
+  inProgress: import_zod23.z.array(MyMealPlanListItemSchema),
+  today: import_zod23.z.array(MyMealPlanListItemSchema),
+  recordNeeded: import_zod23.z.array(MyMealPlanListItemSchema),
+  pendingJoinRequests: import_zod23.z.array(MealPlanJoinRequestSummarySchema),
+  unreadNotifications: import_zod23.z.array(MealPlanNotificationSchema).default([]),
+  nextActions: import_zod23.z.array(HomeMealPlanActionCardSchema)
+});
+var MealMapLayerSchema = import_zod23.z.enum([
   "MY_MEAL_PLAN_PLACE",
   "NEARBY_FRIEND_MEAL_PLAN",
   "FRIEND_RECORD_LOCATION",
   "RESTAURANT_CANDIDATE"
 ]);
-var MealMapMarkerBaseSchema = import_zod21.z.object({
-  markerId: import_zod21.z.string().min(1),
-  lat: import_zod21.z.number().min(-90).max(90),
-  lng: import_zod21.z.number().min(-180).max(180),
-  title: import_zod21.z.string().min(1),
-  subtitle: import_zod21.z.string().nullable(),
-  href: import_zod21.z.string().min(1).nullable(),
+var MealMapMarkerBaseSchema = import_zod23.z.object({
+  markerId: import_zod23.z.string().min(1),
+  lat: import_zod23.z.number().min(-90).max(90),
+  lng: import_zod23.z.number().min(-180).max(180),
+  title: import_zod23.z.string().min(1),
+  subtitle: import_zod23.z.string().nullable(),
+  href: import_zod23.z.string().min(1).nullable(),
   mealPlanId: MealPlanIdSchema.nullable(),
   articleId: ArticleIdSchema.nullable(),
   restaurant: RestaurantSchema.nullable(),
-  distanceMeters: import_zod21.z.number().int().min(0).nullable(),
+  distanceMeters: import_zod23.z.number().int().min(0).nullable(),
   updatedAt: ISODateTimeStringSchema
 });
-var MealMapMyMealPlanPlaceMetadataSchema = import_zod21.z.object({
+var MealMapMyMealPlanPlaceMetadataSchema = import_zod23.z.object({
   ownerId: MemberIdSchema.nullable().default(null),
-  status: import_zod21.z.string().min(1),
-  participantCount: import_zod21.z.number().int().min(1),
-  source: import_zod21.z.string().min(1)
+  status: import_zod23.z.string().min(1),
+  participantCount: import_zod23.z.number().int().min(1),
+  source: import_zod23.z.string().min(1)
 });
-var MealMapNearbyFriendMealPlanMetadataSchema = import_zod21.z.object({
+var MealMapNearbyFriendMealPlanMetadataSchema = import_zod23.z.object({
   ownerId: MemberIdSchema.nullable().default(null),
-  ownerName: import_zod21.z.string().min(1),
-  participantCount: import_zod21.z.number().int().min(1),
+  ownerName: import_zod23.z.string().min(1),
+  participantCount: import_zod23.z.number().int().min(1),
   expiresAt: ISODateTimeStringSchema.nullable(),
-  source: import_zod21.z.string().min(1)
+  source: import_zod23.z.string().min(1)
 });
-var MealMapFriendRecordLocationMetadataSchema = import_zod21.z.object({
+var MealMapFriendRecordLocationMetadataSchema = import_zod23.z.object({
   authorId: MemberIdSchema.nullable().default(null),
-  authorName: import_zod21.z.string().min(1),
-  imageUrl: import_zod21.z.string().nullable().default(null),
-  mealDate: import_zod21.z.string().min(1)
+  authorName: import_zod23.z.string().min(1),
+  imageUrl: import_zod23.z.string().nullable().default(null),
+  mealDate: import_zod23.z.string().min(1)
 });
-var MealMapRestaurantCandidateCompletionBlockedReasonSchema = import_zod21.z.enum([
+var MealMapRestaurantCandidateCompletionBlockedReasonSchema = import_zod23.z.enum([
   "OWNER_ONLY",
   "STAGE_ALREADY_COMPLETED",
   "MEAL_PLAN_NOT_MUTABLE"
 ]);
-var MealMapRestaurantCandidateMetadataSchema = import_zod21.z.object({
+var MealMapRestaurantCandidateMetadataSchema = import_zod23.z.object({
   stageId: MealPlanDecisionStageIdSchema,
   ownerId: MemberIdSchema.nullable().default(null),
-  status: import_zod21.z.string().min(1),
-  source: import_zod21.z.enum([
-    "search",
-    "fallback",
-    "manual"
-  ]).default("search"),
-  stageStatus: import_zod21.z.enum([
-    "OPEN",
-    "COMPLETED",
-    "REOPENED"
-  ]).default("OPEN"),
-  canVote: import_zod21.z.boolean().default(false),
-  canCompleteStage: import_zod21.z.boolean().default(false),
+  status: import_zod23.z.string().min(1),
+  source: import_zod23.z.enum(["search", "fallback", "manual"]).default("search"),
+  stageStatus: import_zod23.z.enum(["OPEN", "COMPLETED", "REOPENED"]).default("OPEN"),
+  canVote: import_zod23.z.boolean().default(false),
+  canCompleteStage: import_zod23.z.boolean().default(false),
   completionBlockedReason: MealMapRestaurantCandidateCompletionBlockedReasonSchema.nullable().default(null)
 });
-var MealMapMarkerSchema = import_zod21.z.discriminatedUnion("layer", [
+var MealMapMarkerSchema = import_zod23.z.discriminatedUnion("layer", [
   MealMapMarkerBaseSchema.extend({
-    layer: import_zod21.z.literal("MY_MEAL_PLAN_PLACE"),
+    layer: import_zod23.z.literal("MY_MEAL_PLAN_PLACE"),
     metadata: MealMapMyMealPlanPlaceMetadataSchema
   }),
   MealMapMarkerBaseSchema.extend({
-    layer: import_zod21.z.literal("NEARBY_FRIEND_MEAL_PLAN"),
+    layer: import_zod23.z.literal("NEARBY_FRIEND_MEAL_PLAN"),
     metadata: MealMapNearbyFriendMealPlanMetadataSchema
   }),
   MealMapMarkerBaseSchema.extend({
-    layer: import_zod21.z.literal("FRIEND_RECORD_LOCATION"),
+    layer: import_zod23.z.literal("FRIEND_RECORD_LOCATION"),
     metadata: MealMapFriendRecordLocationMetadataSchema
   }),
   MealMapMarkerBaseSchema.extend({
-    layer: import_zod21.z.literal("RESTAURANT_CANDIDATE"),
+    layer: import_zod23.z.literal("RESTAURANT_CANDIDATE"),
     metadata: MealMapRestaurantCandidateMetadataSchema
   })
 ]);
-var MealMapQuerySchema = import_zod21.z.object({
-  friendRecordDays: import_zod21.z.coerce.number().int().min(1).max(90).optional().default(7)
+var MealMapQuerySchema = import_zod23.z.object({
+  friendRecordDays: import_zod23.z.coerce.number().int().min(1).max(90).optional().default(7)
 });
-var MealMapResponseSchema = import_zod21.z.object({
+var MealMapResponseSchema = import_zod23.z.object({
   generatedAt: ISODateTimeStringSchema,
-  center: import_zod21.z.object({
-    lat: import_zod21.z.number().min(-90).max(90),
-    lng: import_zod21.z.number().min(-180).max(180),
-    source: import_zod21.z.enum([
-      "LAST_KNOWN_LOCATION",
-      "MY_MEAL_PLAN",
-      "DEFAULT"
-    ])
+  center: import_zod23.z.object({
+    lat: import_zod23.z.number().min(-90).max(90),
+    lng: import_zod23.z.number().min(-180).max(180),
+    source: import_zod23.z.enum(["LAST_KNOWN_LOCATION", "MY_MEAL_PLAN", "DEFAULT"])
   }),
-  layers: import_zod21.z.object({
-    myMealPlanPlaces: import_zod21.z.array(MealMapMarkerSchema),
-    nearbyFriendMealPlans: import_zod21.z.array(MealMapMarkerSchema),
-    friendRecordLocations: import_zod21.z.array(MealMapMarkerSchema),
-    restaurantCandidates: import_zod21.z.array(MealMapMarkerSchema)
+  layers: import_zod23.z.object({
+    myMealPlanPlaces: import_zod23.z.array(MealMapMarkerSchema),
+    nearbyFriendMealPlans: import_zod23.z.array(MealMapMarkerSchema),
+    friendRecordLocations: import_zod23.z.array(MealMapMarkerSchema),
+    restaurantCandidates: import_zod23.z.array(MealMapMarkerSchema)
   })
 });
 
@@ -1815,7 +1831,6 @@ var DEFAULT_POLICY = MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES.MEAL_PLAN_PARTICIP
 function getMealPlanNotificationPriorityPolicy(kind) {
   return MEAL_PLAN_NOTIFICATION_PRIORITY_POLICIES[kind] ?? DEFAULT_POLICY;
 }
-__name(getMealPlanNotificationPriorityPolicy, "getMealPlanNotificationPriorityPolicy");
 function getMealPlanNotificationPriority(kind, channel = "HOME") {
   const policy = getMealPlanNotificationPriorityPolicy(kind);
   switch (channel) {
@@ -1831,15 +1846,12 @@ function getMealPlanNotificationPriority(kind, channel = "HOME") {
       return policy.priority;
   }
 }
-__name(getMealPlanNotificationPriority, "getMealPlanNotificationPriority");
 function getMealPlanLiveActivityBehavior(kind) {
   return getMealPlanNotificationPriorityPolicy(kind).liveActivityBehavior;
 }
-__name(getMealPlanLiveActivityBehavior, "getMealPlanLiveActivityBehavior");
 function shouldShowForegroundToast(kind) {
   return getMealPlanNotificationPriorityPolicy(kind).foregroundToast;
 }
-__name(shouldShowForegroundToast, "shouldShowForegroundToast");
 function compareMealPlanNotificationsByPriority(channel) {
   return (a, b) => {
     const unreadDelta = Number(Boolean(a.readAt)) - Number(Boolean(b.readAt));
@@ -1849,273 +1861,240 @@ function compareMealPlanNotificationsByPriority(channel) {
     return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
   };
 }
-__name(compareMealPlanNotificationsByPriority, "compareMealPlanNotificationsByPriority");
 
 // src/domain/promotion/referral.schema.ts
-var import_zod22 = require("zod");
-var ReferralCreateResponseSchema = import_zod22.z.object({
+var import_zod24 = require("zod");
+var ReferralCreateResponseSchema = import_zod24.z.object({
   code: ReferralCodeSchema,
-  link: import_zod22.z.string().url(),
+  link: import_zod24.z.string().url(),
   expiresAt: ISODateTimeStringSchema
 });
-var ReferralItemResponseSchema = import_zod22.z.object({
+var ReferralItemResponseSchema = import_zod24.z.object({
   code: ReferralCodeSchema,
   createdAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
-  used: import_zod22.z.boolean(),
+  used: import_zod24.z.boolean(),
   usedByMemberId: MemberIdSchema.nullable(),
-  usedByUsername: import_zod22.z.string().nullable()
+  usedByUsername: import_zod24.z.string().nullable()
 });
-var RedeemReferralRequestSchema = import_zod22.z.object({
+var RedeemReferralRequestSchema = import_zod24.z.object({
   code: ReferralCodeSchema
 });
 
 // src/domain/promotion/coupon.schema.ts
-var import_zod23 = require("zod");
-var CouponTypeSchema = import_zod23.z.enum([
-  "DISCOUNT",
-  "SERVICE"
-]);
-var CouponStatusSchema = import_zod23.z.enum([
-  "UNUSED",
-  "USED"
-]);
-var CouponResponseSchema = import_zod23.z.object({
+var import_zod25 = require("zod");
+var CouponTypeSchema = import_zod25.z.enum(["DISCOUNT", "SERVICE"]);
+var CouponStatusSchema = import_zod25.z.enum(["UNUSED", "USED"]);
+var CouponResponseSchema = import_zod25.z.object({
   couponId: CouponIdSchema,
-  title: import_zod23.z.string(),
-  shopName: import_zod23.z.string(),
+  title: import_zod25.z.string(),
+  shopName: import_zod25.z.string(),
   type: CouponTypeSchema,
-  condition: import_zod23.z.string(),
+  condition: import_zod25.z.string(),
   expiresAt: ISODateStringSchema,
-  used: import_zod23.z.boolean(),
-  thumbnailUrl: import_zod23.z.string().url()
+  used: import_zod25.z.boolean(),
+  thumbnailUrl: import_zod25.z.string().url()
 });
 
 // src/domain/promotion/challenge.schema.ts
-var import_zod24 = require("zod");
-var RewardTypeSchema = import_zod24.z.enum([
-  "WEEK",
-  "MONTH"
-]);
-var WeekProgressSchema = import_zod24.z.object({
-  days: import_zod24.z.array(import_zod24.z.boolean()),
-  completed: import_zod24.z.number().int().min(0),
-  goal: import_zod24.z.number().int().positive()
+var import_zod26 = require("zod");
+var RewardTypeSchema = import_zod26.z.enum(["WEEK", "MONTH"]);
+var WeekProgressSchema = import_zod26.z.object({
+  days: import_zod26.z.array(import_zod26.z.boolean()),
+  completed: import_zod26.z.number().int().min(0),
+  goal: import_zod26.z.number().int().positive()
 });
-var MonthProgressSchema = import_zod24.z.object({
-  count: import_zod24.z.number().int().min(0),
-  goal: import_zod24.z.number().int().positive()
+var MonthProgressSchema = import_zod26.z.object({
+  count: import_zod26.z.number().int().min(0),
+  goal: import_zod26.z.number().int().positive()
 });
-var ChallengeStatusResponseSchema = import_zod24.z.object({
+var ChallengeStatusResponseSchema = import_zod26.z.object({
   week: WeekProgressSchema,
   month: MonthProgressSchema,
-  weekRewardAvailable: import_zod24.z.boolean(),
-  monthRewardAvailable: import_zod24.z.boolean()
+  weekRewardAvailable: import_zod26.z.boolean(),
+  monthRewardAvailable: import_zod26.z.boolean()
 });
-var ClaimChallengeRewardRequestSchema = import_zod24.z.object({
+var ClaimChallengeRewardRequestSchema = import_zod26.z.object({
   type: RewardTypeSchema
 });
-var ClaimChallengeRewardResponseSchema = import_zod24.z.object({
+var ClaimChallengeRewardResponseSchema = import_zod26.z.object({
   rewardType: RewardTypeSchema,
-  claimed: import_zod24.z.boolean()
+  claimed: import_zod26.z.boolean()
 });
 
 // src/domain/push/push.schema.ts
-var import_zod25 = require("zod");
-var PushProviderSchema = import_zod25.z.enum([
-  "FCM",
-  "APNS_LIVE_ACTIVITY"
-]);
-var PushPlatformSchema = import_zod25.z.enum([
-  "WEB",
-  "ANDROID",
-  "IOS"
-]);
-var PushPermissionStatusSchema = import_zod25.z.enum([
+var import_zod27 = require("zod");
+var PushProviderSchema = import_zod27.z.enum(["FCM", "APNS_LIVE_ACTIVITY"]);
+var PushPlatformSchema = import_zod27.z.enum(["WEB", "ANDROID", "IOS"]);
+var PushPermissionStatusSchema = import_zod27.z.enum([
   "UNKNOWN",
   "PROMPT",
   "GRANTED",
   "DENIED"
 ]);
-var PushTokenStatusSchema = import_zod25.z.enum([
-  "ACTIVE",
-  "REVOKED",
-  "DISABLED"
-]);
-var RegisterPushTokenRequestSchema = import_zod25.z.object({
+var PushTokenStatusSchema = import_zod27.z.enum(["ACTIVE", "REVOKED", "DISABLED"]);
+var RegisterPushTokenRequestSchema = import_zod27.z.object({
   provider: PushProviderSchema.default("FCM"),
   platform: PushPlatformSchema,
-  token: import_zod25.z.string().min(10),
-  deviceId: import_zod25.z.string().min(1).max(128),
-  appVersion: import_zod25.z.string().min(1).max(64).optional(),
-  buildNumber: import_zod25.z.string().min(1).max(64).optional(),
+  token: import_zod27.z.string().min(10),
+  deviceId: import_zod27.z.string().min(1).max(128),
+  appVersion: import_zod27.z.string().min(1).max(64).optional(),
+  buildNumber: import_zod27.z.string().min(1).max(64).optional(),
   permissionStatus: PushPermissionStatusSchema
 });
-var RevokePushTokenRequestSchema = import_zod25.z.object({
+var RevokePushTokenRequestSchema = import_zod27.z.object({
   provider: PushProviderSchema.default("FCM"),
-  token: import_zod25.z.string().min(10).optional(),
-  deviceId: import_zod25.z.string().min(1).max(128).optional()
+  token: import_zod27.z.string().min(10).optional(),
+  deviceId: import_zod27.z.string().min(1).max(128).optional()
 });
-var PushTokenResponseSchema = import_zod25.z.object({
-  pushTokenId: import_zod25.z.string().uuid(),
+var PushTokenResponseSchema = import_zod27.z.object({
+  pushTokenId: import_zod27.z.string().uuid(),
   provider: PushProviderSchema,
   platform: PushPlatformSchema,
-  deviceId: import_zod25.z.string(),
+  deviceId: import_zod27.z.string(),
   status: PushTokenStatusSchema,
   permissionStatus: PushPermissionStatusSchema,
-  appVersion: import_zod25.z.string().nullable(),
-  buildNumber: import_zod25.z.string().nullable(),
+  appVersion: import_zod27.z.string().nullable(),
+  buildNumber: import_zod27.z.string().nullable(),
   lastSeenAt: ISODateTimeStringSchema,
   revokedAt: ISODateTimeStringSchema.nullable()
 });
-var PushPayloadSchemaVersionSchema = import_zod25.z.literal("2026-06-17");
-var MealPlanPushPayloadDataSchema = import_zod25.z.object({
+var PushPayloadSchemaVersionSchema = import_zod27.z.literal("2026-06-17");
+var MealPlanPushPayloadDataSchema = import_zod27.z.object({
   schemaVersion: PushPayloadSchemaVersionSchema,
-  notificationId: import_zod25.z.string().min(1),
+  notificationId: import_zod27.z.string().min(1),
   kind: MealPlanNotificationKindSchema,
   mealPlanId: MealPlanIdSchema,
-  deepLink: import_zod25.z.string().min(1),
-  title: import_zod25.z.string().min(1),
-  body: import_zod25.z.string().min(1),
-  fcmPriority: import_zod25.z.coerce.number().int().min(0),
-  liveActivityPriority: import_zod25.z.coerce.number().int().min(0),
+  deepLink: import_zod27.z.string().min(1),
+  title: import_zod27.z.string().min(1),
+  body: import_zod27.z.string().min(1),
+  fcmPriority: import_zod27.z.coerce.number().int().min(0),
+  liveActivityPriority: import_zod27.z.coerce.number().int().min(0),
   liveActivityBehavior: MealPlanLiveActivityBehaviorSchema
 });
-var PushDeliveryStatusSchema = import_zod25.z.enum([
+var PushDeliveryStatusSchema = import_zod27.z.enum([
   "PENDING",
   "SENT",
   "FAILED",
   "SKIPPED"
 ]);
-var PushDeliveryAttemptResultSchema = import_zod25.z.enum([
+var PushDeliveryAttemptResultSchema = import_zod27.z.enum([
   "SENT",
   "FAILED",
   "SKIPPED"
 ]);
-var PushDeliveryAttemptSummarySchema = import_zod25.z.object({
-  attemptId: import_zod25.z.string().uuid(),
-  outboxId: import_zod25.z.string().uuid(),
-  pushTokenId: import_zod25.z.string().uuid().nullable(),
+var PushDeliveryAttemptSummarySchema = import_zod27.z.object({
+  attemptId: import_zod27.z.string().uuid(),
+  outboxId: import_zod27.z.string().uuid(),
+  pushTokenId: import_zod27.z.string().uuid().nullable(),
   provider: PushProviderSchema,
   result: PushDeliveryAttemptResultSchema,
-  providerMessageId: import_zod25.z.string().nullable(),
-  errorCode: import_zod25.z.string().nullable(),
-  errorMessage: import_zod25.z.string().nullable(),
-  invalidToken: import_zod25.z.boolean(),
+  providerMessageId: import_zod27.z.string().nullable(),
+  errorCode: import_zod27.z.string().nullable(),
+  errorMessage: import_zod27.z.string().nullable(),
+  invalidToken: import_zod27.z.boolean(),
   createdAt: ISODateTimeStringSchema
 });
-var PushDeliveryOutboxSummarySchema = import_zod25.z.object({
-  outboxId: import_zod25.z.string().uuid(),
-  notificationId: import_zod25.z.string().min(1),
-  memberId: import_zod25.z.number().int().positive(),
+var PushDeliveryOutboxSummarySchema = import_zod27.z.object({
+  outboxId: import_zod27.z.string().uuid(),
+  notificationId: import_zod27.z.string().min(1),
+  memberId: import_zod27.z.number().int().positive(),
   status: PushDeliveryStatusSchema,
-  attemptCount: import_zod25.z.number().int().min(0),
-  lastError: import_zod25.z.string().nullable(),
+  attemptCount: import_zod27.z.number().int().min(0),
+  lastError: import_zod27.z.string().nullable(),
   nextAttemptAt: ISODateTimeStringSchema.nullable(),
   sentAt: ISODateTimeStringSchema.nullable(),
   createdAt: ISODateTimeStringSchema
 });
 
 // src/domain/live-activity/live-activity.schema.ts
-var import_zod26 = require("zod");
-var MealPlanLiveActivityPlatformSchema = import_zod26.z.enum([
+var import_zod28 = require("zod");
+var MealPlanLiveActivityPlatformSchema = import_zod28.z.enum([
   "IOS_LIVE_ACTIVITY",
   "ANDROID_LIVE_UPDATE"
 ]);
-var MealPlanLiveActivitySessionStatusSchema = import_zod26.z.enum([
+var MealPlanLiveActivitySessionStatusSchema = import_zod28.z.enum([
   "ACTIVE",
   "ENDED",
   "EXPIRED",
   "DISABLED"
 ]);
-var MealPlanLiveActivityUpdateStatusSchema = import_zod26.z.enum([
+var MealPlanLiveActivityUpdateStatusSchema = import_zod28.z.enum([
   "PENDING",
   "SENT",
   "FAILED",
   "SKIPPED"
 ]);
-var RegisterMealPlanLiveActivitySessionRequestSchema = import_zod26.z.object({
+var RegisterMealPlanLiveActivitySessionRequestSchema = import_zod28.z.object({
   platform: MealPlanLiveActivityPlatformSchema,
-  deviceId: import_zod26.z.string().min(1).max(128),
-  activityId: import_zod26.z.string().min(1).max(128),
-  pushToken: import_zod26.z.string().min(10).optional(),
-  appVersion: import_zod26.z.string().min(1).max(64).optional(),
-  buildNumber: import_zod26.z.string().min(1).max(64).optional()
+  deviceId: import_zod28.z.string().min(1).max(128),
+  activityId: import_zod28.z.string().min(1).max(128),
+  pushToken: import_zod28.z.string().min(10).optional(),
+  appVersion: import_zod28.z.string().min(1).max(64).optional(),
+  buildNumber: import_zod28.z.string().min(1).max(64).optional()
 });
-var EndMealPlanLiveActivitySessionRequestSchema = import_zod26.z.object({
+var EndMealPlanLiveActivitySessionRequestSchema = import_zod28.z.object({
   platform: MealPlanLiveActivityPlatformSchema.optional(),
-  deviceId: import_zod26.z.string().min(1).max(128).optional(),
-  activityId: import_zod26.z.string().min(1).max(128).optional()
+  deviceId: import_zod28.z.string().min(1).max(128).optional(),
+  activityId: import_zod28.z.string().min(1).max(128).optional()
 });
-var MealPlanLiveActivityStateSchema = import_zod26.z.object({
+var MealPlanLiveActivityStateSchema = import_zod28.z.object({
   mealPlanId: MealPlanIdSchema,
-  title: import_zod26.z.string().min(1),
-  status: import_zod26.z.string().min(1),
+  title: import_zod28.z.string().min(1),
+  status: import_zod28.z.string().min(1),
   scheduledAt: ISODateTimeStringSchema.nullable(),
-  restaurantName: import_zod26.z.string().nullable(),
-  placeName: import_zod26.z.string().nullable(),
-  deepLink: import_zod26.z.string().min(1),
-  progressLabel: import_zod26.z.string().min(1),
+  restaurantName: import_zod28.z.string().nullable(),
+  placeName: import_zod28.z.string().nullable(),
+  deepLink: import_zod28.z.string().min(1),
+  progressLabel: import_zod28.z.string().min(1),
   updatedAt: ISODateTimeStringSchema
 });
-var MealPlanLiveActivitySessionResponseSchema = import_zod26.z.object({
-  sessionId: import_zod26.z.string().uuid(),
+var MealPlanLiveActivitySessionResponseSchema = import_zod28.z.object({
+  sessionId: import_zod28.z.string().uuid(),
   mealPlanId: MealPlanIdSchema,
-  memberId: import_zod26.z.number().int().positive(),
+  memberId: import_zod28.z.number().int().positive(),
   platform: MealPlanLiveActivityPlatformSchema,
   devicePlatform: PushPlatformSchema,
-  deviceId: import_zod26.z.string(),
-  activityId: import_zod26.z.string(),
+  deviceId: import_zod28.z.string(),
+  activityId: import_zod28.z.string(),
   status: MealPlanLiveActivitySessionStatusSchema,
-  appVersion: import_zod26.z.string().nullable(),
-  buildNumber: import_zod26.z.string().nullable(),
+  appVersion: import_zod28.z.string().nullable(),
+  buildNumber: import_zod28.z.string().nullable(),
   lastEventKind: MealPlanNotificationKindSchema.nullable(),
   lastBehavior: MealPlanLiveActivityBehaviorSchema.nullable(),
   lastUpdateStatus: MealPlanLiveActivityUpdateStatusSchema.nullable(),
-  lastError: import_zod26.z.string().nullable(),
+  lastError: import_zod28.z.string().nullable(),
   startedAt: ISODateTimeStringSchema,
   endedAt: ISODateTimeStringSchema.nullable(),
   updatedAt: ISODateTimeStringSchema
 });
-var MealPlanLiveActivitySessionListResponseSchema = import_zod26.z.object({
+var MealPlanLiveActivitySessionListResponseSchema = import_zod28.z.object({
   mealPlanId: MealPlanIdSchema,
   state: MealPlanLiveActivityStateSchema,
-  sessions: import_zod26.z.array(MealPlanLiveActivitySessionResponseSchema)
+  sessions: import_zod28.z.array(MealPlanLiveActivitySessionResponseSchema)
 });
 
 // src/domain/common/contracts/endpoint.ts
-var import_zod27 = require("zod");
-var NoBodySchema = import_zod27.z.undefined();
-var NoQuerySchema = import_zod27.z.undefined();
-var NoParamsSchema = import_zod27.z.undefined();
-var endpoint = /* @__PURE__ */ __name((contract) => ({
+var import_zod29 = require("zod");
+var NoBodySchema = import_zod29.z.undefined();
+var NoQuerySchema = import_zod29.z.undefined();
+var NoParamsSchema = import_zod29.z.undefined();
+var endpoint = (contract) => ({
   method: contract.method,
   path: contract.path,
   pathParams: contract.pathParams ?? NoParamsSchema,
   query: contract.query ?? NoQuerySchema,
   body: contract.body ?? NoBodySchema,
   response: contract.response
-}), "endpoint");
+});
 
 // src/domain/common/contracts/api.ts
-var memberIdParam = import_zod28.z.object({
-  memberId: MemberIdSchema
-});
-var articleIdParam = import_zod28.z.object({
-  articleId: ArticleIdSchema
-});
-var commentIdParam = import_zod28.z.object({
-  commentId: CommentIdSchema
-});
-var mealPlanIdParam = import_zod28.z.object({
-  mealPlanId: MealPlanIdSchema
-});
-var mealPlanInviteIdParam = import_zod28.z.object({
-  inviteId: MealPlanInviteIdSchema
-});
-var mealPlanJoinRequestIdParam = import_zod28.z.object({
-  requestId: MealPlanJoinRequestIdSchema
-});
+var memberIdParam = import_zod30.z.object({ memberId: MemberIdSchema });
+var articleIdParam = import_zod30.z.object({ articleId: ArticleIdSchema });
+var commentIdParam = import_zod30.z.object({ commentId: CommentIdSchema });
+var mealPlanIdParam = import_zod30.z.object({ mealPlanId: MealPlanIdSchema });
+var mealPlanInviteIdParam = import_zod30.z.object({ inviteId: MealPlanInviteIdSchema });
+var mealPlanJoinRequestIdParam = import_zod30.z.object({ requestId: MealPlanJoinRequestIdSchema });
 var mealPlanDecisionStageIdParam = mealPlanIdParam.extend({
   stageId: MealPlanDecisionStageIdSchema
 });
@@ -2126,707 +2105,156 @@ var mealPlanDecisionTaskKeyParam = mealPlanIdParam.extend({
   taskKey: MealPlanDecisionTaskKeySchema
 });
 var mealPlanDecisionSnapshotIdParam = mealPlanIdParam.extend({
-  snapshotId: import_zod28.z.string().uuid()
+  snapshotId: import_zod30.z.string().uuid()
 });
 var mealPlanParticipantIdParam = mealPlanIdParam.extend({
-  participantId: import_zod28.z.string().uuid()
-});
-var mealPlanShareTokenParam = import_zod28.z.object({
-  token: MealPlanShareLinkTokenSchema
-});
-var notificationIdParam = import_zod28.z.object({
-  notificationId: import_zod28.z.string().min(1)
-});
-var couponIdParam = import_zod28.z.object({
-  couponId: CouponIdSchema
-});
-var mealGroupIdParam = import_zod28.z.object({
-  mealGroupId: MealGroupIdSchema
-});
-var mealGroupMemberIdParam = mealGroupIdParam.extend({
-  memberId: MemberIdSchema
-});
-var friendRequestIdParam = import_zod28.z.object({
-  requestId: FriendRequestIdSchema
-});
-var sseTokenQuery = import_zod28.z.object({
-  token: import_zod28.z.string().min(1)
-});
+  participantId: import_zod30.z.string().uuid()
+});
+var mealPlanShareTokenParam = import_zod30.z.object({ token: MealPlanShareLinkTokenSchema });
+var notificationIdParam = import_zod30.z.object({ notificationId: import_zod30.z.string().min(1) });
+var couponIdParam = import_zod30.z.object({ couponId: CouponIdSchema });
+var mealGroupIdParam = import_zod30.z.object({ mealGroupId: MealGroupIdSchema });
+var mealGroupMemberIdParam = mealGroupIdParam.extend({ memberId: MemberIdSchema });
+var friendRequestIdParam = import_zod30.z.object({ requestId: FriendRequestIdSchema });
+var sseTokenQuery = import_zod30.z.object({ token: import_zod30.z.string().min(1) });
 var apiContract = {
   auth: {
-    signup: endpoint({
-      method: "POST",
-      path: "/auth/signup",
-      body: SignupRequestSchema,
-      response: SignupResponseSchema
-    }),
-    login: endpoint({
-      method: "POST",
-      path: "/auth/login",
-      body: LoginRequestSchema,
-      response: TokenResponseSchema
-    }),
-    refresh: endpoint({
-      method: "POST",
-      path: "/auth/refresh",
-      response: TokenResponseSchema
-    }),
-    logout: endpoint({
-      method: "POST",
-      path: "/auth/logout",
-      response: NoContentSchema
-    })
+    signup: endpoint({ method: "POST", path: "/auth/signup", body: SignupRequestSchema, response: SignupResponseSchema }),
+    login: endpoint({ method: "POST", path: "/auth/login", body: LoginRequestSchema, response: TokenResponseSchema }),
+    refresh: endpoint({ method: "POST", path: "/auth/refresh", response: TokenResponseSchema }),
+    logout: endpoint({ method: "POST", path: "/auth/logout", response: NoContentSchema })
   },
   members: {
-    me: endpoint({
-      method: "GET",
-      path: "/members/me",
-      response: MemberResponseSchema
-    }),
-    myProfile: endpoint({
-      method: "GET",
-      path: "/members/me/profile",
-      response: ProfileDetailResponseSchema
-    }),
-    search: endpoint({
-      method: "GET",
-      path: "/members/search",
-      query: MemberSearchQuerySchema,
-      response: MemberSerachResponseSchema
-    }),
-    memberProfile: endpoint({
-      method: "GET",
-      path: "/members/:memberId/profile",
-      pathParams: memberIdParam,
-      response: ProfileDetailResponseSchema
-    }),
-    presignProfileImage: endpoint({
-      method: "POST",
-      path: "/uploads/presign-profile",
-      body: UploadProfileImageRequestSchema,
-      response: UploadProfileImageResponseSchema
-    }),
-    createProfile: endpoint({
-      method: "POST",
-      path: "/members/onboarding",
-      body: CreateProfileRequestSchema,
-      response: NoContentSchema
-    }),
-    createProfileAlias: endpoint({
-      method: "POST",
-      path: "/onboarding",
-      body: CreateProfileRequestSchema,
-      response: NoContentSchema
-    }),
-    updateProfile: endpoint({
-      method: "PATCH",
-      path: "/members/me/profile",
-      body: UpdateProfileRequestSchema,
-      response: NoContentSchema
-    }),
-    locationSettings: endpoint({
-      method: "GET",
-      path: "/members/me/location-settings",
-      response: MemberLocationSettingsResponseSchema
-    }),
-    updateLocationConsent: endpoint({
-      method: "PATCH",
-      path: "/members/me/location-consent",
-      body: UpdateMemberLocationConsentRequestSchema,
-      response: MemberLocationSettingsResponseSchema
-    }),
-    updateLocation: endpoint({
-      method: "PATCH",
-      path: "/members/me/location",
-      body: UpdateMemberLocationRequestSchema,
-      response: MemberLocationSettingsResponseSchema
-    })
+    me: endpoint({ method: "GET", path: "/members/me", response: MemberResponseSchema }),
+    myProfile: endpoint({ method: "GET", path: "/members/me/profile", response: ProfileDetailResponseSchema }),
+    search: endpoint({ method: "GET", path: "/members/search", query: MemberSearchQuerySchema, response: MemberSerachResponseSchema }),
+    memberProfile: endpoint({ method: "GET", path: "/members/:memberId/profile", pathParams: memberIdParam, response: ProfileDetailResponseSchema }),
+    presignProfileImage: endpoint({ method: "POST", path: "/uploads/presign-profile", body: UploadProfileImageRequestSchema, response: UploadProfileImageResponseSchema }),
+    createProfile: endpoint({ method: "POST", path: "/members/onboarding", body: CreateProfileRequestSchema, response: NoContentSchema }),
+    createProfileAlias: endpoint({ method: "POST", path: "/onboarding", body: CreateProfileRequestSchema, response: NoContentSchema }),
+    updateProfile: endpoint({ method: "PATCH", path: "/members/me/profile", body: UpdateProfileRequestSchema, response: NoContentSchema }),
+    locationSettings: endpoint({ method: "GET", path: "/members/me/location-settings", response: MemberLocationSettingsResponseSchema }),
+    updateLocationConsent: endpoint({ method: "PATCH", path: "/members/me/location-consent", body: UpdateMemberLocationConsentRequestSchema, response: MemberLocationSettingsResponseSchema }),
+    updateLocation: endpoint({ method: "PATCH", path: "/members/me/location", body: UpdateMemberLocationRequestSchema, response: MemberLocationSettingsResponseSchema })
   },
   preferences: {
-    my: endpoint({
-      method: "GET",
-      path: "/preferences/me",
-      response: MemberFoodPreferenceSchema
-    }),
-    update: endpoint({
-      method: "PATCH",
-      path: "/preferences/me",
-      body: UpdatePreferenceRequestSchema,
-      response: NoContentSchema
-    })
+    my: endpoint({ method: "GET", path: "/preferences/me", response: MemberFoodPreferenceSchema }),
+    update: endpoint({ method: "PATCH", path: "/preferences/me", body: UpdatePreferenceRequestSchema, response: NoContentSchema })
   },
   mealStatus: {
-    my: endpoint({
-      method: "GET",
-      path: "/members/me/meal-status",
-      response: MealStatusResponseSchema
-    }),
-    updateMealStatus: endpoint({
-      method: "PATCH",
-      path: "/members/me/meal-status",
-      body: UpdateMealStatusRequestSchema,
-      response: NoContentSchema
-    }),
-    friendMealStatus: endpoint({
-      method: "GET",
-      path: "/friends/me/meals",
-      query: FriendMealQuerySchema,
-      response: import_zod28.z.array(FriendMealItemResponseSchema)
-    })
+    my: endpoint({ method: "GET", path: "/members/me/meal-status", response: MealStatusResponseSchema }),
+    updateMealStatus: endpoint({ method: "PATCH", path: "/members/me/meal-status", body: UpdateMealStatusRequestSchema, response: NoContentSchema }),
+    friendMealStatus: endpoint({ method: "GET", path: "/friends/me/meals", query: FriendMealQuerySchema, response: import_zod30.z.array(FriendMealItemResponseSchema) })
   },
   articles: {
-    list: endpoint({
-      method: "GET",
-      path: "/articles/home",
-      query: ArticleListQuerySchema,
-      response: PageArticleSummaryResponseSchema
-    }),
-    byMember: endpoint({
-      method: "GET",
-      path: "/articles/by-author/:memberId",
-      pathParams: memberIdParam,
-      query: ArticleListQuerySchema,
-      response: PageArticleSummaryResponseSchema
-    }),
-    my: endpoint({
-      method: "GET",
-      path: "/articles/my",
-      response: PageArticleSummaryResponseSchema
-    }),
-    detail: endpoint({
-      method: "GET",
-      path: "/articles/:articleId",
-      pathParams: articleIdParam,
-      response: ArticleDetailResponseSchema
-    }),
-    create: endpoint({
-      method: "POST",
-      path: "/articles",
-      body: CreateArticleRequestSchema,
-      response: CreatedEntityIdResponseSchema
-    }),
-    like: endpoint({
-      method: "POST",
-      path: "/articles/:articleId/like",
-      pathParams: articleIdParam,
-      response: ArticleLikeResponseSchema
-    }),
-    createComment: endpoint({
-      method: "POST",
-      path: "/articles/:articleId/comments",
-      pathParams: articleIdParam,
-      body: CreateCommentRequestSchema,
-      response: CreatedEntityIdResponseSchema
-    }),
-    presignArticleImage: endpoint({
-      method: "POST",
-      path: "/uploads/presign-article",
-      body: UploadArticleImageRequestSchema,
-      response: UploadArticleImageResponseSchema
-    }),
-    delete: endpoint({
-      method: "DELETE",
-      path: "/articles/:articleId",
-      pathParams: articleIdParam,
-      response: NoContentSchema
-    }),
-    deleteComment: endpoint({
-      method: "DELETE",
-      path: "/articles/comments/:commentId",
-      pathParams: commentIdParam,
-      response: NoContentSchema
-    })
+    list: endpoint({ method: "GET", path: "/articles/home", query: ArticleListQuerySchema, response: PageArticleSummaryResponseSchema }),
+    byMember: endpoint({ method: "GET", path: "/articles/by-author/:memberId", pathParams: memberIdParam, query: ArticleListQuerySchema, response: PageArticleSummaryResponseSchema }),
+    my: endpoint({ method: "GET", path: "/articles/my", response: PageArticleSummaryResponseSchema }),
+    detail: endpoint({ method: "GET", path: "/articles/:articleId", pathParams: articleIdParam, response: ArticleDetailResponseSchema }),
+    create: endpoint({ method: "POST", path: "/articles", body: CreateArticleRequestSchema, response: CreatedEntityIdResponseSchema }),
+    like: endpoint({ method: "POST", path: "/articles/:articleId/like", pathParams: articleIdParam, response: ArticleLikeResponseSchema }),
+    createComment: endpoint({ method: "POST", path: "/articles/:articleId/comments", pathParams: articleIdParam, body: CreateCommentRequestSchema, response: CreatedEntityIdResponseSchema }),
+    presignArticleImage: endpoint({ method: "POST", path: "/uploads/presign-article", body: UploadArticleImageRequestSchema, response: UploadArticleImageResponseSchema }),
+    delete: endpoint({ method: "DELETE", path: "/articles/:articleId", pathParams: articleIdParam, response: NoContentSchema }),
+    deleteComment: endpoint({ method: "DELETE", path: "/articles/comments/:commentId", pathParams: commentIdParam, response: NoContentSchema })
   },
   mealPlans: {
-    create: endpoint({
-      method: "POST",
-      path: "/meal-plans",
-      body: CreateMealPlanRequestSchema,
-      response: CreateMealPlanResponseSchema
-    }),
-    my: endpoint({
-      method: "GET",
-      path: "/meal-plans/me",
-      response: MyMealPlanListResponseSchema
-    }),
-    homeDashboard: endpoint({
-      method: "GET",
-      path: "/meal-plans/home-dashboard",
-      response: HomeMealPlanDashboardResponseSchema
-    }),
-    map: endpoint({
-      method: "GET",
-      path: "/meal-plans/map",
-      query: MealMapQuerySchema,
-      response: MealMapResponseSchema
-    }),
-    detail: endpoint({
-      method: "GET",
-      path: "/meal-plans/:mealPlanId",
-      pathParams: mealPlanIdParam,
-      response: MealPlanResponseSchema
-    }),
-    chatMessages: endpoint({
-      method: "GET",
-      path: "/meal-plans/:mealPlanId/chat/messages",
-      pathParams: mealPlanIdParam,
-      response: MealPlanChatMessageListResponseSchema
-    }),
-    updateContext: endpoint({
-      method: "PATCH",
-      path: "/meal-plans/:mealPlanId/context",
-      pathParams: mealPlanIdParam,
-      body: UpdateMealPlanContextRequestSchema,
-      response: MealPlanResponseSchema
-    }),
-    complete: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/complete",
-      pathParams: mealPlanIdParam,
-      response: MealPlanResponseSchema
-    }),
-    cancel: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/cancel",
-      pathParams: mealPlanIdParam,
-      response: MealPlanResponseSchema
-    }),
-    removeParticipant: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/participants/:participantId/remove",
-      pathParams: mealPlanParticipantIdParam,
-      response: MealPlanResponseSchema
-    }),
-    recorded: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/recorded",
-      pathParams: mealPlanIdParam,
-      response: MealPlanResponseSchema
-    }),
-    invite: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/invites",
-      pathParams: mealPlanIdParam,
-      body: CreateMealPlanInviteRequestSchema,
-      response: SendMealPlanInviteResponseSchema
-    }),
-    receivedInvites: endpoint({
-      method: "GET",
-      path: "/meal-plans/invites/received",
-      response: MealPlanInviteListResponseSchema
-    }),
-    sentInvites: endpoint({
-      method: "GET",
-      path: "/meal-plans/invites/sent",
-      response: MealPlanInviteListResponseSchema
-    }),
-    acceptInvite: endpoint({
-      method: "POST",
-      path: "/meal-plans/invites/:inviteId/accept",
-      pathParams: mealPlanInviteIdParam,
-      response: MealPlanResponseSchema
-    }),
-    declineInvite: endpoint({
-      method: "POST",
-      path: "/meal-plans/invites/:inviteId/decline",
-      pathParams: mealPlanInviteIdParam,
-      response: NoContentSchema
-    }),
-    createShareLink: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/share-links",
-      pathParams: mealPlanIdParam,
-      body: CreateMealPlanShareLinkRequestSchema,
-      response: MealPlanShareLinkSummarySchema
-    }),
-    sharePreview: endpoint({
-      method: "GET",
-      path: "/meal-plan-links/:token",
-      pathParams: mealPlanShareTokenParam,
-      response: MealPlanSharePreviewResponseSchema
-    }),
-    joinGuest: endpoint({
-      method: "POST",
-      path: "/meal-plan-links/:token/join",
-      pathParams: mealPlanShareTokenParam,
-      body: JoinMealPlanGuestRequestSchema,
-      response: JoinMealPlanGuestResponseSchema
-    }),
-    guestSession: endpoint({
-      method: "GET",
-      path: "/meal-plan-links/:token/session",
-      pathParams: mealPlanShareTokenParam,
-      query: MealPlanGuestSessionQuerySchema,
-      response: MealPlanGuestSessionResponseSchema
-    }),
-    guestChatMessages: endpoint({
-      method: "GET",
-      path: "/meal-plan-links/:token/chat/messages",
-      pathParams: mealPlanShareTokenParam,
-      query: MealPlanGuestSessionQuerySchema,
-      response: MealPlanChatMessageListResponseSchema
-    }),
-    exposeNearbyFriends: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/nearby-friends/expose",
-      pathParams: mealPlanIdParam,
-      body: ExposeMealPlanToNearbyFriendsRequestSchema,
-      response: ExposeMealPlanToNearbyFriendsResponseSchema
-    }),
-    closeNearbyFriends: endpoint({
-      method: "DELETE",
-      path: "/meal-plans/:mealPlanId/nearby-friends/expose",
-      pathParams: mealPlanIdParam,
-      response: NoContentSchema
-    }),
-    nearbyFriendExposureEligibility: endpoint({
-      method: "GET",
-      path: "/meal-plans/nearby-friends/eligibility",
-      response: NearbyFriendExposureEligibilitySchema
-    }),
-    nearbyFriends: endpoint({
-      method: "GET",
-      path: "/meal-plans/nearby-friends",
-      response: import_zod28.z.array(NearbyFriendMealPlanSummarySchema)
-    }),
-    requestJoin: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/join-requests",
-      pathParams: mealPlanIdParam,
-      body: CreateMealPlanJoinRequestSchema,
-      response: CreatedEntityIdResponseSchema
-    }),
-    acceptJoinRequest: endpoint({
-      method: "POST",
-      path: "/meal-plans/join-requests/:requestId/accept",
-      pathParams: mealPlanJoinRequestIdParam,
-      response: MealPlanResponseSchema
-    }),
-    rejectJoinRequest: endpoint({
-      method: "POST",
-      path: "/meal-plans/join-requests/:requestId/reject",
-      pathParams: mealPlanJoinRequestIdParam,
-      response: NoContentSchema
-    }),
-    vote: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/stages/:stageId/votes",
-      pathParams: mealPlanDecisionStageIdParam,
-      body: CreateMealPlanVoteRequestSchema,
-      response: MealPlanResponseSchema
-    }),
-    completeStage: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/stages/:stageId/complete",
-      pathParams: mealPlanDecisionStageIdParam,
-      body: CompleteMealPlanDecisionStageRequestSchema,
-      response: MealPlanResponseSchema
-    }),
-    decisionProgress: endpoint({
-      method: "GET",
-      path: "/meal-plans/:mealPlanId/decision-progress",
-      pathParams: mealPlanIdParam,
-      response: MealPlanDecisionProgressSchema
-    }),
-    readyDecisionTask: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/decision-tasks/:taskKey/ready",
-      pathParams: mealPlanDecisionTaskKeyParam,
-      body: MealPlanDecisionTaskReadyRequestSchema,
-      response: MealPlanResponseSchema
-    }),
-    reopenDecisionTask: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/decision-tasks/:taskKey/reopen",
-      pathParams: mealPlanDecisionTaskKeyParam,
-      body: ReopenMealPlanDecisionTaskRequestSchema,
-      response: MealPlanResponseSchema
-    }),
-    confirmDecisionSnapshot: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/decision-snapshots/:snapshotId/confirm",
-      pathParams: mealPlanDecisionSnapshotIdParam,
-      body: ConfirmMealPlanDecisionSnapshotRequestSchema,
-      response: MealPlanResponseSchema
-    }),
-    ready: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/ready",
-      pathParams: mealPlanIdParam,
-      response: MealPlanResponseSchema
-    }),
-    unready: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/unready",
-      pathParams: mealPlanIdParam,
-      response: MealPlanResponseSchema
-    }),
-    createChangeRequest: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/change-requests",
-      pathParams: mealPlanIdParam,
-      body: CreateMealPlanChangeRequestSchema,
-      response: CreatedEntityIdResponseSchema
-    }),
-    acceptChangeRequest: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/change-requests/:requestId/accept",
-      pathParams: mealPlanChangeRequestIdParam,
-      response: MealPlanResponseSchema
-    }),
-    confirm: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/confirm",
-      pathParams: mealPlanIdParam,
-      response: MealPlanResponseSchema
-    })
+    create: endpoint({ method: "POST", path: "/meal-plans", body: CreateMealPlanRequestSchema, response: CreateMealPlanResponseSchema }),
+    my: endpoint({ method: "GET", path: "/meal-plans/me", response: MyMealPlanListResponseSchema }),
+    homeDashboard: endpoint({ method: "GET", path: "/meal-plans/home-dashboard", response: HomeMealPlanDashboardResponseSchema }),
+    map: endpoint({ method: "GET", path: "/meal-plans/map", query: MealMapQuerySchema, response: MealMapResponseSchema }),
+    detail: endpoint({ method: "GET", path: "/meal-plans/:mealPlanId", pathParams: mealPlanIdParam, response: MealPlanResponseSchema }),
+    chatMessages: endpoint({ method: "GET", path: "/meal-plans/:mealPlanId/chat/messages", pathParams: mealPlanIdParam, response: MealPlanChatMessageListResponseSchema }),
+    updateContext: endpoint({ method: "PATCH", path: "/meal-plans/:mealPlanId/context", pathParams: mealPlanIdParam, body: UpdateMealPlanContextRequestSchema, response: MealPlanResponseSchema }),
+    complete: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/complete", pathParams: mealPlanIdParam, response: MealPlanResponseSchema }),
+    cancel: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/cancel", pathParams: mealPlanIdParam, response: MealPlanResponseSchema }),
+    removeParticipant: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/participants/:participantId/remove", pathParams: mealPlanParticipantIdParam, response: MealPlanResponseSchema }),
+    recorded: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/recorded", pathParams: mealPlanIdParam, response: MealPlanResponseSchema }),
+    invite: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/invites", pathParams: mealPlanIdParam, body: CreateMealPlanInviteRequestSchema, response: SendMealPlanInviteResponseSchema }),
+    receivedInvites: endpoint({ method: "GET", path: "/meal-plans/invites/received", response: MealPlanInviteListResponseSchema }),
+    sentInvites: endpoint({ method: "GET", path: "/meal-plans/invites/sent", response: MealPlanInviteListResponseSchema }),
+    acceptInvite: endpoint({ method: "POST", path: "/meal-plans/invites/:inviteId/accept", pathParams: mealPlanInviteIdParam, response: MealPlanResponseSchema }),
+    declineInvite: endpoint({ method: "POST", path: "/meal-plans/invites/:inviteId/decline", pathParams: mealPlanInviteIdParam, response: NoContentSchema }),
+    createShareLink: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/share-links", pathParams: mealPlanIdParam, body: CreateMealPlanShareLinkRequestSchema, response: MealPlanShareLinkSummarySchema }),
+    sharePreview: endpoint({ method: "GET", path: "/meal-plan-links/:token", pathParams: mealPlanShareTokenParam, response: MealPlanSharePreviewResponseSchema }),
+    joinGuest: endpoint({ method: "POST", path: "/meal-plan-links/:token/join", pathParams: mealPlanShareTokenParam, body: JoinMealPlanGuestRequestSchema, response: JoinMealPlanGuestResponseSchema }),
+    guestSession: endpoint({ method: "GET", path: "/meal-plan-links/:token/session", pathParams: mealPlanShareTokenParam, query: MealPlanGuestSessionQuerySchema, response: MealPlanGuestSessionResponseSchema }),
+    guestChatMessages: endpoint({ method: "GET", path: "/meal-plan-links/:token/chat/messages", pathParams: mealPlanShareTokenParam, query: MealPlanGuestSessionQuerySchema, response: MealPlanChatMessageListResponseSchema }),
+    exposeNearbyFriends: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/nearby-friends/expose", pathParams: mealPlanIdParam, body: ExposeMealPlanToNearbyFriendsRequestSchema, response: ExposeMealPlanToNearbyFriendsResponseSchema }),
+    closeNearbyFriends: endpoint({ method: "DELETE", path: "/meal-plans/:mealPlanId/nearby-friends/expose", pathParams: mealPlanIdParam, response: NoContentSchema }),
+    nearbyFriendExposureEligibility: endpoint({ method: "GET", path: "/meal-plans/nearby-friends/eligibility", response: NearbyFriendExposureEligibilitySchema }),
+    nearbyFriends: endpoint({ method: "GET", path: "/meal-plans/nearby-friends", response: import_zod30.z.array(NearbyFriendMealPlanSummarySchema) }),
+    requestJoin: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/join-requests", pathParams: mealPlanIdParam, body: CreateMealPlanJoinRequestSchema, response: CreatedEntityIdResponseSchema }),
+    acceptJoinRequest: endpoint({ method: "POST", path: "/meal-plans/join-requests/:requestId/accept", pathParams: mealPlanJoinRequestIdParam, response: MealPlanResponseSchema }),
+    rejectJoinRequest: endpoint({ method: "POST", path: "/meal-plans/join-requests/:requestId/reject", pathParams: mealPlanJoinRequestIdParam, response: NoContentSchema }),
+    completeStage: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/stages/:stageId/complete", pathParams: mealPlanDecisionStageIdParam, body: CompleteMealPlanDecisionStageRequestSchema, response: MealPlanResponseSchema }),
+    decisionProgress: endpoint({ method: "GET", path: "/meal-plans/:mealPlanId/decision-progress", pathParams: mealPlanIdParam, response: MealPlanDecisionProgressSchema }),
+    reopenDecisionTask: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/decision-tasks/:taskKey/reopen", pathParams: mealPlanDecisionTaskKeyParam, body: ReopenMealPlanDecisionTaskRequestSchema, response: MealPlanResponseSchema }),
+    confirmDecisionSnapshot: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/decision-snapshots/:snapshotId/confirm", pathParams: mealPlanDecisionSnapshotIdParam, body: ConfirmMealPlanDecisionSnapshotRequestSchema, response: MealPlanResponseSchema }),
+    ready: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/ready", pathParams: mealPlanIdParam, response: MealPlanResponseSchema }),
+    unready: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/unready", pathParams: mealPlanIdParam, response: MealPlanResponseSchema }),
+    createChangeRequest: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/change-requests", pathParams: mealPlanIdParam, body: CreateMealPlanChangeRequestSchema, response: CreatedEntityIdResponseSchema }),
+    acceptChangeRequest: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/change-requests/:requestId/accept", pathParams: mealPlanChangeRequestIdParam, response: MealPlanResponseSchema }),
+    confirm: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/confirm", pathParams: mealPlanIdParam, response: MealPlanResponseSchema })
   },
   mealGroups: {
-    create: endpoint({
-      method: "POST",
-      path: "/meal-groups",
-      body: CreateMealGroupRequestSchema,
-      response: MealGroupResponseSchema
-    }),
-    list: endpoint({
-      method: "GET",
-      path: "/meal-groups",
-      response: import_zod28.z.array(MealGroupResponseSchema)
-    }),
-    detail: endpoint({
-      method: "GET",
-      path: "/meal-groups/:mealGroupId",
-      pathParams: mealGroupIdParam,
-      response: MealGroupResponseSchema
-    }),
-    startMealPlan: endpoint({
-      method: "POST",
-      path: "/meal-groups/:mealGroupId/meal-plans",
-      pathParams: mealGroupIdParam,
-      body: StartMealPlanFromGroupRequestSchema,
-      response: CreateMealPlanResponseSchema
-    }),
-    history: endpoint({
-      method: "GET",
-      path: "/meal-groups/:mealGroupId/history",
-      pathParams: mealGroupIdParam,
-      response: MealGroupHistoryResponseSchema
-    }),
-    preferences: endpoint({
-      method: "GET",
-      path: "/meal-groups/:mealGroupId/preferences",
-      pathParams: mealGroupIdParam,
-      response: MealGroupPreferenceSummarySchema
-    }),
-    addMember: endpoint({
-      method: "POST",
-      path: "/meal-groups/:mealGroupId/members",
-      pathParams: mealGroupIdParam,
-      body: AddMealGroupMemberRequestSchema,
-      response: MealGroupResponseSchema
-    }),
-    updateMemberRole: endpoint({
-      method: "PATCH",
-      path: "/meal-groups/:mealGroupId/members/:memberId/role",
-      pathParams: mealGroupMemberIdParam,
-      body: UpdateMealGroupMemberRoleRequestSchema,
-      response: MealGroupResponseSchema
-    }),
-    removeMember: endpoint({
-      method: "DELETE",
-      path: "/meal-groups/:mealGroupId/members/:memberId",
-      pathParams: mealGroupMemberIdParam,
-      response: MealGroupResponseSchema
-    })
+    create: endpoint({ method: "POST", path: "/meal-groups", body: CreateMealGroupRequestSchema, response: MealGroupResponseSchema }),
+    list: endpoint({ method: "GET", path: "/meal-groups", response: import_zod30.z.array(MealGroupResponseSchema) }),
+    detail: endpoint({ method: "GET", path: "/meal-groups/:mealGroupId", pathParams: mealGroupIdParam, response: MealGroupResponseSchema }),
+    startMealPlan: endpoint({ method: "POST", path: "/meal-groups/:mealGroupId/meal-plans", pathParams: mealGroupIdParam, body: StartMealPlanFromGroupRequestSchema, response: CreateMealPlanResponseSchema }),
+    history: endpoint({ method: "GET", path: "/meal-groups/:mealGroupId/history", pathParams: mealGroupIdParam, response: MealGroupHistoryResponseSchema }),
+    preferences: endpoint({ method: "GET", path: "/meal-groups/:mealGroupId/preferences", pathParams: mealGroupIdParam, response: MealGroupPreferenceSummarySchema }),
+    addMember: endpoint({ method: "POST", path: "/meal-groups/:mealGroupId/members", pathParams: mealGroupIdParam, body: AddMealGroupMemberRequestSchema, response: MealGroupResponseSchema }),
+    updateMemberRole: endpoint({ method: "PATCH", path: "/meal-groups/:mealGroupId/members/:memberId/role", pathParams: mealGroupMemberIdParam, body: UpdateMealGroupMemberRoleRequestSchema, response: MealGroupResponseSchema }),
+    removeMember: endpoint({ method: "DELETE", path: "/meal-groups/:mealGroupId/members/:memberId", pathParams: mealGroupMemberIdParam, response: MealGroupResponseSchema })
   },
   friends: {
-    list: endpoint({
-      method: "GET",
-      path: "/friends",
-      response: import_zod28.z.array(FriendListItemResponseSchema)
-    }),
-    blockList: endpoint({
-      method: "GET",
-      path: "/friends/blocks",
-      response: import_zod28.z.array(FriendBlockItemResponseSchema)
-    }),
-    search: endpoint({
-      method: "GET",
-      path: "/friends/search",
-      query: MemberSearchQuerySchema,
-      response: MemberSerachResponseSchema
-    }),
-    incomingRequest: endpoint({
-      method: "GET",
-      path: "/friends/requests/incoming",
-      response: import_zod28.z.array(FriendRequestItemResponseSchema)
-    }),
-    outgoingRequest: endpoint({
-      method: "GET",
-      path: "/friends/requests/outgoing",
-      response: import_zod28.z.array(FriendRequestItemResponseSchema)
-    }),
-    sendRequest: endpoint({
-      method: "POST",
-      path: "/friends/requests/:memberId",
-      pathParams: memberIdParam,
-      response: NoContentSchema
-    }),
-    acceptRequest: endpoint({
-      method: "POST",
-      path: "/friends/requests/:requestId/accept",
-      pathParams: friendRequestIdParam,
-      response: NoContentSchema
-    }),
-    rejectRequest: endpoint({
-      method: "POST",
-      path: "/friends/requests/:requestId/reject",
-      pathParams: friendRequestIdParam,
-      response: NoContentSchema
-    }),
-    block: endpoint({
-      method: "POST",
-      path: "/friends/blocks/:memberId",
-      pathParams: memberIdParam,
-      response: NoContentSchema
-    }),
-    cancelRequest: endpoint({
-      method: "DELETE",
-      path: "/friends/requests/:requestId",
-      pathParams: friendRequestIdParam,
-      response: NoContentSchema
-    }),
-    unblock: endpoint({
-      method: "DELETE",
-      path: "/friends/blocks/:memberId",
-      pathParams: memberIdParam,
-      response: NoContentSchema
-    }),
-    unfriend: endpoint({
-      method: "DELETE",
-      path: "/friends/:memberId",
-      pathParams: memberIdParam,
-      response: NoContentSchema
-    })
+    list: endpoint({ method: "GET", path: "/friends", response: import_zod30.z.array(FriendListItemResponseSchema) }),
+    blockList: endpoint({ method: "GET", path: "/friends/blocks", response: import_zod30.z.array(FriendBlockItemResponseSchema) }),
+    search: endpoint({ method: "GET", path: "/friends/search", query: MemberSearchQuerySchema, response: MemberSerachResponseSchema }),
+    incomingRequest: endpoint({ method: "GET", path: "/friends/requests/incoming", response: import_zod30.z.array(FriendRequestItemResponseSchema) }),
+    outgoingRequest: endpoint({ method: "GET", path: "/friends/requests/outgoing", response: import_zod30.z.array(FriendRequestItemResponseSchema) }),
+    sendRequest: endpoint({ method: "POST", path: "/friends/requests/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
+    acceptRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/accept", pathParams: friendRequestIdParam, response: NoContentSchema }),
+    rejectRequest: endpoint({ method: "POST", path: "/friends/requests/:requestId/reject", pathParams: friendRequestIdParam, response: NoContentSchema }),
+    block: endpoint({ method: "POST", path: "/friends/blocks/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
+    cancelRequest: endpoint({ method: "DELETE", path: "/friends/requests/:requestId", pathParams: friendRequestIdParam, response: NoContentSchema }),
+    unblock: endpoint({ method: "DELETE", path: "/friends/blocks/:memberId", pathParams: memberIdParam, response: NoContentSchema }),
+    unfriend: endpoint({ method: "DELETE", path: "/friends/:memberId", pathParams: memberIdParam, response: NoContentSchema })
   },
   coupons: {
-    list: endpoint({
-      method: "GET",
-      path: "/coupons",
-      response: import_zod28.z.array(CouponResponseSchema)
-    }),
-    use: endpoint({
-      method: "POST",
-      path: "/coupons/:couponId/use",
-      pathParams: couponIdParam,
-      response: NoContentSchema
-    })
+    list: endpoint({ method: "GET", path: "/coupons", response: import_zod30.z.array(CouponResponseSchema) }),
+    use: endpoint({ method: "POST", path: "/coupons/:couponId/use", pathParams: couponIdParam, response: NoContentSchema })
   },
   challenges: {
-    status: endpoint({
-      method: "GET",
-      path: "/challenges/status",
-      response: ChallengeStatusResponseSchema
-    }),
-    claimReward: endpoint({
-      method: "POST",
-      path: "/challenges/rewards",
-      body: ClaimChallengeRewardRequestSchema,
-      response: NoContentSchema
-    })
+    status: endpoint({ method: "GET", path: "/challenges/status", response: ChallengeStatusResponseSchema }),
+    claimReward: endpoint({ method: "POST", path: "/challenges/rewards", body: ClaimChallengeRewardRequestSchema, response: NoContentSchema })
   },
   referrals: {
-    list: endpoint({
-      method: "GET",
-      path: "/referrals",
-      response: import_zod28.z.array(ReferralItemResponseSchema)
-    }),
-    create: endpoint({
-      method: "POST",
-      path: "/referrals",
-      response: ReferralCreateResponseSchema
-    }),
-    redeem: endpoint({
-      method: "POST",
-      path: "/referrals/redeem",
-      body: RedeemReferralRequestSchema,
-      response: NoContentSchema
-    })
+    list: endpoint({ method: "GET", path: "/referrals", response: import_zod30.z.array(ReferralItemResponseSchema) }),
+    create: endpoint({ method: "POST", path: "/referrals", response: ReferralCreateResponseSchema }),
+    redeem: endpoint({ method: "POST", path: "/referrals/redeem", body: RedeemReferralRequestSchema, response: NoContentSchema })
   },
   notifications: {
-    list: endpoint({
-      method: "GET",
-      path: "/notifications",
-      response: import_zod28.z.array(MealPlanNotificationSchema)
-    }),
-    markRead: endpoint({
-      method: "PATCH",
-      path: "/notifications/:notificationId/read",
-      pathParams: notificationIdParam,
-      response: MealPlanNotificationSchema
-    }),
-    delete: endpoint({
-      method: "DELETE",
-      path: "/notifications/:notificationId",
-      pathParams: notificationIdParam,
-      response: NoContentSchema
-    })
+    list: endpoint({ method: "GET", path: "/notifications", response: import_zod30.z.array(MealPlanNotificationSchema) }),
+    markRead: endpoint({ method: "PATCH", path: "/notifications/:notificationId/read", pathParams: notificationIdParam, response: MealPlanNotificationSchema }),
+    delete: endpoint({ method: "DELETE", path: "/notifications/:notificationId", pathParams: notificationIdParam, response: NoContentSchema })
   },
   pushTokens: {
-    list: endpoint({
-      method: "GET",
-      path: "/push-tokens",
-      response: import_zod28.z.array(PushTokenResponseSchema)
-    }),
-    register: endpoint({
-      method: "POST",
-      path: "/push-tokens",
-      body: RegisterPushTokenRequestSchema,
-      response: PushTokenResponseSchema
-    }),
-    revoke: endpoint({
-      method: "POST",
-      path: "/push-tokens/revoke",
-      body: RevokePushTokenRequestSchema,
-      response: NoContentSchema
-    })
+    list: endpoint({ method: "GET", path: "/push-tokens", response: import_zod30.z.array(PushTokenResponseSchema) }),
+    register: endpoint({ method: "POST", path: "/push-tokens", body: RegisterPushTokenRequestSchema, response: PushTokenResponseSchema }),
+    revoke: endpoint({ method: "POST", path: "/push-tokens/revoke", body: RevokePushTokenRequestSchema, response: NoContentSchema })
   },
   liveActivities: {
-    listMealPlanSessions: endpoint({
-      method: "GET",
-      path: "/meal-plans/:mealPlanId/live-activity",
-      pathParams: mealPlanIdParam,
-      response: MealPlanLiveActivitySessionListResponseSchema
-    }),
-    registerMealPlanSession: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/live-activity/sessions",
-      pathParams: mealPlanIdParam,
-      body: RegisterMealPlanLiveActivitySessionRequestSchema,
-      response: MealPlanLiveActivitySessionResponseSchema
-    }),
-    endMealPlanSessions: endpoint({
-      method: "POST",
-      path: "/meal-plans/:mealPlanId/live-activity/end",
-      pathParams: mealPlanIdParam,
-      body: EndMealPlanLiveActivitySessionRequestSchema,
-      response: NoContentSchema
-    })
+    listMealPlanSessions: endpoint({ method: "GET", path: "/meal-plans/:mealPlanId/live-activity", pathParams: mealPlanIdParam, response: MealPlanLiveActivitySessionListResponseSchema }),
+    registerMealPlanSession: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/live-activity/sessions", pathParams: mealPlanIdParam, body: RegisterMealPlanLiveActivitySessionRequestSchema, response: MealPlanLiveActivitySessionResponseSchema }),
+    endMealPlanSessions: endpoint({ method: "POST", path: "/meal-plans/:mealPlanId/live-activity/end", pathParams: mealPlanIdParam, body: EndMealPlanLiveActivitySessionRequestSchema, response: NoContentSchema })
   },
   sse: {
-    notifications: endpoint({
-      method: "GET",
-      path: "/sse/notifications",
-      query: sseTokenQuery,
-      response: import_zod28.z.any()
-    })
+    notifications: endpoint({ method: "GET", path: "/sse/notifications", query: sseTokenQuery, response: import_zod30.z.any() })
   },
   health: {
-    healthCheck: endpoint({
-      method: "GET",
-      path: "/",
-      response: import_zod28.z.string()
-    })
+    healthCheck: endpoint({ method: "GET", path: "/", response: import_zod30.z.string() })
   }
 };
 
@@ -2838,166 +2266,29 @@ var makeApiResponseSchema = ApiResponseSchema;
 var makeApiSuccessSchema = ApiSuccessSchema;
 
 // src/domain/common/contracts/id.ts
-var toMemberId = /* @__PURE__ */ __name((value) => MemberIdSchema.parse(value), "toMemberId");
-var toArticleId = /* @__PURE__ */ __name((value) => ArticleIdSchema.parse(value), "toArticleId");
-var toMealPlanId = /* @__PURE__ */ __name((value) => MealPlanIdSchema.parse(value), "toMealPlanId");
-var toMealPlanInviteId = /* @__PURE__ */ __name((value) => MealPlanInviteIdSchema.parse(value), "toMealPlanInviteId");
-var toMealPlanJoinRequestId = /* @__PURE__ */ __name((value) => MealPlanJoinRequestIdSchema.parse(value), "toMealPlanJoinRequestId");
-var toMealPlanNearbyFriendExposureBatchId = /* @__PURE__ */ __name((value) => MealPlanNearbyFriendExposureBatchIdSchema.parse(value), "toMealPlanNearbyFriendExposureBatchId");
-var toMealPlanChangeRequestId = /* @__PURE__ */ __name((value) => MealPlanChangeRequestIdSchema.parse(value), "toMealPlanChangeRequestId");
-var toMealPlanShareLinkId = /* @__PURE__ */ __name((value) => MealPlanShareLinkIdSchema.parse(value), "toMealPlanShareLinkId");
-var toMealPlanShareLinkToken = /* @__PURE__ */ __name((value) => MealPlanShareLinkTokenSchema.parse(value), "toMealPlanShareLinkToken");
-var toMealPlanChatRoomId = /* @__PURE__ */ __name((value) => MealPlanChatRoomIdSchema.parse(value), "toMealPlanChatRoomId");
-var toMealPlanChatMessageId = /* @__PURE__ */ __name((value) => MealPlanChatMessageIdSchema.parse(value), "toMealPlanChatMessageId");
-var toMealGroupId = /* @__PURE__ */ __name((value) => MealGroupIdSchema.parse(value), "toMealGroupId");
-var toRestaurantId = /* @__PURE__ */ __name((value) => RestaurantIdSchema.parse(value), "toRestaurantId");
-var toCommentId = /* @__PURE__ */ __name((value) => CommentIdSchema.parse(value), "toCommentId");
-var toCouponId = /* @__PURE__ */ __name((value) => CouponIdSchema.parse(value), "toCouponId");
-var toSubscriptionId = /* @__PURE__ */ __name((value) => SubscriptionIdSchema.parse(value), "toSubscriptionId");
-var toFriendRequestId = /* @__PURE__ */ __name((value) => FriendRequestIdSchema.parse(value), "toFriendRequestId");
-var toReferralCode = /* @__PURE__ */ __name((value) => ReferralCodeSchema.parse(value), "toReferralCode");
+var toMemberId = (value) => MemberIdSchema.parse(value);
+var toArticleId = (value) => ArticleIdSchema.parse(value);
+var toMealPlanId = (value) => MealPlanIdSchema.parse(value);
+var toMealPlanInviteId = (value) => MealPlanInviteIdSchema.parse(value);
+var toMealPlanJoinRequestId = (value) => MealPlanJoinRequestIdSchema.parse(value);
+var toMealPlanNearbyFriendExposureBatchId = (value) => MealPlanNearbyFriendExposureBatchIdSchema.parse(value);
+var toMealPlanChangeRequestId = (value) => MealPlanChangeRequestIdSchema.parse(value);
+var toMealPlanShareLinkId = (value) => MealPlanShareLinkIdSchema.parse(value);
+var toMealPlanShareLinkToken = (value) => MealPlanShareLinkTokenSchema.parse(value);
+var toMealPlanChatRoomId = (value) => MealPlanChatRoomIdSchema.parse(value);
+var toMealPlanChatMessageId = (value) => MealPlanChatMessageIdSchema.parse(value);
+var toMealGroupId = (value) => MealGroupIdSchema.parse(value);
+var toRestaurantId = (value) => RestaurantIdSchema.parse(value);
+var toCommentId = (value) => CommentIdSchema.parse(value);
+var toCouponId = (value) => CouponIdSchema.parse(value);
+var toSubscriptionId = (value) => SubscriptionIdSchema.parse(value);
+var toFriendRequestId = (value) => FriendRequestIdSchema.parse(value);
+var toReferralCode = (value) => ReferralCodeSchema.parse(value);
 
 // src/domain/food/food.contracts.ts
 var FOOD_CODE_MANIFEST_PATH = "/manifests/food-code-manifest.json";
 var AI_CLASS_TO_FOOD_CODE_MAP_PATH = "/manifests/ai-class-to-food-code-map.json";
 var FOOD_IMAGE_INDEX_PATH = "/manifests/food-image-index.json";
-
-// src/domain/food/food.schema.ts
-var import_zod29 = require("zod");
-var FoodGranularitySchema = import_zod29.z.enum([
-  "main_dish",
-  "side_dish",
-  "beverage",
-  "sauce"
-]);
-var CuisineTagSchema = import_zod29.z.enum([
-  "korean",
-  "western",
-  "chinese",
-  "japanese",
-  "mexican",
-  "indian",
-  "asian",
-  "snack",
-  "dessert",
-  "beverage",
-  "unknown"
-]);
-var FoodResolvedMatchSourceSchema = import_zod29.z.enum([
-  "category",
-  "alias",
-  "lexical",
-  "semantic"
-]);
-var FoodCodeManifestImageSchema = import_zod29.z.object({
-  src: import_zod29.z.string().min(1),
-  avifSrcset: import_zod29.z.string().min(1).optional(),
-  thumbhashDataURL: import_zod29.z.string().min(1).optional(),
-  aspectRatio: import_zod29.z.number().positive().optional()
-});
-var FoodCodeManifestItemSchema = import_zod29.z.object({
-  code: FoodCodeSchema,
-  label: FoodLabelSchema,
-  aliases: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
-  parentCategory: import_zod29.z.string().min(1),
-  cuisineTags: import_zod29.z.array(CuisineTagSchema).default([]),
-  categoryTags: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
-  semanticTags: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
-  granularity: FoodGranularitySchema,
-  searchable: import_zod29.z.boolean(),
-  recommendable: import_zod29.z.boolean(),
-  previewEnabled: import_zod29.z.boolean(),
-  imageUrl: import_zod29.z.string().min(1).nullable().optional(),
-  image: FoodCodeManifestImageSchema.nullable().optional(),
-  popularity: import_zod29.z.number().nonnegative().optional(),
-  source: import_zod29.z.enum([
-    "foodname",
-    "manual",
-    "foodai",
-    "legacy"
-  ]).optional()
-});
-var FoodCodeManifestSchema = import_zod29.z.object({
-  version: import_zod29.z.string().min(1),
-  updatedAt: ISODateTimeStringSchema,
-  taxonomyVersion: import_zod29.z.string().min(1),
-  etag: import_zod29.z.string().min(1).optional(),
-  items: import_zod29.z.array(FoodCodeManifestItemSchema),
-  categoryIndex: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.array(FoodCodeSchema)),
-  aliasIndex: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.array(FoodCodeSchema)).optional()
-});
-var FoodImageIndexItemSchema = import_zod29.z.object({
-  code: FoodCodeSchema,
-  label: FoodLabelSchema,
-  imageUrl: import_zod29.z.string().min(1).nullable(),
-  image: FoodCodeManifestImageSchema.nullable(),
-  source: import_zod29.z.enum([
-    "foodname",
-    "manual",
-    "foodai",
-    "legacy"
-  ]).optional()
-});
-var FoodImageIndexManifestSchema = import_zod29.z.object({
-  version: import_zod29.z.string().min(1),
-  updatedAt: ISODateTimeStringSchema,
-  taxonomyVersion: import_zod29.z.string().min(1),
-  items: import_zod29.z.array(FoodImageIndexItemSchema)
-});
-var ResolvedFoodCodeSchema = import_zod29.z.object({
-  code: FoodCodeSchema,
-  label: FoodLabelSchema,
-  matchedBy: FoodResolvedMatchSourceSchema,
-  score: import_zod29.z.number(),
-  granularity: FoodGranularitySchema,
-  imageUrl: import_zod29.z.string().min(1).nullable().optional()
-});
-var BooleanQuerySchema = import_zod29.z.preprocess((value) => {
-  if (value === "true") return true;
-  if (value === "false") return false;
-  return value;
-}, import_zod29.z.boolean());
-var FoodResolveQuerySchema = import_zod29.z.object({
-  q: import_zod29.z.string().default(""),
-  limit: import_zod29.z.coerce.number().int().min(1).max(100).optional().default(30),
-  recommendableOnly: BooleanQuerySchema.optional().default(true)
-});
-var FoodSearchQuerySchema = import_zod29.z.object({
-  q: import_zod29.z.string().default(""),
-  limit: import_zod29.z.coerce.number().int().min(1).max(100).optional().default(20)
-});
-var FoodResolveResponseSchema = import_zod29.z.object({
-  query: import_zod29.z.string(),
-  items: import_zod29.z.array(ResolvedFoodCodeSchema)
-});
-var FoodSearchResponseSchema = FoodResolveResponseSchema;
-var FoodAiClassMappingStatusSchema = import_zod29.z.enum([
-  "exact",
-  "broad",
-  "narrow",
-  "merged",
-  "ignored",
-  "review_required"
-]);
-var AiClassFoodCodeMappingSchema = import_zod29.z.object({
-  classId: import_zod29.z.number().int().nonnegative(),
-  aiLabel: import_zod29.z.string().min(1),
-  aiAliases: import_zod29.z.array(import_zod29.z.string().min(1)).default([]),
-  representativeCode: FoodCodeSchema.nullable(),
-  candidateCodes: import_zod29.z.array(FoodCodeSchema).default([]),
-  mappingStatus: FoodAiClassMappingStatusSchema,
-  granularity: FoodGranularitySchema,
-  searchable: import_zod29.z.boolean(),
-  recommendable: import_zod29.z.boolean(),
-  reason: import_zod29.z.string().min(1).optional()
-});
-var AiClassToFoodCodeMapManifestSchema = import_zod29.z.object({
-  version: import_zod29.z.string().min(1),
-  updatedAt: ISODateTimeStringSchema,
-  modelTaxonomyVersion: import_zod29.z.string().min(1),
-  serviceTaxonomyVersion: import_zod29.z.string().min(1),
-  classes: import_zod29.z.array(AiClassFoodCodeMappingSchema)
-});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   domain