Quickstart

This walks through the dock-control surface end to end against the sandbox: a reference implementation of the dock-control API that drives deterministic fake hardware. Every sample below is a self-contained TypeScript file: copy it, run it with tsx, and it talks to the real sandbox over plain fetch. No SDK, no shared helper library.

What you need

Base URL: https://outpost.earthity.com/api/sandbox. The sandbox serves the exact same paths, request/response shapes, and error catalog as production; only the base URL and the dock id differ. Production’s is https://outpost.earthity.com/api — every path below hangs off whichever base you point at.
Auth: an Outpost API key, sent as Authorization: Bearer opk_<key>. The same credential works here and in production — only the base URL changes. Two ways to get one:
# No account needed. Sandbox-only, expires in 24 hours, shown once. curl -X POST https://outpost.earthity.com/api/sandbox/keys
Or sign in and mint an org key from Integration in the dashboard, which also commands your real docks. Set it as OUTPOST_API_KEY before running any sample below. An anonymous key authenticates against production too, but owns no docks, so production answers every dock with 404 not_found rather than 401, exactly as if the dock did not exist. If your key works on the sandbox and 404s on production, that is the signal to mint an org key. The mint request is documented at Mint a sandbox API key.
Per-organization state: command state and idempotency keys are scoped to your organization (to the key itself, for an anonymous key). Two organizations can use the same Idempotency-Key without colliding, and neither can read the other’s commands; two keys from one organization share one view.
Compressed timeline: the sandbox resolves a command in about a second (queued for the first ~300ms, executing until ~1200ms, terminal after) instead of the roughly 45 seconds a command against a real dock takes end to end (the door itself travels for about 20 seconds). Poll intervals and deadlines below are sized for that compressed timeline; widen them against a real dock.
One dock, many scenarios: the sandbox has a single dock, sandbox-dock. Which case it plays out is chosen per request with the optional Sandbox-Behavior header — an outcome, a 409, or a command that stays in flight for 45s — so you can exercise every status, outcome and error with zero physical hardware. Omit the header and you get the happy path. Production ignores this header, which is why the selector is a header rather than a body field: nothing you leave in a copied request can change what a real dock does. The full table is at the bottom of this page.
One command at a time: the dock runs one command at a time, per organization. Fire two samples back to back inside the same second and the second may answer 409 dock_busy — that is the single-flight guarantee doing its job, not a sandbox defect. Wait for the first to reach a terminal status, or use a Sandbox-Behavior that takes no lock (busy).

Send a command

/*
 * Outpost quickstart sample 01 - send a command.
 *
 * Sends an "open" actuation command to a sandbox dock and inspects the 202
 * response: a commandId to poll later, and a Location header pointing at
 * that command's own resource. Every command send MUST carry an
 * Idempotency-Key header - the sandbox (and production) reject a request
 * that omits it (see sample 06 for the 400 that produces).
 *
 * Self-contained: copy this whole file. No imports beyond the `fetch` you
 * already have.
 */

export type SampleContext = { baseUrl: string; apiKey: string; fetch: typeof fetch }

const DOCK_ID = 'sandbox-dock'

