business-as-code 0.0.2 → 0.2.0

package/dist/index.js

@@ -1,172 +1,1080 @@
-// src/business.ts
-function Business(config) {
-  const experiments = [];
-  const state = {
-    isLaunched: false,
-    isExecuting: false,
-    metrics: {}
+// src/schema/domains/admin.ts
+var Users = {
+  slug: "users",
+  group: "Admin",
+  titleField: "email",
+  fields: [
+    { name: "email", type: "email", required: true, unique: true },
+    { name: "name", type: "text" },
+    { name: "avatar", type: "image" },
+    { name: "role", type: "status", options: ["admin", "user", "viewer"] }
+  ]
+};
+var Orgs = {
+  slug: "orgs",
+  group: "Admin",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "slug", type: "text", required: true, unique: true },
+    { name: "logo", type: "image" },
+    { name: "domain", type: "text" }
+  ]
+};
+var ServiceAccounts = {
+  slug: "service-accounts",
+  group: "Admin",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "org", type: "ref", config: { relationTo: "orgs" } },
+    { name: "apiKey", type: "text", unique: true },
+    { name: "scopes", type: "array" }
+  ]
+};
+var adminNouns = [Users, Orgs, ServiceAccounts];
+
+// src/schema/domains/business.ts
+var Businesses = {
+  slug: "businesses",
+  group: "Business",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "legalName", type: "text" },
+    { name: "type", type: "status", options: ["LLC", "Corporation", "Partnership", "Sole Proprietorship", "Nonprofit"] },
+    { name: "status", type: "status", options: ["Active", "Inactive", "Dissolved"] },
+    { name: "foundedDate", type: "date" },
+    { name: "website", type: "url" },
+    { name: "description", type: "rich" }
+  ]
+};
+var Goals = {
+  slug: "goals",
+  group: "Business",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "type", type: "status", options: ["Revenue", "Growth", "Retention", "Efficiency", "Quality"] },
+    { name: "targetValue", type: "number" },
+    { name: "currentValue", type: "number" },
+    { name: "unit", type: "text" },
+    { name: "deadline", type: "date" },
+    { name: "status", type: "status", options: ["Not Started", "In Progress", "At Risk", "Achieved"] }
+  ]
+};
+var Metrics = {
+  slug: "metrics",
+  group: "Business",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "type", type: "status", options: ["KPI", "OKR", "North Star", "Health", "Vanity"] },
+    { name: "value", type: "number" },
+    { name: "unit", type: "text" },
+    { name: "frequency", type: "status", options: ["Real-time", "Daily", "Weekly", "Monthly", "Quarterly"] }
+  ]
+};
+var Teams = {
+  slug: "teams",
+  group: "Business",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "type", type: "status", options: ["Engineering", "Product", "Design", "Marketing", "Sales", "Support", "Operations", "Finance", "HR", "Legal"] },
+    { name: "description", type: "text" }
+  ]
+};
+var Processes = {
+  slug: "processes",
+  group: "Business",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "type", type: "status", options: ["Core", "Support", "Management"] },
+    { name: "owner", type: "ref", config: { relationTo: "teams" } },
+    { name: "description", type: "rich" },
+    { name: "status", type: "status", options: ["Draft", "Active", "Deprecated"] }
+  ]
+};
+var businessNouns = [Businesses, Goals, Metrics, Teams, Processes];
+
+// src/schema/domains/product.ts
+var Products = {
+  slug: "products",
+  group: "Product",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "type", type: "status", options: ["API", "App", "CLI", "SDK", "MCP", "Agent", "Dataset", "DataFeed", "Function", "Database", "Queue", "Storage", "Cache", "Platform"] },
+    { name: "description", type: "text" },
+    { name: "isActive", type: "boolean" },
+    { name: "stripeProductId", type: "text", unique: true }
+  ]
+};
+var Services = {
+  slug: "services",
+  group: "Product",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "type", type: "status", options: ["Consulting", "Implementation", "Training", "Support", "Managed"] },
+    { name: "description", type: "text" },
+    { name: "hourlyRate", type: "money" },
+    { name: "isActive", type: "boolean" }
+  ]
+};
+var Offers = {
+  slug: "offers",
+  group: "Product",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "products", type: "ref", config: { relationTo: "products", hasMany: true } },
+    { name: "type", type: "status", options: ["Trial", "Freemium", "Subscription", "One-time", "Usage-based"] },
+    { name: "description", type: "text" },
+    { name: "isActive", type: "boolean" }
+  ]
+};
+var Prices = {
+  slug: "prices",
+  group: "Product",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "offer", type: "ref", config: { relationTo: "offers" } },
+    { name: "amount", type: "money", required: true },
+    { name: "currency", type: "status", options: ["USD", "EUR", "GBP", "JPY"] },
+    { name: "interval", type: "status", options: ["once", "day", "week", "month", "year"] },
+    { name: "stripePriceId", type: "text", unique: true },
+    { name: "isActive", type: "boolean" }
+  ]
+};
+var Features = {
+  slug: "features",
+  group: "Product",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "product", type: "ref", config: { relationTo: "products" } },
+    { name: "description", type: "text" },
+    { name: "type", type: "status", options: ["Core", "Premium", "Enterprise", "Add-on"] },
+    { name: "status", type: "status", options: ["Planned", "In Development", "Beta", "GA", "Deprecated"] }
+  ]
+};
+var productNouns = [Products, Services, Offers, Prices, Features];
+
+// src/schema/domains/success.ts
+var Customers = {
+  slug: "customers",
+  group: "Success",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "type", type: "status", options: ["Business", "Developer", "Consumer", "Professional"], required: true },
+    { name: "user", type: "ref", config: { relationTo: "users" } },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "company", type: "text" },
+    { name: "email", type: "email" },
+    { name: "stripeCustomerId", type: "text", unique: true },
+    { name: "status", type: "status", options: ["Active", "Churned", "Paused"] },
+    { name: "healthScore", type: "score" }
+  ]
+};
+var Contacts = {
+  slug: "contacts",
+  group: "Success",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "customer", type: "ref", config: { relationTo: "customers" } },
+    { name: "email", type: "email" },
+    { name: "phone", type: "text" },
+    { name: "title", type: "text" },
+    { name: "role", type: "status", options: ["Decision Maker", "Influencer", "Champion", "End User", "Billing"] },
+    { name: "isPrimary", type: "boolean" }
+  ]
+};
+var Subscriptions = {
+  slug: "subscriptions",
+  group: "Success",
+  titleField: "id",
+  fields: [
+    { name: "customer", type: "ref", config: { relationTo: "customers" }, required: true },
+    { name: "offer", type: "ref", config: { relationTo: "offers" } },
+    { name: "price", type: "ref", config: { relationTo: "prices" } },
+    { name: "status", type: "status", options: ["Active", "Past Due", "Canceled", "Paused", "Trialing"] },
+    { name: "stripeSubscriptionId", type: "text", unique: true },
+    { name: "currentPeriodStart", type: "date" },
+    { name: "currentPeriodEnd", type: "date" },
+    { name: "canceledAt", type: "date" }
+  ]
+};
+var successNouns = [Customers, Contacts, Subscriptions];
+
+// src/schema/domains/sales.ts
+var Deals = {
+  slug: "deals",
+  group: "Sales",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "customer", type: "ref", config: { relationTo: "customers" } },
+    { name: "contact", type: "ref", config: { relationTo: "contacts" } },
+    { name: "value", type: "money" },
+    { name: "stage", type: "status", options: ["Qualification", "Discovery", "Proposal", "Negotiation", "Closed Won", "Closed Lost"] },
+    { name: "probability", type: "score" },
+    { name: "expectedCloseDate", type: "date" },
+    { name: "actualCloseDate", type: "date" },
+    { name: "lostReason", type: "text" }
+  ]
+};
+var Quotes = {
+  slug: "quotes",
+  group: "Sales",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "deal", type: "ref", config: { relationTo: "deals" } },
+    { name: "customer", type: "ref", config: { relationTo: "customers" } },
+    { name: "total", type: "money", required: true },
+    { name: "status", type: "status", options: ["Draft", "Sent", "Viewed", "Accepted", "Rejected", "Expired"] },
+    { name: "validUntil", type: "date" },
+    { name: "terms", type: "rich" }
+  ]
+};
+var Proposals = {
+  slug: "proposals",
+  group: "Sales",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "deal", type: "ref", config: { relationTo: "deals" } },
+    { name: "customer", type: "ref", config: { relationTo: "customers" } },
+    { name: "content", type: "rich" },
+    { name: "status", type: "status", options: ["Draft", "In Review", "Sent", "Accepted", "Rejected"] },
+    { name: "sentAt", type: "date" }
+  ]
+};
+var salesNouns = [Deals, Quotes, Proposals];
+
+// src/schema/domains/marketing.ts
+var Leads = {
+  slug: "leads",
+  group: "Marketing",
+  titleField: "email",
+  fields: [
+    { name: "email", type: "email", required: true },
+    { name: "name", type: "text" },
+    { name: "company", type: "text" },
+    { name: "title", type: "text" },
+    { name: "source", type: "status", options: ["Website", "Referral", "Event", "Ads", "Content", "Outbound", "Partner"] },
+    { name: "status", type: "status", options: ["New", "Contacted", "Qualified", "Unqualified", "Converted"] },
+    { name: "score", type: "score" },
+    { name: "convertedTo", type: "ref", config: { relationTo: "customers" } }
+  ]
+};
+var Brands = {
+  slug: "brands",
+  group: "Marketing",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "tagline", type: "text" },
+    { name: "description", type: "rich" },
+    { name: "logo", type: "image" },
+    { name: "primaryColor", type: "text" },
+    { name: "secondaryColor", type: "text" }
+  ]
+};
+var Domains = {
+  slug: "domains",
+  group: "Marketing",
+  titleField: "domain",
+  fields: [
+    { name: "domain", type: "text", required: true, unique: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "brand", type: "ref", config: { relationTo: "brands" } },
+    { name: "type", type: "status", options: ["Primary", "Redirect", "Vanity", "Product"] },
+    { name: "status", type: "status", options: ["Active", "Pending", "Expired"] },
+    { name: "registrar", type: "text" },
+    { name: "expiresAt", type: "date" }
+  ]
+};
+var Competitors = {
+  slug: "competitors",
+  group: "Marketing",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "website", type: "url" },
+    { name: "description", type: "text" },
+    { name: "strengths", type: "rich" },
+    { name: "weaknesses", type: "rich" },
+    { name: "threat", type: "status", options: ["Low", "Medium", "High", "Critical"] }
+  ]
+};
+var marketingNouns = [Leads, Brands, Domains, Competitors];
+
+// src/schema/domains/work.ts
+var Projects = {
+  slug: "projects",
+  group: "Work",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "team", type: "ref", config: { relationTo: "teams" } },
+    { name: "description", type: "rich" },
+    { name: "status", type: "status", options: ["Planning", "Active", "On Hold", "Completed", "Archived"] },
+    { name: "startDate", type: "date" },
+    { name: "targetDate", type: "date" },
+    { name: "completedDate", type: "date" }
+  ]
+};
+var Tasks = {
+  slug: "tasks",
+  group: "Work",
+  titleField: "title",
+  fields: [
+    { name: "title", type: "text", required: true },
+    { name: "project", type: "ref", config: { relationTo: "projects" } },
+    { name: "assignee", type: "ref", config: { relationTo: "users" } },
+    { name: "description", type: "rich" },
+    { name: "status", type: "status", options: ["Backlog", "Todo", "In Progress", "In Review", "Done"] },
+    { name: "priority", type: "status", options: ["Low", "Medium", "High", "Urgent"] },
+    { name: "dueDate", type: "date" },
+    { name: "estimatedHours", type: "number" },
+    { name: "actualHours", type: "number" }
+  ]
+};
+var Issues = {
+  slug: "issues",
+  group: "Work",
+  titleField: "title",
+  fields: [
+    { name: "title", type: "text", required: true },
+    { name: "project", type: "ref", config: { relationTo: "projects" } },
+    { name: "reporter", type: "ref", config: { relationTo: "users" } },
+    { name: "assignee", type: "ref", config: { relationTo: "users" } },
+    { name: "description", type: "rich" },
+    { name: "type", type: "status", options: ["Bug", "Feature", "Task", "Epic", "Story"] },
+    { name: "status", type: "status", options: ["Open", "In Progress", "Resolved", "Closed"] },
+    { name: "priority", type: "status", options: ["Low", "Medium", "High", "Critical"] }
+  ]
+};
+var Workflows = {
+  slug: "workflows",
+  group: "Work",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "description", type: "text" },
+    { name: "trigger", type: "status", options: ["Manual", "Schedule", "Event", "Webhook"] },
+    { name: "status", type: "status", options: ["Draft", "Active", "Paused", "Archived"] }
+  ]
+};
+var Roles = {
+  slug: "roles",
+  group: "Work",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "team", type: "ref", config: { relationTo: "teams" } },
+    { name: "description", type: "text" },
+    { name: "level", type: "status", options: ["Individual Contributor", "Lead", "Manager", "Director", "VP", "C-Level"] }
+  ]
+};
+var Agents = {
+  slug: "agents",
+  group: "Work",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "role", type: "ref", config: { relationTo: "roles" } },
+    { name: "type", type: "status", options: ["AI", "Human", "Hybrid"] },
+    { name: "status", type: "status", options: ["Active", "Paused", "Retired"] },
+    { name: "capabilities", type: "array" }
+  ]
+};
+var workNouns = [Projects, Tasks, Issues, Workflows, Roles, Agents];
+
+// src/schema/domains/financial.ts
+var Invoices = {
+  slug: "invoices",
+  group: "Financial",
+  titleField: "number",
+  fields: [
+    { name: "number", type: "text", required: true, unique: true },
+    { name: "customer", type: "ref", config: { relationTo: "customers" } },
+    { name: "subscription", type: "ref", config: { relationTo: "subscriptions" } },
+    { name: "total", type: "money", required: true },
+    { name: "tax", type: "money" },
+    { name: "status", type: "status", options: ["Draft", "Sent", "Paid", "Void", "Uncollectible"] },
+    { name: "dueDate", type: "date" },
+    { name: "paidAt", type: "date" },
+    { name: "stripeInvoiceId", type: "text", unique: true }
+  ]
+};
+var Payments = {
+  slug: "payments",
+  group: "Financial",
+  titleField: "id",
+  fields: [
+    { name: "customer", type: "ref", config: { relationTo: "customers" } },
+    { name: "invoice", type: "ref", config: { relationTo: "invoices" } },
+    { name: "amount", type: "money", required: true },
+    { name: "currency", type: "status", options: ["USD", "EUR", "GBP", "JPY"] },
+    { name: "status", type: "status", options: ["Pending", "Succeeded", "Failed", "Refunded"] },
+    { name: "method", type: "status", options: ["Card", "ACH", "Wire", "Check"] },
+    { name: "stripePaymentId", type: "text", unique: true }
+  ]
+};
+var Refunds = {
+  slug: "refunds",
+  group: "Financial",
+  titleField: "id",
+  fields: [
+    { name: "payment", type: "ref", config: { relationTo: "payments" }, required: true },
+    { name: "amount", type: "money", required: true },
+    { name: "reason", type: "status", options: ["Duplicate", "Fraudulent", "Customer Request", "Product Issue"] },
+    { name: "status", type: "status", options: ["Pending", "Succeeded", "Failed"] },
+    { name: "notes", type: "text" }
+  ]
+};
+var ChartOfAccounts = {
+  slug: "chart-of-accounts",
+  group: "Financial",
+  titleField: "name",
+  fields: [
+    { name: "code", type: "text", required: true, unique: true },
+    { name: "name", type: "text", required: true },
+    { name: "type", type: "status", options: ["Asset", "Liability", "Equity", "Revenue", "Expense"], required: true },
+    { name: "subtype", type: "text" },
+    { name: "description", type: "text" },
+    { name: "isActive", type: "boolean" }
+  ]
+};
+var JournalEntries = {
+  slug: "journal-entries",
+  group: "Financial",
+  titleField: "reference",
+  fields: [
+    { name: "reference", type: "text", required: true },
+    { name: "date", type: "date", required: true },
+    { name: "description", type: "text" },
+    { name: "debitAccount", type: "ref", config: { relationTo: "chart-of-accounts" } },
+    { name: "creditAccount", type: "ref", config: { relationTo: "chart-of-accounts" } },
+    { name: "amount", type: "money", required: true },
+    { name: "status", type: "status", options: ["Draft", "Posted", "Voided"] }
+  ]
+};
+var financialNouns = [Invoices, Payments, Refunds, ChartOfAccounts, JournalEntries];
+
+// src/schema/domains/communications.ts
+var Channels = {
+  slug: "channels",
+  group: "Communications",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "type", type: "status", options: ["Email", "SMS", "Slack", "Discord", "WhatsApp", "In-App", "Push"] },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "isActive", type: "boolean" },
+    { name: "config", type: "text" }
+  ]
+};
+var Messages = {
+  slug: "messages",
+  group: "Communications",
+  titleField: "subject",
+  fields: [
+    { name: "subject", type: "text" },
+    { name: "body", type: "rich", required: true },
+    { name: "channel", type: "ref", config: { relationTo: "channels" } },
+    { name: "from", type: "text" },
+    { name: "to", type: "text", required: true },
+    { name: "status", type: "status", options: ["Draft", "Queued", "Sent", "Delivered", "Bounced", "Failed"] },
+    { name: "sentAt", type: "date" },
+    { name: "openedAt", type: "date" },
+    { name: "clickedAt", type: "date" }
+  ]
+};
+var Sequences = {
+  slug: "sequences",
+  group: "Communications",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "type", type: "status", options: ["Onboarding", "Nurture", "Re-engagement", "Upsell", "Support"] },
+    { name: "status", type: "status", options: ["Draft", "Active", "Paused", "Archived"] },
+    { name: "description", type: "text" }
+  ]
+};
+var Templates = {
+  slug: "templates",
+  group: "Communications",
+  titleField: "name",
+  fields: [
+    { name: "name", type: "text", required: true },
+    { name: "channel", type: "ref", config: { relationTo: "channels" } },
+    { name: "subject", type: "text" },
+    { name: "body", type: "rich", required: true },
+    { name: "type", type: "status", options: ["Transactional", "Marketing", "System"] },
+    { name: "isActive", type: "boolean" }
+  ]
+};
+var Posts = {
+  slug: "posts",
+  group: "Communications",
+  titleField: "title",
+  fields: [
+    { name: "title", type: "text", required: true },
+    { name: "content", type: "rich", required: true },
+    { name: "author", type: "ref", config: { relationTo: "users" } },
+    { name: "business", type: "ref", config: { relationTo: "businesses" } },
+    { name: "status", type: "status", options: ["Draft", "Scheduled", "Published", "Archived"] },
+    { name: "publishedAt", type: "date" },
+    { name: "channels", type: "ref", config: { relationTo: "channels", hasMany: true } }
+  ]
+};
+var communicationsNouns = [Channels, Messages, Sequences, Templates, Posts];
+
+// src/schema/index.ts
+var defaultBusinessSchema = {
+  name: "default",
+  version: "1.0.0",
+  description: "Default business schema with all standard domains",
+  domains: {
+    admin: adminNouns,
+    business: businessNouns,
+    product: productNouns,
+    success: successNouns,
+    sales: salesNouns,
+    marketing: marketingNouns,
+    work: workNouns,
+    financial: financialNouns,
+    communications: communicationsNouns
+  }
+};
+function getAllNouns(schema) {
+  const nouns = [];
+  for (const domain of Object.values(schema.domains)) {
+    if (domain) {
+      nouns.push(...domain);
+    }
+  }
+  return nouns;
+}
+function getDomainNouns(schema, domain) {
+  return schema.domains[domain] || [];
+}
+function findNounBySlug(schema, slug) {
+  for (const domain of Object.values(schema.domains)) {
+    if (domain) {
+      const noun = domain.find((n) => n.slug === slug);
+      if (noun) return noun;
+    }
+  }
+  return void 0;
+}
+function getDomains(schema) {
+  return Object.keys(schema.domains);
+}
+function mergeSchemas(base, extension) {
+  const merged = {
+    name: extension.name || base.name,
+    version: extension.version || base.version,
+    description: extension.description || base.description,
+    domains: { ...base.domains }
   };
-  const business = {
-    ...config,
-    addExperiment(experiment) {
-      experiments.push(experiment);
-    },
-    async launch() {
-      if (state.isLaunched) {
-        return;
+  if (extension.domains) {
+    for (const [domain, nouns] of Object.entries(extension.domains)) {
+      if (nouns) {
+        const existing = merged.domains[domain] || [];
+        const existingSlugs = new Set(existing.map((n) => n.slug));
+        const newNouns = nouns.filter((n) => !existingSlugs.has(n.slug));
+        const overrides = nouns.filter((n) => existingSlugs.has(n.slug));
+        merged.domains[domain] = [
+          ...existing.filter((n) => !overrides.find((o) => o.slug === n.slug)),
+          ...overrides,
+          ...newNouns
+        ];
       }
-      if (business.workflows) {
-        for (const workflowKey in business.workflows) {
-          const workflow = business.workflows[workflowKey];
+    }
+  }
+  return merged;
+}
+function createMinimalSchema(domains, options) {
+  const schema = {
+    name: options?.name || "minimal",
+    version: options?.version || "1.0.0",
+    domains: {}
+  };
+  for (const domain of domains) {
+    schema.domains[domain] = defaultBusinessSchema.domains[domain];
+  }
+  return schema;
+}
+function validateSchema(schema) {
+  const errors = [];
+  if (!schema.name) {
+    errors.push("Schema must have a name");
+  }
+  if (!schema.version) {
+    errors.push("Schema must have a version");
+  }
+  const allSlugs = /* @__PURE__ */ new Set();
+  for (const [domain, nouns] of Object.entries(schema.domains)) {
+    if (nouns) {
+      for (const noun of nouns) {
+        if (!noun.slug) {
+          errors.push(`Noun in domain '${domain}' is missing a slug`);
+        } else if (allSlugs.has(noun.slug)) {
+          errors.push(`Duplicate slug '${noun.slug}' found in domain '${domain}'`);
+        } else {
+          allSlugs.add(noun.slug);
         }
-      }
-      if (business.agents) {
-        for (const agentKey in business.agents) {
-          const agent = business.agents[agentKey];
+        if (!noun.fields || noun.fields.length === 0) {
+          errors.push(`Noun '${noun.slug}' has no fields`);
         }
       }
-      state.isLaunched = true;
-    },
-    async execute() {
-      if (state.isExecuting) {
-        return;
-      }
-      if (!state.isLaunched) {
-        await business.launch();
-      }
-      state.isExecuting = true;
-      try {
-        if (business.workflows) {
-          for (const workflowKey in business.workflows) {
-            const workflow = business.workflows[workflowKey];
-            await workflow.execute();
-          }
-        }
-        for (const experiment of experiments) {
-          await experiment.start();
-        }
-      } finally {
-        state.isExecuting = false;
+    }
+  }
+  return errors;
+}
+
+// src/loaders/mdx.ts
+import { parseMDXAsync, extractNodesByName } from "db.sb";
+function nodeToNounSchema(node) {
+  const fields = [];
+  if (node.children) {
+    for (const child of node.children) {
+      if (typeof child === "object" && "__dsl" in child) {
+        const fieldNode = child;
+        fields.push({
+          name: fieldNode.name,
+          type: fieldNode.type,
+          required: fieldNode.props.required,
+          unique: fieldNode.props.unique,
+          config: fieldNode.props
+        });
       }
     }
+  }
+  return {
+    slug: node.props.slug || node.name,
+    group: node.props.group,
+    titleField: node.props.titleField || node.props.useAsTitle,
+    fields
   };
-  return business;
 }
-
-// src/experiment.ts
-function Experiment(config) {
-  const state = {
-    isRunning: false,
-    startTime: null,
-    endTime: null,
-    variantData: {}
+async function loadFromMDX(source, options = {}) {
+  const ast = await parseMDXAsync(source, options.context || "app");
+  const name = ast.props.name || "unnamed";
+  const version = ast.props.version || "1.0.0";
+  const description = ast.props.description;
+  const nounNodes = extractNodesByName(ast, "noun");
+  const domains = {};
+  for (const node of nounNodes) {
+    const noun = nodeToNounSchema(node);
+    const group = noun.group?.toLowerCase() || "business";
+    if (!domains[group]) {
+      domains[group] = [];
+    }
+    domains[group].push(noun);
+  }
+  return {
+    name,
+    version,
+    description,
+    domains
   };
-  for (const variantKey in config.variants) {
-    state.variantData[variantKey] = {
-      metrics: config.metrics.reduce((acc, metric) => {
-        acc[metric] = [];
-        return acc;
-      }, {}),
-      sampleCount: 0
-    };
-  }
-  const experiment = {
-    ...config,
-    async start() {
-      if (state.isRunning) {
-        return;
-      }
-      state.isRunning = true;
-      state.startTime = /* @__PURE__ */ new Date();
-      for (const variantKey in experiment.variants) {
-        const variant = experiment.variants[variantKey];
-        if (typeof variant.workflow === "string") {
-        }
-        if (typeof variant.agent === "string") {
-        }
-        if (typeof variant.function === "string") {
-        }
+}
+async function loadNounFromMDX(source, options = {}) {
+  const ast = await parseMDXAsync(source, options.context || "noun");
+  if (ast.name !== "noun") {
+    const nounNodes = extractNodesByName(ast, "noun");
+    if (nounNodes.length === 0) {
+      throw new Error("No Noun definition found in MDX");
+    }
+    return nodeToNounSchema(nounNodes[0]);
+  }
+  return nodeToNounSchema(ast);
+}
+async function loadNounsFromMDX(source, options = {}) {
+  const ast = await parseMDXAsync(source, options.context || "app");
+  const nounNodes = extractNodesByName(ast, "noun");
+  return nounNodes.map(nodeToNounSchema);
+}
+
+// src/loaders/yaml.ts
+import YAML from "yaml";
+function parseFieldShorthand(name, value) {
+  if (typeof value === "object") {
+    return { ...value, name };
+  }
+  const parts = value.split(" ");
+  const field = { name, type: "text" };
+  for (const part of parts) {
+    if (part === "required") {
+      field.required = true;
+    } else if (part === "unique") {
+      field.unique = true;
+    } else if (part.includes(":")) {
+      const [type, options] = part.split(":");
+      field.type = type;
+      if (type === "status" || type === "select") {
+        field.options = options.split("|");
+      } else if (type === "ref") {
+        field.to = options;
       }
-    },
-    async stop() {
-      if (!state.isRunning) {
-        return;
+    } else {
+      field.type = part;
+    }
+  }
+  return field;
+}
+function parseNoun(data) {
+  const fields = [];
+  if (data.fields) {
+    if (Array.isArray(data.fields)) {
+      for (const field of data.fields) {
+        fields.push(field);
       }
-      state.isRunning = false;
-      state.endTime = /* @__PURE__ */ new Date();
-    },
-    async analyze() {
-      if (state.isRunning) {
-        await experiment.stop();
+    } else {
+      for (const [name, value] of Object.entries(data.fields)) {
+        fields.push(parseFieldShorthand(name, value));
       }
-      const variantPerformance = {};
-      for (const variantKey in state.variantData) {
-        const variantData = state.variantData[variantKey];
-        const metrics = {};
-        for (const metricKey in variantData.metrics) {
-          const values = variantData.metrics[metricKey];
-          if (values.length > 0) {
-            metrics[metricKey] = values.reduce((sum, value) => sum + value, 0) / values.length;
-          } else {
-            metrics[metricKey] = 0;
-          }
-        }
-        variantPerformance[variantKey] = {
-          metrics,
-          sampleSize: variantData.sampleCount
-        };
+    }
+  }
+  return {
+    slug: data.slug || data.name?.toLowerCase().replace(/\s+/g, "-"),
+    group: data.group,
+    titleField: data.titleField || data.useAsTitle,
+    fields
+  };
+}
+function loadFromYAML(source, _options = {}) {
+  const data = YAML.parse(source);
+  const schema = {
+    name: data.name || "unnamed",
+    version: data.version || "1.0.0",
+    description: data.description,
+    domains: {}
+  };
+  if (data.domains) {
+    for (const [domain, nouns] of Object.entries(data.domains)) {
+      if (Array.isArray(nouns)) {
+        schema.domains[domain] = nouns.map(parseNoun);
       }
-      let winner;
-      let highestScore = -Infinity;
-      const primaryMetric = experiment.metrics[0];
-      for (const variantKey in variantPerformance) {
-        const performance = variantPerformance[variantKey];
-        const score = performance.metrics[primaryMetric] || 0;
-        if (score > highestScore) {
-          highestScore = score;
-          winner = variantKey;
-        }
+    }
+  }
+  if (data.nouns) {
+    for (const nounData of data.nouns) {
+      const noun = parseNoun(nounData);
+      const domain = noun.group?.toLowerCase() || "business";
+      if (!schema.domains[domain]) {
+        schema.domains[domain] = [];
       }
-      const insights = [
-        `Experiment ran for ${state.startTime && state.endTime ? Math.round((state.endTime.getTime() - state.startTime.getTime()) / (1e3 * 60 * 60 * 24)) : "unknown"} days`,
-        winner ? `Variant "${winner}" performed best on primary metric "${primaryMetric}"` : "No clear winner determined"
-      ];
-      return {
-        variantPerformance,
-        winner,
-        confidence: 0.95,
-        // Placeholder - would calculate actual confidence in real implementation
-        insights
-      };
+      schema.domains[domain].push(noun);
     }
-  };
-  return experiment;
+  }
+  return schema;
+}
+function loadNounFromYAML(source, _options = {}) {
+  const data = YAML.parse(source);
+  return parseNoun(data);
+}
+function loadNounsFromYAML(source, _options = {}) {
+  const data = YAML.parse(source);
+  if (Array.isArray(data)) {
+    return data.map(parseNoun);
+  }
+  if (data.nouns) {
+    return data.nouns.map(parseNoun);
+  }
+  return [parseNoun(data)];
+}
+function toYAML(schema) {
+  return YAML.stringify({
+    name: schema.name,
+    version: schema.version,
+    description: schema.description,
+    domains: schema.domains
+  });
+}
+function nounToYAML(noun) {
+  return YAML.stringify(noun);
 }
 
-// src/models/lean-canvas.ts
-function LeanCanvas(config) {
+// src/loaders/json.ts
+function parseFieldShorthand2(name, value) {
+  if (typeof value === "object") {
+    return { ...value, name };
+  }
+  const parts = value.split(" ");
+  const field = { name, type: "text" };
+  for (const part of parts) {
+    if (part === "required") {
+      field.required = true;
+    } else if (part === "unique") {
+      field.unique = true;
+    } else if (part.includes(":")) {
+      const [type, options] = part.split(":");
+      field.type = type;
+      if (type === "status" || type === "select") {
+        field.options = options.split("|");
+      } else if (type === "ref") {
+        field.to = options;
+      }
+    } else {
+      field.type = part;
+    }
+  }
+  return field;
+}
+function parseNoun2(data) {
+  const fields = [];
+  if (data.fields) {
+    if (Array.isArray(data.fields)) {
+      for (const field of data.fields) {
+        fields.push(field);
+      }
+    } else {
+      for (const [name, value] of Object.entries(data.fields)) {
+        fields.push(parseFieldShorthand2(name, value));
+      }
+    }
+  }
   return {
-    ...config
+    slug: data.slug || data.name?.toLowerCase().replace(/\s+/g, "-"),
+    group: data.group,
+    titleField: data.titleField || data.useAsTitle,
+    fields
   };
 }
-
-// src/models/story-brand.ts
-function StoryBrand(config) {
-  return {
-    ...config
+function loadFromJSON(source, _options = {}) {
+  const data = JSON.parse(source);
+  const schema = {
+    name: data.name || "unnamed",
+    version: data.version || "1.0.0",
+    description: data.description,
+    domains: {}
   };
+  if (data.domains) {
+    for (const [domain, nouns] of Object.entries(data.domains)) {
+      if (Array.isArray(nouns)) {
+        schema.domains[domain] = nouns.map(parseNoun2);
+      }
+    }
+  }
+  if (data.nouns) {
+    for (const nounData of data.nouns) {
+      const noun = parseNoun2(nounData);
+      const domain = noun.group?.toLowerCase() || "business";
+      if (!schema.domains[domain]) {
+        schema.domains[domain] = [];
+      }
+      schema.domains[domain].push(noun);
+    }
+  }
+  return schema;
+}
+function loadNounFromJSON(source, _options = {}) {
+  const data = JSON.parse(source);
+  return parseNoun2(data);
+}
+function loadNounsFromJSON(source, _options = {}) {
+  const data = JSON.parse(source);
+  if (Array.isArray(data)) {
+    return data.map(parseNoun2);
+  }
+  if (data.nouns) {
+    return data.nouns.map(parseNoun2);
+  }
+  return [parseNoun2(data)];
+}
+function toJSON(schema, pretty = true) {
+  return JSON.stringify(
+    {
+      name: schema.name,
+      version: schema.version,
+      description: schema.description,
+      domains: schema.domains
+    },
+    null,
+    pretty ? 2 : void 0
+  );
+}
+function nounToJSON(noun, pretty = true) {
+  return JSON.stringify(noun, null, pretty ? 2 : void 0);
 }
 
-// src/models/value-proposition.ts
-function ValueProposition(config) {
+// src/loaders/index.ts
+function detectFormat(source) {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    return "json";
+  }
+  if (trimmed.includes("<") && trimmed.includes(">")) {
+    return "mdx";
+  }
+  return "yaml";
+}
+async function load(source, options = {}) {
+  const format = options.format || detectFormat(source);
+  let schema;
+  switch (format) {
+    case "mdx":
+      schema = await loadFromMDX(source, options);
+      break;
+    case "yaml":
+      schema = loadFromYAML(source, options);
+      break;
+    case "json":
+      schema = loadFromJSON(source, options);
+      break;
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
   return {
-    ...config
+    schema,
+    format
   };
 }
+async function loadNoun(source, options = {}) {
+  const format = options.format || detectFormat(source);
+  switch (format) {
+    case "mdx":
+      return loadNounFromMDX(source, options);
+    case "yaml":
+      return loadNounFromYAML(source, options);
+    case "json":
+      return loadNounFromJSON(source, options);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+async function loadNouns(source, options = {}) {
+  const format = options.format || detectFormat(source);
+  switch (format) {
+    case "mdx":
+      return loadNounsFromMDX(source, options);
+    case "yaml":
+      return loadNounsFromYAML(source, options);
+    case "json":
+      return loadNounsFromJSON(source, options);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function serialize(schema, format = "yaml") {
+  switch (format) {
+    case "yaml":
+      return toYAML(schema);
+    case "json":
+      return toJSON(schema);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+function serializeNoun(noun, format = "yaml") {
+  switch (format) {
+    case "yaml":
+      return nounToYAML(noun);
+    case "json":
+      return nounToJSON(noun);
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
 export {
-  Business,
-  Experiment,
-  LeanCanvas,
-  StoryBrand,
-  ValueProposition
+  Agents,
+  Brands,
+  Businesses,
+  Channels,
+  ChartOfAccounts,
+  Competitors,
+  Contacts,
+  Customers,
+  Deals,
+  Domains,
+  Features,
+  Goals,
+  Invoices,
+  Issues,
+  JournalEntries,
+  Leads,
+  Messages,
+  Metrics,
+  Offers,
+  Orgs,
+  Payments,
+  Posts,
+  Prices,
+  Processes,
+  Products,
+  Projects,
+  Proposals,
+  Quotes,
+  Refunds,
+  Roles,
+  Sequences,
+  ServiceAccounts,
+  Services,
+  Subscriptions,
+  Tasks,
+  Teams,
+  Templates,
+  Users,
+  Workflows,
+  adminNouns,
+  businessNouns,
+  communicationsNouns,
+  createMinimalSchema,
+  defaultBusinessSchema,
+  financialNouns,
+  findNounBySlug,
+  getAllNouns,
+  getDomainNouns,
+  getDomains,
+  load,
+  loadFromJSON,
+  loadFromMDX,
+  loadFromYAML,
+  loadNoun,
+  loadNounFromJSON,
+  loadNounFromMDX,
+  loadNounFromYAML,
+  loadNouns,
+  loadNounsFromJSON,
+  loadNounsFromMDX,
+  loadNounsFromYAML,
+  marketingNouns,
+  mergeSchemas,
+  nounToJSON,
+  nounToYAML,
+  productNouns,
+  salesNouns,
+  serialize,
+  serializeNoun,
+  successNouns,
+  toJSON,
+  toYAML,
+  validateSchema,
+  workNouns
 };
+//# sourceMappingURL=index.js.map