@openmrs/esm-extensions 10.0.1-pre.5378 → 10.0.1-pre.5389

package/.turbo/turbo-build.log

@@ -1,3 +1,3 @@
-[0] Successfully compiled: 11 files with swc (140.22ms)
+[0] Successfully compiled: 11 files with swc (141.95ms)
 [0] swc --strip-leading-paths src -d dist exited with code 0
 [1] tsc --project tsconfig.build.json exited with code 0

package/dist/render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,WAAW,EAEhB,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,aAAa;IAC5B,IAAI,IAAI,CAAC;CACV;AAED,KAAK,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;AA2E3C;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,WAAW,EAChD,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,WAAW,GAAG,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAGlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,IAAI,WAAW,CAEjD;AAoCD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,WAAW,EACvB,iBAAiB,EAAE,MAAM,EACzB,uBAAuB,EAAE,MAAM,EAC/B,WAAW,EAAE,MAAM,EACnB,cAAc,GAAE,CAAC,WAAW,EAAE,YAAY,KAAK,YAAuB,EACtE,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACxC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsGxB"}
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../src/render.ts"],"names":[],"mappings":"AAAA,kCAAkC;AAClC,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,WAAW,EAEhB,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,aAAa;IAC5B,IAAI,IAAI,CAAC;CACV;AAED,KAAK,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;AAwJ3C;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAAC,CAAC,GAAG,WAAW,EAChD,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,WAAW,GAAG,CAAC,GAC3B,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,CAGlC;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,IAAI,WAAW,CAEjD;AAoCD;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,UAAU,EAAE,WAAW,EACvB,iBAAiB,EAAE,MAAM,EACzB,uBAAuB,EAAE,MAAM,EAC/B,WAAW,EAAE,MAAM,EACnB,cAAc,GAAE,CAAC,WAAW,EAAE,YAAY,KAAK,YAAuB,EACtE,eAAe,GAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAM,GACxC,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAsGxB"}

package/dist/render.js

