dsh-ptc-plus 0.4.2 → 0.4.8

package/internal/execution-seam-compat.js

@@ -35,6 +35,19 @@ export const LEGACY_EXECUTION_SEAM_SERVICE = 'codeRuntime'
 
 const SEAM_SERVICES = Object.freeze([EXECUTION_SEAM_SERVICE, LEGACY_EXECUTION_SEAM_SERVICE])
 
+/**
+ * How long the plugin waits for the host's execution seam before it reports the
+ * deployment as unsupported.
+ *
+ * Both seam names belong to the host's code-runtime row, so a composed host
+ * publishes one while the loader settles its entries. A profile that never
+ * registers either one cannot be served, and its activation promise must settle
+ * with a diagnostic: the host awaits loader settlement before it becomes
+ * usable, so an unbounded wait would park the whole host instead of failing
+ * this entry.
+ */
+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
@@ -105,15 +118,8 @@ export function createExecutionSeam(service, serviceName) {
       if (installed !== undefined) throw new Error('ptc-plus: execution seam already taken over')
       const saved = new Map()
       const written = new Map()
-      const define = (name, descriptor) => {
-        const previous = Object.getOwnPropertyDescriptor(service, name)
-        if (!saved.has(name)) saved.set(name, previous)
-        // Preserve the shadowed property's visibility so a consumer that
-        // enumerates the provider sees the same member set.
-        Object.defineProperty(service, name, { enumerable: previous?.enumerable ?? false, ...descriptor })
-        written.set(name, Object.getOwnPropertyDescriptor(service, name))
-      }
-      define('run', {
+      const requested = new Map()
+      requested.set('run', {
         configurable: true,
         writable: true,
         value: current
@@ -125,7 +131,32 @@ export function createExecutionSeam(service, serviceName) {
           : request => execute(request),
       })
       for (const name of WITHHELD_DESCRIPTORS) {
-        define(name, { configurable: true, value: name === 'executionInstructions' ? '' : undefined })
+        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
       }
       const restore = () => {
         if (installed !== restore) return
@@ -145,9 +176,10 @@ export function createExecutionSeam(service, serviceName) {
 /**
  * Wait for the host's execution seam and attach the plugin to the live one.
  *
- * A deployment registers one generation, so the current service is preferred
- * whenever both are live; the preceding generation attaches only when the
- * current one is absent. The injected scope requires the plugin's own core
+ * The current service is preferred whenever both are live; the preceding
+ * generation attaches only when the current one is absent, and a current
+ * service registered later retires the live legacy injection before attaching.
+ * The injected scope requires the plugin's own core
  * services as well, so the callback receives a context the plugin can work in,
  * and everything the plugin registers there belongs to the seam the host
  * registered: unloading that service unloads the plugin, and registering it
@@ -157,16 +189,107 @@ export function createExecutionSeam(service, serviceName) {
  * @param {object} ctx - the plugin context.
  * @param {object} options - `services` are the plugin's own required services,
  *   and `attach` is invoked with the injected scope and the seam handle.
- * @returns {Promise<unknown>} settles with the attach result.
+ *   `attachmentTimeoutMs` bounds the wait for a seam that never appears.
+ * @returns {Promise<void>} settles after attachment with a valid Cordis effect value.
  */
-export function installExecutionSeam(ctx, { services = [], attach }) {
+export function installExecutionSeam(ctx, {
+  services = [],
+  attach,
+  reportFailure,
+  attachmentTimeoutMs = SEAM_ATTACHMENT_TIMEOUT_MS,
+}) {
   let live
+  let stopping = false
+  let startWatcher
+  let unusableCurrent
+  const report = (error, name) => {
+    try {
+      reportFailure?.(error, name)
+    } catch {
+      // A reporting failure cannot replace the seam failure it describes.
+    }
+  }
+  const registerLifecycle = (entry, name, scope) => scope.effect?.(() => () => {
+    if (live !== entry) return
+    if (entry.retiring !== undefined) return
+    live = undefined
+    if (!stopping && name === EXECUTION_SEAM_SERVICE
+      && readService(ctx, EXECUTION_SEAM_SERVICE) === undefined
+      && readService(ctx, LEGACY_EXECUTION_SEAM_SERVICE) !== undefined) {
+      startWatcher(LEGACY_EXECUTION_SEAM_SERVICE)
+    }
+  }, 'ptc-plus execution seam lifecycle')
   const select = (name, scope) => {
-    if (live !== undefined) return live.attached
-    if (name === LEGACY_EXECUTION_SEAM_SERVICE && readService(ctx, EXECUTION_SEAM_SERVICE) !== undefined) {
+    const currentService = readService(ctx, EXECUTION_SEAM_SERVICE)
+    if (unusableCurrent !== undefined && currentService !== unusableCurrent) {
+      unusableCurrent = undefined
+    }
+    if (name === EXECUTION_SEAM_SERVICE && currentService === unusableCurrent) {
+      // A current service whose attach already failed cannot supersede the live
+      // legacy attachment. A replacement service object clears the marker above.
+      return live?.attached
+    }
+    if (live !== undefined) {
+      if (name !== EXECUTION_SEAM_SERVICE || live.name === EXECUTION_SEAM_SERVICE) return live.attached
+      const previous = live
+      if (previous.retiring !== undefined) return previous.retiring
+      const disposeLegacy = previous.scope?.fiber?.dispose
+      if (typeof disposeLegacy !== 'function') {
+        throw new Error('ptc-plus: live codeRuntime attachment cannot be superseded without a disposable injected scope')
+      }
+      let resolveActivation
+      let rejectActivation
+      const activation = new Promise((resolve, reject) => {
+        resolveActivation = resolve
+        rejectActivation = reject
+      })
+      previous.retiring = activation
+      let retirement
+      try {
+        retirement = disposeLegacy.call(previous.scope.fiber)
+      } catch (error) {
+        previous.retiring = undefined
+        rejectActivation(error)
+        return activation
+      }
+      let entry
+      const operation = Promise.resolve(retirement).then(() => {
+        if (live !== previous) return undefined
+        previous.retiring = undefined
+        entry = { name, scope }
+        live = entry
+        registerLifecycle(entry, name, scope)
+        const attached = attach(scope, createExecutionSeam(scope?.[name] ?? readService(ctx, name), name))
+        entry.attached = attached
+        return attached
+      })
+      operation.then(resolveActivation, error => {
+        if (live === previous) previous.retiring = undefined
+        else if (live === entry) {
+          // The current attach failed after the legacy fiber was retired. Keep
+          // the plugin attached by re-arming the preceding generation instead
+          // of silently returning run_code to the host provider.
+          live = undefined
+          unusableCurrent = readService(ctx, EXECUTION_SEAM_SERVICE)
+          if (readService(ctx, LEGACY_EXECUTION_SEAM_SERVICE) !== undefined) {
+            try {
+              startWatcher(LEGACY_EXECUTION_SEAM_SERVICE)
+            } catch (fallbackError) {
+              report(fallbackError, LEGACY_EXECUTION_SEAM_SERVICE)
+            }
+          }
+        }
+        report(error, name)
+        rejectActivation(error)
+      })
+      return activation
+    }
+    if (name === LEGACY_EXECUTION_SEAM_SERVICE
+      && currentService !== undefined
+      && currentService !== unusableCurrent) {
       return undefined
     }
-    const entry = { name }
+    const entry = { name, scope }
     live = entry
     try {
       entry.attached = attach(scope, createExecutionSeam(scope?.[name] ?? readService(ctx, name), name))
@@ -174,20 +297,59 @@ export function installExecutionSeam(ctx, { services = [], attach }) {
       live = undefined
       throw error
     }
-    scope.effect?.(() => () => {
-      if (live === entry) live = undefined
-    }, 'ptc-plus execution seam lifecycle')
+    registerLifecycle(entry, name, scope)
     return entry.attached
   }
+  startWatcher = (name, settlement) => ctx.inject([...services, name], scope => {
+    let selected
+    try {
+      selected = select(name, scope)
+    } catch (error) {
+      settlement?.reject(error)
+      report(error, name)
+      throw error
+    }
+    if (selected !== null && typeof selected === 'object' && typeof selected.then === 'function') {
+      const operation = Promise.resolve(selected)
+      operation.then(
+        value => settlement?.resolve(value),
+        error => settlement?.reject(error),
+      )
+      return operation.then(() => undefined)
+    }
+    settlement?.resolve(selected)
+    return undefined
+  })
   const pending = SEAM_SERVICES.map(name => new Promise((resolve, reject) => {
-    ctx.inject([...services, name], scope => {
-      try {
-        resolve(select(name, scope))
-      } catch (error) {
-        reject(error)
-        throw error
-      }
-    })
+    startWatcher(name, { resolve, reject })
   }))
-  return Promise.race(pending)
+  ctx.effect?.(() => () => { stopping = true }, 'ptc-plus execution seam watcher lifecycle')
+  const bound = seamWaitBound(ctx, attachmentTimeoutMs)
+  return Promise.race([Promise.race(pending), bound.promise])
+    .then(() => undefined)
+    .finally(bound.cancel)
+}
+
+/**
+ * Bound the wait for a seam the deployment never registers.
+ *
+ * @param {object} ctx - the plugin context owning the timer.
+ * @param {number} timeoutMs - positive bound, or a non-positive value for none.
+ * @returns the rejection promise and the disposer that clears its timer.
+ */
+function seamWaitBound(ctx, timeoutMs) {
+  if (!(timeoutMs > 0)) return { promise: new Promise(() => {}), cancel: () => {} }
+  let timer
+  const promise = new Promise((_resolve, reject) => {
+    timer = setTimeout(() => reject(new Error(
+      `ptc-plus: no host execution seam (${SEAM_SERVICES.join(' or ')}) is registered; this deployment does not publish a code runtime`,
+    )), timeoutMs)
+  })
+  // The timer is not unref'd: this rejection is the only thing that settles the
+  // activation promise on a deployment that never registers a seam, and an
+  // unref'd timer would let the process drain before it fires. It is cleared as
+  // soon as the race settles so an attached seam never holds the loop open.
+  const cancel = () => clearTimeout(timer)
+  ctx.effect?.(() => () => cancel(), 'ptc-plus execution seam wait bound')
+  return { promise, cancel }
 }