@kimdaegyu/babmukdang-shared 1.1.11 → 2.0.3

package/dist/domain/common/index.cjs

@@ -34,6 +34,11 @@ __export(common_exports, {
   ApiResponseSchema: () => ApiResponseSchema,
   ApiSuccessSchema: () => ApiSuccessSchema,
   ArticleIdSchema: () => ArticleIdSchema,
+  CACHE_INVALIDATION_SSE_EVENT: () => CACHE_INVALIDATION_SSE_EVENT,
+  CacheInvalidationActionSchema: () => CacheInvalidationActionSchema,
+  CacheInvalidationEntitySchema: () => CacheInvalidationEntitySchema,
+  CacheInvalidationEventSchema: () => CacheInvalidationEventSchema,
+  CacheInvalidationKeySchema: () => CacheInvalidationKeySchema,
   CommentIdSchema: () => CommentIdSchema,
   CouponIdSchema: () => CouponIdSchema,
   CreatedEntityIdResponseSchema: () => CreatedEntityIdResponseSchema,
@@ -43,7 +48,16 @@ __export(common_exports, {
   FriendRequestIdSchema: () => FriendRequestIdSchema,
   ISODateStringSchema: () => ISODateStringSchema,
   ISODateTimeStringSchema: () => ISODateTimeStringSchema,
-  InvitationIdSchema: () => InvitationIdSchema,
+  MealGroupIdSchema: () => MealGroupIdSchema,
+  MealPlanChangeRequestIdSchema: () => MealPlanChangeRequestIdSchema,
+  MealPlanChatMessageIdSchema: () => MealPlanChatMessageIdSchema,
+  MealPlanChatRoomIdSchema: () => MealPlanChatRoomIdSchema,
+  MealPlanIdSchema: () => MealPlanIdSchema,
+  MealPlanInviteIdSchema: () => MealPlanInviteIdSchema,
+  MealPlanJoinRequestIdSchema: () => MealPlanJoinRequestIdSchema,
+  MealPlanNearbyFriendExposureBatchIdSchema: () => MealPlanNearbyFriendExposureBatchIdSchema,
+  MealPlanShareLinkIdSchema: () => MealPlanShareLinkIdSchema,
+  MealPlanShareLinkTokenSchema: () => MealPlanShareLinkTokenSchema,
   MemberIdSchema: () => MemberIdSchema,
   NoBodySchema: () => NoBodySchema,
   NoContentSchema: () => NoContentSchema,
@@ -53,12 +67,9 @@ __export(common_exports, {
   PageMetaSchema: () => PageMetaSchema,
   PageQuerySchema: () => PageQuerySchema,
   PageResponseSchema: () => PageResponseSchema,
-  PlanIdSchema: () => PlanIdSchema,
   PositiveIntIdSchema: () => PositiveIntIdSchema,
-  RecruitIdSchema: () => RecruitIdSchema,
   ReferralCodeSchema: () => ReferralCodeSchema,
   RestaurantIdSchema: () => RestaurantIdSchema,
-  RoomIdSchema: () => RoomIdSchema,
   SortDirectionSchema: () => SortDirectionSchema,
   SubscriptionIdSchema: () => SubscriptionIdSchema,
   TimeHHmmStringSchema: () => TimeHHmmStringSchema,
@@ -71,19 +82,25 @@ __export(common_exports, {
   toCommentId: () => toCommentId,
   toCouponId: () => toCouponId,
   toFriendRequestId: () => toFriendRequestId,
-  toInvitationId: () => toInvitationId,
+  toMealGroupId: () => toMealGroupId,
+  toMealPlanChangeRequestId: () => toMealPlanChangeRequestId,
+  toMealPlanChatMessageId: () => toMealPlanChatMessageId,
+  toMealPlanChatRoomId: () => toMealPlanChatRoomId,
+  toMealPlanId: () => toMealPlanId,
+  toMealPlanInviteId: () => toMealPlanInviteId,
+  toMealPlanJoinRequestId: () => toMealPlanJoinRequestId,
+  toMealPlanNearbyFriendExposureBatchId: () => toMealPlanNearbyFriendExposureBatchId,
+  toMealPlanShareLinkId: () => toMealPlanShareLinkId,
+  toMealPlanShareLinkToken: () => toMealPlanShareLinkToken,
   toMemberId: () => toMemberId,
-  toPlanId: () => toPlanId,
-  toRecruitId: () => toRecruitId,
   toReferralCode: () => toReferralCode,
   toRestaurantId: () => toRestaurantId,
-  toRoomId: () => toRoomId,
   toSubscriptionId: () => toSubscriptionId
 });
 module.exports = __toCommonJS(common_exports);
 
 // src/domain/common/contracts/api.ts
-var import_zod20 = require("zod");
+var import_zod29 = require("zod");
 
 // src/domain/article/article.schema.ts
 var import_zod7 = require("zod");
@@ -103,10 +120,16 @@ var MemberIdSchema = PositiveIntIdSchema.brand();
 var UserIdSchema = MemberIdSchema;
 var ArticleIdSchema = PositiveIntIdSchema.brand();
 var CommentIdSchema = PositiveIntIdSchema.brand();
-var RecruitIdSchema = PositiveIntIdSchema.brand();
-var PlanIdSchema = PositiveIntIdSchema.brand();
-var InvitationIdSchema = PositiveIntIdSchema.brand();
-var RoomIdSchema = NonEmptyStringIdSchema.brand();
+var MealPlanIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanInviteIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanJoinRequestIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanNearbyFriendExposureBatchIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanChangeRequestIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanShareLinkIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanShareLinkTokenSchema = import_zod2.z.string().min(8).max(128).brand();
+var MealPlanChatRoomIdSchema = import_zod2.z.string().uuid().brand();
+var MealPlanChatMessageIdSchema = import_zod2.z.string().uuid().brand();
+var MealGroupIdSchema = import_zod2.z.string().uuid().brand();
 var RestaurantIdSchema = NonEmptyStringIdSchema.brand();
 var CouponIdSchema = PositiveIntIdSchema.brand();
 var SubscriptionIdSchema = PositiveIntIdSchema.brand();
@@ -155,6 +178,46 @@ 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 PermissionStatusSchema = import_zod5.z.enum([
+  "UNKNOWN",
+  "PROMPT",
+  "GRANTED",
+  "DENIED",
+  "LIMITED",
+  "UNSUPPORTED"
+]);
+var PermissionPlatformSchema = import_zod5.z.enum(["WEB", "IOS", "ANDROID", "UNKNOWN"]);
+var DevicePermissionSnapshotSchema = import_zod5.z.object({
+  kind: PermissionKindSchema,
+  status: PermissionStatusSchema,
+  platform: PermissionPlatformSchema.default("UNKNOWN"),
+  canAskAgain: import_zod5.z.boolean().optional(),
+  checkedAt: import_zod5.z.string().datetime()
+});
+var MemberLocationSchema = import_zod5.z.object({
+  latitude: import_zod5.z.number().min(-90).max(90),
+  longitude: import_zod5.z.number().min(-180).max(180),
+  accuracyMeters: import_zod5.z.number().min(0).nullable().optional(),
+  capturedAt: import_zod5.z.string().datetime()
+});
+var UpdateMemberLocationRequestSchema = MemberLocationSchema;
+var UpdateMemberLocationConsentRequestSchema = import_zod5.z.object({
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean().default(false),
+  mealSuggestionAllowed: import_zod5.z.boolean().optional(),
+  permissionSnapshot: DevicePermissionSnapshotSchema.optional()
+});
+var MemberLocationSettingsResponseSchema = import_zod5.z.object({
+  locationConsentStatus: LocationConsentStatusSchema,
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean(),
+  mealSuggestionAllowed: import_zod5.z.boolean(),
+  lastKnownLocation: MemberLocationSchema.nullable(),
+  permissionSnapshot: DevicePermissionSnapshotSchema.nullable().optional(),
+  updatedAt: import_zod5.z.string().datetime().nullable()
+});
 var MemberCoreSchema = import_zod5.z.object({
   memberId: MemberIdSchema,
   username: import_zod5.z.string().min(1).max(50),
@@ -166,6 +229,11 @@ var MemberResponseSchema = MemberCoreSchema.pick({
   memberId: true,
   username: true,
   profileImageUrl: true
+}).extend({
+  onboardingStatus: OnboardingStatusSchema.default("REQUIRED"),
+  onboardingCompletedAt: import_zod5.z.string().datetime().nullable().default(null),
+  locationConsentStatus: LocationConsentStatusSchema.optional(),
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean().optional()
 });
 var MemberSearchQuerySchema = import_zod5.z.object({
   email: import_zod5.z.string().email().optional(),
@@ -176,7 +244,11 @@ var MemberDetailSchema = MemberCoreSchema.extend({
   bio: import_zod5.z.string().nullable(),
   friendConunt: import_zod5.z.number().int().min(0).default(0),
   completedPlans: import_zod5.z.number().int().min(0).default(0),
-  uncompletedPlans: import_zod5.z.number().int().min(0).default(0)
+  uncompletedPlans: import_zod5.z.number().int().min(0).default(0),
+  onboardingStatus: OnboardingStatusSchema.default("REQUIRED"),
+  onboardingCompletedAt: import_zod5.z.string().datetime().nullable().default(null),
+  locationConsentStatus: LocationConsentStatusSchema.default("UNKNOWN"),
+  nearbyMealPlanExposureAllowed: import_zod5.z.boolean().default(false)
 });
 var FoodPreferenceItemSchema = FoodSchema.extend({});
 var MemberFoodPreferenceSchema = import_zod5.z.object({
@@ -191,9 +263,18 @@ var UpdateProfileRequestSchema = import_zod5.z.object({
   bio: import_zod5.z.string().max(500).nullable()
 });
 var UpdatePreferenceRequestSchema = MemberFoodPreferenceSchema;
-var CreateProfileRequestSchema = UpdateProfileRequestSchema.merge(
+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(),
+  bio: import_zod5.z.string().max(500).nullable().optional(),
+  liked: import_zod5.z.array(FoodPreferenceItemSchema).optional(),
+  disliked: import_zod5.z.array(FoodPreferenceItemSchema).optional(),
+  allergy: import_zod5.z.array(FoodPreferenceItemSchema).optional()
+});
+var CreateProfileRequestSchema = CompleteOnboardingRequestSchema;
 
 // src/domain/restaurant/restaurant.schema.ts
 var import_zod6 = require("zod");
@@ -241,7 +322,8 @@ var CreateArticleRequestSchema = import_zod7.z.object({
   mealDate: ISODateStringSchema,
   restaurant: RestaurantSchema,
   taggedMemberIds: import_zod7.z.array(MemberIdSchema).default([]),
-  foodAnalysis: FoodAnalysisResultSchema.optional()
+  foodAnalysis: FoodAnalysisResultSchema.optional(),
+  mealPlanId: MealPlanIdSchema.optional()
 });
 var CreateCommentRequestSchema = import_zod7.z.object({
   content: import_zod7.z.string().min(1).max(500),
@@ -261,6 +343,7 @@ var ArticleCoreSchema = import_zod7.z.object({
   imageUrl: import_zod7.z.string().url(),
   mealDate: ISODateStringSchema,
   restaurant: RestaurantSchema,
+  mealPlanId: MealPlanIdSchema.nullable(),
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
@@ -299,30 +382,55 @@ var SignupResponseSchema = import_zod8.z.object({
   member: MemberCoreSchema
 });
 
-// src/domain/promotion/challenge.schema.ts
+// src/domain/common/schema/cache-invalidation.schema.ts
 var import_zod9 = require("zod");
-var RewardTypeSchema = import_zod9.z.enum(["WEEK", "MONTH"]);
-var WeekProgressSchema = import_zod9.z.object({
-  days: import_zod9.z.array(import_zod9.z.boolean()),
-  completed: import_zod9.z.number().int().min(0),
-  goal: import_zod9.z.number().int().positive()
-});
-var MonthProgressSchema = import_zod9.z.object({
-  count: import_zod9.z.number().int().min(0),
-  goal: import_zod9.z.number().int().positive()
-});
-var ChallengeStatusResponseSchema = import_zod9.z.object({
-  week: WeekProgressSchema,
-  month: MonthProgressSchema,
-  weekRewardAvailable: import_zod9.z.boolean(),
-  monthRewardAvailable: import_zod9.z.boolean()
-});
-var ClaimChallengeRewardRequestSchema = import_zod9.z.object({
-  type: RewardTypeSchema
-});
-var ClaimChallengeRewardResponseSchema = import_zod9.z.object({
-  rewardType: RewardTypeSchema,
-  claimed: import_zod9.z.boolean()
+var CacheInvalidationEntitySchema = import_zod9.z.enum([
+  "article",
+  "mealPlan",
+  "mealPlanInvite",
+  "mealPlanParticipant",
+  "mealPlanDecision",
+  "mealPlanChat",
+  "mealGroup",
+  "notification",
+  "friend"
+]);
+var CacheInvalidationActionSchema = import_zod9.z.enum([
+  "created",
+  "updated",
+  "deleted",
+  "accepted",
+  "rejected",
+  "cancelled",
+  "closed",
+  "joined",
+  "ready",
+  "confirmed",
+  "locked",
+  "completed",
+  "recorded",
+  "read"
+]);
+var CacheInvalidationKeySchema = import_zod9.z.enum([
+  "articles",
+  "mealPlans",
+  "mealPlanDetail",
+  "mealPlanInvites",
+  "mealPlanJoinRequests",
+  "mealPlanNearbyFriends",
+  "mealPlanMessages",
+  "mealGroups",
+  "notifications",
+  "friends",
+  "friendMeals"
+]);
+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(),
+  keys: import_zod9.z.array(CacheInvalidationKeySchema).min(1),
+  occurredAt: import_zod9.z.string().datetime()
 });
 
 // src/domain/common/schema/envelope.schema.ts
@@ -344,18 +452,29 @@ var ApiResponseSchema = (data) => import_zod10.z.union([ApiSuccessSchema(data),
 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("recruit"), id: RecruitIdSchema }),
-  import_zod10.z.object({ entity: import_zod10.z.literal("invitation"), id: InvitationIdSchema }),
   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("plan"), id: PlanIdSchema })
+  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 FriendMealAvailabilitySchema = import_zod11.z.object({
+  isHungry: import_zod11.z.boolean(),
+  mealProposalAllowed: import_zod11.z.boolean(),
+  mealStatusExpiresAt: ISODateTimeStringSchema.nullable(),
+  nearbyMealPlanExposureAllowed: import_zod11.z.boolean()
+});
 var FriendListItemResponseSchema = MemberCoreSchema.extend({
-  friendSince: ISODateTimeStringSchema
+  friendSince: ISODateTimeStringSchema,
+  mealAvailability: FriendMealAvailabilitySchema.optional()
 });
 var FriendBlockItemResponseSchema = MemberCoreSchema.extend({
   blockedAt: ISODateTimeStringSchema
@@ -371,290 +490,1190 @@ var FriendRequestItemResponseSchema = import_zod11.z.object({
 var FriendSearchQuerySchema = import_zod11.z.string().min(1).max(50);
 var FriendSearchResponseSchema = import_zod11.z.array(MemberCoreSchema);
 
-// src/domain/invitation/invitation.schema.ts
-var import_zod12 = require("zod");
-var CreateInvitationRequestSchema = import_zod12.z.object({
-  inviteeId: MemberIdSchema,
-  message: import_zod12.z.string().min(1).max(500)
-});
-var InvitationListItemResponseSchema = import_zod12.z.object({
-  invitationId: InvitationIdSchema,
-  inviterName: import_zod12.z.string(),
-  inviterProfileImageUrl: import_zod12.z.string().url().nullable().optional()
-});
-var SendInvitationResponseSchema = import_zod12.z.object({
-  invitationId: InvitationIdSchema
-});
-var AcceptInvitationResponseSchema = import_zod12.z.object({
-  invitationId: InvitationIdSchema,
-  room: import_zod12.z.object({
-    type: import_zod12.z.literal("invitation"),
-    roomId: RoomIdSchema
-  })
-});
-
 // src/domain/meal/meal.schema.ts
-var import_zod13 = require("zod");
-var MealStatusResponseSchema = import_zod13.z.object({
-  hungry: import_zod13.z.boolean(),
-  label: import_zod13.z.string(),
+var import_zod12 = require("zod");
+var MealStatusResponseSchema = import_zod12.z.object({
+  hungry: import_zod12.z.boolean(),
+  label: import_zod12.z.string(),
   updatedAt: ISODateStringSchema,
-  secondsToAutoOff: import_zod13.z.number().int().min(0)
+  secondsToAutoOff: import_zod12.z.number().int().min(0)
 });
-var MealStatusActionSchema = import_zod13.z.enum(["ARTICLE_UPLOAD", "SET_MANNUALY"]);
-var UpdateMealStatusRequestSchema = import_zod13.z.object({
+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_zod13.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
-var FriendMealQuerySchema = import_zod13.z.object({
+var MealStatusSchema = import_zod12.z.enum(["ALL", "HUNGRY", "NOT_HUNGRY"]);
+var FriendMealQuerySchema = import_zod12.z.object({
   status: MealStatusSchema.optional().default("ALL")
 });
 var FriendMealItemResponseSchema = MemberCoreSchema.extend({
-  hungry: import_zod13.z.boolean(),
-  label: import_zod13.z.string(),
+  hungry: import_zod12.z.boolean(),
+  label: import_zod12.z.string(),
   updatedAt: ISODateStringSchema
 });
 
-// src/domain/plan/plan.schema.ts
-var import_zod15 = require("zod");
+// src/domain/meal-plan/meal-plan.schema.ts
+var import_zod19 = require("zod");
 
-// src/domain/room/schema/room.schema.ts
+// src/domain/meal-plan/meal-plan-decision.schema.ts
 var import_zod14 = require("zod");
-var MenuCodeSchema = FoodCodeSchema;
-var LocationIdSchema = import_zod14.z.string().min(1).brand();
-var MenuSchema = FoodSchema.extend({});
-var LocationCandidateSchema = import_zod14.z.object({
-  locationId: LocationIdSchema,
-  placeName: import_zod14.z.string(),
-  lat: import_zod14.z.number(),
-  lng: import_zod14.z.number(),
-  address: import_zod14.z.string()
-});
-var ParticipantSchema = MemberCoreSchema.extend({
-  ready: import_zod14.z.boolean()
-});
-var RecruitRoomStageSchema = import_zod14.z.enum([
-  "waiting",
-  "location",
-  "location-vote",
-  "exclude-menu",
-  "menu",
-  "restaurant",
-  "finish"
+
+// src/domain/food/food.schema.ts
+var import_zod13 = require("zod");
+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 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_zod14.z.object({
+  locationId: MealPlanLocationCandidateIdSchema,
+  placeName: import_zod14.z.string().min(1),
+  lat: MealPlanLatitudeSchema,
+  lng: MealPlanLongitudeSchema,
+  address: import_zod14.z.string().default(""),
+  source: MealPlanLocationCandidateSourceSchema.default("manual"),
+  createdBy: MemberIdSchema.optional(),
+  createdAt: ISODateTimeStringSchema.optional()
+});
+var MealPlanMenuCandidateSourceSchema = import_zod14.z.enum([
+  "external-recommendation",
+  "prefer-menu",
+  "recent-menu",
+  "fallback",
+  "manual-search"
+]);
+var MealPlanMenuCandidateSchema = import_zod14.z.object({
+  menuCandidateId: MealPlanMenuCandidateIdSchema,
+  menu: FoodSchema,
+  source: MealPlanMenuCandidateSourceSchema,
+  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_zod14.z.enum(["search", "fallback", "manual"]).optional(),
+  createdAt: ISODateTimeStringSchema.optional()
+});
+var MealPlanDecisionStageTypeSchema = import_zod14.z.enum([
+  "DATE",
+  "TIME",
+  "AREA",
+  "MENU",
+  "RESTAURANT",
+  "FINAL_CONFIRMATION"
 ]);
-var RoomTypeSchema = import_zod14.z.enum(["recruit", "invitation"]);
-var InvitationRoomStageSchema = import_zod14.z.enum([
-  "waiting",
+var MealPlanDecisionStageStatusSchema = import_zod14.z.enum([
+  "OPEN",
+  "COMPLETED",
+  "REOPENED"
+]);
+var MealPlanRestaurantSearchStatusSchema = import_zod14.z.enum([
+  "IDLE",
+  "PENDING",
+  "READY",
+  "FAILED",
+  "STALE"
+]);
+var MealPlanRestaurantSearchStateSchema = import_zod14.z.object({
+  searchKey: import_zod14.z.string().min(1).nullable(),
+  status: MealPlanRestaurantSearchStatusSchema,
+  startedAt: ISODateTimeStringSchema.nullable(),
+  completedAt: ISODateTimeStringSchema.nullable(),
+  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_zod14.z.object({
+  restaurantSearch: MealPlanRestaurantSearchStateSchema.optional()
+}).catchall(import_zod14.z.unknown());
+var MealPlanVoteTypeSchema = import_zod14.z.enum([
+  "PICK",
+  "EXCLUDE",
+  "PREFER",
+  "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_zod14.z.object({
+  voteId: MealPlanVoteIdSchema,
+  voterId: MemberIdSchema.nullable(),
+  guestId: import_zod14.z.string().min(1).nullable(),
+  voteType: MealPlanVoteTypeSchema,
+  candidate: MealPlanDecisionCandidateSchema,
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanDecisionStageResponseSchema = import_zod14.z.object({
+  stageId: MealPlanDecisionStageIdSchema,
+  stageType: MealPlanDecisionStageTypeSchema,
+  status: MealPlanDecisionStageStatusSchema,
+  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_zod14.z.object({
+  voteType: MealPlanVoteTypeSchema,
+  candidate: MealPlanDecisionCandidateSchema
+});
+var CompleteMealPlanDecisionStageRequestSchema = import_zod14.z.object({
+  selectedCandidate: MealPlanDecisionCandidateSchema
+});
+var MealPlanChangeRequestStatusSchema = import_zod14.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELLED"
+]);
+var CreateMealPlanChangeRequestSchema = import_zod14.z.object({
+  stageType: MealPlanDecisionStageTypeSchema,
+  reason: import_zod14.z.string().min(1).max(500),
+  proposedCandidate: MealPlanDecisionCandidateSchema.optional()
+});
+var MealPlanChangeRequestSummarySchema = import_zod14.z.object({
+  changeRequestId: MealPlanChangeRequestIdSchema,
+  stageType: MealPlanDecisionStageTypeSchema,
+  status: MealPlanChangeRequestStatusSchema,
+  reason: import_zod14.z.string(),
+  requestedAt: ISODateTimeStringSchema
+});
+var MealPlanDecisionTaskKeySchema = import_zod14.z.enum([
+  "SCHEDULE_DATE",
+  "SCHEDULE_TIME",
+  "LOCATION_CANDIDATE",
+  "LOCATION_VOTE",
+  "EXCLUDE_MENU",
+  "PREFER_MENU",
+  "MENU_PICK",
+  "RESTAURANT_SEARCH",
+  "RESTAURANT_PICK",
+  "FINAL_CONFIRMATION"
+]);
+var MealPlanDecisionTaskStatusSchema = import_zod14.z.enum([
+  "LOCKED",
+  "OPEN",
+  "RESOLVED",
+  "STALE"
+]);
+var MealPlanDecisionFinalFieldSchema = import_zod14.z.enum([
   "date",
   "time",
-  "location",
-  "location-vote",
-  "exclude-menu",
+  "meetingAt",
+  "area",
   "menu",
-  "restaurant",
-  "finish"
-]);
-var ReadyStateRequestSchema = import_zod14.z.object({
-  isReady: import_zod14.z.boolean()
-});
-var ChatMessageRequestSchema = import_zod14.z.object({
-  message: import_zod14.z.string().min(1).max(500)
-});
-var VoteLocationRequestSchema = import_zod14.z.object({ locationId: LocationIdSchema });
-var ExcludeMenuRequestSchema = import_zod14.z.object({ menu: MenuSchema });
-var PickMenuRequestSchema = import_zod14.z.object({ menuCode: MenuCodeSchema });
-var PickRestaurantRequestSchema = import_zod14.z.object({ restaurantId: RestaurantIdSchema });
-var PickTimesRequestSchema = import_zod14.z.object({ times: import_zod14.z.array(import_zod14.z.string().min(1)).min(1) });
-var PickDateRequestSchema = import_zod14.z.object({ dates: import_zod14.z.array(ISODateStringSchema).min(1) });
-var RoomAssignedResponseSchema = import_zod14.z.object({
-  roomId: RoomIdSchema
-});
-var RoomAccessResponseSchema = import_zod14.z.object({
-  roomId: RoomIdSchema,
-  roomType: RoomTypeSchema,
-  stage: import_zod14.z.union([RecruitRoomStageSchema, InvitationRoomStageSchema]),
-  canJoin: import_zod14.z.boolean()
-});
-var MatchingNotificationKindSchema = import_zod14.z.enum(["recruit", "invitation"]);
-var MatchingNotificationSchema = import_zod14.z.object({
-  notificationId: import_zod14.z.string().min(1),
-  kind: MatchingNotificationKindSchema,
-  roomId: RoomIdSchema,
-  roomType: RoomTypeSchema,
-  title: import_zod14.z.string().min(1),
-  message: import_zod14.z.string().min(1),
+  "restaurant"
+]);
+var MealPlanDecisionSnapshotStatusSchema = import_zod14.z.enum([
+  "CANDIDATE",
+  "PROVISIONAL",
+  "FINAL",
+  "STALE"
+]);
+var MealPlanDecisionReasonSchema = import_zod14.z.enum([
+  "COMMON_SCHEDULE",
+  "TOP_VOTED_LOCATION",
+  "TOP_PICKED_MENU",
+  "TOP_PICKED_RESTAURANT",
+  "OWNER_CONFIRMED",
+  "MANUAL_SELECTION"
+]);
+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_zod14.z.unknown(),
+  status: MealPlanDecisionSnapshotStatusSchema,
+  reason: MealPlanDecisionReasonSchema,
+  score: import_zod14.z.number().nullable().default(null),
+  sourceEvent: import_zod14.z.string().min(1),
+  sourceActorType: MealPlanDecisionActorTypeSchema,
+  sourceMemberId: MemberIdSchema.nullable(),
+  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,
-  readAt: ISODateTimeStringSchema.nullable()
+  staleAt: ISODateTimeStringSchema.nullable()
 });
-var RoomSocketErrorSchema = import_zod14.z.object({
-  code: import_zod14.z.string(),
-  message: import_zod14.z.string()
+var MealPlanDecisionTaskProgressSchema = import_zod14.z.object({
+  taskKey: MealPlanDecisionTaskKeySchema,
+  status: MealPlanDecisionTaskStatusSchema,
+  blockers: import_zod14.z.array(import_zod14.z.string()).default([]),
+  updatedAt: ISODateTimeStringSchema
 });
-var ChatMessageResponseSchema = import_zod14.z.object({
-  messageId: import_zod14.z.string(),
-  user: MemberCoreSchema,
-  message: import_zod14.z.string(),
-  createdAt: ISODateTimeStringSchema
+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 ReadyStateChangedSchema = import_zod14.z.object({
-  readyCount: import_zod14.z.number().int().min(0),
-  participantCount: import_zod14.z.number().int().min(0)
-});
-var FinalStateSchema = import_zod14.z.object({
-  location: LocationCandidateSchema.optional(),
-  excludeMenu: import_zod14.z.array(MenuSchema).optional(),
-  menu: MenuSchema.optional(),
-  restaurant: RestaurantSchema.optional(),
-  time: import_zod14.z.string().optional(),
-  date: ISODateStringSchema.optional()
-});
-var RoomInitialStateSchema = import_zod14.z.object({
-  participants: import_zod14.z.array(ParticipantSchema),
-  chat: import_zod14.z.array(ChatMessageResponseSchema),
-  final: FinalStateSchema
-});
-var TimePicksUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, times: import_zod14.z.array(import_zod14.z.string()) })
-);
-var DatePicksUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, dates: import_zod14.z.array(ISODateStringSchema) })
-);
-var LocationCandidateAddUpdateResponseSchema = import_zod14.z.array(
-  LocationCandidateSchema.extend({ authorMemberId: MemberIdSchema })
-);
-var LocationCandidateVoteUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ locationId: LocationIdSchema, votes: import_zod14.z.array(MemberIdSchema) })
-);
-var ExcludeMenuUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ memberId: MemberIdSchema, exclusions: import_zod14.z.array(MenuSchema) })
-);
-var MenuPickUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ menuCode: MenuCodeSchema, selectedMembers: import_zod14.z.array(MemberIdSchema) })
-);
-var RestaurantPickUpdateResponseSchema = import_zod14.z.array(
-  import_zod14.z.object({ restaurantId: RestaurantIdSchema, selectedMembers: import_zod14.z.array(MemberIdSchema) })
+var ReopenMealPlanDecisionTaskRequestSchema = import_zod14.z.object({
+  reason: import_zod14.z.string().max(500).optional()
+});
+var ConfirmMealPlanDecisionSnapshotRequestSchema = import_zod14.z.object({
+  snapshotId: import_zod14.z.string().uuid()
+});
+
+// src/domain/meal-plan/meal-plan-participant.schema.ts
+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_zod15.z.enum([
+  "INVITED",
+  "REQUESTED",
+  "JOINED",
+  "READY",
+  "DECLINED",
+  "LEFT",
+  "REMOVED"
+]);
+var MealPlanJoinSourceSchema = import_zod15.z.enum([
+  "OWNER",
+  "FRIEND_INVITE",
+  "LINK_GUEST",
+  "NEARBY_FRIENDS"
+]);
+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_zod15.z.object({
+  participantId: MealPlanParticipantIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  member: MemberCoreSchema.nullable(),
+  guest: MealPlanGuestParticipantSchema.nullable(),
+  role: MealPlanParticipantRoleSchema,
+  status: MealPlanParticipantStatusSchema,
+  source: MealPlanJoinSourceSchema,
+  joinedAt: ISODateTimeStringSchema.nullable(),
+  readyAt: ISODateTimeStringSchema.nullable()
+});
+var CreateMealPlanParticipantRequestSchema = import_zod15.z.object({
+  memberId: MemberIdSchema.optional(),
+  guestNickname: import_zod15.z.string().min(1).max(50).optional(),
+  source: MealPlanJoinSourceSchema
+});
+
+// src/domain/meal-plan/meal-plan-invite.schema.ts
+var import_zod16 = require("zod");
+var MealPlanInviteStatusSchema = import_zod16.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "DECLINED",
+  "CANCELLED",
+  "EXPIRED"
+]);
+var CreateMealPlanInviteRequestSchema = import_zod16.z.object({
+  inviteeId: MemberIdSchema,
+  message: import_zod16.z.string().max(500).default("")
+});
+var MealPlanInviteSummarySchema = import_zod16.z.object({
+  inviteId: MealPlanInviteIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  inviter: MemberCoreSchema,
+  invitee: MemberCoreSchema,
+  status: MealPlanInviteStatusSchema,
+  message: import_zod16.z.string().max(500),
+  createdAt: ISODateTimeStringSchema,
+  respondedAt: ISODateTimeStringSchema.nullable()
+});
+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_zod17 = require("zod");
+var MealPlanNearbyFriendExposureIdSchema = import_zod17.z.string().uuid().brand();
+var MealPlanNearbyFriendExposureStatusSchema = import_zod17.z.enum([
+  "OPEN",
+  "CLOSED",
+  "EXPIRED"
+]);
+var MealPlanNearbyFriendExposureNotificationStatusSchema = import_zod17.z.enum([
+  "PENDING",
+  "SENT",
+  "PARTIAL",
+  "FAILED",
+  "SKIPPED"
+]);
+var ExposeMealPlanToNearbyFriendsRequestSchema = import_zod17.z.object({
+  radiusMeters: import_zod17.z.number().int().min(100).max(5e3).default(1e3),
+  expiresAt: ISODateTimeStringSchema.optional()
+});
+var NearbyFriendExposureEligibilitySchema = import_zod17.z.object({
+  canExpose: import_zod17.z.boolean(),
+  locationConsentStatus: LocationConsentStatusSchema,
+  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",
+    "MEAL_SUGGESTION_TOGGLE",
+    "LAST_KNOWN_LOCATION"
+  ]))
+});
+var MealPlanNearbyFriendRejectionReasonSchema = import_zod17.z.enum([
+  "NOT_FRIEND",
+  "BLOCKED",
+  "LOCATION_CONSENT_REQUIRED",
+  "LOCATION_UNAVAILABLE",
+  "OUT_OF_RADIUS",
+  "MEAL_SUGGESTION_DISABLED",
+  "NOT_HUNGRY"
+]);
+var MealPlanNearbyFriendRejectionSummarySchema = import_zod17.z.object({
+  reason: MealPlanNearbyFriendRejectionReasonSchema,
+  count: import_zod17.z.number().int().min(0)
+});
+var ExposeMealPlanToNearbyFriendsResponseSchema = import_zod17.z.object({
+  mealPlanId: MealPlanIdSchema,
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
+  exposedFriendCount: import_zod17.z.number().int().min(0),
+  rejectedFriendCount: import_zod17.z.number().int().min(0),
+  notificationStatus: MealPlanNearbyFriendExposureNotificationStatusSchema,
+  rejectionSummary: import_zod17.z.array(MealPlanNearbyFriendRejectionSummarySchema)
+});
+var MealPlanNearbyFriendExposureSummarySchema = import_zod17.z.object({
+  exposureId: MealPlanNearbyFriendExposureIdSchema,
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema.nullable(),
+  mealPlanId: MealPlanIdSchema,
+  status: MealPlanNearbyFriendExposureStatusSchema,
+  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_zod17.z.object({
+  exposureBatchId: MealPlanNearbyFriendExposureBatchIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  status: MealPlanNearbyFriendExposureStatusSchema,
+  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_zod17.z.enum([
+  "PENDING",
+  "ACCEPTED",
+  "REJECTED",
+  "CANCELLED"
+]);
+var CreateMealPlanJoinRequestSchema = import_zod17.z.object({
+  message: import_zod17.z.string().max(500).default("")
+});
+var MealPlanJoinRequestSummarySchema = import_zod17.z.object({
+  joinRequestId: MealPlanJoinRequestIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  requester: MemberCoreSchema,
+  status: MealPlanJoinRequestStatusSchema,
+  message: import_zod17.z.string().max(500),
+  requestedAt: ISODateTimeStringSchema,
+  respondedAt: ISODateTimeStringSchema.nullable()
+});
+var NearbyFriendMealPlanSummarySchema = import_zod17.z.object({
+  mealPlanId: MealPlanIdSchema,
+  owner: MemberCoreSchema,
+  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_zod18 = require("zod");
+var MealPlanChatMessageKindSchema = import_zod18.z.enum([
+  "USER",
+  "SYSTEM"
+]);
+var MealPlanSystemMessageKindSchema = import_zod18.z.enum([
+  "PARTICIPANT_JOINED",
+  "PARTICIPANT_READY",
+  "PARTICIPANT_REMOVED",
+  "STATUS_CHANGED",
+  "DECISION_UPDATED",
+  "CONFIRMED",
+  "RECORD_NEEDED"
+]);
+var MealPlanChatSystemPayloadSchema = import_zod18.z.object({
+  kind: MealPlanSystemMessageKindSchema
+}).catchall(import_zod18.z.unknown());
+var MealPlanChatMessageListResponseSchema = import_zod18.z.array(
+  import_zod18.z.lazy(() => MealPlanChatMessageResponseSchema)
 );
-var WaitingPhaseDataSchema = import_zod14.z.object({
-  locationInitial: import_zod14.z.string().optional(),
-  meetingAt: ISODateTimeStringSchema.optional()
-});
-var LocationVotePhaseDataSchema = import_zod14.z.object({
-  locations: LocationCandidateAddUpdateResponseSchema,
-  votes: LocationCandidateVoteUpdateResponseSchema
-});
-var ExcludeMenuPhaseDataSchema = import_zod14.z.object({
-  recentMenus: import_zod14.z.array(import_zod14.z.object({ userId: import_zod14.z.string(), menuList: import_zod14.z.array(MenuSchema) })),
-  excludedMenuList: ExcludeMenuUpdateResponseSchema
-});
-var MenuPhaseDataSchema = import_zod14.z.object({
-  initialMenus: import_zod14.z.array(MenuSchema),
-  menuPick: MenuPickUpdateResponseSchema
-});
-var RestaurantPhaseDataSchema = import_zod14.z.object({
-  initialRestaurants: import_zod14.z.array(RestaurantSchema),
-  restaurantUserList: RestaurantPickUpdateResponseSchema
-});
-var PhaseDataBroadcastSchema = import_zod14.z.discriminatedUnion("phase", [
-  import_zod14.z.object({ phase: import_zod14.z.literal("waiting"), data: WaitingPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("date"), data: DatePicksUpdateResponseSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("time"), data: TimePicksUpdateResponseSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("location"), data: WaitingPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("location-vote"), data: LocationVotePhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("exclude-menu"), data: ExcludeMenuPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("menu"), data: MenuPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("restaurant"), data: RestaurantPhaseDataSchema }),
-  import_zod14.z.object({ phase: import_zod14.z.literal("finish"), data: WaitingPhaseDataSchema })
-]);
-
-// src/domain/plan/plan.schema.ts
-var PlanStatusSchema = import_zod15.z.enum(["PLANNING", "COMPLETED"]);
-var PlanTypeSchema = import_zod15.z.enum(["RECRUIT", "INVITATION"]);
-var PlanResponseSchema = import_zod15.z.object({
-  planId: PlanIdSchema,
-  meetingAt: ISODateTimeStringSchema,
-  location: LocationCandidateSchema.nullable(),
-  restaurant: RestaurantSchema.nullable(),
-  author: MemberCoreSchema,
-  participants: import_zod15.z.array(MemberCoreSchema),
-  status: PlanStatusSchema,
-  type: PlanTypeSchema,
+var MealPlanChatRoomSummarySchema = import_zod18.z.object({
+  chatRoomId: MealPlanChatRoomIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  messageCount: import_zod18.z.number().int().min(0),
+  lastMessageAt: ISODateTimeStringSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+var SendMealPlanChatMessageRequestSchema = import_zod18.z.object({
+  message: import_zod18.z.string().min(1).max(500)
+});
+var MealPlanChatMessageResponseSchema = import_zod18.z.object({
+  messageId: MealPlanChatMessageIdSchema,
+  chatRoomId: MealPlanChatRoomIdSchema,
+  sender: MemberCoreSchema.nullable(),
+  guestId: import_zod18.z.string().min(1).nullable(),
+  guestNickname: import_zod18.z.string().min(1).nullable(),
+  kind: MealPlanChatMessageKindSchema,
+  message: import_zod18.z.string().min(1).max(1e3),
+  systemPayload: MealPlanChatSystemPayloadSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanSystemMessageSchema = import_zod18.z.object({
+  kind: MealPlanSystemMessageKindSchema,
+  message: import_zod18.z.string().min(1),
+  createdAt: ISODateTimeStringSchema
+});
+
+// src/domain/meal-plan/meal-plan.schema.ts
+var MealPlanStatusSchema = import_zod19.z.enum([
+  "DRAFT",
+  "RECOMMENDING",
+  "GATHERING",
+  "DECIDING",
+  "READY",
+  "CONFIRMED",
+  "LOCKED",
+  "COMPLETED",
+  "RECORDED",
+  "CANCELLED"
+]);
+var MealPlanChannelSchema = import_zod19.z.enum([
+  "OWNER_ONLY",
+  "FRIEND_INVITE",
+  "LINK_GUEST",
+  "NEARBY_FRIENDS"
+]);
+var MealPlanRecommendationContextSchema = import_zod19.z.object({
+  mealDate: ISODateStringSchema.optional(),
+  mealTime: TimeHHmmStringSchema.optional(),
+  area: MealPlanLocationCandidateSchema.optional(),
+  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_zod19.z.object({
+  mealPlanId: MealPlanIdSchema
+});
+var UpdateMealPlanContextRequestSchema = MealPlanRecommendationContextSchema.partial();
+var MealPlanViewerRoleSchema = import_zod19.z.enum([
+  "OWNER",
+  "FRIEND",
+  "GUEST",
+  "NONE"
+]);
+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_zod19.z.string().nullable(),
+  status: MealPlanStatusSchema,
+  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,
+  selectedDate: ISODateStringSchema.nullable(),
+  selectedTime: TimeHHmmStringSchema.nullable(),
+  selectedArea: MealPlanLocationCandidateSchema.nullable(),
+  selectedRestaurant: RestaurantSchema.nullable(),
+  selectedMenuCategory: import_zod19.z.string().nullable(),
+  chatRoom: MealPlanChatRoomSummarySchema.nullable(),
+  confirmedAt: ISODateTimeStringSchema.nullable(),
+  lockedAt: ISODateTimeStringSchema.nullable(),
+  completedAt: ISODateTimeStringSchema.nullable(),
+  recordedAt: ISODateTimeStringSchema.nullable(),
   createdAt: ISODateTimeStringSchema,
   updatedAt: ISODateTimeStringSchema
 });
-var PlanListQuerySchema = import_zod15.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_zod19.z.string(),
+  status: MealPlanStatusSchema,
+  channels: import_zod19.z.array(MealPlanChannelSchema),
+  participantCount: import_zod19.z.number().int().min(1),
+  selectedDate: ISODateStringSchema.nullable(),
+  selectedTime: TimeHHmmStringSchema.nullable(),
+  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_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_zod19.z.enum([
+  "MEAL_PLAN_INVITE_RECEIVED",
+  "MEAL_PLAN_INVITE_ACCEPTED",
+  "MEAL_PLAN_JOIN_REQUESTED",
+  "MEAL_PLAN_JOIN_REQUEST_ACCEPTED",
+  "MEAL_PLAN_NEARBY_FRIEND_EXPOSED",
+  "MEAL_PLAN_PARTICIPANT_JOINED",
+  "MEAL_PLAN_READY_COMPLETED",
+  "MEAL_PLAN_CONFIRMED",
+  "MEAL_PLAN_LOCKED",
+  "MEAL_PLAN_RECORD_NEEDED"
+]);
+var MealPlanNotificationPriorityChannelSchema = import_zod19.z.enum([
+  "HOME",
+  "NOTIFICATION_INBOX",
+  "FCM_PUSH",
+  "LIVE_ACTIVITY"
+]);
+var MealPlanLiveActivityBehaviorSchema = import_zod19.z.enum([
+  "NONE",
+  "START_OR_UPDATE",
+  "UPDATE",
+  "END"
+]);
+var MealPlanNotificationPriorityPolicyItemSchema = import_zod19.z.object({
+  kind: MealPlanNotificationKindSchema,
+  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_zod19.z.boolean()
+});
+var MealPlanNotificationSchema = import_zod19.z.object({
+  notificationId: import_zod19.z.string().min(1),
+  kind: MealPlanNotificationKindSchema,
+  mealPlanId: MealPlanIdSchema,
+  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/recruit/recruit.schema.ts
-var import_zod16 = require("zod");
-var RecruitStatusSchema = import_zod16.z.enum(["OPEN", "CLOSED", "EXPIRED"]);
-var RecruitParticipantSchema = MemberCoreSchema.extend({});
-var RecruitSortBySchema = import_zod16.z.enum(["createdAt", "deadline", "participantCount"]);
-var RecruitListQuerySchema = PageQuerySchema.extend({
-  sortBy: RecruitSortBySchema.default("createdAt"),
-  direction: SortDirectionSchema.default("desc")
-});
-var RecruitResponseSchema = import_zod16.z.object({
-  targetCount: import_zod16.z.number().int().min(2),
-  meetingAt: ISODateTimeStringSchema,
-  location: import_zod16.z.string().min(1),
-  message: import_zod16.z.string().max(500),
-  recruitId: RecruitIdSchema,
-  status: RecruitStatusSchema,
+// src/domain/meal-plan/meal-plan-share-link.schema.ts
+var import_zod20 = require("zod");
+var CreateMealPlanShareLinkRequestSchema = import_zod20.z.object({
+  expiresAt: ISODateTimeStringSchema.optional(),
+  guestJoinEnabled: import_zod20.z.boolean().default(true)
+});
+var MealPlanShareLinkSummarySchema = import_zod20.z.object({
+  shareLinkId: MealPlanShareLinkIdSchema,
+  mealPlanId: MealPlanIdSchema,
+  token: MealPlanShareLinkTokenSchema,
+  url: import_zod20.z.string().url(),
+  expiresAt: ISODateTimeStringSchema,
+  guestJoinEnabled: import_zod20.z.boolean(),
+  createdAt: ISODateTimeStringSchema
+});
+var MealPlanSharePreviewResponseSchema = import_zod20.z.object({
+  mealPlanId: MealPlanIdSchema,
+  token: MealPlanShareLinkTokenSchema,
+  title: import_zod20.z.string(),
+  ownerName: import_zod20.z.string(),
+  participantCount: import_zod20.z.number().int().min(1),
+  expiresAt: ISODateTimeStringSchema,
+  guestJoinEnabled: import_zod20.z.boolean()
+});
+var JoinMealPlanGuestRequestSchema = import_zod20.z.object({
+  nickname: import_zod20.z.string().min(1).max(50),
+  password: import_zod20.z.string().min(1).max(100).optional()
+});
+var JoinMealPlanGuestResponseSchema = import_zod20.z.object({
+  mealPlanId: MealPlanIdSchema,
+  guestId: import_zod20.z.string().min(1),
+  sessionToken: import_zod20.z.string().min(1)
+});
+var MealPlanGuestSessionQuerySchema = import_zod20.z.object({
+  sessionToken: import_zod20.z.string().min(1)
+});
+var MealPlanGuestSessionResponseSchema = import_zod20.z.object({
+  mealPlan: MealPlanResponseSchema,
+  token: MealPlanShareLinkTokenSchema,
+  guestId: import_zod20.z.string().min(1),
+  nickname: import_zod20.z.string().min(1).max(50),
+  sessionToken: import_zod20.z.string().min(1)
+});
+
+// src/domain/meal-plan/meal-group.schema.ts
+var import_zod21 = require("zod");
+var MealGroupMemberRoleSchema = import_zod21.z.enum([
+  "OWNER",
+  "MEMBER"
+]);
+var MealGroupMemberSchema = import_zod21.z.object({
+  member: MemberCoreSchema,
+  role: MealGroupMemberRoleSchema,
+  joinedAt: ISODateTimeStringSchema
+});
+var MealGroupResponseSchema = import_zod21.z.object({
+  mealGroupId: MealGroupIdSchema,
+  name: import_zod21.z.string().min(1).max(50),
+  owner: MemberCoreSchema,
+  profileImageUrl: import_zod21.z.string().url().nullable(),
+  members: import_zod21.z.array(MealGroupMemberSchema),
+  recentMealPlanIds: import_zod21.z.array(MealPlanIdSchema),
   createdAt: ISODateTimeStringSchema,
-  expiredAt: ISODateTimeStringSchema,
-  updatedAt: ISODateTimeStringSchema,
-  author: MemberCoreSchema,
-  participants: import_zod16.z.array(RecruitParticipantSchema)
+  updatedAt: ISODateTimeStringSchema
 });
-var RecruitListResponseSchema = PageResponseSchema(RecruitResponseSchema);
-var CreateRecruitRequestSchema = import_zod16.z.object({
-  targetCount: import_zod16.z.number().int().min(2),
-  meetingAt: ISODateTimeStringSchema,
-  location: import_zod16.z.string().min(1),
-  message: import_zod16.z.string().max(500)
+var CreateMealGroupRequestSchema = import_zod21.z.object({
+  name: import_zod21.z.string().min(1).max(50),
+  memberIds: import_zod21.z.array(import_zod21.z.number().int().positive()).min(1),
+  profileImageUrl: import_zod21.z.string().url().nullable().optional(),
+  sourceMealPlanId: MealPlanIdSchema.optional()
+});
+var StartMealPlanFromGroupRequestSchema = import_zod21.z.object({
+  title: import_zod21.z.string().min(1).max(100).optional()
+});
+var AddMealGroupMemberRequestSchema = import_zod21.z.object({
+  memberId: import_zod21.z.number().int().positive(),
+  role: MealGroupMemberRoleSchema.default("MEMBER")
+});
+var UpdateMealGroupMemberRoleRequestSchema = import_zod21.z.object({
+  role: MealGroupMemberRoleSchema
+});
+var MealGroupHistoryItemSchema = MyMealPlanListItemSchema.extend({});
+var MealGroupPreferenceSummarySchema = import_zod21.z.object({
+  mealGroupId: MealGroupIdSchema,
+  frequentMenuCategories: import_zod21.z.array(import_zod21.z.object({ label: import_zod21.z.string(), count: import_zod21.z.number().int().min(0) })),
+  frequentRestaurants: import_zod21.z.array(import_zod21.z.object({ restaurantName: import_zod21.z.string(), count: import_zod21.z.number().int().min(0) })),
+  recentMenuCategories: import_zod21.z.array(import_zod21.z.string()),
+  recommendationContext: import_zod21.z.object({
+    preferredMenuCategories: import_zod21.z.array(import_zod21.z.string()),
+    excludedMenuCategories: import_zod21.z.array(import_zod21.z.string()),
+    candidateMenuCategories: import_zod21.z.array(import_zod21.z.string())
+  })
 });
-var CreateRecruitResponseSchema = import_zod16.z.object({
-  recruitId: RecruitIdSchema
+var MealGroupHistoryResponseSchema = import_zod21.z.array(MealGroupHistoryItemSchema);
+
+// src/domain/meal-plan/meal-plan-home-map.schema.ts
+var import_zod22 = require("zod");
+var HomeMealPlanActionKindSchema = import_zod22.z.enum([
+  "CONTINUE_DECISION",
+  "TODAY_UPCOMING",
+  "RECORD_NEEDED",
+  "RESPOND_JOIN_REQUEST",
+  "NOTIFICATION_FOLLOW_UP"
+]);
+var HomeMealPlanActionCardSchema = import_zod22.z.object({
+  actionId: import_zod22.z.string().min(1),
+  kind: HomeMealPlanActionKindSchema,
+  priority: import_zod22.z.number().int().min(0),
+  title: import_zod22.z.string().min(1),
+  description: import_zod22.z.string().min(1),
+  primaryAction: import_zod22.z.object({
+    label: import_zod22.z.string().min(1),
+    href: import_zod22.z.string().min(1)
+  }),
+  mealPlan: MyMealPlanListItemSchema.nullable(),
+  joinRequest: MealPlanJoinRequestSummarySchema.nullable(),
+  notification: MealPlanNotificationSchema.nullable().default(null)
+});
+var HomeMealPlanDashboardResponseSchema = import_zod22.z.object({
+  generatedAt: ISODateTimeStringSchema,
+  inProgress: import_zod22.z.array(MyMealPlanListItemSchema),
+  today: import_zod22.z.array(MyMealPlanListItemSchema),
+  recordNeeded: import_zod22.z.array(MyMealPlanListItemSchema),
+  pendingJoinRequests: import_zod22.z.array(MealPlanJoinRequestSummarySchema),
+  unreadNotifications: import_zod22.z.array(MealPlanNotificationSchema).default([]),
+  nextActions: import_zod22.z.array(HomeMealPlanActionCardSchema)
+});
+var MealMapLayerSchema = import_zod22.z.enum([
+  "MY_MEAL_PLAN_PLACE",
+  "NEARBY_FRIEND_MEAL_PLAN",
+  "FRIEND_RECORD_LOCATION",
+  "RESTAURANT_CANDIDATE"
+]);
+var MealMapMarkerBaseSchema = import_zod22.z.object({
+  markerId: import_zod22.z.string().min(1),
+  lat: import_zod22.z.number().min(-90).max(90),
+  lng: import_zod22.z.number().min(-180).max(180),
+  title: import_zod22.z.string().min(1),
+  subtitle: import_zod22.z.string().nullable(),
+  href: import_zod22.z.string().min(1).nullable(),
+  mealPlanId: MealPlanIdSchema.nullable(),
+  articleId: ArticleIdSchema.nullable(),
+  restaurant: RestaurantSchema.nullable(),
+  distanceMeters: import_zod22.z.number().int().min(0).nullable(),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealMapMyMealPlanPlaceMetadataSchema = import_zod22.z.object({
+  ownerId: MemberIdSchema.nullable().default(null),
+  status: import_zod22.z.string().min(1),
+  participantCount: import_zod22.z.number().int().min(1),
+  source: import_zod22.z.string().min(1)
+});
+var MealMapNearbyFriendMealPlanMetadataSchema = import_zod22.z.object({
+  ownerId: MemberIdSchema.nullable().default(null),
+  ownerName: import_zod22.z.string().min(1),
+  participantCount: import_zod22.z.number().int().min(1),
+  expiresAt: ISODateTimeStringSchema.nullable(),
+  source: import_zod22.z.string().min(1)
+});
+var MealMapFriendRecordLocationMetadataSchema = import_zod22.z.object({
+  authorId: MemberIdSchema.nullable().default(null),
+  authorName: import_zod22.z.string().min(1),
+  imageUrl: import_zod22.z.string().nullable().default(null),
+  mealDate: import_zod22.z.string().min(1)
+});
+var MealMapRestaurantCandidateCompletionBlockedReasonSchema = import_zod22.z.enum([
+  "OWNER_ONLY",
+  "STAGE_ALREADY_COMPLETED",
+  "MEAL_PLAN_NOT_MUTABLE"
+]);
+var MealMapRestaurantCandidateMetadataSchema = import_zod22.z.object({
+  stageId: MealPlanDecisionStageIdSchema,
+  ownerId: MemberIdSchema.nullable().default(null),
+  status: import_zod22.z.string().min(1),
+  source: import_zod22.z.enum(["search", "fallback", "manual"]).default("search"),
+  stageStatus: import_zod22.z.enum(["OPEN", "COMPLETED", "REOPENED"]).default("OPEN"),
+  canVote: import_zod22.z.boolean().default(false),
+  canCompleteStage: import_zod22.z.boolean().default(false),
+  completionBlockedReason: MealMapRestaurantCandidateCompletionBlockedReasonSchema.nullable().default(null)
+});
+var MealMapMarkerSchema = import_zod22.z.discriminatedUnion("layer", [
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod22.z.literal("MY_MEAL_PLAN_PLACE"),
+    metadata: MealMapMyMealPlanPlaceMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod22.z.literal("NEARBY_FRIEND_MEAL_PLAN"),
+    metadata: MealMapNearbyFriendMealPlanMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod22.z.literal("FRIEND_RECORD_LOCATION"),
+    metadata: MealMapFriendRecordLocationMetadataSchema
+  }),
+  MealMapMarkerBaseSchema.extend({
+    layer: import_zod22.z.literal("RESTAURANT_CANDIDATE"),
+    metadata: MealMapRestaurantCandidateMetadataSchema
+  })
+]);
+var MealMapQuerySchema = import_zod22.z.object({
+  friendRecordDays: import_zod22.z.coerce.number().int().min(1).max(90).optional().default(7)
+});
+var MealMapResponseSchema = import_zod22.z.object({
+  generatedAt: ISODateTimeStringSchema,
+  center: import_zod22.z.object({
+    lat: import_zod22.z.number().min(-90).max(90),
+    lng: import_zod22.z.number().min(-180).max(180),
+    source: import_zod22.z.enum(["LAST_KNOWN_LOCATION", "MY_MEAL_PLAN", "DEFAULT"])
+  }),
+  layers: import_zod22.z.object({
+    myMealPlanPlaces: import_zod22.z.array(MealMapMarkerSchema),
+    nearbyFriendMealPlans: import_zod22.z.array(MealMapMarkerSchema),
+    friendRecordLocations: import_zod22.z.array(MealMapMarkerSchema),
+    restaurantCandidates: import_zod22.z.array(MealMapMarkerSchema)
+  })
 });
 
 // src/domain/promotion/referral.schema.ts
-var import_zod17 = require("zod");
-var ReferralCreateResponseSchema = import_zod17.z.object({
+var import_zod23 = require("zod");
+var ReferralCreateResponseSchema = import_zod23.z.object({
   code: ReferralCodeSchema,
-  link: import_zod17.z.string().url(),
+  link: import_zod23.z.string().url(),
   expiresAt: ISODateTimeStringSchema
 });
-var ReferralItemResponseSchema = import_zod17.z.object({
+var ReferralItemResponseSchema = import_zod23.z.object({
   code: ReferralCodeSchema,
   createdAt: ISODateTimeStringSchema,
   expiresAt: ISODateTimeStringSchema,
-  used: import_zod17.z.boolean(),
+  used: import_zod23.z.boolean(),
   usedByMemberId: MemberIdSchema.nullable(),
-  usedByUsername: import_zod17.z.string().nullable()
+  usedByUsername: import_zod23.z.string().nullable()
 });
-var RedeemReferralRequestSchema = import_zod17.z.object({
+var RedeemReferralRequestSchema = import_zod23.z.object({
   code: ReferralCodeSchema
 });
 
 // src/domain/promotion/coupon.schema.ts
-var import_zod18 = require("zod");
-var CouponTypeSchema = import_zod18.z.enum(["DISCOUNT", "SERVICE"]);
-var CouponStatusSchema = import_zod18.z.enum(["UNUSED", "USED"]);
-var CouponResponseSchema = import_zod18.z.object({
+var import_zod24 = require("zod");
+var CouponTypeSchema = import_zod24.z.enum(["DISCOUNT", "SERVICE"]);
+var CouponStatusSchema = import_zod24.z.enum(["UNUSED", "USED"]);
+var CouponResponseSchema = import_zod24.z.object({
   couponId: CouponIdSchema,
-  title: import_zod18.z.string(),
-  shopName: import_zod18.z.string(),
+  title: import_zod24.z.string(),
+  shopName: import_zod24.z.string(),
   type: CouponTypeSchema,
-  condition: import_zod18.z.string(),
+  condition: import_zod24.z.string(),
   expiresAt: ISODateStringSchema,
-  used: import_zod18.z.boolean(),
-  thumbnailUrl: import_zod18.z.string().url()
+  used: import_zod24.z.boolean(),
+  thumbnailUrl: import_zod24.z.string().url()
+});
+
+// src/domain/promotion/challenge.schema.ts
+var import_zod25 = require("zod");
+var RewardTypeSchema = import_zod25.z.enum(["WEEK", "MONTH"]);
+var WeekProgressSchema = import_zod25.z.object({
+  days: import_zod25.z.array(import_zod25.z.boolean()),
+  completed: import_zod25.z.number().int().min(0),
+  goal: import_zod25.z.number().int().positive()
+});
+var MonthProgressSchema = import_zod25.z.object({
+  count: import_zod25.z.number().int().min(0),
+  goal: import_zod25.z.number().int().positive()
+});
+var ChallengeStatusResponseSchema = import_zod25.z.object({
+  week: WeekProgressSchema,
+  month: MonthProgressSchema,
+  weekRewardAvailable: import_zod25.z.boolean(),
+  monthRewardAvailable: import_zod25.z.boolean()
+});
+var ClaimChallengeRewardRequestSchema = import_zod25.z.object({
+  type: RewardTypeSchema
+});
+var ClaimChallengeRewardResponseSchema = import_zod25.z.object({
+  rewardType: RewardTypeSchema,
+  claimed: import_zod25.z.boolean()
+});
+
+// src/domain/push/push.schema.ts
+var import_zod26 = require("zod");
+var PushProviderSchema = import_zod26.z.enum(["FCM", "APNS_LIVE_ACTIVITY"]);
+var PushPlatformSchema = import_zod26.z.enum(["WEB", "ANDROID", "IOS"]);
+var PushPermissionStatusSchema = import_zod26.z.enum([
+  "UNKNOWN",
+  "PROMPT",
+  "GRANTED",
+  "DENIED"
+]);
+var PushTokenStatusSchema = import_zod26.z.enum(["ACTIVE", "REVOKED", "DISABLED"]);
+var RegisterPushTokenRequestSchema = import_zod26.z.object({
+  provider: PushProviderSchema.default("FCM"),
+  platform: PushPlatformSchema,
+  token: import_zod26.z.string().min(10),
+  deviceId: import_zod26.z.string().min(1).max(128),
+  appVersion: import_zod26.z.string().min(1).max(64).optional(),
+  buildNumber: import_zod26.z.string().min(1).max(64).optional(),
+  permissionStatus: PushPermissionStatusSchema
+});
+var RevokePushTokenRequestSchema = import_zod26.z.object({
+  provider: PushProviderSchema.default("FCM"),
+  token: import_zod26.z.string().min(10).optional(),
+  deviceId: import_zod26.z.string().min(1).max(128).optional()
+});
+var PushTokenResponseSchema = import_zod26.z.object({
+  pushTokenId: import_zod26.z.string().uuid(),
+  provider: PushProviderSchema,
+  platform: PushPlatformSchema,
+  deviceId: import_zod26.z.string(),
+  status: PushTokenStatusSchema,
+  permissionStatus: PushPermissionStatusSchema,
+  appVersion: import_zod26.z.string().nullable(),
+  buildNumber: import_zod26.z.string().nullable(),
+  lastSeenAt: ISODateTimeStringSchema,
+  revokedAt: ISODateTimeStringSchema.nullable()
+});
+var PushPayloadSchemaVersionSchema = import_zod26.z.literal("2026-06-17");
+var MealPlanPushPayloadDataSchema = import_zod26.z.object({
+  schemaVersion: PushPayloadSchemaVersionSchema,
+  notificationId: import_zod26.z.string().min(1),
+  kind: MealPlanNotificationKindSchema,
+  mealPlanId: MealPlanIdSchema,
+  deepLink: import_zod26.z.string().min(1),
+  title: import_zod26.z.string().min(1),
+  body: import_zod26.z.string().min(1),
+  fcmPriority: import_zod26.z.coerce.number().int().min(0),
+  liveActivityPriority: import_zod26.z.coerce.number().int().min(0),
+  liveActivityBehavior: MealPlanLiveActivityBehaviorSchema
+});
+var PushDeliveryStatusSchema = import_zod26.z.enum([
+  "PENDING",
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var PushDeliveryAttemptResultSchema = import_zod26.z.enum([
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var PushDeliveryAttemptSummarySchema = import_zod26.z.object({
+  attemptId: import_zod26.z.string().uuid(),
+  outboxId: import_zod26.z.string().uuid(),
+  pushTokenId: import_zod26.z.string().uuid().nullable(),
+  provider: PushProviderSchema,
+  result: PushDeliveryAttemptResultSchema,
+  providerMessageId: import_zod26.z.string().nullable(),
+  errorCode: import_zod26.z.string().nullable(),
+  errorMessage: import_zod26.z.string().nullable(),
+  invalidToken: import_zod26.z.boolean(),
+  createdAt: ISODateTimeStringSchema
+});
+var PushDeliveryOutboxSummarySchema = import_zod26.z.object({
+  outboxId: import_zod26.z.string().uuid(),
+  notificationId: import_zod26.z.string().min(1),
+  memberId: import_zod26.z.number().int().positive(),
+  status: PushDeliveryStatusSchema,
+  attemptCount: import_zod26.z.number().int().min(0),
+  lastError: import_zod26.z.string().nullable(),
+  nextAttemptAt: ISODateTimeStringSchema.nullable(),
+  sentAt: ISODateTimeStringSchema.nullable(),
+  createdAt: ISODateTimeStringSchema
+});
+
+// src/domain/live-activity/live-activity.schema.ts
+var import_zod27 = require("zod");
+var MealPlanLiveActivityPlatformSchema = import_zod27.z.enum([
+  "IOS_LIVE_ACTIVITY",
+  "ANDROID_LIVE_UPDATE"
+]);
+var MealPlanLiveActivitySessionStatusSchema = import_zod27.z.enum([
+  "ACTIVE",
+  "ENDED",
+  "EXPIRED",
+  "DISABLED"
+]);
+var MealPlanLiveActivityUpdateStatusSchema = import_zod27.z.enum([
+  "PENDING",
+  "SENT",
+  "FAILED",
+  "SKIPPED"
+]);
+var RegisterMealPlanLiveActivitySessionRequestSchema = import_zod27.z.object({
+  platform: MealPlanLiveActivityPlatformSchema,
+  deviceId: import_zod27.z.string().min(1).max(128),
+  activityId: import_zod27.z.string().min(1).max(128),
+  pushToken: import_zod27.z.string().min(10).optional(),
+  appVersion: import_zod27.z.string().min(1).max(64).optional(),
+  buildNumber: import_zod27.z.string().min(1).max(64).optional()
+});
+var EndMealPlanLiveActivitySessionRequestSchema = import_zod27.z.object({
+  platform: MealPlanLiveActivityPlatformSchema.optional(),
+  deviceId: import_zod27.z.string().min(1).max(128).optional(),
+  activityId: import_zod27.z.string().min(1).max(128).optional()
+});
+var MealPlanLiveActivityStateSchema = import_zod27.z.object({
+  mealPlanId: MealPlanIdSchema,
+  title: import_zod27.z.string().min(1),
+  status: import_zod27.z.string().min(1),
+  scheduledAt: ISODateTimeStringSchema.nullable(),
+  restaurantName: import_zod27.z.string().nullable(),
+  placeName: import_zod27.z.string().nullable(),
+  deepLink: import_zod27.z.string().min(1),
+  progressLabel: import_zod27.z.string().min(1),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealPlanLiveActivitySessionResponseSchema = import_zod27.z.object({
+  sessionId: import_zod27.z.string().uuid(),
+  mealPlanId: MealPlanIdSchema,
+  memberId: import_zod27.z.number().int().positive(),
+  platform: MealPlanLiveActivityPlatformSchema,
+  devicePlatform: PushPlatformSchema,
+  deviceId: import_zod27.z.string(),
+  activityId: import_zod27.z.string(),
+  status: MealPlanLiveActivitySessionStatusSchema,
+  appVersion: import_zod27.z.string().nullable(),
+  buildNumber: import_zod27.z.string().nullable(),
+  lastEventKind: MealPlanNotificationKindSchema.nullable(),
+  lastBehavior: MealPlanLiveActivityBehaviorSchema.nullable(),
+  lastUpdateStatus: MealPlanLiveActivityUpdateStatusSchema.nullable(),
+  lastError: import_zod27.z.string().nullable(),
+  startedAt: ISODateTimeStringSchema,
+  endedAt: ISODateTimeStringSchema.nullable(),
+  updatedAt: ISODateTimeStringSchema
+});
+var MealPlanLiveActivitySessionListResponseSchema = import_zod27.z.object({
+  mealPlanId: MealPlanIdSchema,
+  state: MealPlanLiveActivityStateSchema,
+  sessions: import_zod27.z.array(MealPlanLiveActivitySessionResponseSchema)
 });
 
 // src/domain/common/contracts/endpoint.ts
-var import_zod19 = require("zod");
-var NoBodySchema = import_zod19.z.undefined();
-var NoQuerySchema = import_zod19.z.undefined();
-var NoParamsSchema = import_zod19.z.undefined();
+var import_zod28 = require("zod");
+var NoBodySchema = import_zod28.z.undefined();
+var NoQuerySchema = import_zod28.z.undefined();
+var NoParamsSchema = import_zod28.z.undefined();
 var endpoint = (contract) => ({
   method: contract.method,
   path: contract.path,
@@ -665,23 +1684,40 @@ var endpoint = (contract) => ({
 });
 
 // src/domain/common/contracts/api.ts
-var memberIdParam = import_zod20.z.object({ memberId: MemberIdSchema });
-var articleIdParam = import_zod20.z.object({ articleId: ArticleIdSchema });
-var commentIdParam = import_zod20.z.object({ commentId: CommentIdSchema });
-var recruitIdParam = import_zod20.z.object({ recruitId: RecruitIdSchema });
-var roomIdParam = import_zod20.z.object({ roomId: RoomIdSchema });
-var invitationIdParam = import_zod20.z.object({ invitationId: InvitationIdSchema });
-var notificationIdParam = import_zod20.z.object({ notificationId: import_zod20.z.string().min(1) });
-var planIdParam = import_zod20.z.object({ planId: PlanIdSchema });
-var couponIdParam = import_zod20.z.object({ couponId: CouponIdSchema });
-var friendRequestIdParam = import_zod20.z.object({ requestId: FriendRequestIdSchema });
+var memberIdParam = import_zod29.z.object({ memberId: MemberIdSchema });
+var articleIdParam = import_zod29.z.object({ articleId: ArticleIdSchema });
+var commentIdParam = import_zod29.z.object({ commentId: CommentIdSchema });
+var mealPlanIdParam = import_zod29.z.object({ mealPlanId: MealPlanIdSchema });
+var mealPlanInviteIdParam = import_zod29.z.object({ inviteId: MealPlanInviteIdSchema });
+var mealPlanJoinRequestIdParam = import_zod29.z.object({ requestId: MealPlanJoinRequestIdSchema });
+var mealPlanDecisionStageIdParam = mealPlanIdParam.extend({
+  stageId: MealPlanDecisionStageIdSchema
+});
+var mealPlanChangeRequestIdParam = mealPlanIdParam.extend({
+  requestId: MealPlanChangeRequestIdSchema
+});
+var mealPlanDecisionTaskKeyParam = mealPlanIdParam.extend({
+  taskKey: MealPlanDecisionTaskKeySchema
+});
+var mealPlanDecisionSnapshotIdParam = mealPlanIdParam.extend({
+  snapshotId: import_zod29.z.string().uuid()
+});
+var mealPlanParticipantIdParam = mealPlanIdParam.extend({
+  participantId: import_zod29.z.string().uuid()
+});
+var mealPlanShareTokenParam = import_zod29.z.object({ token: MealPlanShareLinkTokenSchema });
+var notificationIdParam = import_zod29.z.object({ notificationId: import_zod29.z.string().min(1) });
+var couponIdParam = import_zod29.z.object({ couponId: CouponIdSchema });
+var mealGroupIdParam = import_zod29.z.object({ mealGroupId: MealGroupIdSchema });
+var mealGroupMemberIdParam = mealGroupIdParam.extend({ memberId: MemberIdSchema });
+var friendRequestIdParam = import_zod29.z.object({ requestId: FriendRequestIdSchema });
+var sseTokenQuery = import_zod29.z.object({ token: import_zod29.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 })
-    // test: endpoint({method: "GET",  path: "/auth/test", response: TokenResponseSchema}) TODO: Dev에서만 작동하도록 백엔드에서 수정해야함
   },
   members: {
     me: endpoint({ method: "GET", path: "/members/me", response: MemberResponseSchema }),
@@ -690,7 +1726,11 @@ var apiContract = {
     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 }),
-    updateProfile: endpoint({ method: "PATCH", path: "/members/me/profile", body: UpdateProfileRequestSchema, 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 }),
@@ -699,7 +1739,7 @@ var apiContract = {
   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_zod20.z.array(FriendMealItemResponseSchema) })
+    friendMealStatus: endpoint({ method: "GET", path: "/friends/me/meals", query: FriendMealQuerySchema, response: import_zod29.z.array(FriendMealItemResponseSchema) })
   },
   articles: {
     list: endpoint({ method: "GET", path: "/articles/home", query: ArticleListQuerySchema, response: PageArticleSummaryResponseSchema }),
@@ -712,32 +1752,64 @@ var apiContract = {
     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 })
-    // TODO: 게시물 수정 기능
-  },
-  recruits: {
-    list: endpoint({ method: "GET", path: "/recruits", query: RecruitListQuerySchema, response: RecruitListResponseSchema }),
-    create: endpoint({ method: "POST", path: "/recruits", body: CreateRecruitRequestSchema, response: CreateRecruitResponseSchema }),
-    join: endpoint({ method: "POST", path: "/recruits/:recruitId/join", pathParams: recruitIdParam, response: NoContentSchema }),
-    close: endpoint({ method: "POST", path: "/recruits/:recruitId/close", pathParams: recruitIdParam, response: NoContentSchema })
   },
-  invitations: {
-    list: endpoint({ method: "GET", path: "/invitations", response: import_zod20.z.array(InvitationListItemResponseSchema) }),
-    //  TODO: Invitation Response 정하기 detail: endpoint({ method: "GET", path: "/invitations/:invitationId", pathParams: invitationIdParam, response: InvitationItemDetailResponseSchema }),
-    send: endpoint({ method: "POST", path: "/invitations/send", body: CreateInvitationRequestSchema, response: SendInvitationResponseSchema }),
-    accept: endpoint({ method: "POST", path: "/invitations/:invitationId/accept", pathParams: invitationIdParam, response: AcceptInvitationResponseSchema }),
-    reject: endpoint({ method: "POST", path: "/invitations/:invitationId/reject", pathParams: invitationIdParam, 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_zod29.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 }),
+    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 })
   },
-  plans: {
-    list: endpoint({ method: "GET", path: "/plans", query: PlanListQuerySchema, response: import_zod20.z.array(PlanResponseSchema) }),
-    detail: endpoint({ method: "GET", path: "/plans/:planId", pathParams: planIdParam, response: PlanResponseSchema }),
-    cancel: endpoint({ method: "PATCH", path: "/plans/:planId/cancel", pathParams: planIdParam, response: NoContentSchema })
+  mealGroups: {
+    create: endpoint({ method: "POST", path: "/meal-groups", body: CreateMealGroupRequestSchema, response: MealGroupResponseSchema }),
+    list: endpoint({ method: "GET", path: "/meal-groups", response: import_zod29.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_zod20.z.array(FriendListItemResponseSchema) }),
-    blockList: endpoint({ method: "GET", path: "/friends/blocks", response: import_zod20.z.array(FriendBlockItemResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/friends", response: import_zod29.z.array(FriendListItemResponseSchema) }),
+    blockList: endpoint({ method: "GET", path: "/friends/blocks", response: import_zod29.z.array(FriendBlockItemResponseSchema) }),
     search: endpoint({ method: "GET", path: "/friends/search", query: MemberSearchQuerySchema, response: MemberSerachResponseSchema }),
-    incomingRequest: endpoint({ method: "GET", path: "/friends/requests/incoming", response: import_zod20.z.array(FriendRequestItemResponseSchema) }),
-    outgoingRequest: endpoint({ method: "GET", path: "/friends/requests/outgoing", response: import_zod20.z.array(FriendRequestItemResponseSchema) }),
+    incomingRequest: endpoint({ method: "GET", path: "/friends/requests/incoming", response: import_zod29.z.array(FriendRequestItemResponseSchema) }),
+    outgoingRequest: endpoint({ method: "GET", path: "/friends/requests/outgoing", response: import_zod29.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 }),
@@ -747,7 +1819,7 @@ var apiContract = {
     unfriend: endpoint({ method: "DELETE", path: "/friends/:memberId", pathParams: memberIdParam, response: NoContentSchema })
   },
   coupons: {
-    list: endpoint({ method: "GET", path: "/coupons", response: import_zod20.z.array(CouponResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/coupons", response: import_zod29.z.array(CouponResponseSchema) }),
     use: endpoint({ method: "POST", path: "/coupons/:couponId/use", pathParams: couponIdParam, response: NoContentSchema })
   },
   challenges: {
@@ -755,23 +1827,36 @@ var apiContract = {
     claimReward: endpoint({ method: "POST", path: "/challenges/rewards", body: ClaimChallengeRewardRequestSchema, response: NoContentSchema })
   },
   referrals: {
-    list: endpoint({ method: "GET", path: "/referrals", response: import_zod20.z.array(ReferralItemResponseSchema) }),
+    list: endpoint({ method: "GET", path: "/referrals", response: import_zod29.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_zod20.z.array(MatchingNotificationSchema) }),
-    markRead: endpoint({ method: "PATCH", path: "/notifications/:notificationId/read", pathParams: notificationIdParam, response: MatchingNotificationSchema }),
+    list: endpoint({ method: "GET", path: "/notifications", response: import_zod29.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 })
   },
-  room: {
-    access: endpoint({ method: "GET", path: "/rooms/:roomId/access", pathParams: roomIdParam, response: RoomAccessResponseSchema })
+  pushTokens: {
+    list: endpoint({ method: "GET", path: "/push-tokens", response: import_zod29.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 })
+  },
+  sse: {
+    notifications: endpoint({ method: "GET", path: "/sse/notifications", query: sseTokenQuery, response: import_zod29.z.any() })
   },
   health: {
-    healthCheck: endpoint({ method: "GET", path: "/", response: import_zod20.z.string() })
+    healthCheck: endpoint({ method: "GET", path: "/", response: import_zod29.z.string() })
   }
 };
 
+// src/domain/common/contracts/cache-invalidation.ts
+var CACHE_INVALIDATION_SSE_EVENT = "cache-invalidate";
+
 // src/domain/common/contracts/envelope.ts
 var makeApiResponseSchema = ApiResponseSchema;
 var makeApiSuccessSchema = ApiSuccessSchema;
@@ -779,12 +1864,18 @@ var makeApiSuccessSchema = ApiSuccessSchema;
 // src/domain/common/contracts/id.ts
 var toMemberId = (value) => MemberIdSchema.parse(value);
 var toArticleId = (value) => ArticleIdSchema.parse(value);
-var toRecruitId = (value) => RecruitIdSchema.parse(value);
-var toInvitationId = (value) => InvitationIdSchema.parse(value);
-var toRoomId = (value) => RoomIdSchema.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 toPlanId = (value) => PlanIdSchema.parse(value);
 var toCouponId = (value) => CouponIdSchema.parse(value);
 var toSubscriptionId = (value) => SubscriptionIdSchema.parse(value);
 var toFriendRequestId = (value) => FriendRequestIdSchema.parse(value);
@@ -795,6 +1886,11 @@ var toReferralCode = (value) => ReferralCodeSchema.parse(value);
   ApiResponseSchema,
   ApiSuccessSchema,
   ArticleIdSchema,
+  CACHE_INVALIDATION_SSE_EVENT,
+  CacheInvalidationActionSchema,
+  CacheInvalidationEntitySchema,
+  CacheInvalidationEventSchema,
+  CacheInvalidationKeySchema,
   CommentIdSchema,
   CouponIdSchema,
   CreatedEntityIdResponseSchema,
@@ -804,7 +1900,16 @@ var toReferralCode = (value) => ReferralCodeSchema.parse(value);
   FriendRequestIdSchema,
   ISODateStringSchema,
   ISODateTimeStringSchema,
-  InvitationIdSchema,
+  MealGroupIdSchema,
+  MealPlanChangeRequestIdSchema,
+  MealPlanChatMessageIdSchema,
+  MealPlanChatRoomIdSchema,
+  MealPlanIdSchema,
+  MealPlanInviteIdSchema,
+  MealPlanJoinRequestIdSchema,
+  MealPlanNearbyFriendExposureBatchIdSchema,
+  MealPlanShareLinkIdSchema,
+  MealPlanShareLinkTokenSchema,
   MemberIdSchema,
   NoBodySchema,
   NoContentSchema,
@@ -814,12 +1919,9 @@ var toReferralCode = (value) => ReferralCodeSchema.parse(value);
   PageMetaSchema,
   PageQuerySchema,
   PageResponseSchema,
-  PlanIdSchema,
   PositiveIntIdSchema,
-  RecruitIdSchema,
   ReferralCodeSchema,
   RestaurantIdSchema,
-  RoomIdSchema,
   SortDirectionSchema,
   SubscriptionIdSchema,
   TimeHHmmStringSchema,
@@ -832,12 +1934,18 @@ var toReferralCode = (value) => ReferralCodeSchema.parse(value);
   toCommentId,
   toCouponId,
   toFriendRequestId,
-  toInvitationId,
+  toMealGroupId,
+  toMealPlanChangeRequestId,
+  toMealPlanChatMessageId,
+  toMealPlanChatRoomId,
+  toMealPlanId,
+  toMealPlanInviteId,
+  toMealPlanJoinRequestId,
+  toMealPlanNearbyFriendExposureBatchId,
+  toMealPlanShareLinkId,
+  toMealPlanShareLinkToken,
   toMemberId,
-  toPlanId,
-  toRecruitId,
   toReferralCode,
   toRestaurantId,
-  toRoomId,
   toSubscriptionId
 });