@cortexkit/antigravity-auth-core 2.2.1 → 3.0.0

package/dist/common-auth-embedded/store/publication.d.ts

@@ -0,0 +1,47 @@
+import type { Attribution } from './attribution.js';
+import type { PoolLockSpec } from './refresh-lock.js';
+import { type FailureHook, type ProtectFn } from './rows.js';
+import { type StoreRuntime } from './runtime.js';
+export interface PublishPlan {
+    operationId: string;
+    remove: Array<{
+        id: string;
+        attribution: Attribution;
+        fingerprint?: string;
+    }>;
+    finalize: Array<{
+        id: string;
+        attribution: Attribution;
+        reservation: string;
+        enabled: boolean;
+        disabledReason?: string;
+    }>;
+    order: string[];
+}
+export interface PublicationReceipt {
+    operationId: string;
+    planDigest: string;
+    phase: 'committed' | 'cleaned';
+    removed: Array<{
+        id: string;
+        credentialEpoch: number;
+    }>;
+    finalized: Array<{
+        id: string;
+        credentialEpoch: number;
+        reservation: string;
+        enabled: boolean;
+    }>;
+}
+export interface PublishOptions {
+    protect?: ProtectFn;
+    extraLocks?: PoolLockSpec[];
+    providerLock?: PoolLockSpec;
+    onFailure?: FailureHook;
+}
+export interface PublishResult {
+    outcome: 'published' | 'cleaned' | 'already-cleaned';
+    receipt: PublicationReceipt;
+}
+export declare function publication(rt: StoreRuntime, operationId: string): Promise<PublicationReceipt | undefined>;
+export declare function publishRoster(rt: StoreRuntime, plan: PublishPlan, options?: PublishOptions): Promise<PublishResult>;

package/dist/common-auth-embedded/store/publication.js

