@git.zone/tsrust 1.13.2 → 1.15.0

package/dist_ts/mod_notices/classes.noticetoolchain.d.ts

@@ -0,0 +1,30 @@
+/** Runs a toolchain command in a directory and returns its standard output. */
+export interface INoticeCommandRunner {
+    run(commandArg: string, argsArg: string[], cwdArg: string): Promise<string>;
+}
+/**
+ * Runs commands through bash behind an optional toolchain environment prefix
+ * (see `ToolchainManager.getEnvPrefix`), the way tsrust runs Cargo.
+ */
+export declare class ShellNoticeCommandRunner implements INoticeCommandRunner {
+    private readonly envPrefix;
+    private readonly shell;
+    constructor(envPrefix?: string);
+    run(commandArg: string, argsArg: string[], cwdArg: string): Promise<string>;
+}
+/** The Rust toolchain whose runtime the notices describe. */
+export interface INoticeToolchain {
+    release: string;
+    commitHash: string;
+    /** Absolute toolchain sysroot, as printed by `rustc --print sysroot`. */
+    sysroot: string;
+}
+export declare const rustSourceLockfile: (sysrootArg: string) => string;
+export declare const muslSelfContainedLibc: (sysrootArg: string, tripleArg: string) => string;
+/**
+ * Identifies the toolchain that builds `rustDir` and makes sure it has what
+ * notice generation reads: the `rust-src` component and the musl targets.
+ * With `installArg` false (every check) it installs nothing and names the
+ * missing component instead.
+ */
+export declare function resolveNoticeToolchain(runnerArg: INoticeCommandRunner, rustDirArg: string, triplesArg: string[], installArg: boolean): Promise<INoticeToolchain>;

package/dist_ts/mod_notices/classes.noticetoolchain.js

