@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:

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

Layer 1: Platform Primitives

The .do infrastructure that makes everything executable:

Layer 2: AI (Intelligence Services)

Layer 3: Agents (Autonomous Actors)

Layer 4: Services & Products (What Gets Built)

Layer 5: Business (High-Level Abstractions)

Layer 6: Content (Media & Publishing)

Layer 7: Integrations (External Connections)

Layer 8: Builder (Meta-Creation)

Domain Registry

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:

TypeScript Compatibility

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

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