nativemason 0.0.0-stage → 0.3.0

package/dist/evidence/report.js

@@ -0,0 +1,180 @@
+import { EvidenceInputsSchema, NativeTargetSchema, NativeVerificationSchema, SpatialSnapshotSchema, VisualEvidenceReportSchema, VisualEvidenceRunSchema, } from '@nativemason/contracts';
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { buildOverlayScene } from '../core/index.js';
+const MAX_INPUT_BYTES = 16 * 1024 * 1024;
+const MAX_SNAPSHOT_NODES = 5_000;
+const MAX_RENDERED_NODES = 250;
+const MAX_LAYOUT_UNITS = 100_000;
+const palette = ['#2563eb', '#dc2626', '#059669', '#7c3aed', '#d97706', '#0891b2'];
+function readJson(path) {
+    try {
+        if (statSync(path).size > MAX_INPUT_BYTES)
+            return undefined;
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function isRelativeEvidencePath(path) {
+    const hasControl = [...path].some(character => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127);
+    return path.length > 0 && !path.startsWith('/') && !path.includes('\\') && !path.includes(':') && !hasControl && path.split('/').every(part => part !== '' && part !== '.' && part !== '..');
+}
+function hasSafePaths(run) {
+    const paths = [
+        ...Object.keys(run.before.revisions),
+        ...Object.keys(run.after.revisions),
+        ...run.before.nodes.flatMap(node => node.source ? [node.source.path, ...(node.source.dependencies ?? [])] : []),
+        ...run.after.nodes.flatMap(node => node.source ? [node.source.path, ...(node.source.dependencies ?? [])] : []),
+        ...(run.receipt ? [run.receipt.path, ...(run.receipt.files?.map(file => file.path) ?? [])] : []),
+    ];
+    return paths.every(isRelativeEvidencePath);
+}
+function boundedSnapshot(snapshot) {
+    const { width, height } = snapshot.profile.window;
+    if (width > MAX_LAYOUT_UNITS || height > MAX_LAYOUT_UNITS || snapshot.nodes.length > MAX_SNAPSHOT_NODES)
+        return false;
+    return snapshot.nodes.every(({ rect }) => [rect.x, rect.y, rect.width, rect.height].every(value => Math.abs(value) <= MAX_LAYOUT_UNITS));
+}
+function unavailable(message) { return `${message} No measurements were added.`; }
+function addRun(value, label, runs, notes) {
+    const parsed = VisualEvidenceRunSchema.safeParse(value);
+    if (!parsed.success || !hasSafePaths(parsed.data) || !boundedSnapshot(parsed.data.before) || !boundedSnapshot(parsed.data.after)) {
+        notes.push(unavailable(`${label} evidence is missing, invalid, unsafe, or exceeds report bounds.`));
+        return;
+    }
+    runs.push(parsed.data);
+}
+function addNativeRun(directory, platform, runs, notes) {
+    const label = platform === 'android' ? 'Android emulator' : 'iOS simulator';
+    if (!directory) {
+        notes.push(unavailable(`${label} evidence is unavailable.`));
+        return;
+    }
+    const calibrationValue = readJson(join(directory, 'calibration.json'));
+    const acceptanceValue = readJson(join(directory, 'acceptance.json'));
+    const verified = acceptanceValue?.verified;
+    const target = NativeTargetSchema.safeParse(acceptanceValue?.target);
+    const before = SpatialSnapshotSchema.safeParse(calibrationValue);
+    const verification = NativeVerificationSchema.safeParse(verified);
+    const rawTarget = acceptanceValue?.target;
+    const rawBefore = calibrationValue;
+    const rawAfter = verified?.snapshot;
+    const isPhysical = rawTarget?.kind === 'physical' || rawBefore?.nativeTarget?.kind === 'physical' || rawAfter?.nativeTarget?.kind === 'physical'
+        || target.success && target.data.kind === 'physical'
+        || before.success && before.data.nativeTarget?.kind === 'physical'
+        || verification.success && verification.data.snapshot.nativeTarget?.kind === 'physical';
+    if (isPhysical) {
+        notes.push(unavailable(`${label} physical-target evidence is excluded from public reports.`));
+        return;
+    }
+    if (!target.success || !before.success || !verification.success || verification.data.results.length === 0) {
+        notes.push(unavailable(`${label} acceptance or calibration evidence is missing or inconsistent.`));
+        return;
+    }
+    const after = verification.data.snapshot;
+    const receipt = verification.data.receipt;
+    const expectedKind = platform === 'android' ? 'emulator' : 'simulator';
+    const valid = target.data.platform === platform && target.data.kind === expectedKind
+        && before.data.platform === platform && before.data.nativeTarget?.kind === expectedKind
+        && after.platform === platform && after.nativeTarget?.kind === expectedKind
+        && (verification.data.passed || receipt.nativeStatus !== 'passed')
+        && before.data.nativeTarget.targetId === target.data.targetId
+        && after.nativeTarget.targetId === target.data.targetId;
+    if (!valid) {
+        notes.push(unavailable(`${label} acceptance or calibration evidence is missing or inconsistent.`));
+        return;
+    }
+    const passed = verification.data.passed;
+    addRun({
+        id: platform === 'android' ? 'android-emulator' : 'ios-simulator',
+        title: label,
+        target: platform === 'android' ? 'android-emulator' : 'ios-simulator',
+        before: before.data,
+        after,
+        results: verification.data.results,
+        receipt,
+        nativeStatus: passed ? 'passed' : 'failed',
+        notes: passed ? [] : ['Native acceptance did not pass.'],
+    }, label, runs, notes);
+}
+export function buildEvidenceReport(rawInput) {
+    const input = EvidenceInputsSchema.parse(rawInput);
+    const runs = [];
+    const notes = [];
+    if (input.webFile) {
+        const web = readJson(input.webFile);
+        if (web === undefined)
+            notes.push(unavailable('Web evidence is unavailable.'));
+        else
+            addRun(web, 'Web', runs, notes);
+    }
+    else
+        notes.push(unavailable('Web evidence is unavailable.'));
+    addNativeRun(input.androidDirectory, 'android', runs, notes);
+    addNativeRun(input.iosDirectory, 'ios', runs, notes);
+    return VisualEvidenceReportSchema.parse({
+        schemaVersion: 1,
+        repository: input.repository,
+        revision: input.revision,
+        ...(input.pullRequest ? { pullRequest: input.pullRequest } : {}),
+        runs,
+        notes,
+    });
+}
+function escapeHtml(value) {
+    const text = String(value);
+    const bounded = text.length > 512 ? text.slice(0, 509) + '…' : text;
+    return bounded.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&#39;');
+}
+function number(value) { return Number(value.toFixed(3)).toString(); }
+function rectText(node) {
+    if (!node)
+        return '—';
+    const { x, y, width, height } = node.rect;
+    return `${number(x)}, ${number(y)} · ${number(width)} × ${number(height)}`;
+}
+function renderSvg(snapshot, title, colors) {
+    const scene = buildOverlayScene(snapshot, {
+        schemaVersion: 1, scenarioId: snapshot.scenarioId, profile: snapshot.profile, requiredElementIds: [], constraints: [],
+    });
+    const { width, height } = scene;
+    const nodes = scene.marks.slice(0, MAX_RENDERED_NODES);
+    const shapes = nodes.map((node, index) => {
+        const color = colors.get(node.id) ?? palette[index % palette.length];
+        const rect = node.rect;
+        return `<rect x="${number(rect.x)}" y="${number(rect.y)}" width="${number(rect.width)}" height="${number(rect.height)}" fill="${color}" fill-opacity=".13" stroke="${color}" stroke-width="1"><title>${escapeHtml(node.id)} · registered layout box</title></rect>`;
+    }).join('');
+    return `<svg class="layout" viewBox="0 0 ${number(width)} ${number(height)}" role="img" aria-label="${escapeHtml(title)} registered measured layout boxes"><title>${escapeHtml(title)} · registered measured layout boxes</title><rect width="100%" height="100%" fill="#f8fafc"/>${shapes}</svg>`;
+}
+function renderRun(run) {
+    const colors = new Map([...new Set([...run.before.nodes, ...run.after.nodes].map(node => node.id))].sort().map((id, index) => [id, palette[index % palette.length]]));
+    const beforeById = new Map(run.before.nodes.map(node => [node.id, node]));
+    const afterById = new Map(run.after.nodes.map(node => [node.id, node]));
+    const ids = [...new Set([...beforeById.keys(), ...afterById.keys()])].sort();
+    const visibleIds = ids.slice(0, MAX_RENDERED_NODES);
+    const geometryRows = visibleIds.map(id => `<tr><th>${escapeHtml(id)}</th><td>${rectText(beforeById.get(id))}</td><td>${rectText(afterById.get(id))}</td></tr>`).join('');
+    const constraints = run.results.length ? run.results.slice(0, MAX_RENDERED_NODES).map(result => `<tr><td>${escapeHtml(result.constraintId)}</td><td>${escapeHtml(result.status)}</td><td>${escapeHtml(result.elementIds.join(', '))}</td><td>${escapeHtml(result.tolerance)}</td><td>${escapeHtml(result.deviation ?? '—')}</td><td>${escapeHtml(result.message)}</td></tr>`).join('') : '<tr><td colspan="6">No constraint results were supplied.</td></tr>';
+    const revisions = [...new Set([...Object.keys(run.before.revisions), ...Object.keys(run.after.revisions)])].sort();
+    const revisionRows = revisions.slice(0, MAX_RENDERED_NODES).map(path => `<tr><th>${escapeHtml(path)}</th><td><code>${escapeHtml(run.before.revisions[path] ?? '—')}</code></td><td><code>${escapeHtml(run.after.revisions[path] ?? '—')}</code></td></tr>`).join('');
+    const receiptFiles = run.receipt?.files?.length ? run.receipt.files : run.receipt ? [run.receipt] : [];
+    const receipt = run.receipt ? `<table><caption>Commit receipt</caption><thead><tr><th>Commit</th><th>Status</th><th>File</th><th>Old revision</th><th>New revision</th></tr></thead><tbody>${receiptFiles.slice(0, MAX_RENDERED_NODES).map(file => `<tr><td>${escapeHtml(run.receipt.commitId)}</td><td>${escapeHtml(run.receipt.nativeStatus)}</td><td>${escapeHtml(file.path)}</td><td><code>${escapeHtml(file.oldHash)}</code></td><td><code>${escapeHtml(file.newHash)}</code></td></tr>`).join('')}</tbody></table>` : '<p>No commit receipt was supplied.</p>';
+    const notes = run.notes.length ? `<ul>${run.notes.slice(0, MAX_RENDERED_NODES).map(note => `<li>${escapeHtml(note)}</li>`).join('')}</ul>` : '';
+    const truncated = ids.length > MAX_RENDERED_NODES || revisions.length > MAX_RENDERED_NODES || run.results.length > MAX_RENDERED_NODES || receiptFiles.length > MAX_RENDERED_NODES || run.notes.length > MAX_RENDERED_NODES
+        ? `<p>SVGs show at most ${MAX_RENDERED_NODES} boxes; tables and notes show at most ${MAX_RENDERED_NODES} rows. The JSON manifest retains full evidence.</p>` : '';
+    return `<section id="${escapeHtml(run.id)}"><h2>${escapeHtml(run.title)}</h2><p>Target: ${escapeHtml(run.target)} · status: <strong>${escapeHtml(run.nativeStatus)}</strong> · scenario: ${escapeHtml(run.after.scenarioId)}</p>${notes}<h3>Registered measured layout boxes</h3><div class="panels"><figure>${renderSvg(run.before, 'Before', colors)}<figcaption>Before · ${escapeHtml(run.before.profile.window.width)} × ${escapeHtml(run.before.profile.window.height)} window units</figcaption></figure><figure>${renderSvg(run.after, 'After', colors)}<figcaption>After · ${escapeHtml(run.after.profile.window.width)} × ${escapeHtml(run.after.profile.window.height)} window units</figcaption></figure></div><table><caption>Layout box measurements · x, y · width × height in app-root-relative logical units</caption><thead><tr><th>Element</th><th>Before</th><th>After</th></tr></thead><tbody>${geometryRows || '<tr><td colspan="3">No measured layout boxes.</td></tr>'}</tbody></table>${truncated}<table><caption>Constraint results</caption><thead><tr><th>Constraint</th><th>Status</th><th>Elements</th><th>Tolerance</th><th>Deviation</th><th>Message</th></tr></thead><tbody>${constraints}</tbody></table><table><caption>Source revisions</caption><thead><tr><th>Relative source path</th><th>Before</th><th>After</th></tr></thead><tbody>${revisionRows || '<tr><td colspan="3">No source revisions.</td></tr>'}</tbody></table>${receipt}</section>`;
+}
+export function renderEvidenceHtml(report) {
+    const links = report.runs.map(run => `<li><a href="#${escapeHtml(run.id)}">${escapeHtml(run.title)} (${escapeHtml(run.nativeStatus)})</a></li>`).join('');
+    const notes = report.notes.length ? `<section><h2>Unavailable evidence</h2><ul>${report.notes.slice(0, MAX_RENDERED_NODES).map(note => `<li>${escapeHtml(note)}</li>`).join('')}</ul></section>` : '';
+    const runs = report.runs.map(renderRun).join('');
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Visual evidence · ${escapeHtml(report.repository)}</title><style>body{font:16px/1.5 system-ui,sans-serif;max-width:1100px;margin:2rem auto;padding:0 1rem;color:#172033}h1,h2{line-height:1.2}section{border-top:1px solid #cbd5e1;margin-top:2rem;padding-top:1rem}.panels{display:flex;flex-wrap:wrap;gap:1rem}.panels figure{flex:1 1 280px;margin:0}.layout{display:block;width:min(100%,640px);height:auto;border:1px solid #cbd5e1}table{border-collapse:collapse;width:100%;margin:1rem 0;font-size:.9rem}caption{text-align:left;font-weight:700;padding:.5rem 0}th,td{border:1px solid #cbd5e1;padding:.4rem;text-align:left;vertical-align:top}code{overflow-wrap:anywhere}.status{color:#475569}</style></head><body><h1>Visual evidence report</h1><p>${escapeHtml(report.repository)} · revision <code>${escapeHtml(report.revision)}</code>${report.pullRequest ? ` · pull request #${escapeHtml(report.pullRequest)}` : ''}</p><p class="status">SVGs place registered measured layout boxes within the window frame using the profile root origin; measurement tables show app-root-relative logical units. These are not native screenshots. <a href="manifest.json">Download the validated JSON manifest</a>.</p><nav aria-label="Evidence runs"><ul>${links || '<li>No measured runs are available.</li>'}</ul></nav>${notes}${runs}</body></html>`;
+}
+export function renderEvidenceSummary(report) {
+    const rows = ['| Target | Status |', '| --- | --- |', ...report.runs.map(run => `| ${run.target} | ${run.nativeStatus} |`)];
+    if (!report.runs.length)
+        rows.push('| unavailable | no measured run |');
+    rows.push('', `See the visual evidence report for ${report.repository} at revision ${report.revision}.`);
+    return rows.join('\n') + '\n';
+}

package/dist/init/index.d.ts

@@ -0,0 +1,26 @@
+export declare function initialize(projectRoot: string, dryRun?: boolean, settings?: {
+    textProbes?: boolean;
+}): Promise<{
+    projectRoot: string;
+    rootComponent: string;
+    automaticRoot: boolean;
+    dryRun: boolean;
+    changed: boolean;
+    file: string;
+    before: string;
+    after: string;
+    ignoreEdit: {
+        before: string;
+        after: string;
+    };
+    install: string;
+    mcp: {
+        mcpServers: {
+            nativemason: {
+                command: string;
+                args: string[];
+                cwd: string;
+            };
+        };
+    };
+}>;

package/dist/init/index.js

@@ -0,0 +1,81 @@
+import { readFile, writeFile, access } from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath, URL } from 'node:url';
+import { Project, Node, SyntaxKind } from 'ts-morph';
+import { BridgeFault } from '@nativemason/contracts';
+const exists = async (p) => access(p).then(() => true, () => false);
+export async function initialize(projectRoot, dryRun = false, settings = {}) {
+    const root = path.resolve(projectRoot);
+    const app = JSON.parse(await readFile(path.join(root, 'package.json'), 'utf8'));
+    if (!app.dependencies?.expo)
+        throw new BridgeFault('INVALID_INPUT', 'Initialization requires an Expo project');
+    const roots = ['app/_layout', 'src/app/_layout', 'App', 'src/App'].flatMap(base => ['tsx', 'jsx', 'js', 'ts'].map(extension => base + '.' + extension));
+    const discovered = [];
+    for (const file of roots)
+        if (await exists(path.join(root, file)))
+            discovered.push(file);
+    // Follow the declared Router entry and Expo's documented src/app precedence.
+    const routerEntry = typeof app.main === 'string' && /(?:^|\/)expo-router\/entry(?:\.js)?$/.test(app.main);
+    const routerDirectory = ['src/app/', 'app/'].find(directory => discovered.some(file => file.startsWith(directory)));
+    const candidates = routerEntry ? discovered.filter(file => routerDirectory && file.startsWith(routerDirectory)) : discovered;
+    if (candidates.length !== 1)
+        throw new BridgeFault('INVALID_INPUT', 'Expected one Expo app root', { candidates });
+    const configs = ['babel.config.js', 'babel.config.cjs'];
+    const present = [];
+    for (const file of configs)
+        if (await exists(path.join(root, file)))
+            present.push(file);
+    if (present.length > 1)
+        throw new BridgeFault('UNSUPPORTED_EDIT', 'Multiple Babel configurations require manual selection');
+    const file = present[0] ?? 'babel.config.cjs';
+    const old = present.length ? await readFile(path.join(root, file), 'utf8') : "module.exports = function(api) { api.cache(true); return { presets: [require.resolve('babel-preset-expo', { paths: [require.resolve('expo/package.json')] })], plugins: [] }; };\n";
+    const project = new Project({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true });
+    const source = project.createSourceFile('/babel.js', old);
+    const config = source.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression).filter(o => o.getProperty('presets') || o.getProperty('plugins'));
+    const rootSource = project.createSourceFile('/root.tsx', await readFile(path.join(root, candidates[0]), 'utf8'));
+    const providerTags = new Set();
+    let wrappedRoot = false;
+    for (const declaration of rootSource.getImportDeclarations())
+        if (declaration.getModuleSpecifierValue() === '@nativemason/runtime') {
+            for (const imported of declaration.getNamedImports()) {
+                if (imported.getName() === 'LayoutProvider')
+                    providerTags.add(imported.getAliasNode()?.getText() ?? imported.getName());
+                if (imported.getName() === 'withLayoutRoot')
+                    wrappedRoot = true;
+            }
+            const namespace = declaration.getNamespaceImport();
+            if (namespace)
+                providerTags.add(namespace.getText() + '.LayoutProvider');
+        }
+    const manualProvider = wrappedRoot || rootSource.getDescendants().some(node => (Node.isJsxOpeningElement(node) || Node.isJsxSelfClosingElement(node)) && providerTags.has(node.getTagNameNode().getText()));
+    const options = { autoInstrument: true, textProbes: settings.textProbes ?? false, nativewind: Boolean(app.dependencies?.nativewind), ...(manualProvider ? {} : { rootComponent: candidates[0] }) };
+    let updated = old;
+    if (!old.includes('nativemason/babel')) {
+        if (config.length !== 1)
+            throw new BridgeFault('UNSUPPORTED_EDIT', 'Babel configuration cannot be safely edited', { suggestedPlugin: ["nativemason/babel", options] });
+        const plugins = config[0].getProperty('plugins');
+        const text = `[require.resolve('nativemason/babel'), { projectRoot: __dirname, ...${JSON.stringify(options)} }]`;
+        if (!plugins)
+            config[0].addPropertyAssignment({ name: 'plugins', initializer: `[${text}]` });
+        else if (Node.isPropertyAssignment(plugins) && Node.isArrayLiteralExpression(plugins.getInitializer()))
+            plugins.getInitializerIfKindOrThrow(SyntaxKind.ArrayLiteralExpression).insertElement(0, text);
+        else
+            throw new BridgeFault('UNSUPPORTED_EDIT', 'Computed Babel plugins cannot be safely edited', { suggestedPlugin: ["nativemason/babel", options] });
+        updated = source.getFullText();
+    }
+    const ignorePath = path.join(root, '.gitignore');
+    const ignoreBefore = await readFile(ignorePath, 'utf8').catch(error => { if (error.code === 'ENOENT')
+        return ''; throw error; });
+    let ignoreAfter = ignoreBefore;
+    for (const entry of ['/.nativemason/', '/artifacts/nativemason/'])
+        if (!ignoreBefore.split(/\r?\n/).includes(entry))
+            ignoreAfter += (ignoreAfter && !ignoreAfter.endsWith('\n') ? '\n' : '') + entry + '\n';
+    if (!dryRun) {
+        if (updated !== old)
+            await writeFile(path.join(root, file), updated, 'utf8');
+        if (ignoreAfter !== ignoreBefore)
+            await writeFile(ignorePath, ignoreAfter, 'utf8');
+    }
+    const mcp = { mcpServers: { nativemason: { command: 'node', args: [fileURLToPath(new URL('../cli.js', import.meta.url))], cwd: root } } };
+    return { projectRoot: root, rootComponent: candidates[0], automaticRoot: !manualProvider, dryRun, changed: updated !== old || ignoreAfter !== ignoreBefore, file, before: old, after: updated, ignoreEdit: { before: ignoreBefore, after: ignoreAfter }, install: 'Install matching nativemason, @nativemason/runtime and @nativemason/contracts packages before starting Expo.', mcp };
+}

package/dist/instrumentation/index.d.ts

@@ -0,0 +1,25 @@
+import { type PluginObj, type PluginPass } from '@babel/core';
+import * as t from '@babel/types';
+interface Options {
+    projectRoot?: string;
+    autoInstrument?: boolean;
+    rootComponent?: string;
+    textProbes?: boolean;
+    nativewind?: boolean;
+}
+type State = PluginPass & {
+    opts: Options;
+    bridgeHosts?: Map<string, t.Identifier>;
+    bridgeKinds?: Map<string, string>;
+    bridgeRoot?: t.Identifier;
+    bridgeRevision?: t.Identifier;
+    bridgeBindings?: Map<string, unknown>;
+    bridgeStyleImports?: Map<string, {
+        file: string;
+        binding: unknown;
+    }>;
+    bridgeDependencyCache?: Map<string, string[]>;
+    bridgeOrdinal?: number;
+};
+export default function bridgeSourcePlugin(): PluginObj<State>;
+export {};

package/dist/instrumentation/index.js

@@ -0,0 +1,235 @@
+import { parseSync } from '@babel/core';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import * as t from '@babel/types';
+import { createHash } from 'node:crypto';
+import { dirname, relative, resolve, sep } from 'node:path';
+const hosts = new Set(['View', 'Text', 'Pressable', 'TextInput', 'ScrollView', 'Image']);
+function staticCallback(expression) {
+    if (!expression || (!t.isArrowFunctionExpression(expression) && !t.isFunctionExpression(expression)) || expression.async || expression.generator || expression.params.length !== 1)
+        return false;
+    const parameter = expression.params[0];
+    if (!t.isObjectPattern(parameter) || parameter.properties.length !== 1)
+        return false;
+    const pressed = parameter.properties[0];
+    if (!t.isObjectProperty(pressed) || !t.isIdentifier(pressed.key, { name: 'pressed' }) || !t.isIdentifier(pressed.value))
+        return false;
+    const body = t.isBlockStatement(expression.body) ? expression.body.body.length === 1 && t.isReturnStatement(expression.body.body[0]) ? expression.body.body[0].argument : null : expression.body;
+    if (!t.isConditionalExpression(body))
+        return false;
+    const test = t.isUnaryExpression(body.test, { operator: '!' }) ? body.test.argument : body.test;
+    if (!t.isIdentifier(test, { name: pressed.value.name }))
+        return false;
+    return [body.consequent, body.alternate].every(arm => t.isObjectExpression(arm) && arm.properties.every(property => t.isObjectProperty(property) && !property.computed && !property.shorthand && (t.isIdentifier(property.key) || t.isStringLiteral(property.key)) && (t.isStringLiteral(property.value) || t.isNumericLiteral(property.value) || t.isBooleanLiteral(property.value) || t.isNullLiteral(property.value) || (t.isUnaryExpression(property.value) && ['+', '-'].includes(property.value.operator) && t.isNumericLiteral(property.value.argument)))));
+}
+function development(state) { const caller = state.file.opts.caller; if (caller && 'dev' in caller && caller.dev === false)
+    return false; const filename = state.filename ?? state.file.opts.filename ?? ''; if (filename.includes('\0') || !/\.[cm]?[jt]sx?$/.test(filename))
+    return false; return process.env.NODE_ENV !== 'production' && state.file.opts.envName !== 'production' && !state.filename?.split(/[\\/]/).includes('node_modules'); }
+function physicalPath(path) { try {
+    return realpathSync(path);
+}
+catch {
+    return resolve(path);
+} }
+function filePath(state) {
+    const filename = state.filename ?? state.file.opts.filename;
+    if (!filename)
+        return null;
+    return relative(physicalPath(state.opts.projectRoot ?? state.file.opts.root ?? process.cwd()), physicalPath(filename)).split(sep).join('/');
+}
+function localModule(from, specifier) {
+    if (!specifier.startsWith('.'))
+        return;
+    const base = resolve(dirname(from), specifier);
+    return [base, ...['.ts', '.tsx', '.js', '.jsx', '.mts', '.cts', '.mjs', '.cjs'].map(ext => base + ext), ...['index.ts', 'index.tsx', 'index.js', 'index.jsx'].map(file => resolve(base, file))].find(file => /\.[cm]?[jt]sx?$/.test(file) && existsSync(file));
+}
+function styleModules(file, root, seen = new Set()) {
+    if (seen.has(file))
+        return [];
+    seen.add(file);
+    file = physicalPath(file);
+    root = physicalPath(root);
+    const relativePath = relative(root, file).split(sep).join('/');
+    if (relativePath.startsWith('../'))
+        return [];
+    const result = [relativePath];
+    const ast = parseSync(readFileSync(file, 'utf8'), { filename: file, configFile: false, babelrc: false, parserOpts: { plugins: ['typescript', 'jsx'], sourceType: 'unambiguous' } });
+    if (ast)
+        t.traverseFast(ast, node => { if ((t.isImportDeclaration(node) || t.isExportNamedDeclaration(node) || t.isExportAllDeclaration(node)) && node.source) {
+            const dependency = localModule(file, node.source.value);
+            if (dependency)
+                result.push(...styleModules(dependency, root, seen));
+        } });
+    return [...new Set(result)];
+}
+export default function bridgeSourcePlugin() {
+    return {
+        name: 'nativemason-source',
+        visitor: {
+            Program: {
+                enter(path, state) {
+                    if (!development(state))
+                        return;
+                    const projectPath = filePath(state);
+                    if (!projectPath || projectPath.startsWith('../'))
+                        return;
+                    state.bridgeRevision = path.scope.generateUidIdentifier("registerSourceRevision");
+                    state.bridgeOrdinal = 0;
+                    state.bridgeHosts = new Map();
+                    state.bridgeKinds = new Map();
+                    state.bridgeBindings = new Map();
+                    state.bridgeStyleImports = new Map();
+                    state.bridgeDependencyCache = new Map();
+                    for (const statement of path.node.body) {
+                        if (!t.isImportDeclaration(statement) || statement.importKind === 'type')
+                            continue;
+                        const file = localModule(state.filename ?? state.file.opts.filename, statement.source.value);
+                        if (file)
+                            for (const specifier of statement.specifiers)
+                                state.bridgeStyleImports.set(specifier.local.name, { file, binding: path.scope.getBinding(specifier.local.name) });
+                    }
+                    const imports = [t.importSpecifier(state.bridgeRevision, t.identifier("registerSourceRevision"))];
+                    if (state.opts.nativewind)
+                        path.unshiftContainer("body", t.importDeclaration([], t.stringLiteral("@nativemason/runtime/nativewind")));
+                    if (state.opts.autoInstrument)
+                        for (const statement of path.node.body) {
+                            if (!t.isImportDeclaration(statement) || statement.source.value !== 'react-native')
+                                continue;
+                            for (const specifier of statement.specifiers) {
+                                if (t.isImportNamespaceSpecifier(specifier)) {
+                                    for (const host of hosts) {
+                                        const alias = path.scope.generateUidIdentifier('NativeMason' + host);
+                                        state.bridgeHosts.set(specifier.local.name + '.' + host, alias);
+                                        state.bridgeKinds.set(specifier.local.name + '.' + host, host);
+                                        state.bridgeBindings.set(specifier.local.name + '.' + host, path.scope.getBinding(specifier.local.name));
+                                        imports.push(t.importSpecifier(alias, t.identifier('Layout' + host)));
+                                    }
+                                    continue;
+                                }
+                                if (!t.isImportSpecifier(specifier) || specifier.importKind === 'type' || statement.importKind === 'type')
+                                    continue;
+                                const name = t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value;
+                                if (!hosts.has(name))
+                                    continue;
+                                const alias = path.scope.generateUidIdentifier(`NativeMason${name}`);
+                                state.bridgeHosts.set(specifier.local.name, alias);
+                                state.bridgeKinds.set(specifier.local.name, name);
+                                state.bridgeBindings.set(specifier.local.name, path.scope.getBinding(specifier.local.name));
+                                imports.push(t.importSpecifier(alias, t.identifier(`Layout${name}`)));
+                            }
+                        }
+                    if (state.opts.rootComponent?.replaceAll('\\', '/') === projectPath) {
+                        state.bridgeRoot = path.scope.generateUidIdentifier('withLayoutRoot');
+                        imports.push(t.importSpecifier(state.bridgeRoot, t.identifier('withLayoutRoot')));
+                    }
+                    if (imports.length)
+                        path.unshiftContainer('body', t.importDeclaration(imports, t.stringLiteral('@nativemason/runtime')));
+                    if (!state.bridgeRoot)
+                        return;
+                    for (const child of path.get('body')) {
+                        if (!child.isExportDefaultDeclaration())
+                            continue;
+                        const declaration = child.node.declaration;
+                        if (t.isTSDeclareFunction(declaration))
+                            throw child.buildCodeFrameError('NativeMason root must have a runtime default export');
+                        const options = t.objectExpression([t.objectProperty(t.identifier('textProbes'), t.booleanLiteral(state.opts.textProbes ?? false))]);
+                        if ((t.isFunctionDeclaration(declaration) || t.isClassDeclaration(declaration)) && declaration.id) {
+                            child.replaceWithMultiple([declaration, t.exportDefaultDeclaration(t.callExpression(state.bridgeRoot, [t.identifier(declaration.id.name), options]))]);
+                        }
+                        else {
+                            const expression = t.isDeclaration(declaration) ? t.toExpression(declaration) : declaration;
+                            child.node.declaration = t.callExpression(state.bridgeRoot, [expression, options]);
+                        }
+                    }
+                },
+                exit(path, state) {
+                    if (!development(state))
+                        return;
+                    const projectPath = filePath(state);
+                    if (state.bridgeRevision && projectPath && !projectPath.startsWith('../'))
+                        path.pushContainer('body', t.expressionStatement(t.callExpression(state.bridgeRevision, [t.stringLiteral(projectPath), t.stringLiteral(createHash('sha256').update(state.file.code).digest('hex'))])));
+                },
+            },
+            JSXOpeningElement(path, state) {
+                if (!development(state))
+                    return;
+                const name = path.node.name;
+                const member = t.isJSXMemberExpression(name) && t.isJSXIdentifier(name.object) && t.isJSXIdentifier(name.property) ? name : null;
+                const localName = t.isJSXIdentifier(name) ? name.name : member && t.isJSXIdentifier(member.object) ? member.object.name : null;
+                if (!localName)
+                    return;
+                const binding = path.scope.getBinding(localName);
+                const lookupName = member ? localName + '.' + member.property.name : localName;
+                const automatic = Boolean(binding && state.opts.autoInstrument && state.bridgeHosts?.has(lookupName) && state.bridgeBindings?.get(lookupName) === binding);
+                let explicit = false;
+                let explicitKind;
+                if (!automatic) {
+                    if (!binding?.path.isImportSpecifier())
+                        return;
+                    const imported = binding.path.node.imported;
+                    const originalName = t.isIdentifier(imported) ? imported.name : imported.value;
+                    const declaration = binding.path.parentPath;
+                    explicitKind = originalName.slice(6);
+                    explicit = Boolean(declaration?.isImportDeclaration() && declaration.node.source.value === '@nativemason/runtime' && originalName.startsWith('Layout') && hosts.has(originalName.slice(6)));
+                }
+                if (!automatic && !explicit)
+                    return;
+                if (path.node.attributes.some(attribute => t.isJSXAttribute(attribute) && ['__bridgeSource', '__bridgeId'].includes(String(attribute.name.name))))
+                    throw path.buildCodeFrameError('__bridgeSource is reserved for source instrumentation');
+                const element = path.parentPath.node;
+                if (!t.isJSXElement(element) || element.start == null || element.end == null || !element.loc)
+                    return;
+                const projectPath = filePath(state);
+                if (!projectPath || projectPath.startsWith('../'))
+                    throw path.buildCodeFrameError('Instrumented file must be inside projectRoot');
+                const dependencies = new Set(), visited = new Set();
+                const inspectExpression = (expression) => {
+                    if (!expression.node || visited.has(expression.node))
+                        return;
+                    visited.add(expression.node);
+                    const inspectIdentifier = (identifier) => {
+                        const binding = identifier.scope.getBinding(identifier.node.name), imported = state.bridgeStyleImports?.get(identifier.node.name);
+                        if (imported && imported.binding === binding) {
+                            let paths = state.bridgeDependencyCache?.get(imported.file);
+                            if (!paths) {
+                                paths = styleModules(imported.file, resolve(state.opts.projectRoot ?? state.file.opts.root ?? process.cwd()));
+                                state.bridgeDependencyCache?.set(imported.file, paths);
+                            }
+                            for (const file of paths)
+                                dependencies.add(file);
+                        }
+                        else if (binding?.path.isVariableDeclarator()) {
+                            const initializer = binding.path.get('init');
+                            if (initializer.node)
+                                inspectExpression(initializer);
+                        }
+                    };
+                    if (expression.isReferencedIdentifier())
+                        inspectIdentifier(expression);
+                    expression.traverse({ ReferencedIdentifier: inspectIdentifier });
+                };
+                for (const attribute of path.get('attributes'))
+                    if (attribute.isJSXAttribute() && t.isJSXIdentifier(attribute.node.name) && ['style', 'className'].includes(attribute.node.name.name)) {
+                        const value = attribute.get('value');
+                        if (value.isJSXExpressionContainer()) {
+                            const expression = value.get('expression');
+                            if (expression.node)
+                                inspectExpression(expression);
+                        }
+                    }
+                const styleAttribute = path.node.attributes.find(attribute => t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name, { name: 'style' }));
+                const callback = (automatic ? state.bridgeKinds?.get(lookupName) : explicitKind) === 'Pressable' && t.isJSXAttribute(styleAttribute) && t.isJSXExpressionContainer(styleAttribute.value) && staticCallback(styleAttribute.value.expression) && !path.node.attributes.some(attribute => t.isJSXSpreadAttribute(attribute));
+                const source = { path: projectPath, ...(callback ? { styleForm: 'pressable-state' } : {}), ...(dependencies.size ? { dependencies: [...dependencies].sort() } : {}), hash: createHash('sha256').update(state.file.code).digest('hex'), start: element.start, end: element.end, line: element.loc.start.line, column: element.loc.start.column };
+                if (automatic) {
+                    const alias = state.bridgeHosts?.get(lookupName);
+                    if (!alias)
+                        return;
+                    path.node.name = t.jsxIdentifier(alias.name);
+                    if (element.closingElement)
+                        element.closingElement.name = t.jsxIdentifier(alias.name);
+                }
+                path.pushContainer('attributes', t.jsxAttribute(t.jsxIdentifier('__bridgeId'), t.stringLiteral(`${projectPath}#${state.bridgeOrdinal = (state.bridgeOrdinal ?? 0) + 1}`)));
+                path.pushContainer('attributes', t.jsxAttribute(t.jsxIdentifier('__bridgeSource'), t.jsxExpressionContainer(t.valueToNode(source))));
+            },
+        },
+    };
+}

