$ - Semantic Context Proxy

interface PathProxy {
  readonly path: string
  toString(): string
  valueOf(): string
  readonly [key: string]: PathProxy
}

const $: PathProxy & {
  [Subject: string]: PathProxy & {
    [predicate: string]: PathProxy & {
      [Object: string]: PathProxy
    }
  }
}

// Each property access extends the path
$.Person // "$.Person"
$.Person.worksFor // "$.Person.worksFor"
$.Person.worksFor.Organization // "$.Person.worksFor.Organization"

// Conversion to string
String($.Order.created) // "$.Order.created"
$.Payment.succeeded.toString() // "$.Payment.succeeded"

// Create a Person
const person = $.Person({
  name: 'Alice Johnson',
  email: '[email protected]',
  jobTitle: 'Software Engineer',
})

// Create an Organization
const company = $.Organization({
  name: 'Acme Corporation',
  legalName: 'Acme Corp Inc.',
  url: 'https://acme.com',
  industry: 'Technology',
})

// Create a Product
const product = $.Product({
  name: 'Smart Widget',
  description: 'An intelligent widget for your home',
  price: 99.99,
  currency: 'USD',
})

// Define event patterns
$.Order.created // Order creation events
$.Payment.succeeded // Payment success events
$.User.email.verified // Email verification events
$.Product.inventory.updated // Inventory update events
$.Shipment.status.changed // Shipment status changes

// Subscribe to events
on($.Order.created, async (order) => {
  console.log('New order received:', order.id)
})

// Publish events
await send($.Payment.succeeded, {
  orderId: 'ord_123',
  amount: 99.99,
  currency: 'USD',
})

const person = $.Person({
  name: 'John Doe',
  givenName: 'John',
  familyName: 'Doe',
  email: '[email protected]',
  telephone: '+1-555-0123',
  jobTitle: 'Product Manager',
  image: 'https://example.com/photo.jpg',
})

const org = $.Organization({
  name: 'Tech Innovations Inc',
  legalName: 'Tech Innovations Incorporated',
  url: 'https://techinnovations.com',
  email: '[email protected]',
  telephone: '+1-555-0100',
  foundingDate: '2015-03-15',
  address: {
    streetAddress: '123 Innovation Drive',
    addressLocality: 'San Francisco',
    addressRegion: 'CA',
    postalCode: '94103',
    addressCountry: 'US',
  },
})

const business = $.Business({
  name: 'Main Street Coffee',
  description: 'Artisan coffee shop in downtown',
  address: {
    streetAddress: '456 Main Street',
    addressLocality: 'Portland',
    addressRegion: 'OR',
    postalCode: '97201',
  },
  telephone: '+1-555-0200',
  openingHours: 'Mo-Fr 07:00-19:00, Sa-Su 08:00-17:00',
  priceRange: '$$',
  geo: {
    latitude: 45.5231,
    longitude: -122.6765,
  },
})

const product = $.Product({
  name: 'Ergonomic Office Chair',
  description: 'Professional ergonomic chair with lumbar support',
  sku: 'CHAIR-ERG-001',
  brand: $.Brand({ name: 'ErgoMax' }),
  image: 'https://example.com/chair.jpg',
  offers: $.Offer({
    price: 399.99,
    priceCurrency: 'USD',
    availability: 'https://schema.org/InStock',
    seller: $.Organization({ name: 'Office Supply Co' }),
  }),
  aggregateRating: {
    ratingValue: 4.5,
    reviewCount: 127,
  },
})

const order = $.Order({
  orderNumber: 'ORD-2024-001',
  orderDate: new Date(),
  orderStatus: 'https://schema.org/OrderProcessing',
  customer: $.Person({
    name: 'Jane Smith',
    email: '[email protected]',
  }),
  orderedItem: [
    $.OrderItem({
      orderQuantity: 2,
      orderedItem: $.Product({
        name: 'Laptop Stand',
        sku: 'STAND-001',
      }),
    }),
  ],
  totalPrice: 149.98,
  priceCurrency: 'USD',
  billingAddress: {
    streetAddress: '789 Oak Avenue',
    addressLocality: 'Seattle',
    addressRegion: 'WA',
    postalCode: '98101',
  },
})

