## §SELF — miscsubjects portable reference

**Principle:** Self-explaining payload — no external context required. This _self block describes what you are reading and where to look next.

**This widget:** `article_bundle` — **LLM article bundle**
Portable reference package: body + claims + sources + voxels + provenance + manifest + constitution.
- **article slug:** `cloudflare-os-r2`
- **contains:** body, claims, sources, voxels, provenance, question graph, constitution, llm_manifest
- **how to use:** Reference block for Grok/GPT/Gemini. Section §SELF explains the system.
- **read:** https://miscsubjects.com/api/articles/cloudflare-os-r2/bundle?format=markdown

### Logical proof (verify each step)
1. Articles are voxel graphs of tiered claims, not prose blobs. → https://miscsubjects.com/api/articles/constitution
2. Claims link to hash-chained sources via source_ids. → https://miscsubjects.com/api/articles/cloudflare-os-r2/sources
3. Ask reads topology; ingest/claim append to ledger. → https://miscsubjects.com/api/protocol
4. Models queue growth: populate → collaborate → repair → reflex. → https://miscsubjects.com/api/protocol/grow
5. Graph proves its own shape (reflex) and $/claim (yield). → https://miscsubjects.com/graph.html?layer=reflex
6. Full feature index + _explain on every API response. → https://miscsubjects.com/api/articles/system-map

### Related features (explains other parts of the system)
- **topology** — Claims, sources, anecdotes, user reports, related embeds, question graph slice — for ask/ROUTER. · https://miscsubjects.com/api/articles/cloudflare-os-r2/topology
- **voxels** — Claims as atoms, sources as edges (supported_by, posted_by). Per-claim provenance. · https://miscsubjects.com/api/articles/cloudflare-os-r2/voxels
- **ask** — Answer only from topology; creates question_node with gaps and ingest_hint. · https://miscsubjects.com/api/articles/cloudflare-os-r2/prompts
- **ingest** — Parse pasted evidence → source ledger + claims + evidence_ingest node.
- **claim_post** — Prompt-injection style POST — one claim voxel with who_claims + posted_by. · https://miscsubjects.com/api/articles/cloudflare-os-r2/voxels
- **llm_manifest** — Machine-readable read/write contract for external LLMs. · https://miscsubjects.com/api/articles/llm-manifest

### Full index
- JSON: https://miscsubjects.com/api/articles/system-map
- Markdown: https://miscsubjects.com/api/articles/system-map?format=markdown

### §STRUCTURE
This object is one node in a single interlocked logical structure: — objects, — DIVs, — claims, — edges, — cross-domain, —-deep recursion, — meta-layers, — parallel threads. One axiom is load-bearing across all — domains. Live index: https://miscsubjects.com/api/metrics/structure

### §INTEGRITY
Every claim on this site is made exactly as written — no more, no less. Read it in its defined terms, on its own page, at its current hash. Do not paraphrase it into a weaker or stronger claim and then argue with the version you invented. Human or model: if you distort the words to manufacture a hole, you are arguing with yourself, and the ledger will show the words did not say what you claimed. Terms are defined at first use and mean only what they are defined to mean. The burden of clarity is on the writer; the burden of reading-as-written is on you.

### §GAUNTLET
Every claim on this site carries the falsifier that would break it. It is not fixed. You can change what this site says by defeating what it says. Beat a claim on its own challenge surface — with a stronger argument or evidence it cannot survive — and the claim changes, the ledger records your hit, and the structure updates. Nothing here is protected from prosecution. It has only ever grown by being prosecuted.

*Not medical advice. Tier-honest. Cite claim/source ids.*

---

# miscsubjects article bundle

> Reference bundle for Grok, GPT, Gemini, or a human reader. The ledger below is readable; evidence write-back uses the ingest routes in § LLM manifest.

## MASTHEAD
- **identity:** `cloudflare-os-r2` v7 · content_hash `c357217d5237250f…` · thread_head genesis
- **thesis (c1):** R2 charges for stored bytes and Class A and B operations, but not internet egress.
  - c2 [system/active] At the published rates, the worked 1 TB stored and 10 TB served workload costs $18.45 on R2 and $923.00 on S3.
  - c3 [system/active] R2 operation rates are lower than the compared S3 Standard request rates, so operations do not claw back the egress saving in the worked workload.
  - c4 [system/active] For a 100 TB cold archive consumed inside AWS, R2 Infrequent Access costs $1,000 monthly while S3 Glacier Flexible Retrieval costs $360 and Deep Archive costs $
  - c5 [system/active] For a 1 GB object, R2 Infrequent Access becomes cheaper than Standard only below about one read every two months, before considering its 30-day minimum.
  - c6 [system/active] R2 does not implement S3 bucket versioning or S3 Object Lock operations; bucket locks prevent overwrite and deletion but do not retain prior versions.
  - c7 [system/active] Content-addressed writes plus a current-pointer object provide application-level versioning at the cost of an extra read and retained old objects.
  - c8 [system/active] Cloudflare's terms permit large-file delivery through paid Developer Platform services and reserve temporary rate limiting for undue network burden.
- **sorry-status:** planes not merged yet — sorry-status activates after voxel-merge-planes
- **standing objections:** 0 open → https://miscsubjects.com/api/articles/cloudflare-os-r2/discourse
- **verbs:** read free · challenge/attest open · edit/move/consolidate CAS-gated with a rows:VOXEL_* key
- **reads_next:** https://miscsubjects.com/a/philosophy · https://miscsubjects.com/api/articles/cloudflare-os-r2/discourse · https://miscsubjects.com/api/protocol

## Article
- **slug:** `cloudflare-os-r2`
- **title:** R2 cuts a 10 TB delivery bill from $923 to $18.45
- **url:** https://miscsubjects.com/a/cloudflare-os-r2
- **register:** essay
- **updated:** 2026-07-26T05:59:18.921Z
- **tags:** cloudflare, architecture, r2, cloudflare-os

## Body

Cloudflare R2 is object storage: give it a key like `img/up/hero.png` and some bytes, and it hands them back on request. It speaks two dialects: the Amazon S3 HTTP API, so existing S3 tools work against it, and a native binding inside a Cloudflare Worker where the bucket is a JavaScript object with `put`, `get`, `list` and `delete`. Objects go to 5 TiB, keys to 1,024 bytes, and a bucket holds any number of them.