@@ -0,0 +1,304 @@
+import { assertNotInsideHook } from './hooks.js';
+import { notReadyError, readPool, runOperation, withTransaction, } from './mutate.js';
+import { assertBoundRowAttribution, protectIn, validateAttribution, } from './rows.js';
+import { refusal, rowLockSpec } from './runtime.js';
+import { CREDENTIAL_STAMP_KEY, canonicalDigest, fingerprintOf, idProblem, isCredentialEpoch, isRecord, POOL_KEY, PROVIDER_STATE_KEY, parseStamp, rosterOf, rowLockKey, } from './schema.js';
+function receiptsIn(config) {
+    const pool = config[POOL_KEY];
+    return isRecord(pool) && isRecord(pool.publications) ? pool.publications : {};
+}
+function receiptIn(config, operationId) {
+    const receipts = receiptsIn(config);
+    if (!Object.hasOwn(receipts, operationId))
+        return undefined;
+    const raw = receipts[operationId];
+    if (!isRecord(raw) ||
+        raw.operationId !== operationId ||
+        typeof raw.planDigest !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(raw.planDigest) ||
+        !['committed', 'cleaned'].includes(String(raw.phase)) ||
+        !Array.isArray(raw.removed) ||
+        !Array.isArray(raw.finalized) ||
+        raw.removed.some((ref) => !isRecord(ref) ||
+            typeof ref.id !== 'string' ||
+            !isCredentialEpoch(ref.credentialEpoch)) ||
+        raw.finalized.some((ref) => !isRecord(ref) ||
+            typeof ref.id !== 'string' ||
+            !isCredentialEpoch(ref.credentialEpoch) ||
+            typeof ref.reservation !== 'string' ||
+            !ref.reservation ||
+            typeof ref.enabled !== 'boolean'))
+        throw refusal('publishRoster', operationId, 'invalid-input', 'the stored publication receipt is malformed');
+    return structuredClone(raw);
+}
+export async function publication(rt, operationId) {
+    const result = await readPool(rt.ctx);
+    if (result.status !== 'ready')
+        throw notReadyError(result, 'publishRoster', operationId);
+    return receiptIn(result.config, operationId);
+}
+function validatePlan(rt, plan) {
+    const fail = () => {
+        throw refusal('publishRoster', plan?.operationId ?? '', 'invalid-input', 'the publication plan is invalid');
+    };
+    if (!isRecord(plan) ||
+        typeof plan.operationId !== 'string' ||
+        !plan.operationId ||
+        !Array.isArray(plan.remove) ||
+        !Array.isArray(plan.finalize) ||
+        !Array.isArray(plan.order))
+        fail();
+    const ids = new Set();
+    for (const ref of [...plan.remove, ...plan.finalize]) {
+        if (!isRecord(ref) ||
+            typeof ref.id !== 'string' ||
+            idProblem(ref.id) ||
+            ids.has(ref.id) ||
+            !ref.attribution)
+            fail();
+        ids.add(ref.id);
+        validateAttribution('publishRoster', ref.id, ref.attribution);
+        if (ref.attribution.identity !== undefined &&
+            (typeof ref.attribution.identity !== 'string' ||
+                !ref.attribution.identity))
+            fail();
+    }
+    for (const ref of plan.remove)
+        if ((rt.ctx.requireRemovedFingerprint && !ref.fingerprint) ||
+            (ref.fingerprint !== undefined && typeof ref.fingerprint !== 'string'))
+            fail();
+    for (const ref of plan.finalize)
+        if (typeof ref.reservation !== 'string' ||
+            !ref.reservation ||
+            typeof ref.enabled !== 'boolean' ||
+            (ref.enabled
+                ? ref.disabledReason !== undefined
+                : typeof ref.disabledReason !== 'string'))
+            fail();
+    if (plan.order.some((id) => typeof id !== 'string' || idProblem(id)) ||
+        new Set(plan.order).size !== plan.order.length)
+        fail();
+}
+function saveReceipt(tx, receipt) {
+    tx.entries();
+    const pool = tx.config[POOL_KEY];
+    const receipts = { ...receiptsIn(tx.config) };
+    Object.defineProperty(receipts, receipt.operationId, {
+        value: receipt,
+        enumerable: true,
+        writable: true,
+        configurable: true,
+    });
+    pool.publications = receipts;
+    // Never forget which plan used an operation id or the actual row epochs it
+    // changed: otherwise an old replay could publish again against another pool.
+    delete pool.publicationOrder;
+}
+function publicationSurvivors(tx, plan, rows) {
+    const rosterIds = new Set();
+    for (const raw of rosterOf(tx.config)) {
+        if (!isRecord(raw) || typeof raw.id !== 'string')
+            continue;
+        if (rosterIds.has(raw.id))
+            throw refusal('publishRoster', plan.operationId, 'invalid-input', 'publication needs a roster of unique named rows');
+        rosterIds.add(raw.id);
+    }
+    const removedIds = new Set(plan.remove.map((ref) => ref.id));
+    const survivors = rows.filter((row) => row.invalid !== 'roster' && !removedIds.has(row.id));
+    if (survivors.length !== plan.order.length ||
+        plan.order.some((id) => !survivors.some((row) => row.id === id)) ||
+        survivors.some((row) => !plan.order.includes(row.id)))
+        throw refusal('publishRoster', plan.operationId, 'invalid-input', 'order must name exactly the surviving roster');
+    return survivors;
+}
+async function cleanup(tx, receipt) {
+    await tx.assertAll();
+    for (const ref of receipt.removed) {
+        const stamp = parseStamp(tx.stateAccount(ref.id)?.[CREDENTIAL_STAMP_KEY]);
+        // A later add uses a later epoch. Cleanup never deletes that successor.
+        if (stamp?.credentialEpoch === ref.credentialEpoch && !tx.rosterRow(ref.id))
+            tx.dropStateAccount(ref.id);
+    }
+    for (const ref of receipt.finalized) {
+        const account = tx.stateAccount(ref.id);
+        const stamp = parseStamp(account?.[CREDENTIAL_STAMP_KEY]);
+        if (account &&
+            stamp?.credentialEpoch === ref.credentialEpoch &&
+            stamp.staged?.reservation === ref.reservation) {
+            const next = {
+                ...account[CREDENTIAL_STAMP_KEY],
+            };
+            delete next.staged;
+            tx.setStateAccount(ref.id, { ...account, [CREDENTIAL_STAMP_KEY]: next });
+        }
+    }
+    await tx.commitState(undefined, { durable: true });
+    const cleaned = { ...receipt, phase: 'cleaned' };
+    saveReceipt(tx, cleaned);
+    await tx.commitConfig({ durable: true });
+    return cleaned;
+}
+export async function publishRoster(rt, plan, options = {}) {
+    assertNotInsideHook('publishRoster');
+    return runOperation(rt.ctx, 'publishRoster', plan?.operationId ?? '', options.onFailure, async (locks, progress) => {
+        if (!isRecord(plan) ||
+            typeof plan.operationId !== 'string' ||
+            !plan.operationId)
+            throw refusal('publishRoster', plan?.operationId ?? '', 'invalid-input', 'the publication needs an operation id');
+        plan = structuredClone(plan);
+        const planDigest = canonicalDigest(plan);
+        const named = [
+            ...(Array.isArray(plan.remove) ? plan.remove : []),
+            ...(Array.isArray(plan.finalize) ? plan.finalize : []),
+        ].filter((ref) => isRecord(ref) && typeof ref.id === 'string');
+        for (let attempt = 0;; attempt++) {
+            const seen = await readPool(rt.ctx);
+            if (seen.status !== 'ready')
+                throw notReadyError(seen, 'publishRoster', plan.operationId);
+            const keys = new Map(named.map(({ id }) => [
+                id,
+                rowLockKey(seen.rows.find((row) => row.id === id) ?? { id }),
+            ]));
+            // All row keys precede the provider lock. A refresh owns just one row
+            // before that lock, so it cannot wait for a second row this call holds.
+            for (const key of [...new Set(keys.values())].sort())
+                await locks.acquire(rowLockSpec(rt, { id: key }));
+            await locks.acquire(options.providerLock ?? rt.providerLock);
+            for (const extra of options.extraLocks ?? [])
+                await locks.acquire(extra);
+            const result = await withTransaction(rt.ctx, locks, progress, { operation: 'publishRoster', rowId: plan.operationId }, async (tx) => {
+                const rows = tx.rows();
+                if (named.some(({ id }) => rowLockKey(rows.find((row) => row.id === id) ?? { id }) !==
+                    keys.get(id)))
+                    return undefined;
+                const prior = receiptIn(tx.config, plan.operationId);
+                if (prior) {
+                    if (prior.planDigest !== planDigest)
+                        throw refusal('publishRoster', plan.operationId, 'publication-mismatch', 'the operation id belongs to a different publication plan');
+                    if (prior.phase === 'cleaned')
+                        return { outcome: 'already-cleaned', receipt: prior };
+                    tx.markPublicationDecision();
+                    await tx.syncConfig();
+                    return { outcome: 'cleaned', receipt: await cleanup(tx, prior) };
+                }
+                validatePlan(rt, plan);
+                const survivors = publicationSurvivors(tx, plan, rows);
+                const removed = [];
+                for (const ref of plan.remove) {
+                    tx.assertNotStaged(ref.id);
+                    const row = rows.find((row) => row.id === ref.id);
+                    if (!row)
+                        throw refusal('publishRoster', ref.id, 'attribution', 'the removed row no longer exists');
+                    assertBoundRowAttribution(ref.id, row, ref.attribution, 'publishRoster');
+                    if (!row.credential ||
+                        (ref.fingerprint !== undefined &&
+                            fingerprintOf(row.credential) !== ref.fingerprint))
+                        throw refusal('publishRoster', ref.id, 'attribution', 'the removed secret no longer matches');
+                    removed.push(row);
+                }
+                const finalized = [];
+                for (const ref of plan.finalize) {
+                    const row = rows.find((row) => row.id === ref.id);
+                    const stamp = parseStamp(tx.stateAccount(ref.id)?.[CREDENTIAL_STAMP_KEY]);
+                    if (!row ||
+                        row.staged?.reservation !== ref.reservation ||
+                        stamp?.staged?.reservation !== ref.reservation ||
+                        row.enabled)
+                        throw refusal('publishRoster', ref.id, 'row-staged', 'the finalized row is not disabled under this reservation');
+                    const account = tx.stateAccount(ref.id);
+                    const raw = tx.rosterRow(ref.id);
+                    const storedProviderState = account?.[PROVIDER_STATE_KEY];
+                    const fullProviderDigest = storedProviderState === undefined
+                        ? undefined
+                        : canonicalDigest(storedProviderState);
+                    if (!stamp?.staged ||
+                        stamp.staged.label !== raw?.label ||
+                        stamp.staged.disabledReason !== row.disabledReason ||
+                        stamp.staged.providerState !== fullProviderDigest)
+                        throw refusal('publishRoster', ref.id, 'row-staged', 'the staged label, disabled reason or full provider state no longer matches its stamp');
+                    assertBoundRowAttribution(ref.id, row, ref.attribution, 'publishRoster');
+                    finalized.push(row);
+                }
+                const tornSurvivor = survivors.find((row) => row.torn);
+                if (tornSurvivor)
+                    throw refusal('publishRoster', plan.operationId, 'attribution', `Row ${tornSurvivor.id} has an interrupted write; complete it with a normal store operation before publishing.`, false);
+                const identities = new Set();
+                for (const row of survivors) {
+                    const enabled = plan.finalize.find((ref) => ref.id === row.id)?.enabled ??
+                        row.enabled;
+                    if (!enabled ||
+                        row.type !== 'oauth' ||
+                        row.identity === undefined)
+                        continue;
+                    if (identities.has(row.identity))
+                        throw refusal('publishRoster', row.id, 'invalid-input', 'the final enabled roster repeats a known identity');
+                    identities.add(row.identity);
+                }
+                for (const row of survivors) {
+                    if (row.identity !== undefined &&
+                        row.fingerprint !== undefined &&
+                        survivors.some((other) => other.id !== row.id &&
+                            other.identity !== undefined &&
+                            other.identity !== row.identity &&
+                            other.fingerprint === row.fingerprint))
+                        throw refusal('publishRoster', row.id, 'attribution', 'the resulting pool gives the same secret different known identities');
+                }
+                for (const row of finalized)
+                    if (row.identity !== undefined &&
+                        removed.some((old) => old.identity !== undefined &&
+                            old.identity !== row.identity &&
+                            old.fingerprint === row.fingerprint))
+                        throw refusal('publishRoster', row.id, 'attribution', 'the staged secret belonged to a different known identity');
+                await protectIn(tx, plan.operationId, options.protect);
+                const receipt = {
+                    operationId: plan.operationId,
+                    planDigest,
+                    phase: 'committed',
+                    removed: removed.map((row) => ({
+                        id: row.id,
+                        credentialEpoch: row.credentialEpoch ?? 1,
+                    })),
+                    finalized: plan.finalize.map((ref, index) => ({
+                        id: ref.id,
+                        credentialEpoch: finalized[index]?.credentialEpoch ?? 1,
+                        reservation: ref.reservation,
+                        enabled: ref.enabled,
+                    })),
+                };
+                for (const ref of plan.remove)
+                    tx.dropRosterRows(ref.id);
+                for (const ref of plan.finalize) {
+                    const raw = tx.rosterRow(ref.id);
+                    raw.enabled = ref.enabled;
+                    const entry = { ...tx.entry(ref.id) };
+                    delete entry.staged;
+                    if (ref.enabled)
+                        delete entry.disabledReason;
+                    else
+                        entry.disabledReason = ref.disabledReason;
+                    tx.setEntry(ref.id, entry);
+                }
+                const preserved = tx
+                    .roster()
+                    .filter((raw) => !isRecord(raw) ||
+                    typeof raw.id !== 'string' ||
+                    rows.find((row) => row.id === raw.id)?.invalid === 'roster');
+                tx.config.accounts = [
+                    ...plan.order.map((id) => tx.rosterRow(id)),
+                    ...preserved,
+                ];
+                saveReceipt(tx, receipt);
+                // This durable rename is the irreversible roster decision. Everything
+                // after it follows only the receipt, including after a process restart.
+                await tx.syncState();
+                await tx.commitConfig({ durable: true, publicationDecision: true });
+                return { outcome: 'published', receipt: await cleanup(tx, receipt) };
+            }, { completeTorn: false });
+            if (result)
+                return result;
+            await locks.releaseAll();
+            if (attempt >= 1)
+                throw refusal('publishRoster', plan.operationId, 'row-key-changed', 'a named row changed lock key twice during publication', true);
+        }
+    });
+}

