@platless/axom-cli 0.6.36 → 0.6.52

package/dist/workstation/desktopControl/protocol.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { audioConfiguration, audioMode } from './audio.js';
 import { lobbyRequestSchema, lobbyPlanSchema } from './lobby.js';
+import { deviceAcquisitionSchema, deviceOwnershipCommandSchema, deviceOwnershipEventSchema } from './ownershipProtocol.js';
 export const DESKTOP_MAX_JSON_BYTES = 48 * 1024;
 export class DesktopProtocolError extends Error {
     code = 'invalid_request';
@@ -39,6 +40,7 @@ const backend = z.strictObject({ id: bounded, kind: z.enum(['software', 'hardwar
     formats: z.array(encoderFormat).min(1).max(2).refine(a => distinct(a.map(f => f.format))),
 });
 export const desktopCapabilitiesSchema = z.strictObject({
+    deviceOwnershipProtocol: z.literal(1).optional(),
     cursorEmbedded: z.boolean().optional(), cursorVisibility: z.boolean().optional(), lobby: z.boolean().optional(),
     protocols, providerId: bounded, providerVersion: bounded, configured: z.boolean(),
     permission: z.enum(['granted', 'required', 'unknown', 'not_applicable']), health: z.enum(['ready', 'unavailable']), reason: code.nullable(),
@@ -87,7 +89,7 @@ const feedback = z.strictObject({ epoch: u32, receivedId: int(), decodedId: int(
 const resizeResult = z.strictObject({ commandId: id, width: axis, height: axis, displayRevision: u32, outcome: z.enum(['applied', 'rolled_back', 'failed']), dpi: dpi.optional(), captureRegion: captureRegion.optional() });
 export const desktopErrorCodeSchema = z.enum(['unavailable', 'unknown_capability', 'unsupported_protocol', 'unsupported_client',
     'permission_required', 'busy', 'conflict', 'invalid_request', 'rate_limited', 'startup_timeout', 'encoder_failed', 'decoder_failed',
-    'resize_failed', 'transport_failed', 'authorization_lost', 'takeover_lost']);
+    'resize_failed', 'transport_failed', 'authorization_lost', 'takeover_lost', 'upgrade_required']);
 const state = z.enum(['REQUESTED', 'PREPARING', 'NEGOTIATING', 'STARTING', 'ACTIVE', 'RECONFIGURING', 'SUSPENDED', 'RECONNECTING', 'FAILED', 'CLOSED']);
 const clipboardChunk = { controlGeneration: positive, requestId: id, revision: int().default(0), offset: int(0, 1048576).default(0),
     total: int(0, 1048576).default(0), data: z.string().max(10924).default('') };
@@ -153,15 +155,21 @@ const sessionRequest = z.strictObject({ requestId: id, displayId: id, viewer,
     viewport: z.strictObject({ widthDp: z.number().positive().max(16384), heightDp: z.number().positive().max(16384),
         deviceScale: z.number().min(0.5).max(8), orientation: z.enum(['landscape', 'portrait']) }),
     resolution: z.discriminatedUnion('mode', [z.strictObject({ mode: z.literal('fit') }), z.strictObject({ mode: z.literal('fixed'), width: axis, height: axis })]),
-    quality, takeover: z.boolean().default(false), lobbyId: id.optional(), planId: id.optional(), mediaTransport: z.enum(['quic', 'wss']).optional() })
-    .refine(request => (request.lobbyId == null) === (request.planId == null) && (request.lobbyId == null) === (request.mediaTransport == null));
+    quality, takeover: z.boolean().default(false), lobbyId: id.optional(), planId: id.optional(), mediaTransport: z.enum(['quic', 'wss']).optional(),
+    ownershipProtocol: z.literal(1).optional(), expectedOwnershipRevision: int().optional(), expectedDeviceGeneration: bounded.optional(), deviceAcquisition: deviceAcquisitionSchema.optional() })
+    .refine(request => (request.lobbyId == null) === (request.planId == null) && (request.lobbyId == null) === (request.mediaTransport == null) &&
+    (request.deviceAcquisition?.kind !== 'takeover' || request.takeover && request.ownershipProtocol === 1 && request.expectedOwnershipRevision != null) &&
+    (request.expectedOwnershipRevision == null) === (request.expectedDeviceGeneration == null) &&
+    (request.expectedOwnershipRevision == null || request.ownershipProtocol === 1 && request.takeover));
 const desktopManagementSchema = z.discriminatedUnion('t', [
+    deviceOwnershipCommandSchema,
+    deviceOwnershipEventSchema,
     z.strictObject({ t: z.literal('desktop_lobby'), commandId: id, lobbyId: id, deviceGeneration: bounded, request: z.lazy(() => lobbyRequestSchema),
         wssProbeGrant: z.string().regex(/^[A-Za-z0-9_-]{43}$/).nullish(), quicProbeGrant: z.string().regex(/^[A-Za-z0-9_-]{43}$/).nullish(),
         quic: z.strictObject({ port: int(1, 65535), certificate: z.string().min(64).max(2048) }).nullish() }),
     z.strictObject({ t: z.literal('desktop_background'), commandId: id, lobbyId: id, deviceGeneration: bounded,
         planId: id, revision: positive, targetId: id, grant: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
-        cachedVersion: z.string().regex(/^[A-Za-z0-9_-]{1,128}$/).nullish() }),
+        cachedVersion: z.string().regex(/^[A-Za-z0-9_-]{1,128}$/).nullish(), pixelWidth: int(2, 4096), pixelHeight: int(2, 4096) }),
     z.strictObject({ t: z.literal('desktop_lobby_result'), commandId: id, lobbyId: id, deviceGeneration: bounded,
         plan: z.lazy(() => lobbyPlanSchema).nullable(), code: desktopErrorCodeSchema.nullable() }),
     z.strictObject({ t: z.literal('workstation_capabilities'), ...capabilityReportSchema.shape }),
@@ -171,12 +179,13 @@ const desktopManagementSchema = z.discriminatedUnion('t', [
         candidate: z.boolean().optional(), mediaTransport: z.enum(['quic', 'wss']).optional() }),
     z.strictObject({ t: z.literal('desktop_prepare_result'), commandId: id, sessionId: id,
         state: z.enum(['bound', 'failed']), code: desktopErrorCodeSchema.nullable() }),
-    z.strictObject({ t: z.literal('desktop_cancel'), commandId: id, sessionId: id, controlGeneration: positive, code: desktopErrorCodeSchema }),
+    z.strictObject({ t: z.literal('desktop_cancel'), commandId: id, sessionId: id, controlGeneration: positive, code: desktopErrorCodeSchema, requireIsolation: z.boolean().optional() }),
+    z.strictObject({ t: z.literal('desktop_isolation_result'), commandId: id, sessionId: id, deviceGeneration: bounded, controlGeneration: positive, isolated: z.boolean() }),
     z.strictObject({ t: z.literal('desktop_session_state'), sessionId: id, controlGeneration: positive, state, code: desktopErrorCodeSchema.nullable() }),
 ]);
 export function decodeDesktopManagementFrame(source, from) {
     const frame = checked(desktopManagementSchema, source);
-    const sender = ['desktop_lobby_result', 'workstation_capabilities', 'desktop_prepare_result', 'desktop_session_state'].includes(frame.t) ? 'device' : 'server';
+    const sender = ['desktop_ownership_result', 'desktop_isolation_result', 'desktop_lobby_result', 'workstation_capabilities', 'desktop_prepare_result', 'desktop_session_state'].includes(frame.t) ? 'device' : 'server';
     if (from && from !== sender)
         return invalid();
     return frame;

package/dist/workstation/desktopControl/supervisor.js

@@ -14,6 +14,7 @@ const diagnosticCodes = new Set(['invalid_request', 'unavailable', 'conflict', '
 /** One authority owner and bounded management work queue; receive/heartbeat never await native I/O. */
 export class DesktopSessionSupervisor {
     options;
+    get activeCount() { return Number(!!this.active && !this.active.retired) + this.candidates.size; }
     generation;
     active;
     candidates = new Map();
@@ -28,6 +29,7 @@ export class DesktopSessionSupervisor {
     backgroundTail = Promise.resolve();
     backgroundJobs = 0;
     cleanupJobs = 0;
+    retainedSessions = new Map();
     maintenance;
     constructor(options) {
         this.options = options;
@@ -90,8 +92,28 @@ export class DesktopSessionSupervisor {
             return this.planLobby(frame);
         if (frame.t === 'desktop_prepare')
             return this.prepare(frame);
+        if (frame.requireIsolation)
+            return this.isolate(frame, generation);
         return this.cancel(frame.sessionId, { commandId: frame.commandId, deviceGeneration: generation, controlGeneration: frame.controlGeneration });
     }
+    async isolate(frame, generation) {
+        const key = `${generation}:${frame.sessionId}:${frame.controlGeneration}`;
+        const retained = this.retainedSessions.get(key);
+        let isolated = false;
+        if (retained) {
+            this.retire(retained);
+            try {
+                await this.cleanup(retained);
+                isolated = true;
+            }
+            catch { }
+        }
+        if (this.generation === generation && !this.closed)
+            this.options.report(generation, {
+                t: 'desktop_isolation_result', commandId: frame.commandId, sessionId: frame.sessionId,
+                deviceGeneration: generation, controlGeneration: frame.controlGeneration, isolated,
+            });
+    }
     background(frame) {
         if (this.closed || frame.deviceGeneration !== this.generation || this.backgroundJobs >= 16)
             return Promise.resolve();
@@ -103,7 +125,7 @@ export class DesktopSessionSupervisor {
             if (!current() || !this.options.sockets.uploadWallpaper)
                 return;
             try {
-                const wallpaper = this.options.provider.wallpaper ? await bounded(this.options.provider.wallpaper(frame.targetId), 8000) : null;
+                const wallpaper = this.options.provider.wallpaper ? await bounded(this.options.provider.wallpaper(frame.targetId, { width: frame.pixelWidth, height: frame.pixelHeight }), 8000) : null;
                 if (current())
                     await this.options.sockets.uploadWallpaper(frame.grant, wallpaper, wallpaper?.asset.version === frame.cachedVersion);
             }
@@ -184,12 +206,30 @@ export class DesktopSessionSupervisor {
         this.tail = next.catch(() => { }).finally(() => { this.pending--; });
         return next;
     }
+    preparationCurrent(binding) {
+        if (this.options.preparationCurrent)
+            return this.options.preparationCurrent(binding);
+        let begun = false;
+        return (beginEffect = false) => {
+            if (this.closed || binding.deviceGeneration !== this.generation || this.options.controllerCurrent?.(binding) === false)
+                throw new NativeCommandError('control_lost');
+            if (!begun && this.options.newWorkAllowed?.() === false)
+                return false;
+            if (beginEffect)
+                begun = true;
+            return true;
+        };
+    }
     prepare(command) {
         if (this.maintenance)
             return this.maintenance.catch(() => { }).then(() => this.prepare(command));
         decodeDesktopManagementFrame(JSON.stringify({ ...command, t: 'desktop_prepare' }), 'server');
         if (this.closed || command.deviceGeneration !== this.generation)
             return Promise.resolve();
+        if (this.options.newWorkAllowed?.() === false) {
+            this.options.report(command.deviceGeneration, { t: 'desktop_prepare_result', commandId: command.commandId, sessionId: command.sessionId, state: 'failed', code: 'busy' });
+            return Promise.resolve();
+        }
         mediaRequire(this.pending < 16);
         const key = `${command.deviceGeneration}:${command.commandId}`, serialized = canonicalDesktopJson(command);
         const previousCommand = this.commands.get(key);
@@ -201,8 +241,12 @@ export class DesktopSessionSupervisor {
         this.commands.set(key, serialized);
         mediaRequire(!command.candidate || this.candidates.size < 8);
         const previous = command.candidate ? undefined : this.active;
-        if (previous)
+        const openingCurrent = previous ? this.preparationCurrent(command) : () => this.options.newWorkAllowed?.() !== false;
+        if (previous) {
+            if (!openingCurrent(true))
+                return Promise.resolve();
             this.retire(previous);
+        }
         const s = { diagnosticId: ++this.diagnosticId, diagnosticCount: 0, rateDiagnosticCount: 0, lastRateDiagnosticAt: -Infinity,
             performanceDiagnosticCount: 0, lastPerformanceDiagnosticAt: -Infinity, diagnosticKey: randomBytes(16).toString('hex'), motionEncodeMs: 0,
             binding: { ...command }, abort: new AbortController(), retired: false, viewerReady: false, starting: false,
@@ -210,6 +254,8 @@ export class DesktopSessionSupervisor {
             controller: new DesktopRateController({ fpsCeiling: 30, maxFps: 30 }), rateBusy: false, capturePaused: false, lastFeedbackBytes: 0,
             activeBytes: 0, queuedAt: 0, lastPacketAt: performance.now(), receivedFrame: 0, firstCompleteFrame: 0, flow: new DesktopMediaFlowWindow(), delivery: new DesktopDeliveryDelay(), packetLoop: false, mediaWake: new Set(), nativeCreditDirty: false, nativeDisposed: { motion: 0, cursor: 0, exact: 0 }, configAdmittedEpoch: 0, recovery: [],
             overviewBudget: new DesktopOverviewBudget(), overviewSequence: 0, overviewInitialPolls: 0, challenges: new Map(), rtts: [], rtt: 0, nextPing: performance.now() + 10000 };
+        mediaRequire(this.retainedSessions.size < 1024);
+        this.retainedSessions.set(`${command.deviceGeneration}:${command.sessionId}:${command.controlGeneration}`, s);
         if (command.candidate)
             this.candidates.set(s.binding.sessionId, s);
         else
@@ -219,6 +265,12 @@ export class DesktopSessionSupervisor {
                 await this.cleanup(previous);
             if (!this.current(s))
                 return;
+            if (!openingCurrent()) {
+                this.options.report(command.deviceGeneration, { t: 'desktop_prepare_result', commandId: command.commandId, sessionId: command.sessionId, state: 'failed', code: 'busy' });
+                this.retire(s);
+                await this.cleanup(s);
+                return;
+            }
             mediaRequire(!this.failedCleanup);
             try {
                 // Discovery is side-effect free and independent of the authenticated socket attach.
@@ -280,7 +332,8 @@ export class DesktopSessionSupervisor {
     }
     current(s) {
         return !this.closed && !s.retired &&
-            (this.active === s || this.candidates.get(s.binding.sessionId) === s) && this.generation === s.binding.deviceGeneration;
+            (this.active === s || this.candidates.get(s.binding.sessionId) === s) && this.generation === s.binding.deviceGeneration &&
+            (s.binding.candidate || this.options.controllerCurrent?.(s.binding) !== false);
     }
     diagnostic(s, origin, error, packet, command) {
         // At most 16 fixed-shape records per session, before recovery resets its state.
@@ -527,6 +580,10 @@ export class DesktopSessionSupervisor {
             }
             return;
         }
+        if (message.type === 'select' && this.options.newWorkAllowed?.() === false) {
+            await this.send(s, { v: 1, type: 'error', sessionId: s.binding.sessionId, payload: { code: 'busy', retryable: true } });
+            return;
+        }
         if ('commandId' in message.payload && message.type !== 'audio_ready' && !message.type.startsWith('motion_cut_') && !(resumeAudio && message.type === 'audio_select')) {
             const id = message.payload.commandId, body = canonicalDesktopJson(message);
             const previous = s.commands.get(id);
@@ -573,24 +630,60 @@ export class DesktopSessionSupervisor {
                 return;
             }
             case 'select': {
-                if (this.candidates.get(s.binding.sessionId) === s)
-                    await this.enqueue(async () => {
-                        mediaRequire(this.current(s));
-                        const previous = this.active;
-                        if (previous) {
-                            this.retire(previous);
-                            await this.cleanup(previous);
-                        }
-                        mediaRequire(this.current(s) && !this.failedCleanup);
-                        this.candidates.delete(s.binding.sessionId);
-                        this.active = s;
-                    });
+                const operationCurrent = this.preparationCurrent(s.binding);
+                const busy = async () => {
+                    if (s.commands.get(message.payload.commandId) === canonicalDesktopJson(message))
+                        s.commands.delete(message.payload.commandId);
+                    if (this.current(s))
+                        await this.send(s, { v: 1, type: 'error', sessionId: s.binding.sessionId, payload: { code: 'busy', retryable: true } });
+                };
+                if (this.candidates.get(s.binding.sessionId) === s && !await this.enqueue(async () => {
+                    mediaRequire(this.current(s));
+                    if (!operationCurrent())
+                        return false;
+                    const previous = this.active;
+                    if (previous) {
+                        if (!operationCurrent(true))
+                            return false;
+                        this.retire(previous);
+                        await this.cleanup(previous);
+                    }
+                    mediaRequire(this.current(s) && !this.failedCleanup);
+                    if (!operationCurrent())
+                        return false;
+                    this.candidates.delete(s.binding.sessionId);
+                    this.active = s;
+                    s.binding.candidate = false;
+                    return true;
+                })) {
+                    await busy();
+                    return;
+                }
+                if (!operationCurrent()) {
+                    await busy();
+                    return;
+                }
                 mediaRequire(!s.backend && !s.selection);
                 s.selection = message.payload;
                 s.configuredCommand = message.payload.commandId;
                 s.controller = new DesktopRateController({ fpsCeiling: message.payload.fpsCeiling, maxFps: message.payload.fpsCeiling });
-                s.preparation = this.options.provider.prepare(message.payload, s.binding);
-                const backend = await s.preparation;
+                s.preparation = this.options.provider.prepare(message.payload, s.binding, operationCurrent);
+                let backend;
+                try {
+                    backend = await s.preparation;
+                }
+                catch (error) {
+                    if (error instanceof NativeCommandError && error.code === 'busy') {
+                        if (s.selection === message.payload) {
+                            s.selection = undefined;
+                            s.configuredCommand = undefined;
+                            s.preparation = undefined;
+                        }
+                        await busy();
+                        return;
+                    }
+                    throw error;
+                }
                 if (!this.current(s)) {
                     await backend.stop();
                     return;

package/dist/workstation/desktopControl/wallpaper.js

@@ -1,17 +1,37 @@
 import { createHash } from 'node:crypto';
 import { wallpaperAssetSchema } from './lobby.js';
+export const WALLPAPER_MAX_BYTES = 2 * 1024 * 1024;
+export const WALLPAPER_MAX_JSON = 3 * 1024 * 1024;
 export function decodeWallpaper(text) {
-    if (Buffer.byteLength(text) > 100_000)
+    if (Buffer.byteLength(text) > WALLPAPER_MAX_JSON)
         throw new Error('wallpaper_unavailable');
     const result = JSON.parse(text);
     const asset = wallpaperAssetSchema.parse(result.asset);
-    if (typeof result.jpeg !== 'string' || result.jpeg.length > 87384)
+    if (typeof result.image !== 'string' || result.image.length > Math.ceil(WALLPAPER_MAX_BYTES / 3) * 4)
         throw new Error('wallpaper_unavailable');
-    const jpeg = Buffer.from(result.jpeg, 'base64');
-    if (jpeg.length < 4 || jpeg.length > 65536 || jpeg.toString('base64') !== result.jpeg || jpeg[0] !== 255 || jpeg[1] !== 216)
+    const bytes = Buffer.from(result.image, 'base64');
+    if (bytes.length < 20 || bytes.length > WALLPAPER_MAX_BYTES || bytes.toString('base64') !== result.image ||
+        bytes.toString('ascii', 0, 4) !== 'RIFF' || bytes.toString('ascii', 8, 12) !== 'WEBP' || bytes.readUInt32LE(4) + 8 !== bytes.length || asset.mimeType !== 'image/webp')
         throw new Error('wallpaper_unavailable');
-    const version = createHash('sha256').update(JSON.stringify(asset)).update(jpeg).digest('hex');
-    return { asset: { ...asset, version }, jpeg };
+    let dimensions;
+    for (let offset = 12; offset + 8 <= bytes.length;) {
+        const kind = bytes.toString('ascii', offset, offset + 4), size = bytes.readUInt32LE(offset + 4), data = offset + 8;
+        if (size > bytes.length - data || kind === 'ANIM' || kind === 'ANMF')
+            throw new Error('wallpaper_unavailable');
+        if (kind === 'VP8X' && (size !== 10 || (bytes[data] & 2)))
+            throw new Error('wallpaper_unavailable');
+        if (kind === 'VP8 ' && size >= 10 && !(bytes[data] & 1) && bytes[data + 3] === 0x9d && bytes[data + 4] === 1 && bytes[data + 5] === 0x2a)
+            dimensions = [bytes.readUInt16LE(data + 6) & 0x3fff, bytes.readUInt16LE(data + 8) & 0x3fff];
+        if (kind === 'VP8L' && size >= 5 && bytes[data] === 0x2f) {
+            const bits = bytes.readUInt32LE(data + 1);
+            dimensions = [(bits & 0x3fff) + 1, ((bits >>> 14) & 0x3fff) + 1];
+        }
+        offset = data + size + (size & 1);
+    }
+    if (!dimensions || dimensions[0] !== asset.width || dimensions[1] !== asset.height)
+        throw new Error('wallpaper_unavailable');
+    const version = createHash('sha256').update(JSON.stringify(asset)).update(bytes).digest('hex');
+    return { asset: { ...asset, version }, bytes };
 }
 export class XfceWallpaperReader {
     execute;

package/dist/workstation/exec/policy.js

@@ -12,6 +12,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { KeeperFrameTooLargeError, KeeperNotConnectedError, KeeperReplacementRequiredError, KeeperRequestError } from '../keepers/kit/client.js';
 import { KeeperLaunchError } from '../keepers/terminal/client.js';
+import { RegistrationOwnershipError } from '../runtime/ownership.js';
 import { EXEC_CAPABILITY, EXEC_SIGNALS, EXEC_TERMINAL_TTL_MS, ExecErrorCode } from '../keepers/terminal/protocol.js';
 import { execArgv, execCwd, execDeadline, execEnvironment } from './command.js';
 import { DurableExec, EXEC_KILL_GRACE_MS } from './durable.js';
@@ -289,6 +290,8 @@ export class ExecPolicy {
             hello = (await keeper.ensure()).hello;
         }
         catch (error) {
+            if (error instanceof RegistrationOwnershipError)
+                throw error;
             // A repeat may be running in a keeper-terminal this daemon cannot reach right now: running it here too could run it twice.
             if (how.repeat) {
                 this.log(`exec ${req.id}: repeated request while keeper-terminal is unreachable: ${messageOf(error)}`);
@@ -323,6 +326,8 @@ export class ExecPolicy {
             return { kind: 'durable', exec: DurableExec.follow(keeper, descriptor, { outlivesChannel, ...(wire ? { wire } : {}) }, this.durableOptions()) };
         }
         catch (error) {
+            if (error instanceof RegistrationOwnershipError)
+                throw error;
             // Another keeper-terminal generation owns an exec of this id (spec §3.1: two generations may coexist): it exists, so it is
             // never started again here and never run in this process.
             if (errorCode(error) === ExecErrorCode.foreign) {

package/dist/workstation/files/client.js

@@ -78,6 +78,14 @@ export class FilesHostClient {
             return 0;
         return this.lastStatus.uploads + this.lastStatus.encodes;
     }
+    /** Removal must distinguish an idle host from one that has not supplied a current activity sample. */
+    activitySnapshot() {
+        return {
+            known: this.stopped ? !this.child && !this.spawning : !!this.child && this.hostUp && !this.retiring
+                && !!this.lastStatus && Date.now() - this.lastStatusAt <= this.timings.hungPinMs,
+            transfers: this.activity() + this.sent.size + this.waiting,
+        };
+    }
     /** Process id of the current host (diagnostics and tests). */
     get pid() { return this.child?.pid; }
     get isReady() { return this.ready; }
@@ -392,7 +400,8 @@ export class FilesHostClient {
         // Past the grace, stop feeding it: new requests wait for the restarted host while the ones in flight finish.
         if (overdue)
             this.ready = false;
-        if (this.sent.size === 0 && (overdue || (this.lastStatus?.uploads ?? 0) === 0)) {
+        if (this.sent.size === 0 && (overdue || !!this.lastStatus
+            && this.lastStatus.uploads === 0 && this.lastStatus.encodes === 0 && this.lastStatus.inFlight === 0)) {
             this.restartRequestedAt = null;
             this.log('[files-host] workspaces changed; restarting');
             void this.shutdownChild(true);

package/dist/workstation/files/host.js

@@ -19,6 +19,7 @@ let tools;
 let initializing = false;
 let closing;
 const inFlight = new Map();
+const operations = new Set();
 function send(message) {
     if (!process.connected)
         return;
@@ -64,7 +65,7 @@ function run(request) {
     inFlight.set(request.id, controller);
     const deadline = request.deadlineAt === null ? undefined : setTimeout(() => controller.abort(), Math.max(0, request.deadlineAt - Date.now()));
     const current = tools;
-    void (async () => {
+    const operation = (async () => {
         let reply;
         try {
             // runFileFrame never throws: errors (and cancellation) come back as the result frame's `error`.
@@ -89,6 +90,8 @@ function run(request) {
         status();
         send(reply);
     })();
+    operations.add(operation);
+    void operation.finally(() => operations.delete(operation));
 }
 /** Refuses new work, lets running calls finish within a budget (a hung IO cannot hold the exit forever), then exits. */
 function shutdown(code) {
@@ -96,7 +99,11 @@ function shutdown(code) {
         for (const controller of inFlight.values())
             controller.abort();
         const budget = new Promise(resolve => { setTimeout(resolve, DISPOSE_BUDGET_MS).unref(); });
-        await Promise.race([tools?.dispose().catch(() => { }), budget]);
+        const dispose = async () => {
+            await Promise.allSettled([...operations]);
+            await tools?.dispose();
+        };
+        await Promise.race([dispose().catch(() => { }), budget]);
         process.exit(code);
     })();
     return closing;

package/dist/workstation/journal.js

@@ -15,6 +15,7 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { assertRegistrationOwner } from './runtime/ownership.js';
 const SUFFIX = '.jsonl';
 function parseEntry(line) {
     try {
@@ -58,7 +59,7 @@ export async function listLegacyJournalRefs(dir) {
     return refs.sort();
 }
 /** Every readable entry of `sessionRef`'s journal, in file order (unreadable lines skipped). A missing file is empty. */
-export async function readLegacyJournal(dir, sessionRef) {
+export async function readLegacyJournal(dir, sessionRef, ownership) {
     let text;
     try {
         text = await fs.readFile(fileOf(dir, sessionRef), 'utf8');
@@ -73,8 +74,10 @@ export async function readLegacyJournal(dir, sessionRef) {
         if (line.length === 0)
             continue;
         const entry = parseEntry(line);
-        if (entry)
+        if (entry) {
+            assertRegistrationOwner(JSON.parse(line), ownership, { directory: dir, kind: 'journal' });
             entries.push(entry);
+        }
     }
     return entries;
 }

package/dist/workstation/keepers/acp/client.js

@@ -1,6 +1,7 @@
 // Daemon-side: a typed `acp.*` client for keeper-acp (launch through KeeperLauncher, one long-lived KeeperClient per generation).
 // Exempt from the keeper-side import guard (it runs in the daemon), though it imports nothing but the kit and this keeper's protocol.
 import { KeeperClient } from '../kit/client.js';
+import { assertRegistrationOwner, RegistrationOwnershipError } from '../../runtime/ownership.js';
 import { protocolWindow } from '../kit/protocol.js';
 import { ACP_PROTOCOL_VERSION, acpStream, } from './protocol.js';
 /** keeper-acp could not be reached (launch, connect or hello failed): the request was never sent. */
@@ -23,7 +24,7 @@ export class AcpKeeperClient {
     }
     get daemonProtocol() { return this.options.daemonProtocol ?? protocolWindow(ACP_PROTOCOL_VERSION); }
     clientFor(paths) {
-        if (this.client && this.clientGen === paths.gen)
+        if (this.client && this.client.state !== 'closed' && this.clientGen === paths.gen)
             return this.client;
         this.client?.close();
         this.client = new KeeperClient({
@@ -48,6 +49,7 @@ export class AcpKeeperClient {
     get gen() { return this.options.gen; }
     /** The connected client of the current build, launching keeper-acp only when needed (a `gen`-bound client only connects). */
     async ensure() {
+        this.options.launcher.assertOwnership?.('acp', this.clientGen ?? this.options.gen);
         const current = this.client;
         if (current && current.state === 'ready')
             return current;
@@ -64,14 +66,43 @@ export class AcpKeeperClient {
         return client;
     }
     async call(method, params, options = {}) {
+        this.options.launcher.assertOwnership?.('acp', this.clientGen ?? this.options.gen);
         let client;
         try {
             client = await this.ensure();
         }
         catch (error) {
+            if (error instanceof RegistrationOwnershipError)
+                throw error;
             throw new AcpKeeperUnavailableError(error);
         }
-        return client.request(method, params, options);
+        const ownership = this.options.launcher.ownership;
+        const input = params;
+        if (ownership && typeof input.sessionKey === 'string') {
+            const listed = await client.request('acp.list', {});
+            const existing = listed.sessions.find(session => session.sessionKey === input.sessionKey);
+            if (existing) {
+                if (this.options.launcher.assertSessionOwnership)
+                    this.options.launcher.assertSessionOwnership(existing.label, this.clientGen);
+                else
+                    assertRegistrationOwner(existing.label, ownership);
+            }
+            else if (method !== 'acp.spawn')
+                throw new RegistrationOwnershipError('Registration session owner is unknown');
+        }
+        if (ownership && method === 'acp.spawn')
+            params = { ...input, label: { ...input.label, registrationId: ownership.registrationId } };
+        const result = await client.request(method, params, options);
+        if (ownership && method === 'acp.list') {
+            const listed = result;
+            for (const session of listed.sessions) {
+                if (this.options.launcher.assertSessionOwnership)
+                    this.options.launcher.assertSessionOwnership(session.label, this.clientGen);
+                else
+                    assertRegistrationOwner(session.label, ownership);
+            }
+        }
+        return result;
     }
     spawn(params, options = {}) { return this.call('acp.spawn', params, options); }
     list() { return this.call('acp.list', {}); }
@@ -87,13 +118,18 @@ export class AcpKeeperClient {
     release(sessionKey) { return this.call('acp.release', { sessionKey }); }
     activity() { return this.call('keeper.activity', {}); }
     async subscribe(sessionKey, stream, handler, options) {
+        this.options.launcher.assertOwnership?.('acp', this.clientGen ?? this.options.gen);
         let client;
         try {
             client = await this.ensure();
         }
         catch (error) {
+            if (error instanceof RegistrationOwnershipError)
+                throw error;
             throw new AcpKeeperUnavailableError(error);
         }
+        if (this.options.launcher.ownership)
+            await this.attach(sessionKey);
         return client.subscribe(acpStream(stream, sessionKey), handler, options);
     }
     /** Drops the connection (keeper-acp and its adapters keep running). */

package/dist/workstation/keepers/kit/buildVersion.js

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
-import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { opendirSync, readFileSync, lstatSync, statSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 /**
  * The keeper buildVersion: sha256 over the bundle bytes plus the sorted list of
@@ -14,22 +14,46 @@ import { join, relative, sep } from 'node:path';
  * unchanged keeper code does not change it.
  */
 const sha256 = (data) => createHash('sha256').update(data).digest('hex');
-function walkFiles(dir) {
+function walkFiles(dir, limits) {
     const out = [];
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-        const full = join(dir, entry.name);
-        if (entry.isDirectory())
-            out.push(...walkFiles(full));
-        else
-            out.push(full);
-    }
+    let entries = 0;
+    let bytes = 0;
+    const walk = (directory, depth) => {
+        if (limits && depth > limits.maxDepth)
+            throw Error('Native bundle depth limit');
+        const handle = opendirSync(directory, { bufferSize: 32 });
+        try {
+            for (;;) {
+                const entry = handle.readSync();
+                if (!entry)
+                    break;
+                if (limits && ++entries > limits.maxEntries)
+                    throw Error('Native bundle entry limit');
+                const full = join(directory, entry.name);
+                if (entry.isDirectory())
+                    walk(full, depth + 1);
+                else {
+                    if (limits?.maxBytes !== undefined) {
+                        bytes += lstatSync(full).size;
+                        if (bytes > limits.maxBytes)
+                            throw Error('Native bundle byte limit');
+                    }
+                    out.push(full);
+                }
+            }
+        }
+        finally {
+            handle.closeSync();
+        }
+    };
+    walk(dir, 0);
     return out;
 }
 /** Relative (posix) paths of the native files carried next to a bundle, sorted. */
-export function nativeFilesOf(kindDir) {
+export function nativeFilesOf(kindDir, limits) {
     let files;
     try {
-        files = walkFiles(join(kindDir, 'node_modules'));
+        files = walkFiles(join(kindDir, 'node_modules'), limits);
     }
     catch (error) {
         if (error.code === 'ENOENT')

package/dist/workstation/keepers/kit/client.js

@@ -24,7 +24,7 @@ export class KeeperRequestTimeoutError extends Error {
 }
 export class KeeperNotConnectedError extends Error {
     code = 'not_connected';
-    constructor(message = 'Keeper is not connected') { super(message); this.name = 'KeeperNotConnectedError'; }
+    constructor(message = 'Keeper is not connected', options) { super(message, options); this.name = 'KeeperNotConnectedError'; }
 }
 export class KeeperClosedError extends Error {
     code = 'closed';
@@ -154,7 +154,7 @@ function connectLink(socketPath, limits, timeoutMs, onEvt, onClose) {
         const timer = setTimeout(() => fail(new KeeperNotConnectedError('Timed out connecting to the keeper')), timeoutMs);
         const fail = (error) => { if (settled)
             return; settled = true; clearTimeout(timer); socket.destroy(); reject(error); };
-        socket.once('error', (error) => fail(new KeeperNotConnectedError(error.message)));
+        socket.once('error', (error) => fail(new KeeperNotConnectedError(error.message, { cause: error })));
         socket.once('connect', () => {
             if (settled)
                 return;