@empire-builder-kit/nx 1.0.0-rc.38 → 1.0.0-rc.39

package/src/local-dev/private-state.js

@@ -5,6 +5,7 @@ exports.hardenPrivatePath = hardenPrivatePath;
 exports.assertPrivatePath = assertPrivatePath;
 exports.ensurePrivateDirectory = ensurePrivateDirectory;
 exports.createPrivateFileExclusive = createPrivateFileExclusive;
+exports.publishPrivateFileExclusive = publishPrivateFileExclusive;
 exports.atomicWritePrivateFile = atomicWritePrivateFile;
 exports.atomicWritePrivateFileWithMaximumBytes = atomicWritePrivateFileWithMaximumBytes;
 exports.readPrivateFile = readPrivateFile;
@@ -19,34 +20,39 @@ exports.PRIVATE_FILE_MODE = 0o600;
 exports.PRIVATE_STATE_MAX_BYTES = 64 * 1024;
 const WINDOWS_HARDEN_ACL = String.raw `
 $ErrorActionPreference = 'Stop'
-$path = $env:EBK_PRIVATE_PATH
 $kind = $env:EBK_PRIVATE_KIND
 $identity = [System.Security.Principal.WindowsIdentity]::GetCurrent()
-if ($kind -eq 'directory') {
-  $info = [System.IO.DirectoryInfo]::new($path)
-} else {
-  $info = [System.IO.FileInfo]::new($path)
-}
-$acl = $info.GetAccessControl()
-$acl.SetAccessRuleProtection($true, $false)
-foreach ($rule in @($acl.Access)) {
-  [void]$acl.RemoveAccessRuleSpecific($rule)
-}
-$rights = [System.Security.AccessControl.FileSystemRights]::FullControl
-$type = [System.Security.AccessControl.AccessControlType]::Allow
-if ($kind -eq 'directory') {
-  $inheritance = [System.Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
-  $propagation = [System.Security.AccessControl.PropagationFlags]::None
-  $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
-    $identity.User, $rights, $inheritance, $propagation, $type
-  )
-} else {
-  $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
-    $identity.User, $rights, $type
-  )
+# Every path in one invocation: a PowerShell start costs seconds on hosted
+# Windows runners, so the levels a private directory creates are hardened
+# together rather than one process per level.
+foreach ($path in ($env:EBK_PRIVATE_PATHS -split [char]10)) {
+  if ($path.Length -eq 0) { continue }
+  if ($kind -eq 'directory') {
+    $info = [System.IO.DirectoryInfo]::new($path)
+  } else {
+    $info = [System.IO.FileInfo]::new($path)
+  }
+  $acl = $info.GetAccessControl()
+  $acl.SetAccessRuleProtection($true, $false)
+  foreach ($rule in @($acl.Access)) {
+    [void]$acl.RemoveAccessRuleSpecific($rule)
+  }
+  $rights = [System.Security.AccessControl.FileSystemRights]::FullControl
+  $type = [System.Security.AccessControl.AccessControlType]::Allow
+  if ($kind -eq 'directory') {
+    $inheritance = [System.Security.AccessControl.InheritanceFlags]'ContainerInherit,ObjectInherit'
+    $propagation = [System.Security.AccessControl.PropagationFlags]::None
+    $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+      $identity.User, $rights, $inheritance, $propagation, $type
+    )
+  } else {
+    $rule = [System.Security.AccessControl.FileSystemAccessRule]::new(
+      $identity.User, $rights, $type
+    )
+  }
+  $acl.AddAccessRule($rule)
+  $info.SetAccessControl($acl)
 }
-$acl.AddAccessRule($rule)
-$info.SetAccessControl($acl)
 `;
 const WINDOWS_ASSERT_PRIVATE_ACL = String.raw `
 $ErrorActionPreference = 'Stop'
@@ -59,8 +65,16 @@ if ($kind -eq 'directory') {
   $info = [System.IO.FileInfo]::new($path)
 }
 $acl = $info.GetAccessControl()
+# A refusal names the descriptor it saw (owner, protection, every rule with
+# its inheritance flag) so a wrong ACL can be attributed to what wrote it.
+$describe = {
+  $rules = @($acl.Access | ForEach-Object {
+    "$($_.IdentityReference)=$($_.FileSystemRights):$($_.AccessControlType):inherited=$($_.IsInherited)"
+  }) -join '; '
+  "owner=$($acl.Owner); protected=$($acl.AreAccessRulesProtected); user=$($identity.User.Value); rules=[$rules]"
+}
 if (-not $acl.AreAccessRulesProtected) {
-  throw 'ACL inheritance is enabled.'
+  throw "ACL inheritance is enabled: $(& $describe)"
 }
 $allowRules = @($acl.Access | Where-Object {
   $_.AccessControlType -eq [System.Security.AccessControl.AccessControlType]::Allow
@@ -72,10 +86,10 @@ $selfRules = @($allowRules | Where-Object {
   $_.IdentityReference.Translate([System.Security.Principal.SecurityIdentifier]).Value -eq $identity.User.Value
 })
 if ($unsafeRules.Count -ne 0 -or $selfRules.Count -eq 0) {
-  throw 'ACL grants access beyond the current user or omits the current user.'
+  throw "ACL grants access beyond the current user or omits the current user: $(& $describe)"
 }
 `;