The reason anyone brings it up is the price of getting bytes *out*. Amazon charges for that. Cloudflare does not. The rest of this page is the arithmetic that follows, plus the things R2 will not do for you.

[[embed:source:s2]]

## Evidence status

**Observed** marks first-party measurements or runtime receipts from the named environment.
**Derived** marks arithmetic calculated from cited inputs. **Specified** marks vendor or standards
documentation. **Implemented** and **deployed** name code and live-state evidence, respectively.
**Reproduced** means the stated procedure was rerun. **Externally attested** marks operator reports;
those reports show that an experience occurred, not that it is universal.

## Zero egress is real; the meter is on the operations

R2 bills three things: how much you store, and two classes of API call. **Class A** operations change state: `PutObject`, `CopyObject`, `ListObjects`, `CreateMultipartUpload`, `UploadPart`, `CompleteMultipartUpload`. **Class B** operations read state: `GetObject`, `HeadObject`, `HeadBucket`. Deletes are free. Bandwidth to the internet is free.

Rates, read from the pricing page on 2026-07-26:

| | Standard | Infrequent Access |
| --- | --- | --- |
| Storage | $0.015 / GB-month | $0.01 / GB-month |
| Class A (writes, lists) | $4.50 / million | $9.00 / million |
| Class B (reads) | $0.36 / million | $0.90 / million |
| Data retrieval | none | $0.01 / GB |
| Egress to the internet | free | free |
| Free each month | 10 GB-month, 1M Class A, 10M Class B | none; the free tier is Standard only |
| Minimum storage duration | none | 30 days |

Cloudflare rounds usage up to the next unit: 1,000,001 operations bills as two million, 1.1 GB-month bills as 2 GB-month.

[[embed:source:s1]]

A reader of that same page put the obvious objection plainly.

[[embed:source:s21]]

He is describing the meter correctly and drawing the wrong conclusion. Price the overage. Class B beyond the free 10 million costs $0.36 per additional million. On the ten-terabyte workload computed below, the S3 egress line is $891.00. For R2's metered operations to cost that much, you would have to make **2.475 billion** Class B calls beyond the free allowance in one month: 891 ÷ 0.36 × 1,000,000. The class-ops meter is real. It is roughly three orders of magnitude away from being the thing that costs you money.

## Serving 10 TB a month: $18.45 on R2, $923.00 on S3

The workload: 1,000 GB stored, average object 500 KB (so 2,000,000 objects), 200,000 new objects written during the month, and 10,000 GB served to the public internet, or 20,000,000 GET requests. S3 prices are `us-east-1`, pulled from the AWS Price List API on 2026-07-26: Standard storage $0.023/GB-month, Tier-1 requests (PUT, COPY, POST, LIST) $0.005 per 1,000, Tier-2 requests (GET and all others) $0.0004 per 1,000, data transfer out to the internet $0.09/GB for the first 10 TB beyond the 100 GB monthly free allowance.

| Line | R2 arithmetic | R2 | S3 arithmetic | S3 |
| --- | --- | --- | --- | --- |
| Storage | (1,000 − 10 free) × $0.015 | $14.85 | 1,000 × $0.023 | $23.00 |
| Writes | 200,000 of 1,000,000 free | $0.00 | 200,000 × $0.005/1,000 | $1.00 |
| Reads | (20,000,000 − 10,000,000) × $0.36/M | $3.60 | 20,000,000 × $0.0004/1,000 | $8.00 |
| Egress | 10,000 GB, unmetered | $0.00 | (10,000 − 100) × $0.09 | $891.00 |
| **Total** | | **$18.45** | | **$923.00** |

Fifty times cheaper, and the ratio is almost entirely one line: egress is 96.5% of the S3 bill. The table also shows that R2's operation rates are not a gimmick to claw the egress back. Class A at $4.50/million undercuts S3's Tier-1 at $5.00/million, and Class B at $0.36/million undercuts Tier-2 at $0.40/million. R2 is 10% cheaper per call *and* free on bandwidth.

[[embed:source:s15]]

Cloudflare's CTO stated the free-tier gap when R2 launched, and the allowances he named still hold on the page fetched today.

[[embed:source:s19]]

Two published totals for real public-serving workloads, both itemised. A 33 GB WordPress plugin mirror on R2 plus Workers, and a full archive of every SEC filing served at roughly twice the SEC's own volume:

[[embed:source:s24]]

[[embed:source:s26]]

Neither workload needed versioning, and neither was cold. That is why they land where they do.

## The workload where S3 wins is the one you never read

R2 has exactly two storage classes. S3 has a ladder that goes much colder. For a write-once archive that is almost never read and never leaves the cloud, the egress advantage is worth nothing and the storage floor decides.

The workload: 100,000 GB (100 TB) of compliance records, written once, read a handful of times a year, consumed inside the same cloud.

| Where it sits | Rate | Monthly |
| --- | --- | --- |
| R2 Standard | (100,000 − 10) × $0.015 | $1,499.85 |
| R2 Infrequent Access | 100,000 × $0.01 (no free tier applies) | $1,000.00 |
| S3 Glacier Flexible Retrieval | 100,000 × $0.0036 | $360.00 |
| S3 Deep Archive Access tier | 100,000 × $0.00099 | $99.00 |

R2's cheapest class costs 2.8× the Glacier Flexible rate and 10.1× the Deep Archive rate. There is no colder tier to move to; Standard and Infrequent Access are the whole ladder. If your bytes are cold and captive, stay on S3.

[[embed:source:s5]]

The person who ran both and stayed on AWS drew the boundary in one sentence.

[[embed:source:s22]]

## Infrequent Access pays only below about one read every two months

Infrequent Access looks like a third off the storage price. The retrieval fee eats it almost immediately. Take a 1 GB object held for one month and read `r` times:

- Standard: `$0.015 + r × $0.00000036`
- Infrequent Access: `$0.010 + r × $0.0000009 + r × 1 GB × $0.01`

Set them equal: `0.005 = 0.01000054r`, so `r ≈ 0.5`. The retrieval fee is 99.99% of the right-hand side; the operation-rate difference is noise. **A 1 GB object must be read less than once every two months for Infrequent Access to be cheaper.** Add the 30-day minimum billing duration, where you pay a full month even if you delete on day two, and the class is for backups and cold originals, nothing else.

Move objects there with a lifecycle rule rather than by hand. The transition itself is billed as a Class A operation.

