@volter/twin-instagram 0.1.0

package/dist/client/instagram-mirror.d.ts

@@ -0,0 +1,58 @@
+import { type IgRow, type MirrorProfile } from '../src/instagram-mirror-ui.js';
+type Session = {
+    username: string;
+    token: string;
+};
+export type Route = {
+    page: 'profile';
+    username?: string;
+    tab: 'posts' | 'reels';
+} | {
+    page: 'reel';
+    shortcode: string | null;
+};
+export declare function Wordmark({ size }: {
+    size?: number;
+}): import("react").JSX.Element;
+/** The account's avatar: its profile picture, else instagram.com's empty silhouette. */
+export declare function Avatar({ src, size, ring }: {
+    src?: string;
+    size: number;
+    ring?: boolean;
+}): import("react").JSX.Element;
+export declare function Caption({ text }: {
+    text: unknown;
+}): import("react").JSX.Element;
+export declare function ProfileHeader({ profile }: {
+    profile: MirrorProfile;
+}): import("react").JSX.Element;
+export declare function ProfileTabs({ username, tab }: {
+    username: string;
+    tab: 'posts' | 'reels';
+}): import("react").JSX.Element;
+export declare function ReelsGrid({ reels, shape }: {
+    reels: IgRow[];
+    shape: 'reels' | 'posts';
+}): import("react").JSX.Element;
+export type Account = {
+    profile: MirrorProfile | null;
+    reels: IgRow[] | null;
+    error: string | null;
+};
+export declare function ProfileScreen({ account, route }: {
+    account: Account;
+    route: Extract<Route, {
+        page: 'profile';
+    }>;
+}): import("react").JSX.Element;
+export declare function ReelViewer({ reel, profile, nowMs, prev, next }: {
+    reel: IgRow;
+    profile: MirrorProfile;
+    nowMs: number;
+    prev?: string;
+    next?: string;
+}): import("react").JSX.Element;
+export declare function LoginScreen({ onSignedIn }: {
+    onSignedIn: (s: Session) => void;
+}): import("react").JSX.Element;
+export {};

package/dist/client/instagram-mirror.js