const invoice = $.Invoice({
  identifier: 'INV-2024-001',
  referencesOrder: $.Order({ orderNumber: 'ORD-2024-001' }),
  customer: $.Person({ name: 'John Customer' }),
  totalPaymentDue: {
    price: 1250.0,
    priceCurrency: 'USD',
  },
  paymentDueDate: '2024-02-15',
  paymentStatus: 'https://schema.org/PaymentDue',
  billingPeriod: '2024-01',
  accountId: 'ACCT-12345',
})

const offer = $.Offer({
  price: 49.99,
  priceCurrency: 'USD',
  availability: 'https://schema.org/InStock',
  priceValidUntil: '2024-12-31',
  seller: $.Organization({ name: 'Best Electronics' }),
  itemCondition: 'https://schema.org/NewCondition',
  warranty: $.WarrantyPromise({
    durationOfWarranty: {
      value: 2,
      unitCode: 'ANN',
    },
  }),
})

const event = $.Event({
  name: 'Tech Conference 2024',
  description: 'Annual technology conference',
  startDate: '2024-06-15T09:00:00Z',
  endDate: '2024-06-17T18:00:00Z',
  location: $.Place({
    name: 'Convention Center',
    address: {
      addressLocality: 'Austin',
      addressRegion: 'TX',
    },
  }),
  organizer: $.Organization({ name: 'Tech Events Inc' }),
  offers: $.Offer({
    price: 299,
    priceCurrency: 'USD',
    url: 'https://techconf.example.com/register',
  }),
})

const action = $.Action({
  name: 'Process Payment',
  actionStatus: 'https://schema.org/CompletedActionStatus',
  agent: $.Person({ name: 'Payment Processor' }),
  object: $.Order({ orderNumber: 'ORD-123' }),
  result: $.PaymentChargeSpecification({
    amount: 99.99,
    currency: 'USD',
  }),
  startTime: '2024-01-15T10:30:00Z',
  endTime: '2024-01-15T10:30:05Z',
})

const article = $.Article({
  headline: 'Getting Started with Semantic Business-as-Code',
  description: 'Learn how to use the .do platform for semantic programming',
  author: $.Person({
    name: 'Tech Writer',
    url: 'https://example.com/author/tech-writer',
  }),
  datePublished: '2024-01-15',
  dateModified: '2024-01-20',
  image: 'https://example.com/article-image.jpg',
  articleBody: 'Full article content here...',
  keywords: ['semantic-web', 'business-as-code', 'schema.org'],
  publisher: $.Organization({ name: 'Tech Blog' }),
})

const work = $.CreativeWork({
  name: 'Tutorial Video Series',
  description: 'Complete video tutorial on semantic programming',
  creator: $.Person({ name: 'Content Creator' }),
  dateCreated: '2024-01-10',
  license: 'https://creativecommons.org/licenses/by/4.0/',
  keywords: ['tutorial', 'programming', 'video'],
  thumbnailUrl: 'https://example.com/thumbnail.jpg',
})

const place = $.Place({
  name: 'Golden Gate Park',
  description: 'Large urban park in San Francisco',
  address: {
    streetAddress: '501 Stanyan Street',
    addressLocality: 'San Francisco',
    addressRegion: 'CA',
    postalCode: '94117',
    addressCountry: 'US',
  },
  geo: {
    latitude: 37.7694,
    longitude: -122.4862,
  },
  openingHours: 'Mo-Su 05:00-00:00',
  telephone: '+1-555-0300',
})

// Create customer with semantic type
const customer = await db.create(
  'customers',
  $.Person({
    name: 'Sarah Johnson',
    email: '[email protected]',
    telephone: '+1-555-0123',
  })
)