package/dist/common-auth-embedded/store/pull.d.ts

@@ -0,0 +1,36 @@
+import { PoolOperationError } from './errors.js';
+import type { PoolLogger } from './hooks.js';
+import { type PullReason, type StoreRuntime } from './runtime.js';
+import type { StoredCredential } from './schema.js';
+/** What a pull is issued with: the credential and its attribution tuple. */
+export interface PullRequest {
+    id: string;
+    credential: StoredCredential;
+    credentialEpoch: number;
+    identity?: string;
+    reason: PullReason;
+}
+export type PullHook = (request: PullRequest) => Promise<unknown>;
+/**
+ * Fires quota pulls without ever making a caller wait for one. A pull first
+ * gives a row without a per-row entry its entry at epoch 1 (its own locked
+ * config write), then captures the credential and the attribution tuple in
+ * one locked read, requests the observation, and records it only if
+ * attribution still holds. Failures go to the store's pull failure hook.
+ */
+export declare class PullScheduler {
+    private readonly rt;
+    private readonly hook;
+    private readonly onFailure;
+    /** Rows a load-time pull has fired for in this process. */
+    private readonly firedAtLoad;
+    private readonly logger;
+    private readonly inflight;
+    constructor(rt: () => StoreRuntime, hook: PullHook | undefined, onFailure: ((rowId: string, error: PoolOperationError) => void | Promise<void>) | undefined, 
+    /** Rows a load-time pull has fired for in this process. */
+    firedAtLoad: Set<string>, logger: PoolLogger | undefined);
+    fire(id: string, reason: PullReason): void;
+    /** Resolves once every pull fired so far has settled. */
+    settled(): Promise<void>;
+    private run;
+}