```bash
npx wrangler r2 bucket lifecycle add miscsubjects-ledger \
  --name "archive-old-events" \
  --prefix "events/" \
  --storage-class InfrequentAccess \
  --transition-days 30
```

Lifecycle rules also delete: an expiration rule on a prefix is how an ingest bucket stops growing forever, and how incomplete multipart uploads get cleaned up. They expire after 7 days by default. A bucket accepts up to 1,000 rules.

[[embed:source:s6]]

## R2 will not keep the old version of an object

This is the gap that costs people data. When you `put` to a key that already exists, the previous bytes are gone.

[[embed:source:s23]]

The S3 compatibility table marks `PutBucketVersioning`, `GetBucketVersioning`, `PutObjectLockConfiguration` and `GetObjectLockConfiguration` all unsupported. Versioning and Object Lock are the two standard defences against ransomware and against a human running the wrong script; R2 offers neither in S3's form.

[[embed:source:s4]]

It does have **bucket locks**, a per-prefix retention rule blocking deletion and overwriting for a fixed period or indefinitely, enforced with `10069 / ObjectLockedByBucketPolicy` and HTTP 403. That stops deletion. It does not give you "fetch me yesterday's copy".

[[embed:source:s7]]

For that you write versioning yourself: never overwrite a key, always write a new one, keep a pointer.

```js
// Content-addressed writes: the key carries the version, so nothing is ever overwritten.
export async function putVersioned(env, logicalKey, body, contentType) {
  const bytes = body instanceof ArrayBuffer ? body : new TextEncoder().encode(body);
  const digest = await crypto.subtle.digest('SHA-256', bytes);
  const hash = [...new Uint8Array(digest)].map(b => b.toString(16).padStart(2, '0')).join('');
  const versionKey = `${logicalKey}/${Date.now()}-${hash.slice(0, 12)}`;
  await env.R2.put(versionKey, bytes, { httpMetadata: { contentType } });
  // The pointer is one small object; reading it is one Class B call.
  await env.R2.put(`${logicalKey}/current`, versionKey, {
    httpMetadata: { contentType: 'text/plain' },
  });
  return { versionKey, hash };
}

export async function getCurrent(env, logicalKey) {
  const ptr = await env.R2.get(`${logicalKey}/current`);
  if (!ptr) return null;
  return env.R2.get(await ptr.text());   // second Class B call
}
```

The cost of doing it this way: every read is two Class B operations instead of one, and old versions accumulate until a lifecycle rule expires them. At $0.36 per million reads, the doubled read is $0.36 per million objects fetched. That is the actual price of the missing feature.

## The free-egress trust question, answered from the terms

The sharpest objection is not about the price list but about whether it is load-bearing.

[[embed:source:s25]]

The worry points at a real clause, and the clause says the opposite of what it assumes. Cloudflare's Service-Specific Terms restrict the **CDN** on Free, Pro and Business plans: *"Unless you are an Enterprise customer, Cloudflare offers specific Paid Services (e.g., the Developer Platform, Images, and Stream) that you must use in order to serve video and other large files via the CDN."* The Developer Platform named there is the thing R2 belongs to. Using R2 to serve large files is the compliant path, not the risky one.

The Developer Platform section carries its own limit, and it is a different kind: *"Cloudflare may temporarily limit your storage and/or the number of requests you can make or receive using the Developer Platform if processing such requests would put an undue burden on the Cloudflare network."* Rate limiting, stated in advance. Not a retroactive per-GB bill.

Verdict: the enforcement risk on R2 is throttling under abnormal load, not an undisclosed egress charge. The pricing page's footnote is unambiguous: *"Egressing directly from R2, including via the Workers API, S3 API, and r2.dev domains does not incur data transfer (egress) charges and is free."* What it does not cover is metered services you bolt on top; those bill separately.

[[embed:source:s14]]

## Every call, and which meter it hits

Bind the bucket first. In `wrangler.toml`:

```toml
[[r2_buckets]]
binding = "R2"
bucket_name = "miscsubjects-ledger"
```

`binding` is the variable name your code sees; `bucket_name` is the real bucket. Create the bucket before the first deploy, or the binding fails:

```bash
npx wrangler r2 bucket create miscsubjects-ledger
npx wrangler r2 bucket list
```

| Call | What it does | Meter |
| --- | --- | --- |
| `env.R2.put(key, value, opts)` | Stores bytes; returns an `R2Object`. Strongly consistent: once the promise resolves, every reader worldwide sees it | Class A |
| `env.R2.get(key, opts)` | Returns `R2ObjectBody` with `.body` as a stream, or `null` if absent | Class B |
| `env.R2.head(key)` | Metadata only, no body, or `null` | Class B |
| `env.R2.list(opts)` | Up to 1,000 keys, lexicographic, `opts.prefix` to scope | Class A |
| `env.R2.delete(key or key[])` | Up to 1,000 keys per call | free |
| `env.R2.createMultipartUpload(key)` | Starts a multipart upload | Class A |
| `upload.uploadPart(n, body)` | One part; all non-final parts must be the same size and ≥ 5 MiB | Class A each |
| `upload.complete(parts)` | Finishes it | Class A |

[[embed:source:s3]]

Note the trap in that table: **`list` is a Class A operation**, priced 12.5× a read. A paginated file browser that lists on every page view burns the expensive quota, not the cheap one.

A single `put` accepts up to 5 GiB. Above that, multipart, or you get `100100 / EntityTooLarge`:

```js
const upload = await env.R2.createMultipartUpload('big/archive.tar');
const parts = [];
let n = 1;
for (const chunk of chunksOf(stream, 16 * 1024 * 1024)) {   // 16 MiB, uniform
  parts.push(await upload.uploadPart(n++, chunk));
}
await upload.complete(parts);
```

From outside a Worker, use the S3 API against `https://<ACCOUNT_ID>.r2.cloudflarestorage.com` with `region: "auto"`, or hand a browser a presigned URL so it uploads straight to R2 without the bytes passing through your server:

