@shipwithai/loopnote 0.0.0-stage → 2.0.0

package/dist/export/render-review-markdown.js

@@ -0,0 +1,163 @@
+import { controlSafeDisplay } from '../domain/path-bytes.js';
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { parseCanonicalReviewExport } from './review-export.js';
+function fenceFor(value) {
+    const runs = value.match(/`+/gu) ?? [];
+    const longest = runs.reduce((length, run) => Math.max(length, run.length), 2);
+    return '`'.repeat(longest + 1);
+}
+function appendFencedData(lines, label, value) {
+    const fence = fenceFor(value);
+    lines.push(label, `${fence}text`, value, fence);
+}
+function appendAnchor(lines, comment, exactPatch) {
+    const { anchor } = comment;
+    lines.push(`Side: \`${exactPatch ? (anchor.side === 'base' ? 'preimage' : 'postimage') : anchor.side}\``, `Recorded line: ${anchor.line} (hint only)`, `Blob: \`${anchor.blobOid}\``, `Context hash: \`${anchor.contextHash.algorithm}:${anchor.contextHash.value}\``);
+    appendFencedData(lines, 'Repository-relative path:', anchor.path.utf8 ?? anchor.path.bytesBase64url);
+    appendFencedData(lines, 'Selected text:', anchor.selectedText);
+    const context = [];
+    for (const line of anchor.context.before)
+        context.push(`${line.line}: ${line.text}`);
+    context.push(`${anchor.context.target.line}: ${anchor.context.target.text}`);
+    for (const line of anchor.context.after)
+        context.push(`${line.line}: ${line.text}`);
+    appendFencedData(lines, 'Nearby context:', context.join('\n'));
+}
+function appendComment(lines, comment, exactPatch) {
+    lines.push(`### ${comment.id}`);
+    appendAnchor(lines, comment, exactPatch);
+    appendFencedData(lines, 'Review feedback:', comment.body);
+}
+export function renderReviewMarkdown(canonicalBytes) {
+    const document = parseCanonicalReviewExport(canonicalBytes);
+    const exactPatch = document.schemaVersion === 3;
+    const standalone = document.schemaVersion === 4 || document.schemaVersion === 6;
+    const uncommitted = document.schemaVersion === 5;
+    const lines = [`# ${RENAME_MAP.displayName} Export`, ''];
+    if (exactPatch) {
+        lines.push('## Exact patch', `Accepted draft revision: ${document.acceptedDraftRevision}`, `Exported at: ${document.exportedAt}`, `Patch digest: \`${document.patch.digest}\``, `Validation target: \`${document.patch.validationTarget.kind}\``, `Review key: \`${document.patch.reviewKey}\``, 'Anchor sides: `Preimage` and `Postimage`.', '', '## Frozen patch files');
+        if (document.patch.snapshot.files.length === 0) {
+            lines.push('No changed files were recorded.');
+        }
+        else {
+            for (const file of document.patch.snapshot.files) {
+                lines.push('', `### ${file.id}`, `Status: \`${file.status.kind}\``, `Old mode: \`${file.oldMode}\``, `New mode: \`${file.newMode}\``, `Availability: \`${file.availability.kind}\``);
+                if (file.oldPath !== undefined) {
+                    appendFencedData(lines, 'Raw preimage path:', file.oldPath.utf8 ?? file.oldPath.bytesBase64url);
+                }
+                if (file.newPath !== undefined) {
+                    appendFencedData(lines, 'Raw postimage path:', file.newPath.utf8 ?? file.newPath.bytesBase64url);
+                }
+            }
+        }
+    }
+    else if (document.schemaVersion === 4 || document.schemaVersion === 6) {
+        lines.push('## Standalone files', `Accepted draft revision: ${document.acceptedDraftRevision}`, `Exported at: ${document.exportedAt}`, 'Original arguments:');
+        if (document.standalone.originalArguments.length === 0) {
+            lines.push('No arguments were recorded.');
+        }
+        else {
+            let index = 0;
+            for (const argument of document.standalone.originalArguments) {
+                index += 1;
+                appendFencedData(lines, `Argument ${index}:`, controlSafeDisplay(argument));
+            }
+        }
+        lines.push(`Resolved paths: ${document.standalone.resolvedPaths.length}`, `Snapshot chain: ${document.standalone.snapshotChain.join(' → ')}`, 'Anchor side: `Head` (current content).', '', '## Standalone file digests');
+        if (document.standalone.fileDigests.length === 0) {
+            lines.push('No file digests were recorded.');
+        }
+        else {
+            for (const digest of document.standalone.fileDigests) {
+                appendFencedData(lines, `File digest (sha256 ${digest.sha256}):`, digest.path.utf8 ?? digest.path.bytesBase64url);
+            }
+        }
+        if (document.schemaVersion === 6) {
+            lines.push('', '## Working tree drift', `Changed since final snapshot: ${document.workingTreeChangedAfterFinalSnapshot.changed ? 'yes' : 'no'}`);
+            for (const driftPath of document.workingTreeChangedAfterFinalSnapshot.paths) {
+                appendFencedData(lines, 'Changed path:', driftPath.utf8 ?? driftPath.bytesBase64url);
+            }
+        }
+    }
+    else if (document.schemaVersion === 5) {
+        lines.push('## Uncommitted scope', `Accepted draft revision: ${document.acceptedDraftRevision}`, `Exported at: ${document.exportedAt}`, `Source kind: \`${document.uncommitted.sourceKind}\``);
+        if (document.uncommitted.baseCommitOid !== undefined) {
+            lines.push(`Base commit: \`${document.uncommitted.baseCommitOid}\``);
+        }
+        lines.push(`Review key: \`${document.uncommitted.reviewKey}\``, `Snapshot chain: ${document.uncommitted.snapshotChain.join(' → ')}`, 'Anchor side: `Head` (current content).', '', '## Working tree drift', `Changed since final snapshot: ${document.workingTreeChangedAfterFinalSnapshot.changed ? 'yes' : 'no'}`);
+        for (const driftPath of document.workingTreeChangedAfterFinalSnapshot.paths) {
+            appendFencedData(lines, 'Changed path:', driftPath.utf8 ?? driftPath.bytesBase64url);
+        }
+    }
+    else {
+        lines.push('## Pinned comparison', `Accepted draft revision: ${document.acceptedDraftRevision}`, `Exported at: ${document.exportedAt}`, `Base commit: \`${document.comparison.selectedBase.launchOid}\``, `Head commit: \`${document.comparison.selectedHead.launchOid}\``, `Merge base: \`${document.comparison.mergeBaseOid}\``, `Comparison key: \`${document.comparison.comparisonKey}\``);
+        if (document.schemaVersion === 2) {
+            lines.push('## Review scope', `Base commit: \`${document.range.baseOid}\``, `Head commit: \`${document.range.headOid}\``, `Review key: \`${document.range.reviewKey}\``);
+            appendFencedData(lines, 'Requested base:', controlSafeDisplay(document.range.requestedBase));
+            appendFencedData(lines, 'Requested head:', controlSafeDisplay(document.range.requestedHead));
+            lines.push('Ordered Git pathspecs:');
+            let index = 0;
+            for (const pathspec of document.range.pathspecs) {
+                index += 1;
+                appendFencedData(lines, `Pathspec ${index}:`, controlSafeDisplay(pathspec));
+            }
+            lines.push('');
+        }
+        appendFencedData(lines, 'Base label:', document.comparison.selectedBase.label);
+        appendFencedData(lines, 'Head label:', document.comparison.selectedHead.label);
+        lines.push('', '## Drift observation', `Observed at: ${document.drift.observedAt}`, `Acknowledged: ${document.drift.acknowledged ? 'yes' : 'no'}`, `Base selector: ${document.drift.base.status}; launch \`${document.drift.base.launchOid}\`; current \`${document.drift.base.currentOid ?? 'unavailable'}\``, `Head selector: ${document.drift.head.status}; launch \`${document.drift.head.launchOid}\`; current \`${document.drift.head.currentOid ?? 'unavailable'}\``);
+    }
+    lines.push('', '## Summary');
+    if (document.summary.markdown === null) {
+        lines.push('No summary provided');
+    }
+    else {
+        appendFencedData(lines, 'Review summary:', document.summary.markdown);
+    }
+    lines.push('', '## Open actionable requests');
+    let actionable = 0;
+    for (const file of document.files) {
+        const verified = [];
+        for (const comment of file.comments) {
+            if (comment.state === 'open' && comment.verification.state === 'verified')
+                verified.push(comment);
+        }
+        if (verified.length === 0)
+            continue;
+        actionable += verified.length;
+        lines.push('', '### Path');
+        appendFencedData(lines, 'Repository-relative path:', file.path.utf8 ?? file.path.bytesBase64url);
+        for (const comment of verified) {
+            lines.push('');
+            appendComment(lines, comment, exactPatch);
+        }
+    }
+    if (actionable === 0)
+        lines.push('No open actionable requests.');
+    lines.push('', '## Needs reviewer attention');
+    const attention = [];
+    for (const file of document.files) {
+        for (const comment of file.comments) {
+            if (comment.state === 'open' && comment.verification.state !== 'verified')
+                attention.push(comment);
+        }
+    }
+    if (attention.length === 0) {
+        lines.push('No open comments need reviewer attention.');
+    }
+    else {
+        for (const comment of attention) {
+            lines.push('', `### ${comment.id}`, `Anchor state: \`${comment.verification.state}\` (${comment.verification.reason})`);
+            appendAnchor(lines, comment, exactPatch);
+            appendFencedData(lines, 'Review feedback:', comment.body);
+        }
+    }
+    lines.push('', `Resolved comments: ${document.counts.resolved}. Full history remains in canonical JSON.`, '', '## Applying-agent instructions', exactPatch
+        ? 'Before editing, verify the exact patch digest, frozen snapshot facts, relevant blob, repository-relative path, preimage/postimage side, exact selected text, and context hash.'
+        : standalone
+            ? 'Before editing, verify the standalone review key, snapshot chain, relevant blob, repository-relative path, head side, exact selected text, and context hash.'
+            : uncommitted
+                ? 'Before editing, verify the uncommitted review key, snapshot chain, relevant blob, repository-relative path, head side, exact selected text, and context hash.'
+                : 'Before editing, verify the pinned comparison commit, relevant blob, repository-relative path, base/head side, exact selected text, and context hash.', 'Line number is a navigation hint, never editing authority.', 'Do not guess, fuzzy-match, silently relocate, or apply resolved feedback.', 'Do not apply stale, orphaned, missing, or ambiguous anchors.', 'Report ambiguous, missing, stale, orphaned, blob, path, side, selected-text, and context-hash mismatches.', 'Include the recorded comment ID and identity in every mismatch report.');
+    return `${lines.join('\n')}\n`;
+}

package/dist/export/review-export.js

@@ -0,0 +1,273 @@
+import { createHash } from 'node:crypto';
+import { RENAME_MAP } from '../domain/product-identity.js';
+import { AnchorVerificationSchema, ReviewDraftV1Schema, ReviewExportV1Schema, ReviewExportV2Schema, ReviewExportV3Schema, ReviewExportV4Schema, ReviewExportV5Schema, ReviewExportV6Schema, orderReviewExportComments, orderUtf16CodeUnits, } from '../contracts/draft.js';
+import { orderExactPaths } from '../domain/path-bytes.js';
+function assertCanonicalString(value) {
+    if (/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:^|[^\uD800-\uDBFF])[\uDC00-\uDFFF]/u.test(value)) {
+        throw new TypeError('Canonical JSON rejects strings with lone UTF-16 surrogate code units.');
+    }
+}
+function serializeCanonicalJson(value) {
+    if (value === null)
+        return 'null';
+    if (typeof value === 'string') {
+        assertCanonicalString(value);
+        return JSON.stringify(value);
+    }
+    if (typeof value === 'boolean')
+        return value ? 'true' : 'false';
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new TypeError('Canonical JSON rejects non-finite numbers.');
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(serializeCanonicalJson).join(',')}]`;
+    if (typeof value !== 'object' || value === undefined) {
+        throw new TypeError('Canonical JSON accepts only I-JSON primitives, arrays, and objects.');
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError('Canonical JSON accepts only plain objects.');
+    }
+    const object = value;
+    return `{${Object.keys(object)
+        .sort(orderUtf16CodeUnits)
+        .map((key) => `${serializeCanonicalJson(key)}:${serializeCanonicalJson(object[key])}`)
+        .join(',')}}`;
+}
+export function buildReviewExportV1(snapshot, exportedAt) {
+    const draft = ReviewDraftV1Schema.parse(snapshot.acceptedDraft);
+    const comments = draft.comments.map((comment) => {
+        const verification = snapshot.commentVerification[comment.id];
+        if (verification === undefined) {
+            throw new TypeError(`Missing anchor verification for accepted comment ${comment.id}.`);
+        }
+        const verified = AnchorVerificationSchema.parse(verification);
+        return {
+            id: comment.id,
+            state: comment.state,
+            body: comment.body,
+            createdAt: comment.createdAt,
+            updatedAt: comment.updatedAt,
+            resolvedAt: comment.state === 'resolved' ? comment.resolvedAt : null,
+            verification: verified,
+            anchor: comment.anchor,
+        };
+    });
+    const groups = new Map();
+    for (const comment of comments) {
+        const key = comment.anchor.path.bytesBase64url;
+        const group = groups.get(key);
+        if (group === undefined) {
+            groups.set(key, { path: comment.anchor.path, comments: [comment] });
+        }
+        else {
+            group.comments.push(comment);
+        }
+    }
+    const files = [...groups.values()]
+        .sort((left, right) => orderExactPaths(left.path, right.path))
+        .map((group) => ({ path: group.path, comments: group.comments.sort(orderReviewExportComments) }));
+    const allComments = files.flatMap((file) => file.comments);
+    const document = {
+        schemaVersion: 1,
+        kind: `${RENAME_MAP.kindPrefix}/export`,
+        exportedAt,
+        acceptedDraftRevision: draft.revision,
+        comparison: snapshot.comparison,
+        drift: snapshot.drift,
+        summary: { markdown: draft.summary === '' ? null : draft.summary },
+        files,
+        counts: {
+            all: allComments.length,
+            openActionable: allComments.filter((comment) => comment.state === 'open' && comment.verification.state === 'verified').length,
+            openNeedsAttention: allComments.filter((comment) => comment.state === 'open' && comment.verification.state !== 'verified').length,
+            resolved: allComments.filter((comment) => comment.state === 'resolved').length,
+        },
+    };
+    return ReviewExportV1Schema.parse(document);
+}
+function hasMatchingRangeScope(left, right) {
+    return left.requestedBase === right.requestedBase
+        && left.requestedHead === right.requestedHead
+        && left.baseOid === right.baseOid
+        && left.headOid === right.headOid
+        && left.reviewKey === right.reviewKey
+        && left.pathspecs.length === right.pathspecs.length
+        && left.pathspecs.every((pathspec, index) => pathspec === right.pathspecs[index]);
+}
+export function buildReviewExportV2(snapshot, range, exportedAt) {
+    const draft = ReviewDraftV1Schema.parse(snapshot.acceptedDraft);
+    if ('kind' in draft.comparison
+        ||
+            draft.comparison.range === undefined
+        || !hasMatchingRangeScope(draft.comparison.range, range)
+        || snapshot.comparison.selectedBase.label !== range.requestedBase
+        || snapshot.comparison.selectedHead.label !== range.requestedHead
+        || snapshot.comparison.selectedBase.launchOid !== range.baseOid
+        || snapshot.comparison.selectedHead.launchOid !== range.headOid
+        || snapshot.comparison.mergeBaseOid !== range.baseOid
+        || snapshot.comparison.comparisonKey !== range.reviewKey) {
+        throw new TypeError('Range export provenance does not match the frozen comparison.');
+    }
+    const versionOne = buildReviewExportV1(snapshot, exportedAt);
+    return ReviewExportV2Schema.parse({ ...versionOne, schemaVersion: 2, range });
+}
+export function buildReviewExportV3(snapshot, patch, exportedAt) {
+    const draft = ReviewDraftV1Schema.parse(snapshot.acceptedDraft);
+    if (!('kind' in draft.comparison)
+        || draft.comparison.kind !== 'exact-patch'
+        || draft.comparison.digest !== patch.digest
+        || draft.comparison.validationTarget.kind !== patch.validationTarget.kind
+        || draft.comparison.reviewKey !== patch.reviewKey) {
+        throw new TypeError('Exact patch export provenance does not match accepted draft.');
+    }
+    const feedback = buildReviewExportV1({
+        acceptedDraft: draft,
+        commentVerification: snapshot.commentVerification,
+        comparison: {
+            selectedBase: { label: 'preimage', launchOid: '0'.repeat(40) },
+            selectedHead: { label: 'postimage', launchOid: '0'.repeat(40) },
+            mergeBaseOid: '0'.repeat(40),
+            comparisonKey: '0'.repeat(64),
+        },
+        drift: {
+            observedAt: exportedAt,
+            acknowledged: false,
+            base: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+            head: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+        },
+    }, exportedAt);
+    const { comparison: _comparison, drift: _drift, ...document } = feedback;
+    return ReviewExportV3Schema.parse({ ...document, schemaVersion: 3, patch });
+}
+export function buildReviewExportV4(snapshot, standalone, exportedAt) {
+    const draft = ReviewDraftV1Schema.parse(snapshot.acceptedDraft);
+    if (!('kind' in draft.comparison)
+        || draft.comparison.kind !== 'uncommitted'
+        || draft.comparison.sourceKind !== 'standalone'
+        || draft.comparison.reviewKey !== standalone.reviewKey) {
+        throw new TypeError('Standalone export provenance does not match accepted draft.');
+    }
+    const feedback = buildReviewExportV1({
+        acceptedDraft: draft,
+        commentVerification: snapshot.commentVerification,
+        comparison: {
+            selectedBase: { label: 'preimage', launchOid: '0'.repeat(40) },
+            selectedHead: { label: 'postimage', launchOid: '0'.repeat(40) },
+            mergeBaseOid: '0'.repeat(40),
+            comparisonKey: '0'.repeat(64),
+        },
+        drift: {
+            observedAt: exportedAt,
+            acknowledged: false,
+            base: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+            head: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+        },
+    }, exportedAt);
+    const { comparison: _comparison, drift: _drift, ...document } = feedback;
+    return ReviewExportV4Schema.parse({ ...document, schemaVersion: 4, standalone });
+}
+export function buildReviewExportV5(snapshot, uncommitted, drift, exportedAt) {
+    const draft = ReviewDraftV1Schema.parse(snapshot.acceptedDraft);
+    if (!('kind' in draft.comparison)
+        || draft.comparison.kind !== 'uncommitted'
+        || draft.comparison.sourceKind !== uncommitted.sourceKind
+        || draft.comparison.reviewKey !== uncommitted.reviewKey) {
+        throw new TypeError('Uncommitted export provenance does not match accepted draft.');
+    }
+    const feedback = buildReviewExportV1({
+        acceptedDraft: draft,
+        commentVerification: snapshot.commentVerification,
+        comparison: {
+            selectedBase: { label: 'preimage', launchOid: '0'.repeat(40) },
+            selectedHead: { label: 'postimage', launchOid: '0'.repeat(40) },
+            mergeBaseOid: '0'.repeat(40),
+            comparisonKey: '0'.repeat(64),
+        },
+        drift: {
+            observedAt: exportedAt,
+            acknowledged: false,
+            base: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+            head: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+        },
+    }, exportedAt);
+    const { comparison: _comparison, drift: _drift, ...document } = feedback;
+    return ReviewExportV5Schema.parse({
+        ...document,
+        schemaVersion: 5,
+        uncommitted,
+        workingTreeChangedAfterFinalSnapshot: drift,
+    });
+}
+export function buildReviewExportV6(snapshot, standalone, drift, exportedAt) {
+    const draft = ReviewDraftV1Schema.parse(snapshot.acceptedDraft);
+    if (!('kind' in draft.comparison)
+        || draft.comparison.kind !== 'uncommitted'
+        || draft.comparison.sourceKind !== 'standalone'
+        || draft.comparison.reviewKey !== standalone.reviewKey) {
+        throw new TypeError('Standalone export provenance does not match accepted draft.');
+    }
+    const feedback = buildReviewExportV1({
+        acceptedDraft: draft,
+        commentVerification: snapshot.commentVerification,
+        comparison: {
+            selectedBase: { label: 'preimage', launchOid: '0'.repeat(40) },
+            selectedHead: { label: 'postimage', launchOid: '0'.repeat(40) },
+            mergeBaseOid: '0'.repeat(40),
+            comparisonKey: '0'.repeat(64),
+        },
+        drift: {
+            observedAt: exportedAt,
+            acknowledged: false,
+            base: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+            head: { launchOid: '0'.repeat(40), currentOid: '0'.repeat(40), status: 'unchanged' },
+        },
+    }, exportedAt);
+    const { comparison: _comparison, drift: _drift, ...document } = feedback;
+    return ReviewExportV6Schema.parse({
+        ...document,
+        schemaVersion: 6,
+        standalone,
+        workingTreeChangedAfterFinalSnapshot: drift,
+    });
+}
+export function canonicalizeReviewExport(document) {
+    return new TextEncoder().encode(serializeCanonicalJson(document));
+}
+export function parseCanonicalReviewExport(bytes) {
+    const text = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    const parsed = JSON.parse(text);
+    const document = zodParseReviewExport(parsed);
+    const canonicalBytes = canonicalizeReviewExport(document);
+    if (bytes.byteLength !== canonicalBytes.byteLength || bytes.some((byte, index) => byte !== canonicalBytes[index])) {
+        throw new TypeError('Export bytes are not the canonical representation of the validated document.');
+    }
+    return document;
+}
+function zodParseReviewExport(document) {
+    if (document === null || typeof document !== 'object' || !('schemaVersion' in document)) {
+        throw new TypeError('Export schema version is unsupported.');
+    }
+    if (document.schemaVersion === 1)
+        return ReviewExportV1Schema.parse(document);
+    if (document.schemaVersion === 2)
+        return ReviewExportV2Schema.parse(document);
+    if (document.schemaVersion === 3)
+        return ReviewExportV3Schema.parse(document);
+    if (document.schemaVersion === 4)
+        return ReviewExportV4Schema.parse(document);
+    if (document.schemaVersion === 5)
+        return ReviewExportV5Schema.parse(document);
+    if (document.schemaVersion === 6)
+        return ReviewExportV6Schema.parse(document);
+    throw new TypeError('Export schema version unsupported.');
+}
+export function hashExportBytes(bytes) {
+    return Object.freeze({
+        algorithm: 'sha256',
+        sha256: createHash('sha256').update(bytes).digest('hex'),
+        bytes: bytes.byteLength,
+    });
+}

package/dist/git/availability.js

@@ -0,0 +1,92 @@
+export const MAX_INLINE_TEXT_BYTES = 1_048_576;
+const regularFileModes = Object.freeze({
+    '100644': true,
+    '100755': true,
+});
+const textAvailability = Object.freeze({ kind: 'text' });
+const missingAvailability = Object.freeze({
+    kind: 'unavailable',
+    reason: 'missing-object',
+});
+const unsupportedAvailability = Object.freeze({
+    binary: Object.freeze({ kind: 'unsupported', reason: 'binary' }),
+    'mode-or-type': Object.freeze({
+        kind: 'unsupported',
+        reason: 'mode-or-type',
+    }),
+    'non-utf8': Object.freeze({ kind: 'unsupported', reason: 'non-utf8' }),
+    oversized: Object.freeze({ kind: 'unsupported', reason: 'oversized' }),
+    submodule: Object.freeze({ kind: 'unsupported', reason: 'submodule' }),
+    symlink: Object.freeze({ kind: 'unsupported', reason: 'symlink' }),
+    'changed-during-capture': Object.freeze({
+        kind: 'unsupported',
+        reason: 'changed-during-capture',
+    }),
+});
+const fatalUtf8Decoder = new TextDecoder('utf-8', { fatal: true });
+export async function classifyAvailability(file, objectReader, signal) {
+    if (file.oldMode === '160000' || file.newMode === '160000') {
+        return unsupportedAvailability.submodule;
+    }
+    if (file.oldMode === '120000' || file.newMode === '120000') {
+        return unsupportedAvailability.symlink;
+    }
+    if (file.status.kind === 'unsupported') {
+        return unsupportedAvailability['mode-or-type'];
+    }
+    const sides = [];
+    if (file.oldMode !== '000000') {
+        if (regularFileModes[file.oldMode] !== true) {
+            return unsupportedAvailability['mode-or-type'];
+        }
+        sides.push({ mode: file.oldMode, oid: file.oldBlobOid });
+    }
+    if (file.newMode !== '000000') {
+        if (regularFileModes[file.newMode] !== true) {
+            return unsupportedAvailability['mode-or-type'];
+        }
+        sides.push({ mode: file.newMode, oid: file.newBlobOid });
+    }
+    if (sides.length === 0) {
+        return unsupportedAvailability['mode-or-type'];
+    }
+    const sizes = [];
+    for (const side of sides) {
+        const metadata = await objectReader.inspect(side.oid, signal);
+        if (metadata.kind === 'missing' || metadata.objectType !== 'blob') {
+            return missingAvailability;
+        }
+        sizes.push(metadata.size);
+    }
+    if (sizes.some((size) => size > MAX_INLINE_TEXT_BYTES)) {
+        return unsupportedAvailability.oversized;
+    }
+    if (file.additions === null || file.deletions === null) {
+        return unsupportedAvailability.binary;
+    }
+    const contents = [];
+    for (let index = 0; index < sides.length; index += 1) {
+        const side = sides[index];
+        const content = await objectReader.read(side.oid, {
+            maxBytes: MAX_INLINE_TEXT_BYTES,
+            signal,
+        });
+        if (content.kind === 'missing' ||
+            content.bytes.byteLength !== sizes[index]) {
+            return missingAvailability;
+        }
+        contents.push(content.bytes);
+    }
+    if (contents.some((content) => content.includes(0))) {
+        return unsupportedAvailability.binary;
+    }
+    try {
+        for (const content of contents) {
+            fatalUtf8Decoder.decode(content);
+        }
+    }
+    catch {
+        return unsupportedAvailability['non-utf8'];
+    }
+    return textAvailability;
+}