pi-agent-browser-native 0.9.4 → 0.9.6

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

@@ -1,353 +0,0 @@
-import { isRecord } from "./parsing.js";
-import { randomUUID } from "node:crypto";
-import { getAgentBrowserSessionIdentityKey, isAgentBrowserSessionIdentityKeyInNamespace, } from "./argv-grammar.js";
-import { getBrowserRecord, snapshotFromDefinition, } from "./browser-transcript.js";
-import { findReadConfirmation as findPendingReadConfirmation, parseReadConfirmation, } from "./read-confirmation.js";
-import { buildPageTransitionRefSnapshotInvalidation, stripRefSnapshotOrder, stripRefSnapshotInvalidationOrder, shouldApplyTabTargetUpdate, shouldApplyRefStateUpdate, } from "./session-page-observation.js";
-export * from "./session-page-observation.js";
-export class SessionPageState {
-    confirmActions = new Map();
-    readConfirmations = new Map();
-    refSnapshotInvalidations = new Map();
-    refSnapshots = new Map();
-    tabPinningReasons = new Map();
-    tabTargetUnknownOrders = new Map();
-    tabTargets = new Map();
-    updateOrder = 0;
-    nativeGenerations = new Map();
-    pending = new Map();
-    static fromBranch(branch) {
-        const state = new SessionPageState();
-        for (const entry of branch) {
-            const record = getBrowserRecord(entry);
-            if (record) {
-                state.applyBrowserRecord(record);
-            }
-        }
-        for (const key of state.tabTargets.keys()) {
-            state.tabPinningReasons.set(key, "restore");
-        }
-        return state;
-    }
-    /** A command operates on its admitted state while the committed view is unavailable. */
-    fork() {
-        const state = new SessionPageState();
-        state.confirmActions = new Map(this.confirmActions);
-        state.readConfirmations = new Map(this.readConfirmations);
-        state.refSnapshotInvalidations = new Map(this.refSnapshotInvalidations);
-        state.refSnapshots = new Map(this.refSnapshots);
-        state.tabPinningReasons = new Map(this.tabPinningReasons);
-        state.tabTargetUnknownOrders = new Map(this.tabTargetUnknownOrders);
-        state.tabTargets = new Map([...this.tabTargets].map(([key, value]) => [key, { ...value }]));
-        state.pending = new Map(this.pending);
-        state.nativeGenerations = new Map(this.nativeGenerations);
-        state.updateOrder = this.updateOrder;
-        return state;
-    }
-    views() {
-        return new Map([
-            ...new Set([
-                ...this.confirmActions.keys(),
-                ...this.tabTargets.keys(),
-                ...this.tabTargetUnknownOrders.keys(),
-                ...this.refSnapshots.keys(),
-                ...this.refSnapshotInvalidations.keys(),
-            ]),
-        ].map((key) => [key, this.get(key)]));
-    }
-    /** The same reducer commits live observations and replays selected journal envelopes. */
-    applyBrowserRecord({ event, snapshot }) {
-        const update = this.beginUpdate();
-        const confirmation = parseReadConfirmation(event.state.readConfirmation);
-        for (const page of event.pages ?? []) {
-            this.applyPageRecord({ page, event, snapshot, update });
-        }
-        if (confirmation) {
-            this.applyReadConfirmation(confirmation, update);
-        }
-    }
-    applyPageRecord(options) {
-        const { page, event, snapshot, update } = options;
-        const key = page.key;
-        if (page.clear === true) {
-            this.clearSession(key);
-            return;
-        }
-        const pending = this.pending.get(key);
-        if (event.phase === "finish" && pending && pending.operationId !== event.operationId) {
-            return;
-        }
-        if (page.confirmActions !== undefined) {
-            this.setConfirmActions(key, page.confirmActions ?? undefined);
-        }
-        if (this.applyUnknownPageRecord(page, event, update)) {
-            return;
-        }
-        this.applyPageTargetRecord(page, update);
-        this.applyPageRefsRecord({
-            page,
-            snapshot,
-            candidate: pending?.snapshot ?? this.refSnapshots.get(key),
-            update,
-        });
-        this.pending.delete(key);
-    }
-    applyUnknownPageRecord(page, event, update) {
-        const key = page.key;
-        if (event.phase === "begin") {
-            this.pending.set(key, {
-                operationId: event.operationId,
-                snapshot: this.refSnapshots.get(key) ?? this.pending.get(key)?.snapshot,
-            });
-            this.invalidateUnknownPage(key, update, buildPageTransitionRefSnapshotInvalidation("This browser operation has no persisted finish. Inspect the current URL and take a fresh snapshot before using refs; changes may already have happened."));
-            return true;
-        }
-        if (page.unknown === true || page.refs.kind === "unknown") {
-            this.invalidateUnknownPage(key, update, page.refs.kind === "unknown" && page.refs.invalidation
-                ? page.refs.invalidation
-                : buildPageTransitionRefSnapshotInvalidation("The browser target or operation outcome is unknown. Verify the current URL and take a fresh snapshot before using refs."));
-            return true;
-        }
-        return false;
-    }
-    invalidateUnknownPage(key, update, invalidation) {
-        this.markTabTargetUnknown({ sessionName: key, update });
-        this.applyRefSnapshotInvalidation({ sessionName: key, update, invalidation });
-    }
-    applyPageTargetRecord(page, update) {
-        if (page.target) {
-            this.applyTabTarget({ sessionName: page.key, target: page.target, update });
-        }
-        else {
-            this.tabTargets.delete(page.key);
-            this.tabTargetUnknownOrders.delete(page.key);
-        }
-        if (page.reopenPending !== undefined) {
-            this.setTabReopenPending({ pending: page.reopenPending, sessionName: page.key, update });
-        }
-        if (page.pinningReason !== undefined) {
-            this.markPinning(page.key, page.pinningReason);
-        }
-        else {
-            this.tabPinningReasons.delete(page.key);
-        }
-    }
-    applyPageRefsRecord(options) {
-        const { page, snapshot, candidate, update } = options;
-        const key = page.key;
-        if (page.refs.kind === "replace") {
-            const definition = isRecord(snapshot) && snapshot.id === page.refs.snapshotId && Boolean(snapshot.refs)
-                ? snapshotFromDefinition(snapshot)
-                : { snapshotId: page.refs.snapshotId, refIds: [] };
-            this.applyRefSnapshot({
-                sessionName: key,
-                snapshot: definition,
-                fallbackTarget: page.target,
-                update,
-            });
-        }
-        else if (page.refs.kind === "reuse") {
-            if (candidate?.snapshotId === page.refs.snapshotId) {
-                this.applyRefSnapshot({
-                    sessionName: key,
-                    snapshot: candidate,
-                    fallbackTarget: page.target,
-                    update,
-                });
-            }
-            else {
-                this.applyRefSnapshotInvalidation({
-                    sessionName: key,
-                    update,
-                    invalidation: buildPageTransitionRefSnapshotInvalidation("The ancestral snapshot definition is unavailable. Take a new complete snapshot before using refs."),
-                });
-            }
-        }
-        else {
-            this.refSnapshots.delete(key);
-            if (page.refs.invalidation) {
-                this.applyRefSnapshotInvalidation({
-                    sessionName: key,
-                    invalidation: page.refs.invalidation,
-                    update,
-                });
-            }
-            else {
-                this.refSnapshotInvalidations.delete(key);
-            }
-        }
-    }
-    beginUpdate() {
-        this.updateOrder += 1;
-        // This sole constructor brands the privately incremented numeric order without changing runtime comparison semantics.
-        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
-        return this.updateOrder;
-    }
-    reset() {
-        this.confirmActions.clear();
-        this.readConfirmations.clear();
-        this.pending.clear();
-        this.nativeGenerations.clear();
-        this.refSnapshotInvalidations = new Map();
-        this.refSnapshots = new Map();
-        this.tabPinningReasons = new Map();
-        this.tabTargetUnknownOrders = new Map();
-        this.tabTargets = new Map();
-        this.updateOrder = 0;
-    }
-    get(sessionName) {
-        if (sessionName === undefined || sessionName.length === 0) {
-            return {};
-        }
-        return {
-            ...(this.confirmActions.has(sessionName)
-                ? { confirmActions: this.confirmActions.get(sessionName) }
-                : {}),
-            pinningReason: this.tabPinningReasons.get(sessionName),
-            ...(this.tabTargets.get(sessionName)?.reopenPending !== undefined
-                ? { tabReopenPending: this.tabTargets.get(sessionName)?.reopenPending }
-                : {}),
-            refSnapshot: stripRefSnapshotOrder(this.refSnapshots.get(sessionName)),
-            refSnapshotInvalidation: stripRefSnapshotInvalidationOrder(this.refSnapshotInvalidations.get(sessionName)),
-            ...(this.tabTargetUnknownOrders.has(sessionName) ? { tabTargetUnknown: true } : {}),
-            tabTarget: this.tabTargets.get(sessionName)?.target,
-        };
-    }
-    findReadConfirmation(args, namespace, stdin) {
-        return findPendingReadConfirmation(args, [...this.readConfirmations.values()].map((entry) => entry.value), namespace, stdin);
-    }
-    setConfirmActions(sessionName, value) {
-        if (value !== undefined) {
-            this.confirmActions.set(sessionName, value);
-        }
-        else {
-            this.confirmActions.delete(sessionName);
-        }
-    }
-    getReadConfirmation(sessionKey) {
-        return this.readConfirmations.get(sessionKey)?.value;
-    }
-    applyReadConfirmation(value, update) {
-        const key = getAgentBrowserSessionIdentityKey(value.sessionName, value.namespace);
-        if (update >= (this.readConfirmations.get(key)?.order ?? 0)) {
-            this.readConfirmations.set(key, { value, order: update });
-        }
-    }
-    applyTabTarget(options) {
-        const current = this.tabTargets.get(options.sessionName);
-        if (!shouldApplyTabTargetUpdate(current, this.tabTargetUnknownOrders.get(options.sessionName), options.update)) {
-            return { ...this.get(options.sessionName), applied: false, stale: true };
-        }
-        this.tabTargetUnknownOrders.delete(options.sessionName);
-        this.tabTargets.set(options.sessionName, {
-            order: options.update,
-            reopenPending: current?.reopenPending,
-            target: options.target,
-        });
-        return { ...this.get(options.sessionName), applied: true };
-    }
-    setTabReopenPending(options) {
-        const current = this.tabTargets.get(options.sessionName);
-        if (!current ||
-            !shouldApplyTabTargetUpdate(current, this.tabTargetUnknownOrders.get(options.sessionName), options.update)) {
-            return;
-        }
-        this.tabTargets.set(options.sessionName, {
-            ...current,
-            order: options.update,
-            reopenPending: options.pending,
-        });
-    }
-    applyRefSnapshot(options) {
-        if (!shouldApplyRefStateUpdate({
-            currentInvalidation: this.refSnapshotInvalidations.get(options.sessionName),
-            currentSnapshot: this.refSnapshots.get(options.sessionName),
-            updateOrder: options.update,
-        })) {
-            return { ...this.get(options.sessionName), applied: false, stale: true };
-        }
-        const snapshot = {
-            ...options.snapshot,
-            generation: options.snapshot.generation ?? this.nativeGenerations.get(options.sessionName),
-            snapshotId: options.snapshot.snapshotId ?? randomUUID(),
-            target: options.snapshot.target ?? options.fallbackTarget,
-        };
-        this.refSnapshotInvalidations.delete(options.sessionName);
-        this.refSnapshots.set(options.sessionName, { ...snapshot, order: options.update });
-        return { ...this.get(options.sessionName), applied: true };
-    }
-    bindSnapshotGeneration(sessionName, generation) {
-        if (generation !== undefined && generation.length > 0) {
-            this.nativeGenerations.set(sessionName, generation);
-        }
-        else {
-            this.nativeGenerations.delete(sessionName);
-        }
-        const snapshot = this.refSnapshots.get(sessionName);
-        if (snapshot) {
-            this.refSnapshots.set(sessionName, { ...snapshot, generation });
-        }
-    }
-    applyRefSnapshotInvalidation(options) {
-        if (!shouldApplyRefStateUpdate({
-            currentInvalidation: this.refSnapshotInvalidations.get(options.sessionName),
-            currentSnapshot: this.refSnapshots.get(options.sessionName),
-            updateOrder: options.update,
-        })) {
-            return { ...this.get(options.sessionName), applied: false, stale: true };
-        }
-        this.refSnapshots.delete(options.sessionName);
-        this.refSnapshotInvalidations.set(options.sessionName, {
-            ...options.invalidation,
-            order: options.update,
-        });
-        return { ...this.get(options.sessionName), applied: true };
-    }
-    markTabTargetUnknown(options) {
-        const current = this.tabTargets.get(options.sessionName);
-        if (!shouldApplyTabTargetUpdate(current, this.tabTargetUnknownOrders.get(options.sessionName), options.update)) {
-            return { ...this.get(options.sessionName), applied: false, stale: true };
-        }
-        this.refSnapshotInvalidations.delete(options.sessionName);
-        this.refSnapshots.delete(options.sessionName);
-        this.tabPinningReasons.delete(options.sessionName);
-        this.tabTargets.delete(options.sessionName);
-        this.tabTargetUnknownOrders.set(options.sessionName, options.update);
-        return { ...this.get(options.sessionName), applied: true };
-    }
-    clearSession(sessionName) {
-        this.confirmActions.delete(sessionName);
-        this.pending.delete(sessionName);
-        this.nativeGenerations.delete(sessionName);
-        this.readConfirmations.delete(sessionName);
-        this.refSnapshotInvalidations.delete(sessionName);
-        this.refSnapshots.delete(sessionName);
-        this.tabPinningReasons.delete(sessionName);
-        this.tabTargetUnknownOrders.delete(sessionName);
-        this.tabTargets.delete(sessionName);
-    }
-    clearNamespace(namespace) {
-        const sessionKeys = new Set([
-            ...this.confirmActions.keys(),
-            ...this.readConfirmations.keys(),
-            ...this.refSnapshotInvalidations.keys(),
-            ...this.refSnapshots.keys(),
-            ...this.tabPinningReasons.keys(),
-            ...this.tabTargetUnknownOrders.keys(),
-            ...this.tabTargets.keys(),
-        ]);
-        for (const sessionKey of sessionKeys) {
-            if (isAgentBrowserSessionIdentityKeyInNamespace(sessionKey, namespace)) {
-                this.clearSession(sessionKey);
-            }
-        }
-    }
-    markPinning(sessionName, reason) {
-        this.tabPinningReasons.set(sessionName, reason);
-    }
-    clearRestorePinning(sessionName) {
-        if (this.tabPinningReasons.get(sessionName) === "restore") {
-            this.tabPinningReasons.delete(sessionName);
-        }
-    }
-}

