@git.zone/tsrust 1.5.0 → 1.7.0

package/.smartconfig.json

@@ -1,5 +1,6 @@
 {
   "@git.zone/cli": {
+    "schemaVersion": 2,
     "projectType": "npm",
     "module": {
       "githost": "code.foss.global",
@@ -20,12 +21,20 @@
     },
     "release": {
       "targets": {
+        "git": {
+          "enabled": true,
+          "remote": "origin",
+          "pushBranch": true,
+          "pushTags": true
+        },
         "npm": {
+          "enabled": true,
           "registries": [
             "https://verdaccio.lossless.digital",
             "https://registry.npmjs.org"
           ],
-          "accessLevel": "public"
+          "accessLevel": "public",
+          "alreadyPublished": "success"
         }
       }
     }

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/tsrust',
-    version: '1.5.0',
+    version: '1.7.0',
     description: 'A tool for compiling Rust projects, detecting Cargo workspaces, building with cargo, and placing binaries in a conventional dist_rust directory.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxrQkFBa0I7SUFDeEIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLGtKQUFrSjtDQUNoSyxDQUFBIn0=

package/dist_ts/mod_cargo/classes.cargorunner.d.ts

@@ -16,11 +16,14 @@ export declare class CargoRunner {
         target?: string;
         crtStatic?: boolean;
         rustflags?: string[];
+        targetDir?: string;
     }): Promise<ICargoRunResult>;
     private shellQuote;
     /**
      * Ensures a rustup target is installed. If not present, installs it via `rustup target add`.
      */
     ensureTarget(triple: string): Promise<void>;
-    clean(): Promise<ICargoRunResult>;
+    clean(options?: {
+        targetDir?: string;
+    }): Promise<ICargoRunResult>;
 }

package/dist_ts/mod_cargo/classes.cargorunner.js