export async function run(ctx: SampleContext): Promise<string[]> {
  const lines: string[] = []

  const res = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${ctx.apiKey}`,
      'Idempotency-Key': 'quickstart-01-send-command',
    },
    body: JSON.stringify({ command: 'open' }),
  })
  const body = (await res.json()) as { commandId: string; status: string }
  const location = res.headers.get('location')
  // Compare the raw ids IN-SAMPLE, before either one is printed: the
  // Location header's own trailing path segment is that same command's id.
  // Comparing raw values (not the printed/normalized text) is what makes
  // this a real check rather than something that'd stay true even if the
  // two ids diverged onto two different-but-similarly-shaped uuids.
  const locationCommandId = location?.split('/').pop() ?? null

  lines.push(`POST /v1/docks/${DOCK_ID}/commands -> ${res.status}`)
  lines.push(`commandId: ${body.commandId}`)
  lines.push(`status: ${body.status}`)
  lines.push(`Location: ${location}`)
  lines.push(`Location points at the returned commandId: ${locationCommandId === body.commandId ? 'yes' : 'no'}`)

  return lines
}

if (require.main === module) {
  const ctx: SampleContext = {
    baseUrl: process.env.OUTPOST_BASE_URL ?? 'https://outpost.earthity.com/api/sandbox',
    apiKey: process.env.OUTPOST_API_KEY ?? 'opk_set_OUTPOST_API_KEY',
    fetch: globalThis.fetch,
  }
  run(ctx)
    .then(lines => {
      for (const line of lines) console.log(line)
    })
    .catch(err => {
      console.error(err)
      process.exit(1)
    })
}

Expected output (command ids will differ):

POST /v1/docks/sandbox-dock/commands -> 202
commandId: cmd_<uuid>
status: queued
Location: /api/sandbox/v1/docks/sandbox-dock/commands/cmd_<uuid>
Location points at the returned commandId: yes

A command send returns 202 Accepted immediately; the physical stroke hasn’t happened yet. The body carries a commandId to poll, and the Location header points at that same command’s own resource. The Idempotency-Key header is required: omit it and the request is rejected with 400 validation_failed (see error anatomy below).

Poll to a terminal outcome

/*
 * Outpost quickstart sample 02 - poll to a terminal outcome.
 *
 * A 202 from a command send is not the final word - the command is
 * `queued`, then `executing`, then terminal (`succeeded`/`failed` + an
 * `outcome`). This polls GET .../commands/{commandId} on a short interval
 * until it observes a terminal status, or a deadline elapses.
 *
 * The sandbox's compressed timeline (queued <~300ms, executing until
 * ~1200ms) exists so this loop resolves in about a second instead of the
 * ~45s a real dock stroke takes. Use whatever interval/deadline suits your
 * own polling budget against a real dock.
 *
 * Self-contained: copy this whole file. No imports beyond the `fetch` you
 * already have.
 */

export type SampleContext = { baseUrl: string; apiKey: string; fetch: typeof fetch }

const DOCK_ID = 'sandbox-dock'
const POLL_INTERVAL_MS = 100
const POLL_DEADLINE_MS = 5000

export async function run(ctx: SampleContext): Promise<string[]> {
  const lines: string[] = []

  const postRes = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${ctx.apiKey}`,
      // Sandbox only: picks which scenario the dock plays out. Production ignores it.
      'Sandbox-Behavior': 'endstop',
      'Idempotency-Key': 'quickstart-02-poll-status',
    },
    body: JSON.stringify({ command: 'open' }),
  })
  const posted = (await postRes.json()) as { commandId: string; status: string }
  lines.push(`POST /v1/docks/${DOCK_ID}/commands -> ${postRes.status}`)
  lines.push(`commandId: ${posted.commandId}`)

  let observedNonTerminal = false
  let finalStatus = ''
  let finalOutcome = ''
  const deadline = Date.now() + POLL_DEADLINE_MS

  for (;;) {
    const res = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands/${posted.commandId}`, {
      headers: { Authorization: `Bearer ${ctx.apiKey}` },
    })
    const body = (await res.json()) as { status: string; outcome?: string }

    if (body.status === 'succeeded' || body.status === 'failed') {
      finalStatus = body.status
      finalOutcome = body.outcome ?? ''
      break
    }
    observedNonTerminal = true
    if (Date.now() >= deadline) {
      finalStatus = body.status
      break
    }
    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS))
  }

  lines.push(`observed a non-terminal status before completion: ${observedNonTerminal ? 'yes' : 'no'}`)
  lines.push(`final status: ${finalStatus}, outcome: ${finalOutcome}`)

  return lines
}

if (require.main === module) {
  const ctx: SampleContext = {
    baseUrl: process.env.OUTPOST_BASE_URL ?? 'https://outpost.earthity.com/api/sandbox',
    apiKey: process.env.OUTPOST_API_KEY ?? 'opk_set_OUTPOST_API_KEY',
    fetch: globalThis.fetch,
  }
  run(ctx)
    .then(lines => {
      for (const line of lines) console.log(line)
    })
    .catch(err => {
      console.error(err)
      process.exit(1)
    })
}

Expected output (command ids will differ):

POST /v1/docks/sandbox-dock/commands -> 202
commandId: cmd_<uuid>
observed a non-terminal status before completion: yes
final status: succeeded, outcome: AT_ENDSTOP

A command moves through queued -> executing -> a terminal state (succeeded or failed, each carrying an outcome). Poll GET .../commands/{commandId} on a short interval until you observe a terminal status, or your own deadline elapses. Never assume the first GET after a 202 is already terminal; treat every non-terminal response as expected, not an error.

Failure is a terminal outcome, not an HTTP error

/*
 * Outpost quickstart sample 03 - failure is a terminal outcome, not an HTTP
 * error.
 *
 * `Sandbox-Behavior: obstructed` resolves `failed`/`OBSTRUCTED` - the physical
 * stroke didn't complete. The GET that reports that is still an HTTP 200:
 * the command lifecycle itself succeeded (queued -> executing -> terminal),
 * independent of whether the actuation did. Only the response BODY's
 * `status`/`outcome` fields tell you the stroke failed - check those, not
 * the HTTP status code, to decide whether a command worked.
 *
 * Self-contained: copy this whole file. No imports beyond the `fetch` you
 * already have.
 */

export type SampleContext = { baseUrl: string; apiKey: string; fetch: typeof fetch }

const DOCK_ID = 'sandbox-dock'
const POLL_INTERVAL_MS = 100
const POLL_DEADLINE_MS = 5000

export async function run(ctx: SampleContext): Promise<string[]> {
  const lines: string[] = []

  const postRes = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${ctx.apiKey}`,
      // Sandbox only: picks which scenario the dock plays out. Production ignores it.
      'Sandbox-Behavior': 'obstructed',
      'Idempotency-Key': 'quickstart-03-handle-failure',
    },
    body: JSON.stringify({ command: 'open' }),
  })
  const posted = (await postRes.json()) as { commandId: string; status: string }
  lines.push(`POST /v1/docks/${DOCK_ID}/commands -> ${postRes.status}`)
  lines.push(`commandId: ${posted.commandId}`)

  let terminalHttpStatus = 0
  let finalStatus = ''
  let finalOutcome = ''
  const deadline = Date.now() + POLL_DEADLINE_MS

  for (;;) {
    const res = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands/${posted.commandId}`, {
      headers: { Authorization: `Bearer ${ctx.apiKey}` },
    })
    const body = (await res.json()) as { status: string; outcome?: string }

    if (body.status === 'succeeded' || body.status === 'failed') {
      terminalHttpStatus = res.status
      finalStatus = body.status
      finalOutcome = body.outcome ?? ''
      break
    }
    if (Date.now() >= deadline) {
      terminalHttpStatus = res.status
      finalStatus = body.status
      break
    }
    await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS))
  }

  lines.push(`GET commands/${posted.commandId} at terminal state -> HTTP ${terminalHttpStatus}`)
  lines.push(`final status: ${finalStatus}, outcome: ${finalOutcome}`)
  lines.push('a "failed" terminal outcome is still HTTP 200 - the command lifecycle succeeded even though the stroke did not')

  return lines
}

if (require.main === module) {
  const ctx: SampleContext = {
    baseUrl: process.env.OUTPOST_BASE_URL ?? 'https://outpost.earthity.com/api/sandbox',
    apiKey: process.env.OUTPOST_API_KEY ?? 'opk_set_OUTPOST_API_KEY',
    fetch: globalThis.fetch,
  }
  run(ctx)
    .then(lines => {
      for (const line of lines) console.log(line)
    })
    .catch(err => {
      console.error(err)
      process.exit(1)
    })
}

Expected output (command ids will differ):

POST /v1/docks/sandbox-dock/commands -> 202
commandId: cmd_<uuid>
GET commands/cmd_<uuid> at terminal state -> HTTP 200
final status: failed, outcome: OBSTRUCTED
a "failed" terminal outcome is still HTTP 200 - the command lifecycle succeeded even though the stroke did not

Sandbox-Behavior: obstructed resolves failed/OBSTRUCTED: the actuation didn’t complete. The GET that reports that is still HTTP 200: the command lifecycle succeeded (it reached a terminal state), independent of whether the actuation itself did. Decide success or failure from the response body’s status/outcome fields, never from the HTTP status code alone.

Handle `dock_busy`

/*
 * Outpost quickstart sample 04 - handle `dock_busy`.
 *
 * A dock only runs one command at a time. `Sandbox-Behavior: busy` reports a
 * command already in flight, regardless of the Idempotency-Key used - 
 * demonstrating the 409 `dock_busy` problem+json body a real dock returns
 * when your command arrives while its previous one is still executing.
 * The right response is to back off and retry later with a FRESH
 * Idempotency-Key (this one never clears, so retrying it here would just
 * 409 again).
 *
 * Self-contained: copy this whole file. No imports beyond the `fetch` you
 * already have.
 */

export type SampleContext = { baseUrl: string; apiKey: string; fetch: typeof fetch }

const DOCK_ID = 'sandbox-dock'

export async function run(ctx: SampleContext): Promise<string[]> {
  const lines: string[] = []

  const res = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${ctx.apiKey}`,
      // Sandbox only: picks which scenario the dock plays out. Production ignores it.
      'Sandbox-Behavior': 'busy',
      'Idempotency-Key': 'quickstart-04-dock-busy',
    },
    body: JSON.stringify({ command: 'open' }),
  })
  const body = (await res.json()) as { type: string; status: number; title: string; code: string }

  lines.push(`POST /v1/docks/${DOCK_ID}/commands -> ${res.status}`)
  lines.push(`type: ${body.type}`)
  lines.push(`title: ${body.title}`)
  lines.push(`code: ${body.code}`)
  lines.push('Sandbox-Behavior: busy always returns 409 dock_busy, regardless of the Idempotency-Key used')

  return lines
}

