@superdoc/sdk 2.10.0-next.7 → 2.10.0-next.9

package/dist/agent/catalog.js

@@ -143,6 +143,11 @@ export const ACTION_ARG_SCHEMA = {
     },
     finds: { type: 'array', items: { type: 'string' } },
     caseSensitive: { type: 'boolean' },
+    evidence: {
+        type: 'string',
+        enum: ['required', 'full'],
+        description: 'Required evidence by default; full includes complete count summaries.',
+    },
     changeMode: { type: 'string', enum: ['direct', 'tracked'] },
     placement: { type: 'object', additionalProperties: true, properties: {} },
     selector: SELECTOR_SCHEMA,
@@ -387,6 +392,11 @@ export const AGENT_TOOL_DEFINITIONS = [
             additionalProperties: false,
             required: ['plan'],
             properties: {
+                evidence: {
+                    type: 'string',
+                    enum: ['required', 'full'],
+                    description: 'Required evidence by default; full includes complete count summaries.',
+                },
                 plan: {
                     type: 'object',
                     additionalProperties: false,
@@ -425,6 +435,11 @@ export const AGENT_TOOL_DEFINITIONS = [
             additionalProperties: false,
             required: ['checks'],
             properties: {
+                evidence: {
+                    type: 'string',
+                    enum: ['required', 'full'],
+                    description: 'Required evidence by default; full includes complete count summaries.',
+                },
                 checks: {
                     type: 'array',
                     minItems: 1,

package/dist/agent/doc-snapshot.cjs

@@ -159,57 +159,33 @@ async function buildDocumentSnapshot(doc, options = {}) {
     // first match so one call both LOCATES and READS the target section.
     let finds;
     if (typeof options.findText === 'string' && options.findText.trim().length > 0) {
-        const scanFn = maybeMethod(doc, ['blocks', 'list']);
+        const scanFn = maybeMethod(doc, ['blocks', 'findText']);
         if (scanFn) {
-            // Paginated scan with a hard cap: bounded bridge payloads per page, and
-            // an explicit truncated flag instead of a silently-partial `total`.
-            const SCAN_PAGE = 2000;
-            const SCAN_CAP = 20000;
-            const needle = options.findText.toLowerCase();
             const findLimit = options.findLimit != null && options.findLimit > 0 ? options.findLimit : 8;
-            const matches = [];
-            let scanned = 0;
-            let truncated = false;
-            for (let pageOffset = 0; pageOffset < SCAN_CAP; pageOffset += SCAN_PAGE) {
-                const scanRaw = await safeCall(() => scanFn({ offset: pageOffset, limit: SCAN_PAGE, includeText: true }), null, recordError('blocks.findText'));
-                const scanRec = asRecord(scanRaw);
-                const scanBlocks = Array.isArray(scanRec?.blocks) ? scanRec.blocks : [];
-                scanBlocks.forEach((b, i) => {
-                    const rec = asRecord(b) ?? {};
-                    const text = asString(rec.text);
-                    if (!text || !text.toLowerCase().includes(needle))
-                        return;
-                    matches.push({
-                        ordinal: asNumber(rec.ordinal, pageOffset + i) + 1,
-                        nodeId: asString(rec.nodeId),
-                        nodeType: asString(rec.nodeType, 'paragraph'),
-                        preview: text.slice(0, 100),
-                        index: asNumber(rec.ordinal, pageOffset + i),
-                    });
-                });
-                scanned += scanBlocks.length;
-                const totalBlocksReported = explicitCount(scanRec ?? {}, 'total');
-                if (scanBlocks.length < SCAN_PAGE)
-                    break; // last page
-                if (totalBlocksReported != null && scanned >= totalBlocksReported)
-                    break;
-                if (pageOffset + SCAN_PAGE >= SCAN_CAP) {
-                    truncated = true;
-                    break;
-                }
-            }
+            const scanRaw = await safeCall(() => scanFn({ text: options.findText, limit: Math.min(20000, Math.trunc(findLimit)) }), null, recordError('blocks.findText'));
+            const scan = asRecord(scanRaw);
+            const scanError = asRecord(scan?.scanError);
+            if (typeof scanError?.message === 'string')
+                recordError('blocks.findText')(scanError.message);
+            const matches = Array.isArray(scan?.matches) ? scan.matches : [];
             finds = {
                 query: options.findText,
-                total: matches.length,
-                ...(truncated ? { truncated: true } : {}),
-                scannedBlocks: scanned,
-                matches: matches.slice(0, findLimit).map(({ index: _index, nodeId, ...m }) => ({
-                    ...m,
-                    ...(nodeId ? { nodeId } : {}),
-                })),
+                total: asNumber(scan?.total),
+                ...(scan?.truncated === true ? { truncated: true } : {}),
+                scannedBlocks: asNumber(scan?.scannedBlocks),
+                matches: matches.map((match) => {
+                    const rec = asRecord(match) ?? {};
+                    const nodeId = asString(rec.nodeId);
+                    return {
+                        ordinal: asNumber(rec.ordinal) + 1,
+                        ...(nodeId ? { nodeId } : {}),
+                        nodeType: asString(rec.nodeType, 'paragraph'),
+                        preview: asString(rec.preview),
+                    };
+                }),
             };
-            if (matches.length > 0 && options.blockOffset == null) {
-                blockOffset = Math.max(0, matches[0].index - 2);
+            if (typeof scan?.firstMatchOrdinal === 'number' && options.blockOffset == null) {
+                blockOffset = Math.max(0, scan.firstMatchOrdinal - 2);
                 blockLimit = options.blockLimit != null && options.blockLimit > 0 ? options.blockLimit : 12;
             }
         }

package/dist/agent/doc-snapshot.js

@@ -157,57 +157,33 @@ export async function buildDocumentSnapshot(doc, options = {}) {
     // first match so one call both LOCATES and READS the target section.
     let finds;
     if (typeof options.findText === 'string' && options.findText.trim().length > 0) {
-        const scanFn = maybeMethod(doc, ['blocks', 'list']);
+        const scanFn = maybeMethod(doc, ['blocks', 'findText']);
         if (scanFn) {
-            // Paginated scan with a hard cap: bounded bridge payloads per page, and
-            // an explicit truncated flag instead of a silently-partial `total`.
-            const SCAN_PAGE = 2000;
-            const SCAN_CAP = 20000;
-            const needle = options.findText.toLowerCase();
             const findLimit = options.findLimit != null && options.findLimit > 0 ? options.findLimit : 8;
-            const matches = [];
-            let scanned = 0;
-            let truncated = false;
-            for (let pageOffset = 0; pageOffset < SCAN_CAP; pageOffset += SCAN_PAGE) {
-                const scanRaw = await safeCall(() => scanFn({ offset: pageOffset, limit: SCAN_PAGE, includeText: true }), null, recordError('blocks.findText'));
-                const scanRec = asRecord(scanRaw);
-                const scanBlocks = Array.isArray(scanRec?.blocks) ? scanRec.blocks : [];
-                scanBlocks.forEach((b, i) => {
-                    const rec = asRecord(b) ?? {};
-                    const text = asString(rec.text);
-                    if (!text || !text.toLowerCase().includes(needle))
-                        return;
-                    matches.push({
-                        ordinal: asNumber(rec.ordinal, pageOffset + i) + 1,
-                        nodeId: asString(rec.nodeId),
-                        nodeType: asString(rec.nodeType, 'paragraph'),
-                        preview: text.slice(0, 100),
-                        index: asNumber(rec.ordinal, pageOffset + i),
-                    });
-                });
-                scanned += scanBlocks.length;
-                const totalBlocksReported = explicitCount(scanRec ?? {}, 'total');
-                if (scanBlocks.length < SCAN_PAGE)
-                    break; // last page
-                if (totalBlocksReported != null && scanned >= totalBlocksReported)
-                    break;
-                if (pageOffset + SCAN_PAGE >= SCAN_CAP) {
-                    truncated = true;
-                    break;
-                }
-            }
+            const scanRaw = await safeCall(() => scanFn({ text: options.findText, limit: Math.min(20000, Math.trunc(findLimit)) }), null, recordError('blocks.findText'));
+            const scan = asRecord(scanRaw);
+            const scanError = asRecord(scan?.scanError);
+            if (typeof scanError?.message === 'string')
+                recordError('blocks.findText')(scanError.message);
+            const matches = Array.isArray(scan?.matches) ? scan.matches : [];
             finds = {
                 query: options.findText,
-                total: matches.length,
-                ...(truncated ? { truncated: true } : {}),
-                scannedBlocks: scanned,
-                matches: matches.slice(0, findLimit).map(({ index: _index, nodeId, ...m }) => ({
-                    ...m,
-                    ...(nodeId ? { nodeId } : {}),
-                })),
+                total: asNumber(scan?.total),
+                ...(scan?.truncated === true ? { truncated: true } : {}),
+                scannedBlocks: asNumber(scan?.scannedBlocks),
+                matches: matches.map((match) => {
+                    const rec = asRecord(match) ?? {};
+                    const nodeId = asString(rec.nodeId);
+                    return {
+                        ordinal: asNumber(rec.ordinal) + 1,
+                        ...(nodeId ? { nodeId } : {}),
+                        nodeType: asString(rec.nodeType, 'paragraph'),
+                        preview: asString(rec.preview),
+                    };
+                }),
             };
-            if (matches.length > 0 && options.blockOffset == null) {
-                blockOffset = Math.max(0, matches[0].index - 2);
+            if (typeof scan?.firstMatchOrdinal === 'number' && options.blockOffset == null) {
+                blockOffset = Math.max(0, scan.firstMatchOrdinal - 2);
                 blockLimit = options.blockLimit != null && options.blockLimit > 0 ? options.blockLimit : 12;
             }
         }

package/dist/agent/execution-context.cjs

@@ -0,0 +1,385 @@
+'use strict';
+
+var documentEvidence = require('../runtime/document-evidence.cjs');
+var errors = require('../runtime/errors.cjs');
+var docSnapshot = require('./doc-snapshot.cjs');
+var operationCatalog = require('./operation-catalog.cjs');
+
+function supportsLocalSelector(selector) {
+    return (selector.kind === 'nodeId' ||
+        selector.kind === 'textSearch' ||
+        selector.kind === 'placement' ||
+        (selector.kind === 'ordinal' &&
+            ['blockOrdinal', 'headingOrdinal', 'tableOrdinal'].includes(selector.ordinalKind)) ||
+        (selector.kind === 'relative' && supportsLocalSelector(selector.target)));
+}
+function localCheck(check) {
+    return (['revision-changed', 'revision-unchanged', 'block-text-contains', 'block-text-equals', 'table-shape'].includes(check.kind) ||
+        (check.kind === 'block-count-delta' && ['paragraph', 'heading', 'listItem', 'table'].includes(check.nodeType)));
+}
+async function readPublicRevision(doc) {
+    const revision = await documentEvidence.getDocumentRevisionReader(doc)?.();
+    if (revision !== undefined)
+        return revision;
+    const page = await doc.blocks.list({ offset: Number.MAX_SAFE_INTEGER, limit: 1 });
+    if (!page.revision || page.revision === 'unknown')
+        throw new errors.SuperDocCliError('Required document revision is unavailable.', { code: 'EVIDENCE_UNAVAILABLE' });
+    return page.revision;
+}
+class DocumentFacts {
+    doc;
+    revision;
+    complete;
+    summaryCounts;
+    blocks = new Map();
+    counts = new Map();
+    selections = new Map();
+    constructor(doc, revision, complete, summaryCounts = complete?.counts) {
+        this.doc = doc;
+        this.revision = revision;
+        this.complete = complete;
+        this.summaryCounts = summaryCounts;
+    }
+    get summary() {
+        return { revision: this.revision, ...(this.summaryCounts ? { counts: this.summaryCounts } : {}) };
+    }
+    async fence() {
+        if ((await readPublicRevision(this.doc)) !== this.revision)
+            throw new errors.SuperDocCliError('Document changed while acquiring execution evidence.', { code: 'REVISION_CONFLICT' });
+    }
+    async page(input) {
+        const result = await this.doc.blocks.list({ ...input, includeText: true });
+        if (result.revision !== this.revision)
+            throw new errors.SuperDocCliError('Document changed while resolving a target.', { code: 'REVISION_CONFLICT' });
+        const blocks = result.blocks.map((block) => ({
+            ...block,
+            ordinal: block.ordinal + 1,
+            text: block.text ?? '',
+            textPreview: block.textPreview ?? null,
+            styleId: block.styleId ?? null,
+        }));
+        for (const block of blocks)
+            this.blocks.set(block.nodeId, block);
+        return blocks;
+    }
+    async count(nodeType) {
+        const key = nodeType ?? '*';
+        if (this.counts.has(key))
+            return this.counts.get(key);
+        if (this.complete)
+            return nodeType
+                ? this.complete.blocks.filter((block) => block.nodeType === nodeType).length
+                : this.complete.blocks.length;
+        const result = await this.doc.blocks.list({
+            offset: Number.MAX_SAFE_INTEGER,
+            limit: 1,
+            ...(nodeType ? { nodeTypes: [nodeType] } : {}),
+        });
+        if (result.revision !== this.revision || !Number.isSafeInteger(result.total))
+            throw new errors.SuperDocCliError('Required count is unavailable at the execution revision.', {
+                code: 'EVIDENCE_UNAVAILABLE',
+            });
+        this.counts.set(key, result.total);
+        return result.total;
+    }
+    async block(nodeId) {
+        if (this.complete)
+            return this.complete.blocks.find((block) => block.nodeId === nodeId);
+        if (!this.blocks.has(nodeId))
+            await this.page({ nodeIds: [nodeId], limit: 1 });
+        return this.blocks.get(nodeId);
+    }
+    async select(selector) {
+        if (this.complete)
+            return docSnapshot.resolveSnapshotSelector(this.complete, selector);
+        const key = JSON.stringify(selector);
+        if (this.selections.has(key))
+            return this.selections.get(key);
+        let blocks = [];
+        if (selector.kind === 'nodeId') {
+            const block = await this.block(selector.nodeId);
+            if (block)
+                blocks = [block];
+        }
+        else if (selector.kind === 'textSearch') {
+            const terms = selector.terms.filter((term) => term.trim());
+            if (terms.length && selector.nodeTypes?.length !== 0)
+                blocks = await this.page({
+                    textSearch: { terms: [...terms], match: selector.match, caseSensitive: selector.caseSensitive },
+                    nodeTypes: [...(selector.nodeTypes ?? ['paragraph', 'heading', 'listItem'])],
+                    offset: (selector.occurrence ?? 1) - 1,
+                    limit: 1,
+                });
+        }
+        else if (selector.kind === 'placement') {
+            const offset = selector.at === 'document_start' ? 0 : (await this.count()) - 1;
+            if (offset >= 0)
+                blocks = await this.page({ offset, limit: 1 });
+        }
+        else if (selector.kind === 'ordinal') {
+            blocks = await this.page({
+                offset: selector.value - 1,
+                limit: 1,
+                ...(selector.ordinalKind === 'headingOrdinal'
+                    ? { nodeTypes: ['heading'] }
+                    : selector.ordinalKind === 'tableOrdinal'
+                        ? { nodeTypes: ['table'] }
+                        : {}),
+            });
+        }
+        else if (selector.kind === 'relative') {
+            for (const id of await this.select(selector.target)) {
+                const target = await this.block(id);
+                const offset = target ? target.ordinal - 1 + (selector.position === 'before' ? -1 : 1) : -1;
+                if (offset >= 0)
+                    blocks.push(...(await this.page({ offset, limit: 1 })));
+            }
+        }
+        else
+            throw new errors.SuperDocCliError('Selector requires complete evidence.', { code: 'EVIDENCE_UNAVAILABLE' });
+        const ids = [...new Set(blocks.map((block) => block.nodeId))];
+        this.selections.set(key, ids);
+        return ids;
+    }
+    async target(selector) {
+        const ids = await this.select(selector);
+        if (this.complete && selector.kind === 'tableCell' && ids.length === 1) {
+            const cell = this.complete.tables.flatMap((table) => table.cells).find((cell) => cell.nodeId === ids[0]);
+            if (cell?.nodeId)
+                return {
+                    nodeId: cell.nodeId,
+                    nodeType: 'paragraph',
+                    text: cell.text,
+                    textPreview: cell.text,
+                    styleId: null,
+                    ordinal: 0,
+                };
+        }
+        return ids.length === 1 ? this.block(ids[0]) : undefined;
+    }
+    async tableShape(nodeId) {
+        if (this.complete)
+            return this.complete.tables.find((table) => table.nodeId === nodeId);
+        return this.doc.tables.get({ nodeId });
+    }
+    async completeIndex(reason, acquire) {
+        const value = await acquire();
+        await this.fence();
+        return { value, coverage: 'complete', reason };
+    }
+    async prepare(checks) {
+        for (const check of checks)
+            if (check.kind === 'block-count-delta')
+                await this.count(check.nodeType);
+    }
+}
+class ExecutionContext {
+    source;
+    requirements;
+    document;
+    executedOperations = [];
+    selectedTargets = [];
+    pre;
+    post;
+    fallbackReason;
+    currentRevision;
+    legacyRevisionOnly = false;
+    constructor(source, requirements = {}) {
+        this.source = source;
+        this.requirements = requirements;
+        if (requirements.evidence !== undefined && !['required', 'full'].includes(requirements.evidence))
+            throw new errors.SuperDocCliError('evidence must be required or full.', { code: 'INVALID_ARGUMENT' });
+        const wrap = (value, path) => new Proxy(value, {
+            get: (target, property, receiver) => {
+                const member = Reflect.get(target, property, receiver);
+                if (typeof property !== 'string')
+                    return member;
+                const memberPath = [...path, property];
+                const operationId = `doc.${memberPath.join('.')}`;
+                if (typeof member === 'function' && operationCatalog.getOperationCatalogEntry(operationId)?.isMutating) {
+                    return async (args = {}, options) => {
+                        if (operationId === 'doc.format.apply' &&
+                            documentEvidence.supportsDocumentFacts(this.source) &&
+                            typeof args.blockId === 'string') {
+                            const { blockId, start, end, ...rest } = args;
+                            args = {
+                                ...rest,
+                                target: {
+                                    kind: 'selection',
+                                    start: { kind: 'text', blockId, offset: start },
+                                    end: { kind: 'text', blockId, offset: end },
+                                },
+                            };
+                        }
+                        if (this.legacyRevisionOnly && this.executedOperations.length)
+                            throw new errors.SuperDocCliError('This host cannot bind revisions across multiple writes.', {
+                                code: 'EVIDENCE_UNAVAILABLE',
+                            });
+                        const guarded = (documentEvidence.supportsDocumentFacts(this.source) || this.legacyRevisionOnly) &&
+                            !['doc.history.undo', 'doc.history.redo', 'doc.plan.execute'].includes(operationId);
+                        const revision = guarded ? (this.currentRevision ?? (await readPublicRevision(this.source))) : undefined;
+                        const result = await Reflect.apply(member, target, guarded
+                            ? [
+                                { ...args, expectedRevision: args.expectedRevision ?? revision },
+                                { ...options, expectedRevision: options?.expectedRevision ?? revision },
+                            ]
+                            : [args, options]);
+                        this.executedOperations.push({ operationId, result });
+                        if (result?.success === false)
+                            throw new errors.SuperDocCliError('Document operation did not apply.', {
+                                code: result.failure?.code ?? 'APPLY_FAILED',
+                                details: result,
+                            });
+                        if (documentEvidence.supportsDocumentFacts(this.source)) {
+                            const applied = documentEvidence.getMutationRevision(result);
+                            if (!applied ||
+                                applied.before !== this.currentRevision ||
+                                !applied.after ||
+                                applied.after === 'unknown')
+                                throw new errors.SuperDocCliError('Committed operation revision is unavailable or changed.', {
+                                    code: 'EVIDENCE_UNAVAILABLE',
+                                });
+                            this.currentRevision = applied.after;
+                        }
+                        return result;
+                    };
+                }
+                if (member && typeof member === 'object')
+                    return wrap(member, memberPath);
+                return member;
+            },
+        });
+        this.document = wrap(source, []);
+        documentEvidence.forwardDocumentEvidence(source, this.document);
+    }
+    async start() {
+        const { evidence, selectors = [], checks = [], completeReason } = this.requirements;
+        const compactRevision = this.requirements.revisionOnly && evidence !== 'full' && !completeReason
+            ? await documentEvidence.getDocumentRevisionReader(this.source)?.()
+            : undefined;
+        this.legacyRevisionOnly = compactRevision !== undefined && !documentEvidence.supportsDocumentFacts(this.source);
+        this.fallbackReason =
+            completeReason ??
+                (!documentEvidence.supportsDocumentFacts(this.source) && !this.legacyRevisionOnly
+                    ? 'host lacks typed execution facts'
+                    : selectors.some((selector) => !supportsLocalSelector(selector))
+                        ? 'selector requires complete index'
+                        : checks.some((check) => !localCheck(check))
+                            ? 'verification requires complete evidence'
+                            : undefined);
+        const complete = evidence === 'full' || this.fallbackReason ? await docSnapshot.buildMutationSnapshot(this.source) : undefined;
+        if (complete && (complete.revision === 'unknown' || complete.diagnostics.some((item) => item.section === 'info')))
+            throw new errors.SuperDocCliError('Required complete evidence is unavailable.', { code: 'EVIDENCE_UNAVAILABLE' });
+        this.pre = new DocumentFacts(this.source, complete?.revision ?? compactRevision ?? (await readPublicRevision(this.source)), complete);
+        this.currentRevision = this.pre.revision;
+        await this.pre.prepare(checks);
+        return this.pre;
+    }
+    async finishRevision() {
+        if (this.requirements.evidence === 'full')
+            return this.finish();
+        const summary = this.pre?.complete ? await docSnapshot.buildDocumentSnapshot(this.source, { countsOnly: true }) : undefined;
+        if (summary && (summary.revision === 'unknown' || summary.diagnostics.some((item) => item.section === 'info')))
+            throw new errors.SuperDocCliError('Required summary is unavailable.', { code: 'EVIDENCE_UNAVAILABLE' });
+        const revision = summary?.revision ?? (await readPublicRevision(this.source));
+        this.assertExecutionRevision(revision);
+        this.post = new DocumentFacts(this.source, revision, undefined, summary?.counts);
+        this.currentRevision = this.post.revision;
+        return this.post;
+    }
+    async finish() {
+        const complete = this.pre?.complete ? await docSnapshot.buildMutationSnapshot(this.source) : undefined;
+        if (complete && (complete.revision === 'unknown' || complete.diagnostics.some((item) => item.section === 'info')))
+            throw new errors.SuperDocCliError('Required complete evidence is unavailable.', { code: 'EVIDENCE_UNAVAILABLE' });
+        const revision = complete?.revision ?? (await readPublicRevision(this.source));
+        this.assertExecutionRevision(revision);
+        this.post = new DocumentFacts(this.source, revision, complete);
+        this.currentRevision = this.post.revision;
+        return this.post;
+    }
+    assertExecutionRevision(revision) {
+        if (documentEvidence.supportsDocumentFacts(this.source) && this.currentRevision !== revision)
+            throw new errors.SuperDocCliError('Document changed outside this execution.', { code: 'REVISION_CONFLICT' });
+    }
+    receipt(intent, verification, extra = {}) {
+        return {
+            status: verification.every((check) => check.passed) ? 'ok' : 'failed',
+            intent,
+            preSnapshot: this.pre?.summary,
+            postSnapshot: this.post?.summary,
+            selectedTargets: this.selectedTargets,
+            executedOperations: this.executedOperations,
+            verification,
+            ...(this.fallbackReason ? { evidenceFallback: this.fallbackReason } : {}),
+            ...extra,
+        };
+    }
+    failure(intent, error) {
+        const err = error;
+        return this.receipt(intent, [], {
+            status: err?.code === 'AMBIGUOUS_SELECTOR' ? 'aborted' : 'failed',
+            errors: [
+                { code: err?.code ?? 'ACTION_FAILED', message: err?.message ?? String(error), recovery: { kind: 'reinspect' } },
+            ],
+        });
+    }
+}
+async function evaluateFactChecks(pre, post, checks) {
+    const results = [];
+    for (const check of checks) {
+        if ([
+            'revision-changed',
+            'revision-unchanged',
+            'block-count-delta',
+            'comment-count-delta',
+            'tracked-change-count-delta',
+        ].includes(check.kind) &&
+            !pre) {
+            results.push({ check, passed: false, detail: `${check.kind} requires a baseline snapshot` });
+            continue;
+        }
+        if (check.kind === 'revision-changed' || check.kind === 'revision-unchanged')
+            results.push({
+                check,
+                passed: check.kind === 'revision-changed' ? pre.revision !== post.revision : pre.revision === post.revision,
+                detail: `pre=${pre.revision} post=${post.revision}`,
+            });
+        else if (check.kind === 'block-count-delta') {
+            const before = await pre.count(check.nodeType), after = await post.count(check.nodeType);
+            results.push({
+                check,
+                passed: after - before === check.delta,
+                detail: `pre=${before} post=${after} delta=${after - before}`,
+            });
+        }
+        else if (check.kind === 'block-text-contains' || check.kind === 'block-text-equals') {
+            const block = await post.block(check.nodeId);
+            results.push({
+                check,
+                passed: !!block && (check.kind === 'block-text-equals' ? block.text === check.text : block.text.includes(check.text)),
+            });
+        }
+        else if (check.kind === 'table-shape') {
+            const table = await post.tableShape(check.nodeId);
+            results.push({ check, passed: !!table && table.rows === check.rows && table.columns === check.columns });
+        }
+        else if (check.kind === 'comment-count-delta' || check.kind === 'tracked-change-count-delta') {
+            const key = check.kind === 'comment-count-delta' ? 'comments' : 'trackedChanges';
+            const before = pre?.complete?.counts[key], after = post.complete?.counts[key];
+            results.push({
+                check,
+                passed: before !== undefined && after !== undefined && after - before === check.delta,
+                detail: `pre=${before} post=${after}`,
+            });
+        }
+        else
+            results.push({ check, passed: false, detail: 'Check requires domain-specific evidence.' });
+    }
+    return results;
+}
+
+exports.DocumentFacts = DocumentFacts;
+exports.ExecutionContext = ExecutionContext;
+exports.evaluateFactChecks = evaluateFactChecks;
+exports.readPublicRevision = readPublicRevision;
+exports.supportsLocalSelector = supportsLocalSelector;