expect(result.contentType).toBe("text/plain");

});

it("rejects host-read LOG files even though they map to text/plain", async () => {

const logFile = path.join(fixtureRoot, "debug.log");

await fs.writeFile(logFile, "plain text\n", "utf8");

await expect(

loadWebMedia(logFile, {

maxBytes: 1024 * 1024,

localRoots: "any",

readFile: async (filePath) => await fs.readFile(filePath),

hostReadCapability: true,

}),

).rejects.toMatchObject({

code: "path-not-allowed",

});

});

it("rejects renamed host-read text files even when the extension looks allowed", async () => {

const disguisedPdf = path.join(fixtureRoot, "secret.pdf");

await fs.writeFile(disguisedPdf, "secret", "utf8");

const HOST_READ_DECLARED_TEXT_ERROR =

"hostReadCapability permits only validated plain-text documents " +

"and trusted generated HTML reports for local reads";

const HOST_READ_TEXT_PLAIN_EXTENSION_BY_MIME: Record<string, readonly string[]> = {

"text/plain": [".txt"],

};

const MB = 1024 * 1024;

function stripLegacyMediaDirectivePrefix(mediaUrl: string): string {

return text !== undefined && hasHtmlDocumentShape(text);

}

function isAllowedHostReadTextAlias(mime: string | undefined, filePath?: string): boolean {

if (!mime || !HOST_READ_TEXT_PLAIN_ALIASES.has(mime)) {

return false;

}

const allowedExtensions = HOST_READ_TEXT_PLAIN_EXTENSION_BY_MIME[mime];

if (!allowedExtensions) {

return true;

}

const ext = getFileExtension(filePath);

return !!ext && allowedExtensions.includes(ext);

}

function formatMb(bytes: number, digits = 2): string {

return (bytes / MB).toFixed(digits);

}

return;

}

if (

HOST_READ_TEXT_PLAIN_ALIASES.has(declaredMime) &&

isAllowedHostReadTextAlias(declaredMime, params.filePath) &&

!params.sniffedContentType &&

params.buffer &&

isValidatedHostReadText(params.buffer)

if (

!sniffedMime &&

normalizedMime &&

HOST_READ_TEXT_PLAIN_ALIASES.has(normalizedMime) &&

isAllowedHostReadTextAlias(normalizedMime, params.filePath) &&

params.buffer &&

isValidatedHostReadText(params.buffer)

) {