@contractspec/example.marketplace 3.7.6 → 3.7.7

package/dist/browser/index.js

@@ -299,345 +299,490 @@ function createMarketplaceHandlers(db) {
   };
 }
 
-// src/store/store.enum.ts
+// src/order/order.enum.ts
 import { defineEnum } from "@contractspec/lib.schema";
-var StoreStatusEnum = defineEnum("StoreStatus", [
+var OrderStatusEnum = defineEnum("OrderStatus", [
   "PENDING",
-  "ACTIVE",
-  "SUSPENDED",
-  "CLOSED"
+  "PAID",
+  "PROCESSING",
+  "SHIPPED",
+  "DELIVERED",
+  "COMPLETED",
+  "CANCELLED",
+  "REFUNDED",
+  "PARTIALLY_REFUNDED",
+  "DISPUTED"
 ]);
 
-// src/store/store.schema.ts
+// src/order/order.event.ts
+import { defineEvent } from "@contractspec/lib.contracts-spec";
 import { defineSchemaModel, ScalarTypeEnum } from "@contractspec/lib.schema";
-var StoreModel = defineSchemaModel({
-  name: "StoreModel",
-  description: "A seller store",
+var OrderCreatedPayload = defineSchemaModel({
+  name: "OrderCreatedEventPayload",
   fields: {
-    id: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    slug: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    status: { type: StoreStatusEnum, isOptional: false },
-    ownerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
-    logoFileId: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    isVerified: { type: ScalarTypeEnum.Boolean(), isOptional: false },
-    totalProducts: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
-    averageRating: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum.DateTime(), isOptional: false }
+    orderId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orderNumber: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    buyerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    total: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    itemCount: { type: ScalarTypeEnum.Int_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-var CreateStoreInputModel = defineSchemaModel({
-  name: "CreateStoreInput",
+var OrderPaidPayload = defineSchemaModel({
+  name: "OrderPaidEventPayload",
   fields: {
-    name: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    slug: { type: ScalarTypeEnum.NonEmptyString(), isOptional: false },
-    description: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    email: { type: ScalarTypeEnum.EmailAddress(), isOptional: true },
-    country: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
-    currency: { type: ScalarTypeEnum.String_unsecure(), isOptional: true }
+    orderId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orderNumber: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    total: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    paymentMethod: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-
-// src/store/store.operations.ts
-import { defineCommand } from "@contractspec/lib.contracts-spec/operations";
-var OWNERS = ["@example.marketplace"];
-var CreateStoreContract = defineCommand({
-  meta: {
-    key: "marketplace.store.create",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS],
-    tags: ["marketplace", "store", "create"],
-    description: "Create a new seller store.",
-    goal: "Allow users to become sellers on the marketplace.",
-    context: "Seller onboarding."
-  },
-  io: { input: CreateStoreInputModel, output: StoreModel },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "marketplace.store.created",
-        version: "1.0.0",
-        when: "Store is created",
-        payload: StoreModel
-      }
-    ],
-    audit: ["marketplace.store.created"]
-  },
-  acceptance: {
-    scenarios: [
-      {
-        key: "create-store-happy-path",
-        given: ["User is authenticated"],
-        when: ["User creates a new store"],
-        then: ["Store is created", "StoreCreated event is emitted"]
-      }
-    ],
-    examples: [
-      {
-        key: "create-fashion-store",
-        input: { name: "Fashion Boutique", category: "clothing" },
-        output: { id: "store-123", status: "active" }
-      }
-    ]
+var OrderStatusUpdatedPayload = defineSchemaModel({
+  name: "OrderStatusUpdatedEventPayload",
+  fields: {
+    orderId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orderNumber: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    previousStatus: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: false
+    },
+    newStatus: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    updatedBy: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-
-// src/store/store.event.ts
-import { ScalarTypeEnum as ScalarTypeEnum2, defineSchemaModel as defineSchemaModel2 } from "@contractspec/lib.schema";
-import { defineEvent } from "@contractspec/lib.contracts-spec";
-var StoreCreatedPayload = defineSchemaModel2({
-  name: "StoreCreatedEventPayload",
+var OrderShippedPayload = defineSchemaModel({
+  name: "OrderShippedEventPayload",
   fields: {
-    storeId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    slug: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    ownerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+    orderId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orderNumber: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    trackingNumber: {
+      type: ScalarTypeEnum.String_unsecure(),
+      isOptional: true
+    },
+    trackingUrl: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    carrier: { type: ScalarTypeEnum.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-var StoreStatusChangedPayload = defineSchemaModel2({
-  name: "StoreStatusChangedEventPayload",
+var OrderCompletedPayload = defineSchemaModel({
+  name: "OrderCompletedEventPayload",
   fields: {
-    storeId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    previousStatus: {
-      type: ScalarTypeEnum2.String_unsecure(),
-      isOptional: false
-    },
-    newStatus: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
-    reason: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
-    timestamp: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
+    orderId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    orderNumber: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    buyerId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum.String_unsecure(), isOptional: false },
+    total: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    sellerPayout: { type: ScalarTypeEnum.Float_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum.DateTime(), isOptional: false }
   }
 });
-var StoreCreatedEvent = defineEvent({
+var OrderCreatedEvent = defineEvent({
   meta: {
-    key: "marketplace.store.created",
+    key: "marketplace.order.created",
     version: "1.0.0",
-    description: "A new seller store has been created.",
+    description: "A new order has been created.",
     stability: "experimental",
     owners: ["@marketplace-team"],
-    tags: ["marketplace", "store"]
+    tags: ["marketplace", "order"]
   },
-  payload: StoreCreatedPayload
+  payload: OrderCreatedPayload
 });
-var StoreStatusChangedEvent = defineEvent({
+var OrderPaidEvent = defineEvent({
   meta: {
-    key: "marketplace.store.statusChanged",
+    key: "marketplace.order.paid",
     version: "1.0.0",
-    description: "A store status has changed.",
+    description: "An order has been paid.",
     stability: "experimental",
     owners: ["@marketplace-team"],
-    tags: ["marketplace", "store"]
+    tags: ["marketplace", "order"]
   },
-  payload: StoreStatusChangedPayload
+  payload: OrderPaidPayload
+});
+var OrderStatusUpdatedEvent = defineEvent({
+  meta: {
+    key: "marketplace.order.statusUpdated",
+    version: "1.0.0",
+    description: "An order status has been updated.",
+    stability: "experimental",
+    owners: ["@marketplace-team"],
+    tags: ["marketplace", "order"]
+  },
+  payload: OrderStatusUpdatedPayload
+});
+var OrderShippedEvent = defineEvent({
+  meta: {
+    key: "marketplace.order.shipped",
+    version: "1.0.0",
+    description: "An order has been shipped.",
+    stability: "experimental",
+    owners: ["@marketplace-team"],
+    tags: ["marketplace", "order"]
+  },
+  payload: OrderShippedPayload
+});
+var OrderCompletedEvent = defineEvent({
+  meta: {
+    key: "marketplace.order.completed",
+    version: "1.0.0",
+    description: "An order has been completed.",
+    stability: "experimental",
+    owners: ["@marketplace-team"],
+    tags: ["marketplace", "order"]
+  },
+  payload: OrderCompletedPayload
 });
-// src/product/product.enum.ts
-import { defineEnum as defineEnum2 } from "@contractspec/lib.schema";
-var ProductStatusEnum = defineEnum2("ProductStatus", [
-  "DRAFT",
-  "PENDING_REVIEW",
-  "ACTIVE",
-  "OUT_OF_STOCK",
-  "DISCONTINUED",
-  "REJECTED"
-]);
 
-// src/product/product.schema.ts
-import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
-var ProductModel = defineSchemaModel3({
-  name: "ProductModel",
-  description: "A product listing",
+// src/order/order.schema.ts
+import { defineSchemaModel as defineSchemaModel2, ScalarTypeEnum as ScalarTypeEnum2 } from "@contractspec/lib.schema";
+var OrderItemModel = defineSchemaModel2({
+  name: "OrderItemModel",
   fields: {
-    id: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    storeId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    slug: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    description: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    status: { type: ProductStatusEnum, isOptional: false },
-    price: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    quantity: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    categoryId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    primaryImageId: {
-      type: ScalarTypeEnum3.String_unsecure(),
-      isOptional: true
-    },
-    averageRating: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: false },
-    totalSold: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    productId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    productName: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    unitPrice: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
+    quantity: { type: ScalarTypeEnum2.Int_unsecure(), isOptional: false },
+    subtotal: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false }
   }
 });
-var CreateProductInputModel = defineSchemaModel3({
-  name: "CreateProductInput",
+var OrderModel = defineSchemaModel2({
+  name: "OrderModel",
+  description: "An order",
   fields: {
-    storeId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
-    slug: { type: ScalarTypeEnum3.NonEmptyString(), isOptional: false },
-    description: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    price: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    quantity: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: true },
-    categoryId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    sku: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true }
+    id: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    orderNumber: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    buyerId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    status: { type: OrderStatusEnum, isOptional: false },
+    subtotal: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
+    shippingTotal: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
+    taxTotal: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
+    total: { type: ScalarTypeEnum2.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    items: { type: OrderItemModel, isArray: true, isOptional: true },
+    createdAt: { type: ScalarTypeEnum2.DateTime(), isOptional: false }
   }
 });
-var ListProductsInputModel = defineSchemaModel3({
-  name: "ListProductsInput",
+var CreateOrderInputModel = defineSchemaModel2({
+  name: "CreateOrderInput",
   fields: {
-    storeId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    categoryId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    status: { type: ProductStatusEnum, isOptional: true },
-    search: { type: ScalarTypeEnum3.String_unsecure(), isOptional: true },
-    minPrice: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: true },
-    maxPrice: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: true },
-    limit: {
-      type: ScalarTypeEnum3.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 20
+    storeId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    items: {
+      type: ScalarTypeEnum2.JSON(),
+      isOptional: false,
+      description: "Array of {productId, variantId?, quantity}"
     },
-    offset: {
-      type: ScalarTypeEnum3.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 0
-    }
+    shippingAddress: { type: ScalarTypeEnum2.JSON(), isOptional: true },
+    billingAddress: { type: ScalarTypeEnum2.JSON(), isOptional: true },
+    buyerNote: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
   }
 });
-var ListProductsOutputModel = defineSchemaModel3({
-  name: "ListProductsOutput",
+var UpdateOrderStatusInputModel = defineSchemaModel2({
+  name: "UpdateOrderStatusInput",
   fields: {
-    products: { type: ProductModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false }
+    orderId: { type: ScalarTypeEnum2.String_unsecure(), isOptional: false },
+    status: { type: OrderStatusEnum, isOptional: false },
+    trackingNumber: {
+      type: ScalarTypeEnum2.String_unsecure(),
+      isOptional: true
+    },
+    trackingUrl: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true },
+    note: { type: ScalarTypeEnum2.String_unsecure(), isOptional: true }
   }
 });
 
-// src/product/product.operations.ts
-import {
-  defineCommand as defineCommand2,
-  defineQuery
-} from "@contractspec/lib.contracts-spec/operations";
-var OWNERS2 = ["@example.marketplace"];
-var CreateProductContract = defineCommand2({
+// src/order/order.operations.ts
+import { defineCommand } from "@contractspec/lib.contracts-spec/operations";
+var OWNERS = ["@example.marketplace"];
+var CreateOrderContract = defineCommand({
   meta: {
-    key: "marketplace.product.create",
+    key: "marketplace.order.create",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["marketplace", "product", "create"],
-    description: "Create a new product listing.",
-    goal: "Allow sellers to list products.",
-    context: "Product management."
+    owners: [...OWNERS],
+    tags: ["marketplace", "order", "create"],
+    description: "Create a new order.",
+    goal: "Allow buyers to purchase products.",
+    context: "Checkout flow."
   },
-  io: { input: CreateProductInputModel, output: ProductModel },
+  io: { input: CreateOrderInputModel, output: OrderModel },
   policy: { auth: "user" },
   sideEffects: {
     emits: [
       {
-        key: "marketplace.product.created",
+        key: "marketplace.order.created",
         version: "1.0.0",
-        when: "Product is created",
-        payload: ProductModel
+        when: "Order is created",
+        payload: OrderModel
       }
     ],
-    audit: ["marketplace.product.created"]
+    audit: ["marketplace.order.created"]
   },
   acceptance: {
     scenarios: [
       {
-        key: "create-product-happy-path",
-        given: ["User is a seller"],
-        when: ["User creates a product listing"],
-        then: ["Product is created", "ProductCreated event is emitted"]
+        key: "create-order-happy-path",
+        given: ["User is authenticated"],
+        when: ["User creates order with valid items"],
+        then: ["Order is created", "OrderCreated event is emitted"]
       }
     ],
     examples: [
       {
-        key: "create-t-shirt",
+        key: "create-basic-order",
         input: {
-          title: "Classic T-Shirt",
-          price: 25,
-          stock: 100,
-          storeId: "store-123"
+          storeId: "store-123",
+          items: [{ productId: "prod-456", quantity: 1, unitPrice: 100 }]
         },
-        output: {
-          id: "prod-456",
-          title: "Classic T-Shirt",
-          status: "published"
-        }
+        output: { id: "order-789", status: "pending", total: 100 }
       }
     ]
   }
 });
-var ListProductsContract = defineQuery({
+var UpdateOrderStatusContract = defineCommand({
   meta: {
-    key: "marketplace.product.list",
+    key: "marketplace.order.updateStatus",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS2],
-    tags: ["marketplace", "product", "list"],
-    description: "List products with filters.",
-    goal: "Browse products on the marketplace.",
-    context: "Product catalog, search."
+    owners: [...OWNERS],
+    tags: ["marketplace", "order", "status"],
+    description: "Update order status.",
+    goal: "Track order fulfillment.",
+    context: "Order management."
   },
-  io: { input: ListProductsInputModel, output: ListProductsOutputModel },
-  policy: { auth: "anonymous" },
-  acceptance: {
-    scenarios: [
+  io: { input: UpdateOrderStatusInputModel, output: OrderModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
       {
-        key: "list-products-happy-path",
-        given: ["Products exist"],
-        when: ["User searches for products"],
-        then: ["List of products is returned"]
+        key: "marketplace.order.statusUpdated",
+        version: "1.0.0",
+        when: "Status changes",
+        payload: OrderModel
+      }
+    ],
+    audit: ["marketplace.order.statusUpdated"]
+  },
+  acceptance: {
+    scenarios: [
+      {
+        key: "update-status-happy-path",
+        given: ["Order exists"],
+        when: ["Seller updates order status"],
+        then: ["Status is updated", "OrderStatusUpdated event is emitted"]
       }
     ],
     examples: [
       {
-        key: "search-t-shirts",
-        input: { search: "t-shirt", limit: 20 },
-        output: { items: [], total: 50, hasMore: true }
+        key: "mark-shipped",
+        input: {
+          orderId: "order-789",
+          status: "shipped",
+          trackingNumber: "TRACK123"
+        },
+        output: { id: "order-789", status: "shipped" }
       }
     ]
   }
 });
+// src/payout/payout.enum.ts
+import { defineEnum as defineEnum2 } from "@contractspec/lib.schema";
+var PayoutStatusEnum = defineEnum2("PayoutStatus", [
+  "PENDING",
+  "PROCESSING",
+  "PAID",
+  "FAILED",
+  "CANCELLED"
+]);
 
-// src/product/product.event.ts
-import { ScalarTypeEnum as ScalarTypeEnum4, defineSchemaModel as defineSchemaModel4 } from "@contractspec/lib.schema";
+// src/payout/payout.event.ts
 import { defineEvent as defineEvent2 } from "@contractspec/lib.contracts-spec";
-var ProductCreatedPayload = defineSchemaModel4({
-  name: "ProductCreatedEventPayload",
+import { defineSchemaModel as defineSchemaModel3, ScalarTypeEnum as ScalarTypeEnum3 } from "@contractspec/lib.schema";
+var PayoutCreatedPayload = defineSchemaModel3({
+  name: "PayoutCreatedEventPayload",
+  fields: {
+    payoutId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    payoutNumber: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    netAmount: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    orderCount: { type: ScalarTypeEnum3.Int_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var PayoutPaidPayload = defineSchemaModel3({
+  name: "PayoutPaidEventPayload",
+  fields: {
+    payoutId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    payoutNumber: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum3.String_unsecure(), isOptional: false },
+    netAmount: { type: ScalarTypeEnum3.Float_unsecure(), isOptional: false },
+    paymentReference: {
+      type: ScalarTypeEnum3.String_unsecure(),
+      isOptional: true
+    },
+    timestamp: { type: ScalarTypeEnum3.DateTime(), isOptional: false }
+  }
+});
+var PayoutCreatedEvent = defineEvent2({
+  meta: {
+    key: "marketplace.payout.created",
+    version: "1.0.0",
+    description: "A payout has been created.",
+    stability: "experimental",
+    owners: ["@marketplace-team"],
+    tags: ["marketplace", "payout"]
+  },
+  payload: PayoutCreatedPayload
+});
+var PayoutPaidEvent = defineEvent2({
+  meta: {
+    key: "marketplace.payout.paid",
+    version: "1.0.0",
+    description: "A payout has been sent.",
+    stability: "experimental",
+    owners: ["@marketplace-team"],
+    tags: ["marketplace", "payout"]
+  },
+  payload: PayoutPaidPayload
+});
+
+// src/payout/payout.schema.ts
+import { defineSchemaModel as defineSchemaModel4, ScalarTypeEnum as ScalarTypeEnum4 } from "@contractspec/lib.schema";
+var PayoutModel = defineSchemaModel4({
+  name: "PayoutModel",
+  description: "A payout to seller",
   fields: {
-    productId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    id: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
+    payoutNumber: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
     storeId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    name: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    price: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: false },
+    status: { type: PayoutStatusEnum, isOptional: false },
+    grossAmount: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: false },
+    platformFees: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: false },
+    netAmount: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: false },
     currency: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum4.DateTime(), isOptional: false }
+    periodStart: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    periodEnd: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    orderCount: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum4.DateTime(), isOptional: false },
+    paidAt: { type: ScalarTypeEnum4.DateTime(), isOptional: true }
   }
 });
-var ProductPublishedPayload = defineSchemaModel4({
-  name: "ProductPublishedEventPayload",
+var ListPayoutsInputModel = defineSchemaModel4({
+  name: "ListPayoutsInput",
   fields: {
-    productId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
     storeId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum4.DateTime(), isOptional: false }
+    status: { type: PayoutStatusEnum, isOptional: true },
+    limit: {
+      type: ScalarTypeEnum4.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 20
+    },
+    offset: {
+      type: ScalarTypeEnum4.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 0
+    }
+  }
+});
+var ListPayoutsOutputModel = defineSchemaModel4({
+  name: "ListPayoutsOutput",
+  fields: {
+    payouts: { type: PayoutModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
+    totalPending: { type: ScalarTypeEnum4.Float_unsecure(), isOptional: false }
+  }
+});
+
+// src/payout/payout.operations.ts
+import { defineQuery } from "@contractspec/lib.contracts-spec/operations";
+var OWNERS2 = ["@example.marketplace"];
+var ListPayoutsContract = defineQuery({
+  meta: {
+    key: "marketplace.payout.list",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS2],
+    tags: ["marketplace", "payout", "list"],
+    description: "List payouts for a store.",
+    goal: "View payout history.",
+    context: "Seller dashboard."
+  },
+  io: { input: ListPayoutsInputModel, output: ListPayoutsOutputModel },
+  policy: { auth: "user" },
+  acceptance: {
+    scenarios: [
+      {
+        key: "list-payouts-happy-path",
+        given: ["Store has payout history"],
+        when: ["Seller lists payouts"],
+        then: ["List of payouts is returned"]
+      }
+    ],
+    examples: [
+      {
+        key: "list-recent",
+        input: { limit: 10, offset: 0 },
+        output: { items: [], total: 5, hasMore: false }
+      }
+    ]
+  }
+});
+// src/product/product.enum.ts
+import { defineEnum as defineEnum3 } from "@contractspec/lib.schema";
+var ProductStatusEnum = defineEnum3("ProductStatus", [
+  "DRAFT",
+  "PENDING_REVIEW",
+  "ACTIVE",
+  "OUT_OF_STOCK",
+  "DISCONTINUED",
+  "REJECTED"
+]);
+
+// src/product/product.event.ts
+import { defineEvent as defineEvent3 } from "@contractspec/lib.contracts-spec";
+import { defineSchemaModel as defineSchemaModel5, ScalarTypeEnum as ScalarTypeEnum5 } from "@contractspec/lib.schema";
+var ProductCreatedPayload = defineSchemaModel5({
+  name: "ProductCreatedEventPayload",
+  fields: {
+    productId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    price: { type: ScalarTypeEnum5.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum5.DateTime(), isOptional: false }
+  }
+});
+var ProductPublishedPayload = defineSchemaModel5({
+  name: "ProductPublishedEventPayload",
+  fields: {
+    productId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum5.DateTime(), isOptional: false }
   }
 });
-var InventoryUpdatedPayload = defineSchemaModel4({
+var InventoryUpdatedPayload = defineSchemaModel5({
   name: "InventoryUpdatedEventPayload",
   fields: {
-    productId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    variantId: { type: ScalarTypeEnum4.String_unsecure(), isOptional: true },
+    productId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    variantId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
     previousQuantity: {
-      type: ScalarTypeEnum4.Int_unsecure(),
+      type: ScalarTypeEnum5.Int_unsecure(),
       isOptional: false
     },
-    newQuantity: { type: ScalarTypeEnum4.Int_unsecure(), isOptional: false },
-    reason: { type: ScalarTypeEnum4.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum4.DateTime(), isOptional: false }
+    newQuantity: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
+    reason: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum5.DateTime(), isOptional: false }
   }
 });
-var ProductCreatedEvent = defineEvent2({
+var ProductCreatedEvent = defineEvent3({
   meta: {
     key: "marketplace.product.created",
     version: "1.0.0",
@@ -648,7 +793,7 @@ var ProductCreatedEvent = defineEvent2({
   },
   payload: ProductCreatedPayload
 });
-var ProductPublishedEvent = defineEvent2({
+var ProductPublishedEvent = defineEvent3({
   meta: {
     key: "marketplace.product.published",
     version: "1.0.0",
@@ -659,7 +804,7 @@ var ProductPublishedEvent = defineEvent2({
   },
   payload: ProductPublishedPayload
 });
-var InventoryUpdatedEvent = defineEvent2({
+var InventoryUpdatedEvent = defineEvent3({
   meta: {
     key: "marketplace.inventory.updated",
     version: "1.0.0",
@@ -670,523 +815,291 @@ var InventoryUpdatedEvent = defineEvent2({
   },
   payload: InventoryUpdatedPayload
 });
-// src/order/order.enum.ts
-import { defineEnum as defineEnum3 } from "@contractspec/lib.schema";
-var OrderStatusEnum = defineEnum3("OrderStatus", [
-  "PENDING",
-  "PAID",
-  "PROCESSING",
-  "SHIPPED",
-  "DELIVERED",
-  "COMPLETED",
-  "CANCELLED",
-  "REFUNDED",
-  "PARTIALLY_REFUNDED",
-  "DISPUTED"
-]);
 
-// src/order/order.schema.ts
-import { defineSchemaModel as defineSchemaModel5, ScalarTypeEnum as ScalarTypeEnum5 } from "@contractspec/lib.schema";
-var OrderItemModel = defineSchemaModel5({
-  name: "OrderItemModel",
+// src/product/product.schema.ts
+import { defineSchemaModel as defineSchemaModel6, ScalarTypeEnum as ScalarTypeEnum6 } from "@contractspec/lib.schema";
+var ProductModel = defineSchemaModel6({
+  name: "ProductModel",
+  description: "A product listing",
   fields: {
-    id: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    productId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    productName: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    unitPrice: { type: ScalarTypeEnum5.Float_unsecure(), isOptional: false },
-    quantity: { type: ScalarTypeEnum5.Int_unsecure(), isOptional: false },
-    subtotal: { type: ScalarTypeEnum5.Float_unsecure(), isOptional: false }
+    id: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    storeId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    slug: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    status: { type: ProductStatusEnum, isOptional: false },
+    price: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    quantity: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: false },
+    categoryId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    primaryImageId: {
+      type: ScalarTypeEnum6.String_unsecure(),
+      isOptional: true
+    },
+    averageRating: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: false },
+    totalSold: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
   }
 });
-var OrderModel = defineSchemaModel5({
-  name: "OrderModel",
-  description: "An order",
+var CreateProductInputModel = defineSchemaModel6({
+  name: "CreateProductInput",
   fields: {
-    id: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    orderNumber: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    buyerId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    storeId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    status: { type: OrderStatusEnum, isOptional: false },
-    subtotal: { type: ScalarTypeEnum5.Float_unsecure(), isOptional: false },
-    shippingTotal: { type: ScalarTypeEnum5.Float_unsecure(), isOptional: false },
-    taxTotal: { type: ScalarTypeEnum5.Float_unsecure(), isOptional: false },
-    total: { type: ScalarTypeEnum5.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    items: { type: OrderItemModel, isArray: true, isOptional: true },
-    createdAt: { type: ScalarTypeEnum5.DateTime(), isOptional: false }
+    storeId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum6.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    price: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: false },
+    currency: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    quantity: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: true },
+    categoryId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    sku: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true }
   }
 });
-var CreateOrderInputModel = defineSchemaModel5({
-  name: "CreateOrderInput",
+var ListProductsInputModel = defineSchemaModel6({
+  name: "ListProductsInput",
   fields: {
-    storeId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    items: {
-      type: ScalarTypeEnum5.JSON(),
-      isOptional: false,
-      description: "Array of {productId, variantId?, quantity}"
+    storeId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    categoryId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    status: { type: ProductStatusEnum, isOptional: true },
+    search: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
+    minPrice: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: true },
+    maxPrice: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: true },
+    limit: {
+      type: ScalarTypeEnum6.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 20
     },
-    shippingAddress: { type: ScalarTypeEnum5.JSON(), isOptional: true },
-    billingAddress: { type: ScalarTypeEnum5.JSON(), isOptional: true },
-    buyerNote: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true }
+    offset: {
+      type: ScalarTypeEnum6.Int_unsecure(),
+      isOptional: true,
+      defaultValue: 0
+    }
   }
 });
-var UpdateOrderStatusInputModel = defineSchemaModel5({
-  name: "UpdateOrderStatusInput",
+var ListProductsOutputModel = defineSchemaModel6({
+  name: "ListProductsOutput",
   fields: {
-    orderId: { type: ScalarTypeEnum5.String_unsecure(), isOptional: false },
-    status: { type: OrderStatusEnum, isOptional: false },
-    trackingNumber: {
-      type: ScalarTypeEnum5.String_unsecure(),
-      isOptional: true
-    },
-    trackingUrl: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true },
-    note: { type: ScalarTypeEnum5.String_unsecure(), isOptional: true }
+    products: { type: ProductModel, isArray: true, isOptional: false },
+    total: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: false }
   }
 });
 
-// src/order/order.operations.ts
-import { defineCommand as defineCommand3 } from "@contractspec/lib.contracts-spec/operations";
+// src/product/product.operations.ts
+import {
+  defineCommand as defineCommand2,
+  defineQuery as defineQuery2
+} from "@contractspec/lib.contracts-spec/operations";
 var OWNERS3 = ["@example.marketplace"];
-var CreateOrderContract = defineCommand3({
+var CreateProductContract = defineCommand2({
   meta: {
-    key: "marketplace.order.create",
+    key: "marketplace.product.create",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS3],
-    tags: ["marketplace", "order", "create"],
-    description: "Create a new order.",
-    goal: "Allow buyers to purchase products.",
-    context: "Checkout flow."
+    tags: ["marketplace", "product", "create"],
+    description: "Create a new product listing.",
+    goal: "Allow sellers to list products.",
+    context: "Product management."
   },
-  io: { input: CreateOrderInputModel, output: OrderModel },
+  io: { input: CreateProductInputModel, output: ProductModel },
   policy: { auth: "user" },
   sideEffects: {
     emits: [
       {
-        key: "marketplace.order.created",
+        key: "marketplace.product.created",
         version: "1.0.0",
-        when: "Order is created",
-        payload: OrderModel
+        when: "Product is created",
+        payload: ProductModel
       }
     ],
-    audit: ["marketplace.order.created"]
+    audit: ["marketplace.product.created"]
   },
   acceptance: {
     scenarios: [
       {
-        key: "create-order-happy-path",
-        given: ["User is authenticated"],
-        when: ["User creates order with valid items"],
-        then: ["Order is created", "OrderCreated event is emitted"]
+        key: "create-product-happy-path",
+        given: ["User is a seller"],
+        when: ["User creates a product listing"],
+        then: ["Product is created", "ProductCreated event is emitted"]
       }
     ],
     examples: [
       {
-        key: "create-basic-order",
+        key: "create-t-shirt",
         input: {
-          storeId: "store-123",
-          items: [{ productId: "prod-456", quantity: 1, unitPrice: 100 }]
+          title: "Classic T-Shirt",
+          price: 25,
+          stock: 100,
+          storeId: "store-123"
         },
-        output: { id: "order-789", status: "pending", total: 100 }
+        output: {
+          id: "prod-456",
+          title: "Classic T-Shirt",
+          status: "published"
+        }
       }
     ]
   }
 });
-var UpdateOrderStatusContract = defineCommand3({
+var ListProductsContract = defineQuery2({
   meta: {
-    key: "marketplace.order.updateStatus",
+    key: "marketplace.product.list",
     version: "1.0.0",
     stability: "stable",
     owners: [...OWNERS3],
-    tags: ["marketplace", "order", "status"],
-    description: "Update order status.",
-    goal: "Track order fulfillment.",
-    context: "Order management."
-  },
-  io: { input: UpdateOrderStatusInputModel, output: OrderModel },
-  policy: { auth: "user" },
-  sideEffects: {
-    emits: [
-      {
-        key: "marketplace.order.statusUpdated",
-        version: "1.0.0",
-        when: "Status changes",
-        payload: OrderModel
-      }
-    ],
-    audit: ["marketplace.order.statusUpdated"]
+    tags: ["marketplace", "product", "list"],
+    description: "List products with filters.",
+    goal: "Browse products on the marketplace.",
+    context: "Product catalog, search."
   },
+  io: { input: ListProductsInputModel, output: ListProductsOutputModel },
+  policy: { auth: "anonymous" },
   acceptance: {
     scenarios: [
       {
-        key: "update-status-happy-path",
-        given: ["Order exists"],
-        when: ["Seller updates order status"],
-        then: ["Status is updated", "OrderStatusUpdated event is emitted"]
+        key: "list-products-happy-path",
+        given: ["Products exist"],
+        when: ["User searches for products"],
+        then: ["List of products is returned"]
       }
     ],
     examples: [
       {
-        key: "mark-shipped",
-        input: {
-          orderId: "order-789",
-          status: "shipped",
-          trackingNumber: "TRACK123"
-        },
-        output: { id: "order-789", status: "shipped" }
+        key: "search-t-shirts",
+        input: { search: "t-shirt", limit: 20 },
+        output: { items: [], total: 50, hasMore: true }
       }
     ]
   }
 });
-
-// src/order/order.event.ts
-import { ScalarTypeEnum as ScalarTypeEnum6, defineSchemaModel as defineSchemaModel6 } from "@contractspec/lib.schema";
-import { defineEvent as defineEvent3 } from "@contractspec/lib.contracts-spec";
-var OrderCreatedPayload = defineSchemaModel6({
-  name: "OrderCreatedEventPayload",
-  fields: {
-    orderId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    orderNumber: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    buyerId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    storeId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    total: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    itemCount: { type: ScalarTypeEnum6.Int_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
-  }
-});
-var OrderPaidPayload = defineSchemaModel6({
-  name: "OrderPaidEventPayload",
-  fields: {
-    orderId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    orderNumber: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    total: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: false },
-    paymentMethod: {
-      type: ScalarTypeEnum6.String_unsecure(),
-      isOptional: false
-    },
-    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
-  }
-});
-var OrderStatusUpdatedPayload = defineSchemaModel6({
-  name: "OrderStatusUpdatedEventPayload",
-  fields: {
-    orderId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    orderNumber: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    previousStatus: {
-      type: ScalarTypeEnum6.String_unsecure(),
-      isOptional: false
-    },
-    newStatus: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    updatedBy: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
-  }
-});
-var OrderShippedPayload = defineSchemaModel6({
-  name: "OrderShippedEventPayload",
-  fields: {
-    orderId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    orderNumber: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    trackingNumber: {
-      type: ScalarTypeEnum6.String_unsecure(),
-      isOptional: true
-    },
-    trackingUrl: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    carrier: { type: ScalarTypeEnum6.String_unsecure(), isOptional: true },
-    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
-  }
-});
-var OrderCompletedPayload = defineSchemaModel6({
-  name: "OrderCompletedEventPayload",
-  fields: {
-    orderId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    orderNumber: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    buyerId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    storeId: { type: ScalarTypeEnum6.String_unsecure(), isOptional: false },
-    total: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: false },
-    sellerPayout: { type: ScalarTypeEnum6.Float_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum6.DateTime(), isOptional: false }
-  }
-});
-var OrderCreatedEvent = defineEvent3({
-  meta: {
-    key: "marketplace.order.created",
-    version: "1.0.0",
-    description: "A new order has been created.",
-    stability: "experimental",
-    owners: ["@marketplace-team"],
-    tags: ["marketplace", "order"]
-  },
-  payload: OrderCreatedPayload
-});
-var OrderPaidEvent = defineEvent3({
-  meta: {
-    key: "marketplace.order.paid",
-    version: "1.0.0",
-    description: "An order has been paid.",
-    stability: "experimental",
-    owners: ["@marketplace-team"],
-    tags: ["marketplace", "order"]
-  },
-  payload: OrderPaidPayload
-});
-var OrderStatusUpdatedEvent = defineEvent3({
-  meta: {
-    key: "marketplace.order.statusUpdated",
-    version: "1.0.0",
-    description: "An order status has been updated.",
-    stability: "experimental",
-    owners: ["@marketplace-team"],
-    tags: ["marketplace", "order"]
-  },
-  payload: OrderStatusUpdatedPayload
-});
-var OrderShippedEvent = defineEvent3({
-  meta: {
-    key: "marketplace.order.shipped",
-    version: "1.0.0",
-    description: "An order has been shipped.",
-    stability: "experimental",
-    owners: ["@marketplace-team"],
-    tags: ["marketplace", "order"]
-  },
-  payload: OrderShippedPayload
-});
-var OrderCompletedEvent = defineEvent3({
-  meta: {
-    key: "marketplace.order.completed",
-    version: "1.0.0",
-    description: "An order has been completed.",
-    stability: "experimental",
-    owners: ["@marketplace-team"],
-    tags: ["marketplace", "order"]
-  },
-  payload: OrderCompletedPayload
-});
-// src/payout/payout.enum.ts
+// src/review/review.enum.ts
 import { defineEnum as defineEnum4 } from "@contractspec/lib.schema";
-var PayoutStatusEnum = defineEnum4("PayoutStatus", [
+var ReviewStatusEnum = defineEnum4("ReviewStatus", [
   "PENDING",
-  "PROCESSING",
-  "PAID",
-  "FAILED",
-  "CANCELLED"
+  "APPROVED",
+  "REJECTED",
+  "FLAGGED"
 ]);
 
-// src/payout/payout.schema.ts
-import { defineSchemaModel as defineSchemaModel7, ScalarTypeEnum as ScalarTypeEnum7 } from "@contractspec/lib.schema";
-var PayoutModel = defineSchemaModel7({
-  name: "PayoutModel",
-  description: "A payout to seller",
-  fields: {
-    id: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    payoutNumber: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    storeId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    status: { type: PayoutStatusEnum, isOptional: false },
-    grossAmount: { type: ScalarTypeEnum7.Float_unsecure(), isOptional: false },
-    platformFees: { type: ScalarTypeEnum7.Float_unsecure(), isOptional: false },
-    netAmount: { type: ScalarTypeEnum7.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    periodStart: { type: ScalarTypeEnum7.DateTime(), isOptional: false },
-    periodEnd: { type: ScalarTypeEnum7.DateTime(), isOptional: false },
-    orderCount: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum7.DateTime(), isOptional: false },
-    paidAt: { type: ScalarTypeEnum7.DateTime(), isOptional: true }
-  }
-});
-var ListPayoutsInputModel = defineSchemaModel7({
-  name: "ListPayoutsInput",
-  fields: {
-    storeId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
-    status: { type: PayoutStatusEnum, isOptional: true },
-    limit: {
-      type: ScalarTypeEnum7.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 20
-    },
-    offset: {
-      type: ScalarTypeEnum7.Int_unsecure(),
-      isOptional: true,
-      defaultValue: 0
-    }
-  }
-});
-var ListPayoutsOutputModel = defineSchemaModel7({
-  name: "ListPayoutsOutput",
-  fields: {
-    payouts: { type: PayoutModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false },
-    totalPending: { type: ScalarTypeEnum7.Float_unsecure(), isOptional: false }
-  }
-});
-
-// src/payout/payout.operations.ts
-import { defineQuery as defineQuery2 } from "@contractspec/lib.contracts-spec/operations";
-var OWNERS4 = ["@example.marketplace"];
-var ListPayoutsContract = defineQuery2({
-  meta: {
-    key: "marketplace.payout.list",
-    version: "1.0.0",
-    stability: "stable",
-    owners: [...OWNERS4],
-    tags: ["marketplace", "payout", "list"],
-    description: "List payouts for a store.",
-    goal: "View payout history.",
-    context: "Seller dashboard."
-  },
-  io: { input: ListPayoutsInputModel, output: ListPayoutsOutputModel },
-  policy: { auth: "user" },
-  acceptance: {
-    scenarios: [
-      {
-        key: "list-payouts-happy-path",
-        given: ["Store has payout history"],
-        when: ["Seller lists payouts"],
-        then: ["List of payouts is returned"]
-      }
-    ],
-    examples: [
-      {
-        key: "list-recent",
-        input: { limit: 10, offset: 0 },
-        output: { items: [], total: 5, hasMore: false }
-      }
-    ]
-  }
-});
-
-// src/payout/payout.event.ts
-import { ScalarTypeEnum as ScalarTypeEnum8, defineSchemaModel as defineSchemaModel8 } from "@contractspec/lib.schema";
+// src/review/review.event.ts
 import { defineEvent as defineEvent4 } from "@contractspec/lib.contracts-spec";
-var PayoutCreatedPayload = defineSchemaModel8({
-  name: "PayoutCreatedEventPayload",
+import { defineSchemaModel as defineSchemaModel7, ScalarTypeEnum as ScalarTypeEnum7 } from "@contractspec/lib.schema";
+var ReviewCreatedPayload = defineSchemaModel7({
+  name: "ReviewCreatedEventPayload",
   fields: {
-    payoutId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
-    payoutNumber: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
-    storeId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
-    netAmount: { type: ScalarTypeEnum8.Float_unsecure(), isOptional: false },
-    currency: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
-    orderCount: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum8.DateTime(), isOptional: false }
+    reviewId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    productId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    storeId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: true },
+    authorId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    rating: { type: ScalarTypeEnum7.Int_unsecure(), isOptional: false },
+    isVerifiedPurchase: { type: ScalarTypeEnum7.Boolean(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum7.DateTime(), isOptional: false }
   }
 });
-var PayoutPaidPayload = defineSchemaModel8({
-  name: "PayoutPaidEventPayload",
+var ReviewRespondedPayload = defineSchemaModel7({
+  name: "ReviewRespondedEventPayload",
   fields: {
-    payoutId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
-    payoutNumber: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
-    storeId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
-    netAmount: { type: ScalarTypeEnum8.Float_unsecure(), isOptional: false },
-    paymentReference: {
-      type: ScalarTypeEnum8.String_unsecure(),
-      isOptional: true
-    },
-    timestamp: { type: ScalarTypeEnum8.DateTime(), isOptional: false }
+    reviewId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    responseId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    authorId: { type: ScalarTypeEnum7.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum7.DateTime(), isOptional: false }
   }
 });
-var PayoutCreatedEvent = defineEvent4({
+var ReviewCreatedEvent = defineEvent4({
   meta: {
-    key: "marketplace.payout.created",
+    key: "marketplace.review.created",
     version: "1.0.0",
-    description: "A payout has been created.",
+    description: "A review has been created.",
     stability: "experimental",
     owners: ["@marketplace-team"],
-    tags: ["marketplace", "payout"]
+    tags: ["marketplace", "review"]
   },
-  payload: PayoutCreatedPayload
+  payload: ReviewCreatedPayload
 });
-var PayoutPaidEvent = defineEvent4({
+var ReviewRespondedEvent = defineEvent4({
   meta: {
-    key: "marketplace.payout.paid",
+    key: "marketplace.review.responded",
     version: "1.0.0",
-    description: "A payout has been sent.",
+    description: "A seller has responded to a review.",
     stability: "experimental",
     owners: ["@marketplace-team"],
-    tags: ["marketplace", "payout"]
+    tags: ["marketplace", "review"]
   },
-  payload: PayoutPaidPayload
+  payload: ReviewRespondedPayload
 });
-// src/review/review.enum.ts
-import { defineEnum as defineEnum5 } from "@contractspec/lib.schema";
-var ReviewStatusEnum = defineEnum5("ReviewStatus", [
-  "PENDING",
-  "APPROVED",
-  "REJECTED",
-  "FLAGGED"
-]);
 
 // src/review/review.schema.ts
-import { defineSchemaModel as defineSchemaModel9, ScalarTypeEnum as ScalarTypeEnum9 } from "@contractspec/lib.schema";
-var ReviewModel = defineSchemaModel9({
+import { defineSchemaModel as defineSchemaModel8, ScalarTypeEnum as ScalarTypeEnum8 } from "@contractspec/lib.schema";
+var ReviewModel = defineSchemaModel8({
   name: "ReviewModel",
   description: "A customer review",
   fields: {
-    id: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    productId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    storeId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    authorId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
-    rating: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: false },
-    title: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    content: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+    id: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    productId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    storeId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    authorId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: false },
+    rating: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
+    title: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    content: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
     status: { type: ReviewStatusEnum, isOptional: false },
-    isVerifiedPurchase: { type: ScalarTypeEnum9.Boolean(), isOptional: false },
-    helpfulCount: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: false },
-    hasResponse: { type: ScalarTypeEnum9.Boolean(), isOptional: false },
-    createdAt: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
+    isVerifiedPurchase: { type: ScalarTypeEnum8.Boolean(), isOptional: false },
+    helpfulCount: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
+    hasResponse: { type: ScalarTypeEnum8.Boolean(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum8.DateTime(), isOptional: false }
   }
 });
-var CreateReviewInputModel = defineSchemaModel9({
+var CreateReviewInputModel = defineSchemaModel8({
   name: "CreateReviewInput",
   fields: {
-    productId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    storeId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    orderId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    rating: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: false },
-    title: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    content: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true }
+    productId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    storeId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    orderId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    rating: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
+    title: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    content: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true }
   }
 });
-var ListReviewsInputModel = defineSchemaModel9({
+var ListReviewsInputModel = defineSchemaModel8({
   name: "ListReviewsInput",
   fields: {
-    productId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
-    storeId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+    productId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
+    storeId: { type: ScalarTypeEnum8.String_unsecure(), isOptional: true },
     status: { type: ReviewStatusEnum, isOptional: true },
-    minRating: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: true },
+    minRating: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: true },
     limit: {
-      type: ScalarTypeEnum9.Int_unsecure(),
+      type: ScalarTypeEnum8.Int_unsecure(),
       isOptional: true,
       defaultValue: 20
     },
     offset: {
-      type: ScalarTypeEnum9.Int_unsecure(),
+      type: ScalarTypeEnum8.Int_unsecure(),
       isOptional: true,
       defaultValue: 0
     }
   }
 });
-var ListReviewsOutputModel = defineSchemaModel9({
+var ListReviewsOutputModel = defineSchemaModel8({
   name: "ListReviewsOutput",
   fields: {
     reviews: { type: ReviewModel, isArray: true, isOptional: false },
-    total: { type: ScalarTypeEnum9.Int_unsecure(), isOptional: false },
-    averageRating: { type: ScalarTypeEnum9.Float_unsecure(), isOptional: false },
-    ratingDistribution: { type: ScalarTypeEnum9.JSON(), isOptional: false }
+    total: { type: ScalarTypeEnum8.Int_unsecure(), isOptional: false },
+    averageRating: { type: ScalarTypeEnum8.Float_unsecure(), isOptional: false },
+    ratingDistribution: { type: ScalarTypeEnum8.JSON(), isOptional: false }
   }
 });
 
 // src/review/review.operations.ts
 import {
-  defineCommand as defineCommand4,
+  defineCommand as defineCommand3,
   defineQuery as defineQuery3
 } from "@contractspec/lib.contracts-spec/operations";
-var OWNERS5 = ["@example.marketplace"];
-var CreateReviewContract = defineCommand4({
+var OWNERS4 = ["@example.marketplace"];
+var CreateReviewContract = defineCommand3({
   meta: {
     key: "marketplace.review.create",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS5],
+    owners: [...OWNERS4],
     tags: ["marketplace", "review", "create"],
     description: "Create a product/store review.",
     goal: "Allow buyers to leave feedback.",
@@ -1228,7 +1141,7 @@ var ListReviewsContract = defineQuery3({
     key: "marketplace.review.list",
     version: "1.0.0",
     stability: "stable",
-    owners: [...OWNERS5],
+    owners: [...OWNERS4],
     tags: ["marketplace", "review", "list"],
     description: "List reviews with filters.",
     goal: "Display product/store reviews.",
@@ -1254,299 +1167,143 @@ var ListReviewsContract = defineQuery3({
     ]
   }
 });
-
-// src/review/review.event.ts
-import { ScalarTypeEnum as ScalarTypeEnum10, defineSchemaModel as defineSchemaModel10 } from "@contractspec/lib.schema";
-import { defineEvent as defineEvent5 } from "@contractspec/lib.contracts-spec";
-var ReviewCreatedPayload = defineSchemaModel10({
-  name: "ReviewCreatedEventPayload",
+// src/store/store.enum.ts
+import { defineEnum as defineEnum5 } from "@contractspec/lib.schema";
+var StoreStatusEnum = defineEnum5("StoreStatus", [
+  "PENDING",
+  "ACTIVE",
+  "SUSPENDED",
+  "CLOSED"
+]);
+
+// src/store/store.event.ts
+import { defineEvent as defineEvent5 } from "@contractspec/lib.contracts-spec";
+import { defineSchemaModel as defineSchemaModel9, ScalarTypeEnum as ScalarTypeEnum9 } from "@contractspec/lib.schema";
+var StoreCreatedPayload = defineSchemaModel9({
+  name: "StoreCreatedEventPayload",
   fields: {
-    reviewId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
-    productId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: true },
-    storeId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: true },
-    authorId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
-    rating: { type: ScalarTypeEnum10.Int_unsecure(), isOptional: false },
-    isVerifiedPurchase: { type: ScalarTypeEnum10.Boolean(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum10.DateTime(), isOptional: false }
+    storeId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    slug: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    ownerId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
   }
 });
-var ReviewRespondedPayload = defineSchemaModel10({
-  name: "ReviewRespondedEventPayload",
+var StoreStatusChangedPayload = defineSchemaModel9({
+  name: "StoreStatusChangedEventPayload",
   fields: {
-    reviewId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
-    responseId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
-    authorId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
-    timestamp: { type: ScalarTypeEnum10.DateTime(), isOptional: false }
+    storeId: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    previousStatus: {
+      type: ScalarTypeEnum9.String_unsecure(),
+      isOptional: false
+    },
+    newStatus: { type: ScalarTypeEnum9.String_unsecure(), isOptional: false },
+    reason: { type: ScalarTypeEnum9.String_unsecure(), isOptional: true },
+    timestamp: { type: ScalarTypeEnum9.DateTime(), isOptional: false }
   }
 });
-var ReviewCreatedEvent = defineEvent5({
+var StoreCreatedEvent = defineEvent5({
   meta: {
-    key: "marketplace.review.created",
+    key: "marketplace.store.created",
     version: "1.0.0",
-    description: "A review has been created.",
+    description: "A new seller store has been created.",
     stability: "experimental",
     owners: ["@marketplace-team"],
-    tags: ["marketplace", "review"]
+    tags: ["marketplace", "store"]
   },
-  payload: ReviewCreatedPayload
+  payload: StoreCreatedPayload
 });
-var ReviewRespondedEvent = defineEvent5({
+var StoreStatusChangedEvent = defineEvent5({
   meta: {
-    key: "marketplace.review.responded",
+    key: "marketplace.store.statusChanged",
     version: "1.0.0",
-    description: "A seller has responded to a review.",
+    description: "A store status has changed.",
     stability: "experimental",
     owners: ["@marketplace-team"],
-    tags: ["marketplace", "review"]
+    tags: ["marketplace", "store"]
   },
-  payload: ReviewRespondedPayload
+  payload: StoreStatusChangedPayload
 });
-// src/ui/renderers/marketplace.markdown.ts
-var mockStores = [
-  {
-    id: "store-1",
-    name: "Tech Gadgets Store",
-    status: "ACTIVE",
-    productCount: 45,
-    rating: 4.8
-  },
-  {
-    id: "store-2",
-    name: "Home & Garden",
-    status: "ACTIVE",
-    productCount: 120,
-    rating: 4.5
-  },
-  {
-    id: "store-3",
-    name: "Fashion Boutique",
-    status: "PENDING",
-    productCount: 0,
-    rating: 0
+
+// src/store/store.schema.ts
+import { defineSchemaModel as defineSchemaModel10, ScalarTypeEnum as ScalarTypeEnum10 } from "@contractspec/lib.schema";
+var StoreModel = defineSchemaModel10({
+  name: "StoreModel",
+  description: "A seller store",
+  fields: {
+    id: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
+    name: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
+    slug: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
+    description: { type: ScalarTypeEnum10.String_unsecure(), isOptional: true },
+    status: { type: StoreStatusEnum, isOptional: false },
+    ownerId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: false },
+    logoFileId: { type: ScalarTypeEnum10.String_unsecure(), isOptional: true },
+    isVerified: { type: ScalarTypeEnum10.Boolean(), isOptional: false },
+    totalProducts: { type: ScalarTypeEnum10.Int_unsecure(), isOptional: false },
+    averageRating: { type: ScalarTypeEnum10.Float_unsecure(), isOptional: false },
+    createdAt: { type: ScalarTypeEnum10.DateTime(), isOptional: false }
   }
-];
-var mockProducts = [
-  {
-    id: "prod-1",
-    name: "Wireless Earbuds",
-    storeId: "store-1",
-    price: 79.99,
-    currency: "USD",
-    status: "ACTIVE",
-    stock: 150
-  },
-  {
-    id: "prod-2",
-    name: "Smart Watch",
-    storeId: "store-1",
-    price: 249.99,
-    currency: "USD",
-    status: "ACTIVE",
-    stock: 50
-  },
-  {
-    id: "prod-3",
-    name: "Garden Tools Set",
-    storeId: "store-2",
-    price: 89.99,
-    currency: "USD",
-    status: "ACTIVE",
-    stock: 30
-  },
-  {
-    id: "prod-4",
-    name: "Indoor Plant Kit",
-    storeId: "store-2",
-    price: 45.99,
-    currency: "USD",
-    status: "ACTIVE",
-    stock: 75
-  },
-  {
-    id: "prod-5",
-    name: "LED Desk Lamp",
-    storeId: "store-1",
-    price: 34.99,
-    currency: "USD",
-    status: "OUT_OF_STOCK",
-    stock: 0
+});
+var CreateStoreInputModel = defineSchemaModel10({
+  name: "CreateStoreInput",
+  fields: {
+    name: { type: ScalarTypeEnum10.NonEmptyString(), isOptional: false },
+    slug: { type: ScalarTypeEnum10.NonEmptyString(), isOptional: false },
+    description: { type: ScalarTypeEnum10.String_unsecure(), isOptional: true },
+    email: { type: ScalarTypeEnum10.EmailAddress(), isOptional: true },
+    country: { type: ScalarTypeEnum10.String_unsecure(), isOptional: true },
+    currency: { type: ScalarTypeEnum10.String_unsecure(), isOptional: true }
   }
-];
-var mockOrders = [
-  {
-    id: "ord-1",
-    storeId: "store-1",
-    customerId: "cust-1",
-    total: 329.98,
-    currency: "USD",
-    status: "DELIVERED",
-    itemCount: 2,
-    createdAt: "2024-01-15T10:00:00Z"
-  },
-  {
-    id: "ord-2",
-    storeId: "store-2",
-    customerId: "cust-2",
-    total: 135.98,
-    currency: "USD",
-    status: "SHIPPED",
-    itemCount: 2,
-    createdAt: "2024-01-14T14:00:00Z"
+});
+
+// src/store/store.operations.ts
+import { defineCommand as defineCommand4 } from "@contractspec/lib.contracts-spec/operations";
+var OWNERS5 = ["@example.marketplace"];
+var CreateStoreContract = defineCommand4({
+  meta: {
+    key: "marketplace.store.create",
+    version: "1.0.0",
+    stability: "stable",
+    owners: [...OWNERS5],
+    tags: ["marketplace", "store", "create"],
+    description: "Create a new seller store.",
+    goal: "Allow users to become sellers on the marketplace.",
+    context: "Seller onboarding."
   },
-  {
-    id: "ord-3",
-    storeId: "store-1",
-    customerId: "cust-3",
-    total: 79.99,
-    currency: "USD",
-    status: "PROCESSING",
-    itemCount: 1,
-    createdAt: "2024-01-16T08:00:00Z"
+  io: { input: CreateStoreInputModel, output: StoreModel },
+  policy: { auth: "user" },
+  sideEffects: {
+    emits: [
+      {
+        key: "marketplace.store.created",
+        version: "1.0.0",
+        when: "Store is created",
+        payload: StoreModel
+      }
+    ],
+    audit: ["marketplace.store.created"]
   },
-  {
-    id: "ord-4",
-    storeId: "store-2",
-    customerId: "cust-4",
-    total: 45.99,
-    currency: "USD",
-    status: "PENDING",
-    itemCount: 1,
-    createdAt: "2024-01-16T12:00:00Z"
-  }
-];
-function formatCurrency(value, currency = "USD") {
-  return new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency,
-    minimumFractionDigits: 2
-  }).format(value);
-}
-var marketplaceDashboardMarkdownRenderer = {
-  target: "markdown",
-  render: async (desc) => {
-    if (desc.source.type !== "component" || desc.source.componentKey !== "MarketplaceDashboard") {
-      throw new Error("marketplaceDashboardMarkdownRenderer: not MarketplaceDashboard");
-    }
-    const stores = mockStores;
-    const products = mockProducts;
-    const orders = mockOrders;
-    const activeStores = stores.filter((s) => s.status === "ACTIVE");
-    const activeProducts = products.filter((p) => p.status === "ACTIVE");
-    const totalRevenue = orders.reduce((sum, o) => sum + o.total, 0);
-    const pendingOrders = orders.filter((o) => o.status === "PENDING" || o.status === "PROCESSING");
-    const lines = [
-      "# Marketplace Dashboard",
-      "",
-      "> Two-sided marketplace overview",
-      "",
-      "## Summary",
-      "",
-      "| Metric | Value |",
-      "|--------|-------|",
-      `| Active Stores | ${activeStores.length} |`,
-      `| Active Products | ${activeProducts.length} |`,
-      `| Total Orders | ${orders.length} |`,
-      `| Total Revenue | ${formatCurrency(totalRevenue)} |`,
-      `| Pending Orders | ${pendingOrders.length} |`,
-      "",
-      "## Top Stores",
-      "",
-      "| Store | Products | Rating | Status |",
-      "|-------|----------|--------|--------|"
-    ];
-    for (const store of stores.slice(0, 5)) {
-      lines.push(`| ${store.name} | ${store.productCount} | ⭐ ${store.rating || "N/A"} | ${store.status} |`);
-    }
-    lines.push("");
-    lines.push("## Recent Orders");
-    lines.push("");
-    lines.push("| Order | Items | Total | Status | Date |");
-    lines.push("|-------|-------|-------|--------|------|");
-    for (const order of orders.slice(0, 10)) {
-      const date = new Date(order.createdAt).toLocaleDateString();
-      lines.push(`| ${order.id} | ${order.itemCount} | ${formatCurrency(order.total, order.currency)} | ${order.status} | ${date} |`);
-    }
-    return {
-      mimeType: "text/markdown",
-      body: lines.join(`
-`)
-    };
-  }
-};
-var productCatalogMarkdownRenderer = {
-  target: "markdown",
-  render: async (desc) => {
-    if (desc.source.type !== "component" || desc.source.componentKey !== "ProductCatalog") {
-      throw new Error("productCatalogMarkdownRenderer: not ProductCatalog");
-    }
-    const products = mockProducts;
-    const stores = mockStores;
-    const lines = [
-      "# Product Catalog",
-      "",
-      "> Browse products across all marketplace stores",
-      ""
-    ];
-    for (const store of stores.filter((s) => s.status === "ACTIVE")) {
-      const storeProducts = products.filter((p) => p.storeId === store.id);
-      if (storeProducts.length === 0)
-        continue;
-      lines.push(`## ${store.name}`);
-      lines.push("");
-      lines.push("| Product | Price | Stock | Status |");
-      lines.push("|---------|-------|-------|--------|");
-      for (const product of storeProducts) {
-        const stockStatus = product.stock > 0 ? `${product.stock} in stock` : "Out of stock";
-        lines.push(`| ${product.name} | ${formatCurrency(product.price, product.currency)} | ${stockStatus} | ${product.status} |`);
+  acceptance: {
+    scenarios: [
+      {
+        key: "create-store-happy-path",
+        given: ["User is authenticated"],
+        when: ["User creates a new store"],
+        then: ["Store is created", "StoreCreated event is emitted"]
       }
-      lines.push("");
-    }
-    return {
-      mimeType: "text/markdown",
-      body: lines.join(`
-`)
-    };
-  }
-};
-var orderListMarkdownRenderer = {
-  target: "markdown",
-  render: async (desc) => {
-    if (desc.source.type !== "component" || desc.source.componentKey !== "OrderList") {
-      throw new Error("orderListMarkdownRenderer: not OrderList");
-    }
-    const orders = mockOrders;
-    const stores = mockStores;
-    const lines = [
-      "# Orders",
-      "",
-      "> Manage marketplace orders",
-      "",
-      "| Order ID | Store | Items | Total | Status | Created |",
-      "|----------|-------|-------|-------|--------|---------|"
-    ];
-    for (const order of orders) {
-      const store = stores.find((s) => s.id === order.storeId);
-      const date = new Date(order.createdAt).toLocaleDateString();
-      lines.push(`| ${order.id} | ${store?.name ?? "Unknown"} | ${order.itemCount} | ${formatCurrency(order.total, order.currency)} | ${order.status} | ${date} |`);
-    }
-    lines.push("");
-    lines.push("## Order Status Legend");
-    lines.push("");
-    lines.push("- **PENDING**: Awaiting payment confirmation");
-    lines.push("- **PROCESSING**: Being prepared");
-    lines.push("- **SHIPPED**: In transit");
-    lines.push("- **DELIVERED**: Order completed");
-    lines.push("- **CANCELLED**: Order cancelled");
-    return {
-      mimeType: "text/markdown",
-      body: lines.join(`
-`)
-    };
+    ],
+    examples: [
+      {
+        key: "create-fashion-store",
+        input: { name: "Fashion Boutique", category: "clothing" },
+        output: { id: "store-123", status: "active" }
+      }
+    ]
   }
-};
+});
 // src/ui/hooks/useMarketplaceData.ts
-import { useCallback, useEffect, useState } from "react";
 import { useTemplateRuntime } from "@contractspec/lib.example-shared-ui";
+import { useCallback, useEffect, useState } from "react";
 "use client";
 function useMarketplaceData(projectId = "local-project") {
   const { handlers } = useTemplateRuntime();
@@ -1598,8 +1355,10 @@ function useMarketplaceData(projectId = "local-project") {
   };
 }
 
+// src/ui/hooks/index.ts
+"use client";
+
 // src/ui/MarketplaceDashboard.tsx
-import { useState as useState2 } from "react";
 import {
   Button,
   ErrorState,
@@ -1607,6 +1366,7 @@ import {
   StatCard,
   StatCardGroup
 } from "@contractspec/lib.design-system";
+import { useState as useState2 } from "react";
 import { jsxDEV } from "react/jsx-dev-runtime";
 "use client";
 var STATUS_COLORS = {
@@ -1622,7 +1382,7 @@ var STATUS_COLORS = {
   DELIVERED: "bg-green-100 text-green-700 dark:bg-green-900/30 dark:text-green-400",
   CANCELLED: "bg-red-100 text-red-700 dark:bg-red-900/30 dark:text-red-400"
 };
-function formatCurrency2(value, currency = "USD") {
+function formatCurrency(value, currency = "USD") {
   return new Intl.NumberFormat("en-US", {
     style: "currency",
     currency,
@@ -1658,7 +1418,7 @@ function MarketplaceDashboard() {
         className: "flex items-center justify-between",
         children: [
           /* @__PURE__ */ jsxDEV("h2", {
-            className: "text-2xl font-bold",
+            className: "font-bold text-2xl",
             children: "Marketplace"
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV(Button, {
@@ -1692,20 +1452,20 @@ function MarketplaceDashboard() {
           }, undefined, false, undefined, this),
           /* @__PURE__ */ jsxDEV(StatCard, {
             label: "Revenue",
-            value: formatCurrency2(stats.totalRevenue),
+            value: formatCurrency(stats.totalRevenue),
             hint: "total"
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
       /* @__PURE__ */ jsxDEV("nav", {
-        className: "bg-muted flex gap-1 rounded-lg p-1",
+        className: "flex gap-1 rounded-lg bg-muted p-1",
         role: "tablist",
         children: tabs.map((tab) => /* @__PURE__ */ jsxDEV(Button, {
           type: "button",
           role: "tab",
           "aria-selected": activeTab === tab.id,
           onClick: () => setActiveTab(tab.id),
-          className: `flex flex-1 items-center justify-center gap-2 rounded-md px-4 py-2 text-sm font-medium transition-colors ${activeTab === tab.id ? "bg-background text-foreground shadow-sm" : "text-muted-foreground hover:text-foreground"}`,
+          className: `flex flex-1 items-center justify-center gap-2 rounded-md px-4 py-2 font-medium text-sm transition-colors ${activeTab === tab.id ? "bg-background text-foreground shadow-sm" : "text-muted-foreground hover:text-foreground"}`,
           children: [
             /* @__PURE__ */ jsxDEV("span", {
               children: tab.icon
@@ -1719,35 +1479,35 @@ function MarketplaceDashboard() {
         role: "tabpanel",
         children: [
           activeTab === "stores" && /* @__PURE__ */ jsxDEV("div", {
-            className: "border-border rounded-lg border",
+            className: "rounded-lg border border-border",
             children: /* @__PURE__ */ jsxDEV("table", {
               className: "w-full",
               children: [
                 /* @__PURE__ */ jsxDEV("thead", {
-                  className: "border-border bg-muted/30 border-b",
+                  className: "border-border border-b bg-muted/30",
                   children: /* @__PURE__ */ jsxDEV("tr", {
                     children: [
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Store"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Status"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Rating"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Reviews"
                       }, undefined, false, undefined, this)
                     ]
                   }, undefined, true, undefined, this)
                 }, undefined, false, undefined, this),
                 /* @__PURE__ */ jsxDEV("tbody", {
-                  className: "divide-border divide-y",
+                  className: "divide-y divide-border",
                   children: [
                     stores.map((store) => /* @__PURE__ */ jsxDEV("tr", {
                       className: "hover:bg-muted/50",
@@ -1768,7 +1528,7 @@ function MarketplaceDashboard() {
                         /* @__PURE__ */ jsxDEV("td", {
                           className: "px-4 py-3",
                           children: /* @__PURE__ */ jsxDEV("span", {
-                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[store.status] ?? ""}`,
+                            className: `inline-flex rounded-full px-2 py-0.5 font-medium text-xs ${STATUS_COLORS[store.status] ?? ""}`,
                             children: store.status
                           }, undefined, false, undefined, this)
                         }, undefined, false, undefined, this),
@@ -1783,7 +1543,7 @@ function MarketplaceDashboard() {
                           }, undefined, true, undefined, this)
                         }, undefined, false, undefined, this),
                         /* @__PURE__ */ jsxDEV("td", {
-                          className: "text-muted-foreground px-4 py-3 text-sm",
+                          className: "px-4 py-3 text-muted-foreground text-sm",
                           children: [
                             store.reviewCount,
                             " reviews"
@@ -1794,7 +1554,7 @@ function MarketplaceDashboard() {
                     stores.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
                       children: /* @__PURE__ */ jsxDEV("td", {
                         colSpan: 4,
-                        className: "text-muted-foreground px-4 py-8 text-center",
+                        className: "px-4 py-8 text-center text-muted-foreground",
                         children: "No stores found"
                       }, undefined, false, undefined, this)
                     }, undefined, false, undefined, this)
@@ -1804,35 +1564,35 @@ function MarketplaceDashboard() {
             }, undefined, true, undefined, this)
           }, undefined, false, undefined, this),
           activeTab === "products" && /* @__PURE__ */ jsxDEV("div", {
-            className: "border-border rounded-lg border",
+            className: "rounded-lg border border-border",
             children: /* @__PURE__ */ jsxDEV("table", {
               className: "w-full",
               children: [
                 /* @__PURE__ */ jsxDEV("thead", {
-                  className: "border-border bg-muted/30 border-b",
+                  className: "border-border border-b bg-muted/30",
                   children: /* @__PURE__ */ jsxDEV("tr", {
                     children: [
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Product"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Price"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Stock"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Status"
                       }, undefined, false, undefined, this)
                     ]
                   }, undefined, true, undefined, this)
                 }, undefined, false, undefined, this),
                 /* @__PURE__ */ jsxDEV("tbody", {
-                  className: "divide-border divide-y",
+                  className: "divide-y divide-border",
                   children: [
                     products.map((product) => /* @__PURE__ */ jsxDEV("tr", {
                       className: "hover:bg-muted/50",
@@ -1852,7 +1612,7 @@ function MarketplaceDashboard() {
                         }, undefined, true, undefined, this),
                         /* @__PURE__ */ jsxDEV("td", {
                           className: "px-4 py-3 font-mono",
-                          children: formatCurrency2(product.price, product.currency)
+                          children: formatCurrency(product.price, product.currency)
                         }, undefined, false, undefined, this),
                         /* @__PURE__ */ jsxDEV("td", {
                           className: "px-4 py-3",
@@ -1861,7 +1621,7 @@ function MarketplaceDashboard() {
                         /* @__PURE__ */ jsxDEV("td", {
                           className: "px-4 py-3",
                           children: /* @__PURE__ */ jsxDEV("span", {
-                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[product.status] ?? ""}`,
+                            className: `inline-flex rounded-full px-2 py-0.5 font-medium text-xs ${STATUS_COLORS[product.status] ?? ""}`,
                             children: product.status
                           }, undefined, false, undefined, this)
                         }, undefined, false, undefined, this)
@@ -1870,7 +1630,7 @@ function MarketplaceDashboard() {
                     products.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
                       children: /* @__PURE__ */ jsxDEV("td", {
                         colSpan: 4,
-                        className: "text-muted-foreground px-4 py-8 text-center",
+                        className: "px-4 py-8 text-center text-muted-foreground",
                         children: "No products found"
                       }, undefined, false, undefined, this)
                     }, undefined, false, undefined, this)
@@ -1880,39 +1640,39 @@ function MarketplaceDashboard() {
             }, undefined, true, undefined, this)
           }, undefined, false, undefined, this),
           activeTab === "orders" && /* @__PURE__ */ jsxDEV("div", {
-            className: "border-border rounded-lg border",
+            className: "rounded-lg border border-border",
             children: /* @__PURE__ */ jsxDEV("table", {
               className: "w-full",
               children: [
                 /* @__PURE__ */ jsxDEV("thead", {
-                  className: "border-border bg-muted/30 border-b",
+                  className: "border-border border-b bg-muted/30",
                   children: /* @__PURE__ */ jsxDEV("tr", {
                     children: [
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Order ID"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Customer"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Total"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Status"
                       }, undefined, false, undefined, this),
                       /* @__PURE__ */ jsxDEV("th", {
-                        className: "px-4 py-3 text-left text-sm font-medium",
+                        className: "px-4 py-3 text-left font-medium text-sm",
                         children: "Date"
                       }, undefined, false, undefined, this)
                     ]
                   }, undefined, true, undefined, this)
                 }, undefined, false, undefined, this),
                 /* @__PURE__ */ jsxDEV("tbody", {
-                  className: "divide-border divide-y",
+                  className: "divide-y divide-border",
                   children: [
                     orders.map((order) => /* @__PURE__ */ jsxDEV("tr", {
                       className: "hover:bg-muted/50",
@@ -1927,17 +1687,17 @@ function MarketplaceDashboard() {
                         }, undefined, false, undefined, this),
                         /* @__PURE__ */ jsxDEV("td", {
                           className: "px-4 py-3 font-mono",
-                          children: formatCurrency2(order.total, order.currency)
+                          children: formatCurrency(order.total, order.currency)
                         }, undefined, false, undefined, this),
                         /* @__PURE__ */ jsxDEV("td", {
                           className: "px-4 py-3",
                           children: /* @__PURE__ */ jsxDEV("span", {
-                            className: `inline-flex rounded-full px-2 py-0.5 text-xs font-medium ${STATUS_COLORS[order.status] ?? ""}`,
+                            className: `inline-flex rounded-full px-2 py-0.5 font-medium text-xs ${STATUS_COLORS[order.status] ?? ""}`,
                             children: order.status
                           }, undefined, false, undefined, this)
                         }, undefined, false, undefined, this),
                         /* @__PURE__ */ jsxDEV("td", {
-                          className: "text-muted-foreground px-4 py-3 text-sm",
+                          className: "px-4 py-3 text-muted-foreground text-sm",
                           children: order.createdAt.toLocaleDateString()
                         }, undefined, false, undefined, this)
                       ]
@@ -1945,7 +1705,7 @@ function MarketplaceDashboard() {
                     orders.length === 0 && /* @__PURE__ */ jsxDEV("tr", {
                       children: /* @__PURE__ */ jsxDEV("td", {
                         colSpan: 5,
-                        className: "text-muted-foreground px-4 py-8 text-center",
+                        className: "px-4 py-8 text-center text-muted-foreground",
                         children: "No orders found"
                       }, undefined, false, undefined, this)
                     }, undefined, false, undefined, this)
@@ -1960,8 +1720,249 @@ function MarketplaceDashboard() {
   }, undefined, true, undefined, this);
 }
 
-// src/ui/hooks/index.ts
-"use client";
+// src/ui/renderers/marketplace.markdown.ts
+var mockStores = [
+  {
+    id: "store-1",
+    name: "Tech Gadgets Store",
+    status: "ACTIVE",
+    productCount: 45,
+    rating: 4.8
+  },
+  {
+    id: "store-2",
+    name: "Home & Garden",
+    status: "ACTIVE",
+    productCount: 120,
+    rating: 4.5
+  },
+  {
+    id: "store-3",
+    name: "Fashion Boutique",
+    status: "PENDING",
+    productCount: 0,
+    rating: 0
+  }
+];
+var mockProducts = [
+  {
+    id: "prod-1",
+    name: "Wireless Earbuds",
+    storeId: "store-1",
+    price: 79.99,
+    currency: "USD",
+    status: "ACTIVE",
+    stock: 150
+  },
+  {
+    id: "prod-2",
+    name: "Smart Watch",
+    storeId: "store-1",
+    price: 249.99,
+    currency: "USD",
+    status: "ACTIVE",
+    stock: 50
+  },
+  {
+    id: "prod-3",
+    name: "Garden Tools Set",
+    storeId: "store-2",
+    price: 89.99,
+    currency: "USD",
+    status: "ACTIVE",
+    stock: 30
+  },
+  {
+    id: "prod-4",
+    name: "Indoor Plant Kit",
+    storeId: "store-2",
+    price: 45.99,
+    currency: "USD",
+    status: "ACTIVE",
+    stock: 75
+  },
+  {
+    id: "prod-5",
+    name: "LED Desk Lamp",
+    storeId: "store-1",
+    price: 34.99,
+    currency: "USD",
+    status: "OUT_OF_STOCK",
+    stock: 0
+  }
+];
+var mockOrders = [
+  {
+    id: "ord-1",
+    storeId: "store-1",
+    customerId: "cust-1",
+    total: 329.98,
+    currency: "USD",
+    status: "DELIVERED",
+    itemCount: 2,
+    createdAt: "2024-01-15T10:00:00Z"
+  },
+  {
+    id: "ord-2",
+    storeId: "store-2",
+    customerId: "cust-2",
+    total: 135.98,
+    currency: "USD",
+    status: "SHIPPED",
+    itemCount: 2,
+    createdAt: "2024-01-14T14:00:00Z"
+  },
+  {
+    id: "ord-3",
+    storeId: "store-1",
+    customerId: "cust-3",
+    total: 79.99,
+    currency: "USD",
+    status: "PROCESSING",
+    itemCount: 1,
+    createdAt: "2024-01-16T08:00:00Z"
+  },
+  {
+    id: "ord-4",
+    storeId: "store-2",
+    customerId: "cust-4",
+    total: 45.99,
+    currency: "USD",
+    status: "PENDING",
+    itemCount: 1,
+    createdAt: "2024-01-16T12:00:00Z"
+  }
+];
+function formatCurrency2(value, currency = "USD") {
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency,
+    minimumFractionDigits: 2
+  }).format(value);
+}
+var marketplaceDashboardMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "MarketplaceDashboard") {
+      throw new Error("marketplaceDashboardMarkdownRenderer: not MarketplaceDashboard");
+    }
+    const stores = mockStores;
+    const products = mockProducts;
+    const orders = mockOrders;
+    const activeStores = stores.filter((s) => s.status === "ACTIVE");
+    const activeProducts = products.filter((p) => p.status === "ACTIVE");
+    const totalRevenue = orders.reduce((sum, o) => sum + o.total, 0);
+    const pendingOrders = orders.filter((o) => o.status === "PENDING" || o.status === "PROCESSING");
+    const lines = [
+      "# Marketplace Dashboard",
+      "",
+      "> Two-sided marketplace overview",
+      "",
+      "## Summary",
+      "",
+      "| Metric | Value |",
+      "|--------|-------|",
+      `| Active Stores | ${activeStores.length} |`,
+      `| Active Products | ${activeProducts.length} |`,
+      `| Total Orders | ${orders.length} |`,
+      `| Total Revenue | ${formatCurrency2(totalRevenue)} |`,
+      `| Pending Orders | ${pendingOrders.length} |`,
+      "",
+      "## Top Stores",
+      "",
+      "| Store | Products | Rating | Status |",
+      "|-------|----------|--------|--------|"
+    ];
+    for (const store of stores.slice(0, 5)) {
+      lines.push(`| ${store.name} | ${store.productCount} | ⭐ ${store.rating || "N/A"} | ${store.status} |`);
+    }
+    lines.push("");
+    lines.push("## Recent Orders");
+    lines.push("");
+    lines.push("| Order | Items | Total | Status | Date |");
+    lines.push("|-------|-------|-------|--------|------|");
+    for (const order of orders.slice(0, 10)) {
+      const date = new Date(order.createdAt).toLocaleDateString();
+      lines.push(`| ${order.id} | ${order.itemCount} | ${formatCurrency2(order.total, order.currency)} | ${order.status} | ${date} |`);
+    }
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+var productCatalogMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "ProductCatalog") {
+      throw new Error("productCatalogMarkdownRenderer: not ProductCatalog");
+    }
+    const products = mockProducts;
+    const stores = mockStores;
+    const lines = [
+      "# Product Catalog",
+      "",
+      "> Browse products across all marketplace stores",
+      ""
+    ];
+    for (const store of stores.filter((s) => s.status === "ACTIVE")) {
+      const storeProducts = products.filter((p) => p.storeId === store.id);
+      if (storeProducts.length === 0)
+        continue;
+      lines.push(`## ${store.name}`);
+      lines.push("");
+      lines.push("| Product | Price | Stock | Status |");
+      lines.push("|---------|-------|-------|--------|");
+      for (const product of storeProducts) {
+        const stockStatus = product.stock > 0 ? `${product.stock} in stock` : "Out of stock";
+        lines.push(`| ${product.name} | ${formatCurrency2(product.price, product.currency)} | ${stockStatus} | ${product.status} |`);
+      }
+      lines.push("");
+    }
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
+var orderListMarkdownRenderer = {
+  target: "markdown",
+  render: async (desc) => {
+    if (desc.source.type !== "component" || desc.source.componentKey !== "OrderList") {
+      throw new Error("orderListMarkdownRenderer: not OrderList");
+    }
+    const orders = mockOrders;
+    const stores = mockStores;
+    const lines = [
+      "# Orders",
+      "",
+      "> Manage marketplace orders",
+      "",
+      "| Order ID | Store | Items | Total | Status | Created |",
+      "|----------|-------|-------|-------|--------|---------|"
+    ];
+    for (const order of orders) {
+      const store = stores.find((s) => s.id === order.storeId);
+      const date = new Date(order.createdAt).toLocaleDateString();
+      lines.push(`| ${order.id} | ${store?.name ?? "Unknown"} | ${order.itemCount} | ${formatCurrency2(order.total, order.currency)} | ${order.status} | ${date} |`);
+    }
+    lines.push("");
+    lines.push("## Order Status Legend");
+    lines.push("");
+    lines.push("- **PENDING**: Awaiting payment confirmation");
+    lines.push("- **PROCESSING**: Being prepared");
+    lines.push("- **SHIPPED**: In transit");
+    lines.push("- **DELIVERED**: Order completed");
+    lines.push("- **CANCELLED**: Order cancelled");
+    return {
+      mimeType: "text/markdown",
+      body: lines.join(`
+`)
+    };
+  }
+};
 export {
   useMarketplaceData,
   productCatalogMarkdownRenderer,