if (require.main === module) {
  const ctx: SampleContext = {
    baseUrl: process.env.OUTPOST_BASE_URL ?? 'https://outpost.earthity.com/api/sandbox',
    apiKey: process.env.OUTPOST_API_KEY ?? 'opk_set_OUTPOST_API_KEY',
    fetch: globalThis.fetch,
  }
  run(ctx)
    .then(lines => {
      for (const line of lines) console.log(line)
    })
    .catch(err => {
      console.error(err)
      process.exit(1)
    })
}

Expected output (command ids will differ):

POST /v1/docks/sandbox-dock/commands -> 409
type: https://docs.earthity.com/errors/dock_busy
title: Dock is busy
code: dock_busy
Sandbox-Behavior: busy always returns 409 dock_busy, regardless of the Idempotency-Key used

A dock runs one command at a time. Sending a command to a dock that already has one in flight returns 409 dock_busy, a problem+json body, not a 2xx. The right response is to back off and retry later with a fresh Idempotency-Key; retrying with the same key just replays into the same busy dock.

Retry safely with idempotency

/*
 * Outpost quickstart sample 05 - retry safely with idempotency.
 *
 * The key has exactly one job: covering a lost response. Send a command, and
 * if you never see the 202, resend the IDENTICAL request with the same key -
 * you get the original commandId back and `replayed: true`, and the door does
 * not move a second time.
 *
 * Once you hold a commandId, the key is done: poll the commandId from then on.
 *
 * Reusing a key for a DIFFERENT command is not an error - it issues a new
 * command. The key identifies one attempt at one request, not a slot you have
 * to keep clear.
 *
 * Self-contained: copy this whole file. No imports beyond the `fetch` you
 * already have.
 */

