---
title: "Build it"
url: https://services.dev/docs/examples/legal/build
captured: [legal-build.txt]
---
# Build it

URL: https://services.dev/docs/examples/legal/build

> The legal brand's folder, one file at a time. Its words, its rules table and its Pool first, then six Services, with check after each one.

*legal's words: matter is a job, asset is a subject, review is a task, signer is a member, network is a pool, outcome is a end (examples/legal/brand.ts).*

The brand is a folder: `brand.ts`, `rules.ts`, `pools/attorneys.ts`, and one file per Service under `services/`. Write them in that order and run `check` after each. The count it prints is lines of code, comments left out, and every file stays within 40.

## brand.ts

The brand's words. Every surface its clients, agents and attorneys read says matter, review and signer, and `also` keeps api.lawyer's own paths for the same operations. [Your brand's words](https://services.dev/docs/service/brand-words.md) covers each key.

```bash
cat brand.ts
```

```txt title="magic values: none"
import { Brand } from 'services.dev'

// A legal brand shaped like api.lawyer. Its words render every surface its
// buyers, agents and signers read: /matters, matter.ordered, get_matter. `also` keeps api.lawyer's own paths
// for the same rows: a matter's journal and attestations are its record, its documents are its files, and a
// signer's conflicts ledger is /conflicts.
export default Brand({
  domain: 'api.lawyer',
  words: { job: 'matter', subject: 'asset', task: 'review', member: 'signer', pool: 'network', end: 'outcome' },
  also: {
    'job.record': ['/matters/:id/journal', '/matters/:id/attestations?type=attested'],
    'job.files.list': '/matters/:id/documents',
    'job.files.put': 'POST /matters/:id/documents',
    'job.end': '/matters/:id/terminal',
    'member.ledger.get': '/conflicts',
    'member.ledger.add': '/conflicts/entries',
  },
})
```

With no Service yet, `check` has nothing to sell:

```bash
npx services.dev check   # after brand.ts
```

```txt title="magic values: none"
No Services here.
  next    npx services.dev init
```

## rules.ts

Who may perform each act, per Service, frozen under a version. Every row is illustrative and records its position. [The rules table](https://services.dev/docs/examples/legal/rules.md) reads each one.

```bash
cat rules.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Rules } from 'services.dev'

// Rows per Service, frozen and versioned. A brand's counsel authors its real
// table, and every row records its position. An advice row reserves a class of answer, held in the job's thread until
// the attorney on the matter adopts it. An attorney's fee is the signer's own, sold on their account at the same
// checkout; a practitioner's act on a patent is the brand's.
const practitioner = ['patent attorney', 'patent agent']

export default Rules({
  version: '2026-10',
  services: {
    'provisional-patent': {
      second_look: { reserved: practitioner, where: '*', rail: 'brand', position: 'Judgment on a draft the review still flags is the practitioner\'s.' },
      sign: { reserved: practitioner, where: '*', self: true, rail: 'brand', position: 'Signed by a registered practitioner, or by the applicant for themselves.' },
      file: { reserved: practitioner, where: '*', self: true, rail: 'brand', position: 'Filing for another is practice before the office.' },
    },
    'trademark-response': {
      respond: { reserved: 'bar admission', where: '*', rail: 'member', position: 'A response for the applicant is signed by an attorney admitted in any state.' },
      file: { reserved: 'bar admission', where: '*', rail: 'member', position: 'Filing the response for the applicant is practice before the office.' },
      fee: { open: true, position: 'Paying the office its fee is a delivery act.' },
    },
    'contract-review': {
      advise: { reserved: 'bar admission', where: 'client', regions: ['US-CA', 'US-NY', 'US-TX'], kind: 'advice', rail: 'member', position: 'Advice on a contract is legal advice in the client\'s state.' },
      send: { open: true, position: 'Sending a signed memo to its client is a delivery act.' },
    },
    'demand-letter': {
      sign: {
        reserved: 'bar admission', where: 'client', rail: 'member', position: 'A letter on counsel\'s letterhead is signed by counsel.',
        flags: { recipient_elsewhere: job => job.input.recipient_region !== job.input.client_region },
      },
      send: { open: true, position: 'Delivering a signed letter is a delivery act.' },
      courier: { open: true, position: 'Delivering it by courier is a delivery act.' },
      settle: { client: true, position: 'Whether to settle, and for how much, is the client\'s decision alone.' },
    },
    'docket-watch': {
      ack: { open: true, position: 'Acknowledging a date on the docket is a delivery act; the response is its own Service.' },
    },
    formation: {
      advise_entity_choice: { reserved: 'bar admission', where: 'client', kind: 'advice', rail: 'member', position: 'Which entity to form is advice.' },
      form_entity: { open: true, position: 'The brand files the certificate as a filing service.' },
      advise_83b: { reserved: 'bar admission', where: 'client', kind: 'advice', rail: 'member', position: 'Whether to make the election is advice.' },
    },
  },
  shared: { litigate: { refused: true, route: 'https://referrals.example.test/litigation', position: 'Litigation is retained directly, never ordered here.' } },
})
```

## pools/attorneys.ts

The people: four roles, each a credential the Pool's verifier checks, and what a member sees before and after they claim. [The attorneys' Pool](https://services.dev/docs/examples/legal/pool.md) shows a member join.

```bash
cat pools/attorneys.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Pool } from 'services.dev'

// One Pool, shared by every legal Service: attorneys join, the verifier checks each admission, and
// a cascade offers each Task one member at a time, because `check` names parties. Tiers are computed from outcomes,
// so the default fill ladder widens to the next one down. An attorney's own malpractice policy covers their act; one
// who carries none is covered by the Pool's, at $4 an act. A claim holds three times the step's estimate, at least a day.
export const attorneys = Pool({
  name: 'attorneys',
  roles: {
    attorney: { credential: 'bar admission' },
    practitioner: { credential: ['patent attorney', 'patent agent'], where: '*' },
    watcher: { credential: ['patent attorney', 'patent agent'], where: '*' },
    student: { credential: 'law school enrollment' },
  },
  scopes: { 'bar admission': 'region', 'patent attorney': '*', 'patent agent': '*', 'law school enrollment': 'region' },
  join: {
    name: 'text: your name as admitted', credential: ['bar admission', 'patent attorney', 'patent agent', 'law school enrollment'],
    number: 'text: your bar or registration number', regions: 'jurisdiction[]: every place you are admitted',
    areas: ['patents', 'trademarks', 'contracts', 'entities', 'collections'], hours: 'number: spare hours a week',
    turnaround: ['same day', '24h', '48h'], min_fee: 'money: the least you would take per review',
  },
  verify: 'https://verify.example.test/credentials',
  coverage: { per_act: 1_000_000, by: 'either', usd: 4 },
  sees: { teaser: ['act', 'region', 'fee_usd', 'signals'], sheet: ['parties', 'kind', 'amount'] },
  clear: { attest: ['I checked conflicts across my full book, including my firm'], check: ['client', 'applicant', 'recipient'] },
  affinity: '30d', rank: ['fit', 'track', 'speed'],
  tiers: [{ name: 'reviewer' }, { name: 'signer', after: 20, sendbacks: '5%', on_time: '95%' }, { name: 'counsel', after: 100, sendbacks: '3%', on_time: '98%' }],
})
```

## services/trademark-response.ts

The first Service answers an office action and files it. Now `check` reads the whole folder: the brand, the table and the Pool, then the Service's steps, who signs, and what each matter leaves you.

```bash
cat services/trademark-response.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Service } from 'services.dev'
import { attorneys } from '../pools/attorneys.ts'
import rules from '../rules.ts'

// The attorney comes from the attorneys Pool, admitted anywhere, and signs and files on their own
// account. The office action's three-month clock sits on the family, and an extension moves it.
export default Service({
  name: 'Trademark Office Action Response',
  description: 'An office action answered and filed.',
  input: { serial: 'text: such as 97123456', action: 'file: the office action', issued: 'date: such as 2026-10-01', client: 'party' },
  output: { response: 'file', receipt: 'text' },
  rules,
  roles: { attorney: { pool: attorneys, pay: 175 } },
  deliver: {
    consent: { ask: 'client', to: 'consent', expires: '7d' },
    read: { by: 'ai', cite: 'source' },
    evidence: { ask: 'client', to: 'upload', items: () => [{ id: 'specimen', label: 'A specimen showing the mark in use' }] },
    draft: 'ai',
    attack: { review: 'adversarial', lenses: ['likelihood of confusion', 'descriptiveness', 'specimen'] },
    respond: { by: 'attorney', stamp: true, est: '1h', checklist: ['every ground is answered', 'the specimen shows use'] },
    file: {
      submit: 'https://filings.example.test/trademark-office', to: 'USPTO', receipt: 'receipt',
      rejected: { missing_specimen: 'evidence', fee_deficiency: 'fee', '*': 'draft' },
    },
    fee: { routed: true, submit: 'https://filings.example.test/fees', to: 'USPTO', receipt: 'receipt', next: () => 'file' },
  },
  ends: { abandoned: { charge: 'acts', by: ['client', 'clock'] } },
  price: { usd: 349, release: 'file' },
})
```

```bash
npx services.dev check   # after services/trademark-response.ts
```

```txt title="magic values: none"
brand.ts · 10 lines · legal · api.lawyer · words job → matter, subject → asset, task → review, member → signer, pool → network, end → outcome
rules.ts · 36 lines · rules 2026-10 · 6 Services · 16 rows · 1 shared
pools/attorneys.ts · 20 lines · attorneys · 4 roles: attorney, practitioner, watcher, student · joins in 3 steps · cascade · hold 24h
inert   rules rail on 9 rows: the ledger names who sells each fee; money moves at payout

services/trademark-response.ts · 21 lines · $349 per job, within 48 hours, charged on file's receipt.
  who     An attorney signs every response before it is filed. (rules 2026-10) The client consents first and uploads at evidence.
  roles   attorney · bar admission · from attorneys · $175 an act
  steps   consent · client · consent → read · ai · cites source → evidence · client · upload → draft · ai → attack · ai · adversarial · 3 lenses → respond · attorney · * · stamped · 2-item checklist → file · USPTO → fee · USPTO · routed
  bounds  reserved respond and file to bar admission · the attorney sells the fee · open fee · refused litigate
  agent   order_trademark_response · 30 of 30 words · add "such as …" to client for an agent to try it
  ledger  +$349.00 · attorney's fee $175.00, sold by the attorney (rail member) · brand $174.00 · AI $2.10 (example) · coverage $4.00 · you $167.90
  margin  at least $100.20 when the first attorney signs ($349.00 − $175.00 attorney − $69.80 AI cap − $4.00 coverage) · $12.70 at the ladder's cap, the lower of 50% and what the floor leaves · −$78.80 after a decline and a second attorney
          a job that stops costs you at most $244.80
  apps    customer portal · delivery portal · owner console
  ✗ The rules table binds a name nothing reads: a key that names no Service file, or a row no step performs that is neither an advice class nor refused. Rename it to what it means, or take it out. rules.services has a key 'provisional-patent', and no Service file is services/provisional-patent.ts. rules.services has a key 'contract-review', and no Service file is services/contract-review.ts. rules.services has a key 'demand-letter', and no Service file is services/demand-letter.ts. rules.services has a key 'docket-watch', and no Service file is services/docket-watch.ts. rules.services has a key 'formation', and no Service file is services/formation.ts.
    at rules.ts:12 · rules.services['provisional-patent']
    https://services.dev/docs/reference/check/rule_unread

mcp     13 buyer tools · 4,633 of 8,000 tokens · 9 more with ?toolset=sandbox
✗ 1 to fix
  next    Rename it to what it means, or take it out. rules.services has a key 'provisional-patent', and no Service file is services/provisional-patent.ts. rules.services has a key 'contract-review', and no Service file is services/contract-review.ts. rules.services has a key 'demand-letter', and no Service file is services/demand-letter.ts. rules.services has a key 'docket-watch', and no Service file is services/docket-watch.ts. rules.services has a key 'formation', and no Service file is services/formation.ts.

AI and money are simulated until you wire them. $0.42 a call is an example.
```

The table names six Services and the folder has one, so `check` holds the brand at [`rule_unread`](https://services.dev/docs/reference/check/rule_unread.md) until each is written.

## services/docket-watch.ts

A subscription on the patent family that routes an office action to the response. [Docket watch](https://services.dev/docs/examples/legal/docket-watch.md) walks it:

```bash
cat services/docket-watch.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Service } from 'services.dev'
import { attorneys } from '../pools/attorneys.ts'
import rules from '../rules.ts'
import trademarkResponse from './trademark-response.ts'

// A subscription on the patent family, $12 a month. Every Monday the AI checks the docket, and inside
// the last week before a date on the family, the watcher acknowledges it too. An office action routes to its own Service.
export default Service({
  name: 'Docket Watch',
  description: 'A docket watched every week, and an office action routed to its response.',
  input: { matter: 'text: an application or file number' },
  output: { status: 'text', next_due: 'date' },
  rules,
  subject: { kind: 'patent family', key: 'matter' },
  roles: { watcher: { pool: attorneys, pay: { usd: 4, on: 'act' } } },
  on: { schedule: { check: 'every monday' }, event: { 'office_action.issued': trademarkResponse } },
  deliver: { check: 'ai', ack: { by: 'watcher', when: job => job.clocks.inside('7d') } },
  price: { usd: 12, every: 'month' },
})
```

```bash
npx services.dev check   # after services/docket-watch.ts
```

```txt title="magic values: none"
services/docket-watch.ts · 10 lines · $12 per month, charged at the start of each month.
  ledger  +$12.00 · AI $0.84 (example) · watcher $4.00 · coverage $4.00 · you $3.16
  ✗ The rules table binds a name nothing reads: a key that names no Service file, or a row no step performs that is neither an advice class nor refused. Rename it to what it means, or take it out. rules.services has a key 'provisional-patent', and no Service file is services/provisional-patent.ts. rules.services has a key 'contract-review', and no Service file is services/contract-review.ts. rules.services has a key 'demand-letter', and no Service file is services/demand-letter.ts. rules.services has a key 'formation', and no Service file is services/formation.ts.
✗ 1 to fix
```

## services/provisional-patent.ts

Its patent family names the docket watch as its steward.

```bash
cat services/provisional-patent.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Service } from 'services.dev'
import { attorneys } from '../pools/attorneys.ts'
import rules from '../rules.ts'
import docketWatch from './docket-watch.ts'

// The practitioner comes from the attorneys Pool, and the rules reserve signing and filing. price.self
// lets the applicant sign and file it themselves, for $79. The practitioner who signs stays of record on the patent
// family; if their registration lapses, another practitioner covers it, then the brand. The docket watch keeps its dates.
export default Service({
  name: 'Provisional Patent Application',
  description: 'A provisional application, drafted, examined, filed.',
  input: {
    invention: 'file[]: a description, drawings, anything you have',
    applicant: 'party', inventors: 'party[]', entity_size: ['micro', 'small', 'large'],
  },
  output: { application: 'file', exam: 'file', application_number: 'text' },
  rules,
  roles: { practitioner: { pool: attorneys, pay: 150 } },
  deliver: {
    consent: { ask: 'applicant', to: 'consent', expires: '7d' },
    questions: { ask: 'applicant', to: 'answer', within: '3d' },
    draft: { by: 'ai', cite: 'source' },
    examine: { review: 'adversarial', lenses: ['eligibility', 'novelty', 'obviousness', 'written description'], rounds: 3, exhausted: 'second_look' },
    second_look: { by: 'practitioner', routed: true, est: '1h' },
    sign: { by: 'practitioner', stamp: true, est: '1h', checklist: ['the claims read on the disclosure', 'every inventor is named', 'a reasonable inquiry was made'] },
    file: { submit: 'https://filings.example.test/patent-office', to: 'USPTO', receipt: 'application_number', wait: '2d', rejected: 'draft' },
  },
  subject: {
    kind: 'patent family', key: 'application_number', steward: docketWatch,
    of_record: { role: 'practitioner', named_at: 'sign', custodian: ['practitioner', 'brand'] },
  },
  ends: { withdrawn: { charge: 'acts', by: 'client' }, referred_out: { charge: false } },
  price: { usd: 199, self: 79, release: 'file', within: '5d' },
})
```

```bash
npx services.dev check   # after services/provisional-patent.ts
```

```txt title="magic values: none"
  ✗ The rules table binds a name nothing reads: a key that names no Service file, or a row no step performs that is neither an advice class nor refused. Rename it to what it means, or take it out. rules.services has a key 'contract-review', and no Service file is services/contract-review.ts. rules.services has a key 'demand-letter', and no Service file is services/demand-letter.ts. rules.services has a key 'formation', and no Service file is services/formation.ts.
services/provisional-patent.ts · 24 lines · $199 per job, within 5 days, charged on file's receipt.
✗ 1 to fix
```

## The other three

Each file, whole, then what `check` prints once it's added; each one's page walks it:

[`services/contract-review.ts`](https://services.dev/docs/examples/legal/contract-review.md):

```bash
cat services/contract-review.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Service } from 'services.dev'
import { attorneys } from '../pools/attorneys.ts'
import rules from '../rules.ts'

// The attorney comes from the attorneys Pool, admitted where the client is, and rules.ts ratifies
// the advice in US-CA, US-NY and US-TX. Advice the AI drafts in the thread is held for the attorney who claimed advise,
// included in their fee, up to three answers. The client consents before any attorney reads the parties' names.
export default Service({
  name: 'Contract Review',
  description: 'A contract flagged, then advised on.',
  input: { contract: 'file', client: 'party', client_region: 'jurisdiction: such as US-CA', goals: 'text?' },
  output: { flags: 'file', memo: 'file' },
  rules,
  roles: { attorney: { pool: attorneys, pay: 50 } },
  talk: { adopt: 'attorney' },
  deliver: {
    consent: { ask: 'client', to: 'consent', expires: '7d' },
    flag: 'ai',
    attack: { review: 'adversarial' },
    advise: { by: 'attorney', stamp: true, est: '45min', checklist: ['every flag is addressed', 'the memo answers the goals'] },
    send: { by: 'ai' },
  },
  ends: { withdrawn: { charge: 'acts', by: 'client' } },
  price: { usd: 99, release: 'accept' },
})
```

```bash
npx services.dev check   # after services/contract-review.ts
```

```txt title="magic values: none"
services/contract-review.ts · 16 lines · $99 per job, within 48 hours, charged on acceptance.
  ✗ The rules table binds a name nothing reads: a key that names no Service file, or a row no step performs that is neither an advice class nor refused. Rename it to what it means, or take it out. rules.services has a key 'demand-letter', and no Service file is services/demand-letter.ts. rules.services has a key 'formation', and no Service file is services/formation.ts.
✗ 1 to fix
```

[`services/demand-letter.ts`](https://services.dev/docs/examples/legal/demand-letter.md):

```bash
cat services/demand-letter.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Service } from 'services.dev'
import { attorneys } from '../pools/attorneys.ts'
import rules from '../rules.ts'

// The attorney comes from the attorneys Pool, and signs on their own account. Whether to settle is the
// client's decision alone (rules.ts): every offer reaches them, and an offer under their floor raises below_floor rather
// than being turned away. The floor is merits: only the client sets it, and it is their default answer.
// The draft doesn't cite here: under cite: 'source' every output field is { value, source }, which the
// typed `settlement` doesn't say (a finding for the next pass).
export default Service({
  name: 'Demand Letter',
  description: 'A demand letter, sent certified.',
  input: {
    client: 'party', recipient: 'party', claim: 'text: such as unpaid invoice 1042', amount: 'money: such as 4200',
    client_region: 'jurisdiction: such as US-NY', recipient_region: 'jurisdiction: such as US-NJ', evidence: 'file[]',
  },
  output: { letter: 'file', delivery: 'text', settlement: 'money?' },
  rules,
  roles: { attorney: { pool: attorneys, pay: 75 } },
  policy: { floor: { word: 'money', default: 0, binds: 'merits', note: 'the least you will settle for: your default answer to an offer; only you set it' } },
  signals: {
    collections: job => job.input.claim.includes('debt'),
    below_floor: job => job.output.settlement !== undefined && job.output.settlement < job.policy.floor,
  },
  deliver: {
    consent: { ask: 'client', to: 'consent', expires: '7d' },
    draft: 'ai',
    attack: { review: 'adversarial', lenses: ['accuracy', 'tone', 'collection rules'] },
    sign: { by: 'attorney', stamp: true, est: '30min', checklist: ['every claim is supported', 'no threat the client cannot carry out'] },
    send: { submit: 'https://delivery.example.test/certified', to: 'the recipient', receipt: 'delivery', fallback: 'courier' },
    courier: { routed: true, submit: 'https://delivery.example.test/courier', to: 'a courier', receipt: 'delivery' },
    reply: { by: 'ai', within: '30d' },
    settle: { ask: 'client', to: 'decide', choices: ['accept', 'counter', 'close the file'], when: job => job.output.settlement !== undefined },
  },
  ends: { settled: { charge: true }, closed: { charge: true, by: 'client' } },
  price: { usd: 149, release: 'send' },
})
```

```bash
npx services.dev check   # after services/demand-letter.ts
```

```txt title="magic values: none"
  ✗ The rules table binds a name nothing reads: a key that names no Service file, or a row no step performs that is neither an advice class nor refused. Rename it to what it means, or take it out. rules.services has a key 'formation', and no Service file is services/formation.ts.
services/demand-letter.ts · 26 lines · $149 per job, within 48 hours, charged on send's receipt.
✗ 1 to fix
```

[`services/formation.ts`](https://services.dev/docs/examples/legal/formation.md):

```bash
cat services/formation.ts
```

```txt title="captured/legal-build.txt · magic values: none"
import { Service } from 'services.dev'
import { attorneys } from '../pools/attorneys.ts'
import rules from '../rules.ts'

// The brand forms the entity, an open act; which entity, and the 83(b), are an attorney's advice, admitted
// where the founders are. Two clocks recur on the company and outlive the job: its end asks the client to own them.
export default Service({
  name: 'Company Formation',
  description: 'A company formed, papers signed.',
  input: {
    name: 'text: the name you want, such as Acme Robotics', founders: 'party[]', state: ['DE', 'WY'], shares: 'number: such as 10000000', vesting: 'boolean: such as true',
    client_region: 'jurisdiction: where the founders are, such as US-CA',
  },
  output: { certificate: 'file', file_number: 'text', documents: 'file[]' },
  rules,
  roles: { attorney: { pool: attorneys, pay: 60 } },
  talk: { adopt: 'attorney' },
  subject: { kind: 'company', key: 'file_number' },
  deliver: {
    consent: { ask: 'founders', to: 'consent', expires: '7d' },
    advise_entity: { by: 'attorney', act: 'advise_entity_choice', est: '30min', checklist: ['the founders know why this entity, in this state'] },
    form_entity: { submit: 'https://filings.example.test/secretary-of-state', to: 'the state', receipt: 'file_number', rejected: { name_unavailable: 'rename' } },
    rename: { routed: true, ask: 'founders', to: 'answer', next: () => 'form_entity' },
    documents: 'ai',
    adopt: { ask: 'founders', to: 'sign', what: 'documents', all: true, how: 'esign', capacity: ['director', 'founder'] },
    advise_83b: { by: 'attorney', est: '20min', when: job => job.input.vesting, checklist: ['the founder knows the 30-day limit'] },
  },
  clocks: {
    election: { due: '30d after adopt', owner: 'buyer', rungs: ['notice 14d', 'ack daily 7d'], lapse: ['mailed, with proof', 'not filing, in writing'] },
    agent: { due: '1y after form_entity', every: 'year', owner: 'brand', lives_on: 'subject' },
    franchise_tax: { due: job => franchiseTaxDue(job.input.state, job.record), every: 'year', owner: 'buyer', lives_on: 'subject', rungs: ['notice 30d'] },
  },
  price: { usd: 299, release: 'form_entity' },
})

// Your code: Delaware's franchise tax is due 1 March after the company forms; Wyoming's, on the first of its month. Until
// it forms there is no date yet, and the clock waits to open.
function franchiseTaxDue(state: string, record: readonly { type: string; step?: string; at: string }[]) {
  const at = record.find(e => e.type === 'step.committed' && e.step === 'form_entity')?.at
  return at && `${Number(at.slice(0, 4)) + 1}-${state === 'DE' ? '03' : at.slice(5, 7)}-01`
}
```

```bash
npx services.dev check   # after services/formation.ts
```

```txt title="magic values: none"
services/formation.ts · 30 lines · $299 per job, within 48 hours, charged on form_entity's receipt.
✓ ready to sell · 6 Services · each keeps at least 3% of every job
```

The last reads the table's last name, and the brand is ready to sell. [Every branch](https://services.dev/docs/examples/legal/branches.md) runs what these files can do.

---

- Up: [The legal example](https://services.dev/docs/examples/legal.md)
- Previous: [The legal example](https://services.dev/docs/examples/legal.md)
- Next: [One job, every side](https://services.dev/docs/examples/legal/walk.md)