dsh-ptc-plus 0.4.8 → 0.4.10

package/internal/cordis-tools-owner.js

@@ -149,8 +149,9 @@ function containsCompanionSkill(directory, fileExists) {
 
 /** Resolve the official Cordis companion Skill across DSH preset generations. */
 export async function resolveCompanionSkillDirectory(agentPresets, options = {}) {
-  const fileExists = options.fileExists ?? existsSync
   const preset = await agentPresets.resolve(CORDIS_PRESET_ID)
+  const resolution = typeof options === 'function' ? options() : options
+  const fileExists = resolution.fileExists ?? existsSync
   if (typeof preset?.broken === 'string' && preset.broken.length > 0) {
     throw new Error(`ptc-plus: DSH cordis preset is unavailable: ${preset.broken}`)
   }
@@ -166,7 +167,7 @@ export async function resolveCompanionSkillDirectory(agentPresets, options = {})
   }
 
   for (const layout of COMPANION_PACKAGE_LAYOUTS) {
-    const pkg = options.packageOf?.(layout.name, options.packageBaseUrl)
+    const pkg = resolution.packageOf?.(layout.name, resolution.packageBaseUrl)
     if (pkg === undefined) continue
     if (pkg?.name !== layout.name || typeof pkg.dir !== 'string' || !isAbsolute(pkg.dir)) {
       throw new Error(`ptc-plus: DSH pluginPackages returned an invalid ${layout.name} package resource`)
@@ -175,10 +176,10 @@ export async function resolveCompanionSkillDirectory(agentPresets, options = {})
     if (containsCompanionSkill(directory, fileExists)) return directory
   }
 
-  if (options.packageOf === undefined && options.resolveLegacyPackageManifest !== undefined) {
+  if (resolution.packageOf === undefined && resolution.resolveLegacyPackageManifest !== undefined) {
     let manifest
     try {
-      manifest = options.resolveLegacyPackageManifest('@deepseek-ai/dsh-agent-presets/package.json')
+      manifest = resolution.resolveLegacyPackageManifest('@deepseek-ai/dsh-agent-presets/package.json')
     } catch (error) {
       if (error?.code !== 'MODULE_NOT_FOUND' && error?.code !== 'ERR_PACKAGE_PATH_NOT_EXPORTED') throw error
     }
@@ -320,22 +321,24 @@ export function createCordisToolsOwner(
   const cordisInspectLeases = createCordisInspectLeases(ctx)
   const scopedCordisPlugin = cordisInspectLeases.plugin(cordisPlugin)
   const scopedSkillPlugin = exactCompanionSkillPlugin(skillFilesystemPlugin)
-  const pluginPackages = ctx.get?.('pluginPackages')
   const packageBaseUrl = ctx.baseUrl
-  const skillResolution = companionResolution ?? {
-    packageOf: pluginPackages === undefined
-      ? undefined
-      : (name, parentURL) => {
-          if (typeof pluginPackages?.packageOf !== 'function') {
-            throw new Error('ptc-plus: cordisToolsEnabled requires the DSH pluginPackages.packageOf API')
-          }
-          return pluginPackages.packageOf(name, parentURL)
-        },
-    packageBaseUrl,
-    resolveLegacyPackageManifest: pluginPackages === undefined && typeof packageBaseUrl === 'string'
-      ? specifier => createRequire(packageBaseUrl).resolve(specifier)
-      : undefined,
-  }
+  const skillResolution = companionResolution ?? (() => {
+    const pluginPackages = ctx.get?.('pluginPackages')
+    return {
+      packageOf: pluginPackages === undefined
+        ? undefined
+        : (name, parentURL) => {
+            if (typeof pluginPackages?.packageOf !== 'function') {
+              throw new Error('ptc-plus: cordisToolsEnabled requires the DSH pluginPackages.packageOf API')
+            }
+            return pluginPackages.packageOf(name, parentURL)
+          },
+      packageBaseUrl,
+      resolveLegacyPackageManifest: pluginPackages === undefined && typeof packageBaseUrl === 'string'
+        ? specifier => createRequire(packageBaseUrl).resolve(specifier)
+        : undefined,
+    }
+  })
   let disposed = false
 
   const leafErrors = error => error instanceof AggregateError

package/internal/direct-surface-owner.js

@@ -464,6 +464,7 @@ export function createDirectSurfaceOwner({
   toolSchemasForAgent,
   userBindingsForAgent = async () => undefined,
   setAgentPresentation = async () => {},
+  sessionLogView,
 }) {
   // Composition is anchored to Agent identity because DSH selects presentation
   // once per composed agent. Request signals bind the exact assembly to stream
@@ -634,6 +635,7 @@ export function createDirectSurfaceOwner({
       }
       const runtimeContexts = sessionPtc
         ? sessionRuntimeContexts(agent, tipConfig, {
+          sessionLogView,
           cordisRecoveryRequired(view) {
             return cordisRecovery.required(agent, view)
           },

package/internal/edit-transport-owner.js

@@ -17,7 +17,7 @@ import {
   editRejectedCell,
   editRunCodeSchema,
 } from './rejected-cell-editor.js'
-import { editTargetForCall, projectSessionLog } from './session-log-view.js'
+import { projectSessionLog } from './session-log-view.js'
 import { RUN_CODE } from './runtime-bridge-owner.js'
 import { isRecord } from './record-utils.js'
 import {
@@ -67,6 +67,8 @@ export function createEditTransportOwner(ctx, {
   presentationGeneration,
   sessionId,
   toolSchemasForAgent,
+  readSessionLog,
+  sessionLogView = projectSessionLog,
 }) {
   let currentDurableReplay = durableReplay
   const editExecutionMetadata = new WeakMap()
@@ -143,13 +145,14 @@ export function createEditTransportOwner(ctx, {
   definition.execute = async (args, exec) => {
     const agent = exec?.agent
     const callId = typeof exec?.callId === 'string' ? exec.callId : undefined
-    const persistedTargetCallSeq = liveToolCallSeq(agent?.session, callId, EDIT_RUN_CODE)
-    if (persistedTargetCallSeq === undefined && projectSessionLog(agent).editableRun !== undefined) {
+    const sessionLog = await readSessionLog(agent?.session, exec.signal)
+    const persistedTargetCallSeq = liveToolCallSeq(sessionLog, callId, EDIT_RUN_CODE)
+    if (persistedTargetCallSeq === undefined && sessionLogView(agent).editableRun !== undefined) {
       throw new Error('ptc-plus: edit_run_code requires a unique persisted tool/call event')
     }
     const target = persistedTargetCallSeq === undefined
       ? undefined
-      : editTargetForCall(agent, callId, persistedTargetCallSeq)
+      : sessionLogView(agent, { callId, callSeq: persistedTargetCallSeq }).requestedEditTarget
     if (target?.source === undefined || target.callSeq === undefined) {
       return { edited: false, reason: 'no run_code cell is currently eligible for safe editing' }
     }
@@ -190,7 +193,7 @@ export function createEditTransportOwner(ctx, {
         agent,
         signal: exec.signal,
       })
-      const tentative = await executeTentative(persistedCallSeq, dispatch)
+      const tentative = await executeTentative(persistedCallSeq, dispatch, sessionLog)
       const inner = tentative.result
       finalizeTentative = tentative.finalize
       const journalValue = isRecord(inner?.meta) && Object.hasOwn(inner.meta, JOURNAL_KEY)

package/internal/execution-provider-owner.js

@@ -0,0 +1,157 @@
+import { createExecutionSeam, EXECUTION_SEAM_SERVICE } from './execution-seam-compat.js'
+
+export const name = 'ptc-plus-execution-provider'
+export const inject = ['loader']
+
+export function apply(ctx, config = {}) {
+  const ownerFiber = ctx.fiber
+  const { originalEntryId = 'ptc-runtime', isolation = 'ptc-plus-original' } = config
+  if (typeof originalEntryId !== 'string' || originalEntryId.length === 0
+    || typeof isolation !== 'string' || isolation.length === 0) {
+    throw new TypeError('ptc-plus: execution provider requires an original entry id and named isolation')
+  }
+  // Profile rows belong to the Include's tree; the global Loader resolves root IDs.
+  const entryTree = ownerFiber.entry?.parent.tree ?? ctx.loader
+  const originalEntry = entryTree.resolve(originalEntryId)
+  const isolated = () => originalEntry.options.isolate?.[EXECUTION_SEAM_SERVICE] === isolation
+  if (!isolated()) throw new Error(`ptc-plus: original entry ${originalEntryId} must isolate ${EXECUTION_SEAM_SERVICE} as ${isolation}`)
+  const originalContext = originalEntry.context.extend({ [originalEntry.constructor.key]: undefined })
+  let watcher
+  let live
+  let stopped = false
+  let suspended = false
+  let generation
+  const pending = new Set()
+  let resolveAttachment
+  let rejectAttachment
+  const attachment = new Promise((resolve, reject) => {
+    resolveAttachment = resolve
+    rejectAttachment = reject
+  })
+  const readOriginal = () => {
+    const original = isolated() ? originalContext.get(EXECUTION_SEAM_SERVICE) : undefined
+    if (stopped || original === undefined) {
+      throw new Error(`ptc-plus: original ${EXECUTION_SEAM_SERVICE} generation is unavailable`)
+    }
+    return original
+  }
+  const release = () => {
+    const entry = live
+    if (entry === undefined) return
+    live = undefined
+    entry.seam.retire()
+    const unregistration = entry.unregister?.()
+    const disposal = Promise.allSettled([unregistration, entry.disposeChild?.()]).then(results => {
+      const failures = results.filter(result => result.status === 'rejected').map(result => result.reason)
+      if (failures.length > 0) throw new AggregateError(failures, 'ptc-plus: execution provider disposal failed')
+    })
+    pending.add(disposal)
+    disposal.then(() => pending.delete(disposal), error => {
+      pending.delete(disposal)
+      ctx.logger.warn(error)
+    })
+    return disposal
+  }
+  const suspend = () => {
+    suspended = true
+    const disposal = release()
+    const previous = watcher
+    watcher = undefined
+    return Promise.all([disposal, previous?.dispose()])
+  }
+  const publish = () => {
+    const resolutions = new WeakMap()
+    const delegate = {
+      get language() { return readOriginal().language },
+      get isolation() { return readOriginal().isolation },
+      get executionInstructions() { return readOriginal().executionInstructions },
+      get sandboxMode() { return readOriginal().sandboxMode },
+      get timeout() { return readOriginal().timeout },
+      resolve(request) {
+        const original = readOriginal()
+        const spec = original.resolve(request)
+        if (spec !== null && typeof spec === 'object') {
+          resolutions.set(spec, { original, generation })
+        }
+        return spec
+      },
+      run(spec) {
+        const resolved = resolutions.get(spec)
+        if (resolved?.generation?.active === false) throw new Error('ptc-plus: resolved spec belongs to an unavailable original generation')
+        const original = resolved?.original ?? readOriginal()
+        return original.run(spec)
+      },
+    }
+    const seam = createExecutionSeam(delegate, EXECUTION_SEAM_SERVICE)
+    const entry = { seam }
+    live = entry
+    entry.disposeChild = ctx.effect(() => {
+      const child = ctx.plugin({
+        name: 'ptc-plus-composed-runtime',
+        apply(childContext) {
+          childContext.effect(() => {
+            if (stopped || live !== entry || !isolated()) return () => {}
+            entry.unregister = childContext.provide(EXECUTION_SEAM_SERVICE, seam.provider)
+            return () => entry.unregister()
+          }, 'ptc-plus owned execution registration')
+        },
+      })
+      entry.child = child
+      return () => child.dispose()
+    }, 'ptc-plus owned execution child')
+    return entry.child.await().then(() => {
+      if (!stopped && live === entry && entry.unregister !== undefined && entry.child.state === 2) resolveAttachment()
+    }, error => {
+      rejectAttachment(error)
+      throw error
+    })
+  }
+  const watch = () => {
+    if (stopped || watcher !== undefined || !isolated()) return
+    ctx.effect(() => {
+      const observer = originalContext.inject([EXECUTION_SEAM_SERVICE], scope => {
+        if (stopped || !isolated()) return
+        createExecutionSeam(scope.get(EXECUTION_SEAM_SERVICE), EXECUTION_SEAM_SERVICE)
+        const currentGeneration = { active: true }
+        generation = currentGeneration
+        scope.effect(() => () => {
+          currentGeneration.active = false
+          if (generation === currentGeneration) generation = undefined
+        }, 'ptc-plus original generation scope')
+        if (live === undefined) return publish()
+        return live.seam.sourceChanged()
+      })
+      watcher = observer
+      return () => observer.dispose()
+    }, 'ptc-plus original execution observer')
+  }
+  ctx.on('loader/partial-dispose', (entry, _legacy, active) => {
+    if (entry === originalEntry && (!active || !isolated())) void suspend().catch(error => ctx.logger.warn(error))
+  }, { prepend: true, global: true })
+  ctx.on('loader/patch-context', (entry, next) => {
+    if (entry === originalEntry && !isolated()) void suspend().catch(error => ctx.logger.warn(error))
+    next()
+    if (entry === originalEntry && isolated() && suspended && !stopped && ownerFiber.state === 2) {
+      stopped = true
+      resolveAttachment()
+      void suspend().catch(error => ctx.logger.warn(error))
+      void ownerFiber.restart().catch(error => ctx.logger.warn(error))
+    }
+  }, { prepend: true, global: true })
+  ctx.effect(() => () => {
+    stopped = true
+    resolveAttachment()
+    const suspension = suspend()
+    return Promise.all([suspension, ...pending])
+  }, 'ptc-plus execution provider composition')
+  if (originalEntry.disabled) resolveAttachment()
+  const timer = setTimeout(() => rejectAttachment(new Error(
+    `ptc-plus: original execution entry ${originalEntryId} did not publish ${EXECUTION_SEAM_SERVICE}`,
+  )), 30_000)
+  ctx.effect(() => () => clearTimeout(timer), 'ptc-plus original execution provider wait')
+  const originalReady = originalEntry.fiber?.await() ?? Promise.resolve()
+  return originalReady.then(() => {
+    watch()
+    return attachment
+  }).finally(() => clearTimeout(timer))
+}

package/internal/execution-seam-compat.js

@@ -1,39 +1,11 @@
-/**
- * Own how PTC Plus attaches to the host's program-execution seam.
- *
- * DSH registers one execution seam per generation. The current release
- * registers `ctx.ptcRuntime` (`@deepseek-ai/dsh-ptc-runtime`); the preceding one
- * registered `ctx.codeRuntime` (`@deepseek-ai/dsh-code-runtime`). Both run one
- * model-written program against host async bindings. They differ in the service
- * name, in the call shape (`resolve(request)` then `run(spec)` against a single
- * `run(request)`), and in the capability descriptors a provider publishes.
- * Which seam is live is decided by the registered service, never by a version
- * string, so a deployment on either generation obtains the same behavior.
- *
- * PTC Plus replaces the execution of session cells with its own persistent
- * REPL. The object DSH describes to the model is therefore the plugin's
- * execution, not the wrapped provider's, so `takeOver()` answers the
- * descriptors the plugin can honor and withholds the ones it cannot. The REPL
- * runs every cell in one long-lived worker rather than a fresh process per
- * call, applies the session's configured budgets rather than a per-call host
- * deadline, and performs no file confinement. DSH gates `timeoutMs` on
- * `timeout` and resolves or escalates file policy on `sandboxMode`, so
- * withholding those descriptors keeps DSH's authority decisions with DSH
- * instead of having this plugin accept an input it would then ignore.
- *
- * A seam-neutral request carries exactly `program`, `bindings`, and `signal`:
- * the fields PTC Plus consumes. A resolved spec's directory, deadline, and
- * authority describe the provider whose execution was replaced, and are neither
- * forwarded to the session kernel nor re-derived here.
- */
-
 /** Cordis service name registered by the current DSH generation. */
 export const EXECUTION_SEAM_SERVICE = 'ptcRuntime'
 
-/** Cordis service name registered by the preceding DSH generation. */
+/** Historical request-only service name, retained with fixture evidence. */
 export const LEGACY_EXECUTION_SEAM_SERVICE = 'codeRuntime'
 
 const SEAM_SERVICES = Object.freeze([EXECUTION_SEAM_SERVICE, LEGACY_EXECUTION_SEAM_SERVICE])
+const PLUGIN_EXECUTION_SEAM = Symbol.for('dsh-ptc-plus.execution-seam')
 
 /**
  * How long the plugin waits for the host's execution seam before it reports the
@@ -48,34 +20,12 @@ const SEAM_SERVICES = Object.freeze([EXECUTION_SEAM_SERVICE, LEGACY_EXECUTION_SE
  */
 const SEAM_ATTACHMENT_TIMEOUT_MS = 30_000
 
-/**
- * Descriptors the plugin replaces with the capabilities of its own execution.
- * `executionInstructions` describes the wrapped provider's program model, which
- * no longer applies; `timeout` and `sandboxMode` gate host inputs the plugin
- * cannot honor. Withdrawal is unconditional because the rule is a property of
- * the plugin's execution, not of a generation: the preceding generation's
- * contract defines none of these members and nothing in its install closure
- * reads them, so withdrawing there is inert, while a provider that published
- * them stays unable to outlive the takeover.
- */
-const WITHHELD_DESCRIPTORS = Object.freeze(['executionInstructions', 'sandboxMode', 'timeout'])
-
 /** Read a registered service without declaring an injection requirement. */
 function readService(ctx, name) {
   if (typeof ctx?.get === 'function') return ctx.get(name)
   return ctx?.[name]
 }
 
-function descriptorsMatch(left, right) {
-  if (left === undefined || right === undefined) return left === right
-  return left.value === right.value
-    && left.get === right.get
-    && left.set === right.set
-    && left.writable === right.writable
-    && left.enumerable === right.enumerable
-    && left.configurable === right.configurable
-}
-
 /**
  * Build the seam handle for one live execution service.
  * @param {object} service - the registered `ctx.ptcRuntime` or `ctx.codeRuntime`.
@@ -85,6 +35,7 @@ export function createExecutionSeam(service, serviceName) {
   if (service === null || typeof service !== 'object') {
     throw new TypeError(`ptc-plus: ${serviceName} must be an execution service object`)
   }
+  if (typeof service[PLUGIN_EXECUTION_SEAM] === 'function') return service[PLUGIN_EXECUTION_SEAM]()
   const current = serviceName === EXECUTION_SEAM_SERVICE
   const upstreamRun = service.run
   if (typeof upstreamRun !== 'function') {
@@ -95,82 +46,87 @@ export function createExecutionSeam(service, serviceName) {
     throw new TypeError('ptc-plus: ptcRuntime.resolve must be a function')
   }
   let installed
-  return Object.freeze({
+  const sourceListeners = new Set()
+  let available = true
+  const requireAvailable = () => {
+    if (!available) throw new Error(`ptc-plus: original ${serviceName} generation is unavailable`)
+  }
+  const requireCompatible = () => {
+    requireAvailable()
+    if (installed !== undefined && service.language !== installed.language) {
+      throw new Error(`ptc-plus: current original language ${JSON.stringify(service.language)} is incompatible with the active ${JSON.stringify(installed.language)} runtime`)
+    }
+  }
+  const provider = Object.freeze({
+    get language() { requireCompatible(); return service.language },
+    get isolation() { requireCompatible(); return installed === undefined ? service.isolation : 'worker-thread' },
+    get executionInstructions() { requireCompatible(); return installed === undefined ? service.executionInstructions ?? '' : '' },
+    get sandboxMode() { requireCompatible(); return installed === undefined ? service.sandboxMode : undefined },
+    get timeout() { requireCompatible(); return installed === undefined ? service.timeout : undefined },
+    resolve(request) {
+      requireCompatible()
+      return current ? upstreamResolve.call(service, request) : request
+    },
+    run(input) {
+      requireCompatible()
+      return installed === undefined ? upstreamRun.call(service, input) : installed.execute(input)
+    },
+    [PLUGIN_EXECUTION_SEAM]() { return seam },
+  })
+  const seam = Object.freeze({
     serviceName,
-    language: service.language,
+    get language() { requireAvailable(); return service.language },
+    provider,
+    get active() { return installed !== undefined && service.language === installed.language },
+    onSourceChange(listener) {
+      sourceListeners.add(listener)
+      return () => sourceListeners.delete(listener)
+    },
+    sourceChanged() {
+      return Promise.all([...sourceListeners].map(listener => listener())).then(() => undefined)
+    },
     /**
      * Run one program through the provider this plugin wraps. The current
      * generation resolves the request before running it, exactly as its own
      * consumer does; the preceding generation accepts the request directly.
      */
     invokeUpstream(request) {
+      requireCompatible()
       return current
         ? upstreamRun.call(service, upstreamResolve.call(service, request))
         : upstreamRun.call(service, request)
     },
-    /**
-     * Install the plugin's execution entry, and its capability descriptors, on
-     * the live service. Only one takeover is live at a time.
-     * @param {(request: object) => Promise<object>} execute - the plugin's entry.
-     * @returns {() => void} restores every descriptor this call replaced.
-     */
-    takeOver(execute) {
-      if (installed !== undefined) throw new Error('ptc-plus: execution seam already taken over')
-      const saved = new Map()
-      const written = new Map()
-      const requested = new Map()
-      requested.set('run', {
-        configurable: true,
-        writable: true,
-        value: current
-          ? spec => execute({
-              program: spec.program,
-              bindings: spec.bindings,
-              signal: spec.signal,
-            })
-          : request => execute(request),
-      })
-      for (const name of WITHHELD_DESCRIPTORS) {
-        requested.set(name, { configurable: true, value: name === 'executionInstructions' ? '' : undefined })
-      }
-      const extensible = Object.isExtensible(service)
-      for (const [name, descriptor] of requested) {
-        const previous = Object.getOwnPropertyDescriptor(service, name)
-        saved.set(name, previous)
-        const next = { enumerable: previous?.enumerable ?? false, ...descriptor }
-        requested.set(name, next)
-        const probe = {}
-        if (previous !== undefined) Object.defineProperty(probe, name, previous)
-        if (!extensible) Object.preventExtensions(probe)
-        Object.defineProperty(probe, name, next)
-      }
-      try {
-        for (const [name, descriptor] of requested) {
-          Object.defineProperty(service, name, descriptor)
-          written.set(name, Object.getOwnPropertyDescriptor(service, name))
-        }
-      } catch (error) {
-        for (const name of [...written.keys()].reverse()) {
-          if (!descriptorsMatch(Object.getOwnPropertyDescriptor(service, name), written.get(name))) continue
-          const descriptor = saved.get(name)
-          if (descriptor === undefined) delete service[name]
-          else Object.defineProperty(service, name, descriptor)
-        }
-        throw error
-      }
+    runUpstream(spec) {
+      requireCompatible()
+      return upstreamRun.call(service, spec)
+    },
+    installExecute(execute) {
+      requireAvailable()
+      if (typeof execute !== 'function') throw new TypeError('ptc-plus: execution entry must be a function')
+      if (installed !== undefined) throw new Error('ptc-plus: execution seam already installed')
+      const entry = { execute, language: service.language }
+      installed = entry
       const restore = () => {
-        if (installed !== restore) return
+        if (installed !== entry) return
         installed = undefined
-        for (const [name, descriptor] of saved) {
-          if (!descriptorsMatch(Object.getOwnPropertyDescriptor(service, name), written.get(name))) continue
-          if (descriptor === undefined) delete service[name]
-          else Object.defineProperty(service, name, descriptor)
-        }
       }
-      installed = restore
       return restore
     },
+    retire() {
+      available = false
+      installed = undefined
+      sourceListeners.clear()
+    },
   })
+  return seam
+}
+
+function registeredExecutionSeam(service, serviceName) {
+  const seam = createExecutionSeam(service, serviceName)
+  if (typeof service[PLUGIN_EXECUTION_SEAM] !== 'function') {
+    throw new Error(`ptc-plus: ${serviceName} requires the public execution-provider bundle composition`)
+  }
+  return seam
 }
 
 /**
@@ -259,7 +215,7 @@ export function installExecutionSeam(ctx, {
         entry = { name, scope }
         live = entry
         registerLifecycle(entry, name, scope)
-        const attached = attach(scope, createExecutionSeam(scope?.[name] ?? readService(ctx, name), name))
+        const attached = attach(scope, registeredExecutionSeam(scope?.[name] ?? readService(ctx, name), name))
         entry.attached = attached
         return attached
       })
@@ -292,7 +248,7 @@ export function installExecutionSeam(ctx, {
     const entry = { name, scope }
     live = entry
     try {
-      entry.attached = attach(scope, createExecutionSeam(scope?.[name] ?? readService(ctx, name), name))
+      entry.attached = attach(scope, registeredExecutionSeam(scope?.[name] ?? readService(ctx, name), name))
     } catch (error) {
       live = undefined
       throw error

package/internal/isolated-worker.js

@@ -15,6 +15,17 @@ const ISOLATED_STOP_MS = 5000
 /** Bound on the helper's output pipes really ending after its process exited. */
 const ISOLATED_OUTPUT_MS = 5000
 
+export function isolatedWorkerEntry(entry) {
+  if (!(entry instanceof URL) && (typeof entry !== 'string' || entry.length === 0)) {
+    throw new TypeError('isolated worker entry must be a URL or a non-empty string filename')
+  }
+  return entry instanceof URL
+    ? entry.href
+    : entry.slice(0, 5).toLowerCase() === 'file:'
+      ? new URL(entry).href
+      : pathToFileURL(resolve(entry)).href
+}
+
 /**
  * A worker-shaped transport whose worker lives in a killable helper process.
  *
@@ -29,17 +40,10 @@ export class IsolatedWorker extends EventEmitter {
     super()
     // The entry follows the worker constructor's contract: a URL or a string
     // filename. Anything else fails here, before a helper process exists.
-    if (!(entry instanceof URL) && (typeof entry !== 'string' || entry.length === 0)) {
-      throw new TypeError('isolated worker entry must be a URL or a non-empty string filename')
-    }
     // The init message crosses advanced IPC, which cannot rebuild a URL object, so
     // the boundary normalizes it to one absolute file URL string. A path follows
     // the worker constructor's rule: resolved from the current working directory.
-    const entrySpec = entry instanceof URL
-      ? entry.href
-      : entry.slice(0, 5).toLowerCase() === 'file:'
-        ? new URL(entry).href
-        : pathToFileURL(resolve(entry)).href
+    const entrySpec = isolatedWorkerEntry(entry)
     this.stdout = new PassThrough()
     this.stderr = new PassThrough()
     this.protocol = protocol