@modelprofile.com/authswitch 3.3.0 → 5.0.0

package/dist_ts/classes.tui.js

@@ -89,11 +89,12 @@ export class AuthSwitchTui {
          *
          * The dashboard makes the same offer the command line does, with the same rule: only pids
          * enumerated for this user are signalled, the session running this dashboard is never one of
-         * them, and declining still performs the switch.
+         * them, and declining still performs the switch. A harness that picks up swaps live is never
+         * offered a stop here; the dashboard has no explicit stop request.
          */
         const settleInstances = (screen) => async () => {
             const control = harness.processes;
-            if (!control)
+            if (!control || harness.liveSwap === true)
                 return;
             let running;
             try {
@@ -241,4 +242,4 @@ export class AuthSwitchTui {
         return 0;
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tui.js","sourceRoot":"","sources":["../ts/classes.tui.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tui.js","sourceRoot":"","sources":["../ts/classes.tui.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.watch.d.ts

@@ -0,0 +1,108 @@
+import type { AuthSwitchOperations } from './classes.operations.js';
+import type { WatchLock } from './classes.watchlock.js';
+import type { IAccountType, IAuthHarness, IHarnessUsageWindow } from './interfaces.harness.js';
+/** The watch's time source; tests replace it so that no test waits for an interval. */
+export interface IWatchClock {
+    now(): number;
+    /** Resolves after the delay; rejects when the signal aborts first, leaving no timer behind. */
+    sleep(millisecondsArg: number, signalArg: AbortSignal): Promise<void>;
+}
+/** An account as a watch event names it. Carries no credential. */
+export interface IWatchAccount {
+    accountId: string;
+    label: string;
+    slotId?: string;
+    accountType: IAccountType | null;
+    /** The usage windows the decision used; null while the usage is unknown. */
+    usageWindows: IHarnessUsageWindow[] | null;
+}
+/** One line of `authswitch watch --json`. Times are ISO 8601 UTC. */
+export type TWatchEvent = {
+    type: 'start';
+    at: string;
+    harnesses: {
+        harnessId: string;
+        label: string;
+        note: string | null;
+    }[];
+    intervalSeconds: number;
+    threshold: number;
+    dryRun: boolean;
+} | {
+    type: 'tick';
+    at: string;
+    harnessId: string;
+    label: string;
+    active: IWatchAccount | null;
+    ok: boolean;
+    reason: string;
+} | {
+    type: 'switch';
+    at: string;
+    harnessId: string;
+    label: string;
+    dryRun: boolean;
+    from: IWatchAccount;
+    to: IWatchAccount;
+    reason: string;
+} | {
+    type: 'error';
+    at: string;
+    harnessId: string;
+    label: string;
+    message: string;
+};
+export interface IAuthSwitchWatchOptions {
+    harnesses: readonly IAuthHarness[];
+    /** The one mutation path every switch goes through. */
+    operations: AuthSwitchOperations;
+    lock: WatchLock;
+    intervalMs: number;
+    threshold: number;
+    dryRun: boolean;
+    onEvent: (eventArg: TWatchEvent) => void;
+    clock?: IWatchClock;
+}
+/**
+ * `authswitch watch`: reads every account's usage on an interval and switches a harness to a better saved account when
+ * its active one runs out, through the same mutation path as `use`.
+ *
+ * Ticks never overlap: the next one starts an interval after the previous one started, or at once when that one took
+ * longer. Lookups never change which account is in use and are bounded; an account whose lookup a provider refused or
+ * whose lookup failed is not asked about again until the time the provider named, or after an exponentially growing
+ * delay, and its last reading stands in meanwhile while it is recent. A failed or refused switch is reported and
+ * decided again on the next tick.
+ */
+export declare class AuthSwitchWatch {
+    private readonly options;
+    private readonly clock;
+    private readonly session;
+    /** Per harness id, per account id. */
+    private readonly memory;
+    constructor(options: IAuthSwitchWatchOptions);
+    private at;
+    /**
+     * Holds the lock and ticks until the signal aborts, or once. Resolves whether every switch it attempted completed;
+     * throws `WatchBusyError` when another watch is running.
+     */
+    run(signalArg: AbortSignal, optionsArg?: {
+        once?: boolean;
+    }): Promise<boolean>;
+    /** One round over every harness. Resolves false when a switch was attempted and did not complete. */
+    private tick;
+    private read;
+    /**
+     * Folds one lookup into the account's memory and returns what the decision may use. A row without a status was not
+     * looked up because the account is backing off.
+     *
+     * A lookup that a provider refused (a rate limit) or that failed (a rejected login, a timeout, an unreachable
+     * service) puts the account on hold for the time the provider named, else for a delay that doubles from one
+     * interval, and its last reading stands in meanwhile while it is recent: the accounts failing hardest must not be
+     * the ones asked most often, and one flaky request must not discard a reading taken moments ago. A lookup that
+     * answered without usage and without a problem is the provider reporting none, which is an answer: it clears both.
+     */
+    private remember;
+    private decide;
+}
+/** How `authswitch watch` prints an event: one line each, with the notes of a start on their own lines. */
+export declare const watchEventText: (eventArg: TWatchEvent) => string;

package/dist_ts/classes.watch.js

@@ -0,0 +1,219 @@
+import { accountBadge, accountName, durationText, localTime, readAccountRows } from './accounts.js';
+import { pause } from './helpers.js';
+import { bold, dim, green, orange, plainText, red } from './formatting.js';
+import { decideWatchAction } from './watchpolicy.js';
+const systemClock = { now: () => Date.now(), sleep: pause };
+/** How long a reading stands in for an account that is backing off. */
+const READING_REUSE_MS = 10 * 60_000;
+/** The longest backoff after repeated failures that named no retry time. */
+const MAX_BACKOFF_MS = 30 * 60_000;
+/** How a rate limited account's deferral reads; a lookup that failed otherwise is named by its own problem. */
+const RATE_LIMITED = 'rate limited';
+/** A caller-owned memo of slow-changing lookups, aged by the watch's clock. */
+class WatchStatusSession {
+    now;
+    entries = new Map();
+    constructor(now) {
+        this.now = now;
+    }
+    async reuse(keyArg, maxAgeMsArg, lookupArg) {
+        const now = this.now();
+        for (const [key, entry] of this.entries)
+            if (now - entry.at >= entry.maxAgeMs)
+                this.entries.delete(key);
+        const entry = this.entries.get(keyArg);
+        // Keys are adapter-owned and always name values of one type (IHarnessStatusSession).
+        if (entry)
+            return entry.value;
+        const value = await lookupArg();
+        this.entries.set(keyArg, { at: this.now(), maxAgeMs: maxAgeMsArg, value });
+        return value;
+    }
+}
+/**
+ * `authswitch watch`: reads every account's usage on an interval and switches a harness to a better saved account when
+ * its active one runs out, through the same mutation path as `use`.
+ *
+ * Ticks never overlap: the next one starts an interval after the previous one started, or at once when that one took
+ * longer. Lookups never change which account is in use and are bounded; an account whose lookup a provider refused or
+ * whose lookup failed is not asked about again until the time the provider named, or after an exponentially growing
+ * delay, and its last reading stands in meanwhile while it is recent. A failed or refused switch is reported and
+ * decided again on the next tick.
+ */
+export class AuthSwitchWatch {
+    options;
+    clock;
+    session;
+    /** Per harness id, per account id. */
+    memory = new Map();
+    constructor(options) {
+        this.options = options;
+        this.clock = options.clock ?? systemClock;
+        this.session = new WatchStatusSession(() => this.clock.now());
+    }
+    at() { return new Date(this.clock.now()).toISOString(); }
+    /**
+     * Holds the lock and ticks until the signal aborts, or once. Resolves whether every switch it attempted completed;
+     * throws `WatchBusyError` when another watch is running.
+     */
+    async run(signalArg, optionsArg = {}) {
+        this.options.lock.acquire();
+        try {
+            this.options.onEvent({
+                type: 'start', at: this.at(), intervalSeconds: this.options.intervalMs / 1000, threshold: this.options.threshold, dryRun: this.options.dryRun,
+                harnesses: this.options.harnesses.map(harness => ({ harnessId: harness.id, label: plainText(harness.label),
+                    note: harness.liveSwap === true ? null : `Running ${plainText(harness.label)} sessions keep the login they loaded; new sessions use the switched one.` })),
+            });
+            let completed = true;
+            while (!signalArg.aborted) {
+                const startedAt = this.clock.now();
+                completed = await this.tick(signalArg) && completed;
+                if (optionsArg.once)
+                    break;
+                try {
+                    await this.clock.sleep(Math.max(0, startedAt + this.options.intervalMs - this.clock.now()), signalArg);
+                }
+                catch (error) {
+                    if (!signalArg.aborted)
+                        throw error;
+                }
+            }
+            return completed;
+        }
+        finally {
+            this.options.lock.release();
+        }
+    }
+    /** One round over every harness. Resolves false when a switch was attempted and did not complete. */
+    async tick(signalArg) {
+        const now = this.clock.now();
+        const reads = await Promise.allSettled(this.options.harnesses.map(harness => this.read(harness, now, signalArg)));
+        let completed = true;
+        for (const [index, read] of reads.entries()) {
+            if (signalArg.aborted)
+                break;
+            const harness = this.options.harnesses[index];
+            if (read.status === 'rejected') {
+                this.options.onEvent({ type: 'error', at: this.at(), harnessId: harness.id, label: plainText(harness.label),
+                    message: `Could not read the accounts. Run authswitch ${harness.id} doctor.` });
+                continue;
+            }
+            completed = await this.decide(read.value, now) && completed;
+        }
+        return completed;
+    }
+    async read(harnessArg, nowArg, signalArg) {
+        const previous = this.memory.get(harnessArg.id) ?? new Map();
+        const { rows } = await readAccountRows(harnessArg, {
+            signal: signalArg, session: this.session, lookup: account => nowArg >= (previous.get(account.id)?.retryAt ?? 0),
+        });
+        // Only listed accounts are remembered, so a removed account leaves nothing behind.
+        const current = new Map();
+        const readings = [];
+        const accounts = new Map();
+        for (const row of rows) {
+            const memory = previous.get(row.account.id) ?? { usage: null, retryAt: 0, strikes: 0, deferralReason: null };
+            current.set(row.account.id, memory);
+            const { reading, account } = this.remember(memory, row, nowArg);
+            readings.push(reading);
+            accounts.set(row.account.id, account);
+        }
+        this.memory.set(harnessArg.id, current);
+        return { harness: harnessArg, rows, readings, accounts };
+    }
+    /**
+     * Folds one lookup into the account's memory and returns what the decision may use. A row without a status was not
+     * looked up because the account is backing off.
+     *
+     * A lookup that a provider refused (a rate limit) or that failed (a rejected login, a timeout, an unreachable
+     * service) puts the account on hold for the time the provider named, else for a delay that doubles from one
+     * interval, and its last reading stands in meanwhile while it is recent: the accounts failing hardest must not be
+     * the ones asked most often, and one flaky request must not discard a reading taken moments ago. A lookup that
+     * answered without usage and without a problem is the provider reporting none, which is an answer: it clears both.
+     */
+    remember(memoryArg, rowArg, nowArg) {
+        const status = rowArg.status;
+        const windows = status?.summary?.usageWindows;
+        const limited = status?.rateLimit !== undefined;
+        const failed = status !== undefined && !limited && windows === undefined && status.problems.length > 0;
+        if (status !== undefined && (limited || failed)) {
+            const named = status.rateLimit?.retryAt == null ? Number.NaN : Date.parse(status.rateLimit.retryAt);
+            memoryArg.strikes = Number.isFinite(named) ? 0 : memoryArg.strikes + 1;
+            memoryArg.retryAt = Number.isFinite(named) ? named : nowArg + Math.min(this.options.intervalMs * 2 ** (memoryArg.strikes - 1), MAX_BACKOFF_MS);
+            memoryArg.deferralReason = limited ? RATE_LIMITED : plainText(status.problems[0]);
+        }
+        else if (status) {
+            memoryArg.strikes = 0;
+            memoryArg.retryAt = 0;
+            memoryArg.deferralReason = null;
+        }
+        if (windows !== undefined)
+            memoryArg.usage = { accountType: status.summary.subscription ?? null, windows, at: nowArg };
+        else if (status && !limited && !failed)
+            memoryArg.usage = null;
+        const deferred = status === undefined || limited || failed;
+        const usage = deferred && memoryArg.usage !== null && nowArg - memoryArg.usage.at >= READING_REUSE_MS ? null : memoryArg.usage;
+        const unknownReason = usage !== null ? undefined
+            : `${memoryArg.deferralReason ?? 'usage not reported'}${nowArg < memoryArg.retryAt ? `, next lookup at ${localTime(memoryArg.retryAt)}` : ''}`;
+        const accountType = usage?.accountType ?? status?.summary?.subscription ?? null;
+        return {
+            reading: { id: rowArg.account.id, label: plainText(rowArg.account.label), isSaved: rowArg.account.isStashed, windows: usage?.windows ?? null,
+                ...(unknownReason === undefined ? {} : { unknownReason }) },
+            account: { accountId: rowArg.account.id, label: plainText(rowArg.account.label), ...(rowArg.account.slotId === undefined ? {} : { slotId: plainText(rowArg.account.slotId) }),
+                accountType: accountType === null ? null : { plan: plainText(accountType.plan), source: accountType.source }, usageWindows: usage === null ? null : [...usage.windows] },
+        };
+    }
+    async decide(tickArg, nowArg) {
+        const { harness } = tickArg;
+        const label = plainText(harness.label);
+        const activeId = tickArg.rows.find(row => row.account.isActive)?.account.id ?? null;
+        const decision = decideWatchAction({ activeId, readings: tickArg.readings, threshold: this.options.threshold, intervalMs: this.options.intervalMs, now: nowArg });
+        const active = activeId === null ? null : tickArg.accounts.get(activeId);
+        if (decision.action === 'stay') {
+            this.options.onEvent({ type: 'tick', at: this.at(), harnessId: harness.id, label, active, ok: decision.ok, reason: decision.reason });
+            return true;
+        }
+        const target = tickArg.accounts.get(decision.target);
+        const switched = { type: 'switch', harnessId: harness.id, label, from: active, to: target, reason: decision.reason };
+        if (this.options.dryRun) {
+            this.options.onEvent({ ...switched, at: this.at(), dryRun: true });
+            return true;
+        }
+        let problems;
+        try {
+            problems = (await this.options.operations.run(harness, { harnessId: harness.id, action: 'switch', accountId: target.accountId })).problems;
+        }
+        catch (error) {
+            problems = [error instanceof Error ? error.message : 'The switch failed.'];
+        }
+        if (problems.length) {
+            this.options.onEvent({ type: 'error', at: this.at(), harnessId: harness.id, label,
+                message: `Switching to ${accountName(target)} did not complete: ${problems.map(plainText).join(' ')} Deciding again next tick.` });
+            return false;
+        }
+        this.options.onEvent({ ...switched, at: this.at(), dryRun: false });
+        return true;
+    }
+}
+/** An account and its switch badge: `alice@example.com (type:Max) (5h:17%) (w:4%)`. */
+const badged = (accountArg) => `${bold(accountName(accountArg))}${accountBadge({ facts: [], problems: [], summary: {
+        ...(accountArg.accountType === null ? {} : { subscription: accountArg.accountType }),
+        ...(accountArg.usageWindows === null ? {} : { usageWindows: accountArg.usageWindows }),
+    } })}`;
+/** How `authswitch watch` prints an event: one line each, with the notes of a start on their own lines. */
+export const watchEventText = (eventArg) => {
+    const time = dim(localTime(Date.parse(eventArg.at)));
+    switch (eventArg.type) {
+        case 'start':
+            return [`${time} Watching ${eventArg.harnesses.map(harness => harness.label).join(', ')} every ${durationText(eventArg.intervalSeconds)}; switching at ${eventArg.threshold}%${eventArg.dryRun ? ' (dry run: nothing is switched)' : ''}.`,
+                ...eventArg.harnesses.flatMap(harness => harness.note === null ? [] : [`${time} ${dim(harness.note)}`])].join('\n');
+        case 'tick':
+            return eventArg.active === null ? `${time} ${eventArg.label} ${orange(eventArg.reason)}`
+                : `${time} ${eventArg.label} ${badged(eventArg.active)} ${eventArg.ok ? green('ok') : orange(eventArg.reason)}`;
+        case 'switch':
+            return `${time} ${eventArg.label} ${eventArg.dryRun ? 'would switch' : 'switched'} ${accountName(eventArg.from)} → ${badged(eventArg.to)} — ${eventArg.reason}`;
+        case 'error':
+            return `${time} ${eventArg.label} ${red(eventArg.message)}`;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.watch.js","sourceRoot":"","sources":["../ts/classes.watch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,SAAS,EAAE,eAAe,EAAoB,MAAM,eAAe,CAAC;AACtH,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAAE,iBAAiB,EAAsB,MAAM,kBAAkB,CAAC;AAYzE,MAAM,WAAW,GAAgB,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AA+BzE,uEAAuE;AACvE,MAAM,gBAAgB,GAAG,EAAE,GAAG,MAAM,CAAC;AACrC,4EAA4E;AAC5E,MAAM,cAAc,GAAG,EAAE,GAAG,MAAM,CAAC;AACnC,+GAA+G;AAC/G,MAAM,YAAY,GAAG,cAAc,CAAC;AAEpC,+EAA+E;AAC/E,MAAM,kBAAkB;IAEO;IADZ,OAAO,GAAG,IAAI,GAAG,EAA4D,CAAC;IAC/F,YAA6B,GAAiB;QAAjB,QAAG,GAAH,GAAG,CAAc;IAAG,CAAC;IAC3C,KAAK,CAAC,KAAK,CAAI,MAAc,EAAE,WAAmB,EAAE,SAA2B;QACpF,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,CAAC,OAAO;YAAE,IAAI,GAAG,GAAG,KAAK,CAAC,EAAE,IAAI,KAAK,CAAC,QAAQ;gBAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACxG,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACvC,qFAAqF;QACrF,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC,KAAU,CAAC;QACnC,MAAM,KAAK,GAAG,MAAM,SAAS,EAAE,CAAC;QAChC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC;QAC3E,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AAoBD;;;;;;;;;GASG;AACH,MAAM,OAAO,eAAe;IAMG;IALZ,KAAK,CAAc;IACnB,OAAO,CAAqB;IAC7C,sCAAsC;IACrB,MAAM,GAAG,IAAI,GAAG,EAAuC,CAAC;IAEzE,YAA6B,OAAgC;QAAhC,YAAO,GAAP,OAAO,CAAyB;QAC3D,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC;QAC1C,IAAI,CAAC,OAAO,GAAG,IAAI,kBAAkB,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC;IAChE,CAAC;IAEO,EAAE,KAAa,OAAO,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAEzE;;;OAGG;IACI,KAAK,CAAC,GAAG,CAAC,SAAsB,EAAE,aAAiC,EAAE;QAC1E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC;gBACnB,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,eAAe,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;gBAC7I,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;oBACxG,IAAI,EAAE,OAAO,CAAC,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,WAAW,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,0EAA0E,EAAE,CAAC,CAAC;aAC7J,CAAC,CAAC;YACH,IAAI,SAAS,GAAG,IAAI,CAAC;YACrB,OAAO,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;gBAC1B,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;gBACnC,SAAS,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC;gBACpD,IAAI,UAAU,CAAC,IAAI;oBAAE,MAAM;gBAC3B,IAAI,CAAC;oBAAC,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,SAAS,CAAC,CAAC;gBAAC,CAAC;gBAC/G,OAAO,KAAK,EAAE,CAAC;oBAAC,IAAI,CAAC,SAAS,CAAC,OAAO;wBAAE,MAAM,KAAK,CAAC;gBAAC,CAAC;YACxD,CAAC;YACD,OAAO,SAAS,CAAC;QACnB,CAAC;gBAAS,CAAC;YAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QAAC,CAAC;IAC5C,CAAC;IAED,qGAAqG;IAC7F,KAAK,CAAC,IAAI,CAAC,SAAsB;QACvC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,KAAK,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;QAClH,IAAI,SAAS,GAAG,IAAI,CAAC;QACrB,KAAK,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;YAC5C,IAAI,SAAS,CAAC,OAAO;gBAAE,MAAM;YAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;YAC9C,IAAI,IAAI,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;gBAC/B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;oBACzG,OAAO,EAAE,+CAA+C,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC,CAAC;gBAClF,SAAS;YACX,CAAC;YACD,SAAS,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,SAAS,CAAC;QAC9D,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC;IAEO,KAAK,CAAC,IAAI,CAAC,UAAwB,EAAE,MAAc,EAAE,SAAsB;QACjF,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,IAAI,GAAG,EAA0B,CAAC;QACrF,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,eAAe,CAAC,UAAU,EAAE;YACjD,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,OAAO,IAAI,CAAC,CAAC;SAChH,CAAC,CAAC;QACH,mFAAmF;QACnF,MAAM,OAAO,GAAG,IAAI,GAAG,EAA0B,CAAC;QAClD,MAAM,QAAQ,GAAoB,EAAE,CAAC;QACrC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAyB,CAAC;QAClD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;YACvB,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,cAAc,EAAE,IAAI,EAAE,CAAC;YAC7G,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;YACpC,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,MAAM,CAAC,CAAC;YAChE,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACvB,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACxC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;QACxC,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,CAAC;IAC3D,CAAC;IAED;;;;;;;;;OASG;IACK,QAAQ,CAAC,SAAyB,EAAE,MAAmB,EAAE,MAAc;QAC7E,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC7B,MAAM,OAAO,GAAG,MAAM,EAAE,OAAO,EAAE,YAAY,CAAC;QAC9C,MAAM,OAAO,GAAG,MAAM,EAAE,SAAS,KAAK,SAAS,CAAC;QAChD,MAAM,MAAM,GAAG,MAAM,KAAK,SAAS,IAAI,CAAC,OAAO,IAAI,OAAO,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC;QACvG,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,OAAO,IAAI,MAAM,CAAC,EAAE,CAAC;YAChD,MAAM,KAAK,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,IAAI,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;YACpG,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,GAAG,CAAC,CAAC;YACvE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,GAAG,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;YAC/I,SAAS,CAAC,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QACpF,CAAC;aAAM,IAAI,MAAM,EAAE,CAAC;YAClB,SAAS,CAAC,OAAO,GAAG,CAAC,CAAC;YACtB,SAAS,CAAC,OAAO,GAAG,CAAC,CAAC;YACtB,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC;QAClC,CAAC;QACD,IAAI,OAAO,KAAK,SAAS;YAAE,SAAS,CAAC,KAAK,GAAG,EAAE,WAAW,EAAE,MAAO,CAAC,OAAQ,CAAC,YAAY,IAAI,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC;aACpH,IAAI,MAAM,IAAI,CAAC,OAAO,IAAI,CAAC,MAAM;YAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC;QAC/D,MAAM,QAAQ,GAAG,MAAM,KAAK,SAAS,IAAI,OAAO,IAAI,MAAM,CAAC;QAC3D,MAAM,KAAK,GAAG,QAAQ,IAAI,SAAS,CAAC,KAAK,KAAK,IAAI,IAAI,MAAM,GAAG,SAAS,CAAC,KAAK,CAAC,EAAE,IAAI,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC;QAC/H,MAAM,aAAa,GAAG,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS;YAC9C,CAAC,CAAC,GAAG,SAAS,CAAC,cAAc,IAAI,oBAAoB,GAAG,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,oBAAoB,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;QACjJ,MAAM,WAAW,GAAG,KAAK,EAAE,WAAW,IAAI,MAAM,EAAE,OAAO,EAAE,YAAY,IAAI,IAAI,CAAC;QAChF,OAAO;YACL,OAAO,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,IAAI,IAAI;gBAC1I,GAAG,CAAC,aAAa,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE;YAC7D,OAAO,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;gBAC3K,WAAW,EAAE,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE;SAC3K,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,MAAM,CAAC,OAAqB,EAAE,MAAc;QACxD,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAC5B,MAAM,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvC,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC,EAAE,IAAI,IAAI,CAAC;QACpF,MAAM,QAAQ,GAAG,iBAAiB,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;QAClK,MAAM,MAAM,GAAG,QAAQ,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAE,CAAC;QAC1E,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,EAAE,CAAC;YAC/B,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;YACtI,OAAO,IAAI,CAAC;QACd,CAAC;QACD,MAAM,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAE,CAAC;QACtD,MAAM,QAAQ,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,MAAO,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,EAAW,CAAC;QAC/H,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC;YACnE,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,QAAkB,CAAC;QACvB,IAAI,CAAC;YAAC,QAAQ,GAAG,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;QAAC,CAAC;QACnJ,OAAO,KAAK,EAAE,CAAC;YAAC,QAAQ,GAAG,CAAC,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,oBAAoB,CAAC,CAAC;QAAC,CAAC;QAC7F,IAAI,QAAQ,CAAC,MAAM,EAAE,CAAC;YACpB,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK;gBAC/E,OAAO,EAAE,gBAAgB,WAAW,CAAC,MAAM,CAAC,sBAAsB,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,4BAA4B,EAAE,CAAC,CAAC;YACrI,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,QAAQ,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC;QACpE,OAAO,IAAI,CAAC;IACd,CAAC;CACF;AAED,uFAAuF;AACvF,MAAM,MAAM,GAAG,CAAC,UAAyB,EAAU,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,GAAG,YAAY,CAAC,EAAE,KAAK,EAAE,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,OAAO,EAAE;QACxI,GAAG,CAAC,UAAU,CAAC,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,WAAW,EAAE,CAAC;QACpF,GAAG,CAAC,UAAU,CAAC,YAAY,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,YAAY,EAAE,UAAU,CAAC,YAAY,EAAE,CAAC;KACvF,EAAE,CAAC,EAAE,CAAC;AAEP,2GAA2G;AAC3G,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,QAAqB,EAAU,EAAE;IAC9D,MAAM,IAAI,GAAG,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACrD,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;QACtB,KAAK,OAAO;YACV,OAAO,CAAC,GAAG,IAAI,aAAa,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,YAAY,CAAC,QAAQ,CAAC,eAAe,CAAC,kBAAkB,QAAQ,CAAC,SAAS,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,iCAAiC,CAAC,CAAC,CAAC,EAAE,GAAG;gBACxO,GAAG,QAAQ,CAAC,SAAS,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACxH,KAAK,MAAM;YACT,OAAO,QAAQ,CAAC,MAAM,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE;gBACtF,CAAC,CAAC,GAAG,IAAI,IAAI,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;QACpH,KAAK,QAAQ;YACX,OAAO,GAAG,IAAI,IAAI,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,UAAU,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,QAAQ,CAAC,MAAM,EAAE,CAAC;QAClK,KAAK,OAAO;YACV,OAAO,GAAG,IAAI,IAAI,QAAQ,CAAC,KAAK,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;IAChE,CAAC;AACH,CAAC,CAAC"}

package/dist_ts/classes.watchlock.d.ts

@@ -0,0 +1,33 @@
+/** Another watch holds the lock. */
+export declare class WatchBusyError extends Error {
+    readonly pid: number;
+    constructor(pid: number, fileArg: string);
+}
+export interface IWatchLockOptions {
+    /** The pid the lock names; this process by default. */
+    pid?: number;
+    /** Whether a process with this pid exists; a pid owned by another user counts as existing. */
+    isAlive?: (pidArg: number) => boolean;
+}
+/**
+ * The single watch of one authswitch home: `<home>/watch.lock`, naming the pid that holds it.
+ *
+ * The lock file is created by hard-linking a complete file into place, so it never exists half-written and a second
+ * watch always reads a pid. A lock whose process no longer exists is left over from a watch that died and is taken
+ * over; the stale file is removed only while it still holds exactly what was judged stale. A lock another watch in
+ * this same process holds is never taken over.
+ */
+export declare class WatchLock {
+    private readonly home;
+    readonly file: string;
+    private readonly pid;
+    private readonly isAlive;
+    private content;
+    constructor(home: string, optionsArg?: IWatchLockOptions);
+    private read;
+    private static holder;
+    /** Takes the lock, or throws `WatchBusyError` naming the running watch. */
+    acquire(): void;
+    /** Releases the lock if this watch still holds it; a lock another watch took over is left alone. */
+    release(): void;
+}

package/dist_ts/classes.watchlock.js

@@ -0,0 +1,118 @@
+import * as plugins from './plugins.js';
+import { errorCode } from './helpers.js';
+/** Another watch holds the lock. */
+export class WatchBusyError extends Error {
+    pid;
+    constructor(pid, fileArg) {
+        super(`Another authswitch watch is running (pid ${pid}). If it is not, remove ${fileArg}.`);
+        this.pid = pid;
+    }
+}
+const processExists = (pidArg) => {
+    try {
+        process.kill(pidArg, 0);
+        return true;
+    }
+    catch (error) {
+        return errorCode(error) === 'EPERM';
+    }
+};
+/**
+ * The lock files this process holds.
+ *
+ * A lock naming this process's own pid is otherwise taken over, because a process that died can have its pid reused
+ * by the one that replaces it. While a watch in this process still holds the lock, that reasoning does not apply,
+ * and a second watch must be refused like any other.
+ */
+const heldFiles = new Set();
+/**
+ * The single watch of one authswitch home: `<home>/watch.lock`, naming the pid that holds it.
+ *
+ * The lock file is created by hard-linking a complete file into place, so it never exists half-written and a second
+ * watch always reads a pid. A lock whose process no longer exists is left over from a watch that died and is taken
+ * over; the stale file is removed only while it still holds exactly what was judged stale. A lock another watch in
+ * this same process holds is never taken over.
+ */
+export class WatchLock {
+    home;
+    file;
+    pid;
+    isAlive;
+    content = null;
+    constructor(home, optionsArg = {}) {
+        this.home = home;
+        this.file = plugins.path.join(home, 'watch.lock');
+        this.pid = optionsArg.pid ?? process.pid;
+        this.isAlive = optionsArg.isAlive ?? processExists;
+    }
+    read() {
+        try {
+            return plugins.fs.readFileSync(this.file, 'utf8');
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT')
+                return null;
+            throw error;
+        }
+    }
+    static holder(contentArg) {
+        try {
+            const pid = JSON.parse(contentArg).pid;
+            return typeof pid === 'number' && Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Takes the lock, or throws `WatchBusyError` naming the running watch. */
+    acquire() {
+        if (this.content !== null)
+            throw new Error('This watch already holds its lock.');
+        if (heldFiles.has(this.file))
+            throw new WatchBusyError(this.pid, this.file);
+        plugins.fs.mkdirSync(this.home, { recursive: true, mode: 0o700 });
+        const content = `${JSON.stringify({ pid: this.pid, startedAt: new Date().toISOString() })}\n`;
+        const candidate = `${this.file}.${this.pid}`;
+        plugins.fs.writeFileSync(candidate, content, { mode: 0o600 });
+        try {
+            // One attempt, and one more after removing a stale lock; a watch that took it over in between wins.
+            for (let attempt = 0; attempt < 2; attempt++) {
+                try {
+                    plugins.fs.linkSync(candidate, this.file);
+                    this.content = content;
+                    heldFiles.add(this.file);
+                    return;
+                }
+                catch (error) {
+                    if (errorCode(error) !== 'EEXIST')
+                        throw error;
+                }
+                const existing = this.read();
+                if (existing === null)
+                    continue;
+                const holder = WatchLock.holder(existing);
+                if (holder !== null && holder !== this.pid && this.isAlive(holder))
+                    throw new WatchBusyError(holder, this.file);
+                if (this.read() === existing)
+                    plugins.fs.rmSync(this.file, { force: true });
+            }
+            const holder = WatchLock.holder(this.read() ?? '');
+            if (holder !== null)
+                throw new WatchBusyError(holder, this.file);
+            throw new Error(`The watch lock ${this.file} could not be taken. Try again.`);
+        }
+        finally {
+            plugins.fs.rmSync(candidate, { force: true });
+        }
+    }
+    /** Releases the lock if this watch still holds it; a lock another watch took over is left alone. */
+    release() {
+        if (this.content === null)
+            return;
+        heldFiles.delete(this.file);
+        if (this.read() === this.content)
+            plugins.fs.rmSync(this.file, { force: true });
+        this.content = null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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