// Create order with nested semantic types
const order = await db.create(
  'orders',
  $.Order({
    orderNumber: 'ORD-2024-123',
    customer: $.Person({ id: customer.id }),
    orderedItem: [
      $.OrderItem({
        orderQuantity: 1,
        orderedItem: $.Product({ name: 'Laptop', sku: 'LAP-001' }),
      }),
    ],
    totalPrice: 1299.99,
    priceCurrency: 'USD',
  })
)

// Query with semantic filters
const activeOrders = await db.list('orders', {
  where: {
    orderStatus: 'https://schema.org/OrderProcessing',
  },
})

// Subscribe to order events
on($.Order.created, async (order) => {
  console.log('Processing new order:', order.orderNumber)

  // Send confirmation email
  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Confirmation',
    template: 'order-confirmation',
    data: { order },
  })

  // Trigger fulfillment workflow
  await send($.Fulfillment.start, {
    orderId: order.id,
    items: order.orderedItem,
  })
})

// Payment processing
on($.Payment.succeeded, async (payment) => {
  // Update order status
  await db.update('orders', payment.orderId, {
    orderStatus: 'https://schema.org/OrderPaymentDue',
    paymentStatus: 'https://schema.org/PaymentComplete',
  })

  // Send receipt
  await send($.Receipt.send, {
    orderId: payment.orderId,
    amount: payment.amount,
  })
})

// Inventory updates
on($.Product.inventory.updated, async (update) => {
  const product = await db.get('products', update.productId)

  if (product.inventory < 10) {
    await send($.Alert.lowInventory, {
      productId: product.id,
      productName: product.name,
      currentInventory: product.inventory,
    })
  }
})

import { registerSchema } from 'sdk.do'
import { z } from 'zod'

// Register custom schema
registerSchema(
  'BusinessPlan',
  z.object({
    executiveSummary: z.string(),
    marketAnalysis: z.string(),
    products: z.array(
      z.object({
        name: z.string(),
        description: z.string(),
        pricing: z.number(),
      })
    ),
    financialProjections: z.object({
      year1Revenue: z.number(),
      year1Expenses: z.number(),
      breakEvenMonth: z.number(),
    }),
  })
)

// Generate with semantic context
const plan = await ai.generate({
  prompt: 'Create a business plan for a coffee shop in Portland',
  schema: $.BusinessPlan,
  model: 'claude-sonnet-4.5',
})

// Type-safe access
console.log(plan.executiveSummary)
console.log(plan.financialProjections.year1Revenue)

// Store with semantic type
await db.create(
  'business-plans',
  $.CreativeWork({
    name: 'Portland Coffee Shop Business Plan',
    creator: $.Person({ name: 'AI Assistant' }),
    text: JSON.stringify(plan),
  })
)

const complexOrder = $.Order({
  orderNumber: 'ORD-2024-456',
  orderDate: new Date(),
  customer: $.Person({
    name: 'Emily Davis',
    email: '[email protected]',
    address: $.PostalAddress({
      streetAddress: '123 Elm Street',
      addressLocality: 'Portland',
      addressRegion: 'OR',
      postalCode: '97201',
    }),
  }),
  seller: $.Organization({
    name: 'Tech Supplies Inc',
    url: 'https://techsupplies.example.com',
  }),
  orderedItem: [
    $.OrderItem({
      orderQuantity: 2,
      orderedItem: $.Product({
        name: 'USB-C Cable',
        brand: $.Brand({ name: 'CablePro' }),
        offers: $.Offer({
          price: 12.99,
          priceCurrency: 'USD',
        }),
      }),
    }),
    $.OrderItem({
      orderQuantity: 1,
      orderedItem: $.Product({
        name: 'Wireless Mouse',
        brand: $.Brand({ name: 'MouseTech' }),
        offers: $.Offer({
          price: 29.99,
          priceCurrency: 'USD',
        }),
      }),
    }),
  ],
  totalPrice: 55.97,
  priceCurrency: 'USD',
  paymentMethod: $.PaymentMethod({
    name: 'Credit Card',
    identifier: '****1234',
  }),
})

