nawabari 0.1.0

package/dist/session-registry.js

@@ -0,0 +1,1190 @@
+import fs from "node:fs";
+import path from "node:path";
+import { defaultGit, listGitWorktrees, normalizeBranchId, readCurrentBranch, resolveRepositoryContext, resolveWorktreeIdentity, } from "./git.js";
+import { SessionRegistryError } from "./errors.js";
+import { generateSessionId, isSessionId } from "./session-id.js";
+import { RegistryLockError, RepositoryLock } from "./registry/lock.js";
+export const REGISTRY_SCHEMA_VERSION = 1;
+export const REGISTRY_DIRECTORY_NAME = "nawabari";
+export const REGISTRY_FILE_NAME = "session-registry.json";
+export const REGISTRY_LOCK_FILE_NAME = "session-registry.lock";
+export const DEFAULT_STALE_AFTER_MS = 24 * 60 * 60 * 1_000;
+const DEFAULT_LOCK_METADATA_GRACE_MS = 1_000;
+const ACTIVE_STATES = new Set(["new", "active", "closing", "stale"]);
+const CURRENT_SESSION_STATES = new Set(["new", "active", "closing"]);
+const SESSION_STATES = new Set(["new", "active", "closing", "closed", "stale"]);
+const ISO_TIMESTAMP_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
+const MAX_ID_GENERATION_ATTEMPTS = 8;
+export class SessionRegistry {
+    repository;
+    paths;
+    git;
+    clock;
+    idGenerator;
+    lockTimeoutMs;
+    defaultBranchName;
+    protectedBranchNames;
+    protectedWorktreePaths;
+    worktreeRoot;
+    staleAfterMs;
+    lockStaleAfterMs;
+    lockMetadataGraceMs;
+    lock;
+    constructor(options = {}) {
+        this.repository = options.repository ?? resolveRepositoryContext({ cwd: options.cwd, git: options.git });
+        this.git = options.git ?? defaultGit;
+        this.clock = options.clock ?? (() => new Date());
+        this.idGenerator = options.idGenerator ?? generateSessionId;
+        this.lockTimeoutMs = options.lockTimeoutMs ?? 5_000;
+        this.defaultBranchName = options.defaultBranchName;
+        this.protectedBranchNames = Object.freeze([...(options.protectedBranchNames ?? [])]);
+        this.protectedWorktreePaths = Object.freeze([...(options.protectedWorktreePaths ?? [])]);
+        this.worktreeRoot = path.resolve(options.worktreeRoot ?? path.dirname(this.repository.worktreePath));
+        this.staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+        this.lockStaleAfterMs = options.lockStaleAfterMs ?? this.lockTimeoutMs;
+        this.lockMetadataGraceMs = options.lockMetadataGraceMs ?? DEFAULT_LOCK_METADATA_GRACE_MS;
+        if (!Number.isSafeInteger(this.lockTimeoutMs) || this.lockTimeoutMs < 0) {
+            throw new RangeError("lockTimeoutMs must be a non-negative safe integer");
+        }
+        if (!Number.isSafeInteger(this.staleAfterMs) || this.staleAfterMs < 0) {
+            throw new RangeError("staleAfterMs must be a non-negative safe integer");
+        }
+        if (!Number.isSafeInteger(this.lockStaleAfterMs) || this.lockStaleAfterMs < 0) {
+            throw new RangeError("lockStaleAfterMs must be a non-negative safe integer");
+        }
+        if (!Number.isSafeInteger(this.lockMetadataGraceMs) || this.lockMetadataGraceMs < 0) {
+            throw new RangeError("lockMetadataGraceMs must be a non-negative safe integer");
+        }
+        const directory = path.join(this.repository.commonGitDirectory, REGISTRY_DIRECTORY_NAME);
+        this.paths = Object.freeze({
+            directory,
+            registry: path.join(directory, REGISTRY_FILE_NAME),
+            lock: path.join(directory, REGISTRY_LOCK_FILE_NAME),
+        });
+        this.lock = new RepositoryLock({
+            lockPath: this.paths.lock,
+            staleAfterMs: this.lockStaleAfterMs,
+            acquireTimeoutMs: this.lockTimeoutMs,
+            metadataGraceMs: this.lockMetadataGraceMs,
+        });
+    }
+    read() {
+        return this.readUnsafe().map(cloneSessionRecord);
+    }
+    list() {
+        return this.read();
+    }
+    get(sessionId) {
+        assertSessionId(sessionId);
+        const record = this.readUnsafe().find((candidate) => candidate.sessionId === sessionId);
+        return record === undefined ? undefined : cloneSessionRecord(record);
+    }
+    create(options = {}) {
+        const resources = this.resolveCreationResources(options);
+        return this.mutate((records) => {
+            for (let attempt = 0; attempt < MAX_ID_GENERATION_ATTEMPTS; attempt += 1) {
+                const sessionId = this.idGenerator();
+                assertSessionId(sessionId);
+                if (records.some((record) => record.sessionId === sessionId)) {
+                    continue;
+                }
+                const timestamp = toTimestamp(this.clock());
+                const record = freezeSessionRecord({
+                    schemaVersion: REGISTRY_SCHEMA_VERSION,
+                    sessionId,
+                    repositoryId: this.repository.repositoryId,
+                    worktreeId: resources.worktreeId,
+                    worktreePath: resources.worktreePath,
+                    branchId: resources.branchId,
+                    branchName: resources.branchName,
+                    state: "active",
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                    ...(options.label === undefined ? {} : { label: validateLabel(options.label) }),
+                });
+                assertNoOwnershipConflict(records, record);
+                return { records: [...records, record], result: cloneSessionRecord(record) };
+            }
+            throw new SessionRegistryError("SESSION_ID_COLLISION", `Could not generate a unique session ID after ${MAX_ID_GENERATION_ATTEMPTS} attempts`, { attempts: MAX_ID_GENERATION_ATTEMPTS });
+        });
+    }
+    createSession(options = {}) {
+        return this.create(options);
+    }
+    /** Provision one isolated Git worktree and commit its ownership atomically. */
+    provision(options = {}) {
+        return this.withLock(() => {
+            const records = this.readUnsafe();
+            const sessionId = generateUniqueSessionId(records, this.idGenerator);
+            const resources = this.resolveProvisioningResources(options, sessionId);
+            const timestamp = toTimestamp(this.clock());
+            const record = freezeSessionRecord({
+                schemaVersion: REGISTRY_SCHEMA_VERSION,
+                sessionId,
+                repositoryId: this.repository.repositoryId,
+                worktreeId: resources.worktreePath,
+                worktreePath: resources.worktreePath,
+                branchId: resources.branchId,
+                branchName: resources.branchName,
+                state: "active",
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                ...(options.label === undefined ? {} : { label: validateLabel(options.label) }),
+            });
+            assertNoOwnershipConflict(records, record);
+            assertGitResourcesAvailable(this.git, this.repository.worktreePath, resources);
+            let gitProvisioned = false;
+            try {
+                this.git.run(["worktree", "add", "--quiet", "-b", resources.branchName, resources.worktreePath, resources.baseRef], this.repository.worktreePath);
+                gitProvisioned = true;
+                this.writeUnsafe([...records, record]);
+                return cloneSessionRecord(record);
+            }
+            catch (error) {
+                if (gitProvisioned) {
+                    rollbackProvisionedResources(this.git, this.repository.worktreePath, resources);
+                }
+                throw error;
+            }
+        });
+    }
+    provisionSession(options = {}) {
+        return this.provision(options);
+    }
+    createProvisionedSession(options = {}) {
+        return this.provision(options);
+    }
+    register(record) {
+        const validated = validateSessionRecord(record, this.repository.repositoryId);
+        return this.mutate((records) => {
+            if (records.some((candidate) => candidate.sessionId === validated.sessionId)) {
+                throw new SessionRegistryError("DUPLICATE_SESSION_ID", `Session ID already exists: ${validated.sessionId}`, {
+                    sessionId: validated.sessionId,
+                });
+            }
+            assertNoOwnershipConflict(records, validated);
+            return { records: [...records, validated], result: cloneSessionRecord(validated) };
+        });
+    }
+    registerSession(record) {
+        return this.register(record);
+    }
+    resolveCurrentSession() {
+        const records = this.readUnsafe();
+        const matches = records.filter((record) => CURRENT_SESSION_STATES.has(record.state) && record.worktreeId === this.repository.worktreePath);
+        if (matches.length === 1) {
+            return cloneSessionRecord(matches[0]);
+        }
+        if (matches.length > 1) {
+            throw new SessionRegistryError("DUPLICATE_WORKTREE_OWNERSHIP", `Multiple active sessions claim the current worktree: ${this.repository.worktreePath}`, { worktree: this.repository.worktreePath });
+        }
+        throw new SessionRegistryError("SESSION_NOT_FOUND", `No active session owns the current worktree: ${this.repository.worktreePath}`, { worktree: this.repository.worktreePath });
+    }
+    currentSession() {
+        return this.resolveCurrentSession();
+    }
+    /**
+     * Evaluate the current worktree as a Nawabari mutation context without taking
+     * the registry lock or changing Git or registry state.
+     */
+    guard(options = {}) {
+        const requestedSessionId = options.sessionId ?? null;
+        const base = {
+            repositoryId: this.repository.repositoryId,
+            worktreePath: this.repository.worktreePath,
+            branchName: null,
+            sessionId: null,
+            ownerSessionId: null,
+            requestedSessionId,
+            state: null,
+        };
+        try {
+            if (requestedSessionId !== null && !isSessionId(requestedSessionId)) {
+                return deniedGuard("INVALID_SESSION_ID", base, { sessionId: requestedSessionId });
+            }
+            const worktrees = listGitWorktrees(this.git, this.repository.worktreePath);
+            if (worktrees.length === 0) {
+                return deniedGuard("WORKTREE_IDENTITY_AMBIGUOUS", base, { worktree: this.repository.worktreePath });
+            }
+            const identity = resolveWorktreeIdentity({
+                repository: this.repository,
+                git: this.git,
+            });
+            const identityBase = { ...base, branchName: identity.branchName };
+            const listedCurrentWorktree = worktrees.find((worktree) => samePath(worktree.worktreePath, this.repository.worktreePath));
+            if (listedCurrentWorktree?.branchName !== identity.branchName) {
+                return deniedGuard("WORKTREE_IDENTITY_AMBIGUOUS", identityBase, {
+                    worktree: this.repository.worktreePath,
+                    listedBranch: listedCurrentWorktree?.branchName ?? "<detached>",
+                    resolvedBranch: identity.branchName,
+                });
+            }
+            const records = this.readUnsafe();
+            const currentRecords = records.filter((record) => record.worktreeId === this.repository.worktreePath && record.state !== "closed");
+            if (currentRecords.length > 1) {
+                return deniedGuard("DUPLICATE_WORKTREE_OWNERSHIP", identityBase, {
+                    worktree: this.repository.worktreePath,
+                    sessionId: requestedSessionId ?? "<unspecified>",
+                }, currentRecords[0]?.sessionId ?? null, currentRecords[0]?.state ?? null);
+            }
+            const currentRecord = currentRecords.find((record) => record.state === "active");
+            if (currentRecord !== undefined) {
+                identityBase.sessionId = currentRecord.sessionId;
+                identityBase.ownerSessionId = currentRecord.sessionId;
+                identityBase.state = currentRecord.state;
+            }
+            else {
+                const transitionalRecord = currentRecords[0];
+                if (transitionalRecord !== undefined) {
+                    identityBase.sessionId = transitionalRecord.sessionId;
+                    identityBase.ownerSessionId = transitionalRecord.sessionId;
+                    identityBase.state = transitionalRecord.state;
+                }
+            }
+            if (this.protectedWorktree(this.repository.worktreePath, worktrees)) {
+                return deniedGuard("PROTECTED_WORKTREE", identityBase, { worktree: this.repository.worktreePath }, identityBase.ownerSessionId, identityBase.state);
+            }
+            if (this.protectedBranch(identity.branchName, worktrees)) {
+                return deniedGuard("PROTECTED_BRANCH", identityBase, { branch: identity.branchName }, identityBase.ownerSessionId, identityBase.state);
+            }
+            if (currentRecord === undefined) {
+                const requestedRecord = requestedSessionId === null ? undefined : records.find((record) => record.sessionId === requestedSessionId);
+                return deniedGuard("SESSION_NOT_FOUND", identityBase, {
+                    worktree: this.repository.worktreePath,
+                    ...(requestedRecord === undefined ? {} : { state: requestedRecord.state }),
+                }, identityBase.ownerSessionId, identityBase.state);
+            }
+            if (currentRecord.branchId !== identity.branchId || currentRecord.branchName !== identity.branchName) {
+                return deniedGuard("OWNERSHIP_MISMATCH", identityBase, {
+                    worktree: this.repository.worktreePath,
+                    expectedBranch: currentRecord.branchName,
+                    actualBranch: identity.branchName,
+                }, currentRecord.sessionId, currentRecord.state);
+            }
+            if (requestedSessionId !== null) {
+                const requestedRecord = records.find((record) => record.sessionId === requestedSessionId);
+                if (requestedRecord === undefined || requestedRecord.state !== "active") {
+                    return deniedGuard("SESSION_NOT_FOUND", identityBase, { sessionId: requestedSessionId }, currentRecord.sessionId, currentRecord.state);
+                }
+                if (requestedRecord.sessionId !== currentRecord.sessionId) {
+                    return deniedGuard("DUPLICATE_WORKTREE_OWNERSHIP", identityBase, {
+                        worktree: this.repository.worktreePath,
+                        sessionId: requestedSessionId,
+                        ownerSessionId: currentRecord.sessionId,
+                    }, currentRecord.sessionId, currentRecord.state);
+                }
+                if (requestedRecord.branchId !== identity.branchId) {
+                    return deniedGuard("OWNERSHIP_MISMATCH", identityBase, {
+                        sessionId: requestedSessionId,
+                        expectedBranch: requestedRecord.branchName,
+                        actualBranch: identity.branchName,
+                    }, currentRecord.sessionId, currentRecord.state);
+                }
+            }
+            return Object.freeze({
+                allowed: true,
+                code: "ALLOWED",
+                ...identityBase,
+                details: {},
+            });
+        }
+        catch (error) {
+            if (error instanceof SessionRegistryError) {
+                return deniedGuard(error.code, base, error.details, base.ownerSessionId, base.state);
+            }
+            throw error;
+        }
+    }
+    /** Close one session only after its ownership and recoverability are proven safe. */
+    close(sessionIdOrOptions) {
+        return this.withLock(() => {
+            const sessionId = typeof sessionIdOrOptions === "object" && sessionIdOrOptions !== null
+                ? (sessionIdOrOptions.sessionId ?? sessionIdOrOptions.session_id)
+                : sessionIdOrOptions;
+            const selectedSessionId = sessionId ?? this.resolveCurrentSession().sessionId;
+            assertSessionId(selectedSessionId);
+            return this.closeUnsafe(selectedSessionId);
+        });
+    }
+    closeSession(sessionIdOrOptions) {
+        return this.close(sessionIdOrOptions);
+    }
+    /** Detect stale sessions, optionally applying only cleanup that passes close preflight. */
+    garbageCollect(options = {}) {
+        const apply = options.apply ?? false;
+        const staleAfterMs = options.staleAfterMs ?? this.staleAfterMs;
+        assertStaleAfterMs(staleAfterMs);
+        return this.withLock(() => {
+            let records = [...this.readUnsafe()];
+            const now = toTimestamp(this.clock());
+            const worktrees = listGitWorktrees(this.git, this.repository.worktreePath);
+            const candidates = records
+                .filter((record) => isStaleCandidate(record, now, staleAfterMs, worktrees))
+                .map(cloneSessionRecord);
+            if (!apply || candidates.length === 0) {
+                return {
+                    apply,
+                    candidates,
+                    cleaned: [],
+                    blocked: [],
+                };
+            }
+            const cleaned = [];
+            const blocked = [];
+            for (const candidate of candidates) {
+                const current = records.find((record) => record.sessionId === candidate.sessionId);
+                if (current === undefined || current.state === "closed")
+                    continue;
+                if (current.state !== "stale" && current.state !== "closing") {
+                    const staleRecord = transitionSessionState(current, "stale", this.clock);
+                    records = replaceRecord(records, staleRecord);
+                    validateRecords(records, this.repository.repositoryId);
+                    this.writeUnsafe(records);
+                }
+                try {
+                    const result = this.closeUnsafe(candidate.sessionId);
+                    cleaned.push(result.session);
+                }
+                catch (error) {
+                    if (!(error instanceof SessionRegistryError))
+                        throw error;
+                    blocked.push({
+                        sessionId: candidate.sessionId,
+                        code: error.code,
+                        message: error.message,
+                        details: error.details,
+                    });
+                }
+                records = [...this.readUnsafe()];
+            }
+            return {
+                apply,
+                candidates,
+                cleaned: cleaned.map(cloneSessionRecord),
+                blocked,
+            };
+        });
+    }
+    gc(options = {}) {
+        return this.garbageCollect(options);
+    }
+    closeUnsafe(sessionId) {
+        const records = this.readUnsafe();
+        const record = records.find((candidate) => candidate.sessionId === sessionId);
+        if (record === undefined) {
+            throw new SessionRegistryError("SESSION_NOT_FOUND", `Session was not found: ${sessionId}`, {
+                sessionId,
+            });
+        }
+        if (record.state === "closed") {
+            return {
+                session: cloneSessionRecord(record),
+                worktreeRemoved: false,
+                branchRemoved: false,
+                idempotent: true,
+            };
+        }
+        const resources = this.inspectCleanupResources(record);
+        const closingRecord = record.state === "closing" ? record : transitionSessionState(record, "closing", this.clock);
+        let closingRecords = replaceRecord(records, closingRecord);
+        validateRecords(closingRecords, this.repository.repositoryId);
+        this.writeUnsafe(closingRecords);
+        let worktreeRemoved = false;
+        let branchRemoved = false;
+        if (resources.worktreePresent && resources.removeWorktree) {
+            removeSessionWorktree(this.git, resources.gitCwd, record.worktreePath);
+            worktreeRemoved = true;
+        }
+        if (resources.branchPresent && resources.removeBranch) {
+            removeSessionBranch(this.git, resources.gitCwd, record.branchName);
+            branchRemoved = true;
+        }
+        const closedRecord = transitionSessionState(closingRecord, "closed", this.clock);
+        closingRecords = replaceRecord(closingRecords, closedRecord);
+        validateRecords(closingRecords, this.repository.repositoryId);
+        this.writeUnsafe(closingRecords);
+        return {
+            session: cloneSessionRecord(closedRecord),
+            worktreeRemoved,
+            branchRemoved,
+            idempotent: false,
+        };
+    }
+    inspectCleanupResources(record) {
+        const git = this.git;
+        const worktrees = listGitWorktrees(git, this.repository.worktreePath);
+        const gitCwd = worktrees.find((worktree) => !samePath(worktree.worktreePath, record.worktreePath))?.worktreePath ??
+            this.repository.worktreePath;
+        const registeredWorktree = worktrees.find((worktree) => samePath(worktree.worktreePath, record.worktreePath));
+        const branchWorktree = worktrees.find((worktree) => worktree.branchName === record.branchName);
+        if (registeredWorktree !== undefined && registeredWorktree.branchName !== record.branchName) {
+            throw ownershipMismatch(record, "The registered worktree branch does not match the session branch", {
+                actualBranch: registeredWorktree.branchName ?? "<detached>",
+            });
+        }
+        if (branchWorktree !== undefined && !samePath(branchWorktree.worktreePath, record.worktreePath)) {
+            throw ownershipMismatch(record, "The session branch is checked out by another worktree", {
+                actualWorktree: branchWorktree.worktreePath,
+            });
+        }
+        const pathEntry = lstatIfPresent(record.worktreePath);
+        if (registeredWorktree === undefined && pathEntry !== undefined) {
+            throw ownershipMismatch(record, "The session worktree path exists but is not a Git worktree");
+        }
+        if (pathEntry !== undefined && (pathEntry.isSymbolicLink() || !pathEntry.isDirectory())) {
+            throw ownershipMismatch(record, "The session worktree path is not a directory worktree");
+        }
+        const worktreePresent = registeredWorktree !== undefined;
+        const branchPresent = localBranchExists(git, this.repository.worktreePath, record.branchId);
+        if (worktreePresent) {
+            if (!branchPresent || registeredWorktree?.branchName !== record.branchName) {
+                throw ownershipMismatch(record, "The registered worktree no longer has the owned local branch");
+            }
+            assertWorktreeClean(git, record.worktreePath);
+        }
+        const worktreeProtection = this.protectedWorktree(record.worktreePath, worktrees);
+        const branchProtection = this.protectedBranch(record.branchName, worktrees);
+        const removeBranch = branchPresent && !branchProtection && this.branchIsReachableFromIntegration(record);
+        return {
+            gitCwd,
+            worktreePresent,
+            branchPresent,
+            removeWorktree: worktreePresent && !worktreeProtection,
+            removeBranch,
+        };
+    }
+    protectedWorktree(worktreePath, worktrees) {
+        const defaultWorktreePath = worktrees[0]?.worktreePath ?? this.repository.worktreePath;
+        const configured = this.protectedWorktreePaths.map((candidate) => resolvePotentialWorktreePath(candidate, this.repository.worktreePath));
+        return (samePath(worktreePath, defaultWorktreePath) || configured.some((candidate) => samePath(worktreePath, candidate)));
+    }
+    protectedBranch(branchName, worktrees) {
+        const defaultBranchName = resolveDefaultBranchName(this.git, this.repository.worktreePath, worktrees, this.defaultBranchName);
+        const protectedBranchIds = [
+            ...(defaultBranchName === undefined ? [] : [normalizeBranchId(defaultBranchName)]),
+            ...this.protectedBranchNames.map((candidate) => normalizeBranchId(candidate)),
+        ];
+        return protectedBranchIds.includes(normalizeBranchId(branchName));
+    }
+    branchIsReachableFromIntegration(record) {
+        const git = this.git;
+        const worktrees = listGitWorktrees(git, this.repository.worktreePath);
+        const defaultBranchName = resolveDefaultBranchName(git, this.repository.worktreePath, worktrees, this.defaultBranchName);
+        if (defaultBranchName === undefined) {
+            throw new SessionRegistryError("RECOVERABLE_COMMITS", `Cannot prove that commits on ${record.branchName} are safely retained: no integration branch is known`, { branch: record.branchName });
+        }
+        if (normalizeBranchId(defaultBranchName) === record.branchId)
+            return true;
+        try {
+            git.run(["merge-base", "--is-ancestor", record.branchId, normalizeBranchId(defaultBranchName)], this.repository.worktreePath);
+            return true;
+        }
+        catch (error) {
+            if (error instanceof SessionRegistryError && error.code === "GIT_COMMAND_FAILED") {
+                throw new SessionRegistryError("RECOVERABLE_COMMITS", `Commits on ${record.branchName} are not proven reachable from ${defaultBranchName}`, { branch: record.branchName, integrationBranch: defaultBranchName }, error);
+            }
+            throw error;
+        }
+    }
+    resolveProvisioningResources(options, sessionId) {
+        const git = this.git;
+        const worktrees = listGitWorktrees(git, this.repository.worktreePath);
+        const requestedWorktreePath = resolveProvisionedWorktreePath(options.worktreePath ??
+            path.join(this.worktreeRoot, `${path.basename(this.repository.worktreePath)}-${sessionId}`), this.repository.worktreePath);
+        const defaultWorktreePath = worktrees[0]?.worktreePath ?? this.repository.worktreePath;
+        const configuredProtectedWorktrees = [
+            ...this.protectedWorktreePaths,
+            ...(options.protectedWorktreePaths ?? []),
+        ].map((candidate) => resolvePotentialWorktreePath(candidate, this.repository.worktreePath));
+        if (samePath(requestedWorktreePath, defaultWorktreePath) ||
+            samePath(requestedWorktreePath, this.repository.worktreePath) ||
+            configuredProtectedWorktrees.some((candidate) => samePath(requestedWorktreePath, candidate))) {
+            throw new SessionRegistryError("PROTECTED_WORKTREE", `The integration worktree cannot be used as a session worktree: ${requestedWorktreePath}`, { worktree: requestedWorktreePath });
+        }
+        const branchName = options.branchName ?? `nawabari/session/${sessionId}`;
+        const branchId = normalizeBranchId(branchName);
+        const shortBranchName = branchId.slice("refs/heads/".length);
+        const defaultBranchName = resolveDefaultBranchName(git, this.repository.worktreePath, worktrees, options.defaultBranchName ?? this.defaultBranchName);
+        const protectedBranchIds = new Set();
+        if (defaultBranchName !== undefined)
+            protectedBranchIds.add(normalizeBranchId(defaultBranchName));
+        for (const protectedBranch of [...this.protectedBranchNames, ...(options.protectedBranchNames ?? [])]) {
+            protectedBranchIds.add(normalizeBranchId(protectedBranch));
+        }
+        if (protectedBranchIds.has(branchId)) {
+            throw new SessionRegistryError("PROTECTED_BRANCH", `Protected branch cannot be used by a session: ${shortBranchName}`, {
+                branch: shortBranchName,
+            });
+        }
+        const baseRef = resolveBaseRef(git, this.repository.worktreePath, options.baseRef ?? "HEAD");
+        return {
+            worktreePath: requestedWorktreePath,
+            branchId,
+            branchName: shortBranchName,
+            baseRef,
+        };
+    }
+    resolveCreationResources(options) {
+        const worktreePath = canonicalWorktreePath(options.worktreePath ?? this.repository.worktreePath);
+        const branchName = options.branchName ??
+            (worktreePath === this.repository.worktreePath ? readCurrentBranch(this.git, worktreePath) : undefined);
+        if (branchName === undefined) {
+            throw new SessionRegistryError("WORKTREE_IDENTITY_AMBIGUOUS", `A branch identity is required for a worktree other than the current worktree: ${worktreePath}`, { worktree: worktreePath });
+        }
+        const branchId = normalizeBranchId(branchName);
+        return {
+            worktreeId: worktreePath,
+            worktreePath,
+            branchId,
+            branchName: branchId.slice("refs/heads/".length),
+        };
+    }
+    readUnsafe() {
+        let contents;
+        try {
+            contents = fs.readFileSync(this.paths.registry, "utf8");
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT") {
+                return [];
+            }
+            throw new SessionRegistryError("REGISTRY_IO_FAILURE", `Could not read ${this.paths.registry}`, {
+                path: this.paths.registry,
+            }, error);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(contents);
+        }
+        catch (error) {
+            throw new SessionRegistryError("REGISTRY_CORRUPT", `Registry is not valid JSON: ${this.paths.registry}`, {
+                path: this.paths.registry,
+            }, error);
+        }
+        return parseRegistry(parsed, this.repository.repositoryId);
+    }
+    writeUnsafe(records) {
+        const registry = {
+            schema_version: REGISTRY_SCHEMA_VERSION,
+            repository_id: this.repository.repositoryId,
+            sessions: records.map((record) => toPersistedSessionRecord(record, this.repository.repositoryId)),
+        };
+        const contents = `${JSON.stringify(registry, null, 2)}\n`;
+        const temporaryPath = `${this.paths.registry}.tmp-${process.pid}-${generateSessionId()}`;
+        let descriptor;
+        try {
+            fs.mkdirSync(this.paths.directory, { recursive: true, mode: 0o700 });
+            descriptor = fs.openSync(temporaryPath, "wx", 0o600);
+            fs.writeFileSync(descriptor, contents, "utf8");
+            fs.fsyncSync(descriptor);
+            fs.closeSync(descriptor);
+            descriptor = undefined;
+            fs.renameSync(temporaryPath, this.paths.registry);
+            syncDirectory(this.paths.directory);
+        }
+        catch (error) {
+            if (descriptor !== undefined) {
+                closeQuietly(descriptor);
+            }
+            unlinkQuietly(temporaryPath);
+            throw new SessionRegistryError("REGISTRY_IO_FAILURE", `Could not atomically write ${this.paths.registry}`, {
+                path: this.paths.registry,
+            }, error);
+        }
+    }
+    mutate(mutation) {
+        return this.withLock(() => {
+            const records = this.readUnsafe();
+            const { records: nextRecords, result } = mutation(records);
+            validateRecords(nextRecords, this.repository.repositoryId);
+            this.writeUnsafe(nextRecords);
+            return result;
+        });
+    }
+    withLock(operation) {
+        let lease;
+        try {
+            lease = this.lock.acquireSync();
+        }
+        catch (error) {
+            throw toSessionRegistryLockError(error, this.paths.lock);
+        }
+        let result;
+        let operationFailed = false;
+        let operationError;
+        try {
+            result = operation();
+        }
+        catch (error) {
+            operationFailed = true;
+            operationError = error;
+        }
+        let releaseError;
+        try {
+            lease.release();
+        }
+        catch (error) {
+            releaseError = toSessionRegistryLockError(error, this.paths.lock);
+        }
+        if (operationFailed) {
+            throw operationError;
+        }
+        if (releaseError !== undefined) {
+            throw releaseError;
+        }
+        return result;
+    }
+}
+function assertStaleAfterMs(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError("staleAfterMs must be a non-negative safe integer");
+    }
+}
+function isStaleCandidate(record, now, staleAfterMs, worktrees) {
+    if (record.state === "closed")
+        return false;
+    if (record.state === "stale" || record.state === "closing")
+        return true;
+    const age = Date.parse(now) - Date.parse(record.updatedAt);
+    const worktreePresent = worktrees.some((worktree) => samePath(worktree.worktreePath, record.worktreePath));
+    const pathEntryPresent = lstatIfPresent(record.worktreePath) !== undefined;
+    return age >= staleAfterMs || (!worktreePresent && !pathEntryPresent);
+}
+function replaceRecord(records, replacement) {
+    return records.map((record) => (record.sessionId === replacement.sessionId ? replacement : record));
+}
+function transitionSessionState(record, state, clock) {
+    const clockTimestamp = toTimestamp(clock());
+    const updatedAt = new Date(Math.max(Date.parse(record.updatedAt), Date.parse(clockTimestamp))).toISOString();
+    return freezeSessionRecord({ ...record, state, updatedAt });
+}
+function ownershipMismatch(record, message, details = {}) {
+    return new SessionRegistryError("OWNERSHIP_MISMATCH", message, {
+        sessionId: record.sessionId,
+        worktree: record.worktreePath,
+        branch: record.branchName,
+        ...details,
+    });
+}
+function deniedGuard(code, base, details, ownerSessionId = base.ownerSessionId, state = base.state) {
+    return Object.freeze({
+        allowed: false,
+        code,
+        ...base,
+        sessionId: ownerSessionId,
+        ownerSessionId,
+        state,
+        details: { ...details },
+    });
+}
+function assertWorktreeClean(git, worktreePath) {
+    // Ignore build/cache artifacts owned by the repository's .gitignore. Git's
+    // default status still reports tracked edits and recoverable untracked files.
+    const status = git.run(["status", "--porcelain=v1", "--untracked-files=all", "--ignored=no"], worktreePath);
+    if (status.length > 0) {
+        throw new SessionRegistryError("DIRTY_WORKTREE", `Worktree contains recoverable changes: ${worktreePath}`, {
+            worktree: worktreePath,
+            status,
+        });
+    }
+}
+function removeSessionWorktree(git, cwd, worktreePath) {
+    const force = !fs.existsSync(worktreePath);
+    git.run(["worktree", "remove", ...(force ? ["--force"] : []), worktreePath], cwd);
+}
+function removeSessionBranch(git, cwd, branchName) {
+    git.run(["branch", "-d", "--", branchName], cwd);
+}
+function generateUniqueSessionId(records, idGenerator) {
+    for (let attempt = 0; attempt < MAX_ID_GENERATION_ATTEMPTS; attempt += 1) {
+        const sessionId = idGenerator();
+        assertSessionId(sessionId);
+        if (!records.some((record) => record.sessionId === sessionId))
+            return sessionId;
+    }
+    throw new SessionRegistryError("SESSION_ID_COLLISION", `Could not generate a unique session ID after ${MAX_ID_GENERATION_ATTEMPTS} attempts`, { attempts: MAX_ID_GENERATION_ATTEMPTS });
+}
+function resolveProvisionedWorktreePath(candidate, baseDirectory) {
+    const resolved = resolvePotentialWorktreePath(candidate, baseDirectory);
+    if (resolved === path.parse(resolved).root) {
+        throw new SessionRegistryError("INVALID_WORKTREE_PATH", `A filesystem root cannot be a session worktree: ${resolved}`, {
+            worktree: resolved,
+        });
+    }
+    const entry = lstatIfPresent(resolved);
+    if (entry !== undefined) {
+        if (!entry.isDirectory() || entry.isSymbolicLink()) {
+            throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Worktree path is not a directory: ${resolved}`, {
+                worktree: resolved,
+            });
+        }
+        return resolved;
+    }
+    const parent = path.dirname(resolved);
+    try {
+        if (!fs.statSync(parent).isDirectory())
+            throw new Error("worktree parent is not a directory");
+        return resolved;
+    }
+    catch (error) {
+        throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Worktree parent does not exist: ${parent}`, { worktree: resolved }, error);
+    }
+}
+function resolvePotentialWorktreePath(candidate, baseDirectory) {
+    if (candidate.includes("\u0000") || candidate.trim().length === 0) {
+        throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Invalid worktree path: ${candidate}`, {
+            worktree: candidate,
+        });
+    }
+    const resolved = path.resolve(baseDirectory, candidate);
+    assertNoSymlinkPath(resolved);
+    try {
+        return fs.realpathSync.native(resolved);
+    }
+    catch {
+        const parent = path.dirname(resolved);
+        try {
+            return path.join(fs.realpathSync.native(parent), path.basename(resolved));
+        }
+        catch {
+            return resolved;
+        }
+    }
+}
+function assertNoSymlinkPath(candidate) {
+    const root = path.parse(candidate).root;
+    let current = root;
+    for (const component of path.relative(root, candidate).split(path.sep).filter(Boolean)) {
+        current = path.join(current, component);
+        let entry;
+        try {
+            entry = fs.lstatSync(current);
+        }
+        catch (error) {
+            if (isNodeError(error) && error.code === "ENOENT")
+                break;
+            throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Could not inspect worktree path: ${candidate}`, { worktree: candidate }, error);
+        }
+        if (entry.isSymbolicLink()) {
+            throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Worktree path contains a symbolic link: ${candidate}`, {
+                worktree: candidate,
+            });
+        }
+    }
+}
+function samePath(left, right) {
+    return path.resolve(left) === path.resolve(right);
+}
+function resolveDefaultBranchName(git, cwd, worktrees, configured) {
+    if (configured !== undefined)
+        return configured;
+    const integrationBranch = worktrees[0]?.branchName;
+    if (integrationBranch !== null && integrationBranch !== undefined)
+        return integrationBranch;
+    try {
+        const configuredDefault = git.run(["config", "--get", "init.defaultBranch"], cwd);
+        if (configuredDefault.length > 0)
+            return configuredDefault;
+    }
+    catch {
+        // A repository without init.defaultBranch is valid; continue to the local HEAD fallback.
+    }
+    try {
+        const remoteHead = git.run(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], cwd);
+        if (remoteHead.startsWith("origin/"))
+            return remoteHead.slice("origin/".length);
+    }
+    catch {
+        // A local repository may not have an origin or a symbolic remote HEAD.
+    }
+    return undefined;
+}
+function localBranchExists(git, cwd, branchId) {
+    try {
+        git.run(["show-ref", "--verify", "--quiet", branchId], cwd);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof SessionRegistryError && error.code === "GIT_COMMAND_FAILED")
+            return false;
+        throw error;
+    }
+}
+function assertGitResourcesAvailable(git, cwd, resources) {
+    const worktrees = listGitWorktrees(git, cwd);
+    if (worktrees.some((worktree) => samePath(worktree.worktreePath, resources.worktreePath))) {
+        throw new SessionRegistryError("WORKTREE_ALREADY_EXISTS", `Worktree path already exists: ${resources.worktreePath}`, {
+            worktree: resources.worktreePath,
+        });
+    }
+    const worktreeEntry = lstatIfPresent(resources.worktreePath);
+    if (worktreeEntry?.isSymbolicLink()) {
+        throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Worktree path is a symbolic link: ${resources.worktreePath}`, {
+            worktree: resources.worktreePath,
+        });
+    }
+    if (worktreeEntry !== undefined) {
+        throw new SessionRegistryError("WORKTREE_ALREADY_EXISTS", `Worktree path already exists: ${resources.worktreePath}`, {
+            worktree: resources.worktreePath,
+        });
+    }
+    if (localBranchExists(git, cwd, resources.branchId)) {
+        throw new SessionRegistryError("BRANCH_ALREADY_EXISTS", `Local branch already exists: ${resources.branchName}`, {
+            branch: resources.branchName,
+        });
+    }
+}
+function resolveBaseRef(git, cwd, candidate) {
+    if (candidate.trim().length === 0 ||
+        candidate !== candidate.trim() ||
+        candidate.startsWith("-") ||
+        candidate.includes("\u0000")) {
+        throw new SessionRegistryError("INVALID_BASE_REF", `Invalid base ref: ${candidate}`, { baseRef: candidate });
+    }
+    try {
+        git.run(["rev-parse", "--verify", `${candidate}^{commit}`], cwd);
+        return candidate;
+    }
+    catch (error) {
+        if (error instanceof SessionRegistryError && error.code === "GIT_COMMAND_FAILED") {
+            throw new SessionRegistryError("INVALID_BASE_REF", `Base ref does not resolve to a commit: ${candidate}`, {
+                baseRef: candidate,
+            });
+        }
+        throw error;
+    }
+}
+function rollbackProvisionedResources(git, cwd, resources) {
+    try {
+        git.run(["worktree", "remove", "--force", "--", resources.worktreePath], cwd);
+    }
+    catch {
+        // Best effort: the registry must remain unclaimed even if Git cleanup fails.
+    }
+    try {
+        git.run(["branch", "-D", "--", resources.branchName], cwd);
+    }
+    catch {
+        // Best effort: never replace the original provisioning or registry error.
+    }
+}
+function lstatIfPresent(candidate) {
+    try {
+        return fs.lstatSync(candidate);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return undefined;
+        throw new SessionRegistryError("INVALID_WORKTREE_PATH", `Could not inspect worktree path: ${candidate}`, { worktree: candidate }, error);
+    }
+}
+export function toPersistedSessionRecord(record, expectedRepositoryId = record.repositoryId) {
+    const validated = validateSessionRecord(record, expectedRepositoryId);
+    return {
+        schema_version: validated.schemaVersion,
+        session_id: validated.sessionId,
+        repository_id: validated.repositoryId,
+        worktree_id: validated.worktreeId,
+        worktree_path: validated.worktreePath,
+        branch_id: validated.branchId,
+        branch_name: validated.branchName,
+        state: validated.state,
+        created_at: validated.createdAt,
+        updated_at: validated.updatedAt,
+        ...(validated.label === undefined ? {} : { label: validated.label }),
+    };
+}
+function parseRegistry(value, expectedRepositoryId) {
+    if (!isRecord(value)) {
+        throw new SessionRegistryError("REGISTRY_CORRUPT", "Registry root must be an object");
+    }
+    if (value.schema_version !== REGISTRY_SCHEMA_VERSION) {
+        if (typeof value.schema_version === "number") {
+            throw new SessionRegistryError("UNSUPPORTED_SCHEMA_VERSION", `Unsupported registry schema version: ${value.schema_version}`, {
+                schemaVersion: value.schema_version,
+            });
+        }
+        throw new SessionRegistryError("REGISTRY_CORRUPT", "Registry schema_version must be a number");
+    }
+    assertExactKeys(value, ["schema_version", "repository_id", "sessions"]);
+    if (typeof value.repository_id !== "string" || value.repository_id !== expectedRepositoryId) {
+        throw new SessionRegistryError("REGISTRY_REPOSITORY_MISMATCH", "Registry repository identity does not match the current repository", { expectedRepositoryId, actualRepositoryId: stringifyDetail(value.repository_id) });
+    }
+    if (!Array.isArray(value.sessions)) {
+        throw new SessionRegistryError("REGISTRY_CORRUPT", "Registry sessions must be an array");
+    }
+    const records = value.sessions.map((candidate, index) => parseSessionRecord(candidate, index, expectedRepositoryId));
+    validateRecords(records, expectedRepositoryId);
+    return records;
+}
+function parseSessionRecord(value, index, expectedRepositoryId) {
+    if (!isRecord(value)) {
+        throw invalidRecord(index, "record must be an object");
+    }
+    assertExactKeys(value, [
+        "schema_version",
+        "session_id",
+        "repository_id",
+        "worktree_id",
+        "worktree_path",
+        "branch_id",
+        "branch_name",
+        "state",
+        "created_at",
+        "updated_at",
+    ], ["label"], index);
+    if (value.schema_version !== REGISTRY_SCHEMA_VERSION) {
+        if (typeof value.schema_version === "number") {
+            throw new SessionRegistryError("UNSUPPORTED_SCHEMA_VERSION", `Unsupported session schema version: ${value.schema_version}`, {
+                schemaVersion: value.schema_version,
+                index,
+            });
+        }
+        throw invalidRecord(index, "schema_version must be a number");
+    }
+    const record = {
+        schemaVersion: REGISTRY_SCHEMA_VERSION,
+        sessionId: requireString(value.session_id, index, "session_id"),
+        repositoryId: requireString(value.repository_id, index, "repository_id"),
+        worktreeId: requireString(value.worktree_id, index, "worktree_id"),
+        worktreePath: requireString(value.worktree_path, index, "worktree_path"),
+        branchId: requireString(value.branch_id, index, "branch_id"),
+        branchName: requireString(value.branch_name, index, "branch_name"),
+        state: requireState(value.state, index),
+        createdAt: requireString(value.created_at, index, "created_at"),
+        updatedAt: requireString(value.updated_at, index, "updated_at"),
+        ...(value.label === undefined ? {} : { label: requireString(value.label, index, "label") }),
+    };
+    return validateSessionRecord(record, expectedRepositoryId, index);
+}
+function validateSessionRecord(record, expectedRepositoryId, index) {
+    const position = index === undefined ? "" : ` at index ${index}`;
+    if (record.schemaVersion !== REGISTRY_SCHEMA_VERSION) {
+        throw new SessionRegistryError("UNSUPPORTED_SCHEMA_VERSION", `Unsupported session schema version${position}`, {
+            schemaVersion: record.schemaVersion,
+        });
+    }
+    if (!isSessionId(record.sessionId)) {
+        throw new SessionRegistryError("INVALID_SESSION_ID", `Invalid session ID${position}: ${record.sessionId}`, {
+            sessionId: record.sessionId,
+        });
+    }
+    if (record.repositoryId !== expectedRepositoryId) {
+        throw new SessionRegistryError("REGISTRY_REPOSITORY_MISMATCH", `Session repository identity does not match${position}`, {
+            expectedRepositoryId,
+            actualRepositoryId: record.repositoryId,
+        });
+    }
+    if (!isAbsolutePath(record.repositoryId) ||
+        !isAbsolutePath(record.worktreeId) ||
+        !isAbsolutePath(record.worktreePath)) {
+        throw invalidRecord(index, "repository and worktree identities must be absolute paths");
+    }
+    if (record.worktreeId !== record.worktreePath) {
+        throw invalidRecord(index, "worktree_id must equal the canonical worktree_path");
+    }
+    if (normalizeBranchId(record.branchName) !== record.branchId) {
+        throw invalidRecord(index, "branch_id must be the canonical identity of branch_name");
+    }
+    if (record.branchName !== record.branchId.slice("refs/heads/".length)) {
+        throw invalidRecord(index, "branch_name must be the short name represented by branch_id");
+    }
+    if (!SESSION_STATES.has(record.state)) {
+        throw invalidRecord(index, `unsupported lifecycle state: ${record.state}`);
+    }
+    if (!isTimestamp(record.createdAt) || !isTimestamp(record.updatedAt)) {
+        throw invalidRecord(index, "created_at and updated_at must be canonical UTC timestamps");
+    }
+    if (Date.parse(record.updatedAt) < Date.parse(record.createdAt)) {
+        throw invalidRecord(index, "updated_at cannot precede created_at");
+    }
+    if (record.label !== undefined && (typeof record.label !== "string" || record.label.length === 0)) {
+        throw invalidRecord(index, "label must be a non-empty string");
+    }
+    return freezeSessionRecord({ ...record });
+}
+function validateRecords(records, expectedRepositoryId) {
+    const sessionIds = new Set();
+    const worktreeOwners = new Map();
+    const branchOwners = new Map();
+    for (const [index, record] of records.entries()) {
+        const validated = validateSessionRecord(record, expectedRepositoryId, index);
+        if (sessionIds.has(validated.sessionId)) {
+            throw new SessionRegistryError("DUPLICATE_SESSION_ID", `Duplicate session ID: ${validated.sessionId}`, {
+                sessionId: validated.sessionId,
+            });
+        }
+        sessionIds.add(validated.sessionId);
+        if (!ACTIVE_STATES.has(validated.state)) {
+            continue;
+        }
+        const existingWorktreeOwner = worktreeOwners.get(validated.worktreeId);
+        if (existingWorktreeOwner !== undefined) {
+            throw new SessionRegistryError("DUPLICATE_WORKTREE_OWNERSHIP", `Worktree is claimed by multiple active sessions: ${validated.worktreePath}`, { worktree: validated.worktreePath, sessionId: validated.sessionId, ownerSessionId: existingWorktreeOwner });
+        }
+        worktreeOwners.set(validated.worktreeId, validated.sessionId);
+        const existingBranchOwner = branchOwners.get(validated.branchId);
+        if (existingBranchOwner !== undefined) {
+            throw new SessionRegistryError("DUPLICATE_BRANCH_OWNERSHIP", `Branch is claimed by multiple active sessions: ${validated.branchId}`, { branch: validated.branchId, sessionId: validated.sessionId, ownerSessionId: existingBranchOwner });
+        }
+        branchOwners.set(validated.branchId, validated.sessionId);
+    }
+}
+function assertNoOwnershipConflict(records, candidate) {
+    if (!ACTIVE_STATES.has(candidate.state)) {
+        return;
+    }
+    for (const record of records) {
+        if (!ACTIVE_STATES.has(record.state)) {
+            continue;
+        }
+        if (record.worktreeId === candidate.worktreeId) {
+            throw new SessionRegistryError("DUPLICATE_WORKTREE_OWNERSHIP", `Worktree is already owned: ${candidate.worktreePath}`, {
+                worktree: candidate.worktreePath,
+                ownerSessionId: record.sessionId,
+            });
+        }
+        if (record.branchId === candidate.branchId) {
+            throw new SessionRegistryError("DUPLICATE_BRANCH_OWNERSHIP", `Branch is already owned: ${candidate.branchId}`, {
+                branch: candidate.branchId,
+                ownerSessionId: record.sessionId,
+            });
+        }
+    }
+}
+function canonicalWorktreePath(candidate) {
+    const resolved = path.resolve(candidate);
+    try {
+        const stat = fs.statSync(resolved);
+        if (!stat.isDirectory()) {
+            throw new Error("path is not a directory");
+        }
+        return fs.realpathSync.native(resolved);
+    }
+    catch (error) {
+        throw new SessionRegistryError("WORKTREE_IDENTITY_AMBIGUOUS", `Could not resolve worktree identity: ${resolved}`, {
+            worktree: resolved,
+        }, error);
+    }
+}
+function assertSessionId(sessionId) {
+    if (!isSessionId(sessionId)) {
+        throw new SessionRegistryError("INVALID_SESSION_ID", `Invalid session ID: ${sessionId}`, { sessionId });
+    }
+}
+function validateLabel(label) {
+    if (typeof label !== "string" || label.length === 0) {
+        throw new SessionRegistryError("INVALID_SESSION_RECORD", "Session label must be a non-empty string");
+    }
+    return label;
+}
+function toTimestamp(date) {
+    if (Number.isNaN(date.getTime())) {
+        throw new SessionRegistryError("INVALID_SESSION_RECORD", "Session clock returned an invalid timestamp");
+    }
+    return date.toISOString();
+}
+function isTimestamp(value) {
+    return (ISO_TIMESTAMP_PATTERN.test(value) && !Number.isNaN(Date.parse(value)) && new Date(value).toISOString() === value);
+}
+function isAbsolutePath(value) {
+    return path.isAbsolute(value) && path.resolve(value) === value && !value.includes("\u0000");
+}
+function cloneSessionRecord(record) {
+    return freezeSessionRecord({ ...record });
+}
+function freezeSessionRecord(record) {
+    return Object.freeze(record);
+}
+function requireString(value, index, field) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw invalidRecord(index, `${field} must be a non-empty string`);
+    }
+    return value;
+}
+function requireState(value, index) {
+    if (typeof value !== "string" || !SESSION_STATES.has(value)) {
+        throw invalidRecord(index, `state is invalid: ${stringifyDetail(value)}`);
+    }
+    return value;
+}
+function invalidRecord(index, reason) {
+    return new SessionRegistryError("INVALID_SESSION_RECORD", `Invalid session record${index === undefined ? "" : ` at index ${index}`}: ${reason}`, {
+        ...(index === undefined ? {} : { index }),
+    });
+}
+function assertExactKeys(value, required, optional = [], index) {
+    const allowed = new Set([...required, ...optional]);
+    const keys = Object.keys(value);
+    if (keys.length !== required.length + optional.filter((key) => Object.hasOwn(value, key)).length ||
+        keys.some((key) => !allowed.has(key))) {
+        throw invalidRecord(index, `unexpected or missing fields: ${keys.join(", ")}`);
+    }
+    for (const key of required) {
+        if (!Object.hasOwn(value, key)) {
+            throw invalidRecord(index, `missing field: ${key}`);
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string";
+}
+function stringifyDetail(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+        ? String(value)
+        : "<invalid>";
+}
+function toSessionRegistryLockError(error, lockPath) {
+    if (error instanceof SessionRegistryError) {
+        return error;
+    }
+    if (error instanceof RegistryLockError) {
+        const details = { path: lockPath };
+        for (const [key, value] of Object.entries(error.details)) {
+            if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+                details[key] = value;
+            }
+        }
+        const code = error.code === "LOCK_BUSY" || error.code === "LOCK_STALE" || error.code === "LOCK_INVALID"
+            ? "REGISTRY_LOCK_TIMEOUT"
+            : "REGISTRY_IO_FAILURE";
+        return new SessionRegistryError(code, error.message, details, error);
+    }
+    return new SessionRegistryError("REGISTRY_IO_FAILURE", `Could not operate on ${lockPath}`, { path: lockPath }, error);
+}
+function closeQuietly(descriptor) {
+    try {
+        fs.closeSync(descriptor);
+    }
+    catch {
+        // The original operation's error is more useful than a best-effort close error.
+    }
+}
+function unlinkQuietly(filePath) {
+    try {
+        fs.unlinkSync(filePath);
+    }
+    catch {
+        // A missing temporary file is already the desired state.
+    }
+}
+function syncDirectory(directory) {
+    let descriptor;
+    try {
+        descriptor = fs.openSync(directory, "r");
+        fs.fsyncSync(descriptor);
+    }
+    catch {
+        // Directory fsync is not available on every supported filesystem. The
+        // file itself was fsynced before rename, so continue on that limitation.
+    }
+    finally {
+        if (descriptor !== undefined) {
+            closeQuietly(descriptor);
+        }
+    }
+}
+//# sourceMappingURL=session-registry.js.map