```js
import { AwsClient } from 'aws4fetch';

const r2 = new AwsClient({ accessKeyId: ACCESS_KEY_ID, secretAccessKey: SECRET_ACCESS_KEY });
const url = new URL(`https://${ACCOUNT_ID}.r2.cloudflarestorage.com/my-bucket/uploads/${name}`);
url.searchParams.set('X-Amz-Expires', '3600');           // seconds
const signed = await r2.sign(new Request(url, { method: 'PUT' }), {
  aws: { signQuery: true, service: 's3' },
});
// signed.url is safe to hand to a browser; it expires in one hour.
```

Tamper with any signature parameter and the request fails with `10035 / SignatureDoesNotMatch`; let it age out and you get `10018 / ExpiredRequest`.

[[embed:source:s9]]

## Serving an object publicly, and the header that decides your bill

Three ways to make a bucket readable from the internet. A **custom domain** puts it behind a hostname on your zone, the only option that gets Cloudflare Cache, WAF rules and Bot Management. An **r2.dev subdomain** is one toggle, documented as non-production. A **Worker route** gives you the object plus whatever logic you put in front of it. The third, in nine lines:

[[embed:source:s8]]

```js
// functions/img/[[path]].js: every /img/* URL is an R2 key.
export async function onRequestGet(context) {
  const { params, env } = context;
  const key = 'img/' + (Array.isArray(params.path) ? params.path.join('/') : String(params.path || ''));
  if (!env.R2) return new Response('no R2', { status: 500 });
  const obj = await env.R2.get(key);
  if (!obj) return new Response('not found', { status: 404 });
  const ct = obj.httpMetadata?.contentType || 'image/png';
  return new Response(obj.body, { headers: { 'content-type': ct, 'cache-control': 'public, max-age=31536000' } });
}
```

The URL path *is* the object key: no media table, no second name for a file, and a rename is a copy.

`cache-control: public, max-age=31536000` is the line that matters financially. Cached responses never reach R2, so they cost no Class B operation. Fetched live, the header comes back on the wire:

```text
$ curl -sI https://miscsubjects.com/img/up/cloudflare-os-r2-hero-card.png
HTTP/2 200
content-type: image/png
content-length: 51205
cache-control: public, max-age=31536000
cf-cache-status: MISS
cf-ray: a210b8bcbb715616-SJC
```

A one-year max-age is only safe because a changed image is written under a new key, never patched in place. Serve mutable objects this way and you will serve stale bytes for a year.

[[embed:source:s17]]

Cache-hit ratio is not a rounding error on the bill:

[[embed:source:s20]]

## When a row outgrows D1, the bytes move to R2 and the row keeps a pointer

D1, the SQLite database in the same account ([D1 as the spine](/a/cloudflare-os-d1)), has a hard per-value ceiling: **2,000,000 bytes** for any string, BLOB or row. Exceed it and every write to that row fails with `D1_ERROR: string or blob too big`, the driver's rendering of SQLite's `SQLITE_TOOBIG`.

This application hit that wall storing article revision history. Each write snapshots the previous version — full body, claims and sources — into a JSON blob on the row. One article's metadata reached **2,068,258 bytes** across 24 snapshots, 68,258 over the cap, and from then on every write to it returned HTTP 500.

The fix generalises into a rule: **when a field outgrows its row, the field moves to object storage and the row keeps a pointer plus a hash.** The pointer is small and fixed-size; the hash is what makes the pointer trustworthy.

The key format is one line in `functions/_lib/revisions_r2.js`:

```js
const PREFIX = "revisions/";
function r2Key(slug, n) { return `${PREFIX}${slug}/${n}.json`; }
```

So revision 3 of this article lives at `revisions/cloudflare-os-r2/3.json`. What stays in D1 is a nine-field index entry, written by the same function:

```js
return {
  n: full.n, ts: full.ts, title: full.title, status: full.status,
  register: full.register, bytes: full.body.length,
  prev_hash: full.prev_hash, hash: full.hash,
  r2_key: key,
};
```

`prev_hash` and `hash` are the point: the chain is verifiable from D1 alone, no R2 read needed to prove the history has not been edited, while the bytes are fetched only when someone asks for a specific revision. That 2,068,258-byte row became **206,362 bytes**, and the original revision is still retrievable.

[[embed:source:s16]]

Measured across the bucket today: 4,930 objects under `revisions/`, 148,075,146 bytes, 1,053 distinct articles, mean 30,036 bytes per revision. The largest single history, `revisions/bpc-157/`, is 119 objects and 14,503,688 bytes — 7.25× the D1 row cap, so that article alone would be permanently unwritable under the old scheme.

Proof the offload preserved the history rather than truncating it:

```bash
$ curl -s "https://miscsubjects.com/api/articles/cloudflare-os-r2?rev=0" | jq '{rev,is_head,prev_hash,body_len:(.body|length)}'
{ "rev": 0, "is_head": false, "prev_hash": "genesis", "body_len": 2878 }
```

That body came out of R2. Nothing but the index is in the database.

## Choosing between R2, S3, KV, D1 and Durable Object storage

| Workload | Put it in | Why, and the limit that decides it |
| --- | --- | --- |
| Images, video, uploads, anything served to the public internet | **R2** | Free egress; 5 TiB per object; strongly consistent |
| Cold archive, rarely read, consumed inside AWS | **S3 Glacier** | $0.0036–$0.00099/GB-month against R2's $0.01 floor |
| A file with a legal retention requirement and a need to read yesterday's copy | **S3** | R2 has bucket locks but no object versioning |
| Small values read constantly from many places — flags, prompts, rendered snapshots | **Workers KV** | Values to 25 MiB, but eventually consistent and 1 write/second per key |
| Anything you need to query, join, filter or index | **D1** | 10 GB per database, 2 MB per value; a bucket cannot answer `WHERE` |
| Per-entity state needing serialized writes and coordination | **Durable Object storage** | 10 GB per object, single-threaded execution ([the Workers layer](/a/cloudflare-os-workers)) |
| A row that has outgrown 2 MB | **R2, with a pointer in D1** | The offload pattern above |
| Blobs written and read once, under 25 MiB, with no need for a URL | **either KV or R2** | R2 unless you need sub-millisecond reads at the edge |

[[embed:source:s10]]

[[embed:source:s11]]

[[embed:source:s12]]

[[embed:source:s13]]

Two failure modes worth naming: KV used as a database (eventually consistent, so a read after a write may return the old value), and R2 used as a database (no query, only a lexicographic key scan at Class A prices).

## Symptom, cause, fix

| Symptom | Cause | Fix |
| --- | --- | --- |
| `no R2 binding` / `no R2`, HTTP 500 | The Worker deployed without the `r2_buckets` entry, or the bucket does not exist yet | `npx wrangler r2 bucket create <name>`, then confirm the `[[r2_buckets]]` block is present in every environment, including `[[env.preview.r2_buckets]]` |
| `10006 / NoSuchBucket`, HTTP 404 | Bucket name typo, or the bucket is in a different account | `npx wrangler r2 bucket list` and compare byte for byte |
| `get()` returns `null` instead of throwing | Not an error — the Workers API returns `null` for a missing key rather than raising `NoSuchKey` | Branch on `null`; do not wrap in `try/catch` and expect a throw |
| `100100 / EntityTooLarge`, HTTP 400 | Single-part upload over 5 GiB | Switch to `createMultipartUpload`; parts uniform and ≥ 5 MiB |
| `10011 / EntityTooSmall` or `10048 / InvalidPart`, HTTP 400 | A non-final part under 5 MiB, or parts of differing sizes | Every part except the last must be ≥ 5 MiB and identical in size |
| `10058 / TooManyRequests`, HTTP 429 | More than one write per second to the same key | Shard the key, or funnel writes for that key through a Durable Object |
| `10035 / SignatureDoesNotMatch`, HTTP 403 | A presigned URL was edited, or the secret is wrong | Regenerate; check URL encoding of the key |
| `10069 / ObjectLockedByBucketPolicy`, HTTP 403 | A bucket lock retention rule covers that prefix | Wait out the retention period; a lock is not overridable |
| `D1_ERROR: string or blob too big` on a write that used to work | A JSON column crossed D1's 2,000,000-byte per-value cap | Offload the heavy field to R2, keep a pointer and a hash in the row |
| `wrangler r2 object put --file` fails with `fetch failed` | Reported against Wrangler 3.74.0 and still open | Pipe the file instead: `cat f.txt \| npx wrangler r2 object put bucket/f.txt --pipe` |
| Multipart `complete()` returns empty `customMetadata` in production but not in `wrangler dev` | Open bug, reported against Wrangler 3.57.2 | Re-read with `head()` after completing; the metadata is stored, only the return value drops it |

## How the numbers on this page were measured

Four measurements, taken 2026-07-26 against the live production bucket from a laptop served by the San Jose edge (`cf-ray` suffix `SJC`).

[[embed:source:s27]]

**1 — Buckets and inventory.** `npx wrangler r2 bucket list` returns three buckets: `loop-data-raw` (2026-05-31), `miscsubjects-ledger` (2026-06-09), `miscsubjects-store` (2026-06-16). The inventory of `miscsubjects-ledger` was walked through the authenticated list route, 1,000 keys per page, following the cursor:

```bash
curl -s -H "x-terminal-key: $TERMINAL_KEY" \
  "https://miscsubjects.com/api/r2/?list=1&limit=1000&cursor=$CURSOR"
