@bleedingdev/modern-js-runtime-extensions 3.8.3-ultramodern.6 → 3.9.0-ultramodern.10

package/tests/routeHydration.test.ts

@@ -0,0 +1,180 @@
+import {
+  createRouteHydrationScriptTags,
+  getMatchedRouteChunks,
+  injectBeforeHydrationEntryScript,
+  orderHydrationScriptChunks,
+  replaceChunkJsPlaceholder,
+} from '../src/routeHydration';
+
+const manifest = {
+  routeAssets: {
+    layout: { assets: ['/shared.js', '/layout.css'] },
+    page: { assets: ['/page.js', '/shared.js'] },
+    empty: {},
+    missing: undefined,
+    'async-main': { assets: ['/shared.js', '/async-main.hash.js'] },
+  },
+};
+
+const tag = (src: string) => `<script src="${src}"></script>`;
+
+describe('route hydration policy', () => {
+  it('maps matched assets in route order without deduplicating or filtering', () => {
+    const mapped = getMatchedRouteChunks(
+      manifest,
+      ['layout', 'unknown', 'empty', 'missing', 'page'],
+      asset => ({ url: asset, marker: 'preserved' }),
+    );
+    expect(mapped).toEqual(
+      ['/shared.js', '/layout.css', '/page.js', '/shared.js'].map(url => ({
+        url,
+        marker: 'preserved',
+      })),
+    );
+  });
+
+  it('returns no chunks for an explicit missing manifest or empty matches', () => {
+    const toChunk = rstest.fn((url: string) => ({ url }));
+    expect(getMatchedRouteChunks(undefined, ['page'], toChunk)).toEqual([]);
+    expect(getMatchedRouteChunks({}, ['page'], toChunk)).toEqual([]);
+    expect(getMatchedRouteChunks(manifest, [], toChunk)).toEqual([]);
+    expect(toChunk).not.toHaveBeenCalled();
+    expect(createRouteHydrationScriptTags(undefined, ['page'], 'main')).toBe(
+      '',
+    );
+    expect(createRouteHydrationScriptTags({}, ['page'], 'main')).toBe('');
+  });
+
+  it('keeps dependencies, collected chunks and route chunks before async entry', () => {
+    const dependency = { url: '/dependency.js', marker: 'dependency' };
+    const collected = { url: '/collected.js', marker: 'collected' };
+    const route = { url: '/route.js', marker: 'route' };
+    const entry = { url: '/async-main.hash.js', marker: 'entry' };
+    const asyncEntryChunks = [entry, dependency];
+    const result = orderHydrationScriptChunks({
+      asyncEntryChunks,
+      collectedChunks: [collected, { ...dependency, marker: 'duplicate' }],
+      matchedRouteChunks: [route, { url: '' }, {}, { ...collected }],
+      entryName: 'main',
+    });
+    expect(result).toEqual([dependency, collected, route, entry]);
+    expect(result[0]).toBe(dependency);
+    expect(result[1]).toBe(collected);
+    expect(asyncEntryChunks).toEqual([entry, dependency]);
+  });
+
+  it('classifies async entries using filename while retaining the JS URL rule', () => {
+    const entry = { url: '/opaque.js', filename: 'nested/async-main-hash.js' };
+    const queried = { url: '/async-main.js?hash=1' };
+    const otherEntry = { url: '/async-other.js' };
+    const asset = { url: '/async-main.css' };
+    const route = { url: '/route.js' };
+    expect(
+      orderHydrationScriptChunks({
+        asyncEntryChunks: [entry, queried, otherEntry, asset],
+        collectedChunks: [],
+        matchedRouteChunks: [route],
+        entryName: 'main',
+      }),
+    ).toEqual([queried, otherEntry, asset, route, entry]);
+  });
+
+  it('serializes unique JS route assets then async assets and matches exact src', () => {
+    expect(
+      createRouteHydrationScriptTags(manifest, ['layout', 'page'], 'main', {
+        template: `${tag('/page.js.map')}${tag('/shared.js')}`,
+      }),
+    ).toBe(`${tag('/page.js')} ${tag('/async-main.hash.js')}`);
+    expect(createRouteHydrationScriptTags(manifest, [], 'main')).toBe(
+      `${tag('/shared.js')} ${tag('/async-main.hash.js')}`,
+    );
+  });
+
+  it('escapes asset and nonce attributes and omits empty nonce', () => {
+    const unsafeManifest = {
+      routeAssets: {
+        page: { assets: ['/route" onload="alert(1)&x=<tag>.js'] },
+      },
+    };
+    expect(
+      createRouteHydrationScriptTags(unsafeManifest, ['page'], 'main', {
+        nonce: 'nonce"&<value>',
+      }),
+    ).toBe(
+      '<script src="/route&quot; onload=&quot;alert(1)&amp;x=&lt;tag&gt;.js" nonce="nonce&quot;&amp;&lt;value&gt;"></script>',
+    );
+    expect(
+      createRouteHydrationScriptTags(manifest, ['page'], 'other', {
+        nonce: '',
+      }),
+    ).toBe(`${tag('/page.js')} ${tag('/shared.js')}`);
+  });
+
+  it('prefers the main entry even when an async entry appears earlier', () => {
+    const asyncEntry = tag('/async-main.hash.js');
+    const entry =
+      "<script defer src='/nested/main-hash.js?build=1#hash'></script>";
+    const template = `${asyncEntry}${entry}`;
+    expect(injectBeforeHydrationEntryScript(template, 'ROUTE', 'main')).toBe(
+      `${asyncEntry}ROUTE${entry}`,
+    );
+  });
+
+  it('falls back to async entry and preserves templates with no entry', () => {
+    const asyncEntry = tag('/nested/async-main.js');
+    expect(injectBeforeHydrationEntryScript(asyncEntry, 'ROUTE', 'main')).toBe(
+      `ROUTE${asyncEntry}`,
+    );
+    expect(injectBeforeHydrationEntryScript(tag('/index.js'), 'ROUTE')).toBe(
+      `ROUTE${tag('/index.js')}`,
+    );
+    const other = tag('/other-main.js');
+    expect(injectBeforeHydrationEntryScript(other, 'ROUTE', 'main')).toBe(
+      other,
+    );
+    expect(injectBeforeHydrationEntryScript(asyncEntry, '', 'main')).toBe(
+      asyncEntry,
+    );
+  });
+
+  it('moves placeholder scripts before hydration and replaces literal text safely', () => {
+    const placeholder = '<!-- chunks -->';
+    const scripts = '<script src="/$&-$`-$\'.js"></script>';
+    const entry = tag('/main.js');
+    expect(
+      replaceChunkJsPlaceholder(
+        `${entry}${placeholder}`,
+        scripts,
+        'main',
+        placeholder,
+      ),
+    ).toBe(`${scripts}${entry}`);
+    expect(
+      replaceChunkJsPlaceholder(
+        `before${placeholder}after`,
+        scripts,
+        'main',
+        placeholder,
+      ),
+    ).toBe(`before${scripts}after`);
+    expect(replaceChunkJsPlaceholder(entry, scripts, 'main', placeholder)).toBe(
+      entry,
+    );
+    expect(
+      replaceChunkJsPlaceholder(
+        `${entry}${placeholder}`,
+        '',
+        'main',
+        placeholder,
+      ),
+    ).toBe(entry);
+    expect(
+      replaceChunkJsPlaceholder(
+        `${placeholder}${placeholder}`,
+        '',
+        undefined,
+        placeholder,
+      ),
+    ).toBe(placeholder);
+  });
+});

