@dotdo/types

The universal shared type system for the .do ecosystem — enabling Business-as-Code and Services-as-Software.

Vision

The .do platform enables every aspect of a business to be defined, configured, and operated as code. Traditional services that require humans (accounting, legal, sales, support, HR) are delivered as software through typed, composable, autonomous agents.

.org.ai  (think)    →  Ontologies & abstractions for the AI-native future
.as      (define)   →  Typed interface definitions & schemas
.do      (execute)  →  Infrastructure & platform for Business-as-Code
.studio  (create)   →  AI-operated startups studio built on .do

This package provides the TypeScript types, interfaces, and runtime constants that power the entire stack — from semantic primitives to autonomous startup creation.

Install

pnpm add @dotdo/types

Usage

// Import core primitives
import type { Thing, Noun, Verb, Event, Action } from '@dotdo/types/things'

// Import platform primitives
import type { Fn, CodeFunction, GenerativeFunction } from '@dotdo/types/functions'
import type { Workflow } from '@dotdo/types/workflows'
import type { Database, Collection } from '@dotdo/types/database'

// Import high-level business abstractions
import type { Business } from '@dotdo/types/businesses'
import type { Startup } from '@dotdo/types/startups'
import type { SaaS, Tenant } from '@dotdo/types/saas'
import type { Service } from '@dotdo/types/services'
import type { Product } from '@dotdo/types/products'
import type { App } from '@dotdo/types/apps'
import type { API } from '@dotdo/types/apis'
import type { SDK } from '@dotdo/types/sdk'

// Import agent types
import type { Agent, AgentConfig } from '@dotdo/types/agents'
import type { Role } from '@dotdo/types/roles'
import type { Team } from '@dotdo/types/teams'

// Import runtime context
import type { DOContext } from '@dotdo/types/context'

// Runtime constants - discover domains, relationships, definitions
import { domains, relationships, definitions } from '@dotdo/types/domains'

Architecture

The type system follows a layered hierarchy from ontological primitives up to autonomous business creation:

Layer 0: Things (Ontological Foundation)

The semantic foundation everything builds on. Based on six universal primitives from .org.ai:

| Primitive | Purpose | Example | |-----------|---------|---------| | Thing | Universal base type | Any entity in the system | | Noun | Entity/object definitions | Customer, Product, Invoice | | Verb | Operation/action definitions | Create, Process, Deploy | | Event | Immutable occurrence records | OrderPlaced, PaymentReceived | | Action | Discrete executable operations | SendEmail, ChargeCard | | Domain | Namespace/context boundaries | Finance, Engineering, Sales |

Plus: Properties, Relationships, Cascade operators (->, ~>, <-, <~), Identity ($id), Semantics ($type, $context, JSON-LD/MDXLD).

Layer 1: Platform Primitives

The .do infrastructure that makes everything executable:

| Module | Domain | Purpose | |--------|--------|---------| | functions/ | functions.do | Computation (Code, Generative, Agentic, Human) | | workflows/ | workflows.do | Orchestration, scheduling, state machines | | database/ | database.do | Persistence (Relational, Document, Graph, Analytics) | | events/ | events.do | Reactivity, triggers, webhooks | | rpc/ | rpc.do | Communication, transports, proxying | | auth/ | oauth.do | Identity, OAuth, keys, RBAC, FGA | | workers/ | workers.do | Runtime (Durable Objects, colo, sandboxing) | | context/ | context.do | The unified $ runtime object |

Layer 2: AI (Intelligence Services)

| Module | Domain | Purpose | |--------|--------|---------| | ai/ | llm.do | LLM completion & streaming | | | embeddings.do | Vector embeddings | | | vectors.do | Similarity search | | | models.do | Model registry | | | evals.do | Evaluation & benchmarks |

Layer 3: Agents (Autonomous Actors)

| Module | Domain | Purpose | |--------|--------|---------| | agents/ | agents.do | Agent definitions, tools, memory | | roles/ | roles.do | Executive (CTO, CMO), IC (SWE, BDR) | | teams/ | teams.do | Agent composition (devs.do, engineers.do) |

Layer 4: Services & Products (What Gets Built)

| Module | Domain | Purpose | |--------|--------|---------| | apis/ | apis.do | API definitions, REST, MCP, discovery | | sdk/ | sdk.do, cli.do | SDK generation, CLI commands | | apps/ | apps.as | Applications, dashboards | | services/ | services.do | Services-as-Software | | products/ | products.do | Product definitions, roadmaps | | sites/ | sites.do | Web presence, blogs, directories |

Layer 5: Business (High-Level Abstractions)

| Module | Domain | Purpose | |--------|--------|---------| | businesses/ | businesses.do | Business entities, accounting, financials | | startups/ | startups.do | Startup formation, fundraising, validation | | saas/ | saas.as | Multi-tenancy, plans, usage metering | | payments/ | payments.do | Charges, accounts, cards, treasury | | communications/ | calls.do, texts.do, emails.do | Voice, SMS, email, messaging |

Layer 6: Content (Media & Publishing)

| Module | Domain | Purpose | |--------|--------|---------| | content/ | mdx.do, blogs.do | MDX/MDXLD, media, publishing, generation |

Layer 7: Integrations (External Connections)

| Module | Domain | Purpose | |--------|--------|---------| | integrations/ | *.do | Database, platform, payment, messaging integrations |

Layer 8: Builder (Meta-Creation)

| Module | Domain | Purpose | |--------|--------|---------| | builder/ | startups.studio | Factory for creating new businesses/products/services |

Domain Registry

| Module | Purpose | |--------|---------| | domains/ | Runtime constants: domain registry, relationships, .as definitions |