// Order creation
on($.Order.created, async (order) => {
  // Validate inventory
  for (const item of order.orderedItem) {
    const product = await db.get('products', item.orderedItem.id)
    if (product.inventory < item.orderQuantity) {
      await send($.Order.cancelled, {
        orderId: order.id,
        reason: 'insufficient_inventory',
        product: product.name,
      })
      return
    }
  }

  // Reserve inventory
  await send($.Inventory.reserve, {
    orderId: order.id,
    items: order.orderedItem,
  })

  // Send confirmation
  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Confirmed',
    template: 'order-confirmation',
    data: { order },
  })
})

// Payment processing
on($.Payment.requested, async (payment) => {
  try {
    const result = await api.proxy('stripe', '/v1/charges', {
      method: 'POST',
      body: {
        amount: Math.round(payment.amount * 100),
        currency: payment.currency.toLowerCase(),
        customer: payment.customerId,
      },
    })

    await send($.Payment.succeeded, {
      orderId: payment.orderId,
      amount: payment.amount,
      transactionId: result.id,
    })
  } catch (error) {
    await send($.Payment.failed, {
      orderId: payment.orderId,
      error: error.message,
    })
  }
})

// Fulfillment
on($.Payment.succeeded, async (payment) => {
  const order = await db.get('orders', payment.orderId)

  await send($.Fulfillment.start, {
    orderId: order.id,
    shippingAddress: order.customer.address,
  })

  await db.update('orders', order.id, {
    orderStatus: 'https://schema.org/OrderProcessing',
  })
})

// Shipping
on($.Fulfillment.shipped, async (fulfillment) => {
  await db.update('orders', fulfillment.orderId, {
    orderStatus: 'https://schema.org/OrderInTransit',
  })

  const order = await db.get('orders', fulfillment.orderId)

  await send($.Email.send, {
    to: order.customer.email,
    subject: 'Order Shipped',
    template: 'order-shipped',
    data: {
      order,
      trackingNumber: fulfillment.trackingNumber,
      carrier: fulfillment.carrier,
    },
  })
})

// New lead registration
on($.Lead.created, async (lead) => {
  // Create person record
  const person = await db.create(
    'people',
    $.Person({
      name: lead.name,
      email: lead.email,
      telephone: lead.phone,
      jobTitle: lead.jobTitle,
      worksFor: $.Organization({ name: lead.company }),
    })
  )

  // Send welcome email
  await send($.Email.send, {
    to: person.email,
    subject: 'Welcome!',
    template: 'lead-welcome',
  })

  // Schedule follow-up
  await send($.Task.schedule, {
    name: 'Follow up with lead',
    assignee: lead.assignedTo,
    dueDate: new Date(Date.now() + 2 * 24 * 60 * 60 * 1000), // 2 days
  })
})

// Lead qualification
on($.Lead.qualified, async (lead) => {
  // Convert to opportunity
  const opportunity = await db.create(
    'opportunities',
    $.Opportunity({
      name: `${lead.company} - ${lead.product}`,
      accountId: lead.accountId,
      amount: lead.estimatedValue,
      closeDate: lead.expectedCloseDate,
      stage: 'Qualification',
    })
  )

  // Notify sales team
  await send($.Notification.send, {
    type: 'new_opportunity',
    recipients: ['[email protected]'],
    data: { opportunity },
  })
})