package/tests/routerPrefetchPolicy.test.ts

@@ -0,0 +1,102 @@
+import { createRouterPrefetchPolicy } from '../src/routerPrefetchPolicy';
+
+const settle = async () => {
+  for (let turn = 0; turn < 10; turn += 1) await Promise.resolve();
+};
+
+afterEach(() => rstest.useRealTimers());
+
+test('implements render defaults and cancels delayed intent before dispatch', async () => {
+  rstest.useFakeTimers();
+  const policy = createRouterPrefetchPolicy();
+  const notify = rstest.fn();
+  const render = policy.observe({ element: null, notify });
+  expect(notify).toHaveBeenLastCalledWith({ code: true, data: true });
+  render.dispose();
+  const intent = policy.observe({
+    element: null,
+    prefetch: 'none',
+    preload: 'intent',
+    notify,
+  });
+  intent.onIntent();
+  intent.onCancel();
+  await rstest.advanceTimersByTimeAsync(100);
+  expect(notify).toHaveBeenLastCalledWith({ code: false, data: false });
+  intent.onIntent();
+  await rstest.advanceTimersByTimeAsync(100);
+  expect(notify).toHaveBeenLastCalledWith({ code: true, data: false });
+  intent.dispose();
+});
+
+test('limits concurrent loads, removes cancelled queued keys, and retries rejected loads', async () => {
+  const policy = createRouterPrefetchPolicy();
+  const context = {};
+  const loader = {};
+  const started: number[] = [];
+  const releases: (() => void)[] = [];
+  const schedule = (id: number) =>
+    policy.schedule({
+      runtimeContext: context,
+      chunkLoader: loader,
+      publicPath: '/',
+      key: String(id),
+      run: () => {
+        started.push(id);
+        return new Promise<void>(resolve => releases.push(resolve));
+      },
+    });
+  const cancellations = Array.from({ length: 6 }, (_, id) => schedule(id));
+  await settle();
+  expect(started).toEqual([0, 1, 2, 3]);
+  cancellations[4]();
+  releases[0]();
+  await settle();
+  expect(started).toEqual([0, 1, 2, 3, 5]);
+  schedule(4);
+  releases[1]();
+  await settle();
+  expect(started).toEqual([0, 1, 2, 3, 5, 4]);
+  for (const release of releases) release();
+  await settle();
+  const fail = rstest.fn(() => Promise.reject(new Error('retry')));
+  const options = {
+    runtimeContext: context,
+    chunkLoader: loader,
+    publicPath: '/',
+    key: 'failed',
+    run: fail,
+  };
+  policy.schedule(options);
+  await settle();
+  policy.schedule(options);
+  await settle();
+  expect(fail).toHaveBeenCalledTimes(2);
+});
+
+test('deduplicates only within matching context, loader, public path and live TTL', async () => {
+  let now = 0;
+  rstest.spyOn(performance, 'now').mockImplementation(() => now);
+  const policy = createRouterPrefetchPolicy();
+  const run = rstest.fn(() => Promise.resolve());
+  const options = {
+    runtimeContext: {},
+    chunkLoader: {},
+    publicPath: '/',
+    key: 'route',
+    run,
+  };
+  policy.schedule(options);
+  policy.schedule(options);
+  await settle();
+  expect(run).toHaveBeenCalledTimes(1);
+  policy.schedule({ ...options, runtimeContext: {} });
+  policy.schedule({ ...options, chunkLoader: {} });
+  policy.schedule({ ...options, publicPath: '/other/' });
+  await settle();
+  expect(run).toHaveBeenCalledTimes(4);
+  now = 30_001;
+  policy.schedule(options);
+  await settle();
+  expect(run).toHaveBeenCalledTimes(5);
+});