package/dist/extensions/agent-browser/lib/session-page-types.js

@@ -1 +0,0 @@
-export {};

package/dist/extensions/agent-browser/lib/string-enum-schema.js

@@ -1,8 +0,0 @@
-import { JsonSchema } from "./json-schema.js";
-export function StringEnum(values, options) {
-    return JsonSchema.Unsafe({
-        type: "string",
-        enum: [...values],
-        ...options,
-    });
-}

package/dist/extensions/agent-browser/lib/temp-artifact-budget.js

@@ -1,78 +0,0 @@
-import { readdir, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
-import { parsePositiveInteger } from "./parsing.js";
-const DEFAULT_MAX_BYTES = 32 * 1_024 * 1_024;
-export function getTempArtifactByteLength(content) {
-    return typeof content === "string" ? Buffer.byteLength(content) : content.byteLength;
-}
-export async function listArtifactFiles(directory, excludedNames = new Set()) {
-    const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
-    const files = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || excludedNames.has(entry.name)) {
-            continue;
-        }
-        const path = join(directory, entry.name);
-        // Bound filesystem work and retain the original ordered scan before eviction.
-        // oxlint-disable-next-line no-await-in-loop
-        const stats = await stat(path).catch(() => undefined);
-        if (stats?.isFile() === true) {
-            files.push({ mtimeMs: stats.mtimeMs, path, size: stats.size });
-        }
-    }
-    return files;
-}
-export function getSecureTempRootMaxBytes(env = process.env) {
-    return parsePositiveInteger(env.PI_AGENT_BROWSER_TEMP_ROOT_MAX_BYTES) ?? DEFAULT_MAX_BYTES;
-}
-export function getPersistentSessionArtifactMaxBytes(env = process.env) {
-    if (env.PI_AGENT_BROWSER_SESSION_ARTIFACT_MAX_BYTES?.trim() === "0") {
-        return 0;
-    }
-    return parsePositiveInteger(env.PI_AGENT_BROWSER_SESSION_ARTIFACT_MAX_BYTES) ?? DEFAULT_MAX_BYTES;
-}
-export async function assertSecureTempRootBudget(tempRoot, additionalBytes) {
-    if (additionalBytes <= 0) {
-        return;
-    }
-    const files = await listArtifactFiles(tempRoot, new Set([".pi-agent-browser-owner.json"]));
-    const currentBytes = files.reduce((total, file) => total + file.size, 0);
-    const maxBytes = getSecureTempRootMaxBytes();
-    const nextBytes = currentBytes + additionalBytes;
-    if (nextBytes > maxBytes) {
-        throw new Error(`pi-agent-browser temp spill budget exceeded (${nextBytes} bytes > ${maxBytes} byte limit).`);
-    }
-}
-export async function prunePersistentSessionArtifactsToBudget(sessionArtifactDir, additionalBytes, protectedPaths) {
-    if (additionalBytes <= 0) {
-        return [];
-    }
-    const maxBytes = getPersistentSessionArtifactMaxBytes();
-    if (maxBytes === 0) {
-        return [];
-    }
-    const files = await listArtifactFiles(sessionArtifactDir);
-    let totalBytes = files.reduce((total, file) => total + file.size, 0);
-    if (totalBytes + additionalBytes <= maxBytes) {
-        return [];
-    }
-    const evictedArtifacts = [];
-    files.sort((left, right) => {
-        const time = left.mtimeMs - right.mtimeMs;
-        return time === 0 ? left.path.localeCompare(right.path) : time;
-    });
-    for (const file of files) {
-        if (protectedPaths.has(file.path)) {
-            continue;
-        }
-        // Evict oldest first and stop immediately once the required budget is available.
-        // oxlint-disable-next-line no-await-in-loop
-        await rm(file.path, { force: true }).catch(() => undefined);
-        evictedArtifacts.push({ mtimeMs: file.mtimeMs, path: file.path, sizeBytes: file.size });
-        totalBytes -= file.size;
-        if (totalBytes + additionalBytes <= maxBytes) {
-            return evictedArtifacts;
-        }
-    }
-    throw new Error(`pi-agent-browser persisted spill budget exceeded (${totalBytes + additionalBytes} bytes > ${maxBytes} byte limit).`);
-}

