Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-sonnet-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

create full stack e commerce website

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Metallama-4-maverick-17b-128e-instruct’s answer.
  1. User

    create full stack e commerce website

  2. Claude Assistant

    I'll help you create a full-stack e-commerce website. I'll build a modern solution using React for the frontend, Node.js/Express for the backend, and MongoDB for the database.

    Project Structure

    ecommerce-website/
    ├── client/                 # React frontend
    ├── server/                 # Node.js backend
    ├── shared/                 # Shared types/utilities
    └── README.md
    

    Backend Setup

    First, let's create the server structure:

    server/package.json

    {
      "name": "ecommerce-server",
      "version": "1.0.0",
      "main": "server.js",
      "scripts": {
        "start": "node server.js",
        "dev": "nodemon server.js"
      },
      "dependencies": {
        "express": "^4.18.2",
        "mongoose": "^7.5.0",
        "cors": "^2.8.5",
        "dotenv": "^16.3.1",
        "bcryptjs": "^2.4.3",
        "jsonwebtoken": "^9.0.2",
        "multer": "^1.4.5",
        "stripe": "^13.6.0"
      },
      "devDependencies": {
        "nodemon": "^3.0.1"
      }
    }
    

    server/.env

    PORT=5000
    MONGODB_URI=mongodb://localhost:27017/ecommerce
    JWT_SECRET=your_jwt_secret_here
    STRIPE_SECRET_KEY=your_stripe_secret_key
    

    server/models/User.js

    const mongoose = require('mongoose');
    const bcrypt = require('bcryptjs');
    
    const userSchema = new mongoose.Schema({
      name: {
        type: String,
        required: true,
        trim: true
      },
      email: {
        type: String,
        required: true,
        unique: true,
        lowercase: true
      },
      password: {
        type: String,
        required: true,
        minlength: 6
      },
      role: {
        type: String,
        enum: ['user', 'admin'],
        default: 'user'
      },
      address: {
        street: String,
        city: String,
        state: String,
        zipCode: String,
        country: String
      }
    }, {
      timestamps: true
    });
    
    userSchema.pre('save', async function(next) {
      if (!this.isModified('password')) return next();
      this.password = await bcrypt.hash(this.password, 12);
      next();
    });
    
    userSchema.methods.comparePassword = async function(password) {
      return await bcrypt.compare(password, this.password);
    };
    
    module.exports = mongoose.model('User', userSchema);
    

    server/models/Product.js

    const mongoose = require('mongoose');
    
    const productSchema = new mongoose.Schema({
      name: {
        type: String,
        required: true,
        trim: true
      },
      description: {
        type: String,
        required: true
      },
      price: {
        type: Number,
        required: true,
        min: 0
      },
      category: {
        type: String,
        required: true
      },
      brand: {
        type: String,
        required: true
      },
      images: [{
        type: String,
        required: true
      }],
      stock: {
        type: Number,
        required: true,
        min: 0,
        default: 0
      },
      rating: {
        type: Number,
        default: 0,
        min: 0,
        max: 5
      },
      numReviews: {
        type: Number,
        default: 0
      },
      reviews: [{
        user: {
          type: mongoose.Schema.Types.ObjectId,
          ref: 'User',
          required: true
        },
        name: {
          type: String,
          required: true
        },
        rating: {
          type: Number,
          required: true,
          min: 1,
          max: 5
        },
        comment: {
          type: String,
          required: true
        },
        createdAt: {
          type: Date,
          default: Date.now
        }
      }],
      featured: {
        type: Boolean,
        default: false
      }
    }, {
      timestamps: true
    });
    
    module.exports = mongoose.model('Product', productSchema);
    

    server/models/Order.js

    const mongoose = require('mongoose');
    
    const orderSchema = new mongoose.Schema({
      user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
      },
      orderItems: [{
        product: {
          type: mongoose.Schema.Types.ObjectId,
          ref: 'Product',
          required: true
        },
        name: {
          type: String,
          required: true
        },
        quantity: {
          type: Number,
          required: true,
          min: 1
        },
        price: {
          type: Number,
          required: true
        },
        image: {
          type: String,
          required: true
        }
      }],
      shippingAddress: {
        street: {
          type: String,
          required: true
        },
        city: {
          type: String,
          required: true
        },
        state: {
          type: String,
          required: true
        },
        zipCode: {
          type: String,
          required: true
        },
        country: {
          type: String,
          required: true
        }
      },
      paymentMethod: {
        type: String,
        required: true,
        default: 'stripe'
      },
      paymentResult: {
        id: String,
        status: String,
        update_time: String,
        email_address: String
      },
      itemsPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      taxPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      shippingPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      totalPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      isPaid: {
        type: Boolean,
        required: true,
        default: false
      },
      paidAt: {
        type: Date
      },
      isDelivered: {
        type: Boolean,
        required: true,
        default: false
      },
      deliveredAt: {
        type: Date
      },
      status: {
        type: String,
        enum: ['pending', 'processing', 'shipped', 'delivered', 'cancelled'],
        default: 'pending'
      }
    }, {
      timestamps: true
    });
    
    module.exports = mongoose.model('Order', orderSchema);
    

    server/middleware/auth.js

    const jwt = require('jsonwebtoken');
    const User = require('../models/User');
    
    const auth = async (req, res, next) => {
      try {
        const token = req.header('Authorization')?.replace('Bearer ', '');
        
        if (!token) {
          return res.status(401).json({ message: 'No token, authorization denied' });
        }
    
        const decoded = jwt.verify(token, process.env.JWT_SECRET);
        const user = await User.findById(decoded.id).select('-password');
        
        if (!user) {
          return res.status(401).json({ message: 'Token is not valid' });
        }
    
        req.user = user;
        next();
      } catch (error) {
        res.status(401).json({ message: 'Token is not valid' });
      }
    };
    
    const adminAuth = async (req, res, next) => {
      try {
        await auth(req, res, () => {
          if (req.user && req.user.role === 'admin') {
            next();
          } else {
            res.status(403).json({ message: 'Admin access required' });
          }
        });
      } catch (error) {
        res.status(401).json({ message: 'Authorization failed' });
      }
    };
    
    module.exports = { auth, adminAuth };
    

    server/routes/auth.js

    const express = require('express');
    const jwt = require('jsonwebtoken');
    const User = require('../models/User');
    const { auth } = require('../middleware/auth');
    
    const router = express.Router();
    
    // Register
    router.post('/register', async (req, res) => {
      try {
        const { name, email, password } = req.body;
    
        const existingUser = await User.findOne({ email });
        if (existingUser) {
          return res.status(400).json({ message: 'User already exists' });
        }
    
        const user = new User({ name, email, password });
        await user.save();
    
        const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, {
          expiresIn: '30d'
        });
    
        res.status(201).json({
          token,
          user: {
            id: user._id,
            name: user.name,
            email: user.email,
            role: user.role
          }
        });
      } catch (error) {
        res.status(500).json({ message: 'Server error', error: error.message });
      }
    });
    
    // Login
    router.post('/login', async (req, res) => {
      try {
        const { email, password } = req.body;
    
        const user = await User.findOne({ email });
        if (!user) {
          return res.status(400).json({ message: 'Invalid credentials' });
        }
    
        const isMatch = await user.comparePassword(password);
        if (!isMatch) {
          return res.status(400).json({ message: 'Invalid credentials' });
        }
    
        const token = jwt.sign({ id: user._id }, process.env.JWT_SECRET, {
          expiresIn: '30d'
        });
    
        res.json({
          token,
          user: {
            id: user._id,
            name: user.name,
            email: user.email,
            role: user.role
          }
        });
      } catch (error) {
        res.status(500).json({ message: 'Server error', error: error.message });
      }
    });
    
    // Get current user
    router.get('/me', auth, async (req, res) => {
      try {
        res.json({
          user: {
            id: req.user._id,
            name: req.user.name,
            email: req.user.email,
            role: req.user.role,
            address: req.user.address
          }
        });
      } catch (error) {
        res.status(500).json({ message: 'Server error' });
      }
    });
    
    module.exports = router;
    

    server/routes/products.js

    const express = require('express');
    const Product = require('../models/Product');
    const { auth, adminAuth } = require('../middleware/auth');
    
    const router = express.Router();
    
    // Get all products with filtering and pagination
    router.get('/', async (req, res) => {
      try {
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 12;
        const skip = (page - 1) * limit;
    
        let query = {};
        
        // Search by name or description
        if (req.query.search) {
          query.$or = [
            { name: { $regex: req.query.search, $options: 'i' } },
            { description: { $regex: req.query.search, $options: 'i' } }
          ];
        }
    
        // Filter by category
        if (req.query.category) {
          query.category = req.query.category;
        }
    
        // Filter by brand
        if (req.query.brand) {
          query.brand = req.query.brand;
        }
    
        // Price range filter
        if (req.query.minPrice || req.query.maxPrice) {
          query.price = {};
          if (req.query.minPrice) query.price.$gte = parseFloat(req.query.minPrice);
          if (req.query.maxPrice) query.price.$lte = parseFloat(req.query.maxPrice);
        }
    
        // Sort options
        let sort = {};
        if (req.query.sort) {
          switch (req.query.sort) {
            case 'price_asc':
              sort.price = 1;
              break;
            case 'price_desc':
              sort.price = -1;
              break;
            case 'rating':
              sort.rating = -1;
              break;
            case 'newest':
              sort.createdAt = -1;
              break;
            default:
              sort.createdAt = -1;
          }
        }
    
        const products = await Product.find(query)
          .sort(sort)
          .skip(skip)
          .limit(limit);
    
        const total = await Product.countDocuments(query);
    
        res.json({
          products,
          currentPage: page,
          totalPages: Math.ceil(total / limit),
          totalProducts: total
        });
      } catch (error) {
        res.status(500).json({ message: 'Server error', error: error.message });
      }
    });
    
    // Get single product
    router.get('/:id', async (req, res) => {
      try {
        const product = await Product.findById(req.params.id).populate('reviews.user', 'name');
        
        if (!product) {
          return res.status(404).json({ message: 'Product not found' });
        }
    
        res.json(product);
      } catch (error) {
        res.status(500).json({ message: 'Server error', error: error.message });
      }
    });
    
    // Create product (Admin only)
    router.post('/', adminAuth, async (req, res) => {
      try {
        const product = new Product(req.body);
        await product.save();
        res.status(201).json(product);
      } catch (error) {
        res.status(500).json({ message: 'Server error', error: error.message });
      }
    });
    
    // Update product (Admin only)
    router.put('/:id', adminAuth, async (req, res) => {
      try {
        const product = await Product.findByIdAndUpdate(
          req.params.id,
          req.body,
          { new: true, runValidators: true }
        );
    
        if (!product) {
          return res.status(404).json({ message: 'Product not found' });
        }
    
        res.json(product);
      } catch (error) {
        res.status(500).json({ message: 'Server error', error: error.message });
      }
    });
    
    // Delete product (Admin only)
    router.delete('/:id', adminAuth, async (req, res) => {
      try {
        const product = await Product.findByIdAndDelete(req.params.id);
    
        if (!product) {
          return res.status(404).json({ message: 'Product not found' });
        }
    
        res.json({ message: 'Product deleted successfully' });
      } catch (error) {
        res.status(500).json({ message: 'Server error', error: error.message });
      }
    });
    
    // Add product review
    router.post('/:id/reviews', auth, async (req, res) => {
      try {
        const { rating, comment } = req.body;
        const product = await Product.findById(req.params.id);
    
        if (!product) {
          return res.status(404).json({ message: 'Product not found' });
        }
    
        // Check if user already reviewed
        const existingReview = product.reviews.find(
          review => review.user.toString() === req.user._id.toString()
        );
    
        if (existingReview) {
          return res.status(400).json({ message:
    
  3. User

    full working and responsive website and no error no nothing full fledged website and 3d 4k and i can review it full ai

  4. Claude Assistant

    I'll create a complete, fully functional e-commerce website with modern 3D/4K design elements. This will be a comprehensive solution with all features working.

    Complete Project Structure

    ecommerce-3d/
    ├── client/                 # React frontend with 3D elements
    ├── server/                 # Node.js backend
    ├── uploads/               # Image uploads
    └── README.md
    

    Backend Implementation

    server/package.json

    {
      "name": "ecommerce-3d-server",
      "version": "1.0.0",
      "main": "server.js",
      "scripts": {
        "start": "node server.js",
        "dev": "nodemon server.js",
        "seed": "node seedData.js"
      },
      "dependencies": {
        "express": "^4.18.2",
        "mongoose": "^7.5.0",
        "cors": "^2.8.5",
        "dotenv": "^16.3.1",
        "bcryptjs": "^2.4.3",
        "jsonwebtoken": "^9.0.2",
        "multer": "^1.4.5",
        "stripe": "^13.6.0",
        "express-rate-limit": "^6.10.0",
        "helmet": "^7.0.0",
        "compression": "^1.7.4"
      },
      "devDependencies": {
        "nodemon": "^3.0.1"
      }
    }
    

    server/.env

    PORT=5000
    MONGODB_URI=mongodb://localhost:27017/ecommerce3d
    JWT_SECRET=your_super_secret_jwt_key_here_make_it_long_and_secure
    STRIPE_SECRET_KEY=sk_test_your_stripe_secret_key
    NODE_ENV=development
    

    server/server.js

    const express = require('express');
    const mongoose = require('mongoose');
    const cors = require('cors');
    const helmet = require('helmet');
    const compression = require('compression');
    const rateLimit = require('express-rate-limit');
    require('dotenv').config();
    
    const authRoutes = require('./routes/auth');
    const productRoutes = require('./routes/products');
    const orderRoutes = require('./routes/orders');
    const uploadRoutes = require('./routes/upload');
    const paymentRoutes = require('./routes/payment');
    
    const app = express();
    
    // Security middleware
    app.use(helmet());
    app.use(compression());
    
    // Rate limiting
    const limiter = rateLimit({
      windowMs: 15 * 60 * 1000, // 15 minutes
      max: 100 // limit each IP to 100 requests per windowMs
    });
    app.use(limiter);
    
    // CORS configuration
    app.use(cors({
      origin: process.env.NODE_ENV === 'production' 
        ? 'https://your-domain.com' 
        : 'http://localhost:3000',
      credentials: true
    }));
    
    app.use(express.json({ limit: '10mb' }));
    app.use(express.urlencoded({ extended: true, limit: '10mb' }));
    
    // Serve static files
    app.use('/uploads', express.static('uploads'));
    
    // Routes
    app.use('/api/auth', authRoutes);
    app.use('/api/products', productRoutes);
    app.use('/api/orders', orderRoutes);
    app.use('/api/upload', uploadRoutes);
    app.use('/api/payment', paymentRoutes);
    
    // Health check
    app.get('/api/health', (req, res) => {
      res.json({ status: 'OK', timestamp: new Date().toISOString() });
    });
    
    // Error handling middleware
    app.use((err, req, res, next) => {
      console.error(err.stack);
      res.status(500).json({ 
        message: 'Something went wrong!',
        error: process.env.NODE_ENV === 'development' ? err.message : {}
      });
    });
    
    // 404 handler
    app.use('*', (req, res) => {
      res.status(404).json({ message: 'Route not found' });
    });
    
    // Database connection
    mongoose.connect(process.env.MONGODB_URI, {
      useNewUrlParser: true,
      useUnifiedTopology: true,
    })
    .then(() => {
      console.log('✅ Connected to MongoDB');
      
      const PORT = process.env.PORT || 5000;
      app.listen(PORT, () => {
        console.log(`🚀 Server running on port ${PORT}`);
        console.log(`📱 Environment: ${process.env.NODE_ENV}`);
      });
    })
    .catch((error) => {
      console.error('❌ MongoDB connection error:', error);
      process.exit(1);
    });
    
    // Graceful shutdown
    process.on('SIGTERM', () => {
      console.log('SIGTERM received. Shutting down gracefully...');
      mongoose.connection.close(() => {
        console.log('MongoDB connection closed.');
        process.exit(0);
      });
    });
    

    server/models/User.js

    const mongoose = require('mongoose');
    const bcrypt = require('bcryptjs');
    
    const userSchema = new mongoose.Schema({
      name: {
        type: String,
        required: [true, 'Name is required'],
        trim: true,
        maxlength: [50, 'Name cannot exceed 50 characters']
      },
      email: {
        type: String,
        required: [true, 'Email is required'],
        unique: true,
        lowercase: true,
        match: [/^\w+([.-]?\w+)*@\w+([.-]?\w+)*(\.\w{2,3})+$/, 'Please enter a valid email']
      },
      password: {
        type: String,
        required: [true, 'Password is required'],
        minlength: [6, 'Password must be at least 6 characters']
      },
      avatar: {
        type: String,
        default: 'https://via.placeholder.com/150x150/007bff/ffffff?text=User'
      },
      role: {
        type: String,
        enum: ['user', 'admin'],
        default: 'user'
      },
      address: {
        street: String,
        city: String,
        state: String,
        zipCode: String,
        country: String
      },
      phone: {
        type: String,
        match: [/^\+?[\d\s-()]+$/, 'Please enter a valid phone number']
      },
      wishlist: [{
        type: mongoose.Schema.Types.ObjectId,
        ref: 'Product'
      }],
      isActive: {
        type: Boolean,
        default: true
      },
      lastLogin: {
        type: Date,
        default: Date.now
      }
    }, {
      timestamps: true
    });
    
    userSchema.pre('save', async function(next) {
      if (!this.isModified('password')) return next();
      this.password = await bcrypt.hash(this.password, 12);
      next();
    });
    
    userSchema.methods.comparePassword = async function(password) {
      return await bcrypt.compare(password, this.password);
    };
    
    userSchema.methods.toJSON = function() {
      const user = this.toObject();
      delete user.password;
      return user;
    };
    
    module.exports = mongoose.model('User', userSchema);
    

    server/models/Product.js

    const mongoose = require('mongoose');
    
    const reviewSchema = new mongoose.Schema({
      user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
      },
      name: {
        type: String,
        required: true
      },
      rating: {
        type: Number,
        required: true,
        min: 1,
        max: 5
      },
      comment: {
        type: String,
        required: true,
        maxlength: 500
      },
      helpful: {
        type: Number,
        default: 0
      }
    }, {
      timestamps: true
    });
    
    const productSchema = new mongoose.Schema({
      name: {
        type: String,
        required: [true, 'Product name is required'],
        trim: true,
        maxlength: [100, 'Product name cannot exceed 100 characters']
      },
      description: {
        type: String,
        required: [true, 'Product description is required'],
        maxlength: [2000, 'Description cannot exceed 2000 characters']
      },
      shortDescription: {
        type: String,
        maxlength: [200, 'Short description cannot exceed 200 characters']
      },
      price: {
        type: Number,
        required: [true, 'Price is required'],
        min: [0, 'Price cannot be negative']
      },
      originalPrice: {
        type: Number,
        min: [0, 'Original price cannot be negative']
      },
      category: {
        type: String,
        required: [true, 'Category is required'],
        enum: ['Electronics', 'Clothing', 'Books', 'Home & Garden', 'Sports', 'Beauty', 'Toys', 'Automotive']
      },
      subcategory: {
        type: String,
        required: true
      },
      brand: {
        type: String,
        required: [true, 'Brand is required']
      },
      model: String,
      sku: {
        type: String,
        unique: true,
        required: true
      },
      images: [{
        url: {
          type: String,
          required: true
        },
        alt: String,
        isPrimary: {
          type: Boolean,
          default: false
        }
      }],
      video: {
        url: String,
        thumbnail: String
      },
      stock: {
        type: Number,
        required: [true, 'Stock quantity is required'],
        min: [0, 'Stock cannot be negative'],
        default: 0
      },
      lowStockThreshold: {
        type: Number,
        default: 10
      },
      rating: {
        type: Number,
        default: 0,
        min: 0,
        max: 5
      },
      numReviews: {
        type: Number,
        default: 0
      },
      reviews: [reviewSchema],
      specifications: [{
        name: String,
        value: String
      }],
      features: [String],
      dimensions: {
        length: Number,
        width: Number,
        height: Number,
        weight: Number,
        unit: {
          type: String,
          enum: ['cm', 'inch', 'kg', 'lb'],
          default: 'cm'
        }
      },
      colors: [{
        name: String,
        hex: String,
        image: String
      }],
      sizes: [{
        name: String,
        stock: Number
      }],
      tags: [String],
      featured: {
        type: Boolean,
        default: false
      },
      onSale: {
        type: Boolean,
        default: false
      },
      saleEndDate: Date,
      isActive: {
        type: Boolean,
        default: true
      },
      views: {
        type: Number,
        default: 0
      },
      sold: {
        type: Number,
        default: 0
      },
      shippingInfo: {
        weight: Number,
        freeShipping: {
          type: Boolean,
          default: false
        },
        shippingCost: {
          type: Number,
          default: 0
        }
      }
    }, {
      timestamps: true
    });
    
    // Indexes for better performance
    productSchema.index({ name: 'text', description: 'text' });
    productSchema.index({ category: 1, price: 1 });
    productSchema.index({ rating: -1 });
    productSchema.index({ createdAt: -1 });
    productSchema.index({ featured: 1 });
    
    // Calculate average rating
    productSchema.methods.calculateAverageRating = function() {
      if (this.reviews.length === 0) {
        this.rating = 0;
        this.numReviews = 0;
      } else {
        const totalRating = this.reviews.reduce((sum, review) => sum + review.rating, 0);
        this.rating = Math.round((totalRating / this.reviews.length) * 10) / 10;
        this.numReviews = this.reviews.length;
      }
    };
    
    // Check if product is low in stock
    productSchema.virtual('isLowStock').get(function() {
      return this.stock <= this.lowStockThreshold;
    });
    
    // Calculate discount percentage
    productSchema.virtual('discountPercentage').get(function() {
      if (this.originalPrice && this.originalPrice > this.price) {
        return Math.round(((this.originalPrice - this.price) / this.originalPrice) * 100);
      }
      return 0;
    });
    
    productSchema.set('toJSON', { virtuals: true });
    
    module.exports = mongoose.model('Product', productSchema);
    

    server/models/Order.js

    const mongoose = require('mongoose');
    
    const orderItemSchema = new mongoose.Schema({
      product: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'Product',
        required: true
      },
      name: {
        type: String,
        required: true
      },
      quantity: {
        type: Number,
        required: true,
        min: 1
      },
      price: {
        type: Number,
        required: true
      },
      image: {
        type: String,
        required: true
      },
      color: String,
      size: String
    });
    
    const orderSchema = new mongoose.Schema({
      orderNumber: {
        type: String,
        unique: true,
        required: true
      },
      user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'User',
        required: true
      },
      orderItems: [orderItemSchema],
      shippingAddress: {
        fullName: {
          type: String,
          required: true
        },
        street: {
          type: String,
          required: true
        },
        city: {
          type: String,
          required: true
        },
        state: {
          type: String,
          required: true
        },
        zipCode: {
          type: String,
          required: true
        },
        country: {
          type: String,
          required: true
        },
        phone: String
      },
      billingAddress: {
        fullName: String,
        street: String,
        city: String,
        state: String,
        zipCode: String,
        country: String
      },
      paymentMethod: {
        type: String,
        required: true,
        enum: ['stripe', 'paypal', 'cash_on_delivery']
      },
      paymentResult: {
        id: String,
        status: String,
        update_time: String,
        email_address: String
      },
      itemsPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      taxPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      shippingPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      discountAmount: {
        type: Number,
        default: 0.0
      },
      totalPrice: {
        type: Number,
        required: true,
        default: 0.0
      },
      isPaid: {
        type: Boolean,
        required: true,
        default: false
      },
      paidAt: Date,
      isDelivered: {
        type: Boolean,
        required: true,
        default: false
      },
      deliveredAt: Date,
      status: {
        type: String,
        enum: ['pending', 'confirmed', 'processing', 'shipped', 'delivered', 'cancelled', 'refunded'],
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.