pi-agent-browser-native 0.9.4 → 0.9.6

package/dist/extensions/agent-browser/lib/managed-session-restore-state.js

@@ -1,83 +0,0 @@
-import { getAgentBrowserSessionIdentityKey } from "./argv-grammar.js";
-import { isRecord } from "./parsing.js";
-/** Per-extension sticky restore decisions and current-process daemon provenance. */
-export class ManagedSessionRestoreState {
-    #daemonRestoreKeys = new Map();
-    #disabled = new Set();
-    clear(sessionName, namespace) {
-        if (sessionName !== undefined && sessionName.length > 0) {
-            const identity = getAgentBrowserSessionIdentityKey(sessionName, namespace);
-            this.#daemonRestoreKeys.delete(identity);
-            this.#disabled.delete(identity);
-        }
-        else {
-            this.#daemonRestoreKeys.clear();
-            this.#disabled.clear();
-        }
-    }
-    disable(sessionName, namespace) {
-        if (sessionName !== undefined && sessionName.length > 0) {
-            this.#disabled.add(getAgentBrowserSessionIdentityKey(sessionName, namespace));
-        }
-    }
-    getDaemonRestoreKey(sessionName, namespace) {
-        return typeof sessionName === "string"
-            ? this.#daemonRestoreKeys.get(getAgentBrowserSessionIdentityKey(sessionName, namespace))
-                ?.restoreKey
-            : undefined;
-    }
-    hasDaemonRestoreKey(sessionName, namespace) {
-        return (typeof sessionName === "string" &&
-            this.#daemonRestoreKeys.get(getAgentBrowserSessionIdentityKey(sessionName, namespace))
-                ?.restored !== true &&
-            this.#daemonRestoreKeys.has(getAgentBrowserSessionIdentityKey(sessionName, namespace)));
-    }
-    forgetDaemonRestoreKey(sessionName, namespace) {
-        if (sessionName !== undefined && sessionName.length > 0) {
-            this.#daemonRestoreKeys.delete(getAgentBrowserSessionIdentityKey(sessionName, namespace));
-        }
-    }
-    isDisabled(sessionName, namespace) {
-        return (typeof sessionName === "string" &&
-            this.#disabled.has(getAgentBrowserSessionIdentityKey(sessionName, namespace)));
-    }
-    recordDaemonRestoreKey(sessionName, namespace, restoreKey, generation) {
-        if (sessionName !== undefined && sessionName.length > 0) {
-            const key = getAgentBrowserSessionIdentityKey(sessionName, namespace);
-            const previous = this.#daemonRestoreKeys.get(key);
-            this.#daemonRestoreKeys.set(key, {
-                restoreKey,
-                generation: generation ?? (previous?.restoreKey === restoreKey ? previous.generation : undefined),
-            });
-        }
-    }
-    getDaemonReceipt(sessionName, namespace) {
-        const receipt = sessionName !== undefined && sessionName.length > 0
-            ? this.#daemonRestoreKeys.get(getAgentBrowserSessionIdentityKey(sessionName, namespace))
-            : undefined;
-        return receipt?.generation !== undefined && receipt.generation.length > 0
-            ? { restoreKey: receipt.restoreKey, generation: receipt.generation }
-            : undefined;
-    }
-    restoreDaemonReceipt(sessionName, namespace, receipt) {
-        if (isRecord(receipt) &&
-            typeof receipt.generation === "string" &&
-            receipt.generation.length > 0 &&
-            (receipt.restoreKey === null || typeof receipt.restoreKey === "string")) {
-            this.#daemonRestoreKeys.set(getAgentBrowserSessionIdentityKey(sessionName, namespace), {
-                restoreKey: receipt.restoreKey,
-                generation: receipt.generation,
-                restored: true,
-            });
-        }
-    }
-    replace(identities = [], options = {}) {
-        if (options.preserveDaemonRestoreKeys !== true) {
-            this.#daemonRestoreKeys.clear();
-        }
-        this.#disabled.clear();
-        for (const identity of identities) {
-            this.disable(identity.sessionName, identity.namespace);
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/managed-session-restore.js

@@ -1,212 +0,0 @@
-import { isUpstreamEnvFlagEnabled } from "./argv-grammar.js";
-import { MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS, MANAGED_RESTORE_INCOMPATIBLE_ENVS, } from "./launch-scoped-flags.js";
-import { createManagedSessionRestoreKey, ensureManagedSessionRestoreStorageIsSecure, getManagedSessionRestoreScope, getManagedSessionRestoreProtectedStorageEnv, hasManagedSessionRestoreProjectIdentity, } from "./managed-session-storage.js";
-import { getAgentBrowserProcessEnvironment } from "./process-environment.js";
-import { AGENT_BROWSER_CONFIG_ENV, AGENT_BROWSER_RESTORE_ENV, MANAGED_SESSION_RESTORE_ENV, agentBrowserExplicitConfigIsPresent, closesBrowserSession, isDisabledEnvFlag, hasUpstreamEnvValue, isManagedSessionRestoreIncompatible, managedSessionRestoreOptedOut, resolveExplicitAutosaveInterval, resolveManagedSessionRestorePolicy, } from "./managed-session-restore-policy.js";
-export { agentBrowserConfigBlocksManagedRestore, resolveExplicitAutosaveInterval, } from "./managed-session-restore-policy.js";
-export { createManagedSessionRestoreKey, ensureManagedSessionRestoreStorageIsSecure, getManagedSessionRestoreScope, } from "./managed-session-storage.js";
-export { pruneOwnedManagedSessionRestoreSnapshots } from "./managed-session-snapshots.js";
-export { ManagedSessionRestoreState, } from "./managed-session-restore-state.js";
-export { withOwnedManagedSessionContext, resolveOwnedManagedSessionContext, isOwnedManagedSessionTarget, } from "./owned-managed-session-context.js";
-export { buildOwnedManagedSessionRestoreContext } from "./managed-session-restore-context.js";
-export const MANAGED_SESSION_NAME_PREFIX = "piab-";
-const SPAWN_PINNED_ENVS = new Set([AGENT_BROWSER_CONFIG_ENV, AGENT_BROWSER_RESTORE_ENV]);
-export function getOwnedManagedSessionNamespaceEnv(options) {
-    const { namespace, owned, ownedContext } = resolveManagedSessionRestorePolicy(options);
-    return owned ? { AGENT_BROWSER_NAMESPACE: ownedContext?.namespace ?? namespace ?? "" } : {};
-}
-function compatibilityForReuse(context, env, args, explicit) {
-    return explicit === undefined &&
-        context.headedManagedAutosaveInterval !== undefined &&
-        !agentBrowserExplicitConfigIsPresent(env, args)
-        ? { AGENT_BROWSER_AUTOSAVE_INTERVAL_MS: context.headedManagedAutosaveInterval }
-        : {};
-}
-function explicitAutosaveInterval(options) {
-    const parent = options.parentEnv ?? getAgentBrowserProcessEnvironment();
-    const env = options.env ?? {};
-    return Object.hasOwn(env, "AGENT_BROWSER_AUTOSAVE_INTERVAL_MS")
-        ? env.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS
-        : parent.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS;
-}
-export function getOwnedManagedSessionCompatibilityEnv(options) {
-    const { owned, ownedContext } = resolveManagedSessionRestorePolicy(options);
-    if (!owned || !ownedContext) {
-        return {};
-    }
-    const parentEnv = options.parentEnv ?? getAgentBrowserProcessEnvironment();
-    const callEnv = options.env ?? {};
-    const explicit = explicitAutosaveInterval(options);
-    if (ownedContext.reuseOnly === true) {
-        return compatibilityForReuse(ownedContext, { ...parentEnv, ...callEnv }, options.args, explicit);
-    }
-    const env = {};
-    if (ownedContext.compatibilityUserAgent !== undefined &&
-        ownedContext.compatibilityUserAgent.length > 0) {
-        env.AGENT_BROWSER_USER_AGENT = ownedContext.compatibilityUserAgent;
-    }
-    if (ownedContext.headedManagedAutosaveInterval !== undefined &&
-        resolveExplicitAutosaveInterval(explicit) !== ownedContext.headedManagedAutosaveInterval) {
-        env.AGENT_BROWSER_AUTOSAVE_INTERVAL_MS = ownedContext.headedManagedAutosaveInterval;
-    }
-    return env;
-}
-export function getManagedSessionRestoreProtectedEnv(options, restoreEnv) {
-    const { ownedContext } = resolveManagedSessionRestorePolicy(options);
-    if (restoreEnv[AGENT_BROWSER_RESTORE_ENV] === undefined) {
-        return {};
-    }
-    if (ownedContext?.protectedStorageEnv) {
-        return { ...ownedContext.protectedStorageEnv };
-    }
-    return getManagedSessionRestoreProtectedStorageEnv(true, {
-        ...(options.parentEnv ?? getAgentBrowserProcessEnvironment()),
-        ...options.env,
-    });
-}
-function validRestoreIdentity(context, cwd) {
-    if (context.restoreKey === undefined ||
-        context.restoreKey.length === 0 ||
-        context.restoreScope === undefined ||
-        context.restoreScope.length === 0) {
-        return false;
-    }
-    return (createManagedSessionRestoreKey(cwd, context.restoreScope) === context.restoreKey &&
-        hasManagedSessionRestoreProjectIdentity(cwd));
-}
-function validLaunchEnvironment(options, context, env) {
-    if (context.reuseOnly === true) {
-        return true;
-    }
-    if (isDisabledEnvFlag(env[MANAGED_SESSION_RESTORE_ENV])) {
-        return false;
-    }
-    if (MANAGED_RESTORE_INCOMPATIBLE_ENVS.some((name) => !SPAWN_PINNED_ENVS.has(name) && hasUpstreamEnvValue(env, name))) {
-        return false;
-    }
-    if (MANAGED_RESTORE_INCOMPATIBLE_BOOLEAN_ENVS.some((name) => isUpstreamEnvFlagEnabled(env[name]))) {
-        return false;
-    }
-    return (options.env?.[AGENT_BROWSER_RESTORE_ENV] === undefined ||
-        options.env[AGENT_BROWSER_RESTORE_ENV] === context.restoreKey);
-}
-export function validateManagedSessionRestoreContextForSpawn(options) {
-    const { namespace, ownedContext, parentEnv } = resolveManagedSessionRestorePolicy(options);
-    if (closesBrowserSession(options.args) ||
-        ownedContext?.restoreDecision !== "enabled" ||
-        (ownedContext.reuseOnly === true && ownedContext.restoreSuppressed === true)) {
-        return true;
-    }
-    if (!validRestoreIdentity(ownedContext, ownedContext.cwd ?? options.cwd)) {
-        return false;
-    }
-    const env = { ...parentEnv, ...options.env };
-    return (validLaunchEnvironment(options, ownedContext, env) &&
-        ensureManagedSessionRestoreStorageIsSecure({ ...env, ...ownedContext.protectedStorageEnv }, process.platform, namespace));
-}
-function reuseRestoreEnv(options, context) {
-    return context.restoreKey !== undefined &&
-        context.restoreKey.length > 0 &&
-        context.restoreSuppressed !== true &&
-        validateManagedSessionRestoreContextForSpawn(options)
-        ? { [AGENT_BROWSER_RESTORE_ENV]: context.restoreKey }
-        : {};
-}
-function disabledByPolicy(options, context, namespace) {
-    return (managedSessionRestoreOptedOut(options) ||
-        context?.restoreSuppressed === true ||
-        isManagedSessionRestoreIncompatible(options, namespace));
-}
-function configuredRestoreEnv(options, context, policy) {
-    if (context.restoreDecision !== "enabled" ||
-        !policy.restoreState ||
-        policy.restoreState.isDisabled(policy.sessionName, policy.namespace)) {
-        return {};
-    }
-    if (policy.sessionName === undefined ||
-        policy.sessionName.length === 0 ||
-        context.restoreKey === undefined ||
-        context.restoreKey.length === 0 ||
-        !validateManagedSessionRestoreContextForSpawn(options)) {
-        return {};
-    }
-    return { [AGENT_BROWSER_RESTORE_ENV]: context.restoreKey };
-}
-function automaticRestoreEnv(options, policy) {
-    if (disabledByPolicy({ ...options, parentEnv: policy.parentEnv }, policy.ownedContext, policy.namespace)) {
-        return {};
-    }
-    if (!policy.restoreState ||
-        policy.restoreState.isDisabled(policy.sessionName, policy.namespace) ||
-        policy.sessionName === undefined ||
-        policy.sessionName.length === 0) {
-        return {};
-    }
-    return {
-        [AGENT_BROWSER_RESTORE_ENV]: createManagedSessionRestoreKey(options.cwd, getManagedSessionRestoreScope(policy.sessionName)),
-    };
-}
-export function getManagedSessionRestoreEnv(options) {
-    const policy = resolveManagedSessionRestorePolicy(options);
-    if (!policy.owned || !policy.restoreState || closesBrowserSession(options.args)) {
-        return {};
-    }
-    const context = policy.ownedContext;
-    if (context?.reuseOnly === true) {
-        return reuseRestoreEnv(options, context);
-    }
-    if (context?.restoreDecision !== undefined) {
-        return configuredRestoreEnv(options, context, policy);
-    }
-    return automaticRestoreEnv(options, policy);
-}
-function recordEnabledDaemonKey(options, context) {
-    const { namespace, restoreState, sessionName } = resolveManagedSessionRestorePolicy(options);
-    if (options.ownedManagedSession !== true || !restoreState) {
-        return;
-    }
-    const disabled = restoreState.isDisabled(sessionName, namespace);
-    if (!disabled && context.restoreKey !== undefined && context.restoreKey.length > 0) {
-        restoreState.recordDaemonRestoreKey(sessionName, namespace, context.restoreKey);
-    }
-    else if (disabled && !restoreState.hasDaemonRestoreKey(sessionName, namespace)) {
-        restoreState.recordDaemonRestoreKey(sessionName, namespace, null);
-    }
-}
-function commitPlannedDecision(options, context, policy) {
-    if (context.restoreDecision === "enabled") {
-        recordEnabledDaemonKey(options, context);
-        return;
-    }
-    if (!policy.restoreState) {
-        return;
-    }
-    if (options.ownedManagedSession === true) {
-        policy.restoreState.recordDaemonRestoreKey(policy.sessionName, policy.namespace, context.expectedDaemonRestoreKey ?? null);
-    }
-    policy.restoreState.disable(policy.sessionName, policy.namespace);
-}
-/** Commit sticky suppression only after an owned-context subprocess has actually started. */
-export function commitManagedSessionRestoreSuppression(options) {
-    const { namespace, owned, ownedContext, parentEnv, restoreState, sessionName } = resolveManagedSessionRestorePolicy(options);
-    if (!owned ||
-        !restoreState ||
-        ownedContext?.reuseOnly === true ||
-        closesBrowserSession(options.args)) {
-        return;
-    }
-    if (ownedContext?.restoreDecision !== undefined) {
-        commitPlannedDecision(options, ownedContext, {
-            namespace,
-            owned,
-            ownedContext,
-            parentEnv,
-            restoreState,
-            sessionName,
-        });
-        return;
-    }
-    if (disabledByPolicy({ ...options, parentEnv }, ownedContext, namespace)) {
-        restoreState.disable(sessionName, namespace);
-    }
-}

package/dist/extensions/agent-browser/lib/managed-session-snapshot-records.js

@@ -1,277 +0,0 @@
-import { createHash, randomUUID } from "node:crypto";
-import { chmodSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmdirSync, unlinkSync, writeFileSync, } from "node:fs";
-import { basename, dirname, isAbsolute, join } from "node:path";
-import { directoryContainsSymlink, ensureOwnerOnlyDirectory, getManagedRestoreSessionsDirectory, resolveManagedSessionRestoreCheckoutRoot, } from "./managed-session-storage.js";
-import { getErrorCode } from "./process-errors.js";
-export const OWNED_RESTORE_SNAPSHOT_FAMILIES_TO_KEEP = 2;
-export const OWNED_RESTORE_SNAPSHOT_MAX_RECORDS = 256;
-export const OWNED_RESTORE_SNAPSHOT_RECORD_MAX_BYTES = 16 * 1_024;
-export const OWNED_RESTORE_SNAPSHOT_MANIFEST_PREFIX = ".pi-agent-browser-owned-snapshots-v2";
-export const OWNED_RESTORE_SNAPSHOT_LINEAGE_DIRECTORY = ".checkout-lineage-v1";
-export const OWNED_RESTORE_SNAPSHOT_TEMP_MAX_AGE_MS = 30_000;
-export const OWNED_RESTORE_SNAPSHOT_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1_000;
-export function pathExistsOrIsUnreadable(path) {
-    try {
-        lstatSync(path);
-        return true;
-    }
-    catch (error) {
-        return getErrorCode(error) !== "ENOENT";
-    }
-}
-export function validateOwnedSnapshotPath(options) {
-    if (!isAbsolute(options.path)) {
-        return undefined;
-    }
-    let path;
-    try {
-        path = realpathSync(options.path);
-    }
-    catch {
-        return undefined;
-    }
-    const directory = getManagedRestoreSessionsDirectory(options.home, options.namespace);
-    const name = basename(path);
-    if (dirname(path) !== directory ||
-        !name.startsWith(`${options.restoreKey}-`) ||
-        !/\.json(?:\.enc)?$/.test(name)) {
-        return undefined;
-    }
-    try {
-        const entry = lstatSync(path);
-        return !entry.isSymbolicLink() && entry.isFile() ? path : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export function getManifestDirectory(directory, restoreKey) {
-    return join(directory, `${OWNED_RESTORE_SNAPSHOT_MANIFEST_PREFIX}-${restoreKey}`);
-}
-export function ensureManifestDirectory(path, platform) {
-    if (platform !== "win32") {
-        return ensureOwnerOnlyDirectory(path, platform) && !directoryContainsSymlink(path);
-    }
-    try {
-        mkdirSync(path, { recursive: true });
-        const entry = lstatSync(path);
-        return !entry.isSymbolicLink() && entry.isDirectory() && !directoryContainsSymlink(path);
-    }
-    catch {
-        return false;
-    }
-}
-export function getCheckoutLineageHash(cwd, platform) {
-    const root = resolveManagedSessionRestoreCheckoutRoot(cwd, platform);
-    if (root === undefined || root.length === 0) {
-        return undefined;
-    }
-    return createHash("sha256")
-        .update(`managed-snapshot-lineage-v1:${platform}:${platform === "win32" ? root.toLowerCase() : root}`)
-        .digest("hex");
-}
-function privateOwnedDirectory(entry, platform) {
-    if (platform === "win32") {
-        return true;
-    }
-    const uid = typeof process.getuid === "function" ? process.getuid() : undefined;
-    return uid !== undefined && entry.uid === uid && (entry.mode & 0o077) === 0;
-}
-export function manifestHasLineage(directory, lineage, platform) {
-    const lineageDirectory = join(directory, OWNED_RESTORE_SNAPSHOT_LINEAGE_DIRECTORY);
-    try {
-        const directoryEntry = lstatSync(lineageDirectory);
-        if (directoryEntry.isSymbolicLink() ||
-            !directoryEntry.isDirectory() ||
-            directoryContainsSymlink(lineageDirectory) ||
-            !privateOwnedDirectory(directoryEntry, platform)) {
-            return false;
-        }
-        const entry = lstatSync(join(lineageDirectory, lineage));
-        if (entry.isSymbolicLink() || !entry.isFile() || entry.size !== 0) {
-            return false;
-        }
-        return platform === "win32" || (entry.mode & 0o077) === 0;
-    }
-    catch {
-        return false;
-    }
-}
-export function ensureManifestLineage(directory, lineage, platform) {
-    const lineageDirectory = join(directory, OWNED_RESTORE_SNAPSHOT_LINEAGE_DIRECTORY);
-    if (!ensureManifestDirectory(lineageDirectory, platform)) {
-        return false;
-    }
-    const path = join(lineageDirectory, lineage);
-    try {
-        writeFileSync(path, "", { encoding: "utf8", flag: "wx", mode: 0o600 });
-        if (platform !== "win32") {
-            chmodSync(path, 0o600);
-        }
-    }
-    catch (error) {
-        if (getErrorCode(error) !== "EEXIST") {
-            return false;
-        }
-    }
-    return manifestHasLineage(directory, lineage, platform);
-}
-export function removeManifestLineages(directory, platform) {
-    const lineageDirectory = join(directory, OWNED_RESTORE_SNAPSHOT_LINEAGE_DIRECTORY);
-    try {
-        if (!ensureManifestDirectory(lineageDirectory, platform)) {
-            return;
-        }
-        for (const entry of readdirSync(lineageDirectory, { withFileTypes: true })) {
-            if (entry.isFile() && /^[a-f\d]{64}$/.test(entry.name)) {
-                unlinkSync(join(lineageDirectory, entry.name));
-            }
-        }
-        rmdirSync(lineageDirectory);
-    }
-    catch {
-        /* Unreadable or concurrently changed ownership evidence remains intact. */
-    }
-}
-function getRecordPath(directory, snapshotPath) {
-    return join(directory, `${createHash("sha256").update(snapshotPath).digest("hex")}.json`);
-}
-function discardRecord(path) {
-    try {
-        unlinkSync(path);
-    }
-    catch {
-        /* Unreadable or concurrently changed ownership evidence remains intact. */
-    }
-}
-function recordFileValid(entry, platform) {
-    return (!entry.isSymbolicLink() &&
-        entry.isFile() &&
-        entry.size <= OWNED_RESTORE_SNAPSHOT_RECORD_MAX_BYTES &&
-        (platform === "win32" || (entry.mode & 0o077) === 0));
-}
-function existingRecord(path, snapshotPath, platform) {
-    try {
-        const entry = lstatSync(path);
-        if (entry.isSymbolicLink() || !entry.isFile()) {
-            return false;
-        }
-        if (entry.size <= OWNED_RESTORE_SNAPSHOT_RECORD_MAX_BYTES &&
-            JSON.parse(readFileSync(path, "utf8")) === snapshotPath) {
-            return platform === "win32" || (entry.mode & 0o077) === 0;
-        }
-        unlinkSync(path);
-    }
-    catch (error) {
-        if (getErrorCode(error) !== "ENOENT" && !(error instanceof SyntaxError)) {
-            return false;
-        }
-        discardRecord(path);
-    }
-    return undefined;
-}
-function verifyRecord(path, snapshotPath, platform) {
-    try {
-        return (recordFileValid(lstatSync(path), platform) &&
-            JSON.parse(readFileSync(path, "utf8")) === snapshotPath);
-    }
-    catch {
-        return false;
-    }
-}
-function publishRecord(path, snapshotPath, content, platform) {
-    const temporaryPath = join(dirname(path), `.tmp-${process.pid}-${randomUUID()}`);
-    try {
-        writeFileSync(temporaryPath, content, { encoding: "utf8", flag: "wx", mode: 0o600 });
-        renameSync(temporaryPath, path);
-        if (platform !== "win32") {
-            chmodSync(path, 0o600);
-        }
-        return true;
-    }
-    catch {
-        return verifyRecord(path, snapshotPath, platform);
-    }
-    finally {
-        discardRecord(temporaryPath);
-    }
-}
-export function writeRecord(directory, snapshotPath, platform) {
-    const content = JSON.stringify(snapshotPath);
-    if (Buffer.byteLength(content) > OWNED_RESTORE_SNAPSHOT_RECORD_MAX_BYTES) {
-        return false;
-    }
-    const path = getRecordPath(directory, snapshotPath);
-    const existing = existingRecord(path, snapshotPath, platform);
-    return existing ?? publishRecord(path, snapshotPath, content, platform);
-}
-function readRecord(options) {
-    try {
-        if (!recordFileValid(lstatSync(options.path), options.platform)) {
-            return undefined;
-        }
-        const parsed = JSON.parse(readFileSync(options.path, "utf8"));
-        if (typeof parsed !== "string" || !isAbsolute(parsed)) {
-            return undefined;
-        }
-        const path = validateOwnedSnapshotPath({
-            home: options.home,
-            namespace: options.namespace,
-            path: parsed,
-            restoreKey: options.restoreKey,
-        });
-        return path !== undefined &&
-            path.length > 0 &&
-            getRecordPath(dirname(options.path), path) === options.path
-            ? path
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function removeExpiredTemporary(path) {
-    try {
-        if (Date.now() - lstatSync(path).mtimeMs > OWNED_RESTORE_SNAPSHOT_TEMP_MAX_AGE_MS) {
-            unlinkSync(path);
-        }
-    }
-    catch {
-        /* Concurrent mutation or unreadable ownership evidence remains intact. */
-    }
-}
-function snapshotReceipt(path, recordPath) {
-    try {
-        return { mtimeMs: lstatSync(path).mtimeMs, path, recordPath };
-    }
-    catch {
-        discardRecord(recordPath);
-        return undefined;
-    }
-}
-export function scanOwnedSnapshots(options) {
-    const snapshots = [];
-    for (const entry of readdirSync(options.manifestDirectory, { withFileTypes: true })) {
-        if (entry.isFile() && entry.name.startsWith(".tmp-")) {
-            removeExpiredTemporary(join(options.manifestDirectory, entry.name));
-            continue;
-        }
-        if (!entry.isFile() || !/^[a-f\d]{64}\.json$/.test(entry.name)) {
-            continue;
-        }
-        const recordPath = join(options.manifestDirectory, entry.name);
-        const path = readRecord({ ...options, path: recordPath });
-        if (path === undefined || path.length === 0) {
-            discardRecord(recordPath);
-            continue;
-        }
-        const receipt = snapshotReceipt(path, recordPath);
-        if (receipt) {
-            snapshots.push(receipt);
-        }
-    }
-    return snapshots.sort((left, right) => {
-        const time = right.mtimeMs - left.mtimeMs;
-        return time === 0 ? left.path.localeCompare(right.path) : time;
-    });
-}