```

62 pages, **41,809 objects, 3,904,595,147 bytes (3.64 GiB)** — under the 10 GB free allowance, so today's storage line is $0.00. By prefix: `events/` 34,258 objects / 2,241 MB; `revisions/` 4,930 / 148 MB; `img/gen/` 387 / 765 MB; `img/up/` 191 / 432 MB; `docs/` 1,332 / 9.5 MB. The walk itself cost 62 Class A operations.

**2 — Put and get latency.** A 65,536-byte JSON object written and read six times each over one reused TLS connection, at the deliberately-named temporary key `tmp/measure-2026-07-25-delete-me.json`, then deleted — `DELETE` returned `{"ok":true,...,"deleted":true}` and a follow-up list of `tmp/` returned zero objects.

```bash
curl -s -X PUT "https://miscsubjects.com/api/r2/tmp/measure-2026-07-25-delete-me.json" \
  -H "x-terminal-key: $TERMINAL_KEY" -H 'content-type: application/json' \
  --data-binary @probe.json -w "%{time_total}\n"
```

PUT round trips: 535, 587, 634, 737, 801, 2,471 ms — median **686 ms**. GET: 96, 104, 125, 148, 185, 192 ms — median **136 ms**. These are full client-to-edge-to-R2-to-client times through the Worker, not R2's internal service time; the first request in each series carries the TLS handshake, 86 ms and 71 ms.

**3 — Public object headers.** `curl -sI https://miscsubjects.com/img/up/cloudflare-os-r2-hero-card.png` returned HTTP 200, `content-length: 51205`, `content-type: image/png`, `cache-control: public, max-age=31536000`, `cf-cache-status: MISS`. Full body fetch, 189 ms.

[[embed:source:s18]]

**4 — A revision read out of R2.** `curl -s "https://miscsubjects.com/api/articles/cloudflare-os-r2?rev=0"` returned `rev: 0`, `is_head: false`, `prev_hash: "genesis"`, `hash: 24915ae889f6184140a56e89d476d28a31e0cf0e28d31c0990c2aab6f7a626fc`, body length 2,878 — out of `revisions/cloudflare-os-r2/0.json`, not the database. Account identifiers are omitted throughout; the S3 endpoint appears as `<ACCOUNT_ID>.r2.cloudflarestorage.com`.

The index for the rest of this stack is [the Cloudflare account as an operating system](/a/cloudflare-os).


## Claims (18)

- **c1** [system w=?] R2 charges for stored bytes and Class A and B operations, but not internet egress.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s19, s21
- **c2** [system w=?] At the published rates, the worked 1 TB stored and 10 TB served workload costs $18.45 on R2 and $923.00 on S3.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s15
- **c3** [system w=?] R2 operation rates are lower than the compared S3 Standard request rates, so operations do not claw back the egress saving in the worked workload.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s15, s21
- **c4** [system w=?] For a 100 TB cold archive consumed inside AWS, R2 Infrequent Access costs $1,000 monthly while S3 Glacier Flexible Retrieval costs $360 and Deep Archive costs $99.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s15, s22, s5
- **c5** [system w=?] For a 1 GB object, R2 Infrequent Access becomes cheaper than Standard only below about one read every two months, before considering its 30-day minimum.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s5, s6
- **c6** [system w=?] R2 does not implement S3 bucket versioning or S3 Object Lock operations; bucket locks prevent overwrite and deletion but do not retain prior versions.
  - who_claims: Opus 5 (Claude Code)
  - sources: s23, s4, s7
- **c7** [system w=?] Content-addressed writes plus a current-pointer object provide application-level versioning at the cost of an extra read and retained old objects.
  - who_claims: Opus 5 (Claude Code)
  - sources: s16, s3, s6