@@ -0,0 +1,69 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as plugins from '../plugins.js';
+const shellQuote = (valueArg) => `'${valueArg.replace(/'/g, `'"'"'`)}'`;
+/**
+ * Runs commands through bash behind an optional toolchain environment prefix
+ * (see `ToolchainManager.getEnvPrefix`), the way tsrust runs Cargo.
+ */
+export class ShellNoticeCommandRunner {
+    envPrefix;
+    shell = new plugins.smartshell.Smartshell({ executor: 'bash' });
+    constructor(envPrefix = '') {
+        this.envPrefix = envPrefix;
+    }
+    async run(commandArg, argsArg, cwdArg) {
+        const commandLine = [commandArg, ...argsArg].map(shellQuote).join(' ');
+        const result = await this.shell.execSilent(`${this.envPrefix}cd ${shellQuote(cwdArg)} && ${commandLine}`);
+        if (result.exitCode !== 0) {
+            throw new Error(`${commandArg} ${argsArg.join(' ')} failed with exit code ${result.exitCode}: ${result.stderr.trim().slice(-4000)}`);
+        }
+        return result.stdout;
+    }
+}
+const exists = async (pathArg) => {
+    try {
+        await fs.promises.access(pathArg);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const rustSourceLockfile = (sysrootArg) => path.join(sysrootArg, 'lib', 'rustlib', 'src', 'rust', 'library', 'Cargo.lock');
+export const muslSelfContainedLibc = (sysrootArg, tripleArg) => path.join(sysrootArg, 'lib', 'rustlib', tripleArg, 'lib', 'self-contained', 'libc.a');
+/**
+ * Identifies the toolchain that builds `rustDir` and makes sure it has what
+ * notice generation reads: the `rust-src` component and the musl targets.
+ * With `installArg` false (every check) it installs nothing and names the
+ * missing component instead.
+ */
+export async function resolveNoticeToolchain(runnerArg, rustDirArg, triplesArg, installArg) {
+    const verbose = await runnerArg.run('rustc', ['-vV'], rustDirArg);
+    const release = /^release: (\S+)$/m.exec(verbose)?.[1];
+    const commitHash = /^commit-hash: ([0-9a-f]{40})$/m.exec(verbose)?.[1];
+    if (!release || !commitHash) {
+        throw new Error('rustc -vV did not report a release and commit hash');
+    }
+    const sysroot = (await runnerArg.run('rustc', ['--print', 'sysroot'], rustDirArg)).trim();
+    if (!path.isAbsolute(sysroot))
+        throw new Error(`rustc reported a relative sysroot: ${sysroot}`);
+    const ensure = async (presentArg, installArgs, labelArg) => {
+        if (await exists(presentArg))
+            return;
+        const command = `rustup ${installArgs.join(' ')}`;
+        if (!installArg) {
+            throw new Error(`${labelArg} of Rust ${release} is not installed; run \`${command}\` (checks install nothing)`);
+        }
+        await runnerArg.run('rustup', installArgs, rustDirArg);
+        if (!(await exists(presentArg))) {
+            throw new Error(`${labelArg} of Rust ${release} is still missing at ${sysroot} after \`${command}\``);
+        }
+    };
+    await ensure(rustSourceLockfile(sysroot), ['component', 'add', 'rust-src'], 'The rust-src component');
+    for (const triple of triplesArg.filter((triple) => triple.endsWith('-linux-musl'))) {
+        await ensure(muslSelfContainedLibc(sysroot, triple), ['target', 'add', triple], `The ${triple} target`);
+    }
+    return { release, commitHash, sysroot };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_notices/helpers.licensetext.d.ts

@@ -0,0 +1,12 @@
+import type { ISpdxTerm } from './helpers.spdx.js';
+/** Returns the license text families a file contains, in a stable order. */
+export declare function classifyLicenseText(contentsArg: Buffer): string[];
+/**
+ * Maps an SPDX identifier onto the license text it requires: `-only`,
+ * `-or-later` and `+` select a version range of the same text.
+ */
+export declare function licenseTextFamily(identifierArg: string): string;
+/** True when the available license texts satisfy every term of one alternative. */
+export declare function licenseAlternativesCovered(alternativesArg: ISpdxTerm[][], familiesArg: ReadonlySet<string>): boolean;
+/** Formats the terms a set of texts leaves uncovered, for error messages. */
+export declare function describeUncoveredTerms(alternativesArg: ISpdxTerm[][], familiesArg: ReadonlySet<string>): string;

package/dist_ts/mod_notices/helpers.licensetext.js

@@ -0,0 +1,81 @@
+const has = (...phrasesArg) => (textArg) => phrasesArg.every((phrase) => textArg.includes(phrase));
+// MIT-0 grants the MIT permissions without MIT's notice condition.
+const mitGrant = 'permission is hereby granted, free of charge, to any person obtaining a copy';
+const mitCondition = 'subject to the following conditions';
+const iscGrant = /permission to use, copy, modify, (?:and\/or |and )distribute this software for any purpose with or without fee is hereby granted/;
+const iscCondition = 'provided that the above copyright notice and this permission notice appear in all copies';
+const bsdRedistribution = 'redistribution and use in source and binary forms';
+const bsdEndorsement = /neither the name|may (?:not )?be used to endorse or promote products derived from this software/;
+/**
+ * Phrases that identify a license text. They are chosen from the operative
+ * wording, so a file that merely names a license (a README or a short
+ * "licensed under X or Y" note) is not mistaken for the text itself.
+ */
+const fingerprints = [
+    { family: 'MIT', matches: (textArg) => textArg.includes(mitGrant) && textArg.includes(mitCondition) },
+    { family: 'MIT-0', matches: (textArg) => textArg.includes(mitGrant) && !textArg.includes(mitCondition) },
+    {
+        family: 'Apache-2.0',
+        matches: has('apache license', 'version 2.0', 'terms and conditions for use, reproduction, and distribution'),
+    },
+    { family: 'LLVM-exception', matches: has('llvm exceptions to the apache 2.0 license') },
+    { family: 'Unlicense', matches: has('this is free and unencumbered software released into the public domain') },
+    { family: 'BSD-3-Clause', matches: (textArg) => textArg.includes(bsdRedistribution) && bsdEndorsement.test(textArg) },
+    { family: 'BSD-2-Clause', matches: (textArg) => textArg.includes(bsdRedistribution) && !bsdEndorsement.test(textArg) },
+    { family: 'ISC', matches: (textArg) => iscGrant.test(textArg) && textArg.includes(iscCondition) },
+    { family: '0BSD', matches: (textArg) => iscGrant.test(textArg) && !textArg.includes(iscCondition) },
+    {
+        family: 'Zlib',
+        matches: has("this software is provided 'as-is', without any express or implied warranty", 'altered source versions must be plainly marked as such'),
+    },
+    { family: 'Unicode-3.0', matches: has('unicode license v3') },
+    { family: 'Unicode-DFS-2016', matches: has('unicode, inc. license agreement - data files and software') },
+    { family: 'BSL-1.0', matches: has('boost software license - version 1.0') },
+    { family: 'CC0-1.0', matches: has('cc0 1.0 universal') },
+    { family: 'MPL-2.0', matches: has('mozilla public license version 2.0') },
+    {
+        family: 'GPL-2.0',
+        matches: has('gnu general public license', 'version 2, june 1991', 'the gnu general public license is intended to guarantee'),
+    },
+    { family: 'GPL-3.0', matches: has('the gnu general public license is a free, copyleft license') },
+    { family: 'LGPL-2.1', matches: has('gnu lesser general public license', 'version 2.1, february 1999') },
+    { family: 'LGPL-3.0', matches: has('gnu lesser general public license', 'version 3, 29 june 2007') },
+    { family: 'GCC-exception-3.1', matches: has('gcc runtime library exception', 'version 3.1') },
+];
+// Line prefixes of license texts kept as source comments.
+const commentPrefix = /^[ \t]*(?:\/\/+|\/\*+|\*+|#+|--|;+)[ \t]?/gm;
+const normalizeText = (bufferArg) => bufferArg
+    .toString('utf8')
+    .replace(commentPrefix, '')
+    .toLowerCase()
+    .replace(/[‘’]/g, "'")
+    .replace(/[“”]/g, '"')
+    .replace(/\s+/g, ' ');
+/** Returns the license text families a file contains, in a stable order. */
+export function classifyLicenseText(contentsArg) {
+    const text = normalizeText(contentsArg);
+    return fingerprints.filter((fingerprint) => fingerprint.matches(text)).map((fingerprint) => fingerprint.family);
+}
+/**
+ * Maps an SPDX identifier onto the license text it requires: `-only`,
+ * `-or-later` and `+` select a version range of the same text.
+ */
+export function licenseTextFamily(identifierArg) {
+    return identifierArg.replace(/\+$/, '').replace(/-(?:only|or-later)$/, '');
+}
+const termCovered = (termArg, familiesArg) => familiesArg.has(licenseTextFamily(termArg.license)) &&
+    (termArg.exception === undefined || familiesArg.has(termArg.exception));
+/** True when the available license texts satisfy every term of one alternative. */
+export function licenseAlternativesCovered(alternativesArg, familiesArg) {
+    return alternativesArg.some((terms) => terms.every((term) => termCovered(term, familiesArg)));
+}
+/** Formats the terms a set of texts leaves uncovered, for error messages. */
+export function describeUncoveredTerms(alternativesArg, familiesArg) {
+    return alternativesArg
+        .map((terms) => terms
+        .filter((term) => !termCovered(term, familiesArg))
+        .map((term) => (term.exception ? `${term.license} WITH ${term.exception}` : term.license))
+        .join(' AND '))
+        .join(' | ');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_notices/helpers.muslversion.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Reads the musl release from a static `libc.a`. musl compiles its version
+ * string into the `version` object (`src/internal/version.c`); the archive
+ * member holds exactly one NUL-terminated `major.minor.patch` string.
+ */
+export declare function readMuslVersion(archiveArg: Buffer): string;

package/dist_ts/mod_notices/helpers.muslversion.js

@@ -0,0 +1,47 @@
+const archiveMagic = '!<arch>\n';
+const headerBytes = 60;
+const versionPattern = /^\d+\.\d+\.\d+$/;
+/**
+ * Reads the musl release from a static `libc.a`. musl compiles its version
+ * string into the `version` object (`src/internal/version.c`); the archive
+ * member holds exactly one NUL-terminated `major.minor.patch` string.
+ */
+export function readMuslVersion(archiveArg) {
+    if (archiveArg.subarray(0, archiveMagic.length).toString('latin1') !== archiveMagic) {
+        throw new Error('musl libc.a is not an ar archive');
+    }
+    let longNames = '';
+    let offset = archiveMagic.length;
+    while (offset + headerBytes <= archiveArg.length) {
+        const header = archiveArg.subarray(offset, offset + headerBytes).toString('latin1');
+        if (header.slice(58, 60) !== '`\n')
+            throw new Error('musl libc.a has a malformed member header');
+        const size = Number(header.slice(48, 58).trim());
+        if (!Number.isSafeInteger(size) || size < 0 || offset + headerBytes + size > archiveArg.length) {
+            throw new Error('musl libc.a has a malformed member size');
+        }
+        const data = archiveArg.subarray(offset + headerBytes, offset + headerBytes + size);
+        let name = header.slice(0, 16).trim();
+        if (name === '//') {
+            longNames = data.toString('latin1');
+        }
+        else if (/^\/\d+$/.test(name)) {
+            const start = Number(name.slice(1));
+            const end = longNames.indexOf('/\n', start);
+            name = longNames.slice(start, end < 0 ? undefined : end);
+        }
+        else {
+            name = name.replace(/\/$/, '');
+        }
+        if (name === 'version.lo' || name === 'version.o') {
+            const versions = new Set(data.toString('latin1').split('\u0000').filter((value) => versionPattern.test(value)));
+            if (versions.size !== 1) {
+                throw new Error('musl libc.a version member does not hold exactly one version string');
+            }
+            return [...versions][0];
+        }
+        offset += headerBytes + size + (size % 2);
+    }
+    throw new Error('musl libc.a has no version member');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_notices/helpers.noticesconfig.d.ts

@@ -0,0 +1,71 @@
+/**
+ * A license text that covers a package whose own files tsrust cannot match to
+ * its declared license: a reviewed text kept in the project, or a crate file
+ * whose wording tsrust does not recognise.
+ */
+export interface ITsrustNoticeFileOverride {
+    from: 'project' | 'crate';
+    /** Relative to the project root (`project`) or the crate root (`crate`). */
+    path: string;
+    /** SPDX license identifiers the text satisfies. */
+    licenses: string[];
+}
+/** A C/C++ library a Cargo package compiles into the executables. */
+export interface ITsrustNoticeNativeComponent {
+    name: string;
+    version: string;
+    license: string;
+    /** License files inside the crate source, relative to the crate root. */
+    files: string[];
+}
+/**
+ * What an extra text is: the license of a component the crate vendors, or a
+ * supplement reproducing the copyright and license comments of its sources.
+ */
+export type TTsrustNoticeExtraTextKind = 'component-license' | 'source-attribution';
+/**
+ * A reviewed text the project ships with a package in addition to the texts
+ * that cover its license. Extra texts never count towards that coverage.
+ */
+export interface ITsrustNoticeExtraText {
+    /** Relative to the project root. */
+    path: string;
+    /** Lowercase hex SHA-256 digest of the reviewed file. */
+    sha256: string;
+    kind: TTsrustNoticeExtraTextKind;
+    /** The vendored component the text applies to, for example `once_cell`. */
+    component?: string;
+}
+export interface ITsrustNoticePackageOverride {
+    /** Only for a package that declares no license, or one tsrust cannot parse. */
+    license?: string;
+    files?: ITsrustNoticeFileOverride[];
+    /** Reviewed texts copied beside the package's license files; they cover nothing. */
+    extraTexts?: ITsrustNoticeExtraText[];
+    /** Required for every package with a `links` key; `[]` declares that nothing is bundled. */
+    native?: ITsrustNoticeNativeComponent[];
+}
+/** Runtime material a target's linker adds beyond what tsrust knows about. */
+export interface ITsrustNoticeRuntimeComponent {
+    name: string;
+    version?: string;
+    license: string;
+    /** License files in the project, relative to the project root. */
+    files: string[];
+}
+export interface ITsrustNoticesConfig {
+    /** Project-relative output directory, `native-notices` by default. */
+    directory?: string;
+    /** Keyed by the exact `name@version`. */
+    packages?: Record<string, ITsrustNoticePackageOverride>;
+    /** Keyed by target name, for example `linux_amd64_musl`. */
+    runtime?: Record<string, ITsrustNoticeRuntimeComponent[]>;
+}
+export interface IResolvedNoticesConfig {
+    directory: string;
+    packages: Map<string, ITsrustNoticePackageOverride>;
+    runtime: Map<string, ITsrustNoticeRuntimeComponent[]>;
+}
+export declare const defaultNoticesDirectory = "native-notices";
+/** Validates the `notices` section of the tsrust configuration. */
+export declare function resolveNoticesConfig(valueArg: unknown): IResolvedNoticesConfig;

package/dist_ts/mod_notices/helpers.noticesconfig.js

@@ -0,0 +1,133 @@
+export const defaultNoticesDirectory = 'native-notices';
+const directoryPattern = /^[a-z0-9][a-z0-9._-]*(?:\/[a-z0-9][a-z0-9._-]*)*$/;
+const packageKeyPattern = /^[A-Za-z0-9_-]+@[0-9][A-Za-z0-9.+-]*$/;
+const componentNamePattern = /^[a-z0-9][a-z0-9._-]*$/;
+const componentVersionPattern = /^[a-z0-9][a-z0-9.+-]*$/;
+const spdxIdentifierPattern = /^[A-Za-z0-9][A-Za-z0-9.-]*\+?$/;
+const sha256Pattern = /^[0-9a-f]{64}$/;
+const extraTextKinds = ['component-license', 'source-attribution'];
+const isRecord = (valueArg) => !!valueArg && typeof valueArg === 'object' && !Array.isArray(valueArg);
+const assertRecord = (valueArg, labelArg, allowedKeysArg) => {
+    if (!isRecord(valueArg))
+        throw new Error(`${labelArg} must be an object`);
+    const unexpected = Object.keys(valueArg).filter((key) => !allowedKeysArg.includes(key));
+    if (unexpected.length > 0) {
+        throw new Error(`${labelArg} contains unsupported keys: ${unexpected.join(', ')}`);
+    }
+    return valueArg;
+};
+const assertEntries = (valueArg, labelArg) => {
+    if (!isRecord(valueArg))
+        throw new Error(`${labelArg} must be an object`);
+    return valueArg;
+};
+const assertString = (valueArg, labelArg, patternArg) => {
+    if (typeof valueArg !== 'string' || valueArg.length === 0 || valueArg.length > 1024) {
+        throw new Error(`${labelArg} must be a non-empty string`);
+    }
+    if (patternArg && !patternArg.test(valueArg)) {
+        throw new Error(`${labelArg} has an invalid value: ${JSON.stringify(valueArg)}`);
+    }
+    return valueArg;
+};
+const assertArray = (valueArg, labelArg, nonEmptyArg) => {
+    if (!Array.isArray(valueArg) || (nonEmptyArg && valueArg.length === 0)) {
+        throw new Error(`${labelArg} must be ${nonEmptyArg ? 'a non-empty' : 'an'} array`);
+    }
+    return valueArg;
+};
+const relativePath = (valueArg, labelArg) => {
+    const value = assertString(valueArg, labelArg);
+    if (value.startsWith('/') || value.includes('\\') || value.split('/').some((segment) => segment === '' || segment === '.')) {
+        throw new Error(`${labelArg} must be a relative path: ${JSON.stringify(value)}`);
+    }
+    return value;
+};
+const validateFileOverride = (valueArg, labelArg) => {
+    const value = assertRecord(valueArg, labelArg, ['from', 'path', 'licenses']);
+    if (value.from !== 'project' && value.from !== 'crate') {
+        throw new Error(`${labelArg}.from must be "project" or "crate"`);
+    }
+    return {
+        from: value.from,
+        path: relativePath(value.path, `${labelArg}.path`),
+        licenses: assertArray(value.licenses, `${labelArg}.licenses`, true).map((license, index) => assertString(license, `${labelArg}.licenses[${index}]`, spdxIdentifierPattern)),
+    };
+};
+const validateExtraText = (valueArg, labelArg) => {
+    const value = assertRecord(valueArg, labelArg, ['path', 'sha256', 'kind', 'component']);
+    const kind = extraTextKinds.find((candidate) => candidate === value.kind);
+    if (kind === undefined) {
+        throw new Error(`${labelArg}.kind must be one of ${extraTextKinds.map((entry) => `"${entry}"`).join(', ')}`);
+    }
+    return {
+        path: relativePath(value.path, `${labelArg}.path`),
+        sha256: assertString(value.sha256, `${labelArg}.sha256`, sha256Pattern),
+        kind,
+        ...(value.component === undefined
+            ? {}
+            : { component: assertString(value.component, `${labelArg}.component`, componentNamePattern) }),
+    };
+};
+const validateNativeComponent = (valueArg, labelArg) => {
+    const value = assertRecord(valueArg, labelArg, ['name', 'version', 'license', 'files']);
+    return {
+        name: assertString(value.name, `${labelArg}.name`, componentNamePattern),
+        version: assertString(value.version, `${labelArg}.version`, componentVersionPattern),
+        license: assertString(value.license, `${labelArg}.license`),
+        files: assertArray(value.files, `${labelArg}.files`, true).map((file, index) => relativePath(file, `${labelArg}.files[${index}]`)),
+    };
+};
+const validateRuntimeComponent = (valueArg, labelArg) => {
+    const value = assertRecord(valueArg, labelArg, ['name', 'version', 'license', 'files']);
+    return {
+        name: assertString(value.name, `${labelArg}.name`, componentNamePattern),
+        ...(value.version === undefined
+            ? {}
+            : { version: assertString(value.version, `${labelArg}.version`, componentVersionPattern) }),
+        license: assertString(value.license, `${labelArg}.license`),
+        files: assertArray(value.files, `${labelArg}.files`, true).map((file, index) => relativePath(file, `${labelArg}.files[${index}]`)),
+    };
+};
+/** Validates the `notices` section of the tsrust configuration. */
+export function resolveNoticesConfig(valueArg) {
+    const value = assertRecord(valueArg, 'notices', ['directory', 'packages', 'runtime']);
+    const directory = value.directory === undefined
+        ? defaultNoticesDirectory
+        : assertString(value.directory, 'notices.directory');
+    if (!directoryPattern.test(directory) || directory.split('/')[0] === 'dist_rust' || directory.split('/')[0] === 'node_modules') {
+        throw new Error(`notices.directory must be a lowercase project-relative path outside dist_rust: ${JSON.stringify(directory)}`);
+    }
+    const packages = new Map();
+    if (value.packages !== undefined) {
+        for (const [key, entry] of Object.entries(assertEntries(value.packages, 'notices.packages'))) {
+            const label = `notices.packages["${key}"]`;
+            if (!packageKeyPattern.test(key))
+                throw new Error(`${label} must be keyed by the exact name@version`);
+            const override = assertRecord(entry, label, ['license', 'files', 'extraTexts', 'native']);
+            const resolved = {};
+            if (override.license !== undefined)
+                resolved.license = assertString(override.license, `${label}.license`);
+            if (override.files !== undefined) {
+                resolved.files = assertArray(override.files, `${label}.files`, true).map((file, index) => validateFileOverride(file, `${label}.files[${index}]`));
+            }
+            if (override.extraTexts !== undefined) {
+                resolved.extraTexts = assertArray(override.extraTexts, `${label}.extraTexts`, true).map((text, index) => validateExtraText(text, `${label}.extraTexts[${index}]`));
+            }
+            if (override.native !== undefined) {
+                resolved.native = assertArray(override.native, `${label}.native`, false).map((component, index) => validateNativeComponent(component, `${label}.native[${index}]`));
+            }
+            if (Object.keys(resolved).length === 0)
+                throw new Error(`${label} is empty`);
+            packages.set(key, resolved);
+        }
+    }
+    const runtime = new Map();
+    if (value.runtime !== undefined) {
+        for (const [target, components] of Object.entries(assertEntries(value.runtime, 'notices.runtime'))) {
+            runtime.set(target, assertArray(components, `notices.runtime.${target}`, false).map((component, index) => validateRuntimeComponent(component, `notices.runtime.${target}[${index}]`)));
+        }
+    }
+    return { directory, packages, runtime };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helpers.noticesconfig.js","sourceRoot":"","sources":["../../ts/mod_notices/helpers.noticesconfig.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_notices/helpers.runtimetexts.d.ts

@@ -0,0 +1,9 @@
+export type TRuntimeLicenseTextId = 'musl' | 'glibc-lgpl-2.1' | 'gcc-gpl-3.0' | 'gcc-runtime-library-exception-3.1';
+export interface IRuntimeLicenseText {
+    id: TRuntimeLicenseTextId;
+    contents: Buffer;
+}
+/** musl releases whose COPYRIGHT file is the bundled `musl` text. */
+export declare const knownMuslVersions: string[];
+export declare function readRuntimeLicenseText(idArg: TRuntimeLicenseTextId): Promise<Buffer>;
+export declare function readRuntimeLicenseTexts(): Promise<IRuntimeLicenseText[]>;

package/dist_ts/mod_notices/helpers.runtimetexts.js

@@ -0,0 +1,45 @@
+import * as crypto from 'node:crypto';
+import * as fs from 'node:fs';
+import * as url from 'node:url';
+/**
+ * Canonical runtime license texts shipped in `assets/notices/`, verified
+ * byte-for-byte against their upstream sources.
+ */
+const runtimeLicenseTextSources = {
+    musl: {
+        file: 'musl-copyright.txt',
+        sha256: 'f9bc4423732350eb0b3f7ed7e91d530298476f8fec0c6c427a1c04ade22655af',
+        source: 'https://git.musl-libc.org/cgit/musl/plain/COPYRIGHT?h=v1.2.3 and ?h=v1.2.5 (identical)',
+    },
+    'glibc-lgpl-2.1': {
+        file: 'glibc-lgpl-2.1.txt',
+        sha256: 'dc626520dcd53a22f727af3ee42c770e56c97a64fe3adb063799d8ab032fe551',
+        source: 'https://raw.githubusercontent.com/bminor/glibc/glibc-2.39/COPYING.LIB',
+    },
+    'gcc-gpl-3.0': {
+        file: 'gcc-gpl-3.0.txt',
+        sha256: '8ceb4b9ee5adedde47b31e975c1d90c73ad27b6b165a1dcd80c7c545eb65b903',
+        source: 'https://raw.githubusercontent.com/gcc-mirror/gcc/releases/gcc-14.2.0/COPYING3',
+    },
+    'gcc-runtime-library-exception-3.1': {
+        file: 'gcc-runtime-library-exception-3.1.txt',
+        sha256: '9d6b43ce4d8de0c878bf16b54d8e7a10d9bd42b75178153e3af6a815bdc90f74',
+        source: 'https://raw.githubusercontent.com/gcc-mirror/gcc/releases/gcc-14.2.0/COPYING.RUNTIME',
+    },
+};
+/** musl releases whose COPYRIGHT file is the bundled `musl` text. */
+export const knownMuslVersions = ['1.2.3', '1.2.5'];
+const assetDirectory = new URL('../../assets/notices/', import.meta.url);
+export async function readRuntimeLicenseText(idArg) {
+    const source = runtimeLicenseTextSources[idArg];
+    const contents = await fs.promises.readFile(url.fileURLToPath(new URL(source.file, assetDirectory)));
+    if (crypto.createHash('sha256').update(contents).digest('hex') !== source.sha256) {
+        throw new Error(`Bundled runtime license text differs from its reviewed source: ${source.file}`);
+    }
+    return contents;
+}
+export async function readRuntimeLicenseTexts() {
+    const ids = Object.keys(runtimeLicenseTextSources);
+    return Promise.all(ids.map(async (id) => ({ id, contents: await readRuntimeLicenseText(id) })));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/mod_notices/helpers.spdx.d.ts

@@ -0,0 +1,21 @@
+/**
+ * One license requirement of an SPDX expression alternative: a license
+ * identifier, optionally combined with an exception (`WITH`).
+ */
+export interface ISpdxTerm {
+    license: string;
+    exception?: string;
+}
+/**
+ * An SPDX license expression expanded into its alternatives. Satisfying every
+ * term of any one alternative satisfies the expression.
+ */
+export interface IParsedSpdxExpression {
+    alternatives: ISpdxTerm[][];
+}
+/**
+ * Parses an SPDX license expression (`AND`, `OR`, `WITH`, parentheses, and
+ * Cargo's legacy `/` separator). Operators are case-sensitive; anything the
+ * grammar does not describe is rejected rather than guessed.
+ */
+export declare function parseSpdxExpression(expressionArg: string): IParsedSpdxExpression;