package/tests/routerProvider.test.ts

@@ -0,0 +1,29 @@
+import { createRouterPlugin } from '../src/routerProvider';
+
+test('selects the injected app-local factory from runtime config and preserves native hook objects', () => {
+  const registryHooks = { afterCreate: { call() {} } };
+  const defaultFactory = rstest.fn(() => ({ setup: rstest.fn() }));
+  const setup = rstest.fn();
+  const localFactory = rstest.fn(() => ({ registryHooks, setup }));
+  const plugin = createRouterPlugin({
+    defaultProvider: { name: 'native', factory: defaultFactory },
+    registryHooks,
+    localProviders: [{ name: 'custom', factory: localFactory }],
+  })();
+  const api = { getRuntimeConfig: () => ({ router: { framework: 'custom' } }) };
+  expect(plugin.registryHooks).toBe(registryHooks);
+  plugin.setup(api);
+  expect(localFactory).toHaveBeenCalledWith({});
+  expect(setup).toHaveBeenCalledWith(api);
+  expect(defaultFactory).not.toHaveBeenCalled();
+});
+
+test('rejects missing local providers', () => {
+  const factory = createRouterPlugin({
+    defaultProvider: { name: 'native', factory: () => ({}) },
+    registryHooks: {},
+  });
+  expect(() =>
+    factory({ framework: 'foreign' }).setup({ getRuntimeConfig: () => ({}) }),
+  ).toThrow(/app-owned router provider realm/);
+});

package/tests/routerState.test.ts