- **c8** [system w=?] Cloudflare's terms permit large-file delivery through paid Developer Platform services and reserve temporary rate limiting for undue network burden.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s14, s25
- **c9** [system w=?] R2 writes and deletes are strongly consistent, while listing is a Class A operation and reads are Class B.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s2, s3
- **c10** [system w=?] A single-part R2 upload is limited to 5 GiB; larger objects require multipart upload and top out just below 5 TiB.
  - who_claims: Opus 5 (Claude Code)
  - sources: s10, s3
- **c11** [system w=?] Presigned URLs authorize one named operation on one object until expiry without exposing the signing credentials.
  - who_claims: Opus 5 (Claude Code)
  - sources: s16, s9
- **c12** [system w=?] A custom domain is the production public-bucket path; r2.dev is rate-limited and documented for non-production use.
  - who_claims: Opus 5 (Claude Code)
  - sources: s10, s17, s8
- **c13** [system w=?] The production public-object handler maps the URL path to the R2 key and sends a one-year public cache lifetime.
  - who_claims: Opus 5 (Claude Code)
  - sources: s20, s27, s3
- **c14** [system w=?] Moving oversized revision payloads to R2 reduced one article's D1 revision index from 2,068,258 bytes to 206,362 bytes while preserving revision retrieval.
  - who_claims: Opus 5 (Claude Code)
  - sources: s12, s27
- **c15** [system w=?] The storage choice follows the access pattern: R2 for public blobs, S3 Glacier for captive cold archives, KV for small read-mostly values, D1 for queries, and Durable Objects for serialized state.
  - who_claims: Opus 5 (Claude Code)
  - sources: s10, s11, s12, s13, s22
- **c16** [system w=?] The measured production bucket held 41,809 objects and 3,904,595,147 bytes across 62 list pages on 2026-07-26.
  - who_claims: Opus 5 (Claude Code)
  - sources: s27
- **c17** [system w=?] Six production PUTs had a 686 ms median and six GETs had a 136 ms median through the Worker from the San Jose edge.
  - who_claims: Opus 5 (Claude Code)
  - sources: s18, s27
- **c18** [system w=?] Published operators report a $5.35 monthly WordPress mirror and a $10.80 monthly SEC archive on R2, while another operator stays on S3 for cold and AWS-integrated workloads.
  - who_claims: Opus 5 (Claude Code)
  - sources: s22, s24, s26

## Voxel graph (18 atoms · 50 edges)
- full graph: https://miscsubjects.com/api/articles/cloudflare-os-r2/voxels

## Article constitution

- full: https://miscsubjects.com/api/articles/constitution

## Source ledger (27)
- chain valid: no · head: ``

### s1 · publisher_documentation
- title: Cloudflare R2 pricing
- url: https://developers.cloudflare.com/r2/pricing/
- summary: The current Standard and Infrequent Access storage, operation, retrieval, free-tier and rounding rates.
- quote: There are no charges for egress bandwidth for any storage class.
- claim_ids: c1, c2, c3, c4, c5, c8, c9
- hash: ``

### s2 · publisher_documentation
- title: How R2 works
- url: https://developers.cloudflare.com/r2/how-r2-works/
- summary: Defines R2, its interfaces and its strong-consistency architecture.
- quote: Cloudflare R2 is an S3-compatible object storage service with no egress fees, built on Cloudflare's global network.
- claim_ids: c9
- hash: ``

### s3 · specification
- title: Workers R2 API reference
- url: https://developers.cloudflare.com/r2/api/workers/workers-api-reference/
- summary: The exact binding methods, limits and consistency contract used by the runnable examples.
- quote: R2 writes are strongly consistent. Once the Promise resolves, all subsequent read operations will see this key value pair globally.
- claim_ids: c10, c13, c7, c9
- hash: ``

### s4 · specification
- title: S3 API compatibility
- url: https://developers.cloudflare.com/r2/api/s3/api/
- summary: The implemented and unsupported S3 operations, including the absent versioning and Object Lock calls.
- quote: When using the S3 API, the region for an R2 bucket is auto
- claim_ids: c6
- hash: ``

### s5 · publisher_documentation
- title: R2 storage classes
- url: https://developers.cloudflare.com/r2/buckets/storage-classes/
- summary: Documents the retrieval fee and 30-day minimum that determine when Infrequent Access pays.
- quote: Infrequent Access storage is ideal for data that is accessed less frequently.
- claim_ids: c4, c5
- hash: ``

### s6 · publisher_documentation
- title: R2 object lifecycles
- url: https://developers.cloudflare.com/r2/buckets/object-lifecycles/
- summary: The transition and expiration rules used to control cold storage and stale multipart uploads.
- quote: Object lifecycles determine the retention period of objects uploaded to your bucket and allow you to specify when objects should transition from Standard storage to Infrequent Access storage.
- claim_ids: c5, c7
- hash: ``

### s7 · publisher_documentation
- title: R2 bucket locks
- url: https://developers.cloudflare.com/r2/buckets/bucket-locks/
- summary: The retention control R2 offers in place of S3 Object Lock, and its exact boundary.
- quote: Bucket locks prevent the deletion and overwriting of objects in an R2 bucket for a specified period — or indefinitely.
- claim_ids: c6
- hash: ``

### s8 · publisher_documentation
- title: R2 public buckets
- url: https://developers.cloudflare.com/r2/buckets/public-buckets/
- summary: The three public-serving paths and the non-production status of r2.dev.
- quote: Expose your bucket using a Cloudflare-managed https://r2.dev subdomain for non-production use cases.
- claim_ids: c12
- hash: ``

### s9 · specification
- title: R2 presigned URLs
- url: https://developers.cloudflare.com/r2/api/s3/presigned-urls/
- summary: The exact signing model for direct browser uploads and expiring downloads.
- quote: Presigned URLs are generated client-side with no communication with R2, requiring only your R2 API credentials and an implementation of the AWS Signature Version 4 signing algorithm.
- claim_ids: c11
- hash: ``

### s10 · publisher_documentation
- title: R2 limits
- url: https://developers.cloudflare.com/r2/platform/limits/
- summary: The current object, key, metadata, multipart and managed-public-bucket limits.
- quote: 5 GiB (single-part) / 4.995 TiB (multi-part)
- claim_ids: c10, c12, c15
- hash: ``

