@microsoft/opentelemetry 1.3.0 → 1.4.0

package/dist/commonjs/a365/exporter/durable/DurableRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DurableRecord.js","sourceRoot":"","sources":["../../../../../src/a365/exporter/durable/DurableRecord.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/a365/exporter/durable/PersistentStore.d.ts

@@ -0,0 +1,48 @@
+import type { ILogger } from "../../logging.js";
+import { ResolvedDurableDeliveryOptions } from "./DurableDeliveryOptions.js";
+import { type DurableRecordV1 } from "./DurableRecord.js";
+import { type DirectoryAccessControl } from "./WindowsFileAccessControl.js";
+export interface ClaimedRecord {
+    record: DurableRecordV1;
+    leasePath: string;
+}
+export interface ClaimBatchOptions {
+    /**
+     * Record ids to skip during this claim scan. Matching pending records are
+     * left in place (released back to pending if already leased for
+     * inspection) so callers can exclude records they already determined are
+     * temporarily unusable without starving unrelated records that sort later.
+     */
+    excludeRecordIds?: ReadonlySet<string>;
+}
+export interface PersistentStoreDependencies {
+    directoryAccessControl?: DirectoryAccessControl;
+}
+export declare class PersistentStore {
+    private readonly root;
+    private readonly options;
+    private readonly logger;
+    private static readonly persistenceQueues;
+    private claimQueue;
+    private constructor();
+    static create(options: ResolvedDurableDeliveryOptions, logger: ILogger, dependencies?: PersistentStoreDependencies): Promise<PersistentStore>;
+    persist(record: DurableRecordV1): Promise<string>;
+    private persistInternal;
+    claimBatch(limit: number, options?: ClaimBatchOptions): Promise<ClaimedRecord[]>;
+    complete(claim: ClaimedRecord): Promise<void>;
+    release(claim: ClaimedRecord): Promise<void>;
+    private quarantinePendingFile;
+    private pruneForCapacity;
+    private recoverStaleLeases;
+    private pendingPath;
+    private recoveredPendingPath;
+    private leasePath;
+    private migratedLeasePath;
+    private temporaryPath;
+    private readManagedFiles;
+    private listManagedFilePaths;
+    private withClaimLock;
+    private withPersistenceLock;
+}
+export declare function applicationPartition(): string;
+//# sourceMappingURL=PersistentStore.d.ts.map

package/dist/commonjs/a365/exporter/durable/PersistentStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersistentStore.d.ts","sourceRoot":"","sources":["../../../../../src/a365/exporter/durable/PersistentStore.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,8BAA8B,EAAE,MAAM,6BAA6B,CAAC;AAC7E,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC9E,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,+BAA+B,CAAC;AAiBvC,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,eAAe,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;CACxC;AAUD,MAAM,WAAW,2BAA2B;IAC1C,sBAAsB,CAAC,EAAE,sBAAsB,CAAC;CACjD;AAED,qBAAa,eAAe;IAKxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM;IANzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,iBAAiB,CAAoC;IAC7E,OAAO,CAAC,UAAU,CAAoC;IAEtD,OAAO;WAMa,MAAM,CACxB,OAAO,EAAE,8BAA8B,EACvC,MAAM,EAAE,OAAO,EACf,YAAY,GAAE,2BAAgC,GAC7C,OAAO,CAAC,eAAe,CAAC;IASpB,OAAO,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,MAAM,CAAC;YAI1C,eAAe;IA8BhB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;IAsHhF,QAAQ,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAW7C,OAAO,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;YAW3C,qBAAqB;YAkBrB,gBAAgB;YAsDhB,kBAAkB;IAqChC,OAAO,CAAC,WAAW;YAQL,oBAAoB;IAUlC,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,iBAAiB;IAOzB,OAAO,CAAC,aAAa;YAOP,gBAAgB;YA2BhB,oBAAoB;YAcpB,aAAa;YAeb,mBAAmB;CAkBlC;AAgID,wBAAgB,oBAAoB,IAAI,MAAM,CAQ7C"}

package/dist/commonjs/a365/exporter/durable/PersistentStore.js

