@superblocksteam/vite-plugin-file-sync 2.0.156 → 2.0.157-next.0

package/dist/lock-service/index.d.ts

@@ -1,5 +1,5 @@
 import type { Tracer } from "@opentelemetry/api";
-import { TracedEventEmitter } from "@superblocksteam/shared";
+import { ConflictError, TracedEventEmitter } from "@superblocksteam/shared";
 import type { LockInfo } from "@superblocksteam/shared";
 import { type ErrorEventMap } from "../errors/error-handler.js";
 import type { AutoConnectingRpcClient } from "../server-rpc/index.js";
@@ -59,6 +59,15 @@ interface EventMap extends ErrorEventMap {
         }
     ];
 }
+/**
+ * The methods {@link LockService} reports as spans.
+ *
+ * `addTracingToMethods` matches by string, so an entry naming a method that no
+ * longer exists is dropped at runtime rather than failing to compile — tracing
+ * disappears and nothing says so. Exported so a test can assert every name here
+ * still resolves to a method.
+ */
+export declare const TRACED_LOCK_SERVICE_METHODS: readonly ["acquireLock", "releaseLock", "relinquishLock", "notifyClosedByServer", "checkAndUpdateLockIfPossible", "ensureLockForWrite", "shutdownAndExit", "restartInactivityTimer", "switchBranch"];
 export declare class LockService extends TracedEventEmitter<EventMap> {
     private readonly applicationId;
     private branchName;
@@ -67,11 +76,22 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
     private syncCallback;
     private waitForGenerationCompleteCallback;
     private onGatewayLivenessLapsed;
+    private onLockConflict;
     private _status;
     private _lockId;
     private _heartbeatTimeout;
     private _heartbeatGeneration;
     private _heartbeatStoppedForIdle;
+    private _lockGivenUp;
+    private _closedByServer;
+    /**
+     * True only while the last-chance sync of a session that is ending is in
+     * flight. That write is not gated on still holding the lock — see
+     * {@link ensureLockForWrite}.
+     */
+    private _flushingFinalWork;
+    /** The evaluation overlapping callers join rather than starting their own. */
+    private _inFlightLockEvaluation;
     private _inactivityTimeout;
     private _bufferPeriodTimeout;
     private _isRestarting;
@@ -80,9 +100,9 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
     private _rpcClient;
     private _inactivityThresholdMs;
     private _lockBufferMs;
-    private _startupConnectionTimeout;
-    private _startupConnectionTimeoutStartedAt;
-    private _startupConnectionTimeoutExpired;
+    /** In-flight acquisition kicked off by a client attaching, if any. */
+    private _clientLockAcquisition;
+    private readonly _lockOperationQueue;
     private _activityTracker;
     /** Gateway peer id -> when its liveness was last refreshed. */
     private readonly _gatewayLivenessByPeerId;
@@ -101,6 +121,15 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
      * same peer so Clark stops targeting a dead gateway.
      */
     setOnGatewayLivenessLapsed(callback: (peerId: string) => void): void;
+    /**
+     * Called when a client attached and somebody else already holds the lock.
+     *
+     * What a conflict means is the host's to decide, not this service's: a CLI
+     * with a person at it can describe the holder and offer a takeover, a
+     * sandbox can only write it down. This is the hook that used to be the
+     * `ConflictError` catch around the boot-time acquire.
+     */
+    setOnLockConflict(callback: (error: ConflictError) => Promise<void> | void): void;
     get status(): LockServiceStatus;
     private set status(value);
     get isLocked(): boolean;
@@ -110,19 +139,154 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
     get isRestarting(): boolean;
     get wasRecentlyActive(): boolean;
     get timeSinceLastActivity(): number | null;
+    /** Whether any client — a browser editor or a headless gateway peer — is here. */
+    private get hasAttachedClient();
+    /**
+     * A client attached and this pod has never held the lock: take it for them.
+     *
+     * The lock is a mutual-exclusion marker between clients, not a capability the
+     * pod needs in order to serve — no write path on either side gates on holding
+     * it. So it belongs to whoever is attached, and a pod that grabs it at boot
+     * only invents a state nobody wants: a lock held on behalf of nobody, which
+     * then needs a watchdog to clean up. Claiming it on attach makes that state
+     * unreachable instead.
+     *
+     * Deliberately narrower than {@link reclaimLockForActiveClient}: neither a
+     * lock this pod handed back nor one it was refused is taken here. A tab left
+     * open reconnects its socket on its own, so an attach is no evidence its user
+     * came back, and treating it as evidence would hand the app to somebody who
+     * walked away (APPS-4840).
+     */
+    private claimLockForFirstClient;
+    /**
+     * The client proved it is still there: take the lock if we do not have it.
+     *
+     * Driven by editor activity pings and by a gateway peer starting a turn —
+     * both are a client doing something, which is the evidence a lock we are not
+     * holding needs before it is worth asking for again.
+     *
+     * That includes a lock we were refused. A refusal is what happened to one
+     * attempt, not a mode this pod is stuck in: the other session ends, and the
+     * user sitting here still wants to edit. Without this a pod that lost one
+     * race could never take the lock again for the rest of its life — and since
+     * SABS hands running pods to the next caller, it would go on failing for
+     * people who had nothing to do with the race.
+     */
+    private reclaimLockForActiveClient;
+    /**
+     * Fire-and-forget by design: the sockets, pings and branch switches that ask
+     * for this have nothing to do with the answer.
+     *
+     * What keeps a retry from becoming a stream of 409s is the trigger, not the
+     * status: the only thing that asks repeatedly is the editor's activity ping,
+     * which the pod acts on solely while the user is genuinely active. A blocked
+     * session asks about as often as a held lock heartbeats; one nobody is
+     * sitting at goes quiet on its own.
+     */
+    private acquireLockForAttachedClient;
+    /**
+     * Record an acquisition so anything that settles can see it.
+     *
+     * Every source goes through here — a client attaching, an activity ping, a
+     * force takeover, the reacquire after a heartbeat grab misses, a branch
+     * switch. Tracking only the attach path left the others invisible:
+     * `isLockedWhenSettled` would answer "no lock" for one that was an rpc away
+     * from landing, and `relinquishLock` would find nothing to release and let
+     * the lock land on a pod that had already gone.
+     *
+     * What is stored is a swallowed copy. Callers of
+     * {@link settleClientLockAcquisition} only want the state to have stopped
+     * moving; a rejection surfacing as theirs would turn a refused lock into a
+     * failed disconnect. The promise handed back keeps its rejection for whoever
+     * asked for the lock.
+     */
+    private trackAcquisition;
+    /**
+     * Wait for an acquisition a client attach kicked off, if one is in flight.
+     *
+     * Anything that decides what to do about the lock has to do this first, or it
+     * decides on a half-known state. While the RPC is out `isLocked` is false and
+     * `_lockId` is unset, so a disconnect would "release" nothing and the lock
+     * would land moments later with nobody left to hold it for — and a branch
+     * switch would move on and leave it attached to the branch it came from.
+     *
+     * Never rejects: the acquisition's own catch has already handled failure.
+     */
+    private settleClientLockAcquisition;
+    /**
+     * Whether this pod holds the lock after attach and queued turn operations
+     * already in flight have settled. The synchronous getter remains the current
+     * state for status reporting.
+     */
+    isLockedWhenSettled(): Promise<boolean>;
     /**
-     * Check if the lock service is in a state where it can reacquire a lock.
-     * This happens when the lock was released, the dev server is still alive,
-     * and an editor is attached to reacquire it for.
+     * Nothing is awaiting the acquisition a client triggers, so this is where a
+     * failure stops: swallowing it here is what keeps a conflict from surfacing
+     * as an unhandled rejection. `acquireLock` has already logged it and moved
+     * the status to `FAILED_TO_ACQUIRE_LOCK`; the host is told separately because
+     * only it knows whether there is anyone to tell.
+     */
+    private reportLockConflict;
+    /**
+     * Serializes branch changes with lock acquisition and handback. Omitting
+     * `reacquireLock` preserves the lock state observed inside that operation.
      */
-    get canReacquireLock(): boolean;
     switchBranch(nextBranchName: string, options?: {
         reacquireLock?: boolean;
     }): Promise<void>;
+    private switchBranchNow;
     /**
-     * Acquire a lock on the specified application and branch
+     * Acquire a lock on the specified application and branch.
+     *
+     * Not `async`: the body has to start and be registered in the same tick, so
+     * a caller that immediately settles sees this acquisition rather than
+     * missing it by a microtask.
      */
     acquireLock(): Promise<void>;
+    private acquireLockImpl;
+    /**
+     * Take write access for a turn that is about to start.
+     *
+     * The lock is permission to write for one turn, not a lease on the session: a
+     * headless turn takes it on the way in and hands it back when it ends, so the
+     * app sits unlocked between prompts and a person can open it in the editor.
+     *
+     * Deliberately not routed through {@link claimLockForFirstClient} or
+     * {@link reclaimLockForActiveClient}. Those weigh up whether a signal is
+     * evidence of a client that wants the lock; a turn starting is not evidence
+     * of that, it *is* that, so it asks directly and a lock we handed back
+     * earlier is taken again without ceremony.
+     *
+     * Unlike an attach, this is awaited and its failure is the caller's: a turn
+     * that cannot write must fail before routing is bound, carrying the server's
+     * own reason. Failing does not take the pod down — the lock is per app+branch
+     * while a pod is per live edit, so somebody editing in the browser says
+     * nothing about whether this pod can serve the turn after them.
+     */
+    acquireLockForTurn(): Promise<void>;
+    /**
+     * Hand back the write access a turn took, once that turn has finished.
+     *
+     * The wait belongs here rather than in the callers. A turn ends in more than
+     * one way — the gateway releases it, its socket drops, its liveness lapses —
+     * and only the first of those arrives with the generation already complete.
+     * The other two reach this while Clark may still be writing, and handing the
+     * lock back there gives write access away mid-generation.
+     *
+     * Before the queue, never inside it, for the reason spelled out on
+     * {@link handBackTurnLockWhenGenerationSettles}: that queue serialises the
+     * handback, branch switches and the next turn's acquisition, so a wait
+     * inside it lets one hung turn stall all of them.
+     *
+     * `isStillNeeded` is re-read after that wait, because waiting is exactly
+     * what makes the caller's decision stale: a replacement gateway can attach
+     * and take a turn while the old one's generation is finishing, and releasing
+     * then would pull write access out from under it. The caller owns the
+     * question — this cannot ask "is a gateway attached?" itself, since the
+     * explicit `editor.releaseTurnLock` path runs with one attached by
+     * definition.
+     */
+    relinquishLockForTurn(isStillNeeded?: () => boolean): Promise<void>;
     /**
      * Release the currently held lock
      */
@@ -136,25 +300,116 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
      * Force takeover of the lock from another user (only allowed when user is inactive)
      */
     forceTakeover(): Promise<void>;
+    private forceTakeoverImpl;
     checkAndUpdateLockIfPossible(): Promise<boolean>;
     /**
-     * Cleanup method to be called when the class is destroyed
-     * This ensures the lock is released
+     * Make sure this pod holds the lock a write is about to need.
+     *
+     * The write is itself the demand for the lock, which is what separates this
+     * from the heartbeat's check above. That one asks whether a lock we already
+     * hold is still there, and answers for a lock id; this one is asked before a
+     * sync, when there may be no lock at all.
+     *
+     * The distinction is load-bearing at boot. Nothing acquires the lock at
+     * startup any more — a client attaching is what claims it — but the dev
+     * server still uploads the user's local files before any editor connects.
+     * With no lock id {@link checkAndUpdateLockIfPossible} skips the grab
+     * entirely and reports false without ever asking the server, so routing that
+     * upload through it failed the sync and took the dev server down with it.
+     *
+     * A lock this session handed back is still not taken back here: a write
+     * queued before the handback belongs to the session that ended.
+     */
+    ensureLockForWrite(): Promise<boolean>;
+    /**
+     * Flush what this client left behind and hand the lock back.
+     *
+     * The only way to give the lock up, and the whole of what this service does
+     * about a session ending. Whether the process then stops is the caller's
+     * business and this cannot tell: the same call serves a tab closing on a
+     * sandbox that keeps serving, a `superblocks dev` the user is quitting, and
+     * every exit path in `dev()`. So it says nothing about the server's fate —
+     * that used to be `shutdown()`'s job, and a lock service asserting a process
+     * was exiting is precisely the tangle that made a lock release look like a
+     * teardown.
+     *
+     * Releasing the lock and stopping the dev server used to be one action, so a
+     * client going away took the sandbox with it. On the cloud path it did not
+     * even stop — it closed the rpc client and returned, leaving a pod still
+     * bound to its port with no lock, no heartbeat and nothing behind it: healthy
+     * to every probe and unable to do anything. SABS hands such a pod straight
+     * back to the next caller, whose requests then go nowhere.
+     *
+     * Where the pod does stay up, reopening is cheap for the same reason keeping
+     * it was worth it: Vite is still running, packages are installed, files are
+     * downloaded. A returning editor reacquires through
+     * {@link restartInactivityTimer}.
+     */
+    relinquishLock(): Promise<void>;
+    private relinquishLockNow;
+    /**
+     * The server closed this session: tell the editor, flush, and stop
+     * heartbeating — but do not release.
+     *
+     * The lock is already gone. `/_sb_disconnect` is the server saying it has
+     * taken it, typically to hand the app to a session moving the other way
+     * across local↔cloud, so releasing from here would give back something that
+     * is not ours; on a switch it belongs to whoever is taking over. What is
+     * still ours is the heartbeat, which would otherwise keep refreshing a lock
+     * the server reassigned.
+     *
+     * The editor needs both halves of {@link EventMap.closedByServer}: it has to
+     * distinguish "the server closed you" from a socket dropping, and a switch
+     * from an ending.
      */
-    shutdown({ serverInitiated, switchingTo, initiatedByEmail, }: {
-        serverInitiated?: boolean;
+    notifyClosedByServer({ switchingTo, initiatedByEmail, }: {
         switchingTo?: "local" | "cloud" | "none";
         initiatedByEmail?: string;
     }): Promise<void>;
     /**
-     * Shutdown the lock service and exit the dev server
+     * Push whatever the editor has not synced yet.
+     *
+     * Both ways of giving a session up run this first, and neither can be held up
+     * by it: the caller is either handing the lock to the next client or on its
+     * way out of the process, and a sync that fails is strictly better than one
+     * that blocks the handover. An unheld lock means nothing to flush — the files
+     * belong to whoever holds it now.
+     */
+    private flushPendingWork;
+    /**
+     * Hand the lock back and end the process.
+     *
+     * The only method here that ends anything, and it exists for the four callers
+     * inside this service that have already decided the pod cannot continue: a
+     * heartbeat that failed, a reacquire lost to another user, and the two
+     * {@link LockType.LOCAL} disconnect branches, where the dev server is the
+     * user's foreground process and they expect their terminal back.
+     *
+     * Callers outside this service drive {@link relinquishLock} and own their own
+     * exit. That is not a style preference: `process.exit` is synchronous, so
+     * folding it in here makes everything a caller sequences after it dead code —
+     * which is exactly how the fatal-exit paths in `dev()` came to skip their
+     * telemetry flush on every pod that had a lock service.
+     *
+     * The release is best effort and the exit is not. A lock left held TTL-expires
+     * in two minutes, the same as any pod that dies; a process that fails to exit
+     * is a zombie until something reaps it.
      */
     shutdownAndExit(): Promise<void>;
     /**
      * Add a connected user to the activity tracker.
      */
     addConnectedPeerIdToUser(userId: string, peerId: string): void;
-    private armIdleEvaluationAfterReconnectIfNeeded;
+    /**
+     * Make sure something is still due to ask whether this lock is idle.
+     *
+     * The inactivity timer is one-shot, and the evaluation it fires returns
+     * early on a service that has never held a lock without arming another. So
+     * any path that ends up holding one for something other than an attached
+     * client has to put the question back on the clock, or the lock is refreshed
+     * by the heartbeat for a client that never arrives.
+     */
+    private ensureIdleEvaluationArmed;
     /**
      * Remove a connected user from the activity tracker.
      */
@@ -165,13 +420,11 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
      * Stop the heartbeat
      */
     private stopHeartbeat;
-    private clearStartupConnectionTimeout;
-    private startStartupConnectionTimeoutIfNeeded;
-    private evaluateStartupConnectionTimeoutIfNeeded;
     /**
      * Evaluate if the lock should be released (user disconnected) or marked as ready for takeover (user inactive but connected)
      */
     evaluateLockState(): Promise<void>;
+    private evaluateLockStateOnce;
     /**
      * Restart the inactivity timer when user activity is detected.
      * This timer tracks if the user goes inactive (no pings for N minutes).
@@ -187,11 +440,10 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
      *
      * Gateway peers are deliberately not connected-user presence — they are not
      * a browser editor and must not keep an editor's lock alive — so they need
-     * their own liveness signal. Without it the startup watchdog and the
-     * inactivity reaper would take the sandbox out from under a headless build
-     * that nobody is watching. Tracked per peer id so a reattach that closes the
-     * socket it replaced does not hand the sandbox back while its successor is
-     * still working.
+     * their own liveness signal. Without it the inactivity reaper would take the
+     * sandbox out from under a headless build that nobody is watching. Tracked
+     * per peer id so a reattach that closes the socket it replaced does not hand
+     * the sandbox back while its successor is still working.
      */
     markGatewayAttached(peerId: string): void;
     /**
@@ -199,13 +451,42 @@ export declare class LockService extends TracedEventEmitter<EventMap> {
      * gateway peer is still attached.
      */
     markGatewayDetached(peerId: string): void;
+    /**
+     * The last gateway peer is gone, so no turn is running.
+     *
+     * Write access was taken for the turn, so it goes back now rather than being
+     * left to TTL out — that would leave the app unopenable for up to the lock's
+     * two-minute lifetime after a headless build had already finished. This is
+     * also the backstop for a gateway that dies mid-turn.
+     *
+     * Deliberately not a shutdown: the gateway drops its socket after every turn
+     * and opens a new one for the next prompt, and in between the pod keeps
+     * serving. The next turn takes the lock again through
+     * {@link acquireLockForTurn}. What bounds the pod's life is SABS's live-edit
+     * expiry, not this.
+     *
+     * Only when no editor is attached. An editor disconnect releases on its own
+     * buffer in {@link evaluateLockState}, and a second releaser over the top of
+     * that would race it.
+     */
+    private handleLastGatewayPeerGone;
+    /**
+     * Wait for the turn to finish, then hand its lock back.
+     *
+     * The wait sits outside the lock queue, the way {@link evaluateLockState}
+     * does it. That queue serialises the handback itself, branch switches,
+     * `isLockedWhenSettled` and the next turn's acquisition, so waiting inside
+     * it lets a single hung generation stall all of them — including a graceful
+     * shutdown, which awaits the handback with no timeout of its own.
+     */
+    private handBackTurnLockWhenGenerationSettles;
     /**
      * Watches for the last gateway signal lapsing.
      *
-     * The windows a gateway defers (startup watchdog, inactivity reaper) fire
-     * once and are then only re-examined when something happens. A silent gateway
-     * is the absence of anything happening, so this is what notices it and puts
-     * the lock back up for evaluation.
+     * The inactivity reaper a gateway defers fires once and is then only
+     * re-examined when something happens. A silent gateway is the absence of
+     * anything happening, so this is what notices it and puts the lock back up
+     * for evaluation.
      */
     private armGatewayLivenessSweep;
     private clearGatewayLivenessSweep;

package/dist/lock-service/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lock-service/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lock-service/index.ts"],"names":[],"mappings":"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"}