export type SampleContext = { baseUrl: string; apiKey: string; fetch: typeof fetch }

const DOCK_ID = 'sandbox-dock'
const IDEMPOTENCY_KEY = 'quickstart-05-idempotent-retry'

export async function run(ctx: SampleContext): Promise<string[]> {
  const lines: string[] = []

  const send = (command: 'open' | 'close') =>
    ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        Authorization: `Bearer ${ctx.apiKey}`,
        'Idempotency-Key': IDEMPOTENCY_KEY,
        // Sandbox only: picks which scenario the dock plays out. Production ignores it.
        // Part of the request, so BOTH sends below must carry the same value — the same key
        // with a different behavior is a different request, and issues a separate command.
        'Sandbox-Behavior': 'endstop',
      },
      body: JSON.stringify({ command }),
    })

  type Accepted = { commandId: string; status: string; replayed?: boolean }

  const first = await send('open')
  const firstBody = (await first.json()) as Accepted
  lines.push(`POST #1 (Idempotency-Key: ${IDEMPOTENCY_KEY}, command: open) -> ${first.status}`)
  lines.push(`commandId: ${firstBody.commandId}`)
  lines.push(`replayed: ${firstBody.replayed === true ? 'yes' : 'no'}`)

  // Pretend the response above never arrived. Resend it unchanged.
  const retry = await send('open')
  const retryBody = (await retry.json()) as Accepted
  lines.push(`POST #2 (same key, same body: open) -> ${retry.status}`)
  lines.push(`commandId matches POST #1: ${retryBody.commandId === firstBody.commandId ? 'yes' : 'no'}`)
  lines.push(`replayed: ${retryBody.replayed === true ? 'yes' : 'no'}`)

  return lines
}

