light-plan 0.0.0-stage → 0.1.0

package/dist/core/storage/local.js

@@ -0,0 +1,133 @@
+import { appendFileSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { writeFileAtomic } from './atomic.js';
+import { CREDENTIALS_FILE, LOCAL_FILE, LOCK_FILE, expandHome } from './paths.js';
+const EMPTY = { user: null, profile: null };
+/** Overrides the stored user; handy for CI and shared machines. */
+export const USER_ENV_VAR = 'LPM_USER';
+/** Overrides the stored profile path, for a shell that serves one developer. */
+export const PROFILE_ENV_VAR = 'LPM_PROFILE';
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+export function readLocal(paths) {
+    try {
+        const parsed = JSON.parse(readFileSync(paths.localPath, 'utf8'));
+        return { user: text(parsed.user), profile: text(parsed.profile) };
+    }
+    catch {
+        return { ...EMPTY };
+    }
+}
+export function writeLocal(paths, settings) {
+    writeFileAtomic(paths.localPath, `${JSON.stringify(settings, null, 2)}\n`);
+    ensureLocalIgnored(paths);
+}
+/**
+ * Whoever the CLI should act as, as written (an id or a name — the caller
+ * resolves it against the roster). The environment wins over the stored value.
+ */
+export function currentUserRef(paths) {
+    const fromEnv = process.env[USER_ENV_VAR]?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return readLocal(paths).user;
+}
+/**
+ * The profile file to use, as written, and where that answer came from. The
+ * environment wins, so one shell can serve a different developer than the
+ * checkout is set up for.
+ */
+export function profileRef(paths) {
+    const fromEnv = process.env[PROFILE_ENV_VAR]?.trim();
+    if (fromEnv)
+        return { ref: fromEnv, source: 'env' };
+    const stored = readLocal(paths).profile;
+    return stored ? { ref: stored, source: 'local' } : null;
+}
+/**
+ * A stored path, made absolute. `~` is expanded because a profile is a file a
+ * developer keeps in their home directory as often as in the repository, and
+ * anything relative is resolved against the board root rather than the cwd, so
+ * `lpm` gives the same answer from any folder in the checkout.
+ */
+export function resolveProfilePath(paths, ref) {
+    return path.resolve(paths.root, expandHome(ref));
+}
+/** Pattern for credential files under `.lpm/remotes/` — never commit these. */
+const CREDENTIALS_PATTERN = 'remotes/*/credentials*';
+/**
+ * The entries `.lpm/.gitignore` must carry, each with the comment that
+ * precedes it. One source of truth so the heal (`ensureLocalIgnored`) and the
+ * check (`checkGitignore`) cannot drift about what belongs in the file.
+ */
+const IGNORED_ENTRIES = [
+    { comment: '# Per-checkout settings (current user)', entries: [LOCAL_FILE] },
+    {
+        comment: '# Remote credentials (never commit these)',
+        entries: [CREDENTIALS_FILE, CREDENTIALS_PATTERN],
+    },
+    {
+        comment: '# Write lock, held only while a change is in flight',
+        entries: [LOCK_FILE, `${LOCK_FILE}.stale.*`],
+    },
+];
+/** The trimmed lines of `.lpm/.gitignore`, or [] when the file is absent. */
+function gitignoreLines(paths) {
+    try {
+        return readFileSync(path.join(paths.lpmDir, '.gitignore'), 'utf8')
+            .split(/\r?\n/)
+            .map((line) => line.trim());
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The ignore entries this board's `.lpm/.gitignore` is still missing, in the
+ * order they should appear. The read-only half of `ensureLocalIgnored`; the
+ * check reports from this, and the fix calls the writer.
+ */
+export function missingIgnoredEntries(paths) {
+    const lines = gitignoreLines(paths);
+    const missing = [];
+    for (const group of IGNORED_ENTRIES) {
+        for (const entry of group.entries) {
+            if (!lines.includes(entry))
+                missing.push(entry);
+        }
+    }
+    return missing;
+}
+/**
+ * Add `local.json`, the credentials file, the write lock and remote credential
+ * patterns to `.lpm/.gitignore`. Returns true if the file changed.
+ */
+export function ensureLocalIgnored(paths) {
+    const file = path.join(paths.lpmDir, '.gitignore');
+    let text = '';
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch {
+        // No .gitignore in the board yet; we create it below.
+    }
+    const lines = text.split(/\r?\n/).map((l) => l.trim());
+    const additions = [];
+    for (const group of IGNORED_ENTRIES) {
+        const missing = group.entries.filter((entry) => !lines.includes(entry));
+        if (missing.length === 0)
+            continue;
+        // A group written over two versions should not grow a second heading: the
+        // comment is only added when it is not already in the file.
+        if (!lines.includes(group.comment))
+            additions.push(group.comment);
+        additions.push(...missing, '');
+    }
+    if (additions.length === 0)
+        return false;
+    const separator = text === '' ? '' : text.endsWith('\n') ? '' : '\n';
+    appendFileSync(file, `${separator}${additions.join('\n')}`, 'utf8');
+    return true;
+}
+//# sourceMappingURL=local.js.map

package/dist/core/storage/local.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local.js","sourceRoot":"","sources":["../../../src/core/storage/local.ts"],"names":[],"mappings":"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"}

package/dist/core/storage/lock.d.ts

@@ -0,0 +1,85 @@
+import type { BoardPaths } from './paths.js';
+/**
+ * The board lock: one writer at a time, across processes.
+ *
+ * `atomic.ts` stops a reader seeing half a document. This stops two writers
+ * taking turns *inside* one another — the read-modify-write that every
+ * operation is. Without it two agents both load the board, both see `LP-12`
+ * unassigned, both write it, and the second one wins with no trace that the
+ * first ever claimed anything. With it they queue, and the loser reads what the
+ * winner wrote before deciding what to do (`operations/claim.ts` is the worked
+ * example).
+ *
+ * It is a file, because the board is a folder and there is nothing else to be:
+ * `.lpm/lock`, created with `O_EXCL` so exactly one process can make it, holding
+ * a JSON record of who has it and what they are doing. Git-ignored, like
+ * `local.json` — which process is mid-write is not a property of the plan.
+ * Nothing here writes that `.gitignore` entry: `init` puts it there and `check`
+ * reports a board that predates it, which is where derived, repairable state
+ * belongs. A lock primitive with a side effect on the repository would be a
+ * surprise in the one place a surprise is least affordable.
+ *
+ * Four things it has to get right:
+ *
+ * **Held for the write, never for the work.** An agent may spend twenty minutes
+ * on a task; it holds the lock for the milliseconds it takes to record that it
+ * started. A lock scoped to anything longer would be a queue of one.
+ *
+ * **Re-entrant.** Operations call each other — `flagIssue` writes a document and
+ * then a comment, `claimIssue` delegates to `moveNode` — so a nested acquire by
+ * the same process counts up rather than deadlocking.
+ *
+ * **A dead holder does not stop the board — but a live one is never robbed.**
+ * A process killed mid-operation would otherwise leave its lock behind, and a
+ * plan nobody can write to because of a crash last Tuesday is worse than the
+ * race. The cheap answer to that is "break a lock whose pid is not running",
+ * and it is wrong: see `isStale`, which is where the hard-won half of this file
+ * lives. Instead an interrupted process gives the lock up on its way out
+ * (`releaseOnExit`), and a lock is only ever broken for being *old*.
+ *
+ * **Say what it does not do.** Breaking a stale lock cannot be made perfectly
+ * safe without a filesystem primitive nobody has: two processes can decide the
+ * same lock is dead, and the second may unlink a lock a third has just taken.
+ * The rename-then-delete below makes the *breaker* unique, and the token
+ * check-back makes a robbed holder notice — but the real backstop is the stamp
+ * check in `operations/shared.ts`, which refuses a write whose document moved
+ * underneath it whether or not the lock behaved. Two lines of defence, because
+ * this one is advisory: nothing stops a text editor writing `_issue.md`.
+ */
+/** How long to wait for another process before giving up. */
+export declare const LOCK_TIMEOUT_ENV = "LPM_LOCK_TIMEOUT_MS";
+/** How old a lock has to be before it is assumed to be a crash. */
+export declare const LOCK_STALE_ENV = "LPM_LOCK_STALE_MS";
+/**
+ * Skip locking entirely. The escape hatch for a filesystem where `O_EXCL` does
+ * not mean what it says — some network mounts — on which every command would
+ * otherwise fail. It removes the first line of defence and leaves the second:
+ * a stale write is still refused. Documented rather than hidden, for the same
+ * reason `--unsafe` is.
+ */
+export declare const LOCK_DISABLE_ENV = "LPM_NO_LOCK";
+/** Who holds the lock, and what they are doing with it. */
+export interface LockHolder {
+    pid: number;
+    host: string;
+    /** The account the process runs as, so a message names somebody. */
+    user: string;
+    /** What it is doing — "claim LP-12", "push 14 changes". */
+    op: string;
+    /** ISO timestamp of the acquisition. */
+    at: string;
+    /**
+     * Random token for this acquisition. A holder writes it and reads it back,
+     * which is how it finds out that somebody broke its lock and took over.
+     */
+    nonce: string;
+}
+/** Read the record of whoever holds the lock, or null when there is nothing readable. */
+export declare function readLockHolder(file: string): LockHolder | null;
+/**
+ * Run `fn` as the board's only writer.
+ *
+ * `op` is what to tell whoever is waiting — short, and naming the document when
+ * there is one ("claim LP-12" reads better than "moveNode").
+ */
+export declare function withBoardLock<T>(paths: BoardPaths, op: string, fn: () => T): T;

package/dist/core/storage/lock.js

@@ -0,0 +1,364 @@
+import { randomBytes } from 'node:crypto';
+import { closeSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeSync } from 'node:fs';
+import { hostname, userInfo } from 'node:os';
+import path from 'node:path';
+import { BoardError } from '../errors.js';
+import { sleepSync } from './atomic.js';
+/**
+ * The board lock: one writer at a time, across processes.
+ *
+ * `atomic.ts` stops a reader seeing half a document. This stops two writers
+ * taking turns *inside* one another — the read-modify-write that every
+ * operation is. Without it two agents both load the board, both see `LP-12`
+ * unassigned, both write it, and the second one wins with no trace that the
+ * first ever claimed anything. With it they queue, and the loser reads what the
+ * winner wrote before deciding what to do (`operations/claim.ts` is the worked
+ * example).
+ *
+ * It is a file, because the board is a folder and there is nothing else to be:
+ * `.lpm/lock`, created with `O_EXCL` so exactly one process can make it, holding
+ * a JSON record of who has it and what they are doing. Git-ignored, like
+ * `local.json` — which process is mid-write is not a property of the plan.
+ * Nothing here writes that `.gitignore` entry: `init` puts it there and `check`
+ * reports a board that predates it, which is where derived, repairable state
+ * belongs. A lock primitive with a side effect on the repository would be a
+ * surprise in the one place a surprise is least affordable.
+ *
+ * Four things it has to get right:
+ *
+ * **Held for the write, never for the work.** An agent may spend twenty minutes
+ * on a task; it holds the lock for the milliseconds it takes to record that it
+ * started. A lock scoped to anything longer would be a queue of one.
+ *
+ * **Re-entrant.** Operations call each other — `flagIssue` writes a document and
+ * then a comment, `claimIssue` delegates to `moveNode` — so a nested acquire by
+ * the same process counts up rather than deadlocking.
+ *
+ * **A dead holder does not stop the board — but a live one is never robbed.**
+ * A process killed mid-operation would otherwise leave its lock behind, and a
+ * plan nobody can write to because of a crash last Tuesday is worse than the
+ * race. The cheap answer to that is "break a lock whose pid is not running",
+ * and it is wrong: see `isStale`, which is where the hard-won half of this file
+ * lives. Instead an interrupted process gives the lock up on its way out
+ * (`releaseOnExit`), and a lock is only ever broken for being *old*.
+ *
+ * **Say what it does not do.** Breaking a stale lock cannot be made perfectly
+ * safe without a filesystem primitive nobody has: two processes can decide the
+ * same lock is dead, and the second may unlink a lock a third has just taken.
+ * The rename-then-delete below makes the *breaker* unique, and the token
+ * check-back makes a robbed holder notice — but the real backstop is the stamp
+ * check in `operations/shared.ts`, which refuses a write whose document moved
+ * underneath it whether or not the lock behaved. Two lines of defence, because
+ * this one is advisory: nothing stops a text editor writing `_issue.md`.
+ */
+/** How long to wait for another process before giving up. */
+export const LOCK_TIMEOUT_ENV = 'LPM_LOCK_TIMEOUT_MS';
+/** How old a lock has to be before it is assumed to be a crash. */
+export const LOCK_STALE_ENV = 'LPM_LOCK_STALE_MS';
+/**
+ * Skip locking entirely. The escape hatch for a filesystem where `O_EXCL` does
+ * not mean what it says — some network mounts — on which every command would
+ * otherwise fail. It removes the first line of defence and leaves the second:
+ * a stale write is still refused. Documented rather than hidden, for the same
+ * reason `--unsafe` is.
+ */
+export const LOCK_DISABLE_ENV = 'LPM_NO_LOCK';
+const DEFAULT_TIMEOUT_MS = 10_000;
+/**
+ * Deliberately generous. It is the only thing standing between a live holder
+ * and having its lock taken away, so it has to exceed the longest legitimate
+ * hold — a push of a few hundred changes reloads the board between each one —
+ * rather than be tuned to make recovery from a crash feel quick.
+ */
+const DEFAULT_STALE_MS = 120_000;
+/** How long to wait between attempts. Short: a hold is milliseconds. */
+const POLL_MS = 20;
+function positiveEnv(name, fallback) {
+    const raw = process.env[name]?.trim();
+    if (!raw)
+        return fallback;
+    const value = Number(raw);
+    return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function disabled() {
+    const raw = process.env[LOCK_DISABLE_ENV]?.trim().toLowerCase();
+    return raw === '1' || raw === 'true' || raw === 'yes';
+}
+function whoami() {
+    try {
+        return userInfo().username;
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/** Read the record of whoever holds the lock, or null when there is nothing readable. */
+export function readLockHolder(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, 'utf8'));
+        if (typeof parsed.pid !== 'number' || typeof parsed.nonce !== 'string')
+            return null;
+        return {
+            pid: parsed.pid,
+            host: typeof parsed.host === 'string' ? parsed.host : '',
+            user: typeof parsed.user === 'string' ? parsed.user : 'unknown',
+            op: typeof parsed.op === 'string' ? parsed.op : 'something',
+            at: typeof parsed.at === 'string' ? parsed.at : '',
+            nonce: parsed.nonce,
+        };
+    }
+    catch {
+        // Missing, unparseable, or caught between the create and the write. The
+        // caller decides which, by watching how long it stays that way.
+        return null;
+    }
+}
+function ageOf(holder) {
+    const at = Date.parse(holder.at);
+    // A record with no usable timestamp is treated as brand new, so it expires by
+    // the pid check or not at all — guessing "ancient" would break live locks.
+    return Number.isFinite(at) ? Date.now() - at : 0;
+}
+/**
+ * Whether a lock may be taken away from whoever wrote it.
+ *
+ * **Age, and nothing else.** The obvious extra test — "is that pid still
+ * running?" — was here and had to come out: `process.kill(pid, 0)` returns
+ * `ESRCH` for processes that are demonstrably alive, often enough to matter as
+ * soon as a machine is loaded, and a false "dead" does not degrade the lock, it
+ * *deletes* it. Eight concurrent `lpm new` calls on one board produced duplicate
+ * ids exactly this way: one process judged the live holder dead, broke its lock,
+ * and both read the same id counter. A false "alive" costs a wait; a false
+ * "dead" costs the guarantee. There is no version of that trade worth taking, so
+ * liveness is not consulted at all.
+ *
+ * What is left is a clock, which is why `staleMs` has to be longer than the
+ * longest honest hold — a whole push, a whole `check --fix` — rather than
+ * tuned down to make crash recovery snappy. Crash recovery is instead handled
+ * where it belongs: a process that is interrupted releases the lock on its way
+ * out (see `releaseOnExit`), so the window only matters for a kill nothing can
+ * catch.
+ */
+function isStale(holder, staleMs) {
+    return ageOf(holder) > staleMs;
+}
+/**
+ * Take a lock away from a holder judged dead.
+ *
+ * Renaming first is what makes the breaker unique: two processes can both
+ * decide the lock is stale, but only one of them can rename the file, and the
+ * other gets `ENOENT` and goes back to competing for a fresh one.
+ */
+function breakLock(file) {
+    const victim = `${file}.stale.${randomBytes(4).toString('hex')}`;
+    try {
+        renameSync(file, victim);
+    }
+    catch {
+        // Somebody else broke it first, or it was released while we deliberated.
+        return;
+    }
+    try {
+        rmSync(victim, { force: true });
+    }
+    catch {
+        // The record is out of the way, which is all that was needed.
+    }
+}
+/**
+ * Errors from the exclusive create that mean "somebody else has it this
+ * instant", not "this can never work".
+ *
+ * `EEXIST` is the honest one and the only one on a POSIX filesystem. The rest
+ * are Windows: a file another process has just unlinked stays in a
+ * *delete-pending* state until its last handle closes, and creating over it
+ * returns `ERROR_ACCESS_DENIED`, which libuv reports as `EPERM` — so the
+ * ordinary case of "the previous holder released a millisecond ago" arrives
+ * here looking like a permissions failure. Letting it out of the loop turned a
+ * lost race into a crashed command under load. A genuinely unwritable board
+ * still fails, but as a timeout that names the code rather than as a stack
+ * trace, which is the difference between waiting and giving up.
+ */
+const CONTENDED = new Set(['EEXIST', 'EPERM', 'EACCES', 'EBUSY']);
+/** What the last failed create said, so a timeout can name it. */
+let lastCreateError = null;
+/** Create the lock file, or report that somebody already has. */
+function tryCreate(file, holder) {
+    let fd;
+    try {
+        fd = openSync(file, 'wx');
+    }
+    catch (error) {
+        const code = error.code ?? '';
+        if (code === 'ENOENT') {
+            // The board folder is not there yet (a board being created). Make it and
+            // let the next turn of the loop try again.
+            mkdirSync(path.dirname(file), { recursive: true });
+            return false;
+        }
+        if (CONTENDED.has(code)) {
+            lastCreateError = code;
+            return false;
+        }
+        throw error;
+    }
+    lastCreateError = null;
+    try {
+        writeSync(fd, JSON.stringify(holder));
+    }
+    finally {
+        closeSync(fd);
+    }
+    // Read it back: if a process that had judged this board's previous lock stale
+    // broke ours between the create and now, the token will not be the one we
+    // wrote, and we do not hold what we think we hold.
+    return readLockHolder(file)?.nonce === holder.nonce;
+}
+function timedOut(file, op, timeoutMs) {
+    const holder = readLockHolder(file);
+    const seconds = Math.round(timeoutMs / 100) / 10;
+    return new BoardError(holder
+        ? `The board is busy: ${holder.user} is doing "${holder.op}" (pid ${holder.pid} on ${holder.host || 'this machine'})`
+        : 'The board is busy and did not come free', [
+        `Gave up waiting after ${seconds}s to ${op}.`,
+        'Another person, agent or editor is part-way through a change. Try again in a moment.',
+        `If nothing is running, delete ${file} — it is a leftover lock, and nothing on the board depends on it.`,
+        // A board nobody can write to at all reads exactly like a busy one from
+        // in here, so say which it was rather than leaving somebody to guess.
+        ...(holder === null && lastCreateError
+            ? [`The lock file could not be created either (${lastCreateError}); check the folder is writable.`]
+            : []),
+    ]);
+}
+/**
+ * Depth of nesting per lock file, so an operation that calls another operation
+ * does not deadlock against itself. Keyed by path rather than by board, because
+ * two `BoardPaths` objects for the same folder are the same lock.
+ */
+const held = new Map();
+/**
+ * Run `fn` as the board's only writer.
+ *
+ * `op` is what to tell whoever is waiting — short, and naming the document when
+ * there is one ("claim LP-12" reads better than "moveNode").
+ */
+export function withBoardLock(paths, op, fn) {
+    if (disabled())
+        return fn();
+    const file = paths.lockPath;
+    const entry = held.get(file);
+    if (entry) {
+        entry.depth += 1;
+        try {
+            return fn();
+        }
+        finally {
+            entry.depth -= 1;
+            if (entry.depth === 0)
+                held.delete(file);
+        }
+    }
+    const timeoutMs = positiveEnv(LOCK_TIMEOUT_ENV, DEFAULT_TIMEOUT_MS);
+    const staleMs = positiveEnv(LOCK_STALE_ENV, DEFAULT_STALE_MS);
+    const nonce = randomBytes(8).toString('hex');
+    const holder = {
+        pid: process.pid,
+        host: hostname(),
+        user: whoami(),
+        op,
+        at: new Date().toISOString(),
+        nonce,
+    };
+    acquire(file, holder, timeoutMs, staleMs, op);
+    held.set(file, { depth: 1, nonce });
+    const stopWatching = releaseOnExit(file, nonce);
+    try {
+        return fn();
+    }
+    finally {
+        const current = held.get(file);
+        if (current) {
+            current.depth -= 1;
+            if (current.depth === 0) {
+                held.delete(file);
+                stopWatching();
+                release(file, nonce);
+            }
+        }
+    }
+}
+/**
+ * Give the lock up if this process is interrupted while holding it.
+ *
+ * Without this, Ctrl-C during any write leaves a lock behind and the board
+ * refuses every change until it ages out — and since `isStale` is a clock and
+ * nothing else, that wait is long by design. A `finally` does not cover it:
+ * Node's default `SIGINT` handling terminates the process without unwinding.
+ * So while the lock is held, and only then, the two catchable signals are
+ * intercepted, the lock released, and the signal re-raised with the default
+ * behaviour so the process still dies the way the caller asked it to.
+ *
+ * Returns the function that takes the handlers off again.
+ */
+function releaseOnExit(file, nonce) {
+    const onExit = () => release(file, nonce);
+    const onSignal = (signal) => {
+        release(file, nonce);
+        process.removeListener('exit', onExit);
+        process.removeListener('SIGINT', onSignal);
+        process.removeListener('SIGTERM', onSignal);
+        // Re-raise with no listener left, so the default action applies and the
+        // exit code says what actually happened.
+        process.kill(process.pid, signal);
+    };
+    process.once('exit', onExit);
+    process.once('SIGINT', onSignal);
+    process.once('SIGTERM', onSignal);
+    return () => {
+        process.removeListener('exit', onExit);
+        process.removeListener('SIGINT', onSignal);
+        process.removeListener('SIGTERM', onSignal);
+    };
+}
+function acquire(file, holder, timeoutMs, staleMs, op) {
+    const deadline = Date.now() + timeoutMs;
+    /** When we first saw a lock file we could not read, for the same expiry. */
+    let unreadableSince = null;
+    for (;;) {
+        if (tryCreate(file, holder))
+            return;
+        const current = readLockHolder(file);
+        if (current) {
+            unreadableSince = null;
+            if (isStale(current, staleMs)) {
+                breakLock(file);
+                continue;
+            }
+        }
+        else {
+            // Either a lock caught between its create and its write — microseconds —
+            // or a record something truncated. Time decides which.
+            unreadableSince ??= Date.now();
+            if (Date.now() - unreadableSince > staleMs) {
+                breakLock(file);
+                unreadableSince = null;
+                continue;
+            }
+        }
+        if (Date.now() >= deadline)
+            throw timedOut(file, op, timeoutMs);
+        sleepSync(POLL_MS);
+    }
+}
+/** Give the lock up, unless somebody broke it and it is no longer ours to give. */
+function release(file, nonce) {
+    if (readLockHolder(file)?.nonce !== nonce)
+        return;
+    try {
+        rmSync(file, { force: true });
+    }
+    catch {
+        // Already gone. Nothing on the board depends on the file existing.
+    }
+}
+//# sourceMappingURL=lock.js.map

package/dist/core/storage/lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../../src/core/storage/lock.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACtG,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,6DAA6D;AAC7D,MAAM,CAAC,MAAM,gBAAgB,GAAG,qBAAqB,CAAC;AACtD,mEAAmE;AACnE,MAAM,CAAC,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAClD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,aAAa,CAAC;AAE9C,MAAM,kBAAkB,GAAG,MAAM,CAAC;AAClC;;;;;GAKG;AACH,MAAM,gBAAgB,GAAG,OAAO,CAAC;AACjC,wEAAwE;AACxE,MAAM,OAAO,GAAG,EAAE,CAAC;AAmBnB,SAAS,WAAW,CAAC,IAAY,EAAE,QAAgB;IACjD,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC;IACtC,IAAI,CAAC,GAAG;QAAE,OAAO,QAAQ,CAAC;IAC1B,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,OAAO,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC;AAChE,CAAC;AAED,SAAS,QAAQ;IACf,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,EAAE,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;IAChE,OAAO,GAAG,KAAK,GAAG,IAAI,GAAG,KAAK,MAAM,IAAI,GAAG,KAAK,KAAK,CAAC;AACxD,CAAC;AAED,SAAS,MAAM;IACb,IAAI,CAAC;QACH,OAAO,QAAQ,EAAE,CAAC,QAAQ,CAAC;IAC7B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC;AAED,yFAAyF;AACzF,MAAM,UAAU,cAAc,CAAC,IAAY;IACzC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,CAAC,CAAwB,CAAC;QAC7E,IAAI,OAAO,MAAM,CAAC,GAAG,KAAK,QAAQ,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC;QACpF,OAAO;YACL,GAAG,EAAE,MAAM,CAAC,GAAG;YACf,IAAI,EAAE,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE;YACxD,IAAI,EAAE,OAAO,MAAM,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;YAC/D,EAAE,EAAE,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW;YAC3D,EAAE,EAAE,OAAO,MAAM,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;YAClD,KAAK,EAAE,MAAM,CAAC,KAAK;SACpB,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,wEAAwE;QACxE,gEAAgE;QAChE,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,KAAK,CAAC,MAAkB;IAC/B,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACjC,8EAA8E;IAC9E,2EAA2E;IAC3E,OAAO,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;AACnD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAS,OAAO,CAAC,MAAkB,EAAE,OAAe;IAClD,OAAO,KAAK,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC;AACjC,CAAC;AAED;;;;;;GAMG;AACH,SAAS,SAAS,CAAC,IAAY;IAC7B,MAAM,MAAM,GAAG,GAAG,IAAI,UAAU,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;IACjE,IAAI,CAAC;QACH,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC3B,CAAC;IAAC,MAAM,CAAC;QACP,yEAAyE;QACzE,OAAO;IACT,CAAC;IACD,IAAI,CAAC;QACH,MAAM,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAClC,CAAC;IAAC,MAAM,CAAC;QACP,8DAA8D;IAChE,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAC;AAElE,kEAAkE;AAClE,IAAI,eAAe,GAAkB,IAAI,CAAC;AAE1C,iEAAiE;AACjE,SAAS,SAAS,CAAC,IAAY,EAAE,MAAkB;IACjD,IAAI,EAAU,CAAC;IACf,IAAI,CAAC;QACH,EAAE,GAAG,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC5B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,GAAI,KAA+B,CAAC,IAAI,IAAI,EAAE,CAAC;QACzD,IAAI,IAAI,KAAK,QAAQ,EAAE,CAAC;YACtB,yEAAyE;YACzE,2CAA2C;YAC3C,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YACnD,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACxB,eAAe,GAAG,IAAI,CAAC;YACvB,OAAO,KAAK,CAAC;QACf,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;IACD,eAAe,GAAG,IAAI,CAAC;IACvB,IAAI,CAAC;QACH,SAAS,CAAC,EAAE,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IACxC,CAAC;YAAS,CAAC;QACT,SAAS,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC;IACD,8EAA8E;IAC9E,0EAA0E;IAC1E,mDAAmD;IACnD,OAAO,cAAc,CAAC,IAAI,CAAC,EAAE,KAAK,KAAK,MAAM,CAAC,KAAK,CAAC;AACtD,CAAC;AAED,SAAS,QAAQ,CAAC,IAAY,EAAE,EAAU,EAAE,SAAiB;IAC3D,MAAM,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACpC,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,GAAG,CAAC,GAAG,EAAE,CAAC;IACjD,OAAO,IAAI,UAAU,CACnB,MAAM;QACJ,CAAC,CAAC,sBAAsB,MAAM,CAAC,IAAI,cAAc,MAAM,CAAC,EAAE,UAAU,MAAM,CAAC,GAAG,OAAO,MAAM,CAAC,IAAI,IAAI,cAAc,GAAG;QACrH,CAAC,CAAC,yCAAyC,EAC7C;QACE,yBAAyB,OAAO,QAAQ,EAAE,GAAG;QAC7C,sFAAsF;QACtF,iCAAiC,IAAI,mEAAmE;QACxG,wEAAwE;QACxE,sEAAsE;QACtE,GAAG,CAAC,MAAM,KAAK,IAAI,IAAI,eAAe;YACpC,CAAC,CAAC,CAAC,8CAA8C,eAAe,kCAAkC,CAAC;YACnG,CAAC,CAAC,EAAE,CAAC;KACR,CACF,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,IAAI,GAAG,IAAI,GAAG,EAA4C,CAAC;AAEjE;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAI,KAAiB,EAAE,EAAU,EAAE,EAAW;IACzE,IAAI,QAAQ,EAAE;QAAE,OAAO,EAAE,EAAE,CAAC;IAE5B,MAAM,IAAI,GAAG,KAAK,CAAC,QAAQ,CAAC;IAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC7B,IAAI,KAAK,EAAE,CAAC;QACV,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;QACjB,IAAI,CAAC;YACH,OAAO,EAAE,EAAE,CAAC;QACd,CAAC;gBAAS,CAAC;YACT,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC;YACjB,IAAI,KAAK,CAAC,KAAK,KAAK,CAAC;gBAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,MAAM,SAAS,GAAG,WAAW,CAAC,gBAAgB,EAAE,kBAAkB,CAAC,CAAC;IACpE,MAAM,OAAO,GAAG,WAAW,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC;IAC9D,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7C,MAAM,MAAM,GAAe;QACzB,GAAG,EAAE,OAAO,CAAC,GAAG;QAChB,IAAI,EAAE,QAAQ,EAAE;QAChB,IAAI,EAAE,MAAM,EAAE;QACd,EAAE;QACF,EAAE,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;QAC5B,KAAK;KACN,CAAC;IAEF,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC;IAC9C,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACpC,MAAM,YAAY,GAAG,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAChD,IAAI,CAAC;QACH,OAAO,EAAE,EAAE,CAAC;IACd,CAAC;YAAS,CAAC;QACT,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,OAAO,EAAE,CAAC;YACZ,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC;YACnB,IAAI,OAAO,CAAC,KAAK,KAAK,CAAC,EAAE,CAAC;gBACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAClB,YAAY,EAAE,CAAC;gBACf,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACvB,CAAC;QACH,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,SAAS,aAAa,CAAC,IAAY,EAAE,KAAa;IAChD,MAAM,MAAM,GAAG,GAAS,EAAE,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,CAAC,MAAsB,EAAQ,EAAE;QAChD,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACrB,OAAO,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC3C,OAAO,CAAC,cAAc,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAC5C,wEAAwE;QACxE,yCAAyC;QACzC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;IACpC,CAAC,CAAC;IAEF,OAAO,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACjC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAElC,OAAO,GAAG,EAAE;QACV,OAAO,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACvC,OAAO,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC3C,OAAO,CAAC,cAAc,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;IAC9C,CAAC,CAAC;AACJ,CAAC;AAED,SAAS,OAAO,CACd,IAAY,EACZ,MAAkB,EAClB,SAAiB,EACjB,OAAe,EACf,EAAU;IAEV,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;IACxC,4EAA4E;IAC5E,IAAI,eAAe,GAAkB,IAAI,CAAC;IAE1C,SAAS,CAAC;QACR,IAAI,SAAS,CAAC,IAAI,EAAE,MAAM,CAAC;YAAE,OAAO;QAEpC,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,OAAO,EAAE,CAAC;YACZ,eAAe,GAAG,IAAI,CAAC;YACvB,IAAI,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC;gBAC9B,SAAS,CAAC,IAAI,CAAC,CAAC;gBAChB,SAAS;YACX,CAAC;QACH,CAAC;aAAM,CAAC;YACN,yEAAyE;YACzE,uDAAuD;YACvD,eAAe,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;YAC/B,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,eAAe,GAAG,OAAO,EAAE,CAAC;gBAC3C,SAAS,CAAC,IAAI,CAAC,CAAC;gBAChB,eAAe,GAAG,IAAI,CAAC;gBACvB,SAAS;YACX,CAAC;QACH,CAAC;QAED,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,QAAQ;YAAE,MAAM,QAAQ,CAAC,IAAI,EAAE,EAAE,EAAE,SAAS,CAAC,CAAC;QAChE,SAAS,CAAC,OAAO,CAAC,CAAC;IACrB,CAAC;AACH,CAAC;AAED,mFAAmF;AACnF,SAAS,OAAO,CAAC,IAAY,EAAE,KAAa;IAC1C,IAAI,cAAc,CAAC,IAAI,CAAC,EAAE,KAAK,KAAK,KAAK;QAAE,OAAO;IAClD,IAAI,CAAC;QACH,MAAM,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,mEAAmE;IACrE,CAAC;AACH,CAAC"}