@git.zone/tsrust 1.13.2 → 1.15.0

package/dist_ts/mod_notices/classes.nativenoticesgenerator.js

@@ -0,0 +1,946 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as smolToml from 'smol-toml';
+import { configuredAssemblyTargets } from '../mod_cli/helpers.targets.js';
+import { muslSelfContainedLibc, resolveNoticeToolchain, rustSourceLockfile, ShellNoticeCommandRunner, } from './classes.noticetoolchain.js';
+import { classifyLicenseText, describeUncoveredTerms, licenseAlternativesCovered, } from './helpers.licensetext.js';
+import { readMuslVersion } from './helpers.muslversion.js';
+import { assertNoStaticGlibc } from './helpers.staticglibc.js';
+import { resolveNoticesConfig, } from './helpers.noticesconfig.js';
+import { knownMuslVersions, readRuntimeLicenseText } from './helpers.runtimetexts.js';
+import { parseSpdxExpression } from './helpers.spdx.js';
+const noticesFormat = 'tsrust.native-notices';
+const maximumNoticeFileBytes = 4 * 1024 * 1024;
+const maximumLibcArchiveBytes = 64 * 1024 * 1024;
+const licenseFilePattern = /^(?:licen[cs]e|copying|notice|copyright|unlicense)/i;
+const acceptedFilesEntries = (directoryArg) => [
+    directoryArg,
+    `${directoryArg}/`,
+    `${directoryArg}/**`,
+    `${directoryArg}/**/*`,
+];
+const sha256 = (contentsArg) => crypto.createHash('sha256').update(contentsArg).digest('hex');
+const compareStrings = (leftArg, rightArg) => leftArg < rightArg ? -1 : leftArg > rightArg ? 1 : 0;
+const packageKey = (nameArg, versionArg) => `${nameArg}@${versionArg}`;
+const toPosix = (pathArg) => pathArg.split(path.sep).join('/');
+const isInside = (baseArg, candidateArg) => {
+    const relative = path.relative(baseArg, candidateArg);
+    return relative !== '' && !relative.startsWith('..') && !path.isAbsolute(relative);
+};
+const glibcComponent = {
+    id: 'glibc',
+    name: 'glibc',
+    license: 'LGPL-2.1-or-later',
+    files: ['runtime/glibc/lgpl-2.1.txt'],
+};
+const gccComponent = {
+    id: 'gcc',
+    name: 'gcc',
+    license: 'GPL-3.0-or-later WITH GCC-exception-3.1',
+    files: ['runtime/gcc/gpl-3.0.txt', 'runtime/gcc/runtime-library-exception-3.1.txt'],
+};
+/**
+ * Generates the third-party notices for the native executables tsrust builds:
+ * the license files of every Cargo package compiled for a configured target,
+ * the bundled C libraries those packages declare, the Rust standard library
+ * runtime, and the C runtime implied by each target's linkage.
+ */
+export class NativeNoticesGenerator {
+    options;
+    projectDir;
+    rustDir;
+    notices;
+    files = new Map();
+    usedOverrideKeys = new Set();
+    /**
+     * `resolve` may download Cargo packages; `verify` works offline from the
+     * local Cargo cache and the committed bundle, and downloads nothing.
+     */
+    mode = 'resolve';
+    constructor(options) {
+        this.options = options;
+        this.projectDir = path.resolve(options.projectDir);
+        this.rustDir = path.resolve(options.rustDir);
+        if (options.config.notices === undefined) {
+            throw new Error('Native notices are not configured: add "notices" to the @git.zone/tsrust configuration');
+        }
+        this.notices = resolveNoticesConfig(options.config.notices);
+    }
+    get directory() {
+        return path.join(this.projectDir, ...this.notices.directory.split('/'));
+    }
+    /** Builds the complete bundle in memory, downloading what it needs. */
+    async generate() {
+        return this.assemble('resolve');
+    }
+    async assemble(modeArg) {
+        this.mode = modeArg;
+        this.files.clear();
+        this.usedOverrideKeys.clear();
+        const targets = this.resolveTargets();
+        await this.assertPackageFilesShipDirectory();
+        for (const target of this.notices.runtime.keys()) {
+            if (!targets.some((candidate) => candidate.friendly === target)) {
+                throw new Error(`notices.runtime.${target} is not a notices target; configured targets: ${targets
+                    .map((entry) => entry.friendly)
+                    .join(', ')}`);
+            }
+        }
+        const packagesByKey = new Map();
+        const manifestTargets = [];
+        const runtimeDefinitions = new Map();
+        for (const target of targets) {
+            const closure = await this.readTargetClosure(target.triple);
+            for (const entry of closure) {
+                const key = packageKey(entry.name, entry.version);
+                const known = packagesByKey.get(key);
+                if (known && known.source !== entry.source) {
+                    throw new Error(`${key} resolves from two different sources`);
+                }
+                packagesByKey.set(key, entry);
+            }
+            const runtime = await this.runtimeFor(target);
+            for (const definition of runtime) {
+                const known = runtimeDefinitions.get(definition.component.id);
+                if (known && JSON.stringify(known.component) !== JSON.stringify(definition.component)) {
+                    throw new Error(`Runtime component ${definition.component.id} is declared differently for two targets`);
+                }
+                runtimeDefinitions.set(definition.component.id, definition);
+            }
+            manifestTargets.push({
+                target: target.friendly,
+                triple: target.triple,
+                linkage: target.linkage,
+                packages: closure.map((entry) => packageKey(entry.name, entry.version)).sort(compareStrings),
+                runtime: runtime.map((definition) => definition.component.id).sort(compareStrings),
+            });
+        }
+        const packages = [];
+        for (const key of [...packagesByKey.keys()].sort(compareStrings)) {
+            packages.push(await this.collectPackage(packagesByKey.get(key), 'crates'));
+        }
+        const standardLibrary = await this.collectStandardLibrary();
+        const unused = [...this.notices.packages.keys()].filter((key) => !this.usedOverrideKeys.has(key));
+        if (unused.length > 0) {
+            throw new Error(`Unused notices.packages overrides (no such package is compiled): ${unused.join(', ')}`);
+        }
+        for (const definition of [...runtimeDefinitions.values()]) {
+            for (const [name, contents] of definition.contents)
+                this.addFile(name, contents);
+        }
+        const runtime = [...runtimeDefinitions.values()]
+            .map((definition) => definition.component)
+            .sort((left, right) => compareStrings(left.id, right.id));
+        this.addFile('readme.md', Buffer.from(this.renderReadme(manifestTargets, packages, standardLibrary.packages, runtime)));
+        const fileHashes = Object.fromEntries([...this.files.keys()].sort(compareStrings).map((name) => [name, sha256(this.files.get(name))]));
+        const manifest = {
+            format: noticesFormat,
+            rust: { release: this.options.toolchain.release, commitHash: this.options.toolchain.commitHash },
+            targets: manifestTargets,
+            packages,
+            rustStandardLibrary: standardLibrary,
+            runtime,
+            files: fileHashes,
+        };
+        this.addFile('manifest.json', Buffer.from(`${JSON.stringify(manifest, null, 2)}\n`));
+        const files = new Map([...this.files.keys()].sort(compareStrings).map((name) => [name, this.files.get(name)]));
+        return { directory: this.directory, files };
+    }
+    /** Generates the bundle and replaces the notices directory with it. */
+    async write() {
+        const bundle = await this.generate();
+        const directory = bundle.directory;
+        const parent = path.dirname(directory);
+        await fs.promises.mkdir(parent, { recursive: true });
+        const existing = await this.lstatOptional(directory);
+        if (existing && (!existing.isDirectory() || existing.isSymbolicLink())) {
+            throw new Error(`Notices path is not a regular directory: ${directory}`);
+        }
+        const staging = await fs.promises.mkdtemp(path.join(parent, `.${path.basename(directory)}.tsrust-`));
+        let published = false;
+        try {
+            await fs.promises.chmod(staging, 0o755);
+            for (const [name, contents] of bundle.files) {
+                const target = path.join(staging, ...name.split('/'));
+                await fs.promises.mkdir(path.dirname(target), { recursive: true });
+                await fs.promises.writeFile(target, contents, { flag: 'wx' });
+            }
+            if (existing) {
+                const previous = `${staging}-previous`;
+                await fs.promises.rename(directory, previous);
+                await fs.promises.rename(staging, directory);
+                published = true;
+                await fs.promises.rm(previous, { recursive: true });
+            }
+            else {
+                await fs.promises.rename(staging, directory);
+                published = true;
+            }
+        }
+        finally {
+            if (!published)
+                await fs.promises.rm(staging, { recursive: true, force: true });
+        }
+        return bundle;
+    }
+    /**
+     * Verifies that the notices directory matches the bundle byte for byte,
+     * offline: it reads the local Cargo cache and the toolchain, verifies the
+     * committed standard-library notices against the toolchain's checksums,
+     * and downloads or installs nothing.
+     */
+    async check() {
+        const existing = await this.lstatOptional(this.directory);
+        if (!existing) {
+            throw new Error(`Native notices are missing at ${this.relativeDirectory}; run \`tsrust notices\` and commit the result`);
+        }
+        if (!existing.isDirectory() || existing.isSymbolicLink()) {
+            throw new Error(`Notices path is not a regular directory: ${this.directory}`);
+        }
+        const bundle = await this.assemble('verify');
+        const actual = await this.readDirectoryFiles(bundle.directory);
+        const differences = [];
+        for (const [name, contents] of bundle.files) {
+            const present = actual.get(name);
+            if (!present)
+                differences.push(`missing: ${name}`);
+            else if (!present.equals(contents))
+                differences.push(`differs: ${name}`);
+        }
+        for (const name of actual.keys()) {
+            if (!bundle.files.has(name))
+                differences.push(`unexpected: ${name}`);
+        }
+        if (differences.length > 0)
+            throw this.outOfDate(differences);
+        return bundle;
+    }
+    get relativeDirectory() {
+        return toPosix(path.relative(this.projectDir, this.directory));
+    }
+    outOfDate(differencesArg) {
+        return new Error(`Native notices at ${this.relativeDirectory} are out of date; run \`tsrust notices\` and review the diff:\n  ${differencesArg
+            .sort(compareStrings)
+            .slice(0, 40)
+            .join('\n  ')}`);
+    }
+    // -------------------------------------------------------------------------
+    // Targets and packaging
+    // -------------------------------------------------------------------------
+    resolveTargets() {
+        const targets = configuredAssemblyTargets(this.options.config);
+        if (targets.length === 0) {
+            throw new Error('Native notices require configured targets (targets or targetsByHost)');
+        }
+        return targets
+            .map(({ triple, friendly }) => {
+            if (triple.endsWith('-linux-gnu')) {
+                if (this.options.staticLinking) {
+                    assertNoStaticGlibc({ targets: [{ triple, friendly }], staticLinking: true, rustflags: [], environment: {} });
+                }
+                return { triple, friendly, linkage: 'gnu-dynamic' };
+            }
+            if (triple.endsWith('-linux-musl'))
+                return { triple, friendly, linkage: 'musl-static' };
+            if (triple.endsWith('-apple-darwin'))
+                return { triple, friendly, linkage: 'darwin' };
+            throw new Error(`Native notices do not support target ${friendly} (${triple})`);
+        })
+            .sort((left, right) => compareStrings(left.friendly, right.friendly));
+    }
+    async assertPackageFilesShipDirectory() {
+        const directory = this.notices.directory;
+        let packageJson;
+        try {
+            packageJson = JSON.parse(await fs.promises.readFile(path.join(this.projectDir, 'package.json'), 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`Native notices require a readable package.json: ${error.message}`);
+        }
+        const files = packageJson.files;
+        const entries = Array.isArray(files) ? files.filter((entry) => typeof entry === 'string') : [];
+        const excluded = entries.some((entry) => entry.startsWith(`!${directory}`));
+        if (excluded || !entries.some((entry) => acceptedFilesEntries(directory).includes(entry))) {
+            throw new Error(`package.json "files" must include "${directory}/**/*" (and exclude none of it) so the native notices ship with the package`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Cargo packages
+    // -------------------------------------------------------------------------
+    parseMetadata(outputArg) {
+        let metadata;
+        try {
+            metadata = JSON.parse(outputArg);
+        }
+        catch {
+            throw new Error('cargo metadata returned invalid JSON');
+        }
+        if (!Array.isArray(metadata?.packages) || !Array.isArray(metadata.workspace_members)) {
+            throw new Error('cargo metadata returned an unexpected shape');
+        }
+        return metadata;
+    }
+    /**
+     * Resolves every non-workspace package compiled for a target: the normal
+     * and build dependencies of the workspace's binary packages, transitively,
+     * including procedural macros. Development dependencies are excluded.
+     */
+    async readTargetClosure(tripleArg) {
+        const offline = this.mode === 'verify' ? ['--offline'] : [];
+        let output;
+        try {
+            output = await this.options.commandRunner.run('cargo', ['metadata', '--format-version', '1', '--locked', ...offline, '--filter-platform', tripleArg], this.rustDir);
+        }
+        catch (error) {
+            if (this.mode !== 'verify')
+                throw error;
+            const rustDir = toPosix(path.relative(this.projectDir, this.rustDir)) || '.';
+            throw new Error(`\`tsrust notices --check\` never downloads, and cargo metadata --offline failed. If Cargo packages are ` +
+                `missing from the local Cargo cache, run \`cargo fetch --locked\` in ${rustDir} (or \`tsrust notices\`) ` +
+                `and check again.\n${error.message}`);
+        }
+        const metadata = this.parseMetadata(output);
+        if (!Array.isArray(metadata.resolve?.nodes))
+            throw new Error('cargo metadata returned no dependency resolution');
+        const packagesById = new Map(metadata.packages.map((entry) => [entry.id, entry]));
+        const nodesById = new Map(metadata.resolve.nodes.map((node) => [node.id, node]));
+        const workspace = new Set(metadata.workspace_members);
+        const roots = metadata.workspace_members.filter((id) => packagesById.get(id)?.targets.some((target) => target.kind.includes('bin')));
+        if (roots.length === 0)
+            throw new Error('The Cargo workspace has no binary package');
+        const reached = new Set();
+        const pending = [...roots];
+        while (pending.length > 0) {
+            const id = pending.pop();
+            if (reached.has(id))
+                continue;
+            reached.add(id);
+            const node = nodesById.get(id);
+            if (!node)
+                throw new Error(`cargo metadata has no resolution for ${id}`);
+            for (const dependency of node.deps) {
+                if (dependency.dep_kinds.some((kind) => kind.kind === null || kind.kind === 'build')) {
+                    pending.push(dependency.pkg);
+                }
+            }
+        }
+        return [...reached]
+            .filter((id) => !workspace.has(id))
+            .map((id) => {
+            const entry = packagesById.get(id);
+            if (!entry)
+                throw new Error(`cargo metadata has no package ${id}`);
+            return entry;
+        });
+    }
+    licenseExpressionFor(packageArg, overrideArg) {
+        const key = packageKey(packageArg.name, packageArg.version);
+        const declared = packageArg.license;
+        let declaredError;
+        if (declared) {
+            let alternatives;
+            try {
+                alternatives = parseSpdxExpression(declared).alternatives;
+            }
+            catch (error) {
+                declaredError = error.message;
+            }
+            if (alternatives) {
+                if (overrideArg?.license !== undefined) {
+                    throw new Error(`${key} declares "${declared}"; remove notices.packages["${key}"].license`);
+                }
+                return { expression: declared, alternatives };
+            }
+        }
+        if (overrideArg?.license !== undefined) {
+            try {
+                return { expression: overrideArg.license, alternatives: parseSpdxExpression(overrideArg.license).alternatives };
+            }
+            catch (error) {
+                throw new Error(`notices.packages["${key}"].license: ${error.message}`);
+            }
+        }
+        if (declaredError)
+            throw new Error(`${key}: ${declaredError}; set notices.packages["${key}"].license`);
+        throw new Error(`${key} declares no license; set notices.packages["${key}"].license`);
+    }
+    async readRegularFile(fileArg, baseArg, scopeArg, labelArg, maximumBytesArg = maximumNoticeFileBytes) {
+        if (!isInside(baseArg, fileArg))
+            throw new Error(`${labelArg} must stay inside the ${scopeArg}`);
+        const stat = await this.lstatOptional(fileArg);
+        if (!stat)
+            throw new Error(`${labelArg} does not exist: ${fileArg}`);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error(`${labelArg} is not a regular file: ${fileArg}`);
+        if (stat.size > maximumBytesArg)
+            throw new Error(`${labelArg} exceeds its size limit: ${fileArg}`);
+        const [realBase, realFile] = await Promise.all([fs.promises.realpath(baseArg), fs.promises.realpath(fileArg)]);
+        if (!isInside(realBase, realFile))
+            throw new Error(`${labelArg} must stay inside the ${scopeArg}`);
+        return fs.promises.readFile(fileArg);
+    }
+    async collectPackage(packageArg, prefixArg) {
+        const key = packageKey(packageArg.name, packageArg.version);
+        const override = this.notices.packages.get(key);
+        if (override)
+            this.usedOverrideKeys.add(key);
+        const { expression, alternatives } = this.licenseExpressionFor(packageArg, override);
+        const crateRoot = path.dirname(path.resolve(packageArg.manifest_path));
+        const directory = `${prefixArg}/${packageArg.name}-${packageArg.version}`;
+        const collected = new Map();
+        const addCollected = (sourceArg, contentsArg, licensesArg) => {
+            const known = collected.get(sourceArg);
+            if (known) {
+                for (const license of licensesArg)
+                    known.licenses.add(license);
+                return;
+            }
+            const name = path.basename(sourceArg).toLowerCase();
+            if ([...collected.values()].some((entry) => entry.name === name)) {
+                throw new Error(`${key} has two license files named ${name}`);
+            }
+            collected.set(sourceArg, {
+                name,
+                contents: contentsArg,
+                licenses: new Set([...classifyLicenseText(contentsArg), ...licensesArg]),
+            });
+        };
+        const rootEntries = (await fs.promises.readdir(crateRoot, { withFileTypes: true }))
+            .filter((entry) => licenseFilePattern.test(entry.name) && !entry.isDirectory())
+            .map((entry) => path.join(crateRoot, entry.name));
+        if (packageArg.license_file)
+            rootEntries.push(path.resolve(crateRoot, packageArg.license_file));
+        for (const file of [...new Set(rootEntries)].sort(compareStrings)) {
+            addCollected(file, await this.readRegularFile(file, crateRoot, 'crate', `${key} license file`), []);
+        }
+        const families = () => new Set([...collected.values()].flatMap((entry) => [...entry.licenses]));
+        if (override?.files) {
+            if (licenseAlternativesCovered(alternatives, families())) {
+                throw new Error(`notices.packages["${key}"].files is no longer needed: the package's own files cover "${expression}"`);
+            }
+            for (const [index, file] of override.files.entries()) {
+                const base = file.from === 'project' ? this.projectDir : crateRoot;
+                const source = path.resolve(base, file.path);
+                addCollected(source, await this.readRegularFile(source, base, file.from, `notices.packages["${key}"].files[${index}]`), file.licenses);
+            }
+        }
+        if (!licenseAlternativesCovered(alternatives, families())) {
+            const found = [...collected.values()]
+                .map((entry) => `${entry.name} [${[...entry.licenses].sort(compareStrings).join(', ')}]`)
+                .join(', ');
+            throw new Error(`${key} (${expression}): no license text covers ${describeUncoveredTerms(alternatives, families())}; ` +
+                `found ${found || 'no license files'}. Declare reviewed texts in notices.packages["${key}"].files`);
+        }
+        const files = [...collected.values()]
+            .sort((left, right) => compareStrings(left.name, right.name))
+            .map((entry) => {
+            const filePath = `${directory}/${entry.name}`;
+            this.addFile(filePath, entry.contents);
+            return { path: filePath, licenses: [...entry.licenses].sort(compareStrings) };
+        });
+        const result = {
+            name: packageArg.name,
+            version: packageArg.version,
+            source: packageArg.source ?? 'local',
+            license: expression,
+            files,
+        };
+        if (packageArg.links && override?.native === undefined) {
+            throw new Error(`${key} links native library "${packageArg.links}"; declare the C/C++ libraries it compiles in ` +
+                `notices.packages["${key}"].native ([] when it bundles none)`);
+        }
+        if (override?.native && override.native.length > 0) {
+            result.native = [];
+            for (const component of override.native) {
+                result.native.push(await this.collectNativeComponent(key, packageArg, crateRoot, component));
+            }
+        }
+        const extraTexts = await this.collectExtraTexts(key, directory, override);
+        if (extraTexts.length > 0)
+            result.extraTexts = extraTexts;
+        return result;
+    }
+    /**
+     * Copies the reviewed extra texts the project declares for a package into
+     * `<directory>/extra/`, after verifying each against its SHA-256 pin. They
+     * are collected after the coverage check and never count towards it.
+     */
+    async collectExtraTexts(keyArg, directoryArg, overrideArg) {
+        const extraTexts = [];
+        for (const [index, text] of (overrideArg?.extraTexts || []).entries()) {
+            const label = `notices.packages["${keyArg}"].extraTexts[${index}] (${text.path})`;
+            const contents = await this.readRegularFile(path.resolve(this.projectDir, text.path), this.projectDir, 'project', label);
+            const digest = sha256(contents);
+            if (digest !== text.sha256) {
+                throw new Error(`${label} has SHA-256 ${digest}, but its pin is ${text.sha256}; review the text and update the pin`);
+            }
+            const filePath = `${directoryArg}/extra/${path.posix.basename(text.path).toLowerCase()}`;
+            if (extraTexts.some((entry) => entry.path === filePath)) {
+                throw new Error(`notices.packages["${keyArg}"].extraTexts has two files named ${path.posix.basename(filePath)}`);
+            }
+            this.addFile(filePath, contents);
+            extraTexts.push({ path: filePath, kind: text.kind, ...(text.component ? { component: text.component } : {}) });
+        }
+        return extraTexts.sort((left, right) => compareStrings(left.path, right.path));
+    }
+    async collectNativeComponent(keyArg, packageArg, crateRootArg, componentArg) {
+        const label = `${keyArg} native component ${componentArg.name}@${componentArg.version}`;
+        let alternatives;
+        try {
+            alternatives = parseSpdxExpression(componentArg.license).alternatives;
+        }
+        catch (error) {
+            throw new Error(`${label}: ${error.message}`);
+        }
+        const directory = `native/${packageArg.name}-${packageArg.version}/${componentArg.name}-${componentArg.version}`;
+        const files = [];
+        const families = new Set();
+        for (const file of componentArg.files) {
+            const contents = await this.readRegularFile(path.resolve(crateRootArg, file), crateRootArg, 'crate', `${label} file ${file}`);
+            const licenses = classifyLicenseText(contents).sort(compareStrings);
+            for (const license of licenses)
+                families.add(license);
+            const filePath = `${directory}/${file.toLowerCase().split('/').join('-')}`;
+            if (files.some((entry) => entry.path === filePath))
+                throw new Error(`${label} lists ${file} twice`);
+            this.addFile(filePath, contents);
+            files.push({ path: filePath, licenses });
+        }
+        if (!licenseAlternativesCovered(alternatives, families)) {
+            throw new Error(`${label} (${componentArg.license}): no license text covers ${describeUncoveredTerms(alternatives, families)}`);
+        }
+        return {
+            name: componentArg.name,
+            version: componentArg.version,
+            license: componentArg.license,
+            files: files.sort((left, right) => compareStrings(left.path, right.path)),
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Rust standard library
+    // -------------------------------------------------------------------------
+    async collectStandardLibrary() {
+        const sysroot = this.options.toolchain.sysroot;
+        const documentation = path.join(sysroot, 'share', 'doc', 'rust');
+        const release = this.options.toolchain.release;
+        const files = [];
+        const addSysrootFile = async (sourceArg, targetArg) => {
+            this.addFile(targetArg, await this.readRegularFile(sourceArg, sysroot, 'toolchain', `Rust ${release} runtime notice`));
+            files.push(targetArg);
+        };
+        const copyright = path.join(documentation, 'COPYRIGHT-library.html');
+        await addSysrootFile(copyright, 'rust/copyright-library.html');
+        const licenses = (await fs.promises.readdir(path.join(documentation, 'licenses'), { withFileTypes: true }))
+            .filter((entry) => !entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort(compareStrings);
+        if (licenses.length === 0)
+            throw new Error(`Rust ${release} ships no license texts in ${documentation}`);
+        for (const license of licenses) {
+            await addSysrootFile(path.join(documentation, 'licenses', license), `rust/licenses/${license.toLowerCase()}`);
+        }
+        const lockfile = smolToml.parse(await fs.promises.readFile(rustSourceLockfile(sysroot), 'utf8'));
+        const registryPackages = [];
+        for (const entry of lockfile.package || []) {
+            if (typeof entry.source !== 'string' || !entry.source.startsWith('registry+'))
+                continue;
+            if (typeof entry.name !== 'string' || typeof entry.version !== 'string' || typeof entry.checksum !== 'string') {
+                throw new Error(`Rust ${release} library/Cargo.lock has an incomplete registry package`);
+            }
+            registryPackages.push({ name: entry.name, version: entry.version, checksum: entry.checksum });
+        }
+        const builtins = path.join(path.dirname(rustSourceLockfile(sysroot)), 'compiler-builtins', 'LICENSE.txt');
+        if (await this.lstatOptional(builtins)) {
+            await addSysrootFile(builtins, 'rust/compiler-builtins-license.txt');
+        }
+        else if (!registryPackages.some((entry) => entry.name === 'compiler_builtins')) {
+            throw new Error(`Rust ${release} rust-src has no compiler-builtins license`);
+        }
+        // The toolchain inventory lists the standard library's crates.io
+        // dependencies, but not all of them; fetch the license files of the rest.
+        const inventory = await fs.promises.readFile(copyright, 'utf8');
+        const listed = new Set([...inventory.matchAll(/📦 ([^<\s]+)<\/h3>/gu)].map((match) => match[1]));
+        if (listed.size === 0)
+            throw new Error(`Rust ${release} COPYRIGHT-library.html has an unrecognised format`);
+        const gaps = registryPackages
+            .filter((entry) => !listed.has(`${entry.name}-${entry.version}`))
+            .sort((left, right) => compareStrings(packageKey(left.name, left.version), packageKey(right.name, right.version)));
+        if (this.mode === 'verify') {
+            return { files, packages: await this.committedStandardLibraryPackages(gaps) };
+        }
+        const packages = [];
+        const resolved = await this.resolveStandardLibraryGaps(gaps);
+        for (const [index, entry] of resolved.entries()) {
+            const collected = await this.collectPackage(entry, 'rust/crates');
+            packages.push({
+                name: collected.name,
+                version: collected.version,
+                source: collected.source,
+                checksum: gaps[index].checksum,
+                license: collected.license,
+                files: collected.files,
+                ...(collected.native ? { native: collected.native } : {}),
+                ...(collected.extraTexts ? { extraTexts: collected.extraTexts } : {}),
+            });
+        }
+        return { files, packages };
+    }
+    /**
+     * Offline counterpart of `resolveStandardLibraryGaps`: the committed notices
+     * must cover exactly the toolchain's uninventoried dependencies with the
+     * checksums of its library/Cargo.lock, and their files must match the
+     * committed digests.
+     */
+    async committedStandardLibraryPackages(gapsArg) {
+        const stale = (detailArg) => new Error(`${detailArg}; run \`tsrust notices\` and review the diff`);
+        let committed;
+        try {
+            committed = JSON.parse(await fs.promises.readFile(path.join(this.directory, 'manifest.json'), 'utf8'));
+        }
+        catch {
+            throw stale(`Native notices at ${this.relativeDirectory} have no readable manifest.json`);
+        }
+        const entries = committed.rustStandardLibrary?.packages;
+        const hashes = committed.files;
+        if (!Array.isArray(entries) || !hashes || typeof hashes !== 'object' || Array.isArray(hashes)) {
+            throw stale(`Native notices at ${this.relativeDirectory} have a malformed manifest.json`);
+        }
+        const isString = (valueArg) => typeof valueArg === 'string' && valueArg.length > 0;
+        const readFiles = (valueArg) => {
+            if (!Array.isArray(valueArg))
+                throw stale('manifest.json lists malformed standard-library files');
+            return valueArg.map((file) => {
+                const entry = file;
+                if (!isString(entry.path) || !Array.isArray(entry.licenses) || !entry.licenses.every(isString)) {
+                    throw stale('manifest.json lists malformed standard-library files');
+                }
+                return { path: entry.path, licenses: entry.licenses };
+            });
+        };
+        const packages = entries.map((raw) => {
+            const entry = raw;
+            if (![entry.name, entry.version, entry.source, entry.checksum, entry.license].every(isString)) {
+                throw stale('manifest.json lists a malformed standard-library package');
+            }
+            const result = {
+                name: entry.name,
+                version: entry.version,
+                source: entry.source,
+                checksum: entry.checksum,
+                license: entry.license,
+                files: readFiles(entry.files),
+            };
+            if (entry.native !== undefined) {
+                if (!Array.isArray(entry.native))
+                    throw stale('manifest.json lists malformed native components');
+                result.native = entry.native.map((nativeRaw) => {
+                    const component = nativeRaw;
+                    if (![component.name, component.version, component.license].every(isString)) {
+                        throw stale('manifest.json lists malformed native components');
+                    }
+                    return {
+                        name: component.name,
+                        version: component.version,
+                        license: component.license,
+                        files: readFiles(component.files),
+                    };
+                });
+            }
+            return result;
+        });
+        const describe = (listArg) => listArg.map((entry) => `${packageKey(entry.name, entry.version)} (${entry.checksum})`).join(', ') || 'none';
+        if (describe(packages) !== describe(gapsArg)) {
+            throw stale(`The standard-library dependencies of Rust ${this.options.toolchain.release} missing from its inventory ` +
+                `are ${describe(gapsArg)}, but the committed notices cover ${describe(packages)}`);
+        }
+        const differences = [];
+        for (const entry of packages) {
+            const key = packageKey(entry.name, entry.version);
+            const override = this.notices.packages.get(key);
+            if (override)
+                this.usedOverrideKeys.add(key);
+            // Licenses are re-derived as `collectPackage` derives them: the text's
+            // classification plus the identifiers an override declares for it.
+            const declared = new Map();
+            for (const file of override?.files || []) {
+                const name = path.posix.basename(file.path).toLowerCase();
+                declared.set(name, [...(declared.get(name) || []), ...file.licenses]);
+            }
+            const fileGroups = [
+                { prefix: `rust/crates/${entry.name}-${entry.version}/`, files: entry.files, declared },
+                ...(entry.native || []).map((component) => ({
+                    prefix: `native/${entry.name}-${entry.version}/${component.name}-${component.version}/`,
+                    files: component.files,
+                    declared: new Map(),
+                })),
+            ];
+            for (const group of fileGroups) {
+                for (const file of group.files) {
+                    if (!file.path.startsWith(group.prefix) || file.path.split('/').some((segment) => segment === '..')) {
+                        throw stale(`manifest.json lists ${file.path} outside ${group.prefix}`);
+                    }
+                    const committedFile = path.join(this.directory, ...file.path.split('/'));
+                    const stat = await this.lstatOptional(committedFile);
+                    if (!stat || !stat.isFile() || stat.isSymbolicLink()) {
+                        differences.push(`missing: ${file.path}`);
+                        continue;
+                    }
+                    const contents = await fs.promises.readFile(committedFile);
+                    if (sha256(contents) !== hashes[file.path]) {
+                        differences.push(`differs: ${file.path}`);
+                        continue;
+                    }
+                    this.addFile(file.path, contents);
+                    file.licenses = [
+                        ...new Set([...classifyLicenseText(contents), ...(group.declared.get(path.posix.basename(file.path)) || [])]),
+                    ].sort(compareStrings);
+                }
+            }
+            const families = new Set(entry.files.flatMap((file) => file.licenses));
+            let alternatives;
+            try {
+                alternatives = parseSpdxExpression(entry.license).alternatives;
+            }
+            catch (error) {
+                throw stale(`${key}: ${error.message}`);
+            }
+            if (!licenseAlternativesCovered(alternatives, families)) {
+                throw stale(`${key} (${entry.license}): the committed texts do not cover ${describeUncoveredTerms(alternatives, families)}`);
+            }
+            // Extra texts are read from the project and verified against their pins.
+            const extraTexts = await this.collectExtraTexts(key, `rust/crates/${entry.name}-${entry.version}`, override);
+            if (extraTexts.length > 0)
+                entry.extraTexts = extraTexts;
+        }
+        if (differences.length > 0)
+            throw this.outOfDate(differences);
+        return packages;
+    }
+    async resolveStandardLibraryGaps(gapsArg) {
+        if (gapsArg.length === 0)
+            return [];
+        const workspace = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'tsrust-notices-std-'));
+        try {
+            const dependencies = gapsArg
+                .map((entry, index) => `dependency${index} = { package = "${entry.name}", version = "=${entry.version}", default-features = false }`)
+                .join('\n');
+            await fs.promises.writeFile(path.join(workspace, 'Cargo.toml'), `[package]\nname = "tsrust-notices-standard-library"\nversion = "0.0.0"\nedition = "2021"\npublish = false\n\n[lib]\npath = "lib.rs"\n\n[dependencies]\n${dependencies}\n`);
+            await fs.promises.writeFile(path.join(workspace, 'lib.rs'), '');
+            // Run from the Rust directory so the project's Cargo configuration
+            // (registry mirrors, vendored sources) applies.
+            const metadata = this.parseMetadata(await this.options.commandRunner.run('cargo', ['metadata', '--format-version', '1', '--manifest-path', path.join(workspace, 'Cargo.toml')], this.rustDir));
+            const lockfile = smolToml.parse(await fs.promises.readFile(path.join(workspace, 'Cargo.lock'), 'utf8'));
+            return gapsArg.map((gap) => {
+                const key = packageKey(gap.name, gap.version);
+                const resolved = metadata.packages.find((entry) => entry.name === gap.name && entry.version === gap.version && entry.source?.startsWith('registry+'));
+                const locked = (lockfile.package || []).find((entry) => entry.name === gap.name && entry.version === gap.version);
+                if (!resolved || !locked)
+                    throw new Error(`Could not resolve standard-library dependency ${key}`);
+                if (locked.checksum !== gap.checksum) {
+                    throw new Error(`Standard-library dependency ${key} resolved with checksum ${String(locked.checksum)}, but the toolchain records ${gap.checksum}`);
+                }
+                return resolved;
+            });
+        }
+        finally {
+            await fs.promises.rm(workspace, { recursive: true, force: true });
+        }
+    }
+    // -------------------------------------------------------------------------
+    // C runtime
+    // -------------------------------------------------------------------------
+    async runtimeFor(targetArg) {
+        const definitions = [];
+        if (targetArg.linkage === 'musl-static') {
+            const libc = muslSelfContainedLibc(this.options.toolchain.sysroot, targetArg.triple);
+            const version = readMuslVersion(await this.readRegularFile(libc, this.options.toolchain.sysroot, 'toolchain', `musl libc for ${targetArg.friendly}`, maximumLibcArchiveBytes));
+            if (!knownMuslVersions.includes(version)) {
+                throw new Error(`Rust ${this.options.toolchain.release} links musl ${version} into ${targetArg.friendly}; tsrust has no reviewed copyright text for musl ${version}`);
+            }
+            const file = `runtime/musl-${version}/copyright`;
+            definitions.push({
+                component: { id: `musl-${version}`, name: 'musl', version, license: 'MIT', files: [file] },
+                contents: new Map([[file, await readRuntimeLicenseText('musl')]]),
+            });
+        }
+        if (targetArg.linkage === 'gnu-dynamic') {
+            definitions.push({
+                component: glibcComponent,
+                contents: new Map([[glibcComponent.files[0], await readRuntimeLicenseText('glibc-lgpl-2.1')]]),
+            });
+        }
+        if (targetArg.linkage !== 'darwin') {
+            definitions.push({
+                component: gccComponent,
+                contents: new Map([
+                    [gccComponent.files[0], await readRuntimeLicenseText('gcc-gpl-3.0')],
+                    [gccComponent.files[1], await readRuntimeLicenseText('gcc-runtime-library-exception-3.1')],
+                ]),
+            });
+        }
+        for (const component of this.notices.runtime.get(targetArg.friendly) || []) {
+            definitions.push(await this.configuredRuntime(targetArg, component));
+        }
+        const ids = definitions.map((definition) => definition.component.id);
+        if (new Set(ids).size !== ids.length) {
+            throw new Error(`notices.runtime.${targetArg.friendly} repeats a runtime component: ${ids.join(', ')}`);
+        }
+        return definitions;
+    }
+    async configuredRuntime(targetArg, componentArg) {
+        const id = componentArg.version ? `${componentArg.name}-${componentArg.version}` : componentArg.name;
+        const label = `notices.runtime.${targetArg.friendly} component ${id}`;
+        let alternatives;
+        try {
+            alternatives = parseSpdxExpression(componentArg.license).alternatives;
+        }
+        catch (error) {
+            throw new Error(`${label}: ${error.message}`);
+        }
+        const contents = new Map();
+        const families = new Set();
+        for (const file of componentArg.files) {
+            const data = await this.readRegularFile(path.resolve(this.projectDir, file), this.projectDir, 'project', `${label} file ${file}`);
+            for (const license of classifyLicenseText(data))
+                families.add(license);
+            const name = `runtime/${id}/${path.posix.basename(file).toLowerCase()}`;
+            if (contents.has(name))
+                throw new Error(`${label} has two files named ${path.posix.basename(name)}`);
+            contents.set(name, data);
+        }
+        if (!licenseAlternativesCovered(alternatives, families)) {
+            throw new Error(`${label} (${componentArg.license}): no license text covers ${describeUncoveredTerms(alternatives, families)}`);
+        }
+        return {
+            component: {
+                id,
+                name: componentArg.name,
+                ...(componentArg.version ? { version: componentArg.version } : {}),
+                license: componentArg.license,
+                files: [...contents.keys()].sort(compareStrings),
+            },
+            contents,
+        };
+    }
+    // -------------------------------------------------------------------------
+    // Output
+    // -------------------------------------------------------------------------
+    addFile(nameArg, contentsArg) {
+        const known = this.files.get(nameArg);
+        if (known && !known.equals(contentsArg))
+            throw new Error(`Two different notices map to ${nameArg}`);
+        this.files.set(nameArg, contentsArg);
+    }
+    renderReadme(targetsArg, packagesArg, standardLibraryPackagesArg, runtimeArg) {
+        const toolchain = this.options.toolchain;
+        const lockfile = toPosix(path.relative(this.projectDir, path.join(this.rustDir, 'Cargo.lock')));
+        const linkageLabel = {
+            'gnu-dynamic': 'dynamic glibc',
+            'musl-static': 'static musl',
+            darwin: 'macOS system libraries',
+        };
+        const lines = [
+            '# Native distribution notices',
+            '',
+            `Generated by \`tsrust notices\` from \`${lockfile}\`, the Rust ${toolchain.release} toolchain`,
+            `(commit \`${toolchain.commitHash}\`)`,
+            'and the `@git.zone/tsrust` configuration. Do not edit these files by hand:',
+            '`tsrust notices --check` verifies them before every build.',
+            '',
+            'These notices accompany the native executables built for the targets below. The',
+            "package's own code is covered by its own license.",
+            '',
+            '## Targets',
+            '',
+            '| Target | Rust target | Linkage | Cargo packages |',
+            '| --- | --- | --- | --- |',
+            ...targetsArg.map((target) => `| ${target.target} | ${target.triple} | ${linkageLabel[target.linkage]} | ${target.packages.length} |`),
+            '',
+            '## Contents',
+            '',
+            `- \`crates/\`: the license and notice files of the ${packagesArg.length} third-party Cargo packages compiled`,
+            '  for these targets (normal and build dependencies, including procedural macros;',
+            '  development dependencies are excluded), copied verbatim. `manifest.json` records each',
+            "  package's license expression, the texts that cover it, and the targets it is built for.",
+        ];
+        if ([...packagesArg, ...standardLibraryPackagesArg].some((entry) => entry.extraTexts)) {
+            lines.push('- `crates/<package>/extra/` (and `rust/crates/<package>/extra/`): reviewed texts the project ships', '  with a package beyond those that cover its license, such as the licenses of components it', '  vendors or attributions reproduced from its sources. `manifest.json` records their kind.');
+        }
+        if (packagesArg.some((entry) => entry.native)) {
+            lines.push('- `native/`: the license files of C and C++ libraries that Cargo packages compile into', '  the executables.');
+        }
+        lines.push('- `rust/`: the Rust standard library copyright inventory and license texts from the', "  toolchain, and compiler-builtins' license.");
+        if (standardLibraryPackagesArg.length > 0) {
+            lines.push(`  \`rust/crates/\` holds the license files of ${standardLibraryPackagesArg.length} standard-library dependencies the`, '  inventory does not list.');
+        }
+        if (runtimeArg.length > 0) {
+            lines.push('- `runtime/`: license texts of the C runtime described below.');
+        }
+        lines.push('- `manifest.json`: the inventory and the SHA-256 digest of every other file.', '', '## Runtime libraries', '');
+        for (const component of runtimeArg) {
+            if (component.name === 'musl') {
+                lines.push(`The static musl executables contain musl ${component.version}, the C library shipped with the Rust`, `toolchain, under the MIT license (\`${component.files[0]}\`).`, '');
+            }
+            else if (component.id === 'glibc') {
+                lines.push('The glibc executables load the GNU C Library, licensed under the GNU Lesser General Public', `License version 2.1 or later (\`${component.files[0]}\`), from the host system at run time. glibc is`, 'not redistributed with this package, and users may replace it with a modified,', 'interface-compatible version.', '');
+            }
+            else if (component.id === 'gcc') {
+                lines.push('The Linux executables may contain GCC runtime startup code and support routines, licensed', 'under the GNU General Public License version 3 or later with the GCC Runtime Library', `Exception 3.1 (\`runtime/gcc/\`). The exception permits distributing the executables under`, "the package's own terms.", '');
+            }
+            else {
+                lines.push(`${component.name}${component.version ? ` ${component.version}` : ''} (${component.license}) is declared by the project; its`, `license texts are in \`runtime/${component.id}/\`.`, '');
+            }
+        }
+        if (targetsArg.some((target) => target.linkage === 'darwin')) {
+            lines.push("The macOS executables link Apple's system libraries, which are not redistributed with", 'this package.', '');
+        }
+        lines.push('The Rust standard library and its runtime (including LLVM libunwind in static musl', 'executables) are covered by `rust/`.', '');
+        return lines.join('\n');
+    }
+    async readDirectoryFiles(directoryArg) {
+        const result = new Map();
+        const walk = async (currentArg) => {
+            for (const entry of await fs.promises.readdir(currentArg, { withFileTypes: true })) {
+                const entryPath = path.join(currentArg, entry.name);
+                const name = toPosix(path.relative(directoryArg, entryPath));
+                if (entry.isDirectory())
+                    await walk(entryPath);
+                else if (entry.isFile())
+                    result.set(name, await fs.promises.readFile(entryPath));
+                else
+                    throw new Error(`Notices directory contains a non-regular entry: ${name}`);
+            }
+        };
+        await walk(directoryArg);
+        return result;
+    }
+    async lstatOptional(pathArg) {
+        try {
+            return await fs.promises.lstat(pathArg);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return undefined;
+            throw error;
+        }
+    }
+}
+/**
+ * Creates a generator for a project built with the toolchain behind
+ * `envPrefix`, installing the toolchain components notices read from.
+ */
+export async function createProjectNoticesGenerator(optionsArg) {
+    const commandRunner = new ShellNoticeCommandRunner(optionsArg.envPrefix);
+    const toolchain = await resolveNoticeToolchain(commandRunner, optionsArg.rustDir, configuredAssemblyTargets(optionsArg.config).map((target) => target.triple), optionsArg.install);
+    return new NativeNoticesGenerator({
+        projectDir: optionsArg.projectDir,
+        rustDir: optionsArg.rustDir,
+        config: optionsArg.config,
+        staticLinking: optionsArg.staticLinking,
+        toolchain,
+        commandRunner,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.nativenoticesgenerator.js","sourceRoot":"","sources":["../../ts/mod_notices/classes.nativenoticesgenerator.ts"],"names":[],"mappings":"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"}