@withtruing/companion 0.13.2 → 0.14.0

package/dist/whole-read/import-graph.js

@@ -0,0 +1,293 @@
+import { extname, posix } from 'node:path';
+import ts from 'typescript';
+import { decodeCanonicalBlob } from './decode.js';
+const SCRIPT_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs']);
+const RESOLUTION_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+const JS_TO_TS = {
+    '.js': ['.ts'], '.jsx': ['.tsx'], '.mjs': ['.mts'], '.cjs': ['.cts'],
+};
+const invalid = () => { throw new TypeError('import_graph_invalid'); };
+function rawPath(pathBase64) {
+    try {
+        return Buffer.from(pathBase64, 'base64');
+    }
+    catch {
+        return new Uint8Array();
+    }
+}
+function compareBytes(left, right) {
+    const length = Math.min(left.byteLength, right.byteLength);
+    for (let index = 0; index < length; index += 1) {
+        if (left[index] !== right[index])
+            return left[index] - right[index];
+    }
+    return left.byteLength - right.byteLength;
+}
+function decodedPath(bytes) {
+    try {
+        const path = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        const parts = path.split('/');
+        if (!path || path.startsWith('/') || path.includes('\0')
+            || parts.some((part) => !part || part === '.' || part === '..'))
+            return undefined;
+        return path;
+    }
+    catch {
+        return undefined;
+    }
+}
+function scriptKind(path) {
+    const extension = extname(path).toLowerCase();
+    if (extension === '.tsx')
+        return ts.ScriptKind.TSX;
+    if (extension === '.jsx')
+        return ts.ScriptKind.JSX;
+    if (extension === '.js' || extension === '.mjs' || extension === '.cjs')
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function parseImports(path, source) {
+    const file = ts.createSourceFile(path, source, ts.ScriptTarget.Latest, true, scriptKind(path));
+    const imports = [];
+    const add = (kind, expression) => {
+        const literal = expression && ts.isStringLiteralLike(expression) ? expression : undefined;
+        imports.push({
+            kind,
+            specifier: literal?.text ?? null,
+            startCodeUnit: (literal ?? expression)?.getStart(file) ?? 0,
+            endCodeUnit: (literal ?? expression)?.getEnd() ?? 0,
+        });
+    };
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node)) {
+            add(node.importClause ? 'import' : 'side_effect', node.moduleSpecifier);
+        }
+        else if (ts.isExportDeclaration(node) && node.moduleSpecifier) {
+            add('reexport', node.moduleSpecifier);
+        }
+        else if (ts.isImportEqualsDeclaration(node)
+            && ts.isExternalModuleReference(node.moduleReference)) {
+            add('require', node.moduleReference.expression);
+        }
+        else if (ts.isCallExpression(node)) {
+            const dynamic = node.expression.kind === ts.SyntaxKind.ImportKeyword;
+            const required = ts.isIdentifier(node.expression) && node.expression.text === 'require';
+            if (dynamic || required)
+                add(dynamic ? 'dynamic' : 'require', node.arguments.length === 1 ? node.arguments[0] : undefined);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(file);
+    const parseFailed = (file.parseDiagnostics?.length ?? 0) > 0;
+    return { imports: imports.sort((left, right) => left.startCodeUnit - right.startCodeUnit), parseFailed };
+}
+function characterOffset(codeUnitOffsets, codeUnit) {
+    let low = 0;
+    let high = codeUnitOffsets.length - 1;
+    while (low <= high) {
+        const middle = (low + high) >>> 1;
+        const value = codeUnitOffsets[middle];
+        if (value === codeUnit)
+            return middle;
+        if (value < codeUnit)
+            low = middle + 1;
+        else
+            high = middle - 1;
+    }
+    throw new RangeError('import span splits a decoded character');
+}
+function relativeCandidates(importer, specifier) {
+    const base = posix.normalize(posix.join(posix.dirname(importer), specifier));
+    if (!base || base === '..' || base.startsWith('../') || base.startsWith('/'))
+        return [];
+    const extension = extname(base).toLowerCase();
+    const candidates = [];
+    if (JS_TO_TS[extension]) {
+        const stem = base.slice(0, -extension.length);
+        candidates.push(...JS_TO_TS[extension].map((value) => `${stem}${value}`), base);
+    }
+    else if (extension)
+        candidates.push(base);
+    else {
+        candidates.push(...RESOLUTION_EXTENSIONS.map((value) => `${base}${value}`));
+        candidates.push(...RESOLUTION_EXTENSIONS.map((value) => `${base}/index${value}`));
+    }
+    return [...new Set(candidates)];
+}
+function packageSpecifier(specifier) {
+    const parts = specifier.split('/');
+    const count = specifier.startsWith('@') ? 2 : 1;
+    return { name: parts.slice(0, count).join('/'), subpath: parts.slice(count).join('/') };
+}
+/** Derives complete-repository ordering hints and exact mechanical import edges from canonical bytes. */
+export function deriveWholeRepoImports(input) {
+    const ids = new Set();
+    const paths = new Set();
+    const indexed = input.entries.map((entry) => {
+        if (!entry.id || !entry.sourceId || !entry.pathBase64 || !entry.blobId || ids.has(entry.id))
+            invalid();
+        ids.add(entry.id);
+        const raw = rawPath(entry.pathBase64);
+        const pathKey = `${entry.sourceId}\0${Buffer.from(raw).toString('base64')}`;
+        if (paths.has(pathKey))
+            invalid();
+        paths.add(pathKey);
+        return { entry, rawPath: raw, path: decodedPath(raw), rank: -1 };
+    }).sort((left, right) => left.entry.sourceId.localeCompare(right.entry.sourceId)
+        || compareBytes(left.rawPath, right.rawPath) || left.entry.id.localeCompare(right.entry.id));
+    indexed.forEach((value, rank) => { value.rank = rank; });
+    const bySourceAndPath = new Map();
+    for (const value of indexed) {
+        if (!value.path)
+            continue;
+        const key = `${value.entry.sourceId}\0${value.path}`;
+        const matches = bySourceAndPath.get(key) ?? [];
+        matches.push(value);
+        bySourceAndPath.set(key, matches);
+    }
+    const packages = new Map();
+    for (const value of indexed) {
+        if (!value.path || posix.basename(value.path) !== 'package.json' || !['100644', '100755'].includes(value.entry.mode))
+            continue;
+        const bytes = input.readCanonicalBytes(value.entry);
+        if (!bytes)
+            continue;
+        const decoded = decodeCanonicalBlob(bytes);
+        if (decoded.status !== 'decoded')
+            continue;
+        try {
+            const json = JSON.parse(decoded.text);
+            if (typeof json.name !== 'string' || !json.name)
+                continue;
+            const found = packages.get(json.name) ?? [];
+            found.push({ sourceId: value.entry.sourceId, root: posix.dirname(value.path) === '.' ? '' : posix.dirname(value.path), json });
+            packages.set(json.name, found);
+        }
+        catch { /* Invalid manifests do not prevent source ordering. */ }
+    }
+    const diagnostics = [];
+    const edges = [];
+    const targetFor = (source, specifier) => {
+        let candidates = [];
+        if (specifier.startsWith('./') || specifier.startsWith('../')) {
+            candidates = relativeCandidates(source.path, specifier);
+        }
+        else if (!specifier.startsWith('/') && !specifier.startsWith('#')) {
+            const parsed = packageSpecifier(specifier);
+            const matches = (packages.get(parsed.name) ?? []).filter((value) => value.sourceId === source.entry.sourceId);
+            if (matches.length === 0)
+                return 'external';
+            for (const match of matches) {
+                let target = parsed.subpath;
+                if (!target) {
+                    target = typeof match.json.module === 'string' ? match.json.module
+                        : typeof match.json.main === 'string' ? match.json.main : 'index';
+                }
+                candidates.push(...relativeCandidates(`${match.root ? `${match.root}/` : ''}__package__.ts`, `./${target.replace(/^\.\//, '')}`));
+            }
+        }
+        for (const candidate of candidates) {
+            const found = bySourceAndPath.get(`${source.entry.sourceId}\0${candidate}`);
+            if (found)
+                return found.filter((value) => ['100644', '100755'].includes(value.entry.mode));
+        }
+        return [];
+    };
+    for (const source of indexed) {
+        if (!source.path) {
+            diagnostics.push({ code: 'path_not_utf8', sourceEntryId: source.entry.id });
+            continue;
+        }
+        if (!['100644', '100755'].includes(source.entry.mode))
+            continue;
+        if (!SCRIPT_EXTENSIONS.has(extname(source.path).toLowerCase())) {
+            diagnostics.push({ code: 'unsupported_language', sourceEntryId: source.entry.id });
+            continue;
+        }
+        const bytes = input.readCanonicalBytes(source.entry);
+        if (!bytes) {
+            diagnostics.push({ code: 'source_unavailable', sourceEntryId: source.entry.id });
+            continue;
+        }
+        const decoded = decodeCanonicalBlob(bytes);
+        if (decoded.status !== 'decoded') {
+            diagnostics.push({ code: 'source_not_text', sourceEntryId: source.entry.id });
+            continue;
+        }
+        const parsed = parseImports(source.path, decoded.text);
+        if (parsed.parseFailed) {
+            diagnostics.push({ code: 'parse_failed', sourceEntryId: source.entry.id });
+            continue;
+        }
+        for (const imported of parsed.imports) {
+            const startCharacter = characterOffset(decoded.mapping.characterCodeUnitOffsets, imported.startCodeUnit);
+            const endCharacter = characterOffset(decoded.mapping.characterCodeUnitOffsets, imported.endCodeUnit);
+            const sourceSpan = decoded.mapping.canonicalSpanForCharacters(startCharacter, endCharacter);
+            if (imported.specifier === null) {
+                diagnostics.push({ code: 'unresolved_dynamic', sourceEntryId: source.entry.id, sourceSpan });
+                continue;
+            }
+            const targets = targetFor(source, imported.specifier);
+            if (targets === 'external') {
+                diagnostics.push({ code: 'external_import', sourceEntryId: source.entry.id, specifier: imported.specifier, sourceSpan });
+            }
+            else if (targets.length === 0) {
+                diagnostics.push({ code: 'unresolved_import', sourceEntryId: source.entry.id, specifier: imported.specifier, sourceSpan });
+            }
+            else if (targets.length > 1) {
+                diagnostics.push({ code: 'ambiguous_import', sourceEntryId: source.entry.id, specifier: imported.specifier, sourceSpan });
+            }
+            else {
+                edges.push({
+                    sourceEntryId: source.entry.id,
+                    targetEntryId: targets[0].entry.id,
+                    kind: imported.kind,
+                    specifier: imported.specifier,
+                    sourceSpan,
+                });
+            }
+        }
+    }
+    const byId = new Map(indexed.map((value) => [value.entry.id, value]));
+    edges.sort((left, right) => byId.get(left.sourceEntryId).rank - byId.get(right.sourceEntryId).rank
+        || left.sourceSpan.startByte - right.sourceSpan.startByte || left.targetEntryId.localeCompare(right.targetEntryId));
+    diagnostics.sort((left, right) => byId.get(left.sourceEntryId).rank - byId.get(right.sourceEntryId).rank
+        || (left.sourceSpan?.startByte ?? -1) - (right.sourceSpan?.startByte ?? -1)
+        || left.code.localeCompare(right.code) || (left.specifier ?? '').localeCompare(right.specifier ?? ''));
+    const dependencies = new Map();
+    for (const edge of edges) {
+        const found = dependencies.get(edge.sourceEntryId) ?? [];
+        if (!found.includes(edge.targetEntryId))
+            found.push(edge.targetEntryId);
+        dependencies.set(edge.sourceEntryId, found);
+    }
+    for (const found of dependencies.values())
+        found.sort((left, right) => byId.get(left).rank - byId.get(right).rank);
+    const state = new Map();
+    const orderedEntryIds = [];
+    for (const value of indexed) {
+        if (state.has(value.entry.id))
+            continue;
+        const stack = [{ entryId: value.entry.id, expanded: false }];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current.expanded) {
+                if (state.get(current.entryId) !== 'visited') {
+                    state.set(current.entryId, 'visited');
+                    orderedEntryIds.push(current.entryId);
+                }
+                continue;
+            }
+            if (state.has(current.entryId))
+                continue;
+            state.set(current.entryId, 'visiting');
+            stack.push({ entryId: current.entryId, expanded: true });
+            const targets = dependencies.get(current.entryId) ?? [];
+            for (let index = targets.length - 1; index >= 0; index -= 1) {
+                if (!state.has(targets[index]))
+                    stack.push({ entryId: targets[index], expanded: false });
+            }
+        }
+    }
+    return { orderedEntryIds, edges, diagnostics };
+}