package/dist/common-auth-embedded/store/pull.js

@@ -0,0 +1,143 @@
+import { recordQuota } from './attribution.js';
+import { PoolOperationError } from './errors.js';
+import { toFailure, withTransaction } from './mutate.js';
+import { LockStack } from './refresh-lock.js';
+import { requireBound } from './runtime.js';
+/**
+ * Fires quota pulls without ever making a caller wait for one. A pull first
+ * gives a row without a per-row entry its entry at epoch 1 (its own locked
+ * config write), then captures the credential and the attribution tuple in
+ * one locked read, requests the observation, and records it only if
+ * attribution still holds. Failures go to the store's pull failure hook.
+ */
+export class PullScheduler {
+    rt;
+    hook;
+    onFailure;
+    firedAtLoad;
+    logger;
+    inflight = new Set();
+    constructor(rt, hook, onFailure, 
+    /** Rows a load-time pull has fired for in this process. */
+    firedAtLoad, logger) {
+        this.rt = rt;
+        this.hook = hook;
+        this.onFailure = onFailure;
+        this.firedAtLoad = firedAtLoad;
+        this.logger = logger;
+    }
+    fire(id, reason) {
+        if (!this.hook)
+            return;
+        if (reason === 'load') {
+            if (this.firedAtLoad.has(id))
+                return;
+            this.firedAtLoad.add(id);
+        }
+        const run = this.run(id, reason);
+        this.inflight.add(run);
+        void run.finally(() => this.inflight.delete(run));
+    }
+    /** Resolves once every pull fired so far has settled. */
+    async settled() {
+        while (this.inflight.size > 0)
+            await Promise.allSettled([...this.inflight]);
+    }
+    async run(id, reason) {
+        const rt = this.rt();
+        const { ctx } = rt;
+        const locks = new LockStack(ctx.lockDefaults, ctx.lockEnv);
+        const progress = { writes: 0 };
+        try {
+            const request = await withTransaction(ctx, locks, progress, { operation: 'pull', rowId: id }, async (tx) => {
+                // Even a skipped capture must not repair another row on a reserved
+                // row's behalf. Decide reservation before pool-wide torn repair.
+                if (tx.reservation(id) !== undefined)
+                    return undefined;
+                await tx.completeTorn();
+                const row = tx.row(id);
+                // A row that would pull but for its unbound credential refuses, so
+                // the failure hook hears of it instead of the pull vanishing.
+                if (row?.unbound &&
+                    row.enabled &&
+                    row.type === 'oauth' &&
+                    row.credential &&
+                    !row.invalid)
+                    requireBound('pull', row);
+                // Disabled, API-key and credential-less rows never pull.
+                if (!row?.candidate || row.type !== 'oauth')
+                    return undefined;
+                if (!row.hasEntry) {
+                    tx.setEntry(id, { credentialEpoch: 1, needsFirstReading: true });
+                    await tx.commitConfig();
+                }
+                const current = tx.row(id);
+                if (!current?.credential || current.credentialEpoch === undefined)
+                    return undefined;
+                return {
+                    id,
+                    credential: current.credential,
+                    credentialEpoch: current.credentialEpoch,
+                    ...(current.identity !== undefined
+                        ? { identity: current.identity }
+                        : {}),
+                    reason,
+                };
+            }, { completeTorn: false });
+            await locks.releaseAll();
+            if (!request) {
+                this.firedAtLoad.delete(id);
+                return;
+            }
+            await ctx.hold?.('pull-before-request', id);
+            let observation;
+            try {
+                observation = await this.hook?.(request);
+            }
+            catch (cause) {
+                throw new PoolOperationError({
+                    operation: 'pull',
+                    rowId: id,
+                    phase: 'pull',
+                    retryable: true,
+                    kind: 'pull',
+                    message: 'the quota pull rejected',
+                    cause,
+                });
+            }
+            await recordQuota(rt, id, {
+                credentialEpoch: request.credentialEpoch,
+                ...(request.identity !== undefined
+                    ? { identity: request.identity }
+                    : {}),
+            }, observation);
+        }
+        catch (error) {
+            // Needs-first-reading stays set; a later load may fire again.
+            this.firedAtLoad.delete(id);
+            const failure = toFailure(error, 'pull', id, progress);
+            if (this.onFailure) {
+                try {
+                    await this.onFailure(id, failure);
+                }
+                catch (hookError) {
+                    this.logger?.warn('pull failure hook threw', {
+                        rowId: id,
+                        error: hookError instanceof Error
+                            ? hookError.message
+                            : String(hookError),
+                    });
+                }
+            }
+            else {
+                this.logger?.warn('quota pull failed', {
+                    rowId: id,
+                    kind: failure.kind,
+                });
+            }
+        }
+        finally {
+            await locks.releaseAll();
+        }
+    }
+}