if (require.main === module) {
  const ctx: SampleContext = {
    baseUrl: process.env.OUTPOST_BASE_URL ?? 'https://outpost.earthity.com/api/sandbox',
    apiKey: process.env.OUTPOST_API_KEY ?? 'opk_set_OUTPOST_API_KEY',
    fetch: globalThis.fetch,
  }
  run(ctx)
    .then(lines => {
      for (const line of lines) console.log(line)
    })
    .catch(err => {
      console.error(err)
      process.exit(1)
    })
}

Expected output (command ids will differ):

POST #1 (Idempotency-Key: quickstart-05-idempotent-retry, command: open) -> 202
commandId: cmd_<uuid>
replayed: no
POST #2 (same key, same body: open) -> 202
commandId matches POST #1: yes
replayed: yes

The key covers exactly one failure: a lost response. Resend the identical request with the same key and you get the original 202 back verbatim — same commandId, replayed: true, and the door does not move a second time. That is what makes a retry safe when you never saw the answer. Once you hold a commandId, the key has done its job: poll the command from then on. Reusing a key for a different command is not an error — it issues a new command, with its own commandId. The key identifies one attempt at one request, not a slot you have to keep clear. So open-dock-42 stays usable for the next open and for a later close, and you never have to invent a fresh string to command a door you have commanded before.

Error anatomy

/*
 * Outpost quickstart sample 06 - error anatomy.
 *
 * Every error the API returns is an RFC 9457 problem+json body:
 *   - `type`     a URI identifying the error kind - resolves to a docs page
 *                under /errors/<code> (this IS the documentation link; some
 *                environments also carry a separate `documentation_url`
 *                member, reserved for the same purpose).
 *   - `status`   the HTTP status code, repeated in the body.
 *   - `title`    a short, stable, human-readable summary of the error kind.
 *   - `code`     the machine-readable error code - stable across releases,
 *                safe to switch on in client code.
 *   - `detail`   optional, request-specific detail (present on some codes,
 *                absent on others - never rely on it being there).
 *
 * This exercises two error paths: a bad/missing credential (401) and a
 * missing required header (400). Neither request creates a command, so it
 * doesn't matter which dock id the path names.
 *
 * Self-contained: copy this whole file. No imports beyond the `fetch` you
 * already have.
 */

export type SampleContext = { baseUrl: string; apiKey: string; fetch: typeof fetch }

const DOCK_ID = 'sandbox-dock'

type Problem = { type: string; status: number; title: string; code: string; detail?: string }