@@ -0,0 +1,78 @@
+import {
+  applyRouterRuntimeState,
+  applyRouterServerPrepareResult,
+  cleanupRouterRuntimeState,
+  getRouterHydrationScripts,
+  getRouterMatchedRouteIds,
+  getRouterRuntimeState,
+  getRouterServerSnapshot,
+} from '../src/routerState';
+
+describe('router state primitives', () => {
+  it('preserves snapshot precedence and a captured snapshot across client state updates', () => {
+    const context = { requestId: 'one' };
+    expect(
+      applyRouterRuntimeState(context, {
+        framework: 'custom',
+        basename: '/client',
+        hydrationScripts: ['client'],
+        matchedRouteIds: ['client-route'],
+        serverSnapshot: {
+          basename: '/server',
+          hydrationScripts: ['server'],
+          matchedRouteIds: ['server-route'],
+        },
+      }),
+    ).toBe(context);
+    const snapshot = getRouterServerSnapshot(context);
+    expect(snapshot).toMatchObject({
+      framework: 'custom',
+      basename: '/server',
+      hydrationScripts: ['server'],
+      matchedRouteIds: ['server-route'],
+    });
+    expect(getRouterHydrationScripts(context)).toEqual(['server']);
+    expect(getRouterMatchedRouteIds(context)).toEqual(['server-route']);
+
+    applyRouterRuntimeState(context, {
+      framework: 'custom',
+      instance: { client: true },
+    });
+    expect(getRouterRuntimeState(context)?.serverSnapshot).toBeUndefined();
+    expect(getRouterServerSnapshot(context)).toBe(snapshot);
+    expect(getRouterHydrationScripts(context)).toEqual(['server']);
+    expect(getRouterMatchedRouteIds(context)).toEqual(['server-route']);
+  });
+
+  it('applies server prepare overrides and awaits cleanup without propagating failures', async () => {
+    const context = {};
+    const stateCleanup = rstest.fn();
+    const cleanup = rstest.fn(async () => {
+      await Promise.resolve();
+    });
+    expect(
+      applyRouterServerPrepareResult(context, {
+        state: {
+          framework: 'custom',
+          cleanup: stateCleanup,
+          serverSnapshot: { statusCode: 200 },
+        },
+        snapshot: { statusCode: 299 },
+        cleanup,
+      }),
+    ).toBe(context);
+    expect(getRouterServerSnapshot(context)?.statusCode).toBe(299);
+    await cleanupRouterRuntimeState(context);
+    expect(cleanup).toHaveBeenCalledTimes(1);
+    expect(stateCleanup).not.toHaveBeenCalled();
+
+    applyRouterRuntimeState(context, {
+      framework: 'custom',
+      cleanup: async () => {
+        throw new Error('cleanup failed');
+      },
+    });
+    await expect(cleanupRouterRuntimeState(context)).resolves.toBeUndefined();
+    await expect(cleanupRouterRuntimeState({})).resolves.toBeUndefined();
+  });
+});

package/tests/routerStatePlugin.test.ts

@@ -0,0 +1,63 @@
+import {
+  getRouterRuntimeState,
+  getRouterServerSnapshot,
+} from '../src/routerState';
+import { createRouterStatePlugin } from '../src/routerStatePlugin';
+
+function install() {
+  const registryHooks = { onAfterCreateRouter: { call() {} } };
+  const plugin = createRouterStatePlugin({ registryHooks });
+  let beforeRender!: (context: object) => void;
+  let afterCreate!: Parameters<
+    Parameters<typeof plugin.setup>[0]['onAfterCreateRouter']
+  >[0];
+  plugin.setup({
+    onBeforeRender: callback => {
+      beforeRender = callback;
+    },
+    onAfterCreateRouter: callback => {
+      afterCreate = callback;
+    },
+  });
+  return { plugin, registryHooks, beforeRender, afterCreate };
+}
+
+test('keeps injected hooks and per-context policies stable without sharing app values', () => {
+  const { beforeRender } = install();
+  const first: any = {};
+  const second: any = {};
+  beforeRender(first);
+  const policy = first.linkPrefetchPolicy;
+  beforeRender(first);
+  beforeRender(second);
+  expect(first.linkPrefetchPolicy).toBe(policy);
+  expect(second.linkPrefetchPolicy).not.toBe(policy);
+});
+
+test('projects loader data, errors and valid route ids from injected SSR input', () => {
+  const { afterCreate } = install();
+  const errors = { route: new Error('route error') };
+  const context = {
+    routerContext: {
+      statusCode: 503,
+      errors,
+      loaderData: { root: { ok: true } },
+      matches: [{ route: { id: 'root' } }, { route: {} }],
+    },
+  };
+  afterCreate({
+    framework: 'react-router',
+    phase: 'ssr-prepare',
+    runtimeContext: context,
+    router: context.routerContext,
+    basename: '/nested',
+  });
+  expect(getRouterRuntimeState(context)?.instance).toBe(context.routerContext);
+  expect(getRouterServerSnapshot(context)).toMatchObject({
+    framework: 'react-router',
+    basename: '/nested',
+    statusCode: 503,
+    matchedRouteIds: ['root'],
+    routerData: { loaderData: context.routerContext.loaderData, errors },
+  });
+});