@@ -21,7 +21,7 @@ export class CargoRunner {
     async build(options = {}) {
         if (options.clean) {
             console.log('Cleaning previous build...');
-            await this.clean();
+            await this.clean({ targetDir: options.targetDir });
         }
         // crt-static may only be injected together with an explicit --target:
         // without one, cargo applies RUSTFLAGS to host artifacts too, and rustc
@@ -39,8 +39,9 @@ export class CargoRunner {
             rustflags.unshift('-C', 'target-feature=+crt-static');
         }
         const rustflagsPrefix = rustflags.length ? `RUSTFLAGS=${this.shellQuote(rustflags.join(' '))} ` : '';
-        const command = `${this.envPrefix}cd ${this.rustDir} && ${rustflagsPrefix}cargo build${profile}${targetFlag}`;
-        console.log(`Running: ${rustflagsPrefix}cargo build${profile}${targetFlag}`);
+        const targetDirPrefix = options.targetDir ? `CARGO_TARGET_DIR=${this.shellQuote(options.targetDir)} ` : '';
+        const command = `${this.envPrefix}cd ${this.rustDir} && ${targetDirPrefix}${rustflagsPrefix}cargo build${profile}${targetFlag}`;
+        console.log(`Running: ${targetDirPrefix}${rustflagsPrefix}cargo build${profile}${targetFlag}`);
         const result = await this.shell.exec(command);
         return {
             success: result.exitCode === 0,
@@ -66,8 +67,9 @@ export class CargoRunner {
             throw new Error(`Failed to install rustup target ${triple}`);
         }
     }
-    async clean() {
-        const command = `${this.envPrefix}cd ${this.rustDir} && cargo clean`;
+    async clean(options = {}) {
+        const targetDirPrefix = options.targetDir ? `CARGO_TARGET_DIR=${this.shellQuote(options.targetDir)} ` : '';
+        const command = `${this.envPrefix}cd ${this.rustDir} && ${targetDirPrefix}cargo clean`;
         const result = await this.shell.exec(command);
         return {
             success: result.exitCode === 0,
@@ -76,4 +78,4 @@ export class CargoRunner {
         };
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jYXJnb3J1bm5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL21vZF9jYXJnby9jbGFzc2VzLmNhcmdvcnVubmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sZUFBZSxDQUFDO0FBUXpDLE1BQU0sT0FBTyxXQUFXO0lBQ2QsS0FBSyxDQUFnQztJQUNyQyxPQUFPLENBQVM7SUFDaEIsU0FBUyxDQUFTO0lBRTFCLFlBQVksT0FBZSxFQUFFLFlBQW9CLEVBQUU7UUFDakQsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFDdkIsSUFBSSxDQUFDLFNBQVMsR0FBRyxTQUFTLENBQUM7UUFDM0IsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLE9BQU8sQ0FBQyxVQUFVLENBQUMsVUFBVSxDQUFDO1lBQzdDLFFBQVEsRUFBRSxNQUFNO1NBQ2pCLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTSxLQUFLLENBQUMsbUJBQW1CO1FBQzlCLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsR0FBRyxJQUFJLENBQUMsU0FBUyxpQkFBaUIsQ0FBQyxDQUFDO1FBQy9FLE9BQU8sTUFBTSxDQUFDLFFBQVEsS0FBSyxDQUFDLENBQUM7SUFDL0IsQ0FBQztJQUVNLEtBQUssQ0FBQyxlQUFlO1FBQzFCLE1BQU0sTUFBTSxHQUFHLE1BQU0sSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsR0FBRyxJQUFJLENBQUMsU0FBUyxpQkFBaUIsQ0FBQyxDQUFDO1FBQy9FLE9BQU8sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUM5QixDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUssQ0FBQyxVQUFnSSxFQUFFO1FBQ25KLElBQUksT0FBTyxDQUFDLEtBQUssRUFBRSxDQUFDO1lBQ2xCLE9BQU8sQ0FBQyxHQUFHLENBQUMsNEJBQTRCLENBQUMsQ0FBQztZQUMxQyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsRUFBRSxTQUFTLEVBQUUsT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDLENBQUM7UUFDckQsQ0FBQztRQUVELHNFQUFzRTtRQUN0RSx3RUFBd0U7UUFDeEUsMERBQTBEO1FBQzFELElBQUksT0FBTyxDQUFDLFNBQVMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUN6QyxNQUFNLElBQUksS0FBSyxDQUFDLHVDQUF1QyxDQUFDLENBQUM7UUFDM0QsQ0FBQztRQUVELElBQUksT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ25CLE1BQU0sSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDMUMsQ0FBQztRQUVELE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsWUFBWSxDQUFDO1FBQ2xELE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGFBQWEsT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDdkUsTUFBTSxTQUFTLEdBQUcsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLFNBQVMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ2pELElBQUksT0FBTyxDQUFDLFNBQVMsRUFBRSxDQUFDO1lBQ3RCLFNBQVMsQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLDRCQUE0QixDQUFDLENBQUM7UUFDeEQsQ0FBQztRQUNELE1BQU0sZUFBZSxHQUFHLFNBQVMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLGFBQWEsSUFBSSxDQUFDLFVBQVUsQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1FBQ3JHLE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLG9CQUFvQixJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDM0csTUFBTSxPQUFPLEdBQUcsR0FBRyxJQUFJLENBQUMsU0FBUyxNQUFNLElBQUksQ0FBQyxPQUFPLE9BQU8sZUFBZSxHQUFHLGVBQWUsY0FBYyxPQUFPLEdBQUcsVUFBVSxFQUFFLENBQUM7UUFFaEksT0FBTyxDQUFDLEdBQUcsQ0FBQyxZQUFZLGVBQWUsR0FBRyxlQUFlLGNBQWMsT0FBTyxHQUFHLFVBQVUsRUFBRSxDQUFDLENBQUM7UUFDL0YsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU5QyxPQUFPO1lBQ0wsT0FBTyxFQUFFLE1BQU0sQ0FBQyxRQUFRLEtBQUssQ0FBQztZQUM5QixRQUFRLEVBQUUsTUFBTSxDQUFDLFFBQVE7WUFDekIsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNO1NBQ3RCLENBQUM7SUFDSixDQUFDO0lBRU8sVUFBVSxDQUFDLEtBQWE7UUFDOUIsT0FBTyxHQUFHLEdBQUcsS0FBSyxDQUFDLE9BQU8sQ0FBQyxZQUFZLEVBQUUsTUFBTSxDQUFDLEdBQUcsR0FBRyxDQUFDO0lBQ3pELENBQUM7SUFFRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxZQUFZLENBQUMsTUFBYztRQUN0QyxNQUFNLFVBQVUsR0FBRyxNQUFNLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEdBQUcsSUFBSSxDQUFDLFNBQVMsZ0NBQWdDLENBQUMsQ0FBQztRQUNsRyxNQUFNLGdCQUFnQixHQUFHLFVBQVUsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDLENBQUM7UUFDNUUsSUFBSSxnQkFBZ0IsQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQztZQUN0QyxPQUFPO1FBQ1QsQ0FBQztRQUNELE9BQU8sQ0FBQyxHQUFHLENBQUMsNkJBQTZCLE1BQU0sRUFBRSxDQUFDLENBQUM7UUFDbkQsTUFBTSxTQUFTLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLElBQUksQ0FBQyxTQUFTLHFCQUFxQixNQUFNLEVBQUUsQ0FBQyxDQUFDO1FBQ3hGLElBQUksU0FBUyxDQUFDLFFBQVEsS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUM3QixNQUFNLElBQUksS0FBSyxDQUFDLG1DQUFtQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO1FBQy9ELENBQUM7SUFDSCxDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUssQ0FBQyxVQUFrQyxFQUFFO1FBQ3JELE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLG9CQUFvQixJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUM7UUFDM0csTUFBTSxPQUFPLEdBQUcsR0FBRyxJQUFJLENBQUMsU0FBUyxNQUFNLElBQUksQ0FBQyxPQUFPLE9BQU8sZUFBZSxhQUFhLENBQUM7UUFDdkYsTUFBTSxNQUFNLEdBQUcsTUFBTSxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUU5QyxPQUFPO1lBQ0wsT0FBTyxFQUFFLE1BQU0sQ0FBQyxRQUFRLEtBQUssQ0FBQztZQUM5QixRQUFRLEVBQUUsTUFBTSxDQUFDLFFBQVE7WUFDekIsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFNO1NBQ3RCLENBQUM7SUFDSixDQUFDO0NBQ0YifQ==

package/dist_ts/mod_cargo/classes.targetcache.d.ts

@@ -0,0 +1,37 @@
+export declare const toolCacheMarkerFile = ".gitzone-tool-cache.json";
+export declare const tsrustCacheOwner = "@git.zone/tsrust";
+export declare const targetCacheKind = "rust-target-cache";
+export interface IToolCacheMarker {
+    owner: string;
+    kind: string;
+    safeToPrune: boolean;
+    createdAt: string;
+    schemaVersion: 1;
+}
+export interface ITsrustPruneCandidate {
+    path: string;
+    workspace: string;
+    bytes: number;
+    marked: boolean;
+    shouldPrune: boolean;
+    reason: string;
+    truncated?: boolean;
+}
+export interface ITsrustPruneOptions {
+    workspace: string;
+    targetDir?: string;
+    days?: number;
+    maxSizeBytes?: number;
+}
+export declare function createTargetCacheMarker(): IToolCacheMarker;
+export declare function isValidTargetCacheMarker(markerArg: unknown): markerArg is IToolCacheMarker;
+export declare function getDefaultManagedTargetDir(workspaceArg: string): string;
+export declare function isSafeManagedTargetDir(workspaceArg: string, targetDirArg: string): boolean;
+export declare function resolveManagedTargetDir(workspaceArg: string, configTargetDirArg?: string): string;
+export declare function getCargoArtifactDir(targetDirArg: string, profileArg: string, targetTripleArg?: string): string;
+export declare function parseSizeToBytes(valueArg: string | undefined): number | undefined;
+export declare function writeTargetCacheMarker(targetDirArg: string): Promise<void>;
+export declare function readTargetCacheMarker(targetDirArg: string): Promise<IToolCacheMarker | undefined>;
+export declare function getDirectorySize(pathArg: string): Promise<number>;
+export declare function createTsrustPrunePlan(optionsArg: ITsrustPruneOptions): Promise<ITsrustPruneCandidate[]>;
+export declare function applyTsrustPrunePlan(planArg: ITsrustPruneCandidate[]): Promise<void>;

package/dist_ts/mod_cargo/classes.targetcache.js

@@ -0,0 +1,260 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export const toolCacheMarkerFile = '.gitzone-tool-cache.json';
+export const tsrustCacheOwner = '@git.zone/tsrust';
+export const targetCacheKind = 'rust-target-cache';
+export function createTargetCacheMarker() {
+    return {
+        owner: tsrustCacheOwner,
+        kind: targetCacheKind,
+        safeToPrune: true,
+        createdAt: new Date().toISOString(),
+        schemaVersion: 1,
+    };
+}
+export function isValidTargetCacheMarker(markerArg) {
+    const marker = markerArg;
+    return marker.owner === tsrustCacheOwner
+        && marker.kind === targetCacheKind
+        && marker.safeToPrune === true
+        && marker.schemaVersion === 1;
+}
+export function getDefaultManagedTargetDir(workspaceArg) {
+    return path.resolve(workspaceArg, '.nogit', 'tsrust-target');
+}
+export function isSafeManagedTargetDir(workspaceArg, targetDirArg) {
+    const workspace = path.resolve(workspaceArg);
+    const targetDir = path.resolve(targetDirArg);
+    const relative = path.relative(workspace, targetDir);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative)) {
+        return false;
+    }
+    return relative === path.join('.nogit', 'tsrust-target')
+        || relative.startsWith(`${path.join('.nogit', 'tsrust-')}`)
+        || relative.startsWith(`${path.join('.nogit', 'tsrust')}${path.sep}`);
+}
+export function resolveManagedTargetDir(workspaceArg, configTargetDirArg) {
+    const configured = process.env.TSRUST_TARGET_DIR || configTargetDirArg;
+    const targetDir = configured
+        ? path.isAbsolute(configured) ? configured : path.resolve(workspaceArg, configured)
+        : getDefaultManagedTargetDir(workspaceArg);
+    if (!isSafeManagedTargetDir(workspaceArg, targetDir)) {
+        throw new Error(`Refusing unsafe tsrust target dir outside workspace .nogit/: ${targetDir}`);
+    }
+    return targetDir;
+}
+export function getCargoArtifactDir(targetDirArg, profileArg, targetTripleArg) {
+    return targetTripleArg
+        ? path.join(targetDirArg, targetTripleArg, profileArg)
+        : path.join(targetDirArg, profileArg);
+}
+export function parseSizeToBytes(valueArg) {
+    if (!valueArg) {
+        return undefined;
+    }
+    const match = valueArg.trim().match(/^(\d+(?:\.\d+)?)(b|kb|kib|mb|mib|gb|gib)?$/i);
+    if (!match) {
+        return undefined;
+    }
+    const value = Number(match[1]);
+    const unit = (match[2] || 'b').toLowerCase();
+    const multiplier = unit === 'gb' || unit === 'gib'
+        ? 1024 ** 3
+        : unit === 'mb' || unit === 'mib'
+            ? 1024 ** 2
+            : unit === 'kb' || unit === 'kib'
+                ? 1024
+                : 1;
+    return Math.round(value * multiplier);
+}
+export async function writeTargetCacheMarker(targetDirArg) {
+    await fs.mkdir(targetDirArg, { recursive: true });
+    const existingMarker = await readTargetCacheMarker(targetDirArg);
+    if (existingMarker) {
+        return;
+    }
+    const entries = await fs.readdir(targetDirArg);
+    if (entries.length > 0) {
+        throw new Error(`Refusing to mark pre-existing non-empty tsrust target cache: ${targetDirArg}`);
+    }
+    await fs.writeFile(path.join(targetDirArg, toolCacheMarkerFile), `${JSON.stringify(createTargetCacheMarker(), null, 2)}\n`);
+}
+export async function readTargetCacheMarker(targetDirArg) {
+    try {
+        const markerRaw = await fs.readFile(path.join(targetDirArg, toolCacheMarkerFile), 'utf8');
+        const marker = JSON.parse(markerRaw);
+        return isValidTargetCacheMarker(marker) ? marker : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function pathExists(pathArg) {
+    try {
+        await fs.stat(pathArg);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getDirectorySize(pathArg) {
+    let total = 0;
+    let entries;
+    try {
+        entries = await fs.readdir(pathArg, { withFileTypes: true });
+    }
+    catch {
+        return 0;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(pathArg, entry.name);
+        if (entry.isDirectory()) {
+            total += await getDirectorySize(entryPath);
+        }
+        else if (entry.isFile()) {
+            try {
+                total += (await fs.stat(entryPath)).size;
+            }
+            catch {
+                // Ignore files that disappear while planning a prune.
+            }
+        }
+    }
+    return total;
+}
+async function getDirectoryUsage(pathArg, maxEntriesArg = 100_000) {
+    let bytes = 0;
+    let newestMtimeMs = 0;
+    let visitedEntries = 0;
+    let truncated = false;
+    const visit = async (entryPathArg) => {
+        if (visitedEntries >= maxEntriesArg) {
+            truncated = true;
+            return;
+        }
+        visitedEntries++;
+        let stat;
+        try {
+            stat = await fs.stat(entryPathArg);
+        }
+        catch {
+            return;
+        }
+        newestMtimeMs = Math.max(newestMtimeMs, stat.mtimeMs);
+        if (stat.isFile()) {
+            bytes += stat.size;
+            return;
+        }
+        if (!stat.isDirectory()) {
+            return;
+        }
+        let entries;
+        try {
+            entries = await fs.readdir(entryPathArg, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (visitedEntries >= maxEntriesArg) {
+                truncated = true;
+                return;
+            }
+            await visit(path.join(entryPathArg, entry.name));
+        }
+    };
+    await visit(pathArg);
+    return { bytes, newestMtimeMs, truncated };
+}
+async function getNewestMtimeMs(pathArg) {
+    let newest = 0;
+    try {
+        const stat = await fs.stat(pathArg);
+        newest = stat.mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+    let entries;
+    try {
+        entries = await fs.readdir(pathArg, { withFileTypes: true });
+    }
+    catch {
+        return newest;
+    }
+    for (const entry of entries) {
+        const entryPath = path.join(pathArg, entry.name);
+        if (entry.isDirectory()) {
+            newest = Math.max(newest, await getNewestMtimeMs(entryPath));
+        }
+        else if (entry.isFile()) {
+            try {
+                newest = Math.max(newest, (await fs.stat(entryPath)).mtimeMs);
+            }
+            catch {
+                // Ignore files that disappear while planning a prune.
+            }
+        }
+    }
+    return newest;
+}
+export async function createTsrustPrunePlan(optionsArg) {
+    const workspace = path.resolve(optionsArg.workspace);
+    const managedTargetDir = optionsArg.targetDir
+        ? resolveManagedTargetDir(workspace, optionsArg.targetDir)
+        : resolveManagedTargetDir(workspace);
+    const candidates = [
+        managedTargetDir,
+        path.join(workspace, 'rust', 'target'),
+        path.join(workspace, 'ts_rust', 'target'),
+    ];
+    const uniqueCandidates = [...new Set(candidates.map((candidate) => path.resolve(candidate)))];
+    const pruneCandidates = [];
+    const maxAgeMs = typeof optionsArg.days === 'number' ? optionsArg.days * 24 * 60 * 60 * 1000 : undefined;
+    for (const candidate of uniqueCandidates) {
+        if (!(await pathExists(candidate))) {
+            continue;
+        }
+        const marker = await readTargetCacheMarker(candidate);
+        const usage = await getDirectoryUsage(candidate);
+        const isManagedTarget = isSafeManagedTargetDir(workspace, candidate);
+        const ageMatches = typeof maxAgeMs === 'number' ? Date.now() - usage.newestMtimeMs >= maxAgeMs : false;
+        const bytes = usage.bytes;
+        const sizeMatches = typeof optionsArg.maxSizeBytes === 'number' ? bytes >= optionsArg.maxSizeBytes : false;
+        const shouldPrune = !!marker && isManagedTarget && (ageMatches || sizeMatches);
+        const reason = marker
+            ? !isManagedTarget
+                ? 'marked Rust target outside managed tsrust target allowlist; report-only'
+                : shouldPrune
+                    ? [ageMatches ? `older than ${optionsArg.days} day(s)` : '', sizeMatches ? `at least ${optionsArg.maxSizeBytes} bytes` : ''].filter(Boolean).join(', ')
+                    : 'marked tsrust target cache; below prune thresholds'
+            : 'unmarked conventional Rust target; report-only';
+        pruneCandidates.push({
+            path: candidate,
+            workspace,
+            bytes,
+            marked: !!marker,
+            shouldPrune,
+            reason,
+            truncated: usage.truncated,
+        });
+    }
+    return pruneCandidates;
+}
+export async function applyTsrustPrunePlan(planArg) {
+    for (const candidate of planArg) {
+        if (!candidate.shouldPrune) {
+            continue;
+        }
+        if (!isSafeManagedTargetDir(candidate.workspace, candidate.path)) {
+            throw new Error(`Refusing unsafe Rust target cache path: ${candidate.path}`);
+        }
+        const marker = await readTargetCacheMarker(candidate.path);
+        if (!marker) {
+            throw new Error(`Refusing to remove unmarked Rust target cache: ${candidate.path}`);
+        }
+        await fs.rm(candidate.path, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.targetcache.js","sourceRoot":"","sources":["../../ts/mod_cargo/classes.targetcache.ts"],"names":[],"mappings":"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"}

package/dist_ts/mod_cargo/index.d.ts

@@ -1,2 +1,3 @@
 export { CargoConfig } from './classes.cargoconfig.js';
 export { CargoRunner } from './classes.cargorunner.js';
+export * from './classes.targetcache.js';

package/dist_ts/mod_cargo/index.js

@@ -1,3 +1,4 @@
 export { CargoConfig } from './classes.cargoconfig.js';
 export { CargoRunner } from './classes.cargorunner.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9tb2RfY2FyZ28vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQyJ9
+export * from './classes.targetcache.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9tb2RfY2FyZ28vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN2RCxjQUFjLDBCQUEwQixDQUFDIn0=

package/dist_ts/mod_cli/classes.tsrustcli.d.ts

@@ -4,6 +4,12 @@ export declare class TsRustCli {
     private config;
     constructor(cwd?: string);
     private registerCommands;
+    /**
+     * Collects build provenance once per run: consuming project identity,
+     * git commit, and the tsrust version doing the build. Tolerant of
+     * non-git checkouts and missing package metadata.
+     */
+    private collectBuildProvenance;
     /**
      * Resolves the Rust toolchain to use. Tries system cargo first,
      * then falls back to a bundled toolchain at /tmp/tsrust_toolchain/.
@@ -11,8 +17,15 @@ export declare class TsRustCli {
      */
     private resolveToolchain;
     private registerStandardCommand;
+    private shouldPruneAfterBuild;
     private buildRustflags;
+    /**
+     * `tsrust inspect <binary>` — prints the embedded build provenance so any
+     * environment can answer "what is this binary built from" definitively.
+     */
+    private registerInspectCommand;
     private registerCleanCommand;
+    private registerPruneCommand;
     private detectRustDir;
     run(): void;
 }