package/dist/whole-read/inventory-collector.js

@@ -0,0 +1,55 @@
+import { createHash } from 'node:crypto';
+import { decodeCanonicalBlob } from './decode.js';
+import { classifyInventoryEntry } from './inventory-rules.js';
+import { collectionDigest, encodeCollection } from './pages.js';
+import { redactCanonicalText } from './redaction.js';
+function entryId(pathBase64) {
+    return `entry_${createHash('sha256').update(pathBase64).digest('hex').slice(0, 32)}`;
+}
+/** Pure, source-free inventory metadata construction shared by both content hosts. */
+export function collectInventory(input) {
+    const gitmodules = input.entries.find((entry) => entry.pathDisplay === '.gitmodules' && entry.mode !== '160000');
+    const gitmodulesBytes = gitmodules ? input.blobs.get(gitmodules.blobId)?.bytes : undefined;
+    const records = input.entries.map((entry) => {
+        const blob = input.blobs.get(entry.blobId);
+        const classification = classifyInventoryEntry({ ...entry, sourceId: input.sourceId,
+            bytes: blob?.bytes, gitmodulesBytes,
+            ...(blob?.acquisitionFailure ? { acquisitionFailure: blob.acquisitionFailure } : {}) });
+        const findings = blob?.bytes && classification.encoding
+            ? (() => {
+                const decoded = decodeCanonicalBlob(blob.bytes);
+                return decoded.status === 'decoded'
+                    ? redactCanonicalText({ text: decoded.text }).findings : [];
+            })()
+            : [];
+        return {
+            collectionId: input.collectionId,
+            collectionKind: 'inventory',
+            semanticId: entryId(entry.pathBase64),
+            recordKind: 'entry',
+            payload: {
+                sourceId: input.sourceId,
+                pathBase64: entry.pathBase64,
+                pathDisplay: entry.pathDisplay,
+                mode: entry.mode,
+                blobId: entry.blobId,
+                bytes: classification.bytes,
+                encoding: classification.encoding,
+                bomBytes: classification.bomBytes,
+                lineCount: classification.lineCount,
+                laneId: null,
+                state: classification.state,
+                subState: classification.subState,
+                proof: classification.proof,
+                ownerDecision: null,
+                secretFindings: findings,
+                ...(classification.generatedCandidate
+                    ? { generatedCandidate: classification.generatedCandidate } : {}),
+            },
+        };
+    });
+    const pages = [...encodeCollection(records)];
+    return { records, pages, digest: collectionDigest(pages, {
+            collectionId: input.collectionId, kind: 'inventory',
+        }) };
+}