-function runWindowsAclScript(script, path, kind) {
+function runWindowsAclScript(script, paths, kind) {
     const systemRoot = process.env.SystemRoot;
     if (!systemRoot) {
         throw new Error('SystemRoot is unavailable.');
@@ -91,7 +105,8 @@ function runWindowsAclScript(script, path, kind) {
         env: {
             ...process.env,
             EBK_PRIVATE_KIND: kind,
-            EBK_PRIVATE_PATH: path,
+            EBK_PRIVATE_PATH: paths[0],
+            EBK_PRIVATE_PATHS: paths.join('\n'),
         },
         stdio: 'pipe',
         timeout: 15_000,
@@ -100,10 +115,13 @@ function runWindowsAclScript(script, path, kind) {
 }
 const defaultWindowsAcl = {
     assert(path, kind) {
-        runWindowsAclScript(WINDOWS_ASSERT_PRIVATE_ACL, path, kind);
+        runWindowsAclScript(WINDOWS_ASSERT_PRIVATE_ACL, [path], kind);
     },
     harden(path, kind) {
-        runWindowsAclScript(WINDOWS_HARDEN_ACL, path, kind);
+        runWindowsAclScript(WINDOWS_HARDEN_ACL, [path], kind);
+    },
+    hardenAll(paths, kind) {
+        runWindowsAclScript(WINDOWS_HARDEN_ACL, paths, kind);
     },
 };
 function platformFor(security) {
@@ -136,6 +154,26 @@ function hardenPrivatePath(path, kind, security = {}) {
         throw new errors_js_1.LocalDevContractError('invalid-state', `Unable to restrict private ${kind} ${path}: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+/** Harden several paths of one kind, in one platform invocation where the
+ * platform supports it. */
+function hardenPrivatePaths(paths, kind, security) {
+    if (paths.length === 0)
+        return;
+    if (platformFor(security) === 'win32') {
+        const acl = windowsAclFor(security);
+        if (acl.hardenAll && paths.length > 1) {
+            try {
+                acl.hardenAll(paths, kind);
+            }
+            catch (error) {
+                throw new errors_js_1.LocalDevContractError('invalid-state', `Unable to restrict private ${kind} ${paths.join(', ')}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return;
+        }
+    }
+    for (const path of paths)
+        hardenPrivatePath(path, kind, security);
+}
 function assertPrivatePath(path, kind, security = {}) {
     try {
         assertNotSymbolicLink(path, kind);
@@ -159,12 +197,43 @@ function assertPrivatePath(path, kind, security = {}) {
 function ensurePrivateDirectory(path, security = {}) {
     if ((0, node_fs_1.existsSync)(path)) {
         assertNotSymbolicLink(path, 'directory');
+        hardenPrivatePath(path, 'directory', security);
     }
     else {
-        (0, node_fs_1.mkdirSync)(path, { mode: exports.PRIVATE_DIRECTORY_MODE, recursive: true });
-        assertNotSymbolicLink(path, 'directory');
+        // Create and harden every missing level, not only the leaf: a recursive
+        // mkdir applies the POSIX mode to each level it creates, but Windows ACL
+        // protection is applied per path, and an ancestor created implicitly
+        // (the common `.git/ebk` of a linked worktree's registry) kept inherited
+        // access and was refused on the next read (run 34709123641). The levels
+        // are hardened in one platform invocation.
+        const missing = [];
+        let current = path;
+        while (!(0, node_fs_1.existsSync)(current)) {
+            missing.push(current);
+            const parent = (0, node_path_1.dirname)(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        missing.reverse();
+        for (const level of missing) {
+            try {
+                (0, node_fs_1.mkdirSync)(level, { mode: exports.PRIVATE_DIRECTORY_MODE });
+            }
+            catch (error) {
+                // A concurrent owner may have created this level first; it is
+                // hardened and asserted like every other level.
+                if (!error ||
+                    typeof error !== 'object' ||
+                    !('code' in error) ||
+                    error.code !== 'EEXIST') {
+                    throw error;
+                }
+            }
+            assertNotSymbolicLink(level, 'directory');
+        }
+        hardenPrivatePaths(missing, 'directory', security);
     }
-    hardenPrivatePath(path, 'directory', security);
     assertPrivatePath(path, 'directory', security);
 }
 function assertBoundedContents(contents, maximumBytes = exports.PRIVATE_STATE_MAX_BYTES) {
@@ -215,6 +284,29 @@ function createPrivateFileExclusive(path, contents, security = {}) {
         throw error;
     }
 }
+/** Publish complete private bytes without replacing a concurrent winner.
+ * Unlike a lock file, a persistent data record must never be readable empty. */
+function publishPrivateFileExclusive(path, contents, security = {}) {
+    const temporaryPath = (0, node_path_1.join)((0, node_path_1.dirname)(path), `.${(0, node_path_1.basename)(path)}.${(0, node_crypto_1.randomBytes)(12).toString('hex')}.new`);
+    if (!createPrivateFileExclusive(temporaryPath, contents, security)) {
+        throw new errors_js_1.LocalDevContractError('invalid-state', 'Unable to allocate private publication file.');
+    }
+    try {
+        (0, node_fs_1.linkSync)(temporaryPath, path);
+        return true;
+    }
+    catch (error) {
+        if (error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            error.code === 'EEXIST')
+            return false;
+        throw error;
+    }
+    finally {
+        (0, node_fs_1.unlinkSync)(temporaryPath);
+    }
+}
 function atomicWritePrivateFileWithin(path, contents, maximumBytes, security) {
     assertBoundedContents(contents, maximumBytes);
     const directory = (0, node_path_1.dirname)(path);

package/src/local-dev/process-group.d.ts

@@ -0,0 +1,4 @@
+export declare const OWNED_PROCESS_SIGNAL_GRACE_MS = 10000;
+export declare const OWNED_PROCESS_KILL_WAIT_MS = 5000;
+/** Read-only existence check for an already-proved owned POSIX group. */
+export declare function exactOwnedProcessGroupExists(pid: number): boolean;

package/src/local-dev/process-group.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OWNED_PROCESS_KILL_WAIT_MS = exports.OWNED_PROCESS_SIGNAL_GRACE_MS = void 0;
+exports.exactOwnedProcessGroupExists = exactOwnedProcessGroupExists;
+// The fleet owner must allow its SST child the same bounded settlement window.
+exports.OWNED_PROCESS_SIGNAL_GRACE_MS = 10_000;
+exports.OWNED_PROCESS_KILL_WAIT_MS = 5_000;
+/** Read-only existence check for an already-proved owned POSIX group. */
+function exactOwnedProcessGroupExists(pid) {
+    if (process.platform === 'win32' || !Number.isSafeInteger(pid) || pid <= 0) {
+        throw new Error('Exact owned POSIX process-group absence is unavailable.');
+    }
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === 'object' && error !== null && 'code' in error) {
+            if (error.code === 'ESRCH')
+                return false;
+            // Permission refusal cannot establish absence. Keep polling within the
+            // caller's deadline (including transient permission windows on exit).
+            if (error.code === 'EPERM')
+                return true;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=process-group.js.map

package/src/local-dev/process-identity.d.ts

@@ -5,5 +5,13 @@ export interface ProcessIdentityEffects {
     readFile?: (path: string) => string;
     run?: (executable: string, arguments_: readonly string[]) => string;
 }
+/** Budget for one platform identity query. Windows answers through a
+ * PowerShell CIM query whose cold start alone exceeded three seconds on
+ * loaded hosted runners (PR 113, 2026-09-12); the budget bounds a hang, it
+ * is not a target, and an exhausted budget still refuses the identity. */
+export declare const PROCESS_IDENTITY_QUERY_TIMEOUT_MS: Readonly<{
+    default: 3000;
+    win32: 30000;
+}>;
 export declare function captureProcessIdentity(pid?: number, now?: Date, effects?: ProcessIdentityEffects): FleetProcessIdentity;
 export declare function probeProcessIdentity(identity: FleetProcessIdentity, effects?: ProcessIdentityEffects): ProcessIdentityProbe;

package/src/local-dev/process-identity.js

@@ -1,20 +1,50 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROCESS_IDENTITY_QUERY_TIMEOUT_MS = void 0;
 exports.captureProcessIdentity = captureProcessIdentity;
 exports.probeProcessIdentity = probeProcessIdentity;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const contract_validation_js_1 = require("./contract-validation.js");
+/** Budget for one platform identity query. Windows answers through a
+ * PowerShell CIM query whose cold start alone exceeded three seconds on
+ * loaded hosted runners (PR 113, 2026-09-12); the budget bounds a hang, it
+ * is not a target, and an exhausted budget still refuses the identity. */
+exports.PROCESS_IDENTITY_QUERY_TIMEOUT_MS = Object.freeze({
+    default: 3_000,
+    win32: 30_000,
+});
+// The current process's own start marker cannot change while it runs, so it
+// is queried once per process (per platform) instead of once per lease,
+// registration, or binding. Injected effects (tests, controlled probes) are
+// never cached.
+const ownMarkerCache = new Map();
 function processMarker(pid, effects = {}) {
     const targetPlatform = effects.platform ?? (0, node_os_1.platform)();
+    const injected = effects.exists !== undefined ||
+        effects.readFile !== undefined ||
+        effects.run !== undefined;
+    const cacheKey = `${targetPlatform}:${pid}`;
+    if (!injected && pid === process.pid && ownMarkerCache.has(cacheKey)) {
+        return ownMarkerCache.get(cacheKey);
+    }
+    const marker = queryProcessMarker(pid, targetPlatform, effects);
+    if (!injected && pid === process.pid && marker !== undefined) {
+        ownMarkerCache.set(cacheKey, marker);
+    }
+    return marker;
+}
+function queryProcessMarker(pid, targetPlatform, effects) {
     const exists = effects.exists ?? node_fs_1.existsSync;
     const readFile = effects.readFile ?? ((path) => (0, node_fs_1.readFileSync)(path, 'utf8'));
     const run = effects.run ??
         ((executable, arguments_) => (0, node_child_process_1.execFileSync)(executable, [...arguments_], {
             encoding: 'utf8',
             stdio: ['ignore', 'pipe', 'pipe'],
-            timeout: 3_000,
+            timeout: targetPlatform === 'win32'
+                ? exports.PROCESS_IDENTITY_QUERY_TIMEOUT_MS.win32
+                : exports.PROCESS_IDENTITY_QUERY_TIMEOUT_MS.default,
             windowsHide: true,
         }).trim());
     try {

package/src/local-dev/proxy.js

@@ -78,17 +78,20 @@ function responseHeaders(headers, upstream, options) {
     result['x-ebk-foundation-stage'] = options.foundationStage;
     return result;
 }
+function mayUseDevelopment(request, options) {
+    return (options.safeMethodFallback === true &&
+        SAFE_METHODS.has(request.method?.toUpperCase() ?? 'GET') &&
+        request.headers.upgrade === undefined &&
+        request.headers['transfer-encoding'] === undefined &&
+        Number(request.headers['content-length'] ?? '0') === 0);
+}
 function selectUpstream(request, options) {
     const requestUrl = new URL(request.url ?? '/', options.fleetOrigin);
     const route = routeFor(options.routes, requestUrl.pathname);
-    if (!route || !route.selected) {
-        return { route, type: 'development', url: options.remoteOrigin };
-    }
-    if (route.state === 'ready' && route.upstream) {
+    if (route?.selected && route.state === 'ready' && route.upstream) {
         return { route, type: 'local', url: route.upstream };
     }
-    const method = request.method?.toUpperCase() ?? 'GET';
-    if (options.safeMethodFallback && SAFE_METHODS.has(method)) {
+    if (mayUseDevelopment(request, options)) {
         return { route, type: 'development', url: options.remoteOrigin };
     }
     return undefined;
@@ -176,12 +179,7 @@ class FleetSessionProxy {
             response.end(`${JSON.stringify({ error: 'selected local slice is unavailable', route: request.url })}\n`);
             return;
         }
-        const method = request.method?.toUpperCase() ?? 'GET';
-        const mayRetryWithoutBody = selected.type === 'local' &&
-            this.options.safeMethodFallback === true &&
-            SAFE_METHODS.has(method) &&
-            request.headers['transfer-encoding'] === undefined &&
-            Number(request.headers['content-length'] ?? '0') === 0;
+        const mayRetryWithoutBody = selected.type === 'local' && mayUseDevelopment(request, this.options);
         let retried = false;
         const dispatch = (upstream, replay) => {
             const transport = upstream.url.protocol === 'https:' ? node_https_1.request : node_http_1.request;
@@ -231,6 +229,7 @@ class FleetSessionProxy {
     handleUpgrade(request, socket, head) {
         const selected = selectUpstream(request, this.options);
         if (!selected ||
+            selected.type !== 'local' ||
             (selected.type === 'local' && selected.route?.adapter?.websocket !== true)) {
             socket.end('HTTP/1.1 503 Service Unavailable\r\nConnection: close\r\n\r\n');
             return;

package/src/local-dev/runtime-paths.js

@@ -24,7 +24,7 @@ function fleetRuntimePaths(fleetId, appData = (0, tls_js_1.defaultLocalDevAppDat
         runnersDirectory: (0, node_path_1.join)(sessionDirectory, 'runners'),
         sessionDirectory,
         sessionsDirectory,
-        sliceClaimsDirectory: (0, node_path_1.join)(normalizedAppData, 'slice-claims'),
+        sliceClaimsDirectory: (0, node_path_1.join)(normalizedAppData, 'slice-claims', normalizedFleetId),
         startup: (0, node_path_1.join)(sessionDirectory, 'startup.json'),
         state: (0, node_path_1.join)(sessionDirectory, 'control-state.json'),
         supervisorPid: (0, node_path_1.join)(sessionDirectory, 'supervisor.pid'),

package/src/local-dev/slice-claim.js

@@ -138,7 +138,7 @@ function acquireSliceClaims(directory, slices, owner, options = {}) {
                 sessionGeneration: owner.sessionGeneration,
                 slice,
             });
-            const created = (0, private_state_js_1.createPrivateFileExclusive)(sliceClaimPath(directory, slice), `${JSON.stringify(record, null, 2)}\n`, security);
+            const created = (0, private_state_js_1.publishPrivateFileExclusive)(sliceClaimPath(directory, slice), `${JSON.stringify(record, null, 2)}\n`, security);
             if (created) {
                 acquired.push(slice);
                 claims.push(record);

package/src/local-dev/slice-runner.d.ts

@@ -1,7 +1,7 @@
 import { spawn, type ChildProcess } from 'node:child_process';
 import type { FleetProcessIdentity, ProcessIdentityProbe } from './fleet-lock.js';
 import { terminateOwnedChild } from './fleet-process.js';
-import type { FleetStateRecord } from './fleet-state.js';
+import { type FleetStateRecord } from './fleet-state.js';
 import { loadWorkspaceFleetPlan, resolveWorkspaceNxRuntime, spawnDeclaredNxTarget } from './nx-workspace.js';
 import { type PrivateStateSecurity } from './private-state.js';
 import { captureProcessIdentity } from './process-identity.js';
@@ -44,6 +44,15 @@ export interface LaunchedFleetSliceRunner {
 }
 export type FleetSliceRunnerExitReason = 'child-exit' | 'explicit-restart' | 'parent-lost' | 'termination';
 export declare function fleetSliceRunnerRequiresCleanup(reason: FleetSliceRunnerExitReason): boolean;
+interface FleetSliceRunnerRestartRequest {
+    action: 'restart-without-cleanup';
+    createdAt: string;
+    fleetId: string;
+    runnerGeneration: string;
+    schemaVersion: typeof FLEET_SLICE_RUNNER_RESTART_SCHEMA_VERSION;
+    sessionGeneration: string;
+    slice: string;
+}
 export declare function validateFleetSliceRunnerRequest(value: unknown): FleetSliceRunnerRequest;
 export declare function validateFleetSliceRunnerState(value: unknown): FleetSliceRunnerState;
 export declare function fleetSliceRunnerPaths(runnersDirectory: string, slice: string, runnerGeneration: string): {
@@ -51,6 +60,7 @@ export declare function fleetSliceRunnerPaths(runnersDirectory: string, slice: s
     restart: string;
     state: string;
 };
+export declare function validateFleetSliceRunnerRestartRequest(value: unknown): FleetSliceRunnerRestartRequest;
 export declare function requestFleetSliceRunnerRestart(launched: Pick<LaunchedFleetSliceRunner, 'request' | 'restartPath' | 'statePath'>, effects?: {
     now?: () => Date;
     security?: PrivateStateSecurity;
@@ -81,7 +91,7 @@ export declare function runnerParentStatus(request: FleetSliceRunnerRequest, opt
     processProbe?: ProcessIdentityProbe;
     security?: PrivateStateSecurity;
 }): 'ambiguous' | 'lost' | 'present';
-export declare function runFleetSliceRunner(requestPath: string, options?: {
+declare function runFleetSliceRunnerCore(requestPath: string, options: {
     loadPlan?: typeof loadWorkspaceFleetPlan;
     monitorIntervalMs?: number;
     now?: () => Date;
@@ -92,30 +102,29 @@ export declare function runFleetSliceRunner(requestPath: string, options?: {
     security?: PrivateStateSecurity;
     spawnTarget?: typeof spawnDeclaredNxTarget;
     terminate?: typeof terminateOwnedChild;
-}): Promise<0 | 1>;
+}, stopSignal: AbortSignal): Promise<0 | 1>;
+export declare function runFleetSliceRunner(requestPath: string, options?: Parameters<typeof runFleetSliceRunnerCore>[1]): Promise<0 | 1>;
 export declare function assertFleetSliceRunnerCleanup(statePath: string, expected: Pick<FleetSliceRunnerRequest, 'fleetId' | 'runnerGeneration' | 'sessionGeneration' | 'slice'>, security?: PrivateStateSecurity): void;
 export declare function retryFleetSliceRunnerCleanup(launched: Pick<LaunchedFleetSliceRunner, 'request' | 'requestPath' | 'statePath'>, effects?: {
     daemonPath?: string;
     processProbe?: (identity: FleetProcessIdentity) => ProcessIdentityProbe;
     security?: PrivateStateSecurity;
     spawn?: typeof spawn;
-    timeoutMs?: number;
 }): Promise<void>;
 export declare function recoverFleetSliceRunnerCleanups(state: FleetStateRecord, paths: FleetRuntimePaths, effects?: {
     daemonPath?: string;
     processProbe?: (identity: FleetProcessIdentity) => ProcessIdentityProbe;
     security?: PrivateStateSecurity;
     spawn?: typeof spawn;
-    timeoutMs?: number;
 }): Promise<void>;
 export declare function recoverFleetSliceRunnerCleanupsForSlices(authority: Pick<FleetSliceRunnerRequest, 'fleetId' | 'sessionGeneration'>, selectedSlices: ReadonlySet<string> | readonly string[], paths: FleetRuntimePaths, effects?: {
     daemonPath?: string;
     processProbe?: (identity: FleetProcessIdentity) => ProcessIdentityProbe;
     security?: PrivateStateSecurity;
     spawn?: typeof spawn;
-    timeoutMs?: number;
 }): Promise<void>;
 export declare function inspectFleetRunnersAbsent(state: FleetStateRecord, paths: FleetRuntimePaths, effects?: {
     processProbe?: (identity: FleetProcessIdentity) => ProcessIdentityProbe;
     security?: PrivateStateSecurity;
 }): boolean | 'ambiguous';
+export {};