package/dist/extensions/agent-browser/lib/temp-mutation-queue.js

@@ -1,7 +0,0 @@
-let tempMutationQueue = Promise.resolve();
-/** One queue owns all root cleanup, preservation, spill writes and persistent eviction. */
-export function enqueueTempMutation(task) {
-    const nextTask = tempMutationQueue.then(task, task);
-    tempMutationQueue = nextTask.then(() => undefined, () => undefined);
-    return nextTask;
-}

package/dist/extensions/agent-browser/lib/temp-root-ownership.js

@@ -1,234 +0,0 @@
-import { chmod, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
-import { basename, dirname, join, resolve } from "node:path";
-import { isRecord } from "./parsing.js";
-import { processStartIdentitiesMatch, readProcessStartIdentity } from "./process-identity.js";
-import { getErrorCode } from "./process-errors.js";
-export const TEMP_ROOT_MARKER_FILE_NAME = ".pi-agent-browser-owner.json";
-const TEMP_ROOT_MARKER_KIND = "pi-agent-browser-temp-root";
-const TEMP_ROOT_MARKER_VERSION = 2;
-export function getCurrentProcessUid() {
-    return typeof process.getuid === "function" ? process.getuid() : undefined;
-}
-function isPositiveFiniteNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0;
-}
-function isProtectedTempChildName(value) {
-    if (typeof value !== "string") {
-        return false;
-    }
-    if (value === "" || value === "." || value === ".." || value === TEMP_ROOT_MARKER_FILE_NAME) {
-        return false;
-    }
-    if (value.includes("/") || value.includes("\\")) {
-        return false;
-    }
-    return basename(value) === value;
-}
-function isTempRootOwnershipRecord(value) {
-    if (!isRecord(value)) {
-        return false;
-    }
-    if (value.kind !== TEMP_ROOT_MARKER_KIND || value.version !== TEMP_ROOT_MARKER_VERSION) {
-        return false;
-    }
-    if (!isPositiveFiniteNumber(value.createdAtMs)) {
-        return false;
-    }
-    return validLeaseAndProcess(value) && validOwnershipAndChildren(value);
-}
-function validLeaseAndProcess(value) {
-    if (value.leaseUpdatedAtMs !== undefined && !isPositiveFiniteNumber(value.leaseUpdatedAtMs)) {
-        return false;
-    }
-    if (value.ownerPid !== undefined &&
-        (typeof value.ownerPid !== "number" ||
-            !Number.isSafeInteger(value.ownerPid) ||
-            value.ownerPid <= 0)) {
-        return false;
-    }
-    return (value.ownerProcessStartIdentity === undefined ||
-        (typeof value.ownerProcessStartIdentity === "string" &&
-            value.ownerProcessStartIdentity.trim() !== ""));
-}
-function validOwnershipAndChildren(value) {
-    if (value.ownerUid !== undefined &&
-        (typeof value.ownerUid !== "number" ||
-            !Number.isSafeInteger(value.ownerUid) ||
-            value.ownerUid < 0)) {
-        return false;
-    }
-    if (value.protectedChildNames === undefined) {
-        return true;
-    }
-    if (!Array.isArray(value.protectedChildNames)) {
-        return false;
-    }
-    const names = value.protectedChildNames;
-    return names.every(isProtectedTempChildName);
-}
-export async function readTempRootOwnershipMarker(tempRoot) {
-    try {
-        const markerText = await readFile(join(tempRoot, TEMP_ROOT_MARKER_FILE_NAME), "utf8");
-        const parsed = JSON.parse(markerText);
-        return isTempRootOwnershipRecord(parsed) ? parsed : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export function getProtectedTempChildName(tempRoot, childPath) {
-    const normalizedTempRoot = resolve(tempRoot);
-    const normalizedChildPath = resolve(childPath);
-    if (dirname(normalizedChildPath) !== normalizedTempRoot) {
-        return undefined;
-    }
-    const childName = basename(normalizedChildPath);
-    // A string can still be an unsafe child name; validation checks separators and reserved names.
-    // oxlint-disable-next-line typescript/no-unnecessary-condition
-    return isProtectedTempChildName(childName) ? childName : undefined;
-}
-function normalizeProtectedChildNames(names) {
-    return [...new Set([...names].filter(isProtectedTempChildName))].sort();
-}
-export function getPersistedProtectedChildPaths(tempRoot, ownershipMarker) {
-    const normalizedTempRoot = resolve(tempRoot);
-    return new Set((ownershipMarker?.protectedChildNames ?? []).map((childName) => resolve(join(normalizedTempRoot, childName))));
-}
-async function writeTempRootOwnershipMarkerRecord(tempRoot, markerRecord, options = {}) {
-    const markerPath = join(tempRoot, TEMP_ROOT_MARKER_FILE_NAME);
-    await writeFile(markerPath, JSON.stringify(markerRecord, null, 2), {
-        encoding: "utf8",
-        flag: options.flag,
-        mode: 0o600,
-    });
-    await chmod(markerPath, 0o600).catch(() => undefined);
-    return markerPath;
-}
-export async function persistProtectedTempChildren(tempRoot, protectedChildren) {
-    if (protectedChildren.size === 0) {
-        return;
-    }
-    const ownershipMarker = await readTempRootOwnershipMarker(tempRoot);
-    if (!ownershipMarker) {
-        return;
-    }
-    const childNames = normalizeProtectedChildNames([
-        ...(ownershipMarker.protectedChildNames ?? []),
-        ...[...protectedChildren]
-            .map((path) => getProtectedTempChildName(tempRoot, path))
-            .filter((childName) => childName !== undefined),
-    ]);
-    if (childNames.length === 0) {
-        return;
-    }
-    await writeTempRootOwnershipMarkerRecord(tempRoot, {
-        ...ownershipMarker,
-        leaseUpdatedAtMs: Date.now(),
-        protectedChildNames: childNames,
-        version: TEMP_ROOT_MARKER_VERSION,
-    });
-}
-export async function getExistingProtectedChildren(tempRoot, protectedChildren) {
-    const normalizedTempRoot = resolve(tempRoot);
-    const existingChildren = new Set();
-    for (const path of protectedChildren) {
-        const normalizedPath = resolve(path);
-        if (dirname(normalizedPath) !== normalizedTempRoot) {
-            continue;
-        }
-        if (
-        // Scan in bounded sequence instead of opening an unbounded number of filesystem requests.
-        // oxlint-disable-next-line no-await-in-loop
-        await stat(normalizedPath).then((stats) => stats.isDirectory(), () => false)) {
-            existingChildren.add(normalizedPath);
-        }
-    }
-    return existingChildren;
-}
-export async function removeTempRootChildrenExcept(tempRoot, protectedChildren) {
-    const entries = await readdir(tempRoot, { withFileTypes: true }).catch(() => []);
-    await Promise.all(entries.map(async (entry) => {
-        if (entry.name === TEMP_ROOT_MARKER_FILE_NAME) {
-            return;
-        }
-        const entryPath = join(tempRoot, entry.name);
-        if (protectedChildren.has(resolve(entryPath))) {
-            return;
-        }
-        await rm(entryPath, { force: true, recursive: true }).catch(() => undefined);
-    }));
-}
-async function getProcessStartIdentity(pid) {
-    return pid === undefined ? undefined : await readProcessStartIdentity(pid);
-}
-export async function writeSecureTempRootOwnershipMarker(tempRoot, options = {}) {
-    const createdAtMs = options.createdAtMs ?? Date.now();
-    const ownerPid = options.ownerPid ?? process.pid;
-    const markerRecord = {
-        createdAtMs,
-        kind: TEMP_ROOT_MARKER_KIND,
-        leaseUpdatedAtMs: options.leaseUpdatedAtMs ?? createdAtMs,
-        ownerPid,
-        ownerProcessStartIdentity: options.ownerProcessStartIdentity ?? (await getProcessStartIdentity(ownerPid)),
-        ownerUid: getCurrentProcessUid(),
-        version: TEMP_ROOT_MARKER_VERSION,
-    };
-    return await writeTempRootOwnershipMarkerRecord(tempRoot, markerRecord, { flag: "wx" });
-}
-export async function refreshSecureTempRootLease(tempRoot) {
-    const ownershipMarker = await readTempRootOwnershipMarker(tempRoot);
-    if (!ownershipMarker) {
-        return;
-    }
-    if (ownershipMarker.ownerPid !== process.pid) {
-        return;
-    }
-    const currentUid = getCurrentProcessUid();
-    if (currentUid !== undefined &&
-        ownershipMarker.ownerUid !== undefined &&
-        ownershipMarker.ownerUid !== currentUid) {
-        return;
-    }
-    const currentProcessStartIdentity = await getProcessStartIdentity(process.pid);
-    if (ownershipMarker.ownerProcessStartIdentity !== undefined &&
-        currentProcessStartIdentity !== undefined) {
-        const identitiesMatch = processStartIdentitiesMatch(ownershipMarker.ownerProcessStartIdentity, currentProcessStartIdentity);
-        if (!identitiesMatch) {
-            return;
-        }
-    }
-    const refreshedMarker = {
-        ...ownershipMarker,
-        leaseUpdatedAtMs: Date.now(),
-        ownerPid: process.pid,
-        ownerProcessStartIdentity: currentProcessStartIdentity ?? ownershipMarker.ownerProcessStartIdentity,
-        ownerUid: currentUid,
-        version: TEMP_ROOT_MARKER_VERSION,
-    };
-    await writeTempRootOwnershipMarkerRecord(tempRoot, refreshedMarker);
-}
-export async function getMarkerOwnerLiveness(ownershipMarker) {
-    const pid = ownershipMarker.ownerPid;
-    if (pid === undefined) {
-        return "unknown";
-    }
-    try {
-        process.kill(pid, 0);
-    }
-    catch (error) {
-        const code = getErrorCode(error);
-        if (code === "ESRCH") {
-            return "dead";
-        }
-        if (code !== "EPERM") {
-            return "unknown";
-        }
-    }
-    const currentProcessStartIdentity = await getProcessStartIdentity(pid);
-    if (ownershipMarker.ownerProcessStartIdentity === undefined ||
-        currentProcessStartIdentity === undefined) {
-        return "unknown";
-    }
-    const identitiesMatch = processStartIdentitiesMatch(ownershipMarker.ownerProcessStartIdentity, currentProcessStartIdentity);
-    return identitiesMatch ? "alive" : "dead";
-}