// Deal closed
on($.Opportunity.won, async (opportunity) => {
  // Create customer
  const customer = await db.create(
    'customers',
    $.Organization({
      name: opportunity.accountName,
      industry: opportunity.industry,
      numberOfEmployees: opportunity.employeeCount,
    })
  )

  // Send welcome package
  await send($.Email.send, {
    to: opportunity.contactEmail,
    subject: 'Welcome to Our Family!',
    template: 'customer-welcome',
    data: { customer },
  })

  // Schedule onboarding
  await send($.Event.schedule, {
    name: 'Customer Onboarding',
    startDate: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
    attendees: [opportunity.contactEmail, '[email protected]'],
  })
})

// Article draft created
on($.Article.draft.created, async (draft) => {
  const article = await db.create(
    'articles',
    $.Article({
      headline: draft.headline,
      articleBody: draft.content,
      author: $.Person({ id: draft.authorId }),
      dateCreated: new Date(),
      articleSection: draft.category,
      keywords: draft.tags,
    })
  )

  // Assign to editor
  await send($.Task.assign, {
    type: 'review_article',
    assignee: draft.editorId,
    articleId: article.id,
  })
})

// Article published
on($.Article.published, async (article) => {
  // Update article status
  await db.update('articles', article.id, {
    datePublished: new Date(),
  })

  // Generate social media posts
  const socialPost = await ai.generate({
    prompt: `Create an engaging social media post for this article: ${article.headline}`,
    schema: $.SocialMediaPosting,
    model: 'gpt-5',
  })

  // Schedule social posts
  await send($.SocialMedia.schedule, {
    content: socialPost.text,
    platforms: ['twitter', 'linkedin'],
    scheduledTime: new Date(Date.now() + 60 * 60 * 1000), // 1 hour
  })

  // Notify subscribers
  const subscribers = await db.list('subscribers', {
    where: { interests: { contains: article.articleSection } },
  })

  for (const subscriber of subscribers) {
    await send($.Email.send, {
      to: subscriber.email,
      subject: `New Article: ${article.headline}`,
      template: 'new-article',
      data: { article },
    })
  }
})

// This creates a path, not an object
const person = $.Person

// Call it as a function to create an object
const person = $.Person({ name: 'Alice' })

// Can't mix path construction with object creation
const path = $.Person({ name: 'Bob' }).worksFor

// Separate path construction from object creation
const path = $.Person.worksFor.Organization
const person = $.Person({
  name: 'Bob',
  worksFor: $.Organization({ name: 'Acme' }),
})

// Event patterns should use dot notation, not nesting
on($.Order({ status: 'created' }), handler)

// Use property access for event patterns
on($.Order.created, handler)

// Some APIs expect strings
const path = $.Person.worksFor.Organization
fetch(`/api/${path}`) // May not work as expected

// Explicitly convert to string
const path = $.Person.worksFor.Organization
fetch(`/api/${String(path)}`)
// or
fetch(`/api/${path.toString()}`)

// ❌ Bad: Creating path in loop
for (let i = 0; i < 10000; i++) {
  const path = $.Order.created
  // ... use path
}

// ✅ Good: Create path once
const orderCreatedPath = $.Order.created
for (let i = 0; i < 10000; i++) {
  // ... use orderCreatedPath
}

// ❌ Bad: Individual creates
for (const item of items) {
  await db.create('products', $.Product(item))
}

// ✅ Good: Batch create
const products = items.map((item) => $.Product(item))
await Promise.all(products.map((p) => db.create('products', p)))

// All these are equally efficient
on($.Order.created, handler)
on($.Payment.succeeded, handler)
on($.User.email.verified, handler)

// ✅ Available: Path construction
const path = $.Order.created
const type = $.Person

// ✅ Available: Query with semantic types
const orders = await db.list('orders')
const person = await db.get('people', 'person-123')

// ❌ Blocked: Creating records requires auth
await db.create('orders', $.Order({ ... }))

// ❌ Blocked: Event publishing requires auth
await send($.Order.created, { ... })

// Create records with semantic types
await db.create('orders', $.Order({ orderNumber: 'ORD-123' }))

// Subscribe to events
on($.Order.created, handler)

// Publish events
await send($.Payment.succeeded, { ... })