# Commission the site before lunch.

*31 July 2026 · the launch journal*

Commissioning day has a shape every field engineer knows: the readers are up, the network drop the client promised is a VPN ticket in someone else's queue, and a person with sign-off authority is standing behind you wanting to see data. The data layer that survives that day is a local one — reader feed to validated EPCIS event, on your bench, no cloud in the loop. Here is that pipeline, end to end, with the transcripts.

## Reader payload to constructed event

A dock-door read gives you identifiers and a timestamp; the site gives you the rest of the context — read point, business step, disposition. Constructed, that is an ObjectEvent:

```json
{ "type": "ObjectEvent",
  "eventTime": "2026-07-19T10:00:00.000Z",
  "eventTimeZoneOffset": "+00:00",
  "epcList": ["urn:epc:id:sgtin:0614141.107346.2018"],
  "action": "OBSERVE",
  "bizStep": "shipping",
  "disposition": "in_transit" }
```

The rule that keeps the rest of the day boring: **the event is born conformant**. Validate before anything leaves the function — locally, against the pinned official GS1 schema, with `npx epcis.dev validate`:

```json
{ "valid": true,
  "schema": { "artefact": "epcis-json-schema.json", "version": "2.0.1",
              "sha256": "0f46ff694efffd8d8ce840a33dfde84228add11b516b8b258f3200740ae210af" },
  "errors": [] }
```

Note what the verdict carries: the exact schema artifact and its sha256. When the client's IT team asks "validated against what?", the answer is a digest they can check on [the conformance page](/conformance/), not a vendor sentence.

## Capture, locally, with the stamps visible

`npx epcis.dev capture` runs the full gateway on your bench — same validation, same error bodies, same stamping discipline as the hosted door. From a real run over the corpus's replay fixture:

```json
{ "accepted": true,
  "job": { "captureID": "9ff624a6-99ef-4a16-8b38-dfd8dc5ecef6",
           "success": true, "captureErrorBehavior": "rollback", "errors": [],
           "eventIDs": ["urn:uuid:5e900002-0000-4000-8000-000000000001"] },
  "events": [ { "type": "ObjectEvent", "...": "...",
                "recordTime": "2026-07-31T12:47:48.004Z" } ] }
```

Two things in that transcript matter on site. `recordTime` is stamped by the door, not supplied by you — the gateway asserts when it recorded, the event asserts when the world happened, and the two never blur. And the capture response reads the events back **through the query door**, stamps visible — what you show the client is what a query returns, not an echo of what you sent.

Failure is equally typed: an invalid document comes back as an RFC 7807 problem body carrying the standard's own exception types, per event, with **no partial acceptance** — a job lands whole or not at all. No "how much of that batch made it in?" forensics at 4pm.

## Offline tolerance, done honestly

Retries are not an edge case in the field; they are the weather. Buffers flush twice, readers double-fire, the link drops mid-batch and the batch re-sends. The dedupe that survives all of it needs no sequence numbers and no coordination, because event identity is computed from event content — the CBV 2.0 §8.9 hash:

```
hash  0  ni:///sha-256;649a245b6e626325c60ca71777cfb66f386efd6fcc722fab7c2fecdfc56cd0c6?ver=CBV2.0
```

The golden corpus pins the law as a fixture (`sequences/duplicate-benign-replay.json`), in one sentence: *"Re-capturing an identical event (same eventID, same event-hash, same errorDeclaration) is a benign no-op ack, never a re-append."* So the offline pattern is simply: buffer everything, replay everything when the link returns, and let the hash make "did I already send this?" a non-question. The algorithm itself excludes `eventID` and `recordTime`, so a gateway stamping those fields does not break the dedupe. No distributed lock, no site-specific GUID scheme that shears the first time two systems disagree about it.

If the site has a cold chain, the same pipeline carries the evidence in-band — EPCIS 2.0's `sensorElementList` puts temperature series inside the custody event, one artifact instead of two systems glued in a spreadsheet later.

## The 4pm artifact

What you hand the client at the end of commissioning day is not a promise, it is a validation summary: *n* events constructed from live reader feeds, *n* validated against the pinned official EPCIS 2.0.1 schema (digest cited), *n* captured with hashes computed, replay tested — here is the transcript. Every line of it re-runnable by their own team with `npx epcis.dev`, from the fixtures and the contract shipped in the tarball (`node_modules/epcis.dev/AGENTS.md`). The five-minute version of that transcript is [Run it yourself](/run-it-yourself/); what your proposal may claim on the strength of it is [the bid-language entry](/journal/what-you-may-claim-in-the-bid/).

The buffered events on your bench eventually want a durable home — the hosted spine the client's partners can be granted reads against. That destination is on the dated ledger at [/what-ships-today/](/what-ships-today/), and capture keys are requested from [the key list](/get-a-key/?segment=integration): your address first, a few questions about the sites you commission, and the final step locks. We email you when your key is ready.

---

**Proof, not adjectives.** This build could not verify the gateway's test suite green, so no sentence on this page claims a passing run — the last verified run is recorded in the repository's own CI, not here. Live on this origin, no key: POST /translate, /validate, /hash. No conformance attestation has ever been issued. The dated ledger is /what-ships-today/.