The Armory

What it is

The Armory is Zipper’s warrant mesh for iOS, Android, and the web. You mint a hatch-bound session, then a warrant that names a rack. A write warrant is a spent cartridge — reuse returns 409. Musters hold sealed documents with revisions. Kit is cordoned by Palace Guard, including JSON bodies. The roll is SSE on this node. Twenty Docker racks isolate duties. This is not Firebase, not Appwrite Cloud, not FCM/APNs, and not Kubernetes. Without Docker the same twenty racks run in-process and still fail closed.

Closest analogue: Firebase Auth + Firestore (skill map only). SLA 99.9% · p99 45ms. Admins create apps, collections, and webhooks. Operators may inspect mesh health.

• ▸Spent-cartridge write warrants (zw.…)
• ▸Hatch-bound sessions — Origin is identity
• ▸Musters with revision stamps
• ▸Palace Guard on kit and JSON
• ▸Twenty Docker racks, one duty each

How it works

The Armory is a warrant mesh, not a document cloud. Dashboard → The Armory → Create app (watch, roll, todos, or chat). Copy the HTTPS endpoint, anon key, and service key (once). Sign in; the JSON includes a write warrant (spent cartridge) and a read warrant.

Every data-plane call carries X-Armory-Warrant. A write warrant fires once — reuse is spent_cartridge. Sessions are bound to Origin (hatch). Musters are sealed documents with rev stamps. Palace Guard cordons kit bytes and JSON string fields. The roll is SSE on this process. Zipper does not send mail.

Words: anon key on the device, service key on the server, session after sign-in, warrant per rack, muster for documents, kit for files, roll for live SSE, hatch for Origin. The walkthrough is Docs → Using The Armory.

Twenty Docker racks isolate duties. ARMORY_MESH=docker fails closed if a rack is down. Without Docker the same twenty racks run in-process. Warrants are not JWTs. Live is not FCM. The mesh is not Kubernetes.

Use cases

Concrete ways teams use this service on day one.

Set it up in the dashboard

Dashboard → Services → The Armory. The console lists words, five steps, kits, headers, and refusal codes.

Create an app. Copy the endpoint, anon key, and service key (once). Paste a browser origin if the client is a website.

Follow Docs → Using The Armory for signup, spend, and mint examples.

API

Control-plane: GET|POST /api/v1/armory · POST /auth/signup · POST /warrants · GET|POST /musters/:name · POST /kit · GET /roll/:channel · GET /mesh. Send Authorization: Bearer tz_live_YOUR_TOKEN.

Creates count against the plan quota. A 402 plan_limit means you are at the cap — upgrade or delete an unused resource.

curl -sS -X POST https://tinyzipper.com/api/v1/armory \
  -H "Authorization: Bearer tz_live_YOUR_TOKEN" \
  -H "Idempotency-Key: $(uuidgen)" \
  -H "Content-Type: application/json" \
  -d '{"name":"mobile","kit":"watch"}'

const base = "https://tinyzipper.com/api/v1/armory/APP_ID";
const headers = { "X-Armory-Key": process.env.ARMORY_ANON, "Content-Type": "application/json" };
const auth = await fetch(base + "/auth/signup", { method: "POST", headers, body: JSON.stringify({ email: "dev@example.com", password: "long-password" }) }).then((r) => r.json());
await fetch(base + "/musters/events", {
  method: "POST",
  headers: { ...headers, Authorization: "Bearer " + auth.item.access_token, "X-Armory-Warrant": auth.item.warrants.write },
  body: JSON.stringify({ title: "gate-up" }),
});
const next = await fetch(base + "/warrants", { method: "POST", headers: { ...headers, Authorization: "Bearer " + auth.item.access_token }, body: JSON.stringify({ verb: "write", rack: "records" }) }).then((r) => r.json());

const res = await fetch("https://tinyzipper.com/api/v1/armory", {
  method: "GET",
  headers: {
    Authorization: `Bearer ${process.env.ZIPPER_TOKEN}`,
    "Content-Type": "application/json"
  }
});
const json = await res.json();
if (!res.ok) throw new Error(json.error ?? res.statusText);
console.log(json);

Tips

Warrants are not JWTs. A write cartridge is spent on first use.

Never put the service key in a mobile binary. Use the anon key, a session, and a warrant.

Browser Origin is the hatch. Native apps omit Origin and cannot replay a browser session.

Twenty Docker racks are the isolation medium, not a GKE replica set.

Zipper does not send SMTP. Recovery tokens are returned to your backend.

• ▸SOC 2
• ▸AES-256-GCM
• ▸Spent warrants
• ▸Hatch-bound sessions
• ▸Twenty Docker racks

Runbook

Create an app. Copy endpoint, anon key, and service key (once). Sign in at POST /auth/signup — the response includes a write warrant (spent cartridge) and a read warrant. POST /warrants to mint the next write. Insert musters at POST /musters/{name} with X-Armory-Warrant. Reusing a write warrant returns spent_cartridge. Sessions are bound to Origin. Kit and JSON pass Palace Guard. The roll is GET /roll/{channel} SSE on this node. Twenty Docker racks isolate duties when ARMORY_MESH=docker.