@@ -0,0 +1,257 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+// Instagram mirror — React/TSX client. instagram.com's own view of the twin's state: log in as the
+// professional account, see its profile (avatar, username, counts, bio) with its Reels grid, and play a
+// Reel full height. Every read is the twin's OWN Graph API on the same origin; nothing is kept but the
+// signed-in username and token, in the tab's sessionStorage. Routes are `#/…` links, never assigned.
+import { createRoot } from 'react-dom/client';
+import { useEffect, useRef, useState } from 'react';
+import { captionSegments, compactCount, isReel, mediaQuery, MIRROR_VERSION, PROFILE_FIELDS, profileFromRead, reelRoute, tabReels, timeAgo, } from "../src/instagram-mirror-ui.js";
+// WHERE THIS MIRROR LIVES. At a vendor root the base is '' (fetches are root-relative); under a
+// World's <base> every read resolves inside that prefix.
+const WIRE_BASE = typeof document === 'undefined' || document.querySelector('base[href]') === null ? '' : new URL('.', document.baseURI).pathname.replace(/\/$/, '');
+const SESSION_USER = 'instagram-mirror.username';
+const SESSION_TOKEN = 'instagram-mirror.token';
+function readSession() {
+    if (typeof sessionStorage === 'undefined')
+        return null;
+    const username = sessionStorage.getItem(SESSION_USER);
+    const token = sessionStorage.getItem(SESSION_TOKEN);
+    return username && token ? { username, token } : null;
+}
+// THE WORLD'S CLOCK: every answer carries the World's instant as its HTTP `Date`, so ages are drawn
+// against the World's now, never the browser's.
+let worldNowMs = null;
+const currentNow = () => worldNowMs ?? Date.now();
+async function wire(token, path) {
+    const res = await fetch(`${WIRE_BASE}${path}`, { headers: { authorization: `Bearer ${token}` } });
+    const served = Date.parse(res.headers.get('date') ?? '');
+    if (Number.isFinite(served))
+        worldNowMs = served;
+    let body = {};
+    try {
+        body = await res.json();
+    }
+    catch {
+        body = {};
+    }
+    return { status: res.status, body };
+}
+const problemText = (w) => String(w.body.error?.message ?? `HTTP ${w.status}`);
+function parseRoute(hash) {
+    const parts = hash.replace(/^#\/?/, '').split('/').filter(Boolean).map(decodeURIComponent);
+    if (parts[0] === 'reel' && parts[1])
+        return { page: 'reel', shortcode: parts[1] };
+    if (parts[0] === 'reels' && !parts[1])
+        return { page: 'reel', shortcode: null };
+    if (parts[0])
+        return { page: 'profile', username: parts[0], tab: parts[1] === 'reels' ? 'reels' : 'posts' };
+    return { page: 'profile', tab: 'reels' };
+}
+// ── icons (vendor mirror: instagram.com's look, drawn here) ────────────────────────────────────
+const S = { fill: 'none', stroke: 'currentColor', strokeWidth: 2, strokeLinecap: 'round', strokeLinejoin: 'round' };
+function Svg({ size = 24, children, label }) {
+    return _jsx("svg", { viewBox: "0 0 24 24", width: size, height: size, "aria-label": label, "aria-hidden": label ? undefined : true, role: label ? 'img' : undefined, children: children });
+}
+const IconHome = () => _jsx(Svg, { children: _jsx("path", { ...S, d: "M9.005 16.545a2.997 2.997 0 0 1 2.997-2.997A2.997 2.997 0 0 1 15 16.545V22h7V11.543L12 2 2 11.543V22h7.005Z" }) });
+const IconSearch = () => _jsxs(Svg, { children: [_jsx("circle", { ...S, cx: "10.5", cy: "10.5", r: "7.5" }), _jsx("path", { ...S, d: "m16.5 16.5 5.5 5.5" })] });
+const IconExplore = () => _jsxs(Svg, { children: [_jsx("circle", { ...S, cx: "12", cy: "12", r: "10" }), _jsx("path", { ...S, d: "m13.94 13.94-5.66 1.82 1.82-5.66 5.66-1.82z" })] });
+const IconReels = ({ size = 24 }) => _jsxs(Svg, { size: size, children: [_jsx("rect", { ...S, x: "2", y: "2", width: "20", height: "20", rx: "5" }), _jsx("path", { ...S, d: "M2.05 7.5h19.9M13.5 2.05l3.4 5.45M7.36 2.2l3.35 5.3" }), _jsx("path", { d: "M9.8 17.2V11.1a.5.5 0 0 1 .76-.43l5.02 3.05a.5.5 0 0 1 0 .86l-5.02 3.05a.5.5 0 0 1-.76-.43Z", fill: "currentColor" })] });
+const IconMessages = () => _jsx(Svg, { children: _jsx("path", { ...S, d: "M22 3 9.2 10.1M22 3l-7 19-5.8-11.9L2 7.6z" }) });
+const IconHeart = ({ size = 24 }) => _jsx(Svg, { size: size, children: _jsx("path", { ...S, d: "M16.8 3.2a5.4 5.4 0 0 0-4.8 2.9 5.4 5.4 0 0 0-4.8-2.9A5.2 5.2 0 0 0 2 8.6c0 5.3 5.5 8.4 10 12.2 4.5-3.8 10-6.9 10-12.2a5.2 5.2 0 0 0-5.2-5.4Z" }) });
+const IconCreate = () => _jsxs(Svg, { children: [_jsx("rect", { ...S, x: "2", y: "2", width: "20", height: "20", rx: "5" }), _jsx("path", { ...S, d: "M12 7v10M7 12h10" })] });
+const IconMenu = () => _jsx(Svg, { children: _jsx("path", { ...S, d: "M3 5h18M3 12h18M3 19h18" }) });
+const IconComment = ({ size = 24 }) => _jsx(Svg, { size: size, children: _jsx("path", { ...S, d: "M20.66 17A9.9 9.9 0 1 0 17 20.66L22 22Z" }) });
+const IconShare = ({ size = 24 }) => _jsx(Svg, { size: size, children: _jsx("path", { ...S, d: "M22 3 9.2 10.1M22 3l-7 19-5.8-11.9L2 7.6z" }) });
+const IconSave = ({ size = 24 }) => _jsx(Svg, { size: size, children: _jsx("path", { ...S, d: "M20 21 12 13.44 4 21V3h16z" }) });
+const IconMore = ({ size = 24 }) => _jsxs(Svg, { size: size, children: [_jsx("circle", { cx: "5", cy: "12", r: "1.6", fill: "currentColor" }), _jsx("circle", { cx: "12", cy: "12", r: "1.6", fill: "currentColor" }), _jsx("circle", { cx: "19", cy: "12", r: "1.6", fill: "currentColor" })] });
+const IconGrid = () => _jsx(Svg, { size: 12, children: _jsx("path", { ...S, d: "M3 3h18v18H3zM9 3v18M15 3v18M3 9h18M3 15h18" }) });
+const IconTagged = () => _jsx(Svg, { size: 12, children: _jsx("path", { ...S, d: "M10.2 18.1 12 21l1.8-2.9H21V3H3v15.1zM12 11.5a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5ZM7 15.5c.8-1.7 2.7-2.7 5-2.7s4.2 1 5 2.7" }) });
+const IconPlay = ({ size = 22 }) => _jsx(Svg, { size: size, children: _jsx("path", { d: "M5.9 3.4a1 1 0 0 1 1.5-.9l13 8.2a1.5 1.5 0 0 1 0 2.6l-13 8.2a1 1 0 0 1-1.5-.9Z", fill: "currentColor" }) });
+const IconMuted = () => _jsx(Svg, { size: 14, children: _jsx("path", { d: "M3 9v6h4l5 5V4L7 9Zm13.6 3 2.7-2.7-1.4-1.4-2.7 2.7-2.7-2.7-1.4 1.4 2.7 2.7-2.7 2.7 1.4 1.4 2.7-2.7 2.7 2.7 1.4-1.4Z", fill: "currentColor" }) });
+const IconSound = () => _jsx(Svg, { size: 14, children: _jsx("path", { d: "M3 9v6h4l5 5V4L7 9Zm13.5 3A4.5 4.5 0 0 0 14 8v8a4.5 4.5 0 0 0 2.5-4Zm-2.5-9v2.1a7 7 0 0 1 0 13.8V21a9 9 0 0 0 0-18Z", fill: "currentColor" }) });
+const IconGear = () => _jsxs(Svg, { children: [_jsx("circle", { ...S, cx: "12", cy: "12", r: "3" }), _jsx("path", { ...S, d: "M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 1 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06A1.65 1.65 0 0 0 4.68 15a1.65 1.65 0 0 0-1.51-1H3a2 2 0 1 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 9 4.68a1.65 1.65 0 0 0 1-1.51V3a2 2 0 1 1 4 0v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 1 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1Z" })] });
+const IconClose = () => _jsx(Svg, { size: 20, children: _jsx("path", { ...S, d: "M5 5l14 14M19 5 5 19" }) });
+const IconUp = () => _jsx(Svg, { size: 16, children: _jsx("path", { ...S, d: "m6 15 6-6 6 6" }) });
+const IconDown = () => _jsx(Svg, { size: 16, children: _jsx("path", { ...S, d: "m6 9 6 6 6-6" }) });
+export function Wordmark({ size = 29 }) {
+    return _jsx("span", { className: "wordmark", style: { fontSize: size }, "aria-label": "Instagram", children: "Instagram" });
+}
+/** The account's avatar: its profile picture, else instagram.com's empty silhouette. */
+export function Avatar({ src, size, ring = false }) {
+    const inner = src
+        ? _jsx("img", { className: "avatar-img", src: src, width: size, height: size, alt: "Profile picture" })
+        : (_jsxs("svg", { className: "avatar-img avatar-empty", viewBox: "0 0 40 40", width: size, height: size, "aria-label": "Profile picture", role: "img", children: [_jsx("rect", { width: "40", height: "40", fill: "#dbdbdb" }), _jsx("circle", { cx: "20", cy: "15.5", r: "7", fill: "#fff" }), _jsx("path", { d: "M6 38c1.6-7.2 7.3-11 14-11s12.4 3.8 14 11Z", fill: "#fff" })] }));
+    return _jsx("span", { className: `avatar${ring ? ' avatar-ring' : ''}${src ? ' avatar-has-img' : ''}`, style: { width: size, height: size }, children: inner });
+}
+export function Caption({ text }) {
+    return (_jsx(_Fragment, { children: captionSegments(text).map((s, i) => (s.kind === 'text' ? _jsx("span", { children: s.value }, i) : _jsx("span", { className: "ig-link", children: s.value }, i))) }));
+}
+// ── the profile ─────────────────────────────────────────────────────────────────────────────────
+export function ProfileHeader({ profile }) {
+    const count = (n, one, many) => typeof n === 'number' ? _jsxs("li", { children: [_jsx("span", { className: "count", children: compactCount(n) }), " ", n === 1 ? one : many] }) : null;
+    return (_jsxs("header", { className: "profile-header", children: [_jsx("div", { className: "profile-avatar", children: _jsx(Avatar, { src: profile.avatarUrl, size: 150 }) }), _jsxs("section", { className: "profile-info", children: [_jsxs("div", { className: "profile-row", children: [_jsx("h2", { className: "profile-username", children: profile.username }), _jsx("span", { className: "btn-secondary", children: "Edit profile" }), _jsx("span", { className: "btn-secondary", children: "View archive" }), _jsx("span", { className: "profile-gear", "aria-label": "Options", children: _jsx(IconGear, {}) })] }), _jsxs("ul", { className: "profile-counts", children: [count(profile.posts, 'post', 'posts'), count(profile.followers, 'follower', 'followers'), typeof profile.following === 'number' ? _jsxs("li", { children: [_jsx("span", { className: "count", children: compactCount(profile.following) }), " following"] }) : null] }), profile.name ? _jsx("div", { className: "profile-name", children: profile.name }) : null, profile.biography ? _jsx("div", { className: "profile-bio", children: profile.biography }) : null, profile.website ? _jsx("a", { className: "profile-website", href: profile.website, target: "_blank", rel: "noreferrer", children: profile.website.replace(/^https?:\/\/(www\.)?/, '').replace(/\/$/, '') }) : null] })] }));
+}
+export function ProfileTabs({ username, tab }) {
+    const u = encodeURIComponent(username);
+    return (_jsxs("nav", { className: "profile-tabs", children: [_jsxs("a", { className: tab === 'posts' ? 'profile-tab active' : 'profile-tab', href: `#/${u}/`, children: [_jsx(IconGrid, {}), _jsx("span", { children: "POSTS" })] }), _jsxs("a", { className: tab === 'reels' ? 'profile-tab active' : 'profile-tab', href: `#/${u}/reels/`, children: [_jsx(IconReels, { size: 12 }), _jsx("span", { children: "REELS" })] }), _jsxs("span", { className: "profile-tab", children: [_jsx(IconTagged, {}), _jsx("span", { children: "TAGGED" })] })] }));
+}
+/** A Reel's still: its cover when it has one; the twin's thumbnail is a stand-in (an SVG — it decodes
+ *  no frame), so the browser draws the Reel's own first frame instead. */
+function ReelStill({ reel }) {
+    const thumb = typeof reel.thumbnail_url === 'string' ? reel.thumbnail_url : '';
+    if (thumb && !/\.svg(\?|$)/.test(thumb))
+        return _jsx("img", { className: "tile-media", src: thumb, alt: String(reel.caption ?? 'Reel') });
+    if (typeof reel.media_url !== 'string')
+        return _jsx("div", { className: "tile-media tile-empty" });
+    return _jsx("video", { className: "tile-media", src: `${reel.media_url}#t=0.1`, preload: "metadata", muted: true, playsInline: true, "aria-label": String(reel.caption ?? 'Reel') });
+}
+export function ReelsGrid({ reels, shape }) {
+    return (_jsx("div", { className: shape === 'reels' ? 'grid grid-reels' : 'grid grid-posts', children: reels.map((r) => (_jsxs("a", { className: "tile", href: reelRoute(String(r.shortcode)), "data-media-id": String(r.id), children: [_jsx(ReelStill, { reel: r }), shape === 'reels'
+                    ? _jsxs("span", { className: "tile-views", children: [_jsx(IconPlay, { size: 16 }), typeof r.view_count === 'number' ? _jsx("span", { children: compactCount(r.view_count) }) : null] })
+                    : _jsx("span", { className: "tile-badge", children: _jsx(IconReels, { size: 18 }) }), _jsxs("span", { className: "tile-hover", children: [typeof r.like_count === 'number' ? _jsxs("span", { children: [_jsx(IconHeart, { size: 19 }), " ", compactCount(r.like_count)] }) : null, typeof r.comments_count === 'number' ? _jsxs("span", { children: [_jsx(IconComment, { size: 19 }), " ", compactCount(r.comments_count)] }) : null] })] }, String(r.id)))) }));
+}
+function useAccount(session) {
+    const [state, setState] = useState({ profile: null, reels: null, error: null });
+    useEffect(() => {
+        let live = true;
+        void (async () => {
+            const me = await wire(session.token, `/${MIRROR_VERSION}/me?fields=${PROFILE_FIELDS}`);
+            if (!live)
+                return;
+            if (me.status !== 200) {
+                setState({ profile: null, reels: null, error: problemText(me) });
+                return;
+            }
+            const profile = profileFromRead(me.body);
+            setState({ profile, reels: null, error: null });
+            const rows = [];
+            let after;
+            for (let page = 0; page < 10; page += 1) {
+                const w = await wire(session.token, mediaQuery(profile.id, after));
+                if (!live)
+                    return;
+                if (w.status !== 200 || !Array.isArray(w.body.data)) {
+                    setState({ profile, reels: null, error: problemText(w) });
+                    return;
+                }
+                rows.push(...w.body.data);
+                after = typeof w.body.paging?.next === 'string' ? w.body.paging?.cursors?.after : undefined;
+                if (!after)
+                    break;
+            }
+            setState({ profile, reels: rows.filter(isReel), error: null });
+        })();
+        return () => { live = false; };
+    }, [session.token]);
+    return state;
+}
+function Unavailable({ why }) {
+    return (_jsxs("div", { className: "unavailable", children: [_jsx("h2", { children: "Sorry, this page isn't available." }), _jsxs("p", { children: [why ?? 'The link you followed may be broken, or the page may have been removed.', " ", _jsx("a", { href: "#/", children: "Go back to Instagram." })] })] }));
+}
+export function ProfileScreen({ account, route }) {
+    if (account.error)
+        return _jsx(Unavailable, { why: account.error });
+    if (!account.profile)
+        return _jsx("div", { className: "loading" });
+    const p = account.profile;
+    if (route.username && route.username !== p.username)
+        return _jsx(Unavailable, {});
+    const tab = route.tab;
+    const shown = tabReels(account.reels ?? [], tab);
+    return (_jsxs("div", { className: "profile", children: [_jsx(ProfileHeader, { profile: p }), _jsx(ProfileTabs, { username: p.username, tab: tab }), account.reels === null ? _jsx("div", { className: "loading" }) : shown.length === 0 ? (_jsxs("div", { className: "empty", children: [_jsx("div", { className: "empty-icon", children: _jsx(IconReels, { size: 40 }) }), _jsx("h2", { children: tab === 'reels' ? 'Share a moment with the world' : 'Share Photos' }), _jsxs("p", { children: ["When you share ", tab === 'reels' ? 'reels' : 'photos and videos', ", they will appear on your profile."] })] })) : _jsx(ReelsGrid, { reels: shown, shape: tab }), _jsxs("footer", { className: "footer", children: ["Meta \u00B7 About \u00B7 Blog \u00B7 Jobs \u00B7 Help \u00B7 API \u00B7 Privacy \u00B7 Terms \u00B7 Locations \u00B7 Instagram Lite \u00B7 Threads", _jsx("br", {}), "\u00A9 2026 Instagram from Meta"] })] }));
+}
+// ── the Reel viewer ──────────────────────────────────────────────────────────────────────────────
+export function ReelViewer({ reel, profile, nowMs, prev, next }) {
+    const video = useRef(null);
+    const [paused, setPaused] = useState(false);
+    const [muted, setMuted] = useState(true);
+    const [open, setOpen] = useState(false);
+    const toggle = () => {
+        const v = video.current;
+        if (!v)
+            return;
+        if (v.paused) {
+            void v.play().catch(() => undefined);
+            setPaused(false);
+        }
+        else {
+            v.pause();
+            setPaused(true);
+        }
+    };
+    const back = `#/${encodeURIComponent(profile.username)}/reels/`;
+    return (_jsxs("div", { className: "viewer", children: [_jsx("a", { className: "viewer-close", href: back, "aria-label": "Close", children: _jsx(IconClose, {}) }), _jsxs("div", { className: "viewer-stage", children: [_jsxs("div", { className: "player", "data-media-id": String(reel.id), children: [_jsx("video", { ref: video, className: "player-video", src: typeof reel.media_url === 'string' ? reel.media_url : undefined, autoPlay: true, loop: true, muted: muted, playsInline: true, onClick: toggle, "aria-label": String(reel.caption ?? 'Reel') }), paused ? _jsx("button", { className: "player-paused", onClick: toggle, "aria-label": "Play", children: _jsx(IconPlay, { size: 36 }) }) : null, _jsx("button", { className: "player-mute", onClick: () => setMuted(!muted), "aria-label": muted ? 'Audio is muted' : 'Audio is playing', children: muted ? _jsx(IconMuted, {}) : _jsx(IconSound, {}) }), _jsxs("div", { className: "player-overlay", children: [_jsxs("div", { className: "player-who", children: [_jsx(Avatar, { src: profile.avatarUrl, size: 32 }), _jsx("a", { className: "player-username", href: `#/${encodeURIComponent(profile.username)}/`, children: profile.username }), _jsx("span", { className: "player-dot", children: "\u2022" }), _jsx("span", { className: "player-age", children: timeAgo(reel.timestamp, nowMs) })] }), typeof reel.caption === 'string' && reel.caption !== '' ? (_jsx("div", { className: open ? 'player-caption open' : 'player-caption', onClick: () => setOpen(!open), children: _jsx(Caption, { text: reel.caption }) })) : null] })] }), _jsxs("div", { className: "viewer-actions", children: [_jsxs("span", { className: "action", children: [_jsx(IconHeart, { size: 26 }), typeof reel.like_count === 'number' ? _jsx("span", { children: compactCount(reel.like_count) }) : null] }), _jsxs("span", { className: "action", children: [_jsx(IconComment, { size: 26 }), typeof reel.comments_count === 'number' ? _jsx("span", { children: compactCount(reel.comments_count) }) : null] }), _jsx("span", { className: "action", children: _jsx(IconShare, { size: 26 }) }), _jsx("span", { className: "action", children: _jsx(IconSave, { size: 26 }) }), _jsx("span", { className: "action", children: _jsx(IconMore, { size: 26 }) }), _jsx("span", { className: "action-audio", children: _jsx(Avatar, { src: profile.avatarUrl, size: 26 }) })] })] }), _jsxs("div", { className: "viewer-nav", children: [prev ? _jsx("a", { className: "viewer-step", href: reelRoute(prev), "aria-label": "Previous reel", children: _jsx(IconUp, {}) }) : null, next ? _jsx("a", { className: "viewer-step", href: reelRoute(next), "aria-label": "Next reel", children: _jsx(IconDown, {}) }) : null] })] }));
+}
+function ReelScreen({ account, shortcode }) {
+    if (account.error)
+        return _jsx(Unavailable, { why: account.error });
+    if (!account.profile || account.reels === null)
+        return _jsx("div", { className: "loading" });
+    const reels = account.reels;
+    const at = shortcode === null ? 0 : reels.findIndex((r) => r.shortcode === shortcode);
+    const reel = reels[at];
+    if (!reel)
+        return _jsx(Unavailable, {});
+    return _jsx(ReelViewer, { reel: reel, profile: account.profile, nowMs: currentNow(), prev: reels[at - 1]?.shortcode, next: reels[at + 1]?.shortcode });
+}
+// ── the chrome ────────────────────────────────────────────────────────────────────────────────────
+function Sidebar({ session, avatarUrl, route, onSignOut }) {
+    const u = encodeURIComponent(session.username);
+    const item = (icon, label, href, active = false) => href
+        ? _jsxs("a", { className: active ? 'nav-item active' : 'nav-item', href: href, children: [icon, _jsx("span", { children: label })] })
+        : _jsxs("span", { className: "nav-item", children: [icon, _jsx("span", { children: label })] });
+    return (_jsxs("nav", { className: "sidebar", children: [_jsx("a", { className: "sidebar-logo", href: "#/", "aria-label": "Instagram", children: _jsx(Wordmark, { size: 26 }) }), item(_jsx(IconHome, {}), 'Home', '#/'), item(_jsx(IconSearch, {}), 'Search'), item(_jsx(IconExplore, {}), 'Explore'), item(_jsx(IconReels, {}), 'Reels', '#/reels/', route.page === 'reel'), item(_jsx(IconMessages, {}), 'Messages'), item(_jsx(IconHeart, {}), 'Notifications'), item(_jsx(IconCreate, {}), 'Create'), item(_jsx(Avatar, { src: avatarUrl, size: 24 }), 'Profile', `#/${u}/`, route.page === 'profile'), _jsxs("button", { className: "nav-item nav-more", onClick: onSignOut, title: `Log out ${session.username}`, children: [_jsx(IconMenu, {}), _jsx("span", { children: "Log out" })] })] }));
+}
+// ── log in: instagram.com's login, the password being the twin-issued token ─────────────────────
+export function LoginScreen({ onSignedIn }) {
+    const [username, setUsername] = useState('');
+    const [token, setToken] = useState('');
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    const clean = username.trim().replace(/^@/, '');
+    const logIn = async () => {
+        setBusy(true);
+        const me = await wire(token.trim(), `/${MIRROR_VERSION}/me?fields=id,username`);
+        setBusy(false);
+        if (me.status !== 200) {
+            setError(me.body.error?.code === 190 || me.body.error?.code === 104 ? 'Sorry, your access token was incorrect. Please double-check your token.' : problemText(me));
+            return;
+        }
+        // Is this token THIS account's? /me answers the token's own account; a token for another is refused here.
+        if (String(me.body.username ?? '') !== clean) {
+            setError(`That token doesn't log in as ${clean}.`);
+            return;
+        }
+        onSignedIn({ username: clean, token: token.trim() });
+    };
+    return (_jsxs("div", { className: "login-page", children: [_jsxs("div", { className: "login-card", children: [_jsx("div", { className: "login-logo", children: _jsx(Wordmark, { size: 42 }) }), _jsxs("form", { onSubmit: (e) => { e.preventDefault(); void logIn(); }, children: [_jsxs("label", { className: "field", children: [_jsx("input", { name: "username", placeholder: " ", value: username, onChange: (e) => setUsername(e.target.value), autoComplete: "username", autoFocus: true }), _jsx("span", { children: "Phone number, username, or email" })] }), _jsxs("label", { className: "field", children: [_jsx("input", { name: "password", type: "password", placeholder: " ", value: token, onChange: (e) => setToken(e.target.value), autoComplete: "current-password" }), _jsx("span", { children: "Access token" })] }), _jsx("button", { className: "btn-login", type: "submit", disabled: clean === '' || token.trim().length < 8 || busy, children: "Log in" })] }), _jsx("div", { className: "login-or", children: _jsx("span", { children: "OR" }) }), error ? _jsx("p", { className: "login-error", role: "alert", children: error }) : null, _jsxs("p", { className: "login-note", children: ["This twin logs you in with the access token it issued for your account (", _jsx("code", { children: "/_twin/tokens" }), ") in place of a password."] })] }), _jsxs("div", { className: "login-card login-signup", children: ["Don't have an account? ", _jsx("span", { className: "ig-blue", children: "Sign up" })] })] }));
+}
+function App() {
+    const [session, setSession] = useState(readSession);
+    const [route, setRoute] = useState(() => parseRoute(typeof location === 'undefined' ? '' : location.hash));
+    useEffect(() => {
+        const onHash = () => { setRoute(parseRoute(location.hash)); window.scrollTo(0, 0); };
+        window.addEventListener('hashchange', onHash);
+        return () => window.removeEventListener('hashchange', onHash);
+    }, []);
+    const signIn = (s) => {
+        sessionStorage.setItem(SESSION_USER, s.username);
+        sessionStorage.setItem(SESSION_TOKEN, s.token);
+        setSession(s);
+    };
+    const signOut = () => {
+        sessionStorage.removeItem(SESSION_USER);
+        sessionStorage.removeItem(SESSION_TOKEN);
+        setSession(null);
+    };
+    if (!session)
+        return _jsx(LoginScreen, { onSignedIn: signIn });
+    return _jsx(SignedIn, { session: session, route: route, onSignOut: signOut });
+}
+function SignedIn({ session, route, onSignOut }) {
+    const account = useAccount(session);
+    return (_jsxs("div", { className: route.page === 'reel' ? 'app app-dark' : 'app', children: [_jsx(Sidebar, { session: session, avatarUrl: account.profile?.avatarUrl, route: route, onSignOut: onSignOut }), _jsx("main", { className: "main", children: route.page === 'reel' ? _jsx(ReelScreen, { account: account, shortcode: route.shortcode }) : _jsx(ProfileScreen, { account: account, route: route }) })] }));
+}
+const el = typeof document !== 'undefined' ? document.getElementById('root') : null;
+if (el)
+    createRoot(el).render(_jsx(App, {}));

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { keepProcessAlive } from '@volter/world-core/lifecycle';
+import { hasFlag, optionValue } from '@volter/world-core/args';
+import { createInstagramTwinServer } from "./instagram-server.js";
+import { createInstagramMirrorServer } from "./instagram-mirror-ui.js";
+const [cmd, ...rest] = process.argv.slice(2);
+const port = Number(optionValue(rest, '--port', '0')) || undefined;
+const root = optionValue(rest, '--root') || undefined;
+const readOnly = hasFlag(rest, '--read-only');
+if (cmd === 'serve') {
+    const server = await createInstagramTwinServer({ readOnly, ...(root ? { root } : {}), ...(port ? { port } : {}) });
+    process.stdout.write(`instagram twin${readOnly ? ' [read-only]' : ''} at http://127.0.0.1:${server.port}\n`);
+    await keepProcessAlive();
+}
+else if (cmd === 'mirror') {
+    const s = await createInstagramMirrorServer({ readOnly, ...(root ? { root } : {}), ...(port ? { port } : {}) });
+    process.stdout.write(`instagram mirror UI (instagram.com: log in, profile, Reels grid, Reel viewer) at ${s.url}\n`);
+    await keepProcessAlive();
+}
+else if (cmd === 'conformance') {
+    // Lazy — the conformance module is DEV-ONLY and must not be reachable from the runtime entrypoints.
+    const { checkInstagramConformance } = await import("./instagram-conformance.js");
+    const report = await checkInstagramConformance({ ...(root ? { root } : {}) });
+    process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+    if (!report.ok)
+        process.exitCode = 1;
+}
+else {
+    process.stdout.write('Usage: world-instagram serve|mirror|conformance [--port N] [--root DIR] [--read-only]\n');
+}

package/dist/src/index.d.ts

@@ -0,0 +1,10 @@
+export { GRAPH_VERSIONS, handleInstagramTwinRequest, igTimestamp, LATEST_VERSION, projectMedia, PUBLISH_QUOTA_TOTAL, reelVideoUrl, shortcodeFor, tokenDigest, usableVersions } from './instagram-twin.js';
+export type { InstagramRequest } from './instagram-twin.js';
+export type { InstagramResponse } from './instagram-errors.js';
+export { createInstagramTwinFetch, createInstagramTwinServer, RANGE_CAP, type InstagramTwinFetchOptions } from './instagram-server.js';
+export { budgetedInstagramExecute, containerParamsForVendor, INSTAGRAM_VERSION, InstagramCallError, MAX_STATUS_WAIT_MS, performInstagramAction, performInstagramActionWithin, STATUS_POLL_MS, syncInstagramFromReal, syncInstagramFromRemote, UPLOAD_CHUNK_BYTES, uploadReel, uploadTarget, waitForContainer, } from './instagram-connector.js';
+export { buildInstagramMirrorClient, captionSegments, compactCount, createInstagramMirrorServer, instagramMirrorHtml, instagramMirrorStyles, MIRROR_VERSION, profileFromRead, reelRoute, tabReels, timeAgo, } from './instagram-mirror-ui.js';
+export type { IgRow, Segment } from './instagram-mirror-ui.js';
+export { INSTAGRAM_BUDGET_BURST_CEILING, INSTAGRAM_BUDGET_CEILING, INSTAGRAM_BUDGET_MAX_RETRY_AFTER_S, INSTAGRAM_BUDGET_WINDOW_MS, INSTAGRAM_CALL_WEIGHTS, INSTAGRAM_RATE_BUDGET, InstagramBudget, InstagramBudgetError, instagramBudgetPath, instagramCallWeight, } from './instagram-budget.js';
+import { type TwinPack } from '@volter/world-core';
+export declare const pack: TwinPack;

package/dist/src/index.js

@@ -0,0 +1,71 @@
+export { GRAPH_VERSIONS, handleInstagramTwinRequest, igTimestamp, LATEST_VERSION, projectMedia, PUBLISH_QUOTA_TOTAL, reelVideoUrl, shortcodeFor, tokenDigest, usableVersions } from "./instagram-twin.js";
+export { createInstagramTwinFetch, createInstagramTwinServer, RANGE_CAP } from "./instagram-server.js";
+export { budgetedInstagramExecute, containerParamsForVendor, INSTAGRAM_VERSION, InstagramCallError, MAX_STATUS_WAIT_MS, performInstagramAction, performInstagramActionWithin, STATUS_POLL_MS, syncInstagramFromReal, syncInstagramFromRemote, UPLOAD_CHUNK_BYTES, uploadReel, uploadTarget, waitForContainer, } from "./instagram-connector.js";
+export { buildInstagramMirrorClient, captionSegments, compactCount, createInstagramMirrorServer, instagramMirrorHtml, instagramMirrorStyles, MIRROR_VERSION, profileFromRead, reelRoute, tabReels, timeAgo, } from "./instagram-mirror-ui.js";
+// The client-side rate budget the perform and refresh adapters charge (instagram-budget.ts says how the
+// numbers were chosen). The mechanism is the kernel's; these are this vendor's numbers.
+export { INSTAGRAM_BUDGET_BURST_CEILING, INSTAGRAM_BUDGET_CEILING, INSTAGRAM_BUDGET_MAX_RETRY_AFTER_S, INSTAGRAM_BUDGET_WINDOW_MS, INSTAGRAM_CALL_WEIGHTS, INSTAGRAM_RATE_BUDGET, InstagramBudget, InstagramBudgetError, instagramBudgetPath, instagramCallWeight, } from "./instagram-budget.js";
+import { registerPack } from '@volter/world-core';
+import { performInstagramAction, syncInstagramFromRemote } from "./instagram-connector.js";
+import { INSTAGRAM_RATE_BUDGET as RATE_BUDGET } from "./instagram-budget.js";
+/**
+ * The Graph paths THIS pack serves, as a RegExp SOURCE for the descriptor's `hosts` path rule: an
+ * optional `/vNN.N` version, then `/me` or a numeric node (an IG User, an IG Media or an IG Container)
+ * with at most one of the edges modelled here — and the twin-only control prefix. ANCHORED, so
+ * `/{id}/insights` or `/{page-id}/feed` stays unclaimed and refuses loudly at the real vendor. A bare
+ * numeric node is claimed whatever it names (the path cannot tell an IG id from a Page's); a node the
+ * twin does not hold answers Meta's own "Unsupported get request".
+ */
+const GRAPH_PATHS = '^(?:/v\\d+\\.\\d+)?/(?:me|\\d{1,25})(?:/(?:media|media_publish|content_publishing_limit))?/?$|^/_twin/';
+export const pack = {
+    vendor: 'instagram',
+    // The SAME object instagram-budget.ts declares at module load — one source of truth.
+    rateBudget: RATE_BUDGET,
+    transport: 'rest',
+    // PROTOCOL 2 (docs/contributing/architecture.md#protocol-2-the-pack-is-a-plugin): the pack is a
+    // plugin — its wire, its tree, and its half of the real state system. Born on it.
+    protocol: '2',
+    archetype: 'crud',
+    bin: 'world-instagram',
+    resources: ['ig_user', 'media'],
+    specSource: 'Instagram Platform docs (developers.facebook.com/docs/instagram-platform, Graph API v26.0), read 2026-09-27: Content Publishing (incl. Resumable Upload Session and Reels), the IG User, IG User Media, IG Container, IG User Media Publish, IG Media and IG User Content Publishing Limit references, Error Codes; and the Graph API guides for Versioning, Handle Errors and Resumable Upload. Meta publishes no machine-readable spec for this surface.',
+    description: "Instagram twin — a professional account's Reels through the Graph API's content publishing flow (a resumable container, the rupload.facebook.com upload, the status_code lifecycle, media_publish), the account and media nodes, the publishing limit, and an instagram.com profile mirror with a Reels grid and a Reel viewer; everything else refuses by name.",
+    // An account's Reels barely move and Meta's limits are daily: hourly, and on demand.
+    refresh: { every: '1h', webhook: false, onDemand: { atMost: '60s' } },
+    stateSystem: { perform: performInstagramAction, refresh: syncInstagramFromRemote },
+    // The round trip: the professional account and the token the Facebook Login leg would have minted
+    // (the vendor has no create-from-nothing for either), then a Reels container on that account — staging
+    // the twin holds outside the log, as Meta holds it outside the account's media.
+    roundTrip: [
+        { method: 'POST', path: '/_twin/users', body: { id: '17841400000000001', username: 'round.trip', name: 'Round Trip', followers_count: 7 } },
+        { method: 'POST', path: '/_twin/tokens', body: { token: 'round-trip-token', user: '17841400000000001', permissions: ['instagram_basic', 'instagram_content_publish', 'pages_read_engagement'] } },
+        {
+            method: 'POST', path: '/v26.0/17841400000000001/media',
+            headers: { authorization: 'Bearer round-trip-token' },
+            body: { media_type: 'REELS', upload_type: 'resumable', caption: 'round trip' },
+        },
+    ],
+    parityOrigin: 'http://twin',
+    // the write handler and the refresh adapter store the same account shape (scripts/shape-parity.test.ts)
+    shapeParity: 'held',
+    // ADOPTION. Meta publishes no official JavaScript client for the Instagram Platform (the
+    // facebook-nodejs-business-sdk is the Marketing API's, and claiming it would attribute ads traffic
+    // to this twin). INSTAGRAM is the stem of INSTAGRAM_ACCESS_TOKEN / INSTAGRAM_USER_ID et al.
+    adoption: {
+        envStems: ['INSTAGRAM'],
+    },
+    // INTERCEPTION. graph.facebook.com (Facebook Login — the host the resumable upload is documented on)
+    // and graph.instagram.com (Instagram Login), both path-scoped to the nodes and edges above;
+    // rupload.facebook.com only for `/ig-api-upload/` — the upload host, which takes the SAME token, so
+    // the kernel executor sends the sealed credential there only because it is declared here as an exact
+    // host with this path; scontent.cdninstagram.com only for the CDN paths the twin mints for a Reel,
+    // its stand-in thumbnail and a profile picture.
+    hosts: [
+        { host: 'graph.facebook.com', pathPattern: GRAPH_PATHS },
+        { host: 'graph.instagram.com', pathPattern: GRAPH_PATHS },
+        { host: 'rupload.facebook.com', pathPattern: '^/ig-api-upload/' },
+        { host: 'scontent.cdninstagram.com', pathPattern: '^/(?:o1/v/t16/f2/m86/|v/t51\\.(?:71878-15|2885-19)/)' },
+    ],
+    endpointEnvNone: 'Meta ships no Instagram Platform client that reads a base-URL environment variable: apps call https://graph.facebook.com/<version>/… and the rupload host by constant, so a World reaches them through the hosts above; inventing an INSTAGRAM_BASE_URL the app never reads would report coverage the app does not have.',
+};
+registerPack(pack);

package/dist/src/instagram-budget.d.ts

@@ -0,0 +1,44 @@
+import { RateBudget, type RateBudgetDeclaration, type RateBudgetOptions, type RateBudgetReservation, type RateBudgetSnapshot } from '@volter/world-core';
+/** Rolling window, in ms — the longest the kernel's ledger keeps (Meta's windows are 24 hours). */
+export declare const INSTAGRAM_BUDGET_WINDOW_MS: number;
+/** Weighted units per window: the daily publish and container limits spread over the day, rounded down. */
+export declare const INSTAGRAM_BUDGET_CEILING = 250;
+/** Weighted units in any 60 s: 30 calls at the default weight (the fallback's burst), one whole Reel perform. */
+export declare const INSTAGRAM_BUDGET_BURST_CEILING = 180;
+/** Seconds. A Retry-After above this means the account or app is throttled for the day — fail loudly. */
+export declare const INSTAGRAM_BUDGET_MAX_RETRY_AFTER_S = 3600;
+export declare const INSTAGRAM_CALL_WEIGHTS: {
+    /** media_publish — the account speaking in public, 50 of them a day. */
+    readonly publish: 100;
+    /** A container, 400 of them a day. */
+    readonly container: 16;
+    /** A delete. */
+    readonly delete: 8;
+    /** One rupload POST (an 8 MiB chunk at most). */
+    readonly upload: 1;
+    /** A read: a container's status, a node, the media list, the publishing limit. */
+    readonly read: 1;
+    /** Anything unnamed. */
+    readonly other: 6;
+};
+/** THE PACK'S DECLARATION — pure data, the only Instagram-specific thing in the whole budget. */
+export declare const INSTAGRAM_RATE_BUDGET: RateBudgetDeclaration;
+/**
+ * Price one call. `path` is the Graph path (`/v26.0/178…/media`) or, for the upload host, the absolute
+ * rupload URL — keyed `"<METHOD> <path>"` with the query split off (and the upload host kept in front
+ * of its path, so a twin's anchored `/ig-api-upload/…` and Meta's host price the same).
+ */
+export declare function instagramCallWeight(method: string, path: string): number;
+/** Where this vendor's ledger lives: token-keyed and cwd-independent by default. */
+export declare function instagramBudgetPath(opts?: {
+    root?: string;
+    token?: string;
+} | string): string;
+export type InstagramBudgetOptions = Omit<RateBudgetOptions, 'vendor'>;
+/** This vendor's budget — the kernel guard bound to this declaration. */
+export declare class InstagramBudget extends RateBudget {
+    constructor(opts?: InstagramBudgetOptions);
+}
+export { RateBudgetError as InstagramBudgetError } from '@volter/world-core';
+export type InstagramBudgetReservation = RateBudgetReservation;
+export type InstagramBudgetSnapshot = RateBudgetSnapshot;

package/dist/src/instagram-budget.js

@@ -0,0 +1,112 @@
+// Instagram's CLIENT-SIDE RATE BUDGET — this pack's DECLARATION (the numbers) plus the thin typed
+// bindings the perform and refresh adapters use. The MECHANISM — the durable token-keyed ledger, the
+// rolling window, reserve-under-lock, the Retry-After / 429 cooldown, fail-CLOSED on a corrupt ledger
+// — lives ONCE in the kernel (`@volter/world-core` → rateBudget.ts).
+//
+// ── WHAT META PUBLISHES (developers.facebook.com/docs/instagram-platform, fetched 2026-09-27) ──
+//   • Content Publishing guide, "Rate Limit": "Instagram accounts are limited to 100 API-published
+//     posts within a 24-hour moving period … enforced on the POST /<IG_ID>/media_publish endpoint".
+//   • IG User Media Publish reference: "An Instagram professional account can only publish 50 posts
+//     within a 24 hour moving period"; the Content Publishing Limit reference reports quota_total
+//     "(currently 50)" over quota_duration 86400. THE STRICTER, 50, IS THE FIGURE THIS BUDGET KEEPS.
+//   • IG User Media reference: "An Instagram account can only create 400 containers within a rolling
+//     24 hour period".
+//   • The general Graph API call allowance is a Business Use Case formula over the account's
+//     impressions — no scalar a client can transcribe.
+//
+// ── HOW THE DECLARATION HOLDS THOSE DAILY FIGURES ──────────────────────────────────────────
+// The kernel's longest window is ONE HOUR, so a daily limit is spread over the day and rounded DOWN
+// (the YouTube pack's method): 250 weighted units per rolling hour, with
+//     a publish (POST /{id}/media_publish)   100 units → at most 2 an hour = 48 a day   ≤ 50
+//     a container (POST /{id}/media)          16 units → at most 15 an hour = 360 a day ≤ 400
+//     an upload POST to rupload (8 MiB chunk)   1 unit  (a 300 MB Reel is 36 chunks)
+//     a delete                                  8 units
+//     a read (status, node, list, limit)        1 unit
+//     anything else                             6 units
+// A client that spends this flat out for a whole day still lands under both documented limits.
+//
+// ── THE BURST SUB-CEILING ────────────────────────────────────────────────────────────────────
+// 180 units in any 60 s, SET BY THE PERFORM: one whole perform of the largest Reel inside a minute
+// (container 16 + 36 upload chunks + three status reads + publish 100 = 155) with room to spare. A burst
+// below that would refuse the publish of a Reel Meta finished quickly; the guard would be broken, not
+// tighter. The default weight (6, for a call no rule prices — the connector makes none) is then chosen so
+// the burst is 30 calls at it, the kernel fallback's own, so no burst anchor is claimed.
+import { declareRateBudget, rateBudgetPath, rateBudgetWeight, RateBudget, } from '@volter/world-core';
+const VENDOR = 'instagram';
+/** Rolling window, in ms — the longest the kernel's ledger keeps (Meta's windows are 24 hours). */
+export const INSTAGRAM_BUDGET_WINDOW_MS = 60 * 60_000;
+/** Weighted units per window: the daily publish and container limits spread over the day, rounded down. */
+export const INSTAGRAM_BUDGET_CEILING = 250;
+/** Weighted units in any 60 s: 30 calls at the default weight (the fallback's burst), one whole Reel perform. */
+export const INSTAGRAM_BUDGET_BURST_CEILING = 180;
+/** Seconds. A Retry-After above this means the account or app is throttled for the day — fail loudly. */
+export const INSTAGRAM_BUDGET_MAX_RETRY_AFTER_S = 3600;
+export const INSTAGRAM_CALL_WEIGHTS = {
+    /** media_publish — the account speaking in public, 50 of them a day. */
+    publish: 100,
+    /** A container, 400 of them a day. */
+    container: 16,
+    /** A delete. */
+    delete: 8,
+    /** One rupload POST (an 8 MiB chunk at most). */
+    upload: 1,
+    /** A read: a container's status, a node, the media list, the publishing limit. */
+    read: 1,
+    /** Anything unnamed. */
+    other: 6,
+};
+/** THE PACK'S DECLARATION — pure data, the only Instagram-specific thing in the whole budget. */
+export const INSTAGRAM_RATE_BUDGET = {
+    windowMs: INSTAGRAM_BUDGET_WINDOW_MS,
+    ceiling: INSTAGRAM_BUDGET_CEILING,
+    burstCeiling: INSTAGRAM_BUDGET_BURST_CEILING,
+    defaultWeight: INSTAGRAM_CALL_WEIGHTS.other,
+    maxRetryAfterSeconds: INSTAGRAM_BUDGET_MAX_RETRY_AFTER_S,
+    rules: [
+        { match: '^POST (/v\\d+\\.\\d+)?/\\d+/media_publish$', weight: INSTAGRAM_CALL_WEIGHTS.publish },
+        { match: '^POST (/v\\d+\\.\\d+)?/\\d+/media$', weight: INSTAGRAM_CALL_WEIGHTS.container },
+        { match: '^DELETE (/v\\d+\\.\\d+)?/\\d+$', weight: INSTAGRAM_CALL_WEIGHTS.delete },
+        { match: '^POST (rupload\\.facebook\\.com)?/ig-api-upload/', weight: INSTAGRAM_CALL_WEIGHTS.upload },
+        { match: '^GET ', weight: INSTAGRAM_CALL_WEIGHTS.read },
+    ],
+    reason: 'Meta limits an Instagram professional account to 50 API-published posts in a 24-hour moving period (IG User Media '
+        + 'Publish and Content Publishing Limit references, "currently 50"; the Content Publishing guide says 100 — the '
+        + 'stricter 50 is kept) and to 400 containers in a rolling 24 hours (IG User Media reference), '
+        + 'developers.facebook.com/docs/instagram-platform, fetched 2026-09-27. The general call allowance is a Business Use '
+        + 'Case formula with no scalar. The daily figures are spread over the kernel\'s one-hour window and rounded down: '
+        + '250 units an hour, a publish 100 (2 an hour, 48 a day), a container 16 (15 an hour, 360 a day), a rupload POST '
+        + '(an 8 MiB chunk) 1, a delete 8, a read 1, anything else 6; a 180-unit burst per minute (30 calls at the default '
+        + "weight, the fallback's own) admits one whole perform of the largest Reel (155 units).",
+};
+declareRateBudget(VENDOR, INSTAGRAM_RATE_BUDGET);
+/**
+ * Price one call. `path` is the Graph path (`/v26.0/178…/media`) or, for the upload host, the absolute
+ * rupload URL — keyed `"<METHOD> <path>"` with the query split off (and the upload host kept in front
+ * of its path, so a twin's anchored `/ig-api-upload/…` and Meta's host price the same).
+ */
+export function instagramCallWeight(method, path) {
+    let raw = path;
+    if (/^https?:\/\//i.test(raw)) {
+        const u = new URL(raw);
+        raw = `${u.hostname === 'rupload.facebook.com' ? u.hostname : ''}${u.pathname}${u.search}`;
+    }
+    const at = raw.indexOf('?');
+    const query = {};
+    if (at !== -1)
+        for (const [k, v] of new URLSearchParams(raw.slice(at + 1)))
+            query[k] = v;
+    const bare = (at === -1 ? raw : raw.slice(0, at)).replace(/(.)\/+$/, '$1');
+    return rateBudgetWeight(VENDOR, `${String(method).toUpperCase()} ${bare}`, query);
+}
+/** Where this vendor's ledger lives: token-keyed and cwd-independent by default. */
+export function instagramBudgetPath(opts = {}) {
+    const o = typeof opts === 'string' ? { root: opts } : opts;
+    return rateBudgetPath({ ...o, vendor: VENDOR });
+}
+/** This vendor's budget — the kernel guard bound to this declaration. */
+export class InstagramBudget extends RateBudget {
+    constructor(opts = {}) {
+        super({ ...opts, vendor: VENDOR });
+    }
+}
+export { RateBudgetError as InstagramBudgetError } from '@volter/world-core';

package/dist/src/instagram-capabilities.d.ts

@@ -0,0 +1,4 @@
+import { type CapabilityReport, type CapabilitySpec } from '@volter/world-tooling';
+export declare const INSTAGRAM_AREAS: readonly ["versioning", "auth", "users", "containers", "upload", "publish", "media", "limits", "publishing", "comments", "insights", "discovery", "webhooks", "login", "errors", "twin_control", "connector", "rate_limit", "mirror"];
+export declare const INSTAGRAM_CAPABILITIES: CapabilitySpec[];
+export declare function instagramCapabilities(): Promise<CapabilityReport>;