package/tests/runtimeContextProjection.test.ts

@@ -0,0 +1,83 @@
+import { createRuntimeContextExtension } from '../src/contextExtensions';
+import { projectRuntimeContext } from '../src/runtimeContextProjection';
+
+describe('fork runtime context projection', () => {
+  it('removes copied enumerable extension state only from the public projection', () => {
+    const context = { isBrowser: false, requestId: 'original' };
+    const extension = createRuntimeContextExtension<object>('test:projection');
+    const state = { router: 'private' };
+    extension.set(context, state);
+    const publicInput = { ...context };
+
+    const result = projectRuntimeContext(
+      { internalContext: context, publicContext: publicInput },
+      { context, isRsc: false },
+    );
+
+    expect(result.internalContext).toBe(context);
+    expect(result.publicContext).not.toBe(publicInput);
+    expect(extension.get(result.internalContext)).toBe(state);
+    expect(extension.get(publicInput)).toBe(state);
+    expect(extension.get(result.publicContext)).toBeUndefined();
+    expect(Object.getOwnPropertySymbols(result.publicContext)).not.toContain(
+      Symbol.for('@modern-js/runtime:context-extensions'),
+    );
+  });
+
+  it('projects RSC request fields and locals without mutating the original response', () => {
+    const response = {
+      setHeader: rstest.fn(),
+      status: rstest.fn(),
+      locals: { tenant: 'tractor-store' },
+    };
+    const request = {
+      params: { category: 'compact' },
+      pathname: '/tractors',
+      query: { sort: 'price' },
+      headers: { accept: 'text/html' },
+      host: 'example.test',
+      url: 'https://example.test/tractors?sort=price',
+      raw: new Request('https://example.test/tractors'),
+    };
+    const context = { isBrowser: false, ssrContext: { request, response } };
+    const extension = createRuntimeContextExtension<object>('test:rsc');
+    const state = { original: true };
+    extension.set(context, state);
+    const publicContext = { isBrowser: false };
+    const result = projectRuntimeContext(
+      { internalContext: context, publicContext },
+      { context, isRsc: true },
+    );
+    const internal = result.internalContext as typeof result.internalContext & {
+      context: { request: object; response: typeof response };
+      requestContext: { request: object; response: typeof response };
+    };
+    const publicValue = result.publicContext as typeof internal;
+
+    expect(internal).not.toBe(context);
+    expect(internal.ssrContext).toBeUndefined();
+    expect(internal.requestContext).toBe(publicValue.requestContext);
+    expect(internal.context).toBe(internal.requestContext);
+    expect(publicValue.context).toBe(internal.requestContext);
+    expect(internal.requestContext.response.locals).toBe(response.locals);
+    expect(context.ssrContext.response).toBe(response);
+    expect(extension.get(context)).toBe(state);
+    // Internal RSC copy behavior is retained pending separate Flight proof.
+    expect(extension.get(internal)).toBe(state);
+    expect(extension.get(publicValue)).toBeUndefined();
+  });
+
+  it('does not apply server request projection to an RSC browser context', () => {
+    const context = {
+      isBrowser: true,
+      ssrContext: { request: {}, response: { locals: { browser: true } } },
+    };
+    const result = projectRuntimeContext(
+      { internalContext: context, publicContext: { ...context } },
+      { context, isRsc: true },
+    );
+    expect(result.internalContext).toBe(context);
+    expect(result.internalContext.ssrContext).toBe(context.ssrContext);
+    expect(result.publicContext).not.toHaveProperty('requestContext');
+  });
+});