package/dist/whole-read/inventory-rules.js

@@ -0,0 +1,141 @@
+import { decodeCanonicalBlob } from './decode.js';
+import { detectGeneratedEntry } from './generated-rules.js';
+import { INVENTORY_RULES_VERSION, } from './types.js';
+export { INVENTORY_RULES_VERSION } from './types.js';
+const UTF8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const LFS_POINTER = /^version https:\/\/git-lfs\.github\.com\/spec\/v1\noid sha256:[0-9a-f]{64}\nsize (?:0|[1-9][0-9]*)\n$/;
+const startsAt = (bytes, offset, values) => values.every((value, index) => bytes[offset + index] === value);
+const asciiAt = (bytes, offset, value) => startsAt(bytes, offset, [...value].map((character) => character.charCodeAt(0)));
+const u32beAt = (bytes, offset) => offset + 4 <= bytes.length
+    ? ((bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]) >>> 0
+    : null;
+/** Closed binary header table. Callers must already have observed a raw NUL in the first 8,000 bytes. */
+export const BINARY_SIGNATURES = [
+    { id: 'png', matches: (b) => startsAt(b, 0, [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]) },
+    { id: 'jpeg', matches: (b) => startsAt(b, 0, [0xff, 0xd8, 0xff]) },
+    { id: 'gif', matches: (b) => asciiAt(b, 0, 'GIF87a') || asciiAt(b, 0, 'GIF89a') },
+    // RIFF size is at offset 4; the mandatory WebP form type is at offset 8.
+    { id: 'webp', matches: (b) => asciiAt(b, 0, 'RIFF') && asciiAt(b, 8, 'WEBP') },
+    // ICO/CUR reserved field is 0 at offset 0; type at offset 2 is 1 or 2.
+    { id: 'ico', matches: (b) => startsAt(b, 0, [0, 0, 1, 0]) || startsAt(b, 0, [0, 0, 2, 0]) },
+    { id: 'pdf', matches: (b) => asciiAt(b, 0, '%PDF-') && b[5] !== undefined && b[5] >= 0x31 && b[5] <= 0x39 },
+    { id: 'woff', matches: (b) => asciiAt(b, 0, 'wOFF') },
+    { id: 'woff2', matches: (b) => asciiAt(b, 0, 'wOF2') },
+    // TrueType's sfnt version is 0x00010000; OpenType's is the literal OTTO.
+    { id: 'ttf', matches: (b) => startsAt(b, 0, [0, 1, 0, 0]) && b.length >= 12 },
+    { id: 'otf', matches: (b) => asciiAt(b, 0, 'OTTO') && b.length >= 12 },
+    // ZIP's local, central-directory, and empty-archive signatures also cover JAR archives.
+    { id: 'zip_or_jar', matches: (b) => asciiAt(b, 0, 'PK\x03\x04') || asciiAt(b, 0, 'PK\x05\x06') || asciiAt(b, 0, 'PK\x07\x08') },
+    { id: 'gzip', matches: (b) => startsAt(b, 0, [0x1f, 0x8b, 0x08]) && (b[3] ?? 0xff) <= 0x1f },
+    { id: 'sqlite', matches: (b) => asciiAt(b, 0, 'SQLite format 3\0') },
+    { id: 'mp3_id3', matches: (b) => asciiAt(b, 0, 'ID3') && (b[3] === 2 || b[3] === 3 || b[3] === 4) },
+    { id: 'mp3_frame', matches: (b) => b[0] === 0xff && ((b[1] ?? 0) & 0xe0) === 0xe0 && ((b[1] ?? 0) & 0x06) !== 0 },
+    // ISO base media requires a box length at offset 0 and ftyp at offset 4.
+    { id: 'mp4', matches: (b) => (u32beAt(b, 0) ?? 0) >= 16 && asciiAt(b, 4, 'ftyp') },
+    // EBML ID at offset 0; DocType's element ID is 0x4282 and its four-byte value is webm.
+    { id: 'webm', matches: (b) => startsAt(b, 0, [0x1a, 0x45, 0xdf, 0xa3]) && b.some((_, index) => index < 121 && startsAt(b, index, [0x42, 0x82, 0x84]) && asciiAt(b, index + 3, 'webm')) },
+    { id: 'wasm', matches: (b) => startsAt(b, 0, [0, 0x61, 0x73, 0x6d, 1, 0, 0, 0]) },
+];
+function proof(input, ruleId, facts) {
+    return { ruleId, rulesVersion: INVENTORY_RULES_VERSION, sourceId: input.sourceId, blobId: input.blobId, facts };
+}
+function unresolved(bytes, subState, input, facts = {}) {
+    return {
+        state: 'unresolved', subState, bytes, encoding: null, bomBytes: null, lineCount: null,
+        proof: proof(input, subState, facts),
+    };
+}
+function safeGitmodulesUrl(bytes, path) {
+    if (!bytes)
+        return null;
+    let text;
+    try {
+        text = UTF8.decode(bytes);
+    }
+    catch {
+        return null;
+    }
+    let currentPath = null;
+    let currentUrl = null;
+    const found = [];
+    for (const line of text.split(/\r?\n/)) {
+        if (/^\[submodule "[^"\\]+"\]$/.test(line)) {
+            if (currentPath === path && currentUrl)
+                found.push(currentUrl);
+            currentPath = null;
+            currentUrl = null;
+            continue;
+        }
+        const field = /^(path|url) = ([^\r\n]+)$/.exec(line);
+        if (!field)
+            continue;
+        if (field[1] === 'path')
+            currentPath = field[2];
+        else
+            currentUrl = field[2];
+    }
+    if (currentPath === path && currentUrl)
+        found.push(currentUrl);
+    if (found.length !== 1 || /[\x00-\x1f\s]/.test(found[0]) || /^[a-z][a-z0-9+.-]*:\/\/[^/]*@/i.test(found[0]))
+        return null;
+    return found[0];
+}
+/** Applies the §3.3 precedence without touching a worktree, filesystem, or network. */
+export function classifyInventoryEntry(input) {
+    if (input.mode === '160000') {
+        const locator = safeGitmodulesUrl(input.gitmodulesBytes, input.pathDisplay);
+        return {
+            state: 'set_aside', subState: null, bytes: null, encoding: null, bomBytes: null, lineCount: null,
+            proof: proof(input, 'gitlink', { targetCommit: input.blobId, gitmodulesLocator: locator }),
+        };
+    }
+    if (!input.bytes)
+        return unresolved(null, 'failed', input, input.acquisitionFailure ?? { code: 'blob_unavailable', source: 'acquisition' });
+    if (input.mode === '120000') {
+        let targetPath = null;
+        try {
+            targetPath = UTF8.decode(input.bytes);
+        }
+        catch { /* metadata remains honestly unavailable */ }
+        return {
+            state: 'set_aside', subState: null, bytes: input.bytes.length, encoding: targetPath === null ? null : 'utf8',
+            bomBytes: targetPath === null ? null : 0, lineCount: null,
+            proof: proof(input, 'symlink', { targetPath, targetEncoding: targetPath === null ? 'unsupported' : 'utf8' }),
+        };
+    }
+    const bytes = input.bytes;
+    if (bytes.length === 0) {
+        return { state: 'set_aside', subState: null, bytes: 0, encoding: null, bomBytes: null,
+            lineCount: null, proof: proof(input, 'empty', { byteLength: 0 }) };
+    }
+    let text = null;
+    try {
+        text = UTF8.decode(bytes);
+    }
+    catch { /* decoding below records the actual reason */ }
+    if (text !== null && LFS_POINTER.test(text)) {
+        return { state: 'set_aside', subState: null, bytes: bytes.length, encoding: 'utf8', bomBytes: 0,
+            lineCount: text.split('\n').length, proof: proof(input, 'lfs_pointer', { byteLength: bytes.length }) };
+    }
+    const decoded = decodeCanonicalBlob(bytes);
+    if (decoded.status === 'decoded') {
+        const classification = {
+            state: 'unresolved', subState: 'pending', bytes: bytes.length, encoding: decoded.encoding,
+            bomBytes: decoded.bom?.endByte ?? 0, lineCount: decoded.lineCount, proof: null,
+        };
+        const generatedCandidate = detectGeneratedEntry({ text: decoded.text });
+        return generatedCandidate === null ? classification : { ...classification, generatedCandidate };
+    }
+    if (decoded.status === 'decode_failed')
+        return unresolved(bytes.length, 'decode_failed', input, { encoding: decoded.encoding, bomBytes: decoded.bom.endByte });
+    if (decoded.status === 'nul_bytes') {
+        const signature = BINARY_SIGNATURES.find((candidate) => candidate.matches(bytes));
+        if (signature) {
+            return { state: 'set_aside', subState: null, bytes: bytes.length, encoding: null, bomBytes: null,
+                lineCount: null, proof: proof(input, 'binary', { signature: signature.id,
+                    firstNulByte: decoded.firstNulByte, byteLength: bytes.length }) };
+        }
+        return unresolved(bytes.length, 'unknown_format', input, { firstNulByte: decoded.firstNulByte });
+    }
+    return unresolved(bytes.length, 'unsupported_encoding', input, { byteLength: bytes.length });
+}