@@ -0,0 +1,637 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistentStore = void 0;
+exports.applicationPartition = applicationPartition;
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs/promises"));
+const os = __importStar(require("node:os"));
+const node_path_1 = require("node:path");
+const DurableRecord_js_1 = require("./DurableRecord.js");
+const WindowsFileAccessControl_js_1 = require("./WindowsFileAccessControl.js");
+const OWNER_DIRECTORY_MODE = 0o700;
+const OWNER_FILE_MODE = 0o600;
+const PENDING_SUFFIX = ".pending";
+const QUARANTINE_SUFFIX = ".quarantine";
+const TEMPORARY_SUFFIX = ".tmp";
+// NAME_MAX: the largest single path component most filesystems (ext4, NTFS,
+// APFS, etc.) accept. Renaming a pending file to its lease name appends
+// lease metadata to the basename, so a pending basename that itself fits
+// can still overflow this limit once that metadata is appended.
+const MAX_FILENAME_COMPONENT_BYTES = 255;
+const WINDOWS_PROBE_DIRECTORY = ["Microsoft", "A365", "otel-durable"];
+const POSIX_DEFAULT_LEAF_PREFIX = "a365-otel-durable";
+const APPLICATION_PARTITION_PREFIX = "app-";
+const PROCESS_START_CWD = process.cwd();
+class PersistentStore {
+    root;
+    options;
+    logger;
+    static persistenceQueues = new Map();
+    claimQueue = Promise.resolve();
+    constructor(root, options, logger) {
+        this.root = root;
+        this.options = options;
+        this.logger = logger;
+    }
+    static async create(options, logger, dependencies = {}) {
+        const root = await resolveStorageRoot(options, logger, resolveDirectoryAccessControl(dependencies.directoryAccessControl));
+        return new PersistentStore(root, options, logger);
+    }
+    persist(record) {
+        return this.withPersistenceLock(() => this.persistInternal(record));
+    }
+    async persistInternal(record) {
+        const serialized = JSON.stringify(record);
+        const recordBytes = Buffer.byteLength(serialized, "utf8");
+        if (recordBytes > this.options.maxStorageBytes) {
+            throw new RangeError("Durable record exceeds maxStorageBytes");
+        }
+        await this.pruneForCapacity(recordBytes);
+        const temporaryPath = this.temporaryPath(record);
+        const pendingPath = this.pendingPath(record);
+        const handle = await fs.open(temporaryPath, "wx", OWNER_FILE_MODE);
+        try {
+            try {
+                await handle.writeFile(serialized, "utf8");
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await this.pruneForCapacity(0);
+            await fs.rename(temporaryPath, pendingPath);
+            await syncDirectory(this.root);
+            return pendingPath;
+        }
+        catch (error) {
+            await ignoreEnoent(() => fs.unlink(temporaryPath));
+            throw error;
+        }
+    }
+    async claimBatch(limit, options) {
+        return this.withClaimLock(async () => {
+            if (limit <= 0) {
+                return [];
+            }
+            await this.recoverStaleLeases();
+            const excludeRecordIds = options?.excludeRecordIds;
+            const claims = [];
+            const pendingFiles = await this.listManagedFilePaths((name) => name.endsWith(PENDING_SUFFIX));
+            pendingFiles.sort();
+            for (const pendingPath of pendingFiles) {
+                if (claims.length >= limit) {
+                    break;
+                }
+                const leasePath = this.leasePath(pendingPath);
+                // Preflight before ever attempting the pending -> lease rename:
+                // appending lease metadata to an already-near-limit pending
+                // basename can push it past the filesystem's per-component name
+                // limit, and that failure surfaces inconsistently across platforms
+                // (ENAMETOOLONG on POSIX; an unhelpful ENOENT on this Windows/NTFS
+                // setup that the benign-race handling below would otherwise
+                // swallow silently). Validating basename length and content here,
+                // before the rename, guarantees a poison pending file is always
+                // quarantined -- deterministically, regardless of OS-specific
+                // rename errno behavior -- instead of wedging replay or aborting
+                // the batch.
+                if (!isSafeLeaseBasename(leasePath)) {
+                    await this.quarantinePendingFile(pendingPath);
+                    this.logger.warn("[PersistentStore] Quarantined pending durable record with an oversized basename", { path: pendingPath });
+                    continue;
+                }
+                let preflightText;
+                try {
+                    preflightText = await fs.readFile(pendingPath, "utf8");
+                }
+                catch (error) {
+                    if (isEnoent(error)) {
+                        continue;
+                    }
+                    throw error;
+                }
+                try {
+                    (0, DurableRecord_js_1.parseDurableRecord)(preflightText);
+                }
+                catch (error) {
+                    await this.quarantinePendingFile(pendingPath);
+                    this.logger.warn("[PersistentStore] Quarantined malformed pending durable record", error);
+                    continue;
+                }
+                try {
+                    await fs.rename(pendingPath, leasePath);
+                    await syncDirectory(this.root);
+                }
+                catch (error) {
+                    if (isEnoent(error)) {
+                        continue;
+                    }
+                    if (isEnametoolong(error)) {
+                        // Defense in depth: the dynamic-length preflight above should
+                        // make this unreachable, but an OS-specific errno must never be
+                        // the only guard against aborting the batch.
+                        await this.quarantinePendingFile(pendingPath);
+                        this.logger.warn("[PersistentStore] Quarantined pending durable record after an unexpected ENAMETOOLONG", error);
+                        continue;
+                    }
+                    throw error;
+                }
+                // Re-read and re-parse from the claimed lease path rather than
+                // trusting the preflight-parsed content above: the preflight read
+                // and this rename are not atomic with each other, so a same-user
+                // actor could have replaced the pending file's content in between.
+                // The rename is the atomic claim boundary; only content observed
+                // after it succeeds is trustworthy.
+                let text;
+                try {
+                    text = await fs.readFile(leasePath, "utf8");
+                }
+                catch (error) {
+                    if (isEnoent(error)) {
+                        continue;
+                    }
+                    throw error;
+                }
+                let record;
+                try {
+                    record = (0, DurableRecord_js_1.parseDurableRecord)(text);
+                }
+                catch (error) {
+                    await quarantineFile(leasePath);
+                    this.logger.warn("[PersistentStore] Quarantined malformed durable record", error);
+                    continue;
+                }
+                if (excludeRecordIds?.has(record.id)) {
+                    // Leave this record for a later pass instead of starving records
+                    // that sort after it: release it back to pending and keep scanning.
+                    await this.release({ record, leasePath });
+                    continue;
+                }
+                claims.push({ record, leasePath });
+            }
+            return claims;
+        });
+    }
+    async complete(claim) {
+        try {
+            await fs.unlink(claim.leasePath);
+            await syncDirectory(this.root);
+        }
+        catch (error) {
+            if (!isEnoent(error)) {
+                throw error;
+            }
+        }
+    }
+    async release(claim) {
+        try {
+            await fs.rename(claim.leasePath, this.pendingPath(claim.record, `release-${(0, node_crypto_1.randomUUID)()}`));
+            await syncDirectory(this.root);
+        }
+        catch (error) {
+            if (!isEnoent(error)) {
+                throw error;
+            }
+        }
+    }
+    async quarantinePendingFile(pendingPath) {
+        // The quarantine destination is always a short, fixed-shape name built
+        // only from the current timestamp/pid/a fresh UUID -- never derived
+        // from the poison file's basename or content -- so it can never exceed
+        // filesystem name limits and can never escape this.root, no matter how
+        // large or unsafe the source basename/id is. An ENOENT here means
+        // another process already claimed or quarantined this exact pending
+        // file first, which is a benign race, not a failure.
+        try {
+            await fs.rename(pendingPath, (0, node_path_1.join)(this.root, poisonQuarantineName()));
+            await syncDirectory(this.root);
+        }
+        catch (error) {
+            if (!isEnoent(error)) {
+                throw error;
+            }
+        }
+    }
+    async pruneForCapacity(incomingBytes) {
+        const minimumCreatedAt = Date.now() - this.options.maxRecordAgeMilliseconds;
+        let files = await this.readManagedFiles();
+        let usedBytes = sumBytes(files);
+        for (const file of files.sort((left, right) => left.createdAt - right.createdAt)) {
+            if (!file.removableWhenExpired || file.createdAt >= minimumCreatedAt) {
+                continue;
+            }
+            if (await unlinkIfExists(file.path)) {
+                this.logger.warn("[PersistentStore] Evicted expired durable record", {
+                    path: file.path,
+                    bytes: file.size,
+                });
+            }
+            usedBytes -= file.size;
+        }
+        if (usedBytes + incomingBytes <= this.options.maxStorageBytes) {
+            return;
+        }
+        files = await this.readManagedFiles();
+        usedBytes = sumBytes(files);
+        for (const file of files.sort((left, right) => left.createdAt - right.createdAt)) {
+            if (usedBytes + incomingBytes <= this.options.maxStorageBytes) {
+                break;
+            }
+            if (!file.evictable) {
+                continue;
+            }
+            if (await unlinkIfExists(file.path)) {
+                this.logger.warn("[PersistentStore] Evicted durable record for capacity", {
+                    path: file.path,
+                    bytes: file.size,
+                });
+            }
+            usedBytes -= file.size;
+        }
+        if (usedBytes + incomingBytes <= this.options.maxStorageBytes) {
+            return;
+        }
+        const survivingFiles = await this.readManagedFiles();
+        if (sumBytes(survivingFiles) + incomingBytes <= this.options.maxStorageBytes) {
+            return;
+        }
+        throw new RangeError("Durable storage capacity is occupied by active durable files");
+    }
+    async recoverStaleLeases() {
+        const now = Date.now();
+        const leasePaths = await this.listManagedFilePaths(isActiveLeaseFileName);
+        for (const leasePath of leasePaths) {
+            const claimedAt = parseLeaseClaimedAt(leasePath);
+            if (claimedAt === undefined) {
+                const migratedLeasePath = this.migratedLeasePath(leasePath, now);
+                try {
+                    await fs.rename(leasePath, migratedLeasePath);
+                    await syncDirectory(this.root);
+                }
+                catch (error) {
+                    if (isEnoent(error)) {
+                        continue;
+                    }
+                    throw error;
+                }
+                continue;
+            }
+            if (now - claimedAt <= this.options.leaseDurationMilliseconds) {
+                continue;
+            }
+            try {
+                const recoveredPath = await this.recoveredPendingPath(leasePath);
+                await fs.rename(leasePath, recoveredPath);
+                await syncDirectory(this.root);
+            }
+            catch (error) {
+                if (isEnoent(error)) {
+                    continue;
+                }
+                throw error;
+            }
+        }
+    }
+    pendingPath(record, suffix) {
+        const baseName = recordBasename(record);
+        return (0, node_path_1.join)(this.root, suffix ? `${baseName}.${suffix}${PENDING_SUFFIX}` : `${baseName}${PENDING_SUFFIX}`);
+    }
+    async recoveredPendingPath(leasePath) {
+        const text = await fs.readFile(leasePath, "utf8");
+        const suffix = `recovered-${(0, node_crypto_1.randomUUID)()}`;
+        try {
+            return this.pendingPath((0, DurableRecord_js_1.parseDurableRecord)(text), suffix);
+        }
+        catch {
+            return (0, node_path_1.join)(this.root, `${stableRecordBasename(leasePath)}.${suffix}${PENDING_SUFFIX}`);
+        }
+    }
+    leasePath(pendingPath) {
+        return pendingPath.replace(/\.pending$/, `.lease-at-${Date.now()}-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    }
+    migratedLeasePath(leasePath, claimedAt) {
+        return (0, node_path_1.join)(this.root, `${leasePrefix(leasePath)}.lease-at-${claimedAt}-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    }
+    temporaryPath(record) {
+        return (0, node_path_1.join)(this.root, `${Date.now()}-${record.id}.${process.pid}-${(0, node_crypto_1.randomUUID)()}${TEMPORARY_SUFFIX}`);
+    }
+    async readManagedFiles() {
+        const names = await this.listManagedFilePaths(isManagedFileName);
+        const files = [];
+        for (const fullPath of names) {
+            try {
+                const stats = await fs.stat(fullPath);
+                const name = (0, node_path_1.basename)(fullPath);
+                const activeLease = isActiveLeaseFileName(name);
+                files.push({
+                    path: fullPath,
+                    size: stats.size,
+                    createdAt: parseCreatedAt(fullPath) ?? Math.floor(stats.mtimeMs),
+                    evictable: isEvictableFileName(name),
+                    removableWhenExpired: !activeLease,
+                });
+            }
+            catch (error) {
+                if (isEnoent(error)) {
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return files;
+    }
+    async listManagedFilePaths(predicate) {
+        try {
+            const entries = await fs.readdir(this.root, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isFile() && predicate(entry.name))
+                .map((entry) => (0, node_path_1.join)(this.root, entry.name));
+        }
+        catch (error) {
+            if (isEnoent(error)) {
+                return [];
+            }
+            throw error;
+        }
+    }
+    async withClaimLock(callback) {
+        const previous = this.claimQueue;
+        let release = () => { };
+        this.claimQueue = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await callback();
+        }
+        finally {
+            release();
+        }
+    }
+    async withPersistenceLock(callback) {
+        const previous = PersistentStore.persistenceQueues.get(this.root) ?? Promise.resolve();
+        let release = () => { };
+        const current = new Promise((resolve) => {
+            release = resolve;
+        });
+        PersistentStore.persistenceQueues.set(this.root, current);
+        await previous;
+        try {
+            return await callback();
+        }
+        finally {
+            release();
+            if (PersistentStore.persistenceQueues.get(this.root) === current) {
+                PersistentStore.persistenceQueues.delete(this.root);
+            }
+        }
+    }
+}
+exports.PersistentStore = PersistentStore;
+async function resolveStorageRoot(options, logger, directoryAccessControl) {
+    if (options.storageDirectory !== undefined) {
+        return initializeExplicitRoot(options.storageDirectory, directoryAccessControl);
+    }
+    let lastError;
+    for (const candidate of storageRootCandidates()) {
+        const root = defaultStorageBaseRoot(candidate);
+        try {
+            return await initializeDefaultRoot(root, directoryAccessControl);
+        }
+        catch (error) {
+            lastError = error;
+            logger.warn("[PersistentStore] Durable storage candidate unavailable", partitionedStorageRoot(root), error);
+        }
+    }
+    if (lastError instanceof Error) {
+        throw lastError;
+    }
+    throw new Error("Unable to initialize durable storage root");
+}
+async function initializeRoot(root, recursive = true, directoryAccessControl) {
+    try {
+        await fs.mkdir(root, { recursive, mode: OWNER_DIRECTORY_MODE });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST") {
+            throw error;
+        }
+    }
+    return verifyRoot(root, directoryAccessControl);
+}
+async function initializeExplicitRoot(root, directoryAccessControl) {
+    const baseRoot = await initializeRoot(root, true, directoryAccessControl);
+    return initializeRoot(partitionedStorageRoot(baseRoot), false, directoryAccessControl);
+}
+async function initializeDefaultRoot(root, directoryAccessControl) {
+    const baseRoot = await initializeRoot(root, process.platform === "win32", directoryAccessControl);
+    return initializeRoot(partitionedStorageRoot(baseRoot), false, directoryAccessControl);
+}
+async function verifyRoot(root, directoryAccessControl) {
+    let stats = await fs.lstat(root);
+    if (stats.isSymbolicLink() || !stats.isDirectory()) {
+        throw new Error(`Durable storage root must be a real directory: ${root}`);
+    }
+    if (process.platform === "win32") {
+        await directoryAccessControl?.hardenDirectory(root);
+        stats = await fs.lstat(root);
+        if (stats.isSymbolicLink() || !stats.isDirectory()) {
+            throw new Error(`Durable storage root must be a real directory: ${root}`);
+        }
+    }
+    else {
+        const uid = process.getuid?.();
+        if (uid !== undefined && stats.uid !== uid) {
+            throw new Error(`Durable storage root must be owned by the current user: ${root}`);
+        }
+        await fs.chmod(root, OWNER_DIRECTORY_MODE);
+        stats = await fs.lstat(root);
+        if (stats.isSymbolicLink() ||
+            !stats.isDirectory() ||
+            (uid !== undefined && stats.uid !== uid)) {
+            throw new Error(`Durable storage root must be a real directory owned by the current user: ${root}`);
+        }
+    }
+    await probeRoot(root);
+    return root;
+}
+let defaultDirectoryAccessControl;
+function resolveDirectoryAccessControl(directoryAccessControl) {
+    if (directoryAccessControl !== undefined) {
+        return directoryAccessControl;
+    }
+    if (process.platform !== "win32") {
+        return undefined;
+    }
+    defaultDirectoryAccessControl ??= new WindowsFileAccessControl_js_1.WindowsFileAccessControl();
+    return defaultDirectoryAccessControl;
+}
+function defaultStorageBaseRoot(candidate) {
+    if (process.platform === "win32") {
+        return (0, node_path_1.join)(candidate, ...WINDOWS_PROBE_DIRECTORY);
+    }
+    return (0, node_path_1.join)(candidate, `${POSIX_DEFAULT_LEAF_PREFIX}-${process.getuid?.() ?? "unknown"}`);
+}
+function applicationPartition() {
+    const identity = [
+        process.getuid?.() ?? "unknown",
+        process.execPath,
+        stableApplicationIdentityBase(),
+    ].join("\0");
+    const partition = (0, node_crypto_1.createHash)("sha256").update(identity).digest("hex").slice(0, 16);
+    return `${APPLICATION_PARTITION_PREFIX}${partition}`;
+}
+function stableApplicationIdentityBase() {
+    const entryPoint = process.argv[1];
+    if (typeof entryPoint === "string" && entryPoint.length > 0) {
+        return (0, node_path_1.isAbsolute)(entryPoint) ? entryPoint : (0, node_path_1.resolve)(PROCESS_START_CWD, entryPoint);
+    }
+    return PROCESS_START_CWD;
+}
+function partitionedStorageRoot(root) {
+    return (0, node_path_1.join)(root, applicationPartition());
+}
+function storageRootCandidates() {
+    const candidates = process.platform === "win32"
+        ? [process.env.LOCALAPPDATA, process.env.TEMP, os.tmpdir()]
+        : [process.env.TMPDIR, "/var/tmp", "/tmp"];
+    return [...new Set(candidates.filter(isNonEmptyString))];
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.length > 0;
+}
+async function probeRoot(root) {
+    const probePath = (0, node_path_1.join)(root, `.probe-${process.pid}-${(0, node_crypto_1.randomUUID)()}`);
+    const handle = await fs.open(probePath, "wx", OWNER_FILE_MODE);
+    try {
+        await handle.writeFile("probe", "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await fs.unlink(probePath);
+    await syncDirectory(root);
+}
+async function quarantineFile(path) {
+    await fs.rename(path, (0, node_path_1.join)((0, node_path_1.dirname)(path), `${leasePrefix(path)}${QUARANTINE_SUFFIX}`));
+    await syncDirectory((0, node_path_1.dirname)(path));
+}
+async function syncDirectory(root) {
+    if (process.platform === "win32") {
+        return;
+    }
+    const handle = await fs.open(root, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+function parseCreatedAt(path) {
+    const match = /^(\d+)-/.exec((0, node_path_1.basename)(path));
+    if (!match) {
+        return undefined;
+    }
+    const createdAt = Number.parseInt(match[1], 10);
+    return Number.isFinite(createdAt) ? createdAt : undefined;
+}
+function leasePrefix(path) {
+    return (0, node_path_1.basename)(path).split(".lease-")[0];
+}
+function recordBasename(record) {
+    return `${record.createdAt}-${record.id}`;
+}
+function stableRecordBasename(path) {
+    return leasePrefix(path).split(".")[0];
+}
+function parseLeaseClaimedAt(path) {
+    const match = /\.lease-at-(\d+)-\d+-[^.]+$/.exec((0, node_path_1.basename)(path));
+    if (!match) {
+        return undefined;
+    }
+    const claimedAt = Number.parseInt(match[1], 10);
+    return Number.isFinite(claimedAt) ? claimedAt : undefined;
+}
+function isActiveLeaseFileName(name) {
+    return /\.lease-[^.]+$/.test(name);
+}
+function isEvictableFileName(name) {
+    return name.endsWith(PENDING_SUFFIX) || name.endsWith(QUARANTINE_SUFFIX);
+}
+function isManagedFileName(name) {
+    return (isEvictableFileName(name) || name.endsWith(TEMPORARY_SUFFIX) || isActiveLeaseFileName(name));
+}
+function isEnoent(error) {
+    return error.code === "ENOENT";
+}
+function isEnametoolong(error) {
+    return error.code === "ENAMETOOLONG";
+}
+function isSafeLeaseBasename(candidateLeasePath) {
+    return Buffer.byteLength((0, node_path_1.basename)(candidateLeasePath), "utf8") <= MAX_FILENAME_COMPONENT_BYTES;
+}
+function poisonQuarantineName() {
+    return `${Date.now()}-quarantined-${process.pid}-${(0, node_crypto_1.randomUUID)()}${QUARANTINE_SUFFIX}`;
+}
+async function unlinkIfExists(path) {
+    try {
+        await fs.unlink(path);
+        return true;
+    }
+    catch (error) {
+        if (isEnoent(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function ignoreEnoent(action) {
+    try {
+        await action();
+    }
+    catch (error) {
+        if (!isEnoent(error)) {
+            throw error;
+        }
+    }
+}
+function sumBytes(files) {
+    return files.reduce((total, file) => total + file.size, 0);
+}
+//# sourceMappingURL=PersistentStore.js.map