@@ -5,42 +5,74 @@ import { registerExtensionRendering, unregisterExtensionRendering } from "./stor
 let parcelCount = 0;
 let parcelMounter = null;
 /**
- * Mark parcels as dead if they do not succeed within 15s. Note that loading and unloading is
- * skipped as that has an unpredictable timing. Failing here allows us to clean-up correctly
- * if the parcel doesn't fully mount.
- */ const lifecycleTimeouts = {
-    bootstrap: {
-        millis: 15000,
-        dieOnTimeout: true
-    },
-    mount: {
-        millis: 15000,
-        dieOnTimeout: true
-    },
-    unmount: {
-        millis: 15000,
-        dieOnTimeout: true
-    }
+ * How long each lifecycle gets before the parcel is marked dead. Loading and unloading are left
+ * out, as their timing is unpredictable. These are meant to be generous.
+ *
+ * These are enforced by {@link withDeadline} rather than through single-spa's `timeouts`, because
+ * `reasonableTime()` never clears the timers it schedules from that config: until one fires its
+ * closure retains the parcel, the `domElement` it was given and the whole subtree rendered into it.
+ */ const lifecycleDeadlines = {
+    bootstrap: 15000,
+    mount: 15000,
+    unmount: 15000
 };
+/** single-spa's own test for a thenable, which is all it requires a lifecycle to return. */ function isPromiseLike(value) {
+    const thenable = value;
+    return typeof thenable?.then === 'function' && typeof thenable?.catch === 'function';
+}
 /**
- * Applies {@link lifecycleTimeouts} to a parcel config, resolving the function form first so that a
- * lazily loaded config gets them too.
- *
- * The cast is needed because single-spa reads `timeouts` off a parcel config but doesn't declare it
- * on `ParcelConfigObject`.
- */ function withLifecycleTimeouts(parcelConfig) {
-    // Spread after ours, so a parcel that declares its own timeouts keeps them.
-    if (typeof parcelConfig === 'function') {
-        return ()=>parcelConfig().then((resolved)=>({
-                    timeouts: lifecycleTimeouts,
-                    ...resolved
-                }));
+ * Collapses single-spa's "function or array of functions" lifecycle shape into one function that
+ * runs each in turn, rejecting if any of them returns something that is not a promise.
+ */ function toSingleFn(lifecycle, name, which) {
+    const fns = Array.isArray(lifecycle) ? lifecycle : [
+        lifecycle
+    ];
+    return (props)=>fns.reduce((chain, fn, index)=>chain.then(()=>{
+                const result = fn(props);
+                return isPromiseLike(result) ? result : Promise.reject(new Error(`Lifecycle function ${which} at array index ${index} for parcel ${name} did not return a promise`));
+            }), Promise.resolve(undefined));
+}
+/**
+ * Wraps a lifecycle so that it rejects once `millis` have elapsed, clearing the timer as soon as it
+ * settles either way. Rejecting puts the parcel into the same broken state single-spa's own
+ * `dieOnTimeout` would, but without leaving a timer holding the parcel for the full deadline.
+ */ function withDeadline(lifecycle, millis, name, which) {
+    const run = toSingleFn(lifecycle, name, which);
+    return (props)=>{
+        let timer;
+        const deadline = new Promise((_, reject)=>{
+            timer = setTimeout(()=>reject(new Error(`Lifecycle function ${which} for parcel ${name} did not settle within ${millis}ms`)), millis);
+        });
+        return Promise.race([
+            run(props),
+            deadline
+        ]).finally(()=>clearTimeout(timer));
+    };
+}
+/** Applies {@link lifecycleDeadlines} to a resolved parcel config. */ function boundLifecycles(parcelConfig) {
+    // A parcel that declares its own timeouts is bounding itself, so it is left to single-spa.
+    if (parcelConfig.timeouts) {
+        return parcelConfig;
     }
+    const name = parcelConfig.name ?? 'parcel';
+    const bounded = Object.fromEntries(Object.keys(lifecycleDeadlines).filter((which)=>parcelConfig[which]).map((which)=>[
+            which,
+            withDeadline(parcelConfig[which], lifecycleDeadlines[which], name, which)
+        ]));
     return {
-        timeouts: lifecycleTimeouts,
-        ...parcelConfig
+        ...parcelConfig,
+        ...bounded
     };
 }
+/**
+ * Applies {@link boundLifecycles} to a parcel config, resolving the function form first so that a
+ * lazily loaded config gets the deadlines too.
+ */ function withLifecycleDeadlines(parcelConfig) {
+    if (typeof parcelConfig === 'function') {
+        return ()=>parcelConfig().then(boundLifecycles);
+    }
+    return boundLifecycles(parcelConfig);
+}
 /**
  * Resolves the function used to mount extensions, which is the `mountParcel()` of a long-lived
  * parcel of our own rather than single-spa's `mountRootParcel()`.
@@ -85,7 +117,7 @@ let parcelMounter = null;
  * @returns The parcel handle; mounting completes with its `mountPromise`
  */ export async function renderParcel(parcelConfig, customProps) {
     const mountParcel = await getParcelMounter();
-    return mountParcel(withLifecycleTimeouts(parcelConfig), customProps);
+    return mountParcel(withLifecycleDeadlines(parcelConfig), customProps);
 }
 /**
  * Provides the equivalent of {@link renderParcel} for callers that need a `mountParcel()` they can

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openmrs/esm-extensions",
-  "version": "10.0.1-pre.5378",
+  "version": "10.0.1-pre.5389",
   "license": "MPL-2.0",
   "description": "Coordinates extensions and extension points in the OpenMRS Frontend",
   "type": "module",
@@ -57,21 +57,21 @@
     "lodash-es": "^4.17.21"
   },
   "peerDependencies": {
-    "@openmrs/esm-api": "^10.0.1-pre.5378",
-    "@openmrs/esm-config": "^10.0.1-pre.5378",
-    "@openmrs/esm-expression-evaluator": "^10.0.1-pre.5378",
-    "@openmrs/esm-feature-flags": "^10.0.1-pre.5378",
-    "@openmrs/esm-state": "^10.0.1-pre.5378",
-    "@openmrs/esm-utils": "^10.0.1-pre.5378",
+    "@openmrs/esm-api": "^10.0.1-pre.5389",
+    "@openmrs/esm-config": "^10.0.1-pre.5389",
+    "@openmrs/esm-expression-evaluator": "^10.0.1-pre.5389",
+    "@openmrs/esm-feature-flags": "^10.0.1-pre.5389",
+    "@openmrs/esm-state": "^10.0.1-pre.5389",
+    "@openmrs/esm-utils": "^10.0.1-pre.5389",
     "single-spa": "6.x"
   },
   "devDependencies": {
-    "@openmrs/esm-api": "10.0.1-pre.5378",
-    "@openmrs/esm-config": "10.0.1-pre.5378",
-    "@openmrs/esm-expression-evaluator": "10.0.1-pre.5378",
-    "@openmrs/esm-feature-flags": "10.0.1-pre.5378",
-    "@openmrs/esm-state": "10.0.1-pre.5378",
-    "@openmrs/esm-utils": "10.0.1-pre.5378",
+    "@openmrs/esm-api": "10.0.1-pre.5389",
+    "@openmrs/esm-config": "10.0.1-pre.5389",
+    "@openmrs/esm-expression-evaluator": "10.0.1-pre.5389",
+    "@openmrs/esm-feature-flags": "10.0.1-pre.5389",
+    "@openmrs/esm-state": "10.0.1-pre.5389",
+    "@openmrs/esm-utils": "10.0.1-pre.5389",
     "@swc/cli": "0.8.1",
     "@swc/core": "1.15.21",
     "@vitest/coverage-v8": "^4.1.2",

package/src/render.single-spa.test.ts

@@ -0,0 +1,80 @@
+/* eslint-disable testing-library/render-result-naming-convention -- these tests render parcels, not components */
+/*
+ * Unlike `render.test.ts`, these run against the real single-spa. They cover the parts of
+ * `renderParcel()` whose whole purpose is to interact with single-spa's internals — the lifecycle
+ * wrapping in particular, which stands between single-spa and every lifecycle it would otherwise
+ * have validated itself.
+ */
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import type { LifeCycles } from 'single-spa';
+import { renderParcel } from './render';
+
+function goodLifecycles(): LifeCycles {
+  return {
+    bootstrap: () => Promise.resolve(),
+    mount: () => Promise.resolve(),
+    unmount: () => Promise.resolve(),
+  };
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe('renderParcel against the real single-spa', () => {
+  it('mounts and unmounts a well-behaved parcel', async () => {
+    const parcel = await renderParcel(goodLifecycles(), { domElement: document.createElement('div') });
+
+    await parcel.mountPromise;
+    expect(parcel.getStatus()).toBe('MOUNTED');
+
+    await parcel.unmount();
+    expect(parcel.getStatus()).toBe('NOT_MOUNTED');
+  });
+
+  it('breaks a parcel whose mount does not return a promise', async () => {
+    // single-spa would fail this parcel on its own; the deadline wrapper has to not paper over it.
+    const lifecycles = { ...goodLifecycles(), mount: (() => undefined) as never };
+
+    const parcel = await renderParcel(lifecycles, { domElement: document.createElement('div') });
+
+    await expect(parcel.mountPromise).rejects.toThrow(
+      /Lifecycle function mount at array index 0 for parcel .* did not return a promise/,
+    );
+    expect(parcel.getStatus()).toBe('SKIP_BECAUSE_BROKEN');
+  });
+
+  it('breaks a parcel one of whose array lifecycle functions does not return a promise', async () => {
+    const lifecycles = {
+      ...goodLifecycles(),
+      mount: [() => Promise.resolve(), (() => undefined) as never],
+    };
+
+    const parcel = await renderParcel(lifecycles, { domElement: document.createElement('div') });
+
+    await expect(parcel.mountPromise).rejects.toThrow(
+      /Lifecycle function mount at array index 1 for parcel .* did not return a promise/,
+    );
+    expect(parcel.getStatus()).toBe('SKIP_BECAUSE_BROKEN');
+  });
+
+  it('breaks a parcel whose mount overruns its deadline', async () => {
+    vi.useFakeTimers();
+
+    try {
+      const parcel = await renderParcel(
+        { ...goodLifecycles(), mount: () => new Promise(() => {}) },
+        { domElement: document.createElement('div') },
+      );
+
+      // Asserted against before the clock is advanced, so the rejection is never unhandled.
+      const overran = expect(parcel.mountPromise).rejects.toThrow(/did not settle within 15000ms/);
+      await vi.advanceTimersByTimeAsync(15_000);
+      await overran;
+
+      expect(parcel.getStatus()).toBe('SKIP_BECAUSE_BROKEN');
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/src/render.test.ts

@@ -30,13 +30,13 @@ const lifecycles = {
 };
 
 /**
- * Every parcel the framework mounts is given these, so that a lifecycle which never settles fails
- * rather than leaving a parcel that can never be unmounted.
+ * The config single-spa is handed. Each lifecycle is replaced by a deadline-wrapped stand-in, and
+ * no `timeouts` are set, so single-spa keeps its own (short, warn-only) defaults.
  */
-const lifecycleTimeouts = {
-  bootstrap: { millis: 15_000, dieOnTimeout: true },
-  mount: { millis: 15_000, dieOnTimeout: true },
-  unmount: { millis: 15_000, dieOnTimeout: true },
+const boundedConfig = {
+  bootstrap: expect.any(Function),
+  mount: expect.any(Function),
+  unmount: expect.any(Function),
 };
 
 /**
@@ -262,10 +262,7 @@ describe('renderParcel', () => {
 
     const parcel = await renderParcel(lifecycles, { domElement, someProp: 'value' });
 
-    expect(hostMountParcel).toHaveBeenCalledWith(
-      { ...lifecycles, timeouts: lifecycleTimeouts },
-      { domElement, someProp: 'value' },
-    );
+    expect(hostMountParcel).toHaveBeenCalledWith(boundedConfig, { domElement, someProp: 'value' });
     expect(parcel).toBe(hostMountParcel.mock.results[0].value);
     expect(mountRootParcel).toHaveBeenCalledTimes(1);
     expect(mountRootParcel).toHaveBeenCalledWith(expect.objectContaining({ name: hostParcelName }), expect.anything());
@@ -280,11 +277,94 @@ describe('renderParcel', () => {
 
     // Without these, a lifecycle that never settles leaves a parcel single-spa can never unmount,
     // so nothing the caller tracks against it is ever released.
-    const [objectForm] = hostMountParcel.mock.calls[0] as [{ timeouts: unknown }];
-    const [functionForm] = hostMountParcel.mock.calls[1] as [() => Promise<{ timeouts: unknown }>];
+    const [objectForm] = hostMountParcel.mock.calls[0] as [typeof lifecycles];
+    const [functionForm] = hostMountParcel.mock.calls[1] as [() => Promise<typeof lifecycles>];
+
+    expect(objectForm).toEqual(boundedConfig);
+    expect(objectForm.mount).not.toBe(lifecycles.mount);
+    expect(await functionForm()).toEqual(boundedConfig);
+    expect((await functionForm()).mount).not.toBe(lifecycles.mount);
+  });
+
+  it('fails a lifecycle that overruns its deadline, and clears the deadline when it does not', async () => {
+    vi.useFakeTimers();
+
+    try {
+      const { hostMountParcel, renderParcel } = await loadRenderModule();
+      const domElement = document.createElement('div');
+
+      await renderParcel({ ...lifecycles, mount: () => new Promise(() => {}) }, { domElement });
+      await renderParcel(lifecycles, { domElement });
+
+      const [hung] = hostMountParcel.mock.calls[0] as [typeof lifecycles];
+      const [settles] = hostMountParcel.mock.calls[1] as [typeof lifecycles];
+
+      const timersBefore = vi.getTimerCount();
+      await expect(settles.mount({ domElement })).resolves.toBeUndefined();
+      // The deadline is cleared as soon as the lifecycle settles, so nothing is left holding the
+      // parcel — and with it the DOM it rendered into — until the deadline would have elapsed.
+      expect(vi.getTimerCount()).toBe(timersBefore);
+
+      // Asserted against before the clock is advanced, so the rejection is never unhandled.
+      const overran = expect(hung.mount({ domElement })).rejects.toThrow(/did not settle within 15000ms/);
+      expect(vi.getTimerCount()).toBe(timersBefore + 1);
+      await vi.advanceTimersByTimeAsync(15_000);
+      await overran;
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('rejects a lifecycle that does not return a promise', async () => {
+    const { hostMountParcel, renderParcel } = await loadRenderModule();
+    const domElement = document.createElement('div');
+
+    await renderParcel({ ...lifecycles, mount: (() => undefined) as never }, { domElement });
+
+    const [bounded] = hostMountParcel.mock.calls[0] as [typeof lifecycles];
+
+    // single-spa makes this check itself, but only ever sees the deadline wrapper's own promise, so
+    // without it a mount that forgets to return its work would report as instantly complete.
+    await expect(bounded.mount({ domElement })).rejects.toThrow(
+      /Lifecycle function mount at array index 0 for parcel .* did not return a promise/,
+    );
+  });
+
+  it('runs the functions of an array lifecycle in turn, checking each for a promise', async () => {
+    const { hostMountParcel, renderParcel } = await loadRenderModule();
+    const domElement = document.createElement('div');
+    const order: Array<string> = [];
+
+    await renderParcel(
+      {
+        ...lifecycles,
+        mount: [
+          () => Promise.resolve().then(() => void order.push('first')),
+          () => Promise.resolve().then(() => void order.push('second')),
+        ],
+      },
+      { domElement },
+    );
+    await renderParcel({ ...lifecycles, mount: [() => Promise.resolve(), (() => undefined) as never] }, { domElement });
+
+    const [chained] = hostMountParcel.mock.calls[0] as [typeof lifecycles];
+    const [broken] = hostMountParcel.mock.calls[1] as [typeof lifecycles];
+
+    await expect(chained.mount({ domElement })).resolves.toBeUndefined();
+    expect(order).toEqual(['first', 'second']);
+    await expect(broken.mount({ domElement })).rejects.toThrow(
+      /Lifecycle function mount at array index 1 for parcel .* did not return a promise/,
+    );
+  });
+
+  it('leaves a parcel that declares its own timeouts to single-spa', async () => {
+    const { hostMountParcel, renderParcel } = await loadRenderModule();
+    const domElement = document.createElement('div');
+    const selfBounded = { ...lifecycles, timeouts: { mount: { millis: 500, dieOnTimeout: true } } };
+
+    await renderParcel(selfBounded, { domElement });
 
-    expect(objectForm.timeouts).toEqual(lifecycleTimeouts);
-    expect((await functionForm()).timeouts).toEqual(lifecycleTimeouts);
+    expect(hostMountParcel).toHaveBeenCalledWith(selfBounded, { domElement });
   });
 });
 
@@ -301,7 +381,7 @@ describe('createParcelMounter', () => {
 
     await parcel.mountPromise;
 
-    expect(hostMountParcel).toHaveBeenCalledWith({ ...lifecycles, timeouts: lifecycleTimeouts }, { domElement });
+    expect(hostMountParcel).toHaveBeenCalledWith(boundedConfig, { domElement });
     expect(parcel.getStatus()).toBe('MOUNTED');
   });
 

package/src/render.ts

@@ -21,31 +21,108 @@ type MountParcel = AppProps['mountParcel'];
 let parcelCount = 0;
 let parcelMounter: Promise<MountParcel> | null = null;
 
+type ParcelConfigObject = Extract<ParcelConfig, LifeCycles>;
+type LifecycleFn = Exclude<LifeCycles['mount'], readonly unknown[]>;
+type LifecycleName = keyof typeof lifecycleDeadlines;
+
 /**
- * Mark parcels as dead if they do not succeed within 15s. Note that loading and unloading is
- * skipped as that has an unpredictable timing. Failing here allows us to clean-up correctly
- * if the parcel doesn't fully mount.
+ * How long each lifecycle gets before the parcel is marked dead. Loading and unloading are left
+ * out, as their timing is unpredictable. These are meant to be generous.
+ *
+ * These are enforced by {@link withDeadline} rather than through single-spa's `timeouts`, because
+ * `reasonableTime()` never clears the timers it schedules from that config: until one fires its
+ * closure retains the parcel, the `domElement` it was given and the whole subtree rendered into it.
  */
-const lifecycleTimeouts = {
-  bootstrap: { millis: 15_000, dieOnTimeout: true },
-  mount: { millis: 15_000, dieOnTimeout: true },
-  unmount: { millis: 15_000, dieOnTimeout: true },
+const lifecycleDeadlines = {
+  bootstrap: 15_000,
+  mount: 15_000,
+  unmount: 15_000,
 };
 
+/** single-spa's own test for a thenable, which is all it requires a lifecycle to return. */
+function isPromiseLike(value: unknown): value is Promise<unknown> {
+  const thenable = value as Promise<unknown> | undefined;
+  return typeof thenable?.then === 'function' && typeof thenable?.catch === 'function';
+}
+
 /**
- * Applies {@link lifecycleTimeouts} to a parcel config, resolving the function form first so that a
- * lazily loaded config gets them too.
- *
- * The cast is needed because single-spa reads `timeouts` off a parcel config but doesn't declare it
- * on `ParcelConfigObject`.
+ * Collapses single-spa's "function or array of functions" lifecycle shape into one function that
+ * runs each in turn, rejecting if any of them returns something that is not a promise.
+ */
+function toSingleFn(lifecycle: LifecycleFn | Array<LifecycleFn>, name: string, which: LifecycleName): LifecycleFn {
+  const fns = Array.isArray(lifecycle) ? lifecycle : [lifecycle];
+
+  return (props) =>
+    fns.reduce<Promise<unknown>>(
+      (chain, fn, index) =>
+        chain.then(() => {
+          const result = fn(props);
+
+          return isPromiseLike(result)
+            ? result
+            : Promise.reject(
+                new Error(
+                  `Lifecycle function ${which} at array index ${index} for parcel ${name} did not return a promise`,
+                ),
+              );
+        }),
+      Promise.resolve<unknown>(undefined),
+    );
+}
+
+/**
+ * Wraps a lifecycle so that it rejects once `millis` have elapsed, clearing the timer as soon as it
+ * settles either way. Rejecting puts the parcel into the same broken state single-spa's own
+ * `dieOnTimeout` would, but without leaving a timer holding the parcel for the full deadline.
+ */
+function withDeadline(
+  lifecycle: LifecycleFn | Array<LifecycleFn>,
+  millis: number,
+  name: string,
+  which: LifecycleName,
+): LifecycleFn {
+  const run = toSingleFn(lifecycle, name, which);
+
+  return (props) => {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const deadline = new Promise<never>((_, reject) => {
+      timer = setTimeout(
+        () => reject(new Error(`Lifecycle function ${which} for parcel ${name} did not settle within ${millis}ms`)),
+        millis,
+      );
+    });
+
+    return Promise.race([run(props), deadline]).finally(() => clearTimeout(timer));
+  };
+}
+
+/** Applies {@link lifecycleDeadlines} to a resolved parcel config. */
+function boundLifecycles(parcelConfig: ParcelConfigObject): ParcelConfigObject {
+  // A parcel that declares its own timeouts is bounding itself, so it is left to single-spa.
+  if ((parcelConfig as { timeouts?: unknown }).timeouts) {
+    return parcelConfig;
+  }
+
+  const name = (parcelConfig as { name?: string }).name ?? 'parcel';
+  const bounded = Object.fromEntries(
+    (Object.keys(lifecycleDeadlines) as Array<LifecycleName>)
+      .filter((which) => parcelConfig[which])
+      .map((which) => [which, withDeadline(parcelConfig[which], lifecycleDeadlines[which], name, which)]),
+  );
+
+  return { ...parcelConfig, ...bounded };
+}
+
+/**
+ * Applies {@link boundLifecycles} to a parcel config, resolving the function form first so that a
+ * lazily loaded config gets the deadlines too.
  */
-function withLifecycleTimeouts(parcelConfig: ParcelConfig): ParcelConfig {
-  // Spread after ours, so a parcel that declares its own timeouts keeps them.
+function withLifecycleDeadlines(parcelConfig: ParcelConfig): ParcelConfig {
   if (typeof parcelConfig === 'function') {
-    return (() => parcelConfig().then((resolved) => ({ timeouts: lifecycleTimeouts, ...resolved }))) as ParcelConfig;
+    return (() => parcelConfig().then(boundLifecycles)) as ParcelConfig;
   }
 
-  return { timeouts: lifecycleTimeouts, ...parcelConfig } as ParcelConfig;
+  return boundLifecycles(parcelConfig);
 }
 
 /**
@@ -105,7 +182,7 @@ export async function renderParcel<T = CustomProps>(
   customProps: ParcelProps & T,
 ): Promise<ReturnType<MountParcel>> {
   const mountParcel = await getParcelMounter();
-  return mountParcel(withLifecycleTimeouts(parcelConfig), customProps);
+  return mountParcel(withLifecycleDeadlines(parcelConfig), customProps);
 }
 
 /**