@volter/twin-instagram 0.1.0

package/dist/src/instagram-capabilities.js

@@ -0,0 +1,1249 @@
+// THE INSTAGRAM PACK'S CAPABILITY MANIFEST — the real vendor surface as the DENOMINATOR, not a list
+// of what got built. The denominator is the Instagram Platform as a professional account uses it to
+// publish and read its own content (developers.facebook.com/docs/instagram-platform, Graph API v26.0,
+// read 2026-09-27): content publishing (images, Reels, videos, carousels, stories; hosted and
+// resumable uploads), the IG User and IG Media nodes and their edges, comments, insights, hashtag
+// search, mentions, business discovery, the publishing limit, webhooks and the Instagram Login token
+// surface. The Marketing API's Instagram ads, the Messenger Platform's Instagram messaging and Threads
+// are other Meta products this manifest does not enumerate beyond one line each.
+//
+// Every `done` below drives the handler the fetch adapter wraps (`handleInstagramTwinRequest`) on a
+// fresh root with a pinned instant, and asserts VALUES and the vendor's refusals — never a status
+// alone. The mirror's `done`s render the mirror's OWN components over what the handler served.
+import { mkdtempSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { checkCapabilities, verifyBoundary } from '@volter/world-tooling';
+import { blobDigest, buildRemoteExecute, deployableEntries, observeResource, pendingActions, projectResources, RefusedWriteError, validateRemoteOrigin } from '@volter/world-core';
+import { createElement } from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { handleInstagramTwinRequest, tokenDigest } from "./instagram-twin.js";
+import { budgetedInstagramExecute, MAX_STATUS_WAIT_MS, performInstagramAction as performServed, performInstagramActionWithin, syncInstagramFromRemote, UPLOAD_CHUNK_BYTES, uploadReel, uploadTarget } from "./instagram-connector.js";
+import { INSTAGRAM_CALL_WEIGHTS, INSTAGRAM_RATE_BUDGET, InstagramBudget, InstagramBudgetError, instagramCallWeight } from "./instagram-budget.js";
+import { captionSegments, compactCount, createInstagramMirrorServer, instagramMirrorStyles, mediaQuery, profileFromRead, reelRoute, timeAgo } from "./instagram-mirror-ui.js";
+import { listContainers, readContainer, writeContainer } from "./instagram-media.js";
+import { ProfileHeader, ProfileScreen, ReelsGrid, ReelViewer } from "../client/instagram-mirror.js";
+const IG = '17841405822304914';
+const OTHER = '17841400000000777';
+const TOKEN = 'ig-user-token-0001';
+const OTHER_TOKEN = 'ig-other-token-0002';
+const PERMS = ['instagram_basic', 'instagram_content_publish', 'pages_read_engagement', 'instagram_manage_contents'];
+const AUTH = { authorization: `Bearer ${TOKEN}` };
+const OAUTH = { authorization: `OAuth ${TOKEN}` };
+const AT = '2026-09-27T12:00:00.000Z';
+/** Ten seconds before AT: a Reel uploaded then has finished processing (PROCESSING_MS) by AT. */
+const EARLY = '2026-09-27T11:59:50.000Z';
+const LATER = (ms) => new Date(Date.parse(AT) + ms).toISOString();
+function handleFor(root, at = AT) {
+    return (step) => handleInstagramTwinRequest({
+        method: step.m, path: step.p, root, occurredAt: step.at ?? at, readOnly: step.readOnly,
+        headers: { ...(step.form !== undefined ? { 'content-type': 'application/x-www-form-urlencoded' } : { 'content-type': 'application/json' }), ...(step.headers ?? AUTH) },
+        ...(step.form !== undefined ? { body: step.form } : step.b === undefined ? {} : { body: JSON.stringify(step.b) }),
+        ...(step.bytes ? { bytes: step.bytes } : {}),
+        ...(step.base ? { publicBase: step.base } : {}),
+    });
+}
+async function seed(h, opts = {}) {
+    const id = opts.id ?? IG;
+    await h({ m: 'POST', p: '/_twin/users', b: { id, username: opts.username ?? 'metricsaurus', name: 'Metricsaurus', biography: 'Dino data crunching app', website: 'http://www.metricsaurus.com/', followers_count: 12480, follows_count: 87 }, headers: {} });
+    await h({ m: 'POST', p: '/_twin/tokens', b: { token: opts.token ?? TOKEN, user: id, permissions: opts.permissions ?? PERMS }, headers: {} });
+}
+/** A throwaway world with the account and the token the Facebook Login leg would have minted. */
+async function withWorld(fn, opts = {}) {
+    const root = mkdtempSync(join(tmpdir(), 'instagram-cap-'));
+    const h = handleFor(root);
+    try {
+        return await verifyBoundary('instagram.withWorld', async () => { await seed(h, opts); return fn(h, root); });
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+const bodyOf = (r) => r.body;
+const err = (r) => r.body?.error ?? {};
+// ── media fixtures: the smallest bytes the twin reads as a Reel ─────────────────────────────────
+function box(type, ...payload) {
+    const inner = concat(...payload);
+    const out = new Uint8Array(8 + inner.length);
+    new DataView(out.buffer).setUint32(0, out.length);
+    out.set(new TextEncoder().encode(type), 4);
+    out.set(inner, 8);
+    return out;
+}
+function concat(...parts) {
+    const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+    let at = 0;
+    for (const p of parts) {
+        out.set(p, at);
+        at += p.length;
+    }
+    return out;
+}
+function u32s(...values) {
+    const out = new Uint8Array(values.length * 4);
+    values.forEach((v, i) => new DataView(out.buffer).setUint32(i * 4, v >>> 0));
+    return out;
+}
+/** An ISO BMFF file's boxes for a Reel: ftyp, moov (mvhd; a video trak with tkhd, mdhd, hdlr, stsd, stts;
+ *  optionally a sound trak) and mdat — before or after moov. Nothing in it decodes; the twin reads boxes. */
+function mp4(o = {}) {
+    const ms = o.ms ?? 5000;
+    const w = o.w ?? 1080;
+    const hgt = o.h ?? 1920;
+    const fps = o.fps ?? 30;
+    const scale = 15360;
+    const mvhd = new Uint8Array(100);
+    new DataView(mvhd.buffer).setUint32(12, 1000);
+    new DataView(mvhd.buffer).setUint32(16, ms);
+    const tkhd = new Uint8Array(84);
+    new DataView(tkhd.buffer).setUint32(76, w << 16);
+    new DataView(tkhd.buffer).setUint32(80, hgt << 16);
+    const mdhd = (ts, dur) => box('mdhd', u32s(0, 0, 0, ts, dur, 0));
+    const hdlr = (t) => box('hdlr', u32s(0, 0), new TextEncoder().encode(t), new Uint8Array(13));
+    const frames = Math.round((ms / 1000) * fps);
+    const videoEntry = box(o.codec ?? 'avc1', new Uint8Array(78));
+    const video = box('trak', box('tkhd', tkhd), box('mdia', mdhd(scale, Math.round((ms / 1000) * scale)), hdlr('vide'), box('minf', box('stbl', box('stsd', u32s(0, 1), videoEntry), box('stts', u32s(0, 1, frames, Math.round(scale / fps)))))));
+    const tracks = [video];
+    const audio = o.audio === undefined ? { codec: 'mp4a', hz: 48000, ch: 2 } : o.audio;
+    if (audio) {
+        const entry = new Uint8Array(28);
+        new DataView(entry.buffer).setUint16(16, audio.ch);
+        new DataView(entry.buffer).setUint32(24, audio.hz * 65536);
+        tracks.push(box('trak', box('tkhd', new Uint8Array(84)), box('mdia', mdhd(audio.hz, Math.round((ms / 1000) * audio.hz)), hdlr('soun'), box('minf', box('stbl', box('stsd', u32s(0, 1), box(audio.codec, entry)))))));
+    }
+    const pad = new Uint8Array(o.pad ?? 4096);
+    for (let i = 0; i < pad.length; i += 1)
+        pad[i] = (i * 31 + 7) % 251;
+    const ftyp = box('ftyp', new TextEncoder().encode(o.brand ?? 'isom'), u32s(512), new TextEncoder().encode('isomiso2avc1mp41'));
+    const moov = box('moov', box('mvhd', mvhd), ...tracks);
+    const mdat = box('mdat', pad);
+    return o.moovFirst === false ? concat(ftyp, mdat, moov) : concat(ftyp, moov, mdat);
+}
+/** A container, opened at `at`. */
+async function container(h, extra = {}, at = EARLY, user = IG) {
+    const r = await h({ m: 'POST', p: `/v26.0/${user}/media`, b: { media_type: 'REELS', upload_type: 'resumable', ...extra }, at });
+    if (r.status !== 200)
+        throw new Error(`container answered ${r.status}: ${JSON.stringify(r.body)}`);
+    return String(bodyOf(r).id);
+}
+/** The bytes, in one rupload POST, at `at`. */
+async function upload(h, id, bytes, at = EARLY, headers = OAUTH) {
+    return h({ m: 'POST', p: `/ig-api-upload/v26.0/${id}`, bytes, headers: { ...headers, offset: '0', file_size: String(bytes.length) }, at });
+}
+/** A Reel through the whole flow: container and upload ten seconds before AT, published at AT. */
+async function publishReel(h, extra = {}, bytes = mp4()) {
+    const id = await container(h, extra);
+    const up = await upload(h, id, bytes);
+    if (up.status !== 200)
+        throw new Error(`upload answered ${up.status}: ${JSON.stringify(up.body)}`);
+    const r = await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: id } });
+    if (r.status !== 200)
+        throw new Error(`publish answered ${r.status}: ${JSON.stringify(r.body)}`);
+    return String(bodyOf(r).id);
+}
+function vendorExecutor(vendorRoot, calls, opts = {}) {
+    // the vendor's clock moves 3 s per call, so a Reel it received is FINISHED two reads later
+    let clock = Date.parse('2026-09-27T13:00:00.000Z');
+    return async (request) => {
+        clock += opts.step ?? 3_000;
+        const absolute = /^https:\/\//.test(request.path);
+        if (absolute && new URL(request.path).hostname !== 'rupload.facebook.com')
+            throw new Error(`the kernel would refuse ${request.path}`);
+        const path = absolute ? new URL(request.path).pathname + new URL(request.path).search : request.path;
+        const own = Object.keys(request.headers ?? {}).some((k) => k.toLowerCase() === 'authorization');
+        const headers = { ...(request.headers ?? {}), authorization: 'OAuth vendor-token-0002' };
+        calls.push({ method: request.method, path: absolute ? request.path : path, absolute, own, ...(request.headers?.offset !== undefined ? { offset: request.headers.offset } : {}) });
+        const body = request.body;
+        const res = await handleInstagramTwinRequest({
+            method: request.method, path, headers, root: vendorRoot, occurredAt: new Date(clock).toISOString(), ...(opts.base ? { publicBase: opts.base } : {}),
+            ...(body instanceof Uint8Array ? { bytes: body } : body !== undefined ? { body } : {}),
+        });
+        // an HTTP server's own header, as the vendor's server stamps it: the vendor's instant
+        return { status: res.status, headers: { ...(res.headers ?? {}), date: new Date(clock).toUTCString() }, body: res.body === null || res.body === undefined || res.body === '' ? '' : JSON.stringify(res.body) };
+    };
+}
+async function withVendor(fn) {
+    const localRoot = mkdtempSync(join(tmpdir(), 'instagram-cap-local-'));
+    const vendorRoot = mkdtempSync(join(tmpdir(), 'instagram-cap-vendor-'));
+    try {
+        return await verifyBoundary('instagram.withVendor', async () => {
+            const local = handleFor(localRoot);
+            await seed(local);
+            // the vendor holds the same account (a real IG user id); its token is the root's sealed credential
+            await seed(handleFor(vendorRoot), { token: 'vendor-token-0002' });
+            return fn(local, localRoot, vendorRoot);
+        });
+    }
+    finally {
+        rmSync(localRoot, { recursive: true, force: true });
+        rmSync(vendorRoot, { recursive: true, force: true });
+    }
+}
+const entryFor = (root, subjectId, operation) => pendingActions('instagram', root).find((a) => a.subject?.id === subjectId && a.operation === operation);
+const ctxFor = (root) => ({ resolve: (_t, id) => id, root, service: 'instagram' });
+/** A throwaway ledger per verify: a verify never spends the operator's Instagram allowance. */
+const scratchBudget = () => new InstagramBudget({ path: join(mkdtempSync(join(tmpdir(), 'instagram-budget-')), 'ledger.json') });
+const noWait = async (_ms) => undefined;
+const performInstagramAction = (execute, action, ctx, wait = noWait, now) => performInstagramActionWithin(scratchBudget(), execute, action, ctx, wait, now);
+/** Every file under a directory, as text — what a push or a clone of the World would carry. */
+function allText(dir) {
+    let out = '';
+    for (const name of readdirSync(dir)) {
+        const p = join(dir, name);
+        if (statSync(p).isDirectory())
+            out += allText(p);
+        else
+            out += readFileSync(p).toString('latin1');
+    }
+    return out;
+}
+const done = (id, area, title, dimension, tier, verify) => ({ id, area, title, dimension, tier, expected: 'done', verify });
+const todo = (id, area, title, dimension, tier) => ({ id, area, title, dimension, tier, expected: 'todo' });
+export const INSTAGRAM_AREAS = ['versioning', 'auth', 'users', 'containers', 'upload', 'publish', 'media', 'limits', 'publishing', 'comments', 'insights', 'discovery', 'webhooks', 'login', 'errors', 'twin_control', 'connector', 'rate_limit', 'mirror'];
+export const INSTAGRAM_CAPABILITIES = [
+    // ── versioning ──────────────────────────────────────────────────────────────────────────────
+    done('instagram.versioning.versions_served', 'versioning', 'The changelog\'s usable versions (v21.0 … v26.0 on 2026-09-27) and an unversioned path are served; an expired version defaults to the oldest usable at the request\'s own instant (v20.0 → v21.0 now, v21.0 → v22.0 once v21.0 expires 2027-01-21); a version the table does not hold (v27.0, v26.1) is an unknown path, on the Graph hosts and the upload host', 'api', 'core', () => withWorld(async (h) => {
+        const ok = [];
+        for (const v of ['/v21.0', '/v24.0', '/v26.0', '/v20.0', '/v2.0', ''])
+            ok.push(bodyOf(await h({ m: 'GET', p: `${v}/${IG}?fields=username` })).username === 'metricsaurus');
+        const future = await h({ m: 'GET', p: `/v27.0/${IG}` });
+        const minor = await h({ m: 'GET', p: `/v26.1/${IG}` });
+        const uri = bodyOf(await h({ m: 'POST', p: `/v20.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable' } })).uri;
+        const later = bodyOf(await h({ m: 'POST', p: `/v21.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable' }, at: '2027-02-01T00:00:00.000Z' })).uri;
+        const up = await h({ m: 'POST', p: '/ig-api-upload/v27.0/812345678901234567', bytes: mp4(), headers: { ...OAUTH, offset: '0', file_size: '1' } });
+        return ok.every(Boolean) && future.status === 400 && err(future).code === 2500 && minor.status === 400 && /\/ig-api-upload\/v21\.0\//.test(String(uri)) && /\/ig-api-upload\/v22\.0\//.test(String(later))
+            && up.status === 400 && bodyOf(up).debug_info?.message?.includes('Invalid upload path');
+    })),
+    // ── auth ──────────────────────────────────────────────────────────────────────────────────────
+    done('instagram.auth.token_required', 'auth', 'No token is refused (code 104); a token the twin never issued is 190 Invalid OAuth access token', 'api', 'core', () => withWorld(async (h) => {
+        const none = await h({ m: 'GET', p: `/v26.0/${IG}`, headers: {} });
+        const bad = await h({ m: 'GET', p: `/v26.0/${IG}`, headers: { authorization: 'Bearer not-a-real-token' } });
+        return none.status === 400 && err(none).code === 104 && err(none).type === 'OAuthException' && bad.status === 400 && err(bad).code === 190;
+    })),
+    done('instagram.auth.token_carriers', 'auth', 'The token rides Authorization: Bearer, Authorization: OAuth, the access_token query parameter or a form body\'s access_token', 'api', 'core', () => withWorld(async (h) => {
+        const bearer = await h({ m: 'GET', p: `/v26.0/${IG}?fields=username` });
+        const oauth = await h({ m: 'GET', p: `/v26.0/${IG}?fields=username`, headers: OAUTH });
+        const query = await h({ m: 'GET', p: `/v26.0/${IG}?fields=username&access_token=${TOKEN}`, headers: {} });
+        const form = await h({ m: 'POST', p: `/v26.0/${IG}/media`, form: `media_type=REELS&upload_type=resumable&access_token=${TOKEN}`, headers: {} });
+        return [bearer, oauth, query].every((r) => bodyOf(r).username === 'metricsaurus') && form.status === 200 && /^\d{18}$/.test(String(bodyOf(form).id));
+    })),
+    done('instagram.auth.permission_gate', 'auth', "A request needs every permission of its reference's Requirements row: a container instagram_basic + instagram_content_publish + pages_read_engagement, a publish instagram_basic + instagram_content_publish, a read instagram_basic + pages_read_engagement; short of one it is (#10) and nothing is staged or published", 'api', 'core', () => withWorld(async (h, root) => {
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: 'read-only-token-1', user: IG, permissions: ['instagram_basic', 'pages_read_engagement'] }, headers: {} });
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: 'publish-no-pages-1', user: IG, permissions: ['instagram_basic', 'instagram_content_publish'] }, headers: {} });
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: 'publish-only-token', user: IG, permissions: ['instagram_content_publish'] }, headers: {} });
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: 'basic-only-token-1', user: IG, permissions: ['instagram_basic'] }, headers: {} });
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: 'ig-login-token-01', user: IG, permissions: ['instagram_business_basic', 'instagram_business_content_publish'] }, headers: {} });
+        const reel = (t) => h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable' }, headers: { authorization: `Bearer ${t}` } });
+        const noPublish = await reel('read-only-token-1');
+        const noPages = await reel('publish-no-pages-1');
+        const read = await h({ m: 'GET', p: `/v26.0/${IG}?fields=username`, headers: { authorization: 'Bearer publish-only-token' } });
+        const id = await container(h);
+        await upload(h, id, mp4());
+        const pubRead = await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: id }, headers: { authorization: 'Bearer read-only-token-1' } });
+        const pubOnly = await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: id }, headers: { authorization: 'Bearer publish-only-token' } });
+        const reads = await Promise.all([`/v26.0/${IG}?fields=username`, `/v26.0/${IG}/media`, `/v26.0/${id}?fields=status_code`].map((p) => h({ m: 'GET', p, headers: { authorization: 'Bearer basic-only-token-1' } })));
+        const igLogin = await reel('ig-login-token-01');
+        const igLoginRead = await h({ m: 'GET', p: `/v26.0/${IG}?fields=username`, headers: { authorization: 'Bearer ig-login-token-01' } });
+        const pubOk = await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: id }, headers: { authorization: 'Bearer publish-no-pages-1' } });
+        return [noPublish, noPages, read, pubRead, pubOnly, ...reads, igLogin].every((r) => r.status === 400 && err(r).code === 10) && /Facebook Login for Business/.test(String(err(igLogin).message))
+            && bodyOf(igLoginRead).username === 'metricsaurus' && (await listContainers(root)).length === 1 && pubOk.status === 200 && /^9\d{17}$/.test(String(bodyOf(pubOk).id));
+    })),
+    done('instagram.auth.own_account_only', 'auth', "A token reads and writes only its own account: another account's node is Unsupported get request (100/33), creating on it is (#10)", 'api', 'core', () => withWorld(async (h) => {
+        await seed(h, { id: OTHER, username: 'other.account', token: OTHER_TOKEN });
+        const read = await h({ m: 'GET', p: `/v26.0/${OTHER}?fields=username` });
+        const create = await h({ m: 'POST', p: `/v26.0/${OTHER}/media`, b: { media_type: 'REELS', upload_type: 'resumable' } });
+        const own = await h({ m: 'GET', p: `/v26.0/${OTHER}?fields=username`, headers: { authorization: `Bearer ${OTHER_TOKEN}` } });
+        return read.status === 400 && err(read).code === 100 && err(read).error_subcode === 33 && create.status === 400 && err(create).code === 10 && bodyOf(own).username === 'other.account';
+    })),
+    done('instagram.auth.token_held_as_digest', 'auth', "A seeded token never lands in the World in the clear: the log, the tree and the annex hold only its SHA-256, under the `_token` bookkeeping type that is never deployed", 'api', 'core', () => withWorld(async (h, root) => {
+        await publishReel(h);
+        const text = allText(root);
+        const rows = projectResources('instagram', root);
+        const deployable = deployableEntries('instagram', root);
+        const pending = pendingActions('instagram', root);
+        return !text.includes(TOKEN) && rows.some((r) => r.type === '_token' && r.id === tokenDigest(TOKEN)) && tokenDigest(TOKEN) === blobDigest(new TextEncoder().encode(TOKEN))
+            && pending.some((a) => a.subject.type === '_token') && deployable.length > 0 && deployable.every((a) => a.subject.type !== '_token') && !JSON.stringify(pending).includes(TOKEN);
+    })),
+    // ── the IG User node ─────────────────────────────────────────────────────────────────────────
+    done('instagram.users.get_fields', 'users', "GET /{ig-user-id} answers the fields asked for (the reference sample's biography, id, username, website), and only id when none are asked", 'api', 'core', () => withWorld(async (h) => {
+        const sample = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}?fields=biography%2Cid%2Cusername%2Cwebsite` }));
+        const bare = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}` }));
+        const counts = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}?fields=name,followers_count,follows_count,media_count,has_profile_pic` }));
+        return JSON.stringify(sample) === JSON.stringify({ biography: 'Dino data crunching app', id: IG, username: 'metricsaurus', website: 'http://www.metricsaurus.com/' })
+            && JSON.stringify(bare) === JSON.stringify({ id: IG }) && counts.followers_count === 12480 && counts.follows_count === 87 && counts.media_count === 0 && counts.has_profile_pic === false && counts.name === 'Metricsaurus';
+    })),
+    done('instagram.users.nonexisting_field', 'users', 'A field the IG User does not have is (#100) Tried accessing nonexisting field; a documented one the twin does not model is refused by name', 'api', 'common', () => withWorld(async (h) => {
+        const bogus = await h({ m: 'GET', p: `/v26.0/${IG}?fields=username,favorite_color` });
+        const gap = await h({ m: 'GET', p: `/v26.0/${IG}?fields=legacy_instagram_user_id` });
+        return bogus.status === 400 && /nonexisting field \(favorite_color\) on node type \(IGUser\)/.test(String(err(bogus).message)) && gap.status === 422 && /\[twin gap\]/.test(String(err(gap).message));
+    })),
+    done('instagram.users.me', 'users', "GET /me answers the token's own account, so a client needs no stored user id", 'api', 'core', () => withWorld(async (h) => {
+        const me = bodyOf(await h({ m: 'GET', p: '/v26.0/me?fields=id,username' }));
+        await seed(h, { id: OTHER, username: 'other.account', token: OTHER_TOKEN });
+        const them = bodyOf(await h({ m: 'GET', p: '/v26.0/me?fields=id,username', headers: { authorization: `Bearer ${OTHER_TOKEN}` } }));
+        return me.id === IG && me.username === 'metricsaurus' && them.id === OTHER && them.username === 'other.account';
+    })),
+    done('instagram.users.media_count_from_state', 'users', 'media_count is the live media the account holds: a publish raises it and a delete lowers it', 'api', 'common', () => withWorld(async (h) => {
+        const a = await publishReel(h);
+        await publishReel(h, { caption: 'second' }, mp4({ ms: 6000 }));
+        const two = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}?fields=media_count` })).media_count;
+        await h({ m: 'DELETE', p: `/v26.0/${a}` });
+        const one = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}?fields=media_count` })).media_count;
+        return two === 2 && one === 1;
+    })),
+    done('instagram.users.profile_picture', 'users', "A seeded profile picture answers profile_picture_url on the twin's base, whose bytes are the picture, and has_profile_pic true", 'api', 'common', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'instagram-cap-pic-'));
+        try {
+            const { createInstagramTwinFetch } = await import("./instagram-server.js");
+            const fetcher = createInstagramTwinFetch({ root });
+            const png = concat(new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]), box('IHDR', u32s(64, 64), new Uint8Array([8, 2, 0, 0, 0])), new Uint8Array(4));
+            const json = { 'content-type': 'application/json' };
+            await fetcher(new Request('http://twin.test/_twin/users', { method: 'POST', headers: json, body: JSON.stringify({ id: IG, username: 'metricsaurus', profile_picture: btoa(String.fromCharCode(...png)) }) }));
+            await fetcher(new Request('http://twin.test/_twin/tokens', { method: 'POST', headers: json, body: JSON.stringify({ token: TOKEN, user: IG, permissions: PERMS }) }));
+            const me = await (await fetcher(new Request(`http://twin.test/v26.0/${IG}?fields=profile_picture_url,has_profile_pic`, { headers: AUTH }))).json();
+            const url = new URL(String(me.profile_picture_url));
+            const got = await fetcher(new Request(`http://twin.test${url.pathname}`));
+            const bytes = new Uint8Array(await got.arrayBuffer());
+            const forged = await fetcher(new Request(`http://twin.test/v/t51.2885-19/${'0'.repeat(64)}.png`));
+            return url.origin === 'http://twin.test' && me.has_profile_pic === true && got.status === 200 && got.headers.get('content-type') === 'image/png'
+                && bytes.length === png.length && bytes.every((b, i) => b === png[i]) && forged.status === 404;
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    }),
+    todo('instagram.users.business_discovery', 'discovery', "business_discovery: another professional account's public fields and media by username", 'api', 'common'),
+    todo('instagram.users.stories', 'users', 'The stories edge (an account\'s live stories)', 'api', 'common'),
+    todo('instagram.users.tags', 'users', 'The tags edge (media the account is tagged in)', 'api', 'niche'),
+    todo('instagram.users.mentioned_media', 'users', 'mentioned_media and mentioned_comment (media and comments that @mention the account)', 'api', 'niche'),
+    todo('instagram.users.live_media', 'users', 'The live_media edge (live broadcasts)', 'api', 'niche'),
+    todo('instagram.users.collaboration', 'users', 'collaboration_invites and collaborative_media', 'api', 'niche'),
+    todo('instagram.users.threads', 'users', 'connected_threads_user and instagram_backed_threads_user', 'api', 'niche'),
+    todo('instagram.users.shopping', 'users', 'shopping_product_tag_eligibility, available_catalogs and catalog_product_search', 'api', 'niche'),
+    todo('instagram.users.ads_edges', 'users', 'agencies, authorized_adaccounts and upcoming_events', 'api', 'niche'),
+    // ── containers ───────────────────────────────────────────────────────────────────────────────
+    done('instagram.containers.create_resumable_reel', 'containers', 'POST /{ig-user-id}/media with media_type=REELS and upload_type=resumable answers {id, uri}: the uri is the rupload host\'s /ig-api-upload/{version}/{id}, and the container reads IN_PROGRESS', 'api', 'core', () => withWorld(async (h, root) => {
+        const r = bodyOf(await h({ m: 'POST', p: `/v24.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', caption: 'hello', share_to_feed: false, thumb_offset: 1000, audio_name: 'Volter theme' } }));
+        const status = bodyOf(await h({ m: 'GET', p: `/v26.0/${r.id}?fields=status_code` }));
+        const stored = await readContainer(String(r.id), root);
+        return /^8\d{17}$/.test(String(r.id)) && r.uri === `https://rupload.facebook.com/ig-api-upload/v24.0/${r.id}` && status.status_code === 'IN_PROGRESS'
+            && stored?.caption === 'hello' && stored.share_to_feed === false && stored.thumb_offset === 1000 && stored.audio_name === 'Volter theme' && Object.keys(r).length === 2;
+    })),
+    done('instagram.containers.uri_under_public_base', 'containers', "Served by a twin, the container's uri is minted under the twin's own public base, so the upload reaches the twin", 'api', 'core', () => withWorld(async (h) => {
+        const r = bodyOf(await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable' }, base: 'http://127.0.0.1:4400/acme/world/instagram' }));
+        return r.uri === `http://127.0.0.1:4400/acme/world/instagram/ig-api-upload/v26.0/${r.id}`;
+    })),
+    done('instagram.containers.media_type_values', 'containers', 'An unknown media_type is 2207023; no media_type and no image_url asks for image_url; image, carousel, story and VIDEO containers are refused by name', 'api', 'core', () => withWorld(async (h, root) => {
+        const unknown = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'GIF' } });
+        const bare = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: {} });
+        const gaps = await Promise.all([{ image_url: 'https://x.example/a.jpg' }, { media_type: 'CAROUSEL' }, { media_type: 'STORIES' }, { media_type: 'VIDEO' }].map((b) => h({ m: 'POST', p: `/v26.0/${IG}/media`, b })));
+        return unknown.status === 400 && err(unknown).error_subcode === 2207023 && bare.status === 400 && /image_url is required/.test(String(err(bare).message))
+            && gaps.every((g) => g.status === 422 && /\[twin gap\]/.test(String(err(g).message))) && (await listContainers(root)).length === 0;
+    })),
+    done('instagram.containers.upload_type', 'containers', 'A Reel without upload_type needs video_url (a hosted video is refused by name: Meta would fetch it); upload_type must be the lowercase resumable; a resumable session takes no video_url', 'api', 'core', () => withWorld(async (h) => {
+        const bare = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS' } });
+        const hosted = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', video_url: 'https://www.example.com/videos/bronz-fonz.mp4' } });
+        const upper = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'RESUMABLE' } });
+        const both = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', video_url: 'https://x.example/v.mp4' } });
+        return bare.status === 400 && /video_url is required/.test(String(err(bare).message)) && hosted.status === 422 && /video_url/.test(String(err(hosted).message))
+            && upper.status === 400 && err(upper).code === 100 && /lowercase string resumable/.test(String(err(upper).message)) && both.status === 400 && err(both).code === 100 && /video_url is not taken/.test(String(err(both).message));
+    })),
+    done('instagram.containers.caption_limits', 'containers', 'A caption over 2200 characters is 36004/2207010, over 20 @ tags 100/2207040, over 30 hashtags (#100)', 'api', 'common', () => withWorld(async (h) => {
+        const long = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', caption: 'x'.repeat(2201) } });
+        const edge = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', caption: 'x'.repeat(2200) } });
+        const tags = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', caption: Array.from({ length: 21 }, (_, i) => `@user${i}`).join(' ') } });
+        const hashes = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', caption: Array.from({ length: 31 }, (_, i) => `#tag${i}`).join(' ') } });
+        return long.status === 400 && err(long).code === 36004 && err(long).error_subcode === 2207010 && edge.status === 200
+            && tags.status === 400 && err(tags).error_subcode === 2207040 && hashes.status === 400 && err(hashes).code === 100;
+    })),
+    done('instagram.containers.params_validated', 'containers', 'share_to_feed and is_ai_generated take true/false, cover_url an http(s) URL, thumb_offset a non-negative integer (1/2207057); alt_text is refused on a Reel', 'api', 'common', () => withWorld(async (h) => {
+        const r = (b) => h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', ...b } });
+        const share = await r({ share_to_feed: 'maybe' });
+        const ai = await r({ is_ai_generated: 'sure' });
+        const cover = await r({ cover_url: 'ftp://x.example/c.jpg' });
+        const offset = await r({ thumb_offset: -1 });
+        const alt = await r({ alt_text: 'a dino' });
+        const good = await r({ share_to_feed: 'false', is_ai_generated: true, cover_url: 'https://www.example.com/cover.jpg', thumb_offset: '0' });
+        return /share_to_feed must be true or false/.test(String(err(share).message)) && /is_ai_generated must be true or false/.test(String(err(ai).message)) && /cover_url must be an http\(s\) URL/.test(String(err(cover).message))
+            && err(offset).code === 1 && err(offset).error_subcode === 2207057 && /Reels and stories are not supported/.test(String(err(alt).message)) && good.status === 200;
+    })),
+    done('instagram.containers.unmodeled_params_refused', 'containers', 'collaborators, user_tags, location_id, trial_params and product_tags on a Reel are refused by name, and no container is staged', 'api', 'common', () => withWorld(async (h, root) => {
+        const refused = await Promise.all([{ collaborators: ['a'] }, { user_tags: [] }, { location_id: '1' }, { trial_params: { graduation_strategy: 'MANUAL' } }, { product_tags: [] }]
+            .map((b) => h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', ...b } })));
+        return refused.every((r) => r.status === 422 && /\[twin gap\]/.test(String(err(r).message))) && (await listContainers(root)).length === 0;
+    })),
+    done('instagram.containers.status_lifecycle', 'containers', 'status_code: IN_PROGRESS before the bytes and for five seconds of world time after them, then FINISHED; PUBLISHED once published; EXPIRED 24 hours after creation if not; reading never moves it', 'api', 'core', () => withWorld(async (h) => {
+        const s = async (id, at) => bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=status_code`, at })).status_code;
+        const a = await container(h, {}, AT);
+        const empty = await s(a, AT);
+        await upload(h, a, mp4(), LATER(1_000));
+        const processing = [await s(a, LATER(5_999)), await s(a, LATER(5_999))];
+        const finished = await s(a, LATER(6_000));
+        await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: a }, at: LATER(7_000) });
+        const published = await s(a, LATER(8_000));
+        const b = await container(h, {}, AT);
+        const expired = await s(b, LATER(24 * 3_600_000));
+        return empty === 'IN_PROGRESS' && processing.every((x) => x === 'IN_PROGRESS') && finished === 'FINISHED' && published === 'PUBLISHED' && expired === 'EXPIRED';
+    })),
+    done('instagram.containers.error_on_spec_violation', 'containers', "A file outside the Reels specification leaves the container ERROR with the subcode on `status`: moov after mdat, under 3 s, over 1920 columns, 15 FPS, not H.264/HEVC, not AAC, 64 kHz audio, an average bitrate over 25 Mbps (2207026); a thumb_offset past the end (2207057) — unless a cover_url is set, which Meta uses instead", 'api', 'core', () => withWorld(async (h) => {
+        const verdict = async (bytes, extra = {}) => {
+            const id = await container(h, extra);
+            await upload(h, id, bytes);
+            return bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=status_code,status` }));
+        };
+        const bad = await Promise.all([mp4({ moovFirst: false }), mp4({ ms: 2_000 }), mp4({ w: 2160, h: 3840 }), mp4({ fps: 15 }), mp4({ codec: 'vp09' }), mp4({ audio: { codec: 'Opus', hz: 48000, ch: 2 } }), mp4({ audio: { codec: 'mp4a', hz: 64000, ch: 2 } }), mp4({ ms: 3_000, pad: 10_000_000 }), new TextEncoder().encode('not a video at all')].map((b) => verdict(b)));
+        const offset = await verdict(mp4({ ms: 5000 }), { thumb_offset: 5000 });
+        const covered = await verdict(mp4({ ms: 5000 }), { thumb_offset: 5000, cover_url: 'https://www.example.com/cover.jpg' });
+        const fast = await verdict(mp4({ ms: 5_000, pad: 10_000_000 }));
+        return bad.every((v) => v.status_code === 'ERROR' && v.status === '2207026') && offset.status_code === 'ERROR' && offset.status === '2207057' && covered.status_code === 'FINISHED' && fast.status_code === 'FINISHED';
+    })),
+    done('instagram.containers.accepts_the_spec', 'containers', 'Files inside the specification finish: MP4 or MOV, H.264 or HEVC, 23-60 FPS, silent or AAC mono/stereo up to 48 kHz, 3 s to 15 min, a thumb_offset inside the Reel', 'api', 'core', () => withWorld(async (h) => {
+        const fine = [mp4(), mp4({ brand: 'qt  ', codec: 'hvc1', fps: 60 }), mp4({ fps: 23.976, audio: null }), mp4({ ms: 3_000, audio: { codec: 'mp4a', hz: 44100, ch: 1 } }), mp4({ ms: 15 * 60_000, w: 720, h: 1280 })];
+        const out = [];
+        for (const b of fine) {
+            const id = await container(h, { thumb_offset: 2999 });
+            await upload(h, id, b);
+            out.push(String(bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=status_code` })).status_code));
+        }
+        return out.length === 5 && out.every((s) => s === 'FINISHED');
+    })),
+    done('instagram.containers.daily_quota', 'containers', 'An account that created 400 containers in the last 24 hours is refused a 401st (code 9 — the twin\'s own code: the Error Codes table gives none for this limit), and may create again once the window moves', 'api', 'common', () => withWorld(async (h, root) => {
+        const at = Date.parse(AT) - 3_600_000;
+        for (let i = 0; i < 400; i += 1) {
+            const c = { id: String(700000000000000000n + BigInt(i)), owner: IG, media_type: 'REELS', upload_type: 'resumable', share_to_feed: true, created_ms: at, received: 0 };
+            await writeContainer(c, root);
+        }
+        const refused = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable' } });
+        const later = await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable' }, at: LATER(23 * 3_600_000 + 1) });
+        return refused.status === 400 && err(refused).code === 9 && /400 containers/.test(String(err(refused).message)) && later.status === 200 && (await listContainers(root)).length === 401;
+    })),
+    todo('instagram.containers.copyright_check_status', 'containers', "copyright_check_status on a container (matches_found, status)", 'api', 'niche'),
+    todo('instagram.containers.edit_lists', 'containers', 'The "no edit lists" and closed-GOP / progressive / 4:2:0 Reels requirements (the twin reads no edts/elst box or bitstream; most encoders write an edit list, so refusing one unread would refuse files Meta takes)', 'api', 'common'),
+    todo('instagram.media.frame_thumbnail', 'media', "A Reel's thumbnail cut from its frame at thumb_offset (the twin decodes nothing and answers a stand-in poster when no cover_url is set)", 'api', 'niche'),
+    // ── the rupload host ─────────────────────────────────────────────────────────────────────────
+    done('instagram.upload.single_post', 'upload', 'POST rupload /ig-api-upload/{version}/{container} with Authorization: OAuth, offset 0 and file_size carries the whole file: {"success":true,"message":"Upload successful."}, the bytes held content-addressed', 'api', 'core', () => withWorld(async (h, root) => {
+        const bytes = mp4();
+        const id = await container(h);
+        const up = await upload(h, id, bytes);
+        const noVersion = await container(h);
+        const up2 = await h({ m: 'POST', p: `/ig-api-upload/${noVersion}`, bytes, headers: { ...OAUTH, offset: '0', file_size: String(bytes.length) } });
+        const c = await readContainer(id, root);
+        return up.status === 200 && JSON.stringify(up.body) === JSON.stringify({ success: true, message: 'Upload successful.' }) && up2.status === 200
+            && c?.sha256 === blobDigest(bytes) && c.size === bytes.length && c.received === bytes.length && c.video?.width === 1080 && c.video.height === 1920 && c.video.durationMs === 5000;
+    })),
+    done('instagram.upload.resume_from_offset', 'upload', "An upload may arrive in pieces, each POST's offset the first byte it carries: a piece is held (its answer carries no `success`), a POST at any other offset is refused, and the POST that completes the file answers the documented success with the same bytes held", 'api', 'core', () => withWorld(async (h, root) => {
+        const bytes = mp4({ pad: 50_000 });
+        const id = await container(h);
+        const hdr = (offset) => ({ ...OAUTH, offset: String(offset), file_size: String(bytes.length) });
+        const first = await h({ m: 'POST', p: `/ig-api-upload/v26.0/${id}`, bytes: bytes.subarray(0, 20_000), headers: hdr(0) });
+        const wrong = await h({ m: 'POST', p: `/ig-api-upload/v26.0/${id}`, bytes: bytes.subarray(20_000), headers: hdr(10_000) });
+        const status = bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=status_code`, at: LATER(60_000) })).status_code;
+        const rest = await h({ m: 'POST', p: `/ig-api-upload/v26.0/${id}`, bytes: bytes.subarray(20_000), headers: hdr(20_000) });
+        const c = await readContainer(id, root);
+        return first.status === 200 && bodyOf(first).success === undefined && bodyOf(first).offset === 20_000 && wrong.status === 400 && bodyOf(wrong).debug_info?.retriable === false && /resume at offset 20000/.test(String(bodyOf(wrong).debug_info?.message))
+            && status === 'IN_PROGRESS' && JSON.stringify(rest.body) === JSON.stringify({ success: true, message: 'Upload successful.' }) && c?.sha256 === blobDigest(bytes);
+    })),
+    todo('instagram.upload.offset_discovery', 'upload', "How the rupload host tells a client the bytes it holds after an interrupted POST (undocumented for rupload; the twin answers a GET with the Graph Resumable Upload guide's file_offset, as its own shape)", 'api', 'common'),
+    done('instagram.upload.oauth_scheme', 'upload', 'The upload host takes the same token as the Graph API — as Authorization: OAuth (its documented scheme), Bearer or access_token; no token, an unknown one, one without the publishing permissions or another account\'s is "unauthorized user request" and nothing is stored', 'api', 'core', () => withWorld(async (h, root) => {
+        await seed(h, { id: OTHER, username: 'other.account', token: OTHER_TOKEN });
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: 'read-only-token-1', user: IG, permissions: ['instagram_basic', 'pages_read_engagement'] }, headers: {} });
+        const bytes = mp4();
+        const id = await container(h);
+        const carriers = [{}, { authorization: 'OAuth not-a-real-token' }, { authorization: 'OAuth read-only-token-1' }];
+        const refused = await Promise.all(carriers.map((a) => upload(h, id, bytes, EARLY, a)));
+        const foreign = await upload(h, id, bytes, EARLY, { authorization: `OAuth ${OTHER_TOKEN}` });
+        const untouched = (await readContainer(id, root))?.received === 0;
+        const byOAuth = await upload(h, id, bytes);
+        const bearer = await container(h);
+        const byBearer = await upload(h, bearer, bytes, EARLY, AUTH);
+        const query = await container(h);
+        const byQuery = await h({ m: 'POST', p: `/ig-api-upload/v26.0/${query}?access_token=${TOKEN}`, bytes, headers: { offset: '0', file_size: String(bytes.length) } });
+        return refused.every((r) => r.status === 400 && bodyOf(r).debug_info?.retriable === false && /unauthorized user request/.test(String(bodyOf(r).debug_info?.message)))
+            && foreign.status === 400 && /Invalid container id/.test(String(bodyOf(foreign).debug_info?.message)) && untouched && [byOAuth, byBearer, byQuery].every((r) => bodyOf(r).success === true);
+    })),
+    done('instagram.upload.headers_validated', 'upload', 'file_size is required and at most 300MB (the twin\'s own bound), fixed by the first POST; bytes may not run past it; an empty body and a second upload of a finished file are refused', 'api', 'core', () => withWorld(async (h) => {
+        const bytes = mp4();
+        const id = await container(h);
+        const post = (b, headers) => h({ m: 'POST', p: `/ig-api-upload/v26.0/${id}`, bytes: b, headers: { ...OAUTH, ...headers } });
+        const said = (r) => String(bodyOf(r).debug_info?.message ?? '');
+        const noSize = await post(bytes, { offset: '0' });
+        const huge = await post(bytes, { offset: '0', file_size: '300000001' });
+        const past = await post(bytes, { offset: '0', file_size: String(bytes.length - 1) });
+        const empty = await post(new Uint8Array(), { offset: '0', file_size: String(bytes.length) });
+        await post(bytes.subarray(0, 100), { offset: '0', file_size: String(bytes.length) });
+        const resized = await post(bytes.subarray(100), { offset: '100', file_size: String(bytes.length + 5) });
+        const done1 = await post(bytes.subarray(100), { offset: '100', file_size: String(bytes.length) });
+        const again = await post(bytes, { offset: '0', file_size: String(bytes.length) });
+        return /file_size header must be/.test(said(noSize)) && /over the Reels maximum of 300MB/.test(said(huge)) && /run past file_size/.test(said(past)) && /carries no bytes/.test(said(empty))
+            && /differs from the/.test(said(resized)) && bodyOf(done1).success === true && /already received its whole file/.test(said(again));
+    })),
+    done('instagram.upload.expired_container', 'upload', "An upload to a container 24 hours old is refused, and a GET of an unknown container's offset is refused", 'api', 'common', () => withWorld(async (h) => {
+        const id = await container(h, {}, AT);
+        const late = await upload(h, id, mp4(), LATER(24 * 3_600_000));
+        const unknown = await h({ m: 'GET', p: '/ig-api-upload/v26.0/812345678901234567', headers: OAUTH });
+        return late.status === 400 && /expired/.test(String(bodyOf(late).debug_info?.message)) && unknown.status === 400;
+    })),
+    done('instagram.upload.file_url_refused', 'upload', 'Uploading from a hosted file_url (Meta fetching it) is refused by name, never answered as a success', 'api', 'common', () => withWorld(async (h, root) => {
+        const id = await container(h);
+        const r = await h({ m: 'POST', p: `/ig-api-upload/v26.0/${id}`, headers: { ...OAUTH, file_url: 'https://example_hosted_video.com/v.mp4' } });
+        return r.status === 422 && /\[twin gap\]/.test(String(err(r).message)) && (await readContainer(id, root))?.received === 0;
+    })),
+    // ── media_publish ────────────────────────────────────────────────────────────────────────────
+    done('instagram.publish.reel', 'publish', 'media_publish with a FINISHED container answers {id}; the media reads media_type VIDEO, media_product_type REELS, the caption, timestamp, shortcode, the /reel/ permalink, is_shared_to_feed, owner and username', 'api', 'core', () => withWorld(async (h) => {
+        const id = await publishReel(h, { caption: 'Out now #release @volter', share_to_feed: false });
+        const m = bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=id,media_type,media_product_type,caption,timestamp,shortcode,permalink,is_shared_to_feed,owner,username,comments_count,like_count` }));
+        return /^9\d{17}$/.test(id) && m.id === id && m.media_type === 'VIDEO' && m.media_product_type === 'REELS' && m.caption === 'Out now #release @volter'
+            && m.timestamp === '2026-09-27T12:00:00+0000' && /^[A-Za-z0-9_-]{11}$/.test(m.shortcode) && m.permalink === `https://www.instagram.com/reel/${m.shortcode}/`
+            && m.is_shared_to_feed === false && m.owner?.id === IG && m.username === 'metricsaurus' && m.comments_count === 0 && m.like_count === 0;
+    })),
+    done('instagram.publish.refusals', 'publish', 'Publishing a container IN_PROGRESS is 9007/2207027, in ERROR -1/2207032, EXPIRED -2/2207020; an unknown, another account\'s or an already-published container is 24/2207008; no creation_id is (#100)', 'api', 'core', () => withWorld(async (h) => {
+        const pub = (id, at = AT) => h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: id }, at });
+        const waiting = await container(h, {}, AT);
+        const failed = await container(h);
+        await upload(h, failed, mp4({ ms: 1000 }));
+        const old = await container(h, {}, AT);
+        const done1 = await container(h);
+        await upload(h, done1, mp4());
+        await pub(done1);
+        await seed(h, { id: OTHER, username: 'other.account', token: OTHER_TOKEN });
+        const theirs = String(bodyOf(await h({ m: 'POST', p: `/v26.0/${OTHER}/media`, b: { media_type: 'REELS', upload_type: 'resumable' }, headers: { authorization: `Bearer ${OTHER_TOKEN}` } })).id);
+        const r = [await pub(waiting), await pub(failed), await pub(old, LATER(24 * 3_600_000)), await pub('812345678901234567'), await pub(theirs), await pub(done1)];
+        const none = await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: {} });
+        const codes = r.map((x) => `${err(x).code}/${err(x).error_subcode}`);
+        return JSON.stringify(codes) === JSON.stringify(['9007/2207027', '-1/2207032', '-2/2207020', '24/2207008', '24/2207008', '24/2207008']) && none.status === 400 && err(none).code === 100;
+    })),
+    done('instagram.publish.daily_limit', 'publish', "An account that API-published 50 posts in a moving 24 hours is refused a 51st with 9/2207042 — a deleted one still counts, a Reel pulled by a refresh (perhaps posted in the app) does not — and may publish once the oldest leaves the window", 'api', 'core', () => withWorld(async (h, root) => {
+        const ids = [];
+        for (let i = 0; i < 49; i += 1)
+            ids.push(await publishReel(h, { caption: `n${i}` }));
+        await h({ m: 'DELETE', p: `/v26.0/${ids[0]}` });
+        for (let i = 0; i < 5; i += 1) {
+            observeResource('instagram', { type: 'media', id: String(17900000000000000n + BigInt(i)), fields: { media_type: 'VIDEO', media_product_type: 'REELS', owner: { id: IG }, timestamp: '2026-09-27T11:00:00+0000' } }, { root, at: '2026-09-27T11:30:00.000Z' });
+        }
+        const fiftieth = await publishReel(h, { caption: 'fiftieth' });
+        const id = await container(h);
+        await upload(h, id, mp4());
+        const refused = await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: id } });
+        // a day on, the fifty have left the moving window (a fresh container: the refused one has expired)
+        const next = await container(h, {}, LATER(23 * 3_600_000));
+        await upload(h, next, mp4(), LATER(23 * 3_600_000));
+        const later = await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: next }, at: LATER(24 * 3_600_000) });
+        return /^9\d{17}$/.test(fiftieth) && refused.status === 400 && err(refused).code === 9 && err(refused).error_subcode === 2207042 && later.status === 200;
+    })),
+    done('instagram.publish.ids_minted_from_state', 'publish', 'Media ids are a digest of the write, 18 digits starting 9 (above the real id space): two fresh worlds replaying the same writes mint the same id, and a delete-then-publish never reissues one', 'api', 'core', async () => {
+        const run = async () => {
+            const root = mkdtempSync(join(tmpdir(), 'instagram-cap-ids-'));
+            try {
+                const h = handleFor(root);
+                await seed(h);
+                const first = await publishReel(h, { caption: 'same' });
+                await h({ m: 'DELETE', p: `/v26.0/${first}` });
+                const second = await publishReel(h, { caption: 'same' });
+                return [first, second];
+            }
+            finally {
+                rmSync(root, { recursive: true, force: true });
+            }
+        };
+        const [a, b] = [await run(), await run()];
+        return a[0] !== a[1] && /^9\d{17}$/.test(a[0]) && /^9\d{17}$/.test(a[1]) && JSON.stringify(a) === JSON.stringify(b);
+    }),
+    // ── the IG Media node and the media edge ─────────────────────────────────────────────────────
+    done('instagram.media.list_newest_first', 'media', "GET /{ig-user-id}/media lists the account's media newest first, id only by default, the fields asked for otherwise", 'api', 'core', () => withWorld(async (h) => {
+        const a = await publishReel(h, { caption: 'first' });
+        const bId = await container(h, { caption: 'second' }, LATER(1_000));
+        await upload(h, bId, mp4(), LATER(1_000));
+        const b = String(bodyOf(await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: bId }, at: LATER(60_000) })).id);
+        const bare = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media`, at: LATER(61_000) }));
+        const rich = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media?fields=caption,media_product_type,username`, at: LATER(61_000) }));
+        return JSON.stringify(bare.data) === JSON.stringify([{ id: b }, { id: a }]) && rich.data[0].caption === 'second' && rich.data[1].caption === 'first'
+            && rich.data.every((m) => m.media_product_type === 'REELS' && m.username === 'metricsaurus');
+    })),
+    done('instagram.media.list_paging', 'media', 'limit pages the list with cursors and a next link that carries no token; after= reads the next page; a cursor the twin never issued is (#100); since/until are refused by name', 'api', 'common', () => withWorld(async (h) => {
+        const ids = [await publishReel(h, { caption: '1' }), await publishReel(h, { caption: '2' }, mp4({ ms: 4000 })), await publishReel(h, { caption: '3' }, mp4({ ms: 6000 }))];
+        const p1 = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media?limit=2&access_token=${TOKEN}`, headers: {} }));
+        const p2 = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media?limit=2&after=${encodeURIComponent(p1.paging.cursors.after)}` }));
+        const bad = await h({ m: 'GET', p: `/v26.0/${IG}/media?after=bm90LWEtY3Vyc29y` });
+        const since = await h({ m: 'GET', p: `/v26.0/${IG}/media?since=1700000000` });
+        const all = [...p1.data, ...p2.data].map((m) => m.id);
+        return p1.data.length === 2 && typeof p1.paging.next === 'string' && !p1.paging.next.includes(TOKEN) && /after=/.test(p1.paging.next) && p2.data.length === 1 && p2.paging.next === undefined
+            && new Set(all).size === 3 && ids.every((i) => all.includes(i)) && bad.status === 400 && since.status === 422;
+    })),
+    done('instagram.media.get_fields', 'media', 'GET /{ig-media-id} answers id alone by default, the fields asked for, media_url and thumbnail_url on the twin\'s base; a field the node lacks is (#100), a documented one unmodelled is refused by name', 'api', 'core', () => withWorld(async (h) => {
+        const id = await publishReel(h);
+        const bare = bodyOf(await h({ m: 'GET', p: `/v26.0/${id}` }));
+        const urls = bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=media_url,thumbnail_url`, base: 'http://127.0.0.1:4400/w/instagram' }));
+        const bogus = await h({ m: 'GET', p: `/v26.0/${id}?fields=likes_by_dinos` });
+        const views = await h({ m: 'GET', p: `/v26.0/${id}?fields=view_count` });
+        return JSON.stringify(bare) === JSON.stringify({ id }) && urls.media_url === `http://127.0.0.1:4400/w/instagram/o1/v/t16/f2/m86/${blobDigest(mp4())}.mp4`
+            && /\/v\/t51\.71878-15\/[0-9a-f]{64}_poster\.svg$/.test(urls.thumbnail_url) && bogus.status === 400 && views.status === 422;
+    })),
+    done('instagram.media.cover_url_is_thumbnail', 'media', "A Reel created with cover_url answers that URL as its thumbnail_url (the twin fetches nothing, so it is not rehosted)", 'api', 'common', () => withWorld(async (h) => {
+        const id = await publishReel(h, { cover_url: 'https://www.example.com/cover.jpg' });
+        return bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=thumbnail_url` })).thumbnail_url === 'https://www.example.com/cover.jpg';
+    })),
+    done('instagram.media.bytes_served_with_range', 'media', "media_url serves the uploaded bytes on the twin's own base: the whole file identical, Range 206, an open range capped at 8 MiB, suffix ranges, 416 past the end, 404 for a digest no live media names", 'api', 'core', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'instagram-cap-bytes-'));
+        try {
+            const { createInstagramTwinFetch } = await import("./instagram-server.js");
+            const fetcher = createInstagramTwinFetch({ root });
+            const h = handleFor(root);
+            await seed(h);
+            const bytes = mp4({ pad: 9 * 1024 * 1024 });
+            const id = await publishReel(h, {}, bytes);
+            const url = new URL(String(bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=media_url`, base: 'http://twin.test' })).media_url));
+            const get = (range) => fetcher(new Request(`http://twin.test${url.pathname}`, { headers: range ? { range } : {} }));
+            const whole = new Uint8Array(await (await get()).arrayBuffer());
+            const part = await get('bytes=100-199');
+            const partBytes = new Uint8Array(await part.arrayBuffer());
+            const open = await get('bytes=10-');
+            const suffix = await get('bytes=-50');
+            const past = await get(`bytes=${bytes.length}-`);
+            const other = await fetcher(new Request(`http://twin.test/o1/v/t16/f2/m86/${'1'.repeat(64)}.mp4`));
+            await h({ m: 'DELETE', p: `/v26.0/${id}` });
+            const deleted = await get();
+            return whole.length === bytes.length && whole.every((b, i) => b === bytes[i]) && part.status === 206 && part.headers.get('content-range') === `bytes 100-199/${bytes.length}`
+                && partBytes.every((b, i) => b === bytes[100 + i]) && open.status === 206 && open.headers.get('content-range') === `bytes 10-${10 + 8 * 1024 * 1024 - 1}/${bytes.length}`
+                && suffix.status === 206 && Number(suffix.headers.get('content-length')) === 50 && past.status === 416 && other.status === 404 && deleted.status === 404;
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    }),
+    done('instagram.media.delete', 'media', "DELETE /{ig-media-id} answers {success, deleted_id}, the media leaves every read; it needs instagram_manage_contents, and another account's media is refused", 'api', 'common', () => withWorld(async (h) => {
+        const id = await publishReel(h);
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: 'no-manage-token', user: IG, permissions: ['instagram_basic', 'instagram_content_publish'] }, headers: {} });
+        const denied = await h({ m: 'DELETE', p: `/v26.0/${id}`, headers: { authorization: 'Bearer no-manage-token' } });
+        await seed(h, { id: OTHER, username: 'other.account', token: OTHER_TOKEN });
+        const foreign = await h({ m: 'DELETE', p: `/v26.0/${id}`, headers: { authorization: `Bearer ${OTHER_TOKEN}` } });
+        const del = bodyOf(await h({ m: 'DELETE', p: `/v26.0/${id}` }));
+        const gone = await h({ m: 'GET', p: `/v26.0/${id}` });
+        const list = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media` }));
+        return denied.status === 400 && err(denied).code === 10 && foreign.status === 400 && del.success === true && del.deleted_id === id && gone.status === 400 && err(gone).error_subcode === 33 && list.data.length === 0;
+    })),
+    done('instagram.media.kernel_tombstone', 'media', 'A media the kernel tombstones (an observed `deleted`) is gone from the node and the list', 'api', 'common', () => withWorld(async (h, root) => {
+        const id = '17900000000000077';
+        const f = { media_type: 'VIDEO', media_product_type: 'REELS', owner: { id: IG }, caption: 'pulled', timestamp: '2026-09-27T09:00:00+0000', media_url: 'https://scontent.cdninstagram.com/o1/v/x.mp4' };
+        observeResource('instagram', { type: 'media', id, fields: f }, { root, at: '2026-09-27T11:00:00.000Z' });
+        const before = bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=caption,media_url` }));
+        observeResource('instagram', { type: 'media', id, fields: { ...f, deleted: true } }, { root, at: '2026-09-27T11:30:00.000Z' });
+        const after = await h({ m: 'GET', p: `/v26.0/${id}` });
+        const list = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media` }));
+        return before.caption === 'pulled' && before.media_url === f.media_url && after.status === 400 && list.data.length === 0;
+    })),
+    todo('instagram.media.comment_enabled', 'media', 'Enable or disable comments on a media (POST /{ig-media-id}?comment_enabled=)', 'api', 'common'),
+    todo('instagram.media.engagement_counts', 'media', 'view_count, reposts_count, saved_count, shares_count and the total_* counts', 'api', 'common'),
+    todo('instagram.media.children', 'media', 'The children edge of a carousel album', 'api', 'niche'),
+    todo('instagram.media.copyright_check_information', 'media', 'copyright_check_information on a published video', 'api', 'niche'),
+    todo('instagram.media.media_audio_type', 'media', 'media_audio_type (MUSIC or ORIGINAL_SOUND) and the audio_name rename', 'api', 'niche'),
+    todo('instagram.media.boost', 'media', 'boost_ads_list and boost_eligibility_info', 'api', 'niche'),
+    // ── the publishing limit ─────────────────────────────────────────────────────────────────────
+    done('instagram.limits.content_publishing_limit', 'limits', "GET /{ig-user-id}/content_publishing_limit answers {data:[{quota_usage}]} by default — the API publishes in the last 24 hours, a deleted one included, a pulled Reel not — and config {quota_total 50, quota_duration 86400} when asked (or for the reference example's rate_limit_settings); since counts from a timestamp no older than 24 hours", 'api', 'core', () => withWorld(async (h, root) => {
+        const a = await publishReel(h);
+        await publishReel(h, { caption: 'two' });
+        await h({ m: 'DELETE', p: `/v26.0/${a}` });
+        for (const id of ['17900000000000008', '17900000000000009'])
+            observeResource('instagram', { type: 'media', id, fields: { media_type: 'VIDEO', owner: { id: IG }, timestamp: '2026-09-27T11:59:00+0000' } }, { root, at: '2026-09-27T11:59:30.000Z' });
+        const plain = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/content_publishing_limit`, at: LATER(1_000) }));
+        const full = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/content_publishing_limit?fields=quota_usage,config`, at: LATER(1_000) }));
+        const example = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/content_publishing_limit?fields=quota_usage,rate_limit_settings`, at: LATER(1_000) }));
+        const since = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/content_publishing_limit?since=${Math.floor(Date.parse(AT) / 1000) + 1}`, at: LATER(5_000) }));
+        const old = await h({ m: 'GET', p: `/v26.0/${IG}/content_publishing_limit?since=${Math.floor(Date.parse(AT) / 1000) - 2 * 86_400}` });
+        const config = { quota_total: 50, quota_duration: 86400 };
+        return JSON.stringify(plain) === JSON.stringify({ data: [{ quota_usage: 2 }] }) && JSON.stringify(full) === JSON.stringify({ data: [{ quota_usage: 2, config }] })
+            && JSON.stringify(example) === JSON.stringify({ data: [{ quota_usage: 2, config }] }) && since.data[0].quota_usage === 0 && old.status === 400;
+    })),
+    // ── the rest of content publishing (the denominator) ─────────────────────────────────────────
+    todo('instagram.publishing.image_posts', 'publishing', 'Single image posts (image_url containers: JPEG, 8 MB, 4:5 to 1.91:1, alt_text)', 'api', 'core'),
+    todo('instagram.publishing.video_url_reels', 'publishing', 'Reels from a hosted video_url (Meta fetching the file), and the rupload file_url header', 'api', 'common'),
+    todo('instagram.publishing.carousels', 'publishing', 'Carousel posts (CAROUSEL containers of up to 10 image/video children)', 'api', 'common'),
+    todo('instagram.publishing.stories', 'publishing', 'Image and video stories (STORIES containers)', 'api', 'common'),
+    todo('instagram.publishing.trial_reels', 'publishing', 'Trial reels (trial_params graduation_strategy MANUAL / SS_PERFORMANCE)', 'api', 'niche'),
+    todo('instagram.publishing.tags_and_collaborators', 'publishing', 'user_tags, collaborators and location_id on a post', 'api', 'common'),
+    todo('instagram.publishing.product_tags', 'publishing', 'product_tags (shopping) on image and video posts', 'api', 'niche'),
+    todo('instagram.publishing.branded_content', 'publishing', 'Partnership ads labels (branded_content_sponsor_ids, is_paid_partnership)', 'api', 'niche'),
+    todo('instagram.publishing.cover_fetch', 'publishing', "Fetching a Reel's cover_url and holding it to the cover spec (JPEG, 8 MB), rehosted on the CDN", 'api', 'niche'),
+    todo('instagram.comments.read', 'comments', 'The comments edge on a media, and comment replies', 'api', 'common'),
+    todo('instagram.comments.moderate', 'comments', 'Reply to, hide and delete comments', 'api', 'common'),
+    todo('instagram.insights.media', 'insights', 'Media insights (reach, plays, saved, shares, total_interactions for Reels)', 'api', 'common'),
+    todo('instagram.insights.account', 'insights', 'Account insights (reach, profile views, follower demographics)', 'api', 'common'),
+    todo('instagram.discovery.hashtag_search', 'discovery', 'Hashtag search (ig_hashtag_search, top_media, recent_media)', 'api', 'niche'),
+    todo('instagram.webhooks.subscriptions', 'webhooks', 'Webhooks for comments, mentions, story insights and live comments', 'connector', 'common'),
+    todo('instagram.login.oauth', 'login', 'Business Login for Instagram: the authorize page, the code-for-token exchange, long-lived tokens and their refresh', 'api', 'common'),
+    todo('instagram.messaging', 'login', 'Instagram messaging through the Messenger Platform (a separate Meta product, one line in this denominator)', 'api', 'niche'),
+    // ── errors ───────────────────────────────────────────────────────────────────────────────────
+    done('instagram.errors.envelope_shape', 'errors', 'Every Graph refusal is {error:{message, type, code, is_transient, fbtrace_id}}, and the same refusal answers the same fbtrace_id', 'api', 'common', () => withWorld(async (h) => {
+        const rs = [await h({ m: 'GET', p: `/v26.0/${IG}`, headers: {} }), await h({ m: 'GET', p: '/v26.0/17841499999999999' }), await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'GIF' } })];
+        const again = await h({ m: 'GET', p: '/v26.0/17841499999999999' });
+        return rs.every((r) => { const e = err(r); return typeof e.message === 'string' && typeof e.type === 'string' && typeof e.code === 'number' && e.is_transient === false && /^[A-Za-z0-9_-]{11}$/.test(e.fbtrace_id); })
+            && err(again).fbtrace_id === err(rs[1]).fbtrace_id;
+    })),
+    done('instagram.errors.unknown_node_and_edge', 'errors', "An unknown node is Unsupported get request (100/33); an unknown edge is a nonexisting field; a documented edge the twin does not model is refused by name; a deeper path is Unknown path components (2500)", 'api', 'core', () => withWorld(async (h) => {
+        const node = await h({ m: 'GET', p: '/v26.0/17841499999999999' });
+        const edge = await h({ m: 'GET', p: `/v26.0/${IG}/dinosaurs` });
+        const stories = await h({ m: 'GET', p: `/v26.0/${IG}/stories` });
+        const deep = await h({ m: 'GET', p: `/v26.0/${IG}/media/extra` });
+        const post = await h({ m: 'POST', p: `/v26.0/${IG}`, b: {} });
+        return err(node).code === 100 && err(node).error_subcode === 33 && /nonexisting field \(dinosaurs\)/.test(String(err(edge).message)) && stories.status === 422 && err(deep).code === 2500 && err(post).error_subcode === 33;
+    })),
+    done('instagram.errors.malformed_body', 'errors', 'A JSON body that is not an object is (#100), and nothing is staged', 'api', 'common', () => withWorld(async (h, root) => {
+        const r = await handleInstagramTwinRequest({ method: 'POST', path: `/v26.0/${IG}/media`, headers: { ...AUTH, 'content-type': 'application/json' }, body: '[1,2', root, occurredAt: AT });
+        return r.status === 400 && r.body.error?.code === 100 && (await listContainers(root)).length === 0;
+    })),
+    done('instagram.errors.read_only', 'errors', 'A read-only twin refuses every write — a container, an upload, a publish, a delete, a seed — with 405 and still serves reads', 'api', 'common', () => withWorld(async (h) => {
+        const id = await publishReel(h);
+        const c = await container(h);
+        const w = [
+            await h({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable' }, readOnly: true }),
+            await h({ m: 'POST', p: `/ig-api-upload/v26.0/${c}`, bytes: mp4(), headers: { ...OAUTH, offset: '0', file_size: '1' }, readOnly: true }),
+            await h({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: c }, readOnly: true }),
+            await h({ m: 'DELETE', p: `/v26.0/${id}`, readOnly: true }),
+            await h({ m: 'POST', p: '/_twin/users', b: { id: '1', username: 'x' }, headers: {}, readOnly: true }),
+        ];
+        const read = await h({ m: 'GET', p: `/v26.0/${id}?fields=caption`, readOnly: true });
+        return w.every((r) => r.status === 405) && read.status === 200;
+    })),
+    todo('instagram.errors.message_wording', 'errors', "Meta's exact message wording where the Error Codes table gives none (the token errors, the parameter errors)", 'api', 'niche'),
+    todo('instagram.errors.rate_limited', 'errors', 'Business Use Case throttling answered as codes 4 / 17 / 32 / 613 with X-Business-Use-Case-Usage headers', 'api', 'common'),
+    // ── the twin control plane ───────────────────────────────────────────────────────────────────
+    done('instagram.twin_control.seed_and_validate', 'twin_control', 'A world seeds an account and a token; malformed seeds (a non-numeric id, a bad or taken username, a token for an unknown account, an undocumented permission) are refused', 'api', 'common', () => withWorld(async (h) => {
+        const bad = await Promise.all([
+            h({ m: 'POST', p: '/_twin/users', b: { id: 'abc', username: 'x' }, headers: {} }),
+            h({ m: 'POST', p: '/_twin/users', b: { id: '1', username: 'Has Spaces' }, headers: {} }),
+            h({ m: 'POST', p: '/_twin/users', b: { id: '2', username: 'metricsaurus' }, headers: {} }),
+            h({ m: 'POST', p: '/_twin/users', b: { id: '3', username: 'pic', profile_picture: btoa('not an image') }, headers: {} }),
+            h({ m: 'POST', p: '/_twin/tokens', b: { token: 'token-for-nobody', user: '999', permissions: [] }, headers: {} }),
+            h({ m: 'POST', p: '/_twin/tokens', b: { token: 'token-bad-perm', user: IG, permissions: ['instagram_everything'] }, headers: {} }),
+        ]);
+        const good = await h({ m: 'POST', p: '/_twin/users', b: { id: '17841400000000999', username: 'new.one' }, headers: {} });
+        return bad.every((r) => r.status === 400 && err(r).code === 100) && good.status === 200;
+    })),
+    // ── connector (the real state system, over an in-process vendor) ─────────────────────────────
+    done('instagram.connector.perform_reel', 'connector', "performInstagramAction crosses a Reel as Meta documents it — the container, the bytes to the rupload uri as an absolute URL on the declared host, the status wait, media_publish — and the vendor holds the Reel with byte-identical video", 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const bytes = mp4({ pad: 20_000 });
+        const media = await (async () => { const id = await container(local, { caption: 'Release day #volter', share_to_feed: true, thumb_offset: 1500, audio_name: 'Volter theme' }); await upload(local, id, bytes); return String(bodyOf(await local({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: id } })).id); })();
+        const calls = [];
+        const waits = [];
+        const out = await performInstagramAction(vendorExecutor(vendorRoot, calls), entryFor(localRoot, media, 'instagram.media.publish'), ctxFor(localRoot), async (ms) => { waits.push(ms); });
+        const vendor = handleFor(vendorRoot, '2026-09-27T14:00:00.000Z');
+        const vAuth = { authorization: 'Bearer vendor-token-0002' };
+        const got = bodyOf(await vendor({ m: 'GET', p: `/v26.0/${out.externalId}?fields=caption,media_product_type,permalink,is_shared_to_feed,media_url`, headers: vAuth }));
+        const sha = /\/([0-9a-f]{64})\.mp4$/.exec(String(got.media_url))?.[1] ?? '';
+        const up = calls.find((c) => c.path.includes('/ig-api-upload/'));
+        const vc = await readContainer(String(out.data?._vendor_container), vendorRoot);
+        return /^9\d{17}$/.test(out.externalId) && out.externalId !== media && out.url === got.permalink && got.caption === 'Release day #volter' && got.media_product_type === 'REELS'
+            && got.is_shared_to_feed === true && sha === blobDigest(bytes) && up?.absolute === true && up.path.startsWith('https://rupload.facebook.com/ig-api-upload/v26.0/') && up.offset === '0'
+            && calls.every((c) => !c.own) && JSON.stringify(waits) === JSON.stringify([60_000]) && vc?.thumb_offset === 1500 && vc.audio_name === 'Volter theme'
+            && JSON.stringify(calls.map((c) => c.method)) === JSON.stringify(['POST', 'POST', 'GET', 'GET', 'POST', 'GET']);
+    })),
+    done('instagram.connector.anchored_upload_for_a_twin_vendor', 'connector', "A twin standing as the vendor mints its rupload uri under its own base — the root's origin — so the upload goes as the anchored /ig-api-upload/… path the root's base prefixes", 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const media = await publishReel(local);
+        const calls = [];
+        const out = await performInstagramAction(vendorExecutor(vendorRoot, calls, { base: 'http://127.0.0.1:4400/acme/reality/instagram' }), entryFor(localRoot, media, 'instagram.media.publish'), ctxFor(localRoot));
+        const up = calls.find((c) => c.path.includes('/ig-api-upload/'));
+        return /^\d+$/.test(out.externalId) && up?.absolute === false && /^\/ig-api-upload\/v26\.0\/\d+$/.test(up.path)
+            && uploadTarget('https://rupload.facebook.com/ig-api-upload/v26.0/1', '1') === 'https://rupload.facebook.com/ig-api-upload/v26.0/1'
+            && uploadTarget(undefined, '5') === 'https://rupload.facebook.com/ig-api-upload/v26.0/5'
+            && ['https://rupload.facebook.com:8443/ig-api-upload/v26.0/1', 'http://rupload.facebook.com/ig-api-upload/v26.0/1', 'https://u:p@rupload.facebook.com/ig-api-upload/v26.0/1'].every((u) => { try {
+                uploadTarget(u, '1');
+                return false;
+            }
+            catch {
+                return true;
+            } });
+    })),
+    done('instagram.connector.retry_keeps_the_container', 'connector', "A perform whose publish failed keeps the vendor's container; its retry publishes that container with no second container and no second upload", 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const media = await publishReel(local);
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const calls = [];
+        const inner = vendorExecutor(vendorRoot, calls);
+        let fail = true;
+        const flaky = async (request) => {
+            if (request.path.endsWith('/media_publish') && fail) {
+                fail = false;
+                return { status: 500, headers: {}, body: '{"error":{"message":"An unknown error occurred","type":"OAuthException","code":1,"is_transient":true,"fbtrace_id":"x"}}' };
+            }
+            return inner(request);
+        };
+        let first = '';
+        // the local clock eight days AHEAD of the vendor's: the kept container's lifetime is counted locally
+        const ahead = () => Date.parse('2026-10-05T13:00:00.000Z');
+        try {
+            await performInstagramAction(flaky, entry, ctxFor(localRoot), noWait, ahead);
+        }
+        catch (e) {
+            first = String(e.message);
+        }
+        const before = calls.filter((c) => c.path.endsWith('/media') && c.method === 'POST').length;
+        const out = await performInstagramAction(flaky, entry, ctxFor(localRoot), noWait, ahead);
+        const containers = calls.filter((c) => c.path.endsWith('/media') && c.method === 'POST').length;
+        const uploads = calls.filter((c) => c.path.includes('/ig-api-upload/')).length;
+        const listed = bodyOf(await handleFor(vendorRoot, '2026-09-27T14:00:00.000Z')({ m: 'GET', p: `/v26.0/${IG}/media`, headers: { authorization: 'Bearer vendor-token-0002' } }));
+        return /HTTP 500/.test(first) && before === 1 && containers === 1 && uploads === 1 && listed.data.length === 1 && listed.data[0].id === out.externalId;
+    })),
+    done('instagram.connector.status_wait_capped', 'connector', 'A container Meta keeps IN_PROGRESS is read at 0, 60 and 120 seconds and no longer; the perform then fails retryably (a plain failure, not a refusal) and keeps the container for the retry', 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const media = await publishReel(local);
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const inner = vendorExecutor(vendorRoot, []);
+        let reads = 0;
+        const slow = async (request) => {
+            const res = await inner(request);
+            if (request.method === 'GET' && /fields=status_code/.test(request.path)) {
+                reads += 1;
+                return { ...res, body: JSON.stringify({ ...JSON.parse(res.body), status_code: 'IN_PROGRESS' }) };
+            }
+            return res;
+        };
+        const waits = [];
+        let error;
+        try {
+            await performInstagramAction(slow, entry, ctxFor(localRoot), async (ms) => { waits.push(ms); });
+        }
+        catch (e) {
+            error = e;
+        }
+        const { readPerformContainer } = await import("./instagram-media.js");
+        const kept = await readPerformContainer(entry.id, localRoot);
+        return reads === 3 && JSON.stringify(waits) === JSON.stringify([60_000, 60_000]) && waits.reduce((a, b) => a + b, 0) === MAX_STATUS_WAIT_MS
+            && error instanceof Error && error.name === 'Error' && /still IN_PROGRESS after 120s; kept/.test(error.message) && kept !== null;
+    })),
+    done('instagram.connector.lost_publish_recovered', 'connector', "A publish that reached Meta but whose answer was lost is not published twice: the retry reads the container PUBLISHED and lands the one Reel with this caption (every @ ignored, as Meta strips them) since the container opened on the vendor's clock; a caption-less Reel or no single match is refused, and a media list that cannot be read fails retryably — never a blocked queue", 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const media = await publishReel(local, { caption: 'the one that got lost, thanks @volter' });
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const inner = vendorExecutor(vendorRoot, []);
+        let lose = true;
+        // Meta strips the @ from captions for a non-admin app user: the vendor answers the list that way
+        const lossy = async (request) => {
+            const res = await inner(request);
+            if (lose && request.path.endsWith('/media_publish')) {
+                lose = false;
+                return { status: 502, headers: {}, body: '{"error":{"message":"Bad gateway","type":"OAuthException","code":2,"is_transient":true,"fbtrace_id":"x"}}' };
+            }
+            if (request.method === 'GET' && /\/media\?/.test(request.path))
+                return { ...res, body: res.body.replace(/@/g, '') };
+            return res;
+        };
+        // the local clock two hours AHEAD of the vendor's: only the vendor's own instant finds the Reel
+        const ahead = () => Date.parse('2026-09-27T15:00:00.000Z');
+        let first = '';
+        try {
+            await performInstagramAction(lossy, entry, ctxFor(localRoot), noWait, ahead);
+        }
+        catch (e) {
+            first = String(e.message);
+        }
+        const out = await performInstagramAction(lossy, entry, ctxFor(localRoot), noWait, ahead);
+        const listed = bodyOf(await handleFor(vendorRoot, '2026-09-27T14:00:00.000Z')({ m: 'GET', p: `/v26.0/${IG}/media?fields=id,caption`, headers: { authorization: 'Bearer vendor-token-0002' } })).data;
+        const { writePerformContainer } = await import("./instagram-media.js");
+        const keep = () => writePerformContainer(entry.id, { container: '812345678901234567', sha256: blobDigest(mp4()), created_ms: Date.now(), uploaded: mp4().length, target: 'https://rupload.facebook.com/ig-api-upload/v26.0/812345678901234567' }, localRoot);
+        const published = (list) => async (request) => /fields=status_code/.test(request.path) ? { status: 200, headers: {}, body: '{"id":"1","status_code":"PUBLISHED"}' }
+            : list && /\/media\?/.test(request.path) ? list(request) : { status: 200, headers: {}, body: '{}' };
+        // no single match: refused, never a second publish
+        await keep();
+        let refused;
+        try {
+            await performInstagramAction(published(async () => ({ status: 200, headers: {}, body: '{"data":[]}' })), entry, ctxFor(localRoot));
+        }
+        catch (e) {
+            refused = e;
+        }
+        // the list cannot be read: a retryable failure, the Reel not given up
+        await keep();
+        let unreadable;
+        try {
+            await performInstagramAction(published(async () => ({ status: 503, headers: {}, body: '{"error":{"message":"x","type":"OAuthException","code":2,"fbtrace_id":"x"}}' })), entry, ctxFor(localRoot));
+        }
+        catch (e) {
+            unreadable = e;
+        }
+        // a caption-less Reel: refused without guessing
+        const bare = await publishReel(local, {}, mp4({ ms: 7000 }));
+        const bareEntry = entryFor(localRoot, bare, 'instagram.media.publish');
+        await writePerformContainer(bareEntry.id, { container: '812345678901234568', sha256: blobDigest(mp4({ ms: 7000 })), created_ms: Date.now(), uploaded: mp4({ ms: 7000 }).length, target: 'https://rupload.facebook.com/ig-api-upload/v26.0/812345678901234568' }, localRoot);
+        let blind;
+        try {
+            await performInstagramAction(published(async () => ({ status: 200, headers: {}, body: JSON.stringify({ data: [{ id: '17900000000000001', media_product_type: 'REELS', timestamp: '2026-09-27T13:00:00+0000' }] }) })), bareEntry, ctxFor(localRoot));
+        }
+        catch (e) {
+            blind = e;
+        }
+        return /HTTP 502/.test(first) && listed.length === 1 && out.externalId === listed[0].id
+            && refused instanceof RefusedWriteError && /PUBLISHED at Meta/.test(refused.message) && unreadable instanceof Error && !(unreadable instanceof RefusedWriteError) && /HTTP 503/.test(unreadable.message)
+            && blind instanceof RefusedWriteError && /caption-less/.test(blind.message);
+    })),
+    done('instagram.connector.container_error_is_retryable', 'connector', "A container Meta leaves in ERROR for its own reasons (2207001) fails the perform retryably and drops the container, so the retry uploads afresh; an ERROR that names the FILE (2207026, 2207057) refuses the entry, since the same bytes fail again", 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const media = await publishReel(local);
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const { readPerformContainer } = await import("./instagram-media.js");
+        const failing = (status) => {
+            const inner = vendorExecutor(vendorRoot, []);
+            return async (request) => {
+                const res = await inner(request);
+                if (request.method === 'GET' && /fields=status_code/.test(request.path))
+                    return { ...res, body: JSON.stringify({ id: '1', status_code: 'ERROR', status }) };
+                return res;
+            };
+        };
+        let transient;
+        let spec;
+        try {
+            await performInstagramAction(failing('2207001'), entry, ctxFor(localRoot));
+        }
+        catch (e) {
+            transient = e;
+        }
+        const keptAfterTransient = await readPerformContainer(entry.id, localRoot);
+        try {
+            await performInstagramAction(failing('2207026'), entry, ctxFor(localRoot));
+        }
+        catch (e) {
+            spec = e;
+        }
+        let offset;
+        try {
+            await performInstagramAction(failing('2207057'), entry, ctxFor(localRoot));
+        }
+        catch (e) {
+            offset = e;
+        }
+        return offset instanceof RefusedWriteError && /2207057/.test(offset.message) && transient instanceof Error && !(transient instanceof RefusedWriteError) && /2207001/.test(transient.message) && keptAfterTransient === null
+            && spec instanceof RefusedWriteError && /2207026/.test(spec.message) && (await readPerformContainer(entry.id, localRoot)) === null;
+    })),
+    done('instagram.connector.upload_in_chunks_resumes', 'connector', "A Reel crosses in 8 MiB chunks (offsets 0, 8 MiB, 16 MiB), the container kept from its opening and the confirmed offset after each chunk; a chunk that failed before reaching the host is resumed at that offset on the retry, with no second container", 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const bytes = mp4({ ms: 15_000, pad: 17 * 1024 * 1024 });
+        const media = await publishReel(local, {}, bytes);
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const calls = [];
+        const inner = vendorExecutor(vendorRoot, calls);
+        let dropped = false;
+        const flaky = async (request) => {
+            if (!dropped && request.headers?.offset === String(UPLOAD_CHUNK_BYTES)) {
+                dropped = true;
+                return { status: 503, headers: {}, body: JSON.stringify({ debug_info: { retriable: true, type: 'ProcessingFailedError', message: 'x' } }) };
+            }
+            return inner(request);
+        };
+        let first = '';
+        try {
+            await performInstagramAction(flaky, entry, ctxFor(localRoot));
+        }
+        catch (e) {
+            first = String(e.message);
+        }
+        const out = await performInstagramAction(flaky, entry, ctxFor(localRoot));
+        const offsets = calls.filter((c) => c.offset !== undefined).map((c) => Number(c.offset));
+        const containers = calls.filter((c) => c.method === 'POST' && /\/media$/.test(c.path)).length;
+        const got = bodyOf(await handleFor(vendorRoot, '2026-09-27T14:00:00.000Z')({ m: 'GET', p: `/v26.0/${out.externalId}?fields=media_url`, headers: { authorization: 'Bearer vendor-token-0002' } }));
+        return /HTTP 503/.test(first) && containers === 1 && JSON.stringify(offsets) === JSON.stringify([0, UPLOAD_CHUNK_BYTES, 2 * UPLOAD_CHUNK_BYTES])
+            && String(got.media_url).endsWith(`${blobDigest(bytes)}.mp4`);
+    })),
+    done('instagram.connector.resume_refused_opens_a_new_container', 'connector', "A chunk the host received but whose answer was lost leaves the kept offset behind the host's: the resumed POST is refused, the kept container is dropped, and the next retry uploads to a new container — one Reel published", 'connector', 'common', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const bytes = mp4({ ms: 15_000, pad: 9 * 1024 * 1024 });
+        const media = await publishReel(local, {}, bytes);
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const calls = [];
+        const inner = vendorExecutor(vendorRoot, calls);
+        let lost = false;
+        const flaky = async (request) => {
+            const res = await inner(request);
+            if (!lost && request.headers?.offset === '0') {
+                lost = true;
+                return { status: 504, headers: {}, body: '{"debug_info":{"retriable":true,"type":"x","message":"gateway timeout"}}' };
+            }
+            return res;
+        };
+        const errors = [];
+        for (let i = 0; i < 2; i += 1) {
+            try {
+                await performInstagramAction(flaky, entry, ctxFor(localRoot));
+            }
+            catch (e) {
+                errors.push(String(e.message));
+            }
+        }
+        const out = await performInstagramAction(flaky, entry, ctxFor(localRoot));
+        const containers = calls.filter((c) => c.method === 'POST' && /\/media$/.test(c.path)).length;
+        const listed = bodyOf(await handleFor(vendorRoot, '2026-09-27T14:00:00.000Z')({ m: 'GET', p: `/v26.0/${IG}/media`, headers: { authorization: 'Bearer vendor-token-0002' } })).data;
+        return errors.length === 2 && /HTTP 504/.test(errors[0]) && /after a refused resume/.test(errors[1]) && containers === 2 && listed.length === 1 && listed[0].id === out.externalId;
+    })),
+    done('instagram.connector.final_chunk_answer_lost_keeps_the_container', 'connector', "When the LAST chunk reached the host but its answer was lost, the resumed POST is refused and the container reads processing done: the perform goes on with that container — no second container, no second upload", 'connector', 'common', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const bytes = mp4({ ms: 15_000, pad: 9 * 1024 * 1024 });
+        const media = await publishReel(local, {}, bytes);
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const calls = [];
+        // one second of vendor time per call: the resumed POST's status read finds Meta still PROCESSING the whole file
+        const inner = vendorExecutor(vendorRoot, calls, { step: 1_000 });
+        let lost = false;
+        const flaky = async (request) => {
+            const res = await inner(request);
+            if (!lost && request.headers?.offset === String(UPLOAD_CHUNK_BYTES)) {
+                lost = true;
+                return { status: 504, headers: {}, body: '{"debug_info":{"retriable":true,"type":"x","message":"gateway timeout"}}' };
+            }
+            return res;
+        };
+        let first = '';
+        try {
+            await performInstagramAction(flaky, entry, ctxFor(localRoot));
+        }
+        catch (e) {
+            first = String(e.message);
+        }
+        const out = await performInstagramAction(flaky, entry, ctxFor(localRoot));
+        const containers = calls.filter((c) => c.method === 'POST' && /\/media$/.test(c.path)).length;
+        const listed = bodyOf(await handleFor(vendorRoot, '2026-09-27T14:00:00.000Z')({ m: 'GET', p: `/v26.0/${IG}/media`, headers: { authorization: 'Bearer vendor-token-0002' } })).data;
+        return /HTTP 504/.test(first) && containers === 1 && listed.length === 1 && listed[0].id === out.externalId;
+    })),
+    done('instagram.connector.kept_target_revalidated', 'connector', "A kept upload target read back from the annex must be what the vendor could have answered (Meta's upload host over plain https, or the anchored path for this container): a record naming another host is dropped and a fresh container opened, so the credential never follows it", 'connector', 'common', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const bytes = mp4();
+        const media = await publishReel(local, {}, bytes);
+        const entry = entryFor(localRoot, media, 'instagram.media.publish');
+        const { writePerformContainer } = await import("./instagram-media.js");
+        const calls = [];
+        let opened = 0;
+        for (const target of ['https://graph.instagram.com/ig-api-upload/v26.0/812345678901234567', 'https://rupload.facebook.com/ig-api-upload/v26.0/899999999999999999']) {
+            await writePerformContainer(entry.id, { container: '812345678901234567', sha256: blobDigest(bytes), created_ms: Date.now(), uploaded: 0, target }, localRoot);
+            const before = calls.length;
+            try {
+                await performInstagramAction(vendorExecutor(vendorRoot, calls), entry, ctxFor(localRoot));
+            }
+            catch { /* a second publish of one entry is not the point */ }
+            opened += calls.slice(before).filter((c) => c.method === 'POST' && /\/media$/.test(c.path)).length;
+        }
+        return opened === 2 && calls.every((c) => !c.path.includes('graph.instagram.com') && !c.path.includes('899999999999999999'));
+    })),
+    done('instagram.connector.perform_delete', 'connector', 'A landed delete crosses as DELETE /{ig-media-id} against the resolved vendor id', 'connector', 'core', () => withVendor(async (local, localRoot, vendorRoot) => {
+        const media = await publishReel(local);
+        const exec = vendorExecutor(vendorRoot, []);
+        const created = await performInstagramAction(exec, entryFor(localRoot, media, 'instagram.media.publish'), ctxFor(localRoot));
+        await local({ m: 'DELETE', p: `/v26.0/${media}` });
+        const out = await performInstagramAction(exec, entryFor(localRoot, media, 'instagram.media.delete'), { ...ctxFor(localRoot), resolve: (_t, id) => (id === media ? created.externalId : id) });
+        const gone = await handleFor(vendorRoot, '2026-09-27T14:00:00.000Z')({ m: 'GET', p: `/v26.0/${created.externalId}`, headers: { authorization: 'Bearer vendor-token-0002' } });
+        return out.externalId === created.externalId && out.data?.deleted === true && gone.status === 400 && err(gone).error_subcode === 33;
+    })),
+    done('instagram.connector.perform_twin_records_cross_nothing', 'connector', "A seeded account or token is the twin's own record and performs as nothing; a token seed is bookkeeping and is never deployable at all", 'connector', 'common', () => withVendor(async (_local, localRoot, vendorRoot) => {
+        const calls = [];
+        const seeds = deployableEntries('instagram', localRoot).filter((a) => String(a.operation).startsWith('instagram.twin.'));
+        for (const s of seeds) {
+            const out = await performInstagramAction(vendorExecutor(vendorRoot, calls), s, ctxFor(localRoot));
+            if (out.data?.performed !== false)
+                return false;
+        }
+        return seeds.length === 1 && seeds[0].operation === 'instagram.twin.seed_user' && calls.length === 0;
+    })),
+    done('instagram.connector.budget_keyed_by_credential', 'connector', 'The served perform charges one ledger per sealed credential: two World roots with one credential spend one allowance', 'connector', 'core', async () => {
+        const credential = `verify-${crypto.randomUUID()}`;
+        const roots = [mkdtempSync(join(tmpdir(), 'instagram-cap-cred-a-')), mkdtempSync(join(tmpdir(), 'instagram-cap-cred-b-'))];
+        try {
+            const answering = async (r) => ({ status: 200, headers: {}, body: r.method === 'DELETE' ? '{"success":true}' : '{}' });
+            for (const root of roots) {
+                const h = handleFor(root);
+                await seed(h);
+                observeResource('instagram', { type: 'media', id: '17900000000000001', fields: { media_type: 'VIDEO', owner: { id: IG }, timestamp: '2026-09-27T09:00:00+0000' } }, { root, at: '2026-09-27T10:00:00.000Z' });
+                await h({ m: 'DELETE', p: '/v26.0/17900000000000001' });
+                await performServed(answering, entryFor(root, '17900000000000001', 'instagram.media.delete'), { ...ctxFor(root), credential });
+            }
+            // both deletes (8 units each) are on the credential's ledger, and on neither root's
+            return new InstagramBudget({ token: credential }).spend() === 16 && new InstagramBudget({ root: roots[0] }).spend() === 0;
+        }
+        finally {
+            for (const r of roots)
+                rmSync(r, { recursive: true, force: true });
+        }
+    }),
+    done('instagram.connector.refresh_observes_account_and_media', 'connector', "syncInstagramFromRemote observes the credential's account (/me) and every media it holds, paged, into a World that had none; a second refresh leaves one copy of each", 'connector', 'core', () => withVendor(async (_local, _localRoot, vendorRoot) => {
+        const vendor = handleFor(vendorRoot);
+        const vAuth = { authorization: 'Bearer vendor-token-0002' };
+        const made = [];
+        for (let i = 0; i < 3; i += 1) {
+            const bytes = mp4({ ms: 4000 + i * 1000 });
+            const c = String(bodyOf(await vendor({ m: 'POST', p: `/v26.0/${IG}/media`, b: { media_type: 'REELS', upload_type: 'resumable', caption: `on instagram.com ${i}` }, headers: vAuth, at: EARLY })).id);
+            await vendor({ m: 'POST', p: `/ig-api-upload/v26.0/${c}`, bytes, headers: { authorization: 'OAuth vendor-token-0002', offset: '0', file_size: String(bytes.length) }, at: EARLY });
+            made.push(String(bodyOf(await vendor({ m: 'POST', p: `/v26.0/${IG}/media_publish`, b: { creation_id: c }, headers: vAuth, at: LATER(i * 1000) })).id));
+        }
+        await vendor({ m: 'POST', p: '/_twin/users', b: { id: IG, username: 'metricsaurus', name: 'Named On Instagram', followers_count: 99 }, headers: {} });
+        // a World that has never seen the account: what it knows of it is what the refresh observed
+        const pulled = mkdtempSync(join(tmpdir(), 'instagram-cap-pulled-'));
+        try {
+            const exec = vendorExecutor(vendorRoot, [], { base: 'https://graph.facebook.com' });
+            const r1 = await syncInstagramFromRemote(exec, { root: pulled, occurredAt: '2026-09-27T14:00:00.000Z', budget: scratchBudget() });
+            const r2 = await syncInstagramFromRemote(exec, { root: pulled, occurredAt: '2026-09-27T14:10:00.000Z', budget: scratchBudget() });
+            const h = handleFor(pulled);
+            await h({ m: 'POST', p: '/_twin/tokens', b: { token: TOKEN, user: IG, permissions: PERMS }, headers: {} });
+            const me = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}?fields=username,name,followers_count,media_count` }));
+            const got = bodyOf(await h({ m: 'GET', p: `/v26.0/${made[0]}?fields=caption,media_url` }));
+            const listed = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media` })).data;
+            return r1.media === 3 && r2.media === 3 && me.username === 'metricsaurus' && me.name === 'Named On Instagram' && me.followers_count === 99 && me.media_count === 3
+                && got.caption === 'on instagram.com 0' && /^https:\/\/graph\.facebook\.com\/o1\//.test(String(got.media_url)) && listed.length === 3 && made.every((m) => listed.some((l) => l.id === m));
+        }
+        finally {
+            rmSync(pulled, { recursive: true, force: true });
+        }
+    })),
+    done('instagram.connector.refresh_refusal_throws', 'connector', 'A refused refresh read throws rather than folding an empty account', 'connector', 'core', async () => {
+        const refusing = async () => ({ status: 400, headers: {}, body: JSON.stringify({ error: { message: 'Invalid OAuth access token', type: 'OAuthException', code: 190, fbtrace_id: 'x' } }) });
+        const emptyBody = async (r) => ({ status: 200, headers: {}, body: /\/me\?/.test(r.path) ? JSON.stringify({ id: IG, username: 'metricsaurus' }) : '{}' });
+        const root = mkdtempSync(join(tmpdir(), 'instagram-cap-refuse-'));
+        try {
+            const messages = [];
+            for (const exec of [refusing, emptyBody]) {
+                try {
+                    await syncInstagramFromRemote(exec, { root, budget: scratchBudget() });
+                    messages.push('no throw');
+                }
+                catch (e) {
+                    messages.push(String(e.message));
+                }
+            }
+            return /refused IG User GET me: HTTP 400/.test(messages[0]) && /with no data/.test(messages[1]);
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    }),
+    done('instagram.connector.declared_host_executor', 'connector', "Through the kernel's own executor (buildRemoteExecute for an https root with this pack's hosts): the rupload upload goes to rupload.facebook.com WITH the sealed credential; an undeclared host, a rupload path outside /ig-api-upload/ and a userinfo URL are refused before any request", 'connector', 'core', async () => {
+        const { pack } = await import("./index.js");
+        const seen = [];
+        const realFetch = globalThis.fetch;
+        globalThis.fetch = (async (input, init) => {
+            const req = new Request(input, init);
+            seen.push({ url: req.url, auth: req.headers.get('authorization'), offset: req.headers.get('offset') });
+            return new Response(JSON.stringify({ success: true, message: 'Upload successful.' }), { status: 200, headers: { 'content-type': 'application/json' } });
+        });
+        try {
+            const exec = buildRemoteExecute(validateRemoteOrigin('https://graph.facebook.com'), { headers: { authorization: 'OAuth sealed-credential-0003' } }, undefined, pack.hosts);
+            await uploadReel(exec, 'https://rupload.facebook.com/ig-api-upload/v26.0/812345678901234567', new Uint8Array([1, 2, 3]));
+            const refused = [];
+            for (const url of ['https://evil.example/ig-api-upload/v26.0/1', 'https://rupload.facebook.com/other/1', 'https://user:pw@rupload.facebook.com/ig-api-upload/v26.0/1']) {
+                try {
+                    await uploadReel(exec, url, new Uint8Array([1]));
+                }
+                catch (e) {
+                    refused.push(String(e.message));
+                }
+            }
+            return seen.length === 1 && seen[0].url === 'https://rupload.facebook.com/ig-api-upload/v26.0/812345678901234567' && seen[0].auth === 'OAuth sealed-credential-0003' && seen[0].offset === '0'
+                && refused.length === 3 && /not a host this vendor's pack declares/.test(refused[0]) && /not a host this vendor's pack declares/.test(refused[1]) && /userinfo/.test(refused[2]);
+        }
+        finally {
+            globalThis.fetch = realFetch;
+        }
+    }),
+    todo('instagram.connector.refresh_deletions', 'connector', 'A refresh that tombstones media deleted on instagram.com (the media list read in full as a complete scope)', 'connector', 'common'),
+    todo('instagram.connector.refresh_bytes', 'connector', "Refresh a pulled Reel's bytes onto the blob seam, so a pulled Reel previews offline", 'connector', 'niche'),
+    // ── the rate budget (the fail-closed backstop on the perform and refresh paths) ──────────────
+    done('instagram.rate_limit.budget_fails_closed', 'rate_limit', "The budgeted executor refuses BEFORE calling once the declared burst is spent: a second publish in a minute is refused with the fake's call count unchanged", 'connector', 'core', async () => {
+        let calls = 0;
+        const fake = async () => { calls += 1; return { status: 200, headers: {}, body: '{"id":"1"}' }; };
+        const exec = budgetedInstagramExecute(fake, scratchBudget());
+        let refusedAt = -1;
+        for (let i = 0; i < 3; i += 1) {
+            try {
+                await exec({ method: 'POST', path: `/v26.0/${IG}/media_publish`, body: '{}' });
+            }
+            catch (error) {
+                if (error instanceof InstagramBudgetError) {
+                    refusedAt = i;
+                    break;
+                }
+                throw error;
+            }
+        }
+        return refusedAt === 1 && calls === 1;
+    }),
+    done('instagram.rate_limit.prices', 'rate_limit', 'A publish costs 100, a container 16, a delete 8, an 8 MiB rupload chunk 1 on Meta\'s host or anchored, a read 1', 'connector', 'core', () => instagramCallWeight('POST', `/v26.0/${IG}/media_publish`) === 100 && instagramCallWeight('POST', `/v26.0/${IG}/media`) === 16 && instagramCallWeight('DELETE', '/v26.0/1790000') === 8
+        && instagramCallWeight('POST', 'https://rupload.facebook.com/ig-api-upload/v26.0/8123') === 1 && instagramCallWeight('POST', '/ig-api-upload/v26.0/8123') === 1
+        && instagramCallWeight('GET', '/v26.0/8123?fields=status_code') === 1 && instagramCallWeight('GET', `/v26.0/${IG}/media?limit=100`) === 1 && instagramCallWeight('POST', '/v26.0/1/unknown') === 6),
+    done('instagram.rate_limit.declaration_is_the_descriptor', 'rate_limit', 'The pack descriptor arms the SAME declaration the adapters charge; spent flat out for a day it stays under 50 publishes and 400 containers, and its burst admits one whole perform of the largest (300 MB) Reel', 'connector', 'core', async () => {
+        const { pack } = await import("./index.js");
+        const d = INSTAGRAM_RATE_BUDGET;
+        const chunks = Math.ceil(300_000_000 / UPLOAD_CHUNK_BYTES);
+        const perform = INSTAGRAM_CALL_WEIGHTS.container + chunks * INSTAGRAM_CALL_WEIGHTS.upload + 3 * INSTAGRAM_CALL_WEIGHTS.read + INSTAGRAM_CALL_WEIGHTS.publish;
+        return pack.rateBudget === d && d.windowMs === 3_600_000 && Math.floor(d.ceiling / INSTAGRAM_CALL_WEIGHTS.publish) * 24 <= 50
+            && Math.floor(d.ceiling / INSTAGRAM_CALL_WEIGHTS.container) * 24 <= 400 && (d.burstCeiling ?? 0) >= perform && (d.burstCeiling ?? 0) / d.defaultWeight <= 30 && chunks === 36;
+    }),
+    todo('instagram.rate_limit.buc_headers', 'rate_limit', "Settle the ledger from Meta's X-Business-Use-Case-Usage / X-App-Usage headers rather than only 429s", 'connector', 'common'),
+    // ══ MIRROR (dimension 'ui' — each DATA-COUPLED: seed through the handler, read the SAME route the
+    // screen reads, render the mirror's OWN component over it) ═════════════════════════════════════
+    done('instagram.mirror.profile_header', 'mirror', "The profile header renders the /me read: avatar, username, the posts / followers / following counts, name, bio and website", 'ui', 'core', () => withWorld(async (h) => {
+        await publishReel(h);
+        const me = bodyOf(await h({ m: 'GET', p: '/v26.0/me?fields=id,username,name,biography,website,followers_count,follows_count,media_count,profile_picture_url' }));
+        const html = renderToStaticMarkup(createElement(ProfileHeader, { profile: profileFromRead(me) }));
+        return html.includes('>metricsaurus</h2>') && html.includes('<span class="count">1</span> post<') && html.includes('<span class="count">12.4K</span> followers')
+            && html.includes('<span class="count">87</span> following') && html.includes('Dino data crunching app') && html.includes('metricsaurus.com') && html.includes('avatar-empty');
+    })),
+    done('instagram.mirror.counts_only_when_held', 'mirror', 'An account that holds no follower or following count shows no such count — never "0 followers"', 'ui', 'common', () => withWorld(async (h) => {
+        await h({ m: 'POST', p: '/_twin/users', b: { id: OTHER, username: 'sparse.account' }, headers: {} });
+        await h({ m: 'POST', p: '/_twin/tokens', b: { token: OTHER_TOKEN, user: OTHER, permissions: PERMS }, headers: {} });
+        const me = bodyOf(await h({ m: 'GET', p: '/v26.0/me?fields=id,username,followers_count,follows_count,media_count', headers: { authorization: `Bearer ${OTHER_TOKEN}` } }));
+        const html = renderToStaticMarkup(createElement(ProfileHeader, { profile: profileFromRead(me) }));
+        return html.includes('>sparse.account</h2>') && !/follower/.test(html) && !/following/.test(html) && html.includes('<span class="count">0</span> posts');
+    })),
+    done('instagram.mirror.reels_grid', 'mirror', "The Reels grid renders the media list: a 9:16 tile per Reel linking to its /reel/<shortcode>/ route, the Reel's own first frame (the twin's thumbnail is a stand-in) or its cover image, a play glyph and no view count it does not hold", 'ui', 'core', () => withWorld(async (h) => {
+        await publishReel(h, { caption: 'first' });
+        await publishReel(h, { caption: 'covered', cover_url: 'https://www.example.com/cover.jpg' }, mp4({ ms: 7000 }));
+        const list = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media?fields=id,media_product_type,media_url,thumbnail_url,shortcode,caption,like_count,comments_count` })).data;
+        const html = renderToStaticMarkup(createElement(ReelsGrid, { reels: list, shape: 'reels' }));
+        const plain = list.find((m) => m.caption === 'first');
+        return html.includes('grid grid-reels') && list.every((m) => html.includes(`href="${reelRoute(String(m.shortcode))}"`) && html.includes(`data-media-id="${m.id}"`))
+            && html.includes(`src="${String(plain.media_url)}#t=0.1"`) && html.includes('src="https://www.example.com/cover.jpg"')
+            && (html.match(/class="tile-views"><svg[^>]*>.*?<\/svg><\/span>/g) ?? []).length === 2 && /\.grid-reels \.tile \{ aspect-ratio: 9 \/ 16; \}/.test(await instagramMirrorStyles());
+    })),
+    done('instagram.mirror.posts_tab_honours_share_to_feed', 'mirror', "The profile screen's Posts tab shows only Reels shared to the feed (share_to_feed false keeps a Reel in the Reels tab alone; a pulled Reel whose node omits the field stays), from the same media read the grid makes", 'ui', 'core', () => withWorld(async (h, root) => {
+        await publishReel(h, { caption: 'in the feed' });
+        await publishReel(h, { caption: 'reels tab only', share_to_feed: false }, mp4({ ms: 6000 }));
+        observeResource('instagram', { type: 'media', id: '17900000000000031', fields: { media_type: 'VIDEO', media_product_type: 'REELS', owner: { id: IG }, caption: 'pulled', shortcode: 'PULLEDCODE1', timestamp: '2026-09-27T09:00:00+0000', media_url: 'https://scontent.cdninstagram.com/o1/v/p.mp4' } }, { root, at: '2026-09-27T10:00:00.000Z' });
+        const me = bodyOf(await h({ m: 'GET', p: '/v26.0/me?fields=id,username,media_count' }));
+        const list = bodyOf(await h({ m: 'GET', p: mediaQuery(IG) })).data;
+        const account = { profile: profileFromRead(me), reels: list, error: null };
+        const posts = renderToStaticMarkup(createElement(ProfileScreen, { account, route: { page: 'profile', tab: 'posts' } }));
+        const reels = renderToStaticMarkup(createElement(ProfileScreen, { account, route: { page: 'profile', tab: 'reels' } }));
+        const id = (c) => String(list.find((m) => m.caption === c)?.id);
+        return list.length === 3 && posts.includes('grid grid-posts') && posts.includes(`data-media-id="${id('in the feed')}"`) && posts.includes(`data-media-id="${id('pulled')}"`)
+            && !posts.includes(`data-media-id="${id('reels tab only')}"`) && reels.includes('grid grid-reels') && ['in the feed', 'pulled', 'reels tab only'].every((c) => reels.includes(`data-media-id="${id(c)}"`));
+    })),
+    done('instagram.mirror.reel_viewer', 'mirror', "The Reel viewer renders one Reel full height: its media_url playing (autoplay, muted, looped), the username and avatar, the caption with #tags and @mentions as links, the age from the World's clock, and links to the neighbouring Reels", 'ui', 'core', () => withWorld(async (h) => {
+        await publishReel(h, { caption: 'Out now #release with @volter' });
+        const me = bodyOf(await h({ m: 'GET', p: '/v26.0/me?fields=id,username,profile_picture_url,media_count' }));
+        const reel = bodyOf(await h({ m: 'GET', p: `/v26.0/${IG}/media?fields=id,media_product_type,media_url,caption,timestamp,shortcode,like_count,comments_count` })).data[0];
+        const html = renderToStaticMarkup(createElement(ReelViewer, { reel, profile: profileFromRead(me), nowMs: Date.parse(AT) + 3 * 3600_000, next: 'NEXTCODE123' }));
+        return html.includes(`src="${String(reel.media_url)}"`) && /<video[^>]*autoplay=""[^>]*loop=""[^>]*muted=""/i.test(html) && html.includes('>metricsaurus</a>') && html.includes('class="ig-link">#release<')
+            && html.includes('class="ig-link">@volter<') && html.includes('>3h<') && html.includes(`href="${reelRoute('NEXTCODE123')}"`) && !html.includes('Previous reel');
+    })),
+    done('instagram.mirror.format_helpers', 'mirror', "The mirror's own formatters: instagram.com counts (1,234 / 12.4K / 1.2M), post ages, and caption segments", 'ui', 'common', () => withWorld(async (h) => {
+        const id = await publishReel(h, { caption: 'Ship it #twin, thanks @volter.ai! email me a@b.c' });
+        const m = bodyOf(await h({ m: 'GET', p: `/v26.0/${id}?fields=caption,timestamp` }));
+        const segs = captionSegments(m.caption);
+        const now = Date.parse(AT);
+        return segs.some((s) => s.kind === 'hashtag' && s.value === '#twin') && segs.some((s) => s.kind === 'mention' && s.value === '@volter.ai') && !segs.some((s) => s.value === '@b.c')
+            && segs.map((s) => s.value).join('') === m.caption && timeAgo(m.timestamp, now + 90_000) === '1m' && timeAgo(m.timestamp, now + 2 * 86_400_000) === '2d'
+            && timeAgo(m.timestamp, now + 60 * 86_400_000) === 'September 27' && compactCount(1234) === '1,234' && compactCount(12480) === '12.4K' && compactCount(1_250_000) === '1.2M' && compactCount(10_000) === '10K';
+    })),
+    done('instagram.mirror.serves_the_vendor_api_on_its_own_origin', 'mirror', 'The mirror origin serves the REAL Instagram handler — one serving code path — with its shell (<base href="/">, relative assets) and the token-gated Graph API', 'ui', 'core', async () => {
+        const root = mkdtempSync(join(tmpdir(), 'instagram-cap-mirror-'));
+        const server = await createInstagramMirrorServer({ root, port: 0 });
+        try {
+            const json = { 'content-type': 'application/json' };
+            await fetch(`${server.url}/_twin/users`, { method: 'POST', headers: json, body: JSON.stringify({ id: IG, username: 'metricsaurus' }) });
+            await fetch(`${server.url}/_twin/tokens`, { method: 'POST', headers: json, body: JSON.stringify({ token: TOKEN, user: IG, permissions: PERMS }) });
+            const created = await (await fetch(`${server.url}/v26.0/${IG}/media`, { method: 'POST', headers: { ...json, ...AUTH }, body: JSON.stringify({ media_type: 'REELS', upload_type: 'resumable' }) })).json();
+            const direct = await handleInstagramTwinRequest({ method: 'GET', path: `/v26.0/${created.id}?fields=status_code`, headers: AUTH, root });
+            const me = await (await fetch(`${server.url}/v26.0/me?fields=username`, { headers: AUTH })).json();
+            const anon = await fetch(`${server.url}/v26.0/me`);
+            const shell = await (await fetch(`${server.url}/`)).text();
+            return String(created.uri).startsWith(`${server.url}/ig-api-upload/`) && direct.body.status_code === 'IN_PROGRESS' && me.username === 'metricsaurus' && anon.status === 400
+                && shell.includes('<div id="root">') && shell.includes('<base href="/">') && shell.includes('href="assets/styles.css"') && shell.includes('src="assets/app.js"');
+        }
+        finally {
+            server.stop();
+            rmSync(root, { recursive: true, force: true });
+        }
+    }),
+    todo('instagram.mirror.image_posts', 'mirror', 'Image and carousel posts in the Posts grid and a post page (needs image posts)', 'ui', 'common'),
+    todo('instagram.mirror.comments', 'mirror', "A Reel's comments panel (needs the comments edge)", 'ui', 'common'),
+    todo('instagram.mirror.view_counts', 'mirror', 'View counts on the Reels grid (needs view_count)', 'ui', 'common'),
+    todo('instagram.mirror.compose', 'mirror', "instagram.com's Create flow (upload a Reel, caption, share) writing through the container / rupload / media_publish routes", 'ui', 'common'),
+];
+export async function instagramCapabilities() {
+    return checkCapabilities('instagram', INSTAGRAM_CAPABILITIES);
+}