package/tests/safeFailure.test.ts

@@ -10,9 +10,7 @@ const readBody = async (response: Response) =>
 
 describe('safe failure responses', () => {
   it.each([
-    [404, 'REQUEST_FAILED', 'Request failed'],
     [500, 'INTERNAL_SERVER_ERROR', 'Internal Server Error'],
-    [503, 'SERVICE_UNAVAILABLE', 'Service Unavailable'],
   ])('redacts a %i failure through every response surface', async (status, code, message) => {
     const error = Object.assign(new Error('database-password'), {
       status,
@@ -54,23 +52,6 @@ describe('safe failure responses', () => {
 
   it.each([
     ['delay seconds text', ' 120 ', '120'],
-    ['leading-zero delay text', '000120', '120'],
-    ['delay seconds number', 2.1, '3'],
-    [
-      'largest safe delay number',
-      Number.MAX_SAFE_INTEGER,
-      String(Number.MAX_SAFE_INTEGER),
-    ],
-    [
-      'largest safe delay text',
-      String(Number.MAX_SAFE_INTEGER),
-      String(Number.MAX_SAFE_INTEGER),
-    ],
-    [
-      'canonical HTTP-date text',
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-    ],
     [
       'valid Date object',
       new Date(Date.UTC(2026, 7, 30, 20, 0, 0)),
@@ -81,6 +62,16 @@ describe('safe failure responses', () => {
     expect(result.headers['Retry-After']).toBe(expected);
   });
 
+  it('derives Retry-After from a retryAfterSeconds error property', () => {
+    const error = Object.assign(new Error('maintenance'), {
+      status: 503,
+      retryAfterSeconds: 120,
+    });
+    expect(createSafeFailureHttpResult(error).headers['Retry-After']).toBe(
+      '120',
+    );
+  });
+
   it('converts Retry-After milliseconds to canonical delay seconds', () => {
     expect(
       createSafeFailureHttpResult({ status: 503, retryAfterMs: 2500 }).headers[
@@ -91,15 +82,6 @@ describe('safe failure responses', () => {
 
   it.each([
     ['a header injection payload', '120\r\nX-Injected: true'],
-    ['arbitrary text', 'after maintenance'],
-    ['an exponent string', '1e3'],
-    ['a decimal string', '2.1'],
-    ['a negative string', '-1'],
-    ['an unsafe integer string', '9007199254740992'],
-    ['an unsafe number', 1e21],
-    ['infinity', Number.POSITIVE_INFINITY],
-    ['a noncanonical date', 'Sunday, 30-Aug-26 20:00:00 GMT'],
-    ['an invalid date string', 'Wed, 99 Jun 2026 25:61:61 GMT'],
     ['an invalid Date object', new Date(Number.NaN)],
   ])('rejects %s as Retry-After', (_, retryAfter) => {
     const result = createSafeFailureHttpResult({ status: 503, retryAfter });

package/tests/shellStream.test.ts

@@ -83,3 +83,40 @@ describe('conserving web shell stream', () => {
     expect(published).toEqual(['previous']);
   });
 });
+
+test('cancellation waits for the owned source cancellation to finish once', async () => {
+  let release!: () => void;
+  let started!: () => void;
+  const cancelling = new Promise<void>(resolve => {
+    started = resolve;
+  });
+  const gate = new Promise<void>(resolve => {
+    release = resolve;
+  });
+  const cancel = rstest.fn(async () => {
+    started();
+    await gate;
+  });
+  const source = new ReadableStream<Uint8Array>({ cancel });
+  const reader = createConservingWebShellStream(source, {}, MARKER).getReader();
+  let settled = false;
+  const cancellation = reader.cancel('stop').then(() => {
+    settled = true;
+  });
+  await cancelling;
+  expect(settled).toBe(false);
+  release();
+  await cancellation;
+  expect(cancel).toHaveBeenCalledExactlyOnceWith('stop');
+});
+
+test('cancellation propagates an owned source cleanup failure', async () => {
+  const source = new ReadableStream<Uint8Array>({
+    cancel() {
+      throw new Error('cleanup failed');
+    },
+  });
+  await expect(
+    createConservingWebShellStream(source, {}, MARKER).cancel('stop'),
+  ).rejects.toThrow('cleanup failed');
+});