package/dist/common-auth-embedded/store/refresh-lock.d.ts

@@ -0,0 +1,63 @@
+import { acquireRefreshFileLock } from '../fs/refresh-file-lock.js';
+type LockStep = NonNullable<Parameters<typeof acquireRefreshFileLock>[0]['onStep']> extends (step: infer S) => unknown ? S : never;
+/** Tuning shared by every lock the store takes; each field is overridable. */
+export interface PoolLockOptions {
+    ttlMs: number;
+    timeoutMs: number;
+    retryMs: number;
+    renew: boolean;
+    renewIntervalMs?: number;
+}
+/** A lock: the (name, path) pair naming its file plus optional tuning. */
+export interface PoolLockSpec extends Partial<PoolLockOptions> {
+    name: string;
+    path: string;
+}
+/**
+ * Store lock defaults: a 15 000 ms bounded wait retried every 50 ms plus
+ * jitter, and a renewed 10 000 ms lease.
+ */
+export declare const POOL_LOCK_DEFAULTS: Readonly<PoolLockOptions>;
+export type LockEvent = {
+    type: 'acquired' | 'released' | 'contended';
+    name: string;
+    path: string;
+};
+export interface LockEnvironment {
+    now: () => number;
+    onLockEvent?: (event: LockEvent) => void;
+    onLockStep?: (lock: {
+        name: string;
+        path: string;
+    }, step: LockStep) => void | Promise<void>;
+}
+export interface HeldLock {
+    readonly name: string;
+    readonly path: string;
+    assertOwned(): Promise<void>;
+    release(): Promise<void>;
+}
+/**
+ * Takes one lock, retrying while a live holder has it until `timeoutMs` has
+ * passed on the real clock, then throws `LockContentionError`. The lease is
+ * asserted as owned once acquired, so a caller never proceeds on a lease that
+ * expired during the wait.
+ */
+export declare function acquirePoolLock(spec: PoolLockSpec, defaults: PoolLockOptions, env: LockEnvironment): Promise<HeldLock>;
+/**
+ * Locks taken in order and released in reverse. Every acquisition re-asserts
+ * the leases already held, because a wait is exactly when an earlier lease
+ * can expire unnoticed.
+ */
+export declare class LockStack {
+    private readonly defaults;
+    private readonly env;
+    readonly held: HeldLock[];
+    constructor(defaults: PoolLockOptions, env: LockEnvironment);
+    acquire(spec: PoolLockSpec): Promise<HeldLock>;
+    assertAll(): Promise<void>;
+    /** Releases every lock taken after `mark` (a length of `held`), newest first. */
+    releaseTo(mark: number): Promise<void>;
+    releaseAll(): Promise<void>;
+}
+export {};