Domain Taxonomy

The .do ecosystem contains 300+ domains organized by category:

• Agents (~85) — Named AI workers (priya.do, tom.do, sally.do, mark.do...)
• Roles (~15) — Job functions (cto.do, cmo.do, swe.do, devs.do...)
• Primitives (~50) — Core platform (functions.do, workflows.do, database.do, events.do...)
• Business (~25) — Business-as-Code (payments.do, accounting.do, startups.do...)
• AI (~15) — Intelligence services (llm.do, embeddings.do, vectors.do, evals.do...)
• Content (~20) — Media & publishing (blogs.do, images.do, videos.do, mdx.do...)
• Infrastructure (~20) — Platform infra (browsers.do, tunnels.do, deployments.do...)
• Integrations (~30) — External (postgres.do, stripe.do, cloudflare.do, slack.do...)
• Utilities (~10) — Kits & tools (startupkit.do, agentkit.do, chatkit.do...)
• Definitions/.as (~36) — Interface schemas (agent.as, functions.as, workflows.as...)

Interface (.as) vs Implementation (.do)

// .as defines WHAT something must be (interface)
import type { Agent } from '@dotdo/types/agents'  // agent.as

// .do defines HOW it works (implementation types)
import type { AgentRuntime } from '@dotdo/types/agents'     // agents.do

The $ Context Object

Every .do service has access to a typed runtime context:

interface DOContext {
  ai: AIContext           // $.ai.generate(), $.ai.embed()
  db: DBContext           // $.db.collection(), $.db.query()
  on: OnContext           // $.on.event(), $.on.schedule()
  every: EveryContext     // $.every.hour(), $.every.day()
  email: EmailContext     // $.email.send()
  slack: SlackContext     // $.slack.post()
  sms: SMSContext         // $.sms.send()
  call: CallContext       // $.call.start()
  pay: PayContext         // $.pay.charge(), $.pay.transfer()
}

Function Tiers

Functions span from pure code to fully autonomous:

// Tier 1: Pure computation
const add: CodeFunction<number, { a: number; b: number }> = ...

// Tier 2: AI-powered generation
const summarize: GenerativeFunction<string, { text: string }> = ...

// Tier 3: Multi-step agent reasoning
const research: AgenticFunction<Report, { topic: string }> = ...

// Tier 4: Human-in-the-loop
const approve: HumanFunction<boolean, { proposal: Proposal }> = ...

Business-as-Code

Every business operation is typed and composable:

import type { Business, Startup, SaaS } from '@dotdo/types'

// A startup is a typed business entity
const myStartup: Startup = {
  name: 'Acme',
  stage: 'seed',
  hypothesis: 'SMBs need automated invoicing',
  team: ['priya.do', 'tom.do', 'sally.do'],
  products: [invoiceApp],
  metrics: { mrr: 0, customers: 0 }
}

Services-as-Software

Traditional services delivered through autonomous agents:

// sally.do - Sales agent
const sally: Agent = {
  role: 'sales',
  capabilities: ['prospect', 'qualify', 'close'],
  tools: ['emails.do', 'calls.do', 'crm'],
  autonomy: 'SemiAutonomous'
}

// accounting.do - Accounting service
const accounting: Service = {
  type: 'financial',
  capabilities: ['JournalEntries', 'FinancialReports', 'Reconciliation'],
  requires: ['payments.do', 'llm.do']
}

Builder / Studio

Agents can create new businesses, products, and services:

import type { StartupFactory, Template } from '@dotdo/types/builder'

// An agent creating a new startup
const factory: StartupFactory = {
  template: 'saas',
  config: {
    name: 'InvoiceBot',
    product: { type: 'app', framework: 'next' },
    services: ['payments.do', 'emails.do'],
    agents: ['priya.do', 'tom.do', 'sally.do'],
    infrastructure: { database: 'postgres', hosting: 'cloudflare' }
  }
}

Relationship Predicates

Types include relationship semantics for knowledge graphs:

| Category | Predicates | |----------|-----------| | Taxonomic | isA, instanceOf, subtypeOf, typeOf | | Compositional | partOf, memberOf, belongsTo, owns | | Dependency | uses, requires, enables, dependsOn | | Structural | extends, implements, inheritsFrom | | Integration | wraps, integrates, connectsTo | | Semantic | synonymOf, relatedTo, antonymOf | | Capability | provides, exposes | | Branding | brandedAs, aliasOf |

TypeScript Compatibility

This package supports TypeScript 5.0 and later. CI tests against multiple TypeScript versions:

| TypeScript Version | Status | Notes | |-------------------|--------|-------| | 5.0.x | Supported | Minimum supported version | | 5.4.x | Supported | Stable LTS | | 5.7.x | Supported | Latest features |

Version-Specific Notes

• TypeScript 5.0+: Required for verbatimModuleSyntax and modern moduleResolution: bundler
• TypeScript 5.4+: Improved NoInfer utility type, better generic inference
• TypeScript 5.7+: Latest type system improvements

Local Compatibility Testing

Run type checks against all supported versions:

pnpm test:ts-compat

This will install and test TypeScript 5.0, 5.4, and 5.7 in sequence.

Documentation as Tests

This repository uses a doctest system that validates all @example blocks in JSDoc comments. Every documented example is automatically tested to ensure documentation stays accurate.

# Run all doctest examples
pnpm test:e2e

# Show coverage report
pnpm test:e2e --report

See tests/e2e/README.md for more details.

Contributing

This package is the foundation of the entire .do ecosystem. Changes here affect every service, agent, and application in the platform.

License

MIT