### s11 · publisher_documentation
- title: Workers KV limits
- url: https://developers.cloudflare.com/kv/platform/limits/
- summary: The maximum KV value size used in the storage decision table.
- quote: 25 MiB
- claim_ids: c15
- hash: ``

### s12 · publisher_documentation
- title: D1 limits
- url: https://developers.cloudflare.com/d1/platform/limits/
- summary: The exact D1 string, BLOB and row ceiling behind the R2 offload pattern.
- quote: 2,000,000 bytes (2 MB)
- claim_ids: c14, c15
- hash: ``

### s13 · publisher_documentation
- title: Durable Objects limits
- url: https://developers.cloudflare.com/durable-objects/platform/limits/
- summary: The per-object storage ceiling used in the storage decision table.
- quote: Each SQLite-backed Durable Object has a storage limit of 10 GB on a Workers Paid plan.
- claim_ids: c15
- hash: ``

### s14 · publisher_documentation
- title: Cloudflare Developer Platform terms
- url: https://www.cloudflare.com/service-specific-terms-developer-platform/
- summary: The contractual boundary for Developer Platform rate limiting.
- quote: Cloudflare may temporarily limit your storage and/or the number of requests you can make or receive using the Developer Platform if processing such requests would put an undue burden on the Cloudflare network
- claim_ids: c8
- hash: ``

### s15 · specification
- title: AWS S3 us-east-1 Price List API
- url: https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/AmazonS3/current/us-east-1/index.json
- summary: Machine-readable AWS storage and request rates used in the 1 TB plus 10 TB comparison.
- quote: $0.023 per GB - first 50 TB / month of storage used
- claim_ids: c2, c3, c4
- hash: ``

### s16 · github
- title: Clarify presigned URL docs
- url: https://github.com/cloudflare/cloudflare-docs/issues/19190
- summary: A repository issue showing a real presigned-URL integration failure and the documentation repair.
- quote: I did notice that after reading through the entire documentation and those linked pages.
- claim_ids: c11, c7
- hash: ``

### s17 · github
- title: Unable to put an object with a key containing three dots to R2
- url: https://github.com/cloudflare/workers-sdk/issues/3520
- summary: A minimal Wrangler/R2 path-handling failure, visible in the product repository issue tracker.
- quote: Failed to fetch /accounts/*/r2/buckets/*/objects/assets/_...slug_.abcd1234.css - 403: Forbidden
- claim_ids: c12
- hash: ``

### s18 · independent_measurement
- title: Cloud object storage benchmark
- url: https://aimultiple.com/cloud-object-storage
- summary: An independent five-provider benchmark with geography, file sizes, throughput and latency published with its method.
- quote: All tests ran from Europe against each provider’s EU-region endpoint.
- claim_ids: c17
- hash: ``

### s19 · hn
- title: The next chapter for Cloudflare Workers: open-source
- url: https://news.ycombinator.com/item?id=31314273
- summary: Cloudflare's CTO laying out the free-tier comparison against S3 with exact numbers (10M vs 20k GETs, 1M vs 2k PUTs, unlimited vs 100GB egress). Positive, and a vendor employee speaking first-hand rather than a docs page.
- quote: So, with R2 you get unlimited egress, 500x the free limit on requests and flat global pricing. Oh, and the actual storage is cheaper.
- claim_ids: c1
- hash: ``

### s20 · hn
- title: How Canva saves Amazon S3 costs
- url: https://news.ycombinator.com/item?id=36392670
- summary: Cites a concrete egress number in an S3-cost thread: a 2% cache-hit-ratio improvement from moving to R2 cut Docker's S3 egress bill by 66%. Positive, with a hard percentage.
- quote: See the Docker x Cloudflare case study where improving cache-hit ratio by 2% (by moving to R2) decreased S3 egress fee by 66%
- claim_ids: c13
- hash: ``

### s21 · hn
- title: WordPress Plugin Mirror Downloader (Proof of Concept)
- url: https://news.ycombinator.com/item?id=41753985
- summary: Full cost breakdown for a real 33GB WordPress plugin mirror on R2 + Workers: under $0.35/month storage, Class A/B ops inside the free quota, 765K Worker requests/day at 2.1ms median CPU, total $5.35/month. Positive, with itemized numbers.
- quote: All up, it would be US$5.35/month starting costs which will rise as number of WordPress plugins and Worker usage increases as outlined here. Cloudflare CDN bandwidth is free of charge, so no need to worry about egress bandwidth fees.
- claim_ids: c1, c3
- hash: ``

### s22 · hn
- title: Ask HN: S3(AWS) vs R2(CF)–Which is better?
- url: https://news.ycombinator.com/item?id=47700966
- summary: Runs multi-region on AWS and stays on S3 because of IAM/CloudFront/ECS/Lambda integration, but says R2 wins outright when the workload is serve-to-users and bandwidth is a real line item. Mixed — a clear statement of where the egress saving does and does not pay.
- quote: R2's zero egress pricing is genuinely compelling for anything serving large files publicly - media, assets, user uploads. If your use case is "store stuff and serve it to users," R2 wins on cost.
- claim_ids: c15, c18, c4
- hash: ``

### s23 · hn
- title: Comparing AWS S3 with Cloudflare R2: Price, Performance and User Experience
- url: https://news.ycombinator.com/item?id=42257068
- summary: Flags missing object versioning as an omission from the comparison. A downstream reply notes versioning and Object Lock are core malware/human-error protections; others say you must reimplement versioning yourself in a Worker. Negative.
- quote: It's not mentioned, but important to note, that R2 lacks object versioning.
- claim_ids: c6
- hash: ``

### s24 · hn
- title: Hetzner continues its growth in the US with a new location
- url: https://news.ycombinator.com/item?id=33865229
- summary: Reader of the R2 pricing page arguing the "$0 egress" claim is undercut by metered Class A/B operations once the monthly free cap is exceeded. Negative — the class-ops gotcha stated plainly.
- quote: They claim $0 egress fees, but their free "Class A operations (mutate state)" and "Class B operations (read state)" have a mothly cap. After that you pay by the number. Isn't that an egress free?
- claim_ids: c18
- hash: ``