package/dist/mcp/index.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { BridgeApplication } from '../application/index.js';
+export declare function createMcpServer(application?: BridgeApplication): McpServer;

package/dist/mcp/index.js

@@ -0,0 +1,42 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { BridgeFault, ToolSchemas, ToolOutputSchemas, ToolMcpOutputSchemas } from '@nativemason/contracts';
+import { BridgeApplication } from '../application/index.js';
+const descriptions = {
+    import_design_intent: 'Convert Figma auto-layout JSON or agent-provided screenshot annotations into a reviewable spec. Does not load or accept design intent.',
+    inspect_accessibility: 'Report authored native accessibility metadata, browser accessibility evidence, and bounded RTL checks with unavailable evidence explicit.',
+    open_session: 'Connect a managed Chromium mirror and selected Android/iOS measurement runtime. Returns native connection port and token.',
+    load_wireframe_spec: 'Load explicit JSON constraints matching the session scenario/profile.',
+    inspect_ui_spatial_graph: 'Capture stable instrumented layout and evaluate constraints. Replaces the trial baseline.',
+    capture_annotated_overlay: 'Capture a matching live Chromium screenshot with numbered element marks and rectangle targets; native snapshots are unsupported.',
+    simulate_layout_mutation: 'Replace the current trial using React Native style props, without source writes. Null patch resets trials.',
+    commit_rn_ast_patch: 'Preview or apply a scoped source transaction. Explicit allowNativePending may defer unavailable native-only text checks; verification remains required.',
+    verify_native_layout: 'Measure committed Android/iOS layout for matching source revisions, scenario, profile, and required interaction state; return evidence and pass/fail.',
+    revert_commit: 'Revert a transaction with source hash checks; native verification remains pending.',
+    find_elements: 'Search measured elements by ID, role, kind, or source path.',
+    infer_constraints: 'Derive a reviewable specification and default findings from a known-good snapshot.',
+    suggest_fix: 'Rank bounded geometry, text-fit, and wrapping candidates using React browser trials across explicit profiles. Optional native baseline seeds proposals, never native trial claims.',
+    run_scenario: 'Reset and execute a typed scenario script.',
+    run_profile_matrix: 'Run scenario profiles and report supported, failed, or unavailable cells.',
+    close_session: 'Close Chromium and native transport and discard session state.',
+};
+export function createMcpServer(application = new BridgeApplication()) {
+    const server = new McpServer({ name: 'nativemason', version: '0.3.0' });
+    server.registerPrompt('layout-workflow', { description: 'Measured layout correction workflow' }, async () => ({ messages: [{ role: 'user', content: { type: 'text', text: 'Open a session for the same named scenario on web and native. Inspect measurements and diagnostics; load or infer and review constraints. Use suggest_fix or batch trials, preview the transaction and blast radius, then apply only an accepted candidate. Verify matching committed revisions on the selected native target. Report unavailable evidence; use revert_commit when requested and verify the revert. Close the session.' } }] }));
+    for (const name of Object.keys(ToolSchemas)) {
+        server.registerTool(name, { description: descriptions[name], inputSchema: ToolSchemas[name].shape, outputSchema: ToolMcpOutputSchemas[name] }, async (input) => {
+            try {
+                const result = await application.execute(name, input);
+                if (name === 'capture_annotated_overlay') {
+                    const { image, ...metadata } = ToolOutputSchemas.capture_annotated_overlay.parse(result);
+                    return { structuredContent: result, content: [{ type: 'image', data: image, mimeType: 'image/png' }, { type: 'text', text: JSON.stringify(metadata) }] };
+                }
+                return { structuredContent: result, content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (error) {
+                const fault = error instanceof BridgeFault ? { code: error.code, message: error.message, details: error.details } : { code: 'INTERNAL_ERROR', message: error instanceof Error ? error.message : String(error) };
+                return { isError: true, content: [{ type: 'text', text: JSON.stringify({ error: fault }) }] };
+            }
+        });
+    }
+    return server;
+}

package/dist/native/index.d.ts

@@ -0,0 +1,4 @@
+import { type NativeConnectionOptions, type NativePort } from '@nativemason/contracts';
+export declare function createNativeBridge(options: NativeConnectionOptions): Promise<NativePort & {
+    close(): Promise<void>;
+}>;