@microsoft/opentelemetry 1.3.0 → 1.5.0

package/dist/esm/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/esm/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/esm/a365/exporter/durable/PersistentStore.js

@@ -0,0 +1,599 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+import { createHash, randomUUID } from "node:crypto";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { parseDurableRecord } from "./DurableRecord.js";
+import { WindowsFileAccessControl, } from "./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();
+export 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 {
+                    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 = 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-${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, 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 join(this.root, suffix ? `${baseName}.${suffix}${PENDING_SUFFIX}` : `${baseName}${PENDING_SUFFIX}`);
+    }
+    async recoveredPendingPath(leasePath) {
+        const text = await fs.readFile(leasePath, "utf8");
+        const suffix = `recovered-${randomUUID()}`;
+        try {
+            return this.pendingPath(parseDurableRecord(text), suffix);
+        }
+        catch {
+            return join(this.root, `${stableRecordBasename(leasePath)}.${suffix}${PENDING_SUFFIX}`);
+        }
+    }
+    leasePath(pendingPath) {
+        return pendingPath.replace(/\.pending$/, `.lease-at-${Date.now()}-${process.pid}-${randomUUID()}`);
+    }
+    migratedLeasePath(leasePath, claimedAt) {
+        return join(this.root, `${leasePrefix(leasePath)}.lease-at-${claimedAt}-${process.pid}-${randomUUID()}`);
+    }
+    temporaryPath(record) {
+        return join(this.root, `${Date.now()}-${record.id}.${process.pid}-${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 = 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) => 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);
+            }
+        }
+    }
+}
+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();
+    return defaultDirectoryAccessControl;
+}
+function defaultStorageBaseRoot(candidate) {
+    if (process.platform === "win32") {
+        return join(candidate, ...WINDOWS_PROBE_DIRECTORY);
+    }
+    return join(candidate, `${POSIX_DEFAULT_LEAF_PREFIX}-${process.getuid?.() ?? "unknown"}`);
+}
+export function applicationPartition() {
+    const identity = [
+        process.getuid?.() ?? "unknown",
+        process.execPath,
+        stableApplicationIdentityBase(),
+    ].join("\0");
+    const partition = 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 isAbsolute(entryPoint) ? entryPoint : resolve(PROCESS_START_CWD, entryPoint);
+    }
+    return PROCESS_START_CWD;
+}
+function partitionedStorageRoot(root) {
+    return 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 = join(root, `.probe-${process.pid}-${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, join(dirname(path), `${leasePrefix(path)}${QUARANTINE_SUFFIX}`));
+    await syncDirectory(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(basename(path));
+    if (!match) {
+        return undefined;
+    }
+    const createdAt = Number.parseInt(match[1], 10);
+    return Number.isFinite(createdAt) ? createdAt : undefined;
+}
+function leasePrefix(path) {
+    return 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(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(basename(candidateLeasePath), "utf8") <= MAX_FILENAME_COMPONENT_BYTES;
+}
+function poisonQuarantineName() {
+    return `${Date.now()}-quarantined-${process.pid}-${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