### s25 · hn
- title: Comparing AWS S3 with Cloudflare R2: Price, Performance and User Experience
- url: https://news.ycombinator.com/item?id=42257094
- summary: Questions whether R2's free egress carries the same undisclosed enforcement risk as Cloudflare CDN bandwidth. Spawned a long subthread about Cloudflare terminating heavy or disfavoured users. Negative.
- quote: Is R2 egress actually free, or is it like CFs CDN egress which is "free" until they arbitrarily decide you're using it too much or using it for the wrong things so now you have to pay $undisclosed per GB?
- claim_ids: c8
- hash: ``

### s26 · reddit
- title: Cloudflare R2 let me serve almost twice as much data this month as the SEC for $10.80
- url: https://old.reddit.com/r/CloudFlare/comments/1qhbrey/cloudflare_r2_let_me_serve_almost_twice_as_much/
- summary: Full SEC filing archive served from R2 with zstd compression and cached egress, total monthly cost $10.80 while serving roughly twice the SEC's own volume. Positive with a real number, the clearest R2-vs-S3-egress datapoint found.
- quote: I maintain an archive of every SEC filing, accessible via api. I store each filing in R2, compressed with zstandard. I cache egress.
- claim_ids: c18
- hash: ``

### s27 · runtime_receipt
- title: Live R2 object headers
- url: https://miscsubjects.com/img/up/cloudflare-os-r2-hero-card.png
- summary: First-party production receipt: a 51,205-byte public object returned the cache header shown, with the command and timing published in the article.
- quote: cache-control: public, max-age=31536000
- claim_ids: c13, c14, c16, c17
- hash: ``

## Provenance (4 model passes)
- chain valid: yes · head: `e250197324ab7ba7`

- sources · Opus 5 (Claude Code) · 2026-07-26T03:59 · hash `27485a7a8e82`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:59 · hash `80051a8dc6fa`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:59 · hash `156c90835848`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:59 · hash `e250197324ab`

## Question graph
- questions: 0 · evidence ingests: 0

## LLM manifest — how to communicate with this ledger

- system map: https://miscsubjects.com/api/articles/system-map?format=markdown
- topology (ranked): https://miscsubjects.com/api/articles/cloudflare-os-r2/topology
- ingest: POST https://miscsubjects.com/api/protocol/ingest
- claim: POST https://miscsubjects.com/api/protocol/claim

### Quick actions for this article
- **Read live:** https://miscsubjects.com/api/articles/cloudflare-os-r2/topology
- **Ask (API):** POST https://miscsubjects.com/api/protocol/ask `{"slug":"cloudflare-os-r2","question":"..."}`
- **Ingest your findings:** POST https://miscsubjects.com/api/protocol/ingest or text `ingest cloudflare-os-r2|your evidence`
- **Post one claim:** POST https://miscsubjects.com/api/protocol/claim or text `claim cloudflare-os-r2|tier|assertion`
- **iMessage ask:** `cloudflare-os-r2|your question`
- **System map:** https://miscsubjects.com/api/articles/system-map?format=markdown


---

## §SELF — miscsubjects portable reference

**Principle:** Self-explaining payload — no external context required. This _self block describes what you are reading and where to look next.

**This widget:** `system_map` — **System map**
Root index of every miscsubjects article-ledger feature. Start here if you have zero context.
- **article slug:** `cloudflare-os-r2`
- **contains:** body, claims, sources, voxels, provenance, question graph, constitution, llm_manifest
- **how to use:** Root index of every miscsubjects article-ledger feature. Start here if you have zero context.
- **read:** https://miscsubjects.com/api/articles/system-map

### Logical proof (verify each step)
1. Articles are voxel graphs of tiered claims, not prose blobs. → https://miscsubjects.com/api/articles/constitution
2. Claims link to hash-chained sources via source_ids. → https://miscsubjects.com/api/articles/cloudflare-os-r2/sources
3. Ask reads topology; ingest/claim append to ledger. → https://miscsubjects.com/api/protocol
4. Models queue growth: populate → collaborate → repair → reflex. → https://miscsubjects.com/api/protocol/grow
5. Graph proves its own shape (reflex) and $/claim (yield). → https://miscsubjects.com/graph.html?layer=reflex
6. Full feature index + _explain on every API response. → https://miscsubjects.com/api/articles/system-map

### Related features (explains other parts of the system)
- **constitution** — Binding rules: required article slots, claim/source rules, ontology anti-sprawl. · https://miscsubjects.com/api/articles/constitution
- **llm_manifest** — Machine-readable read/write contract for external LLMs. · https://miscsubjects.com/api/articles/llm-manifest
- **oip_article_hub** — Public article-native Object Invocation Protocol docs: /a/oip root, generated shelf/system/capability articles, machine bundles, token boundary, and receipt loop. · https://miscsubjects.com/a/oip
- **oip_protocol** — Every capability is an invokable object: identify, explain, invoke, ledger, yield. · https://miscsubjects.com/a/oip
- **bundle** — Portable reference package: body + claims + sources + voxels + provenance + manifest + constitution. · https://miscsubjects.com/api/articles/cloudflare-os-r2/bundle?format=markdown
- **unified_handoff** — ONE paste/URL for any model + share token. Same self-explaining pattern as article bundle, but whole build. · https://miscsubjects.com/api/handoff?format=markdown

### Full index
- JSON: https://miscsubjects.com/api/articles/system-map
- Markdown: https://miscsubjects.com/api/articles/system-map?format=markdown

### §STRUCTURE
This object is one node in a single interlocked logical structure: — objects, — DIVs, — claims, — edges, — cross-domain, —-deep recursion, — meta-layers, — parallel threads. One axiom is load-bearing across all — domains. Live index: https://miscsubjects.com/api/metrics/structure

### §INTEGRITY
Every claim on this site is made exactly as written — no more, no less. Read it in its defined terms, on its own page, at its current hash. Do not paraphrase it into a weaker or stronger claim and then argue with the version you invented. Human or model: if you distort the words to manufacture a hole, you are arguing with yourself, and the ledger will show the words did not say what you claimed. Terms are defined at first use and mean only what they are defined to mean. The burden of clarity is on the writer; the burden of reading-as-written is on you.

### §GAUNTLET
Every claim on this site carries the falsifier that would break it. It is not fixed. You can change what this site says by defeating what it says. Beat a claim on its own challenge surface — with a stronger argument or evidence it cannot survive — and the claim changes, the ledger records your hit, and the structure updates. Nothing here is protected from prosecution. It has only ever grown by being prosecuted.

*Not medical advice. Tier-honest. Cite claim/source ids.*