nativemason 0.0.0-stage → 0.3.0

package/dist/editor/transaction-planner.js

@@ -0,0 +1,231 @@
+import { createTwoFilesPatch } from 'diff';
+import { Node, Project, SyntaxKind } from 'ts-morph';
+import { SourceMutationSchema } from '@nativemason/contracts';
+import { isLiteralStyleObject, valueText } from './source-format.js';
+import { hashSource, planSourcePatch } from './planner.js';
+/** All project inputs are supplied by the adapter. Planning never reads or executes application code. */
+export function planTransaction(files, mutations) {
+    try {
+        if (!mutations.length)
+            throw Error('A transaction requires at least one mutation');
+        const project = new Project({ useInMemoryFileSystem: true, skipAddingFilesFromTsConfig: true, compilerOptions: { jsx: 4, allowJs: true, noLib: true } });
+        const originals = new Map(files.map(f => [f.path, f]));
+        for (const file of files)
+            project.createSourceFile('/' + file.path, file.text);
+        const changes = new Map();
+        const blastRadius = { consumers: [], unresolvedReferences: [] };
+        const add = (path, source, after) => {
+            const before = originals.get(path).text;
+            let start = 0;
+            while (start < before.length && start < after.length && before[start] === after[start])
+                start++;
+            let end = before.length, newEnd = after.length;
+            while (end > start && newEnd > start && before[end - 1] === after[newEnd - 1]) {
+                end--;
+                newEnd--;
+            }
+            if (start === end && start === newEnd)
+                return;
+            const entry = changes.get(path) ?? { source, edits: [] };
+            const edit = { start, end, text: after.slice(start, newEnd) };
+            if (entry.edits.some(e => e.start === start && e.end === end && e.text === edit.text))
+                return;
+            if (entry.edits.some(e => Math.max(e.start, start) < Math.min(e.end, end) || (e.start === start && e.end === end)))
+                throw Error('Conflicting mutations target the same source range');
+            entry.edits.push(edit);
+            changes.set(path, entry);
+        };
+        const grouped = new Map();
+        for (const raw of mutations) {
+            const mutation = SourceMutationSchema.parse(raw), key = JSON.stringify([mutation.source, mutation.scope ?? { kind: 'local' }]);
+            const prior = grouped.get(key);
+            if (prior) {
+                for (const [property, value] of Object.entries(mutation.patch)) {
+                    const old = prior.patch[property];
+                    if (old !== undefined && old !== value)
+                        throw Error('Conflicting values target the same style property');
+                }
+                prior.patch = { ...prior.patch, ...mutation.patch };
+            }
+            else
+                grouped.set(key, structuredClone(mutation));
+        }
+        for (const raw of grouped.values()) {
+            const mutation = SourceMutationSchema.parse(raw), file = originals.get(mutation.source.path);
+            if (!file || file.hash !== hashSource(file.text) || file.hash !== mutation.source.hash)
+                return { ok: false, error: { code: 'STALE_SOURCE', message: 'Transaction source revision is unavailable or stale' } };
+            if (mutation.scope?.kind !== 'shared') {
+                const planned = planSourcePatch(file.text, mutation.source, mutation.patch, mutation.scope ?? { kind: 'local' });
+                if (!planned.ok)
+                    return planned;
+                // Reuse the shared-edit discovery as a proof, never as authorization to
+                // widen a local edit. Unknown/shared consumers keep the local override.
+                const ast = project.getSourceFileOrThrow('/' + file.path);
+                const site = ast.getDescendants().find(n => (Node.isJsxElement(n) || Node.isJsxSelfClosingElement(n)) && n.getStart() === mutation.source.start && n.getEnd() === mutation.source.end);
+                const opening = site && (Node.isJsxElement(site) ? site.getOpeningElement() : Node.isJsxSelfClosingElement(site) ? site : undefined);
+                const attribute = opening?.getAttribute('style');
+                const initializer = attribute && Node.isJsxAttribute(attribute) ? attribute.getInitializer() : undefined;
+                const expression = initializer && Node.isJsxExpression(initializer) ? initializer.getExpression() : undefined;
+                const finalExpression = expression && Node.isArrayLiteralExpression(expression) ? expression.getElements().at(-1) : expression;
+                if ((!mutation.scope || mutation.scope.kind === 'local') && finalExpression && (Node.isIdentifier(finalExpression) || Node.isPropertyAccessExpression(finalExpression))) {
+                    const folded = planTransaction(files, [{ ...mutation, scope: { ...mutation.scope, kind: 'shared' } }]);
+                    const consumer = folded.ok && folded.value.blastRadius.consumers.length === 1 ? folded.value.blastRadius.consumers[0] : undefined;
+                    if (folded.ok && consumer && consumer.source.path === mutation.source.path && consumer.source.start === mutation.source.start && consumer.source.end === mutation.source.end && folded.value.files.length === 1) {
+                        const plan = folded.value.files[0], definition = project.getSourceFileOrThrow('/' + plan.source.path).getDescendants().find(n => Node.isObjectLiteralExpression(n) && n.getStart() === plan.source.start);
+                        if (definition && Node.isObjectLiteralExpression(definition) && safeAutomaticDefinition(definition, project)) {
+                            add(plan.source.path, plan.source, plan.updatedText);
+                            blastRadius.consumers.push(consumer);
+                            continue;
+                        }
+                    }
+                }
+                add(file.path, mutation.source, planned.value.updatedText);
+                blastRadius.consumers.push({ source: mutation.source, mountedIds: [], requiredScenarios: [] });
+                continue;
+            }
+            const ast = project.getSourceFileOrThrow('/' + file.path);
+            const site = ast.getDescendants().find(n => (Node.isJsxElement(n) || Node.isJsxSelfClosingElement(n)) && n.getStart() === mutation.source.start && n.getEnd() === mutation.source.end);
+            if (!site || (!Node.isJsxElement(site) && !Node.isJsxSelfClosingElement(site)))
+                return { ok: false, error: { code: 'STALE_SOURCE', message: 'Shared mutation no longer identifies its JSX source' } };
+            const opening = Node.isJsxElement(site) ? site.getOpeningElement() : site;
+            const attr = opening.getAttribute('style');
+            if (!attr || !Node.isJsxAttribute(attr))
+                throw Error('Shared editing requires a style expression');
+            const initializer = attr.getInitializer();
+            if (!initializer || !Node.isJsxExpression(initializer) || !initializer.getExpression())
+                throw Error('Shared editing requires a style expression');
+            const initialExpression = initializer.getExpression();
+            const finalExpression = Node.isArrayLiteralExpression(initialExpression) ? initialExpression.getElements().at(-1) : initialExpression;
+            if (!finalExpression || !Node.isExpression(finalExpression))
+                throw Error('Shared editing requires a final style expression');
+            const expression = finalExpression;
+            function resolveObject(expr) {
+                if (Node.isObjectLiteralExpression(expr))
+                    return expr;
+                if (Node.isIdentifier(expr)) {
+                    const symbol = expr.getSymbol()?.getAliasedSymbol() ?? expr.getSymbol();
+                    const declaration = symbol?.getDeclarations().find(Node.isVariableDeclaration);
+                    const value = declaration?.getInitializer();
+                    if (value)
+                        return resolveObject(value);
+                }
+                if (Node.isPropertyAccessExpression(expr)) {
+                    const base = resolveObject(expr.getExpression());
+                    const property = base.getProperty(expr.getName());
+                    if (property && Node.isPropertyAssignment(property) && property.getInitializer())
+                        return resolveObject(property.getInitializer());
+                }
+                if (Node.isCallExpression(expr) && Node.isPropertyAccessExpression(expr.getExpression()) && expr.getExpression().getText().endsWith('.create')) {
+                    const owner = expr.getExpression();
+                    const base = owner.getExpression();
+                    if (!Node.isIdentifier(base) || !base.getSymbol()?.getDeclarations().some(d => Node.isImportSpecifier(d) && d.getImportDeclaration().getModuleSpecifierValue() === 'react-native' && d.getName() === 'StyleSheet'))
+                        throw Error('Untrusted stylesheet factory');
+                    const arg = expr.getArguments()[0];
+                    if (arg && Node.isObjectLiteralExpression(arg))
+                        return arg;
+                }
+                throw Error('Shared definition cannot be resolved statically');
+            }
+            const object = resolveObject(expression), targetFile = object.getSourceFile(), relative = targetFile.getFilePath().slice(1), original = originals.get(relative);
+            if (!original)
+                throw Error('Shared definition is outside supplied project sources');
+            // Resolve property-access references rather than assuming equal text means equal binding.
+            let references = 0;
+            for (const candidate of project.getSourceFiles())
+                for (const node of candidate.getDescendants()) {
+                    if (!Node.isPropertyAccessExpression(node) && !Node.isIdentifier(node))
+                        continue;
+                    try {
+                        if (resolveObject(node) !== object)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const parent = node.getParent();
+                    if (parent && (Node.isPropertyAccessExpression(parent) && parent.getExpression() === node)) {
+                        try {
+                            resolveObject(parent);
+                            continue;
+                        }
+                        catch {
+                            blastRadius.unresolvedReferences.push(candidate.getFilePath().slice(1) + ':' + parent.getStart());
+                            continue;
+                        }
+                    }
+                    if (Node.isVariableDeclaration(parent)) {
+                        if (parent.getInitializer() === node)
+                            blastRadius.unresolvedReferences.push(candidate.getFilePath().slice(1) + ':' + node.getStart());
+                        continue;
+                    }
+                    const jsx = node.getAncestors().find(n => Node.isJsxElement(n) || Node.isJsxSelfClosingElement(n));
+                    if (!jsx) {
+                        blastRadius.unresolvedReferences.push(candidate.getFilePath().slice(1) + ':' + node.getStart());
+                        continue;
+                    }
+                    references++;
+                    const location = candidate.getLineAndColumnAtPos(jsx.getStart());
+                    blastRadius.consumers.push({ source: { path: candidate.getFilePath().slice(1), hash: hashSource(candidate.getFullText()), start: jsx.getStart(), end: jsx.getEnd(), line: location.line, column: location.column - 1 }, mountedIds: [], requiredScenarios: [] });
+                }
+            if (!references || blastRadius.unresolvedReferences.length)
+                return { ok: false, error: { code: 'UNSUPPORTED_EDIT', message: 'Shared definition has unresolved or escaping consumers', details: blastRadius } };
+            for (const prop of object.getProperties())
+                if (!Node.isPropertyAssignment(prop) || prop.getNameNode().getKind() === SyntaxKind.ComputedPropertyName)
+                    throw Error('Shared definitions with spreads or computed keys are unsupported');
+            // Modify an isolated copy so subsequent mutations continue to use original AST offsets.
+            const copyProject = new Project({ useInMemoryFileSystem: true });
+            const copy = copyProject.createSourceFile('/copy.tsx', original.text);
+            const copyObject = copy.getDescendants().find(n => Node.isObjectLiteralExpression(n) && n.getStart() === object.getStart());
+            if (!copyObject || !Node.isObjectLiteralExpression(copyObject))
+                throw Error('Shared source mapping failed');
+            for (const [key, value] of Object.entries(mutation.patch)) {
+                if (value === undefined)
+                    continue;
+                const prop = copyObject.getProperty(key);
+                if (prop && Node.isPropertyAssignment(prop))
+                    prop.setInitializer(valueText(value, copy, prop.getInitializer()));
+                else
+                    copyObject.addPropertyAssignment({ name: key, initializer: valueText(value, copy) });
+            }
+            const location = targetFile.getLineAndColumnAtPos(object.getStart());
+            add(relative, { path: relative, hash: original.hash, start: object.getStart(), end: object.getEnd(), line: location.line, column: location.column - 1 }, copy.getFullText());
+        }
+        const plans = [...changes].sort(([a], [b]) => a.localeCompare(b)).map(([path, { source, edits }]) => {
+            const original = originals.get(path);
+            let updatedText = original.text;
+            for (const edit of edits.sort((a, b) => b.start - a.start))
+                updatedText = updatedText.slice(0, edit.start) + edit.text + updatedText.slice(edit.end);
+            return { source, expectedHash: original.hash, updatedText, diff: createTwoFilesPatch(path, path, original.text, updatedText) };
+        });
+        if (!plans.length)
+            throw Error('Transaction would not change source');
+        return { ok: true, value: { files: plans, blastRadius } };
+    }
+    catch (error) {
+        return { ok: false, error: { code: 'UNSUPPORTED_EDIT', message: error instanceof Error ? error.message : String(error) } };
+    }
+}
+/** Exported StyleSheet containers may only be used through known property access. */
+function safeAutomaticDefinition(object, project) {
+    if (!isLiteralStyleObject(object))
+        return false;
+    const declaration = object.getAncestors().find(Node.isVariableDeclaration);
+    if (!declaration || declaration.getInitializer() === object)
+        return true;
+    const symbol = declaration.getSymbol();
+    if (!symbol)
+        return false;
+    for (const file of project.getSourceFiles())
+        for (const id of file.getDescendantsOfKind(SyntaxKind.Identifier)) {
+            const target = id.getSymbol()?.getAliasedSymbol() ?? id.getSymbol();
+            if (target !== symbol || id === declaration.getNameNode())
+                continue;
+            const parent = id.getParent();
+            if (Node.isImportSpecifier(parent) || Node.isExportSpecifier(parent))
+                continue;
+            if (Node.isPropertyAccessExpression(parent) && parent.getExpression() === id)
+                continue;
+            return false;
+        }
+    return true;
+}

package/dist/editor/transaction-port.d.ts

@@ -0,0 +1,3 @@
+import { type TransactionSourcePort } from '@nativemason/contracts';
+/** Recoverable multi-file replacement. Journals persist until apply or rollback completes. */
+export declare function createTransactionSourcePort(projectRoot: string): TransactionSourcePort;

package/dist/editor/transaction-port.js

@@ -0,0 +1,257 @@
+import { randomUUID } from 'node:crypto';
+import { mkdir, open, readFile, rename, unlink, readdir, realpath, lstat } from 'node:fs/promises';
+import path from 'node:path';
+import { createTwoFilesPatch } from 'diff';
+import { BridgeFault, TransactionPlanSchema, TransactionReceiptSchema } from '@nativemason/contracts';
+import { createSourcePort } from './source-port.js';
+import { hashSource } from './planner.js';
+const ignore = new Set(['node_modules', '.git', '.nativemason', 'artifacts', 'dist', 'build', '.expo', 'android', 'ios']);
+/** Recoverable multi-file replacement. Journals persist until apply or rollback completes. */
+export function createTransactionSourcePort(projectRoot) {
+    const base = createSourcePort(projectRoot);
+    const rootPromise = realpath(projectRoot);
+    let queue = Promise.resolve();
+    async function control() { const root = await rootPromise; const dir = path.join(root, '.nativemason'); await mkdir(dir, { recursive: true, mode: 0o700 }); if ((await realpath(dir)) !== dir)
+        throw new BridgeFault('SOURCE_OUTSIDE_PROJECT', 'Transaction storage must not be a symlink'); return dir; }
+    async function source(relative) {
+        await base.read(relative);
+        const root = await rootPromise;
+        const file = path.resolve(root, relative);
+        if ((await realpath(file)) !== file)
+            throw new BridgeFault('UNSUPPORTED_EDIT', 'Transactions do not replace symlink sources');
+        return file;
+    }
+    async function persist(file, value) { const temporary = file + '.' + randomUUID() + '.tmp'; const handle = await open(temporary, 'wx', 0o600); try {
+        await handle.writeFile(JSON.stringify(value));
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    } await rename(temporary, file); }
+    async function remove(file) { await unlink(file).catch(error => { if (error.code !== 'ENOENT')
+        throw error; }); }
+    async function syncDirectory(dir) { const handle = await open(dir, 'r'); try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    } }
+    async function recoverUnlocked(dir) {
+        for (const filename of await readdir(dir)) {
+            if (!filename.endsWith('.journal.json'))
+                continue;
+            const journalPath = path.join(dir, filename);
+            const journal = JSON.parse(await readFile(journalPath, 'utf8'));
+            if (journal.state === 'committed') {
+                await persist(path.join(dir, journal.id + '.receipt.json'), { receipt: journal.receipt, files: journal.files });
+                await syncDirectory(dir);
+                await remove(journalPath);
+                await syncDirectory(dir);
+                continue;
+            }
+            for (const item of [...journal.files].reverse()) {
+                const file = await source(item.path), current = await readFile(file, 'utf8');
+                if (path.dirname(item.temporary) !== path.dirname(file) || !path.basename(item.temporary).startsWith(path.basename(file) + '.') || !item.temporary.endsWith('.stage'))
+                    throw new BridgeFault('INVALID_INPUT', 'Invalid recovery staging path');
+                if (hashSource(current) === hashSource(item.before)) {
+                    await remove(item.temporary);
+                    continue;
+                }
+                if (hashSource(current) !== hashSource(item.after))
+                    throw new BridgeFault('STALE_SOURCE', 'Transaction recovery conflicts with external edits', { transactionId: journal.id, path: item.path });
+                const temp = file + '.' + randomUUID() + '.rollback';
+                const rollback = await open(temp, 'wx', item.mode);
+                try {
+                    await rollback.writeFile(item.before);
+                    await rollback.chmod(item.mode);
+                    await rollback.sync();
+                }
+                finally {
+                    await rollback.close();
+                }
+                await rename(temp, file);
+                await syncDirectory(path.dirname(file));
+                await remove(item.temporary);
+            }
+            await remove(journalPath);
+        }
+    }
+    async function locked(operation) {
+        const work = async () => {
+            const dir = await control(), lock = path.join(dir, 'transaction.lock');
+            try {
+                const handle = await open(lock, 'wx', 0o600);
+                try {
+                    await handle.writeFile(JSON.stringify({ pid: process.pid }));
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            catch (error) {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                const recovery = path.join(dir, 'transaction.recovery.lock');
+                let recoveryHandle;
+                try {
+                    recoveryHandle = await open(recovery, 'wx', 0o600);
+                    await recoveryHandle.writeFile(JSON.stringify({ pid: process.pid }));
+                    await recoveryHandle.sync();
+                    await recoveryHandle.close();
+                    recoveryHandle = undefined;
+                }
+                catch (cause) {
+                    const created = recoveryHandle !== undefined;
+                    await recoveryHandle?.close().catch(() => undefined);
+                    if (created)
+                        await remove(recovery).catch(() => undefined);
+                    if (cause.code === 'EEXIST' && !created)
+                        throw new BridgeFault('RECOVERY_CONFLICT', 'Transaction recovery is locked; inspect .nativemason/transaction.recovery.lock for its owner before retrying');
+                    throw cause;
+                }
+                try {
+                    let owner;
+                    try {
+                        const decoded = JSON.parse(await readFile(lock, 'utf8'));
+                        if (!decoded || typeof decoded !== 'object' || Array.isArray(decoded) || !Number.isSafeInteger(decoded.pid) || (decoded.pid <= 0))
+                            throw new Error('Invalid lock owner');
+                        owner = decoded;
+                    }
+                    catch (cause) {
+                        if (cause.code !== 'ENOENT')
+                            throw new BridgeFault('INTERNAL_ERROR', 'Transaction lock is unreadable; recovery requires checking the owning process');
+                    }
+                    if (owner) {
+                        try {
+                            process.kill(owner.pid, 0);
+                            throw new BridgeFault('INVALID_INPUT', 'Another source transaction is active');
+                        }
+                        catch (cause) {
+                            if (cause instanceof BridgeFault)
+                                throw cause;
+                            if (cause.code !== 'ESRCH')
+                                throw cause;
+                        }
+                        await remove(lock);
+                    }
+                }
+                finally {
+                    await remove(recovery);
+                }
+                return work();
+            }
+            try {
+                await recoverUnlocked(dir);
+                return await operation(dir);
+            }
+            finally {
+                await remove(lock);
+            }
+        };
+        const result = queue.then(work, work);
+        queue = result.catch(() => undefined);
+        return result;
+    }
+    async function applyUnlocked(plan, dir, revertsCommitId) {
+        const parsed = TransactionPlanSchema.safeParse(plan);
+        if (!parsed.success)
+            throw new BridgeFault('INVALID_INPUT', 'Invalid transaction plan');
+        const paths = plan.files.map(f => f.source.path);
+        if (new Set(paths).size !== paths.length)
+            throw new BridgeFault('INVALID_INPUT', 'A transaction must coalesce each source file');
+        const id = hashSource(JSON.stringify([plan.intentId ?? null, plan.files.map(f => [f.source.path, f.expectedHash, hashSource(f.updatedText)])]));
+        const receiptPath = path.join(dir, id + '.receipt.json');
+        try {
+            const prior = JSON.parse(await readFile(receiptPath, 'utf8'));
+            for (const file of prior.receipt.files)
+                if ((await base.read(file.path)).hash !== file.newHash)
+                    throw new BridgeFault('STALE_SOURCE', 'Previously committed transaction source changed');
+            return TransactionReceiptSchema.parse(prior.receipt);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+        const files = [];
+        for (const planFile of plan.files) {
+            if (planFile.source.hash !== planFile.expectedHash)
+                throw new BridgeFault('INVALID_INPUT', 'Source and expected hashes disagree');
+            const file = await source(planFile.source.path), before = await readFile(file, 'utf8');
+            if (hashSource(before) !== planFile.expectedHash)
+                throw new BridgeFault('STALE_SOURCE', 'Source changed before transaction', { path: planFile.source.path });
+            files.push({ path: planFile.source.path, before, after: planFile.updatedText, mode: (await lstat(file)).mode & 0o777, temporary: file + '.' + randomUUID() + '.stage' });
+        }
+        const receipt = { commitId: id, files: plan.files.map(f => ({ path: f.source.path, oldHash: f.expectedHash, newHash: hashSource(f.updatedText), diff: f.diff })), nativeStatus: 'pending', ...(revertsCommitId ? { revertsCommitId } : {}) };
+        const journal = { id, state: 'prepared', files, receipt }, journalPath = path.join(dir, id + '.journal.json');
+        await persist(journalPath, journal);
+        await syncDirectory(dir);
+        try {
+            for (const item of files) {
+                const handle = await open(item.temporary, 'wx', item.mode);
+                try {
+                    await handle.writeFile(item.after);
+                    await handle.chmod(item.mode);
+                    await handle.sync();
+                }
+                finally {
+                    await handle.close();
+                }
+            }
+            // Preflight the complete set again before the first replacement.
+            for (const item of files)
+                if ((await base.read(item.path)).hash !== hashSource(item.before))
+                    throw new BridgeFault('STALE_SOURCE', 'Source changed while staging', { path: item.path });
+            for (const item of files) {
+                const file = await source(item.path);
+                if (hashSource(await readFile(file, 'utf8')) !== hashSource(item.before))
+                    throw new BridgeFault('STALE_SOURCE', 'Source changed during transaction', { path: item.path });
+                await rename(item.temporary, file);
+                await syncDirectory(path.dirname(file));
+            }
+            journal.state = 'committed';
+            await persist(journalPath, journal);
+            await syncDirectory(dir);
+            await persist(receiptPath, { receipt, files });
+            await syncDirectory(dir);
+            await remove(journalPath);
+            await syncDirectory(dir);
+            return receipt;
+        }
+        catch (error) {
+            await recoverUnlocked(dir);
+            throw error;
+        }
+    }
+    return { ...base,
+        read: async (relative) => { await locked(async () => { }); return base.read(relative); },
+        apply: async (plan) => { const receipt = await locked(dir => applyUnlocked({ files: [plan], blastRadius: { consumers: [], unresolvedReferences: [] } }, dir)); const file = receipt.files[0]; return { commitId: receipt.commitId, ...file, nativeStatus: receipt.nativeStatus, files: receipt.files }; },
+        readProject: async () => {
+            await locked(async () => { });
+            const root = await rootPromise;
+            const files = [];
+            const visit = async (dir) => { for (const entry of await readdir(dir, { withFileTypes: true })) {
+                if (ignore.has(entry.name) || entry.isSymbolicLink())
+                    continue;
+                const absolute = path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    await visit(absolute);
+                else if (/\.[cm]?[jt]sx?$/.test(entry.name)) {
+                    const relative = path.relative(root, absolute).split(path.sep).join('/');
+                    files.push(await base.read(relative));
+                }
+            } };
+            await visit(root);
+            return files;
+        },
+        applyTransaction: plan => locked(dir => applyUnlocked(plan, dir)),
+        recover: () => locked(async () => { }),
+        revert: commitId => locked(async (dir) => {
+            if (!/^[a-f0-9]{64}$/.test(commitId))
+                throw new BridgeFault('INVALID_INPUT', 'Invalid transaction commit ID');
+            const stored = JSON.parse(await readFile(path.join(dir, commitId + '.receipt.json'), 'utf8'));
+            const files = stored.files.map(item => { const current = stored.receipt.files.find(f => f.path === item.path); return { source: { path: item.path, hash: current.newHash, start: 0, end: 1, line: 1, column: 0 }, expectedHash: current.newHash, updatedText: item.before, diff: createTwoFilesPatch(item.path, item.path, item.after, item.before) }; });
+            return applyUnlocked({ intentId: 'revert:' + commitId, files, blastRadius: { consumers: [], unresolvedReferences: [] } }, dir, commitId);
+        }),
+    };
+}

package/dist/evidence/report.d.ts

@@ -0,0 +1,4 @@
+import { type EvidenceInputs, type VisualEvidenceReport } from '@nativemason/contracts';
+export declare function buildEvidenceReport(rawInput: EvidenceInputs): VisualEvidenceReport;
+export declare function renderEvidenceHtml(report: VisualEvidenceReport): string;
+export declare function renderEvidenceSummary(report: VisualEvidenceReport): string;