@mindmakr/reins 0.0.0-stage → 0.1.0

package/dist/bridge/session.js

@@ -0,0 +1,116 @@
+import { closeSync, existsSync, fstatSync, mkdirSync, openSync, readdirSync, readFileSync, readSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { VERSION } from '@mindmakr/reins';
+import { buildSession, mergeServers, renderMarkdown, sessionBase } from '@mindmakr/reins/report';
+import { reinsDir } from './token.js';
+/** Asks every paired `@mindmakr/reins/node` server for its report. Servers that do not answer are skipped. */
+export async function serverReports(hub) {
+    const all = await Promise.all(hub.nodeClients().map((c) => hub.request('server', {}, c).catch(() => null)));
+    return all.filter(Boolean);
+}
+/** How much of the end of the audit log a report reads. The log is never trimmed, so it can be far larger. */
+export const AUDIT_TAIL_BYTES = 1024 * 1024;
+/** The last `maxBytes` of a file as text. A first line cut in half fails to parse and is skipped by the caller. */
+function readTail(file, maxBytes) {
+    const fd = openSync(file, 'r');
+    try {
+        const size = fstatSync(fd).size;
+        const length = Math.min(size, maxBytes);
+        const buf = Buffer.alloc(length);
+        readSync(fd, buf, 0, length, size - length);
+        return buf.toString('utf8');
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Audit log lines written since `since` (ms), oldest first. Missing log: none. Reads only the end of the file. */
+export function readAudit(projectDir, since, max = 500, tailBytes = AUDIT_TAIL_BYTES) {
+    const file = join(projectDir, '.reins', 'audit.log');
+    if (!existsSync(file))
+        return [];
+    const out = [];
+    for (const line of readTail(file, tailBytes).split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const e = JSON.parse(line);
+            if (Date.parse(e.at) >= since - 1000)
+                out.push({ at: e.at, source: e.source, event: e.event, name: e.name, via: e.via, ok: e.ok, error: e.error, ms: e.ms });
+        }
+        catch {
+            // skip a torn line
+        }
+    }
+    return out.slice(-max);
+}
+const safe = (p) => p.catch(() => null);
+/** Gathers a session from the paired app and servers: everything `reins_report` puts in the files. */
+export async function gatherSession(ctx, title) {
+    const hub = ctx.hub;
+    const c = hub.current();
+    const server = mergeServers(await serverReports(hub));
+    if (!c && !server)
+        throw new Error('No app is paired. Open the app in dev mode (it must call reins.connect()) and make sure the dev server serves .reins/token.');
+    let list = null;
+    let state = null;
+    let network = null;
+    let errors = null;
+    let perf = null;
+    const dom = {};
+    if (c) {
+        [list, state, network, errors, perf] = await Promise.all([
+            safe(hub.request('list')),
+            safe(hub.request('state')),
+            safe(hub.request('network', { limit: 100 })),
+            safe(hub.request('errors', { limit: 100 })),
+            safe(hub.request('perf')),
+        ]);
+        for (const id of Array.isArray(list?.panels) ? list.panels : [])
+            dom[id] = await safe(hub.request('dom', { panel: id, depth: 8, maxNodes: 400 }));
+    }
+    return buildSession({
+        title: title || (c?.title ? `${c.title}` : 'session'),
+        source: 'bridge',
+        reinsVersion: VERSION,
+        app: c ? { url: c.url, title: c.title, platform: c.meta?.platform || 'web', meta: c.meta } : { platform: 'node' },
+        actions: [...(list?.actions || []), ...(server?.actions || [])],
+        state,
+        network: network || [],
+        errors: errors || [],
+        perf,
+        dom,
+        server,
+        snaps: ctx.snaps || [],
+        audit: readAudit(ctx.dir, hub.startedAt),
+    });
+}
+/** Snap links relative to where the Markdown file lives. */
+export const linkFrom = (projectDir, mdFile) => (p) => relative(dirname(mdFile), resolve(projectDir, p)).split('\\').join('/');
+/** Writes `.reins/sessions/<time>-<slug>.json` and `.md`. Returns the paths and the Markdown. */
+export function writeSession(projectDir, session) {
+    const folder = join(reinsDir(projectDir), 'sessions');
+    mkdirSync(folder, { recursive: true });
+    const base = join(folder, sessionBase(session.createdAt, session.title));
+    const md = base + '.md';
+    const json = base + '.json';
+    const markdown = renderMarkdown(session, { link: linkFrom(projectDir, md) });
+    writeFileSync(json, JSON.stringify(session, null, 2) + '\n');
+    writeFileSync(md, markdown);
+    return { md, json, markdown };
+}
+/** Reads a session JSON and checks its schema version. */
+export function readSession(file) {
+    const s = JSON.parse(readFileSync(file, 'utf8'));
+    if (!s || s.schemaVersion !== 1)
+        throw new Error(`${file} is not a reins session (schemaVersion 1)`);
+    return s;
+}
+/** The newest session JSON under `<projectDir>/.reins/sessions`, if any. */
+export function latestSession(projectDir) {
+    const folder = join(projectDir, '.reins', 'sessions');
+    if (!existsSync(folder))
+        return undefined;
+    const files = readdirSync(folder).filter((f) => f.endsWith('.json')).sort();
+    return files.length ? join(folder, files[files.length - 1]) : undefined;
+}

package/dist/bridge/snap.d.ts

@@ -0,0 +1,28 @@
+import type { Box } from '@mindmakr/reins';
+import type { Client } from './hub.js';
+export interface SnapOptions {
+    dir: string;
+    /** Chrome DevTools endpoint, for example http://127.0.0.1:9222. Needed for browser snaps. */
+    cdp?: string;
+    copy?: boolean;
+}
+export interface SnapResult {
+    box: Box;
+    file?: string;
+    copied?: boolean;
+    /** For full-screen device captures: the panel in device pixels, to crop with. */
+    pixelBox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    note?: string;
+}
+/**
+ * Takes a pixel-exact picture of a panel.
+ * Browser: Playwright over CDP, clipped to the box (viewport CSS pixels).
+ * Android (Expo): a full-screen `adb screencap` plus the box in device pixels.
+ * Otherwise it returns the box so the agent's own driver can clip.
+ */
+export declare function snap(box: Box, client: Client | undefined, opts: SnapOptions): Promise<SnapResult>;

package/dist/bridge/snap.js

@@ -0,0 +1,65 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { copyImage } from './clipboard.js';
+async function loadPlaywright() {
+    for (const name of ['playwright', 'playwright-core']) {
+        try {
+            return await import(name);
+        }
+        catch {
+            // try the next one
+        }
+    }
+    return null;
+}
+const stripQuery = (url = '') => url.split(/[?#]/)[0];
+function snapFile(dir, id) {
+    const folder = join(dir, '.reins', 'snaps');
+    mkdirSync(folder, { recursive: true });
+    return join(folder, `${id.replace(/[^A-Za-z0-9._-]/g, '_')}-${Date.now()}.png`);
+}
+const pixels = (b) => ({
+    x: Math.round(b.x * b.devicePixelRatio),
+    y: Math.round(b.y * b.devicePixelRatio),
+    width: Math.round(b.width * b.devicePixelRatio),
+    height: Math.round(b.height * b.devicePixelRatio),
+});
+/**
+ * Takes a pixel-exact picture of a panel.
+ * Browser: Playwright over CDP, clipped to the box (viewport CSS pixels).
+ * Android (Expo): a full-screen `adb screencap` plus the box in device pixels.
+ * Otherwise it returns the box so the agent's own driver can clip.
+ */
+export async function snap(box, client, opts) {
+    if (client && client.meta && client.meta.platform === 'android') {
+        try {
+            const png = execFileSync('adb', ['exec-out', 'screencap', '-p'], { maxBuffer: 64 * 1024 * 1024 });
+            const file = snapFile(opts.dir, box.id);
+            writeFileSync(file, png);
+            return { box, file, pixelBox: pixels(box), note: 'Full screen; crop to pixelBox.', copied: opts.copy ? copyImage(file) : undefined };
+        }
+        catch {
+            return { box, pixelBox: pixels(box), note: 'adb screencap failed; is adb on PATH and a device attached?' };
+        }
+    }
+    const pw = await loadPlaywright();
+    if (!pw || !opts.cdp) {
+        return { box, note: pw ? 'Start the bridge with --cdp <url> to take snaps.' : 'Playwright is not installed; clip your own screenshot to this box (viewport CSS pixels).' };
+    }
+    const browser = await pw.chromium.connectOverCDP(opts.cdp);
+    try {
+        const pages = browser.contexts().flatMap((c) => c.pages());
+        const want = stripQuery(client && client.url);
+        const page = pages.find((p) => stripQuery(p.url()) === want) || pages[0];
+        if (!page)
+            return { box, note: 'No page found over CDP.' };
+        const file = snapFile(opts.dir, box.id);
+        await page.screenshot({ path: file, clip: { x: box.x, y: box.y, width: box.width, height: box.height } });
+        return { box, file, copied: opts.copy ? copyImage(file) : undefined };
+    }
+    finally {
+        // For CDP connections this disconnects; it does not close the person's browser.
+        await browser.close();
+    }
+}

package/dist/bridge/token.d.ts

@@ -0,0 +1,10 @@
+/** A fresh random pairing token (192 bits). */
+export declare function newToken(): string;
+/** Compares tokens in constant time. */
+export declare function tokensMatch(given: unknown, expected: string): boolean;
+/** The project's `.reins` folder. It holds its own `.gitignore` so nothing in it is ever committed. */
+export declare function reinsDir(projectDir: string): string;
+export declare function tokenPath(projectDir: string): string;
+/** Writes the token where the dev server's token route reads it. Readable by the owner only. */
+export declare function writeToken(projectDir: string, token: string): string;
+export declare function removeToken(projectDir: string): void;

package/dist/bridge/token.js

@@ -0,0 +1,35 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+/** A fresh random pairing token (192 bits). */
+export function newToken() {
+    return randomBytes(24).toString('base64url');
+}
+/** Compares tokens in constant time. */
+export function tokensMatch(given, expected) {
+    if (typeof given !== 'string' || !expected)
+        return false;
+    const a = Buffer.from(given);
+    const b = Buffer.from(expected);
+    return a.length === b.length && timingSafeEqual(a, b);
+}
+/** The project's `.reins` folder. It holds its own `.gitignore` so nothing in it is ever committed. */
+export function reinsDir(projectDir) {
+    const dir = join(projectDir, '.reins');
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, '.gitignore'), '*\n');
+    return dir;
+}
+export function tokenPath(projectDir) {
+    return join(projectDir, '.reins', 'token');
+}
+/** Writes the token where the dev server's token route reads it. Readable by the owner only. */
+export function writeToken(projectDir, token) {
+    reinsDir(projectDir);
+    const file = tokenPath(projectDir);
+    writeFileSync(file, token + '\n', { mode: 0o600 });
+    return file;
+}
+export function removeToken(projectDir) {
+    rmSync(tokenPath(projectDir), { force: true });
+}

package/dist/bridge/tools.d.ts

@@ -0,0 +1,18 @@
+import type { Audit } from './audit.js';
+import type { Hub } from './hub.js';
+export interface Tool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export declare const TOOLS: Tool[];
+export interface ToolContext {
+    hub: Hub;
+    dir: string;
+    cdp?: string;
+    audit?: Audit;
+    /** Project-relative paths of the snaps taken this session (filled in by reins_snap). */
+    snaps?: string[];
+}
+/** Runs one MCP tool against the paired app (and server). Every call is audited. */
+export declare function callTool(ctx: ToolContext, name: string, args?: Record<string, any>): Promise<unknown>;

package/dist/bridge/tools.js

@@ -0,0 +1,174 @@
+import { relative } from 'node:path';
+import { findings, mergeServers, renderMarkdown, withTimeline } from '@mindmakr/reins/report';
+import { gatherSession, serverReports, writeSession } from './session.js';
+import { snap } from './snap.js';
+const obj = (properties = {}, required = []) => ({ type: 'object', properties, required });
+export const TOOLS = [
+    {
+        name: 'reins_list_actions',
+        description: 'List the actions (with input schemas), state sources and panels the paired app registered, plus the actions of any paired @mindmakr/reins/node server. Call this first.',
+        inputSchema: obj(),
+    },
+    {
+        name: 'reins_run_action',
+        description: 'Run a registered action by name (app or server). Actions marked consequential are refused unless confirm is true; ask the person before confirming. Use target to pick "app" or "server" when both have the name.',
+        inputSchema: obj({ name: { type: 'string' }, input: { type: 'object' }, confirm: { type: 'boolean' }, target: { type: 'string', enum: ['app', 'server'] } }, ['name']),
+    },
+    {
+        name: 'reins_state',
+        description: 'Read a redacted snapshot of the app state: one source by name, or all of them.',
+        inputSchema: obj({ name: { type: 'string' } }),
+    },
+    {
+        name: 'reins_network',
+        description: 'Recent fetch calls: method, url, status, ms, startMs, trace id, redacted headers and bodies.',
+        inputSchema: obj({ limit: { type: 'number' }, url: { type: 'string', description: 'Only calls whose URL contains this' } }),
+    },
+    {
+        name: 'reins_errors',
+        description: 'Recent console errors, uncaught errors and unhandled promise rejections.',
+        inputSchema: obj({ limit: { type: 'number' } }),
+    },
+    {
+        name: 'reins_panel_box',
+        description: 'Bounding box of a panel (data-reins attribute or registered RN panel) in CSS pixels, with devicePixelRatio.',
+        inputSchema: obj({ id: { type: 'string' }, scroll: { type: 'boolean', description: 'Scroll it into view first' } }, ['id']),
+    },
+    {
+        name: 'reins_snap',
+        description: 'Pixel-exact picture of a panel, saved under .reins/snaps. Uses Playwright over CDP (bridge --cdp) or adb for Android; otherwise returns the box.',
+        inputSchema: obj({ id: { type: 'string' }, copy: { type: 'boolean', description: 'Also copy the image to the clipboard' } }, ['id']),
+    },
+    {
+        name: 'reins_perf',
+        description: 'Page lifecycle timings (TTFB, FCP, DOM interactive, load), component/panel mount times and render counts, API call latency stats, and a unified millisecond timeline. With a paired @mindmakr/reins/node server it adds a server section and the server half of each API call (kind "server", with db time and spans), joined by trace id.',
+        inputSchema: obj(),
+    },
+    {
+        name: 'reins_dom',
+        description: "Inspect a panel or CSS selector's DOM subtree, bounding boxes, computed CSS styles, and automatic layout issue flags (horizontal-clip, vertical-clip, zero-size).",
+        inputSchema: obj({
+            panel: { type: 'string', description: 'Panel id (data-reins attribute) to inspect' },
+            selector: { type: 'string', description: 'CSS selector inside the panel (or document if no panel)' },
+            depth: { type: 'number', description: 'Max child tree depth (default 3)' },
+            maxNodes: { type: 'number', description: 'Max elements to return (default 40)' },
+        }),
+    },
+    {
+        name: 'reins_server',
+        description: 'The server side (needs @mindmakr/reins/node in the dev server): recent requests with their spans (db.* time) and outbound fetches, trace ids that match reins_network, the slowest routes, and runtime stats (event-loop delay p50/p99/max, memory). Call it when an API call is slow or fails.',
+        inputSchema: obj({
+            limit: { type: 'number', description: 'Requests to return, newest last (default 50)' },
+            route: { type: 'string', description: 'Only requests whose route or URL contains this' },
+        }),
+    },
+    {
+        name: 'reins_report',
+        description: 'Gather everything into one session report: actions, redacted state, network, errors, perf with the server joined, layout issues per panel, snaps and actions run this session, with plain-language findings (slow or failed calls, duplicate calls, N+1-looking server spans, re-renders, layout issues). Saves .reins/sessions/<time>-<slug>.md and .json unless save is false. Returns the Markdown, the file paths and the findings.',
+        inputSchema: obj({
+            title: { type: 'string', description: 'Short name, e.g. "checkout before fix"' },
+            save: { type: 'boolean', description: 'Write the files (default true)' },
+        }),
+    },
+];
+const METHODS = {
+    reins_state: 'state',
+    reins_network: 'network',
+    reins_errors: 'errors',
+    reins_panel_box: 'panel',
+    reins_dom: 'dom',
+};
+const hasAction = (l, name) => Array.isArray(l?.actions) && l.actions.some((a) => a && a.name === name);
+/** Which client runs an action: the page or app, unless only a paired server has it (or `target` says so). */
+async function actionTarget(hub, name, target) {
+    const nodes = hub.nodeClients();
+    if (!nodes.length || target === 'app')
+        return undefined;
+    if (target !== 'server' && hub.current() && hasAction(await hub.request('list').catch(() => null), name))
+        return undefined;
+    for (const c of nodes)
+        if (hasAction(await hub.request('list', {}, c).catch(() => null), name))
+            return c;
+    if (target === 'server')
+        throw new Error(`no paired server has an action "${name}"`);
+    return undefined;
+}
+async function listAll(hub) {
+    const c = hub.current();
+    const nodes = hub.nodeClients();
+    const app = c || !nodes.length ? await hub.request('list') : { actions: [], states: [], panels: [] };
+    const out = { app: c && { url: c.url, title: c.title, meta: c.meta }, ...app };
+    if (nodes.length)
+        out.servers = await Promise.all(nodes.map(async (n) => ({ client: n.id, title: n.title, meta: n.meta, actions: (await hub.request('list', {}, n).catch(() => null))?.actions || [] })));
+    return out;
+}
+async function perfJoined(hub) {
+    const perf = await hub.request('perf');
+    const server = mergeServers(await serverReports(hub));
+    const out = withTimeline(perf, server?.requests);
+    if (server)
+        out.server = { requests: server.requests.length, slowest: server.slowest.slice(0, 5), runtime: server.runtime };
+    return out;
+}
+async function serverTool(hub, args) {
+    if (!hub.nodeClients().length)
+        throw new Error('No server is paired. In the dev server, call reinsNode.connect() from @mindmakr/reins/node (dev only) and add reinsNode.middleware().');
+    const server = mergeServers(await serverReports(hub));
+    if (!server)
+        throw new Error('the paired server did not answer');
+    const limit = typeof args.limit === 'number' && args.limit > 0 ? args.limit : 50;
+    const route = typeof args.route === 'string' ? args.route : '';
+    return { ...server, requests: server.requests.filter((r) => !route || r.route.includes(route) || r.url.includes(route)).slice(-limit) };
+}
+/** Runs one MCP tool against the paired app (and server). Every call is audited. */
+export async function callTool(ctx, name, args = {}) {
+    const started = Date.now();
+    const entry = {
+        source: 'agent',
+        event: name,
+        name: args.name ?? args.id ?? args.panel ?? args.selector ?? args.title ?? args.route,
+        args: name === 'reins_run_action' ? args.input : undefined,
+    };
+    try {
+        let result;
+        if (name === 'reins_snap') {
+            const box = await ctx.hub.request('panel', { id: args.id, scroll: true });
+            if (!box)
+                throw new Error(`no panel "${args.id}"`);
+            const shot = await snap(box, ctx.hub.current(), { dir: ctx.dir, cdp: ctx.cdp, copy: args.copy === true });
+            if (shot.file)
+                (ctx.snaps ?? (ctx.snaps = [])).push(relative(ctx.dir, shot.file).split('\\').join('/'));
+            result = shot;
+        }
+        else if (name === 'reins_list_actions') {
+            result = await listAll(ctx.hub);
+        }
+        else if (name === 'reins_run_action') {
+            const target = await actionTarget(ctx.hub, args.name, args.target);
+            result = await ctx.hub.request('run', { name: args.name, input: args.input, confirm: args.confirm === true }, target);
+        }
+        else if (name === 'reins_perf') {
+            result = await perfJoined(ctx.hub);
+        }
+        else if (name === 'reins_server') {
+            result = await serverTool(ctx.hub, args);
+        }
+        else if (name === 'reins_report') {
+            const session = await gatherSession(ctx, typeof args.title === 'string' ? args.title : undefined);
+            const files = args.save === false ? null : writeSession(ctx.dir, session);
+            result = { markdown: files ? files.markdown : renderMarkdown(session), files: files && { md: files.md, json: files.json }, findings: findings(session) };
+        }
+        else if (METHODS[name]) {
+            result = await ctx.hub.request(METHODS[name], args);
+        }
+        else {
+            throw new Error(`unknown tool "${name}"`);
+        }
+        ctx.audit?.({ ...entry, ok: true, ms: Date.now() - started });
+        return result;
+    }
+    catch (err) {
+        ctx.audit?.({ ...entry, ok: false, error: err.message, ms: Date.now() - started });
+        throw err;
+    }
+}

package/dist/cli.d.ts

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

package/dist/cli.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+import { resolve } from 'node:path';
+import { parseArgs, portInUse, USAGE } from './bridge/args.js';
+import { fileAudit } from './bridge/audit.js';
+import { DEFAULT_PORT, Hub } from './bridge/hub.js';
+import { startMcp } from './bridge/mcp.js';
+import { reportMain } from './bridge/report-cli.js';
+import { tokenPath } from './bridge/token.js';
+import { main as verifyMain } from './verify.js';
+const err = (m) => process.stderr.write(m + '\n');
+async function main() {
+    const argv = process.argv.slice(2);
+    if (argv[0] === 'verify') {
+        process.exitCode = verifyMain(argv.slice(1));
+        return;
+    }
+    if (argv[0] === 'report') {
+        process.exitCode = reportMain(argv.slice(1));
+        return;
+    }
+    let args;
+    try {
+        args = parseArgs(argv, process.cwd());
+    }
+    catch (e) {
+        err(`reins: ${e.message}\n\n${USAGE}`);
+        process.exitCode = 2;
+        return;
+    }
+    if (args.command === 'help') {
+        err(USAGE);
+        return;
+    }
+    const dir = resolve(args.dir);
+    const audit = fileAudit(dir);
+    let hub;
+    try {
+        hub = await Hub.start({ dir, port: args.port, origins: args.origins, rotate: args.rotate, allowNoOrigin: args.allowNoOrigin, audit });
+    }
+    catch (e) {
+        if (e && e.code === 'EADDRINUSE') {
+            err(portInUse(args.port ?? DEFAULT_PORT));
+            process.exitCode = 1;
+            return;
+        }
+        throw e;
+    }
+    err(`[reins] bridge on ws://127.0.0.1:${hub.port}`);
+    // The token itself is not printed: stderr ends up in the agent host's MCP logs. It is in the file.
+    err(`[reins] pairing token written to ${tokenPath(dir)}${args.rotate ? ' (renewed after each pairing)' : ''}`);
+    audit({ source: 'bridge', event: 'start', ok: true, port: hub.port });
+    if (args.mcp)
+        await startMcp({ hub, dir, cdp: args.cdp, audit });
+    const stop = async () => {
+        audit({ source: 'bridge', event: 'stop', ok: true });
+        await hub.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+    if (args.mcp)
+        process.stdin.on('end', stop);
+}
+main().catch((e) => {
+    err(`reins: ${e && e.message ? e.message : e}`);
+    process.exitCode = 1;
+});

package/dist/dom.d.ts

@@ -0,0 +1,2 @@
+import type { DomNode, DomOptions } from './types.js';
+export declare function inspect(g: any, o?: DomOptions): DomNode | null;

package/dist/dom.js

@@ -0,0 +1,48 @@
+// The DOM and CSS inspector behind `reins.dom()` and `reins_dom`. The core loads this file on the first call.
+import { isSensitive, REDACTED } from './redact.js';
+const STYLE_KEYS = 'display,position,flexDirection,justifyContent,alignItems,gap,overflowX,overflowY,direction,color,backgroundColor,fontSize,fontWeight,opacity,visibility,zIndex'.split(',');
+const R = (n) => Math.round(n || 0);
+export function inspect(g, o = {}) {
+    const d = g.document, findPanel = (id) => d.querySelector?.(`[data-reins="${id.replace(/["\\]/g, '\\$&')}"]`), boxOf = (r) => ({ x: R(r.left), y: R(r.top), width: R(r.width), height: R(r.height) });
+    let root = d && (o.panel ? findPanel(o.panel) : o.selector ? d : d.body);
+    if (root && o.selector)
+        root = root.querySelector?.(o.selector);
+    if (!root)
+        return null;
+    let count = 0;
+    const walk = (el, depth) => {
+        count++;
+        const r = el.getBoundingClientRect?.() || {}, cs = g.getComputedStyle?.(el) || {}, styles = {}, issues = [], clip = (v) => /^hidden|clip$/.test(v), attr = (k) => el.getAttribute?.(k) || undefined, cls = el.className?.trim?.(), children = [];
+        let raw = '';
+        for (const n of el.childNodes || [])
+            if (n.nodeType == 3)
+                raw += n.textContent;
+        raw = raw.trim().slice(0, 80);
+        for (const k of STYLE_KEYS)
+            if (cs[k])
+                styles[k] = '' + cs[k];
+        if (el.scrollWidth > el.clientWidth + 1 && (clip(cs.overflowX) || cs.textOverflow == 'ellipsis'))
+            issues.push('horizontal-clip');
+        if (el.scrollHeight > el.clientHeight + 1 && clip(cs.overflowY))
+            issues.push('vertical-clip');
+        if ((!r.width || !r.height) && !/^(none|contents)$/.test(cs.display))
+            issues.push('zero-size');
+        if (depth < (o.depth ?? 3))
+            for (const ch of el.children || [])
+                if (count < (o.maxNodes ?? 40))
+                    children.push(walk(ch, depth + 1));
+        return {
+            tag: (el.tagName || 'div').toLowerCase(),
+            id: el.id || undefined,
+            classes: cls ? cls.split(/\s+/) : undefined,
+            panel: attr('data-reins'),
+            role: attr('role'),
+            text: raw ? (isSensitive([el.id, attr('name'), attr('type')].join(' ')) ? REDACTED : raw) : undefined,
+            box: boxOf(r),
+            styles,
+            issues,
+            children,
+        };
+    };
+    return walk(root, 0);
+}

package/dist/env.d.ts

@@ -0,0 +1 @@
+export declare function devEnabled(): boolean;

package/dist/env.js

@@ -0,0 +1,6 @@
+export function devEnabled() {
+    const d = import.meta.env, r = globalThis.__DEV__, p = typeof process < 'u' && process.env;
+    return (['', 'VITE_', 'NEXT_PUBLIC_', 'EXPO_PUBLIC_'].some((k) => /^(1|true)$/.test(d?.[k + 'REINS_ENABLE'] || p?.[k + 'REINS_ENABLE'])) ||
+        r === true ||
+        (r !== false && p?.NODE_ENV != 'production' && d?.DEV !== false && !!(d?.DEV || p?.NODE_ENV)));
+}

package/dist/expo.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import { type Box, type ConnectOptions } from '@mindmakr/reins';
+export declare const TOKEN_ROUTE = "/__reins/token";
+/** `http://host:port` of the Metro dev server that served this bundle, if known. */
+export declare function devServerOrigin(scriptURL?: string | undefined): string | null;
+/**
+ * Pairs the app with the bridge. Fetches the token from the Metro dev server (see `withReins` in `@mindmakr/reins/metro`)
+ * and connects to the bridge on localhost. Android emulators and USB devices need `adb reverse tcp:7357 tcp:7357`.
+ * Does nothing in production builds.
+ */
+export declare function connectExpo(opts?: ConnectOptions): Promise<boolean>;
+/** Measures a native view in window coordinates (dp) with the pixel ratio. */
+export declare function measureView(id: string, view: any): Promise<Box | null>;
+/** Returns a ref to put on a View; the agent can then measure and snap it as panel `id`. */
+export declare function useReinsPanel(id: string): import("react").MutableRefObject<any>;
+export interface ReinsPanelProps {
+    id: string;
+    children?: ReactNode;
+    [prop: string]: unknown;
+}
+/** A View with `testID={id}` that the agent can measure and snap. */
+export declare function ReinsPanel({ id, children, ...rest }: ReinsPanelProps): import("react").CElement<{
+    ref: import("react").MutableRefObject<any>;
+    testID: string;
+    collapsable: boolean;
+}, any>;
+export { useReinsAction, useReinsState } from '@mindmakr/reins/react';

package/dist/expo.js

@@ -0,0 +1,48 @@
+import { createElement, useEffect, useRef } from 'react';
+import { NativeModules, PixelRatio, Platform, View } from 'react-native';
+import { reins } from '@mindmakr/reins';
+export const TOKEN_ROUTE = '/__reins/token';
+/** `http://host:port` of the Metro dev server that served this bundle, if known. */
+export function devServerOrigin(scriptURL = NativeModules.SourceCode && NativeModules.SourceCode.scriptURL) {
+    if (!scriptURL)
+        return null;
+    const m = /^(https?:\/\/[^/]+)/.exec(scriptURL);
+    return m ? m[1] : null;
+}
+/**
+ * Pairs the app with the bridge. Fetches the token from the Metro dev server (see `withReins` in `@mindmakr/reins/metro`)
+ * and connects to the bridge on localhost. Android emulators and USB devices need `adb reverse tcp:7357 tcp:7357`.
+ * Does nothing in production builds.
+ */
+export function connectExpo(opts = {}) {
+    const origin = devServerOrigin();
+    return reins.connect({
+        tokenUrl: origin ? origin + TOKEN_ROUTE : undefined,
+        url: 'ws://localhost:7357',
+        ...opts,
+        meta: { platform: Platform.OS, ...(opts.meta || {}) },
+    });
+}
+/** Measures a native view in window coordinates (dp) with the pixel ratio. */
+export function measureView(id, view) {
+    return new Promise((resolve) => {
+        if (!view || typeof view.measureInWindow !== 'function')
+            return resolve(null);
+        view.measureInWindow((x, y, width, height) => resolve({ id, x, y, width, height, scrollX: 0, scrollY: 0, devicePixelRatio: PixelRatio.get() }));
+    });
+}
+/** Returns a ref to put on a View; the agent can then measure and snap it as panel `id`. */
+export function useReinsPanel(id) {
+    const ref = useRef(null);
+    useEffect(() => reins.registerPanel(id, () => measureView(id, ref.current)), [id]);
+    return ref;
+}
+/** A View with `testID={id}` that the agent can measure and snap. */
+export function ReinsPanel({ id, children, ...rest }) {
+    useEffect(() => {
+        reins.markComponent(id);
+    });
+    const ref = useReinsPanel(id);
+    return createElement(View, { testID: id, collapsable: false, ...rest, ref }, children);
+}
+export { useReinsAction, useReinsState } from '@mindmakr/reins/react';