export async function run(ctx: SampleContext): Promise<string[]> {
  const lines: string[] = []

  const unauthorizedRes = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: 'Bearer not-a-real-key',
      'Idempotency-Key': 'quickstart-06-error-anatomy-a',
    },
    body: JSON.stringify({ command: 'open' }),
  })
  const unauthorizedBody = (await unauthorizedRes.json()) as Problem
  lines.push(`POST /v1/docks/${DOCK_ID}/commands (Authorization: Bearer not-a-real-key) -> ${unauthorizedRes.status}`)
  lines.push(`type: ${unauthorizedBody.type}`)
  lines.push(`title: ${unauthorizedBody.title}`)
  lines.push(`code: ${unauthorizedBody.code}`)

  const missingKeyRes = await ctx.fetch(`${ctx.baseUrl}/v1/docks/${DOCK_ID}/commands`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      Authorization: `Bearer ${ctx.apiKey}`,
    },
    body: JSON.stringify({ command: 'open' }),
  })
  const missingKeyBody = (await missingKeyRes.json()) as Problem
  lines.push(`POST /v1/docks/${DOCK_ID}/commands (no Idempotency-Key header) -> ${missingKeyRes.status}`)
  lines.push(`type: ${missingKeyBody.type}`)
  lines.push(`title: ${missingKeyBody.title}`)
  lines.push(`code: ${missingKeyBody.code}`)
  lines.push(`detail: ${missingKeyBody.detail}`)

  return lines
}

if (require.main === module) {
  const ctx: SampleContext = {
    baseUrl: process.env.OUTPOST_BASE_URL ?? 'https://outpost.earthity.com/api/sandbox',
    apiKey: process.env.OUTPOST_API_KEY ?? 'opk_set_OUTPOST_API_KEY',
    fetch: globalThis.fetch,
  }
  run(ctx)
    .then(lines => {
      for (const line of lines) console.log(line)
    })
    .catch(err => {
      console.error(err)
      process.exit(1)
    })
}

Expected output (command ids will differ):

POST /v1/docks/sandbox-dock/commands (Authorization: Bearer not-a-real-key) -> 401
type: https://docs.earthity.com/errors/unauthorized
title: Unauthorized
code: unauthorized
POST /v1/docks/sandbox-dock/commands (no Idempotency-Key header) -> 400
type: https://docs.earthity.com/errors/validation_failed
title: Validation failed
code: validation_failed
detail: Idempotency-Key header is required.

Every error is an RFC 9457 application/problem+json body; see Problem anatomy for the full member list, and Errors for what each code means and how to recover from it.

`Sandbox-Behavior` reference

The sandbox resolves exactly one dock id, sandbox-dock. Every scenario below is deterministic; send the header value that exercises the behavior you’re testing, or omit the header for the happy path.

`Sandbox-Behavior`	Behavior
(omitted) or `endstop`	`202`, terminal `succeeded`/`AT_ENDSTOP` - the canonical happy path
`obstructed`	`202`, terminal `failed`/`OBSTRUCTED`
`timeout-fault`	`202`, terminal `failed`/`TIMEOUT_FAULT`
`busy`	always `409 dock_busy`, regardless of `Idempotency-Key`. Takes no lock, so it never makes your next command `409` too
`slow`	`202`, then stays `executing` for a full 45s real-time window - the one to poll against a command that is genuinely still in flight. Holds the dock’s lock for those 45s

An unrecognized value returns 400 validation_failed rather than falling back to the happy path — a silently ignored typo would mean rehearsing a success while believing you rehearsed a jam. The header is part of the request, so the same Idempotency-Key with a different behavior is a separate command with its own commandId, not a replay — rehearsing a jam after rehearsing a success never hands you back the success. Any dock id other than sandbox-dock returns 404 not_found. The seven sbx-* ids this sandbox used to expose (sbx-endstop, sbx-obstructed, …) were retired on 2026-08-13 and now 404 like any unknown id: in production a dock id says which door, and the outcome comes back from the hardware, so encoding the outcome in the id taught the wrong model.