@fluojs/testing 1.0.6 → 3.0.0

package/dist/module.js

@@ -1,7 +1,8 @@
 import { getModuleMetadata } from '@fluojs/core';
 import { isForwardRef, isOptionalToken, Scope } from '@fluojs/di';
-import { bootstrapModule } from '@fluojs/runtime';
+import { resolveMultiContribution } from '@fluojs/di/internal';
 import { createDispatcher, createHandlerMapping } from '@fluojs/http';
+import { bootstrapModule } from '@fluojs/runtime';
 import { createTestRequestContextMiddleware, makeRequest } from './http.js';
 /**
  * Returns providers declared on a module metadata definition.
@@ -45,9 +46,10 @@ export function extractModuleImports(moduleType) {
   return metadata.imports;
 }
 function createHandlerSources(bootstrappedModules) {
+  const globalModules = bootstrappedModules.filter(compiledModule => compiledModule.definition.global);
   return bootstrappedModules.flatMap(compiledModule => (compiledModule.definition.controllers ?? []).map(controllerToken => ({
     controllerToken,
-    moduleMiddleware: compiledModule.definition.middleware ?? [],
+    moduleMiddleware: [...globalModules.filter(globalModule => globalModule !== compiledModule).flatMap(globalModule => globalModule.definition.middleware ?? []), ...(compiledModule.definition.middleware ?? [])],
     moduleType: compiledModule.type
   })));
 }
@@ -117,33 +119,7 @@ function isSingletonLifecycleProvider(provider) {
   if (provider.scope !== Scope.DEFAULT) {
     return false;
   }
-  return provider.type === 'class' || provider.type === 'value' && hasAnyBootstrapLifecycleHook(provider.useValue);
-}
-async function resolveLifecycleDependency(entry, bootstrapped, introspection) {
-  if (isOptionalToken(entry) && !hasTokenInContainer(introspection, entry.token)) {
-    return undefined;
-  }
-  return bootstrapped.container.resolve(dependencyToken(entry));
-}
-async function instantiateLifecycleProvider(provider, bootstrapped, introspection) {
-  if (provider.type !== 'class' || !provider.useClass) {
-    throw new Error(`Lifecycle provider ${String(provider.provide)} must use a class provider.`);
-  }
-  const dependencies = await Promise.all(provider.inject.map(entry => resolveLifecycleDependency(entry, bootstrapped, introspection)));
-  return new provider.useClass(...dependencies);
-}
-async function resolveMultiLifecycleProvider(provider, bootstrapped, introspection) {
-  const cache = rootContainerIntrospection(introspection).multiSingletonCache;
-  const cached = cache.get(provider);
-  if (cached) {
-    return cached;
-  }
-  const instance = instantiateLifecycleProvider(provider, bootstrapped, introspection).catch(error => {
-    cache.delete(provider);
-    throw error;
-  });
-  cache.set(provider, instance);
-  return instance;
+  return provider.type === 'class' || provider.type === 'factory' || provider.type === 'value' && hasAnyBootstrapLifecycleHook(provider.useValue);
 }
 async function resolveTestingLifecycleInstances(bootstrapped, overrides = []) {
   const lifecycleProviders = [...bootstrapped.effectiveProviders.runtimeProviders, ...bootstrapped.effectiveProviders.moduleProviders, ...overrides];
@@ -153,35 +129,27 @@ async function resolveTestingLifecycleInstances(bootstrapped, overrides = []) {
   for (const provider of lifecycleProviders) {
     const token = providerToken(provider);
     const effectiveProviders = effectiveProvidersForToken(introspection, token);
-    for (let index = 0; index < effectiveProviders.length; index += 1) {
-      const effectiveProvider = effectiveProviders[index];
-      if (!effectiveProvider) {
-        continue;
-      }
-      if (seenProviders.has(effectiveProvider)) {
-        continue;
-      }
-      seenProviders.add(effectiveProvider);
-      if (!isSingletonLifecycleProvider(effectiveProvider)) {
-        continue;
-      }
-      if (effectiveProvider.type === 'value') {
-        instances.push(effectiveProvider.useValue);
-        continue;
-      }
-      try {
-        if (effectiveProvider.multi === true) {
-          instances.push(await resolveMultiLifecycleProvider(effectiveProvider, bootstrapped, introspection));
-          continue;
-        }
-        instances.push(await bootstrapped.container.resolve(token));
-      } catch (error) {
-        if (error instanceof Error && error.message.includes('Request-scoped provider')) {
-          continue;
-        }
-        throw error;
-      }
+    const nextUnseenProviderIndex = effectiveProviders.findIndex(effectiveProvider => !seenProviders.has(effectiveProvider));
+    if (nextUnseenProviderIndex === -1) {
+      continue;
+    }
+    const effectiveProvider = effectiveProviders[nextUnseenProviderIndex];
+    if (!effectiveProvider) {
+      continue;
+    }
+    seenProviders.add(effectiveProvider);
+    if (!isSingletonLifecycleProvider(effectiveProvider)) {
+      continue;
     }
+    if (effectiveProvider.type === 'value') {
+      instances.push(effectiveProvider.useValue);
+      continue;
+    }
+    if (effectiveProvider.multi === true) {
+      instances.push(await resolveMultiContribution(bootstrapped.container, token, nextUnseenProviderIndex));
+      continue;
+    }
+    instances.push(await bootstrapped.container.resolve(token));
   }
   return instances;
 }
@@ -228,30 +196,6 @@ function dependencyToken(entry) {
   }
   return entry;
 }
-function trackFactoryResolutionKind(provider, factoryResolutionKinds) {
-  if (provider.type !== 'factory' || !provider.useFactory) {
-    return;
-  }
-  const originalFactory = provider.useFactory;
-  provider.useFactory = (...deps) => {
-    const value = originalFactory(...deps);
-    factoryResolutionKinds.set(provider, isPromiseLike(value) ? 'async' : 'sync');
-    return value;
-  };
-}
-function installFactoryResolutionTracking(target, factoryResolutionKinds) {
-  if (target.parent) {
-    installFactoryResolutionTracking(target.parent, factoryResolutionKinds);
-  }
-  for (const provider of target.registrations.values()) {
-    trackFactoryResolutionKind(provider, factoryResolutionKinds);
-  }
-  for (const providers of target.multiRegistrations.values()) {
-    for (const provider of providers) {
-      trackFactoryResolutionKind(provider, factoryResolutionKinds);
-    }
-  }
-}
 function providerGraphIsSyncResolvable(state, token, visited = new Set()) {
   if (visited.has(token)) {
     return true;
@@ -332,6 +276,7 @@ function instantiateSyncProvider(provider, state) {
         if (isPromiseLike(value)) {
           throw new Error(`Token ${String(provider.provide)} requires async resolution. Use resolve() instead of get() for async providers.`);
         }
+        state.cacheOwner.recordFactoryResolution(provider, 'sync');
         return value;
       }
     case 'class':
@@ -355,15 +300,20 @@ function resolveSyncProvider(provider, state) {
   if (provider.scope === 'transient') {
     return instantiateSyncProvider(provider, state);
   }
-  if (state.syncSingletonValues.has(provider.provide)) {
-    return state.syncSingletonValues.get(provider.provide);
+  const memo = state.syncSingletonValues.get(provider.provide);
+  if (memo) {
+    return memo.value;
   }
   if (state.singletonCache.has(provider.provide)) {
     throw new Error(`Token ${String(provider.provide)} was already resolved asynchronously. Use resolve() instead of get() for this provider.`);
   }
   const instance = instantiateSyncProvider(provider, state);
-  state.syncSingletonValues.set(provider.provide, instance);
-  state.singletonCache.set(provider.provide, Promise.resolve(instance));
+  const cacheEntry = Promise.resolve(instance);
+  state.syncSingletonValues.set(provider.provide, {
+    cacheEntry,
+    value: instance
+  });
+  state.cacheOwner.setSingleton(provider.provide, cacheEntry);
   return instance;
 }
 function resolveSyncMultiProvider(provider, state) {
@@ -373,15 +323,20 @@ function resolveSyncMultiProvider(provider, state) {
   if (provider.scope === 'transient') {
     return instantiateSyncProvider(provider, state);
   }
-  if (state.syncMultiSingletonValues.has(provider)) {
-    return state.syncMultiSingletonValues.get(provider);
+  const memo = state.syncMultiSingletonValues.get(provider);
+  if (memo) {
+    return memo.value;
   }
   if (state.multiSingletonCache.has(provider)) {
     throw new Error(`Token ${String(provider.provide)} was already resolved asynchronously. Use resolve() instead of get() for this provider.`);
   }
   const instance = instantiateSyncProvider(provider, state);
-  state.syncMultiSingletonValues.set(provider, instance);
-  state.multiSingletonCache.set(provider, Promise.resolve(instance));
+  const cacheEntry = Promise.resolve(instance);
+  state.syncMultiSingletonValues.set(provider, {
+    cacheEntry,
+    value: instance
+  });
+  state.cacheOwner.setMultiSingleton(provider, cacheEntry);
   return instance;
 }
 function resolveSyncToken(token, state) {
@@ -405,31 +360,60 @@ function resolveSyncToken(token, state) {
 }
 function createSyncResolver(container) {
   const introspection = toContainerIntrospection(container);
-  const factoryResolutionKinds = new WeakMap();
-  installFactoryResolutionTracking(introspection, factoryResolutionKinds);
+  const rootIntrospection = rootContainerIntrospection(introspection);
   const state = {
-    factoryResolutionKinds,
+    cacheOwner: rootIntrospection.cacheOwner,
+    factoryResolutionKinds: rootIntrospection.factoryResolutionKinds,
     introspection,
-    multiSingletonCache: rootContainerIntrospection(introspection).multiSingletonCache,
+    multiSingletonCache: rootIntrospection.multiSingletonCache,
     resolutionChain: new Set(),
-    singletonCache: rootContainerIntrospection(introspection).singletonCache,
+    singletonCache: rootIntrospection.singletonCache,
     syncMultiSingletonValues: new Map(),
     syncSingletonValues: new Map()
   };
+  const refreshState = () => {
+    const freshIntrospection = toContainerIntrospection(container);
+    const freshRootIntrospection = rootContainerIntrospection(freshIntrospection);
+    state.cacheOwner = freshRootIntrospection.cacheOwner;
+    state.factoryResolutionKinds = freshRootIntrospection.factoryResolutionKinds;
+    state.introspection = freshIntrospection;
+    state.multiSingletonCache = freshRootIntrospection.multiSingletonCache;
+    state.singletonCache = freshRootIntrospection.singletonCache;
+    for (const [token, memo] of state.syncSingletonValues) {
+      if (state.singletonCache.get(token) !== memo.cacheEntry) {
+        state.syncSingletonValues.delete(token);
+      }
+    }
+    for (const [provider, memo] of state.syncMultiSingletonValues) {
+      if (state.multiSingletonCache.get(provider) !== memo.cacheEntry) {
+        state.syncMultiSingletonValues.delete(provider);
+      }
+    }
+  };
   return {
-    get: token => resolveSyncToken(token, state),
+    get: token => {
+      refreshState();
+      return resolveSyncToken(token, state);
+    },
     syncFromContainer: async () => {
+      refreshState();
       for (const [token, promise] of state.singletonCache) {
         if (!canPromoteCachedSingleton(state, token)) {
           continue;
         }
-        state.syncSingletonValues.set(token, await promise);
+        state.syncSingletonValues.set(token, {
+          cacheEntry: promise,
+          value: await promise
+        });
       }
       for (const [provider, promise] of state.multiSingletonCache) {
         if (!providerGraphForProviderIsSyncResolvable(state, provider)) {
           continue;
         }
-        state.syncMultiSingletonValues.set(provider, await promise);
+        state.syncMultiSingletonValues.set(provider, {
+          cacheEntry: promise,
+          value: await promise
+        });
       }
     }
   };
@@ -523,18 +507,29 @@ class DefaultTestingModuleBuilder {
     return this;
   }
   async compile() {
-    const bootstrapped = this.bootstrapTestingModule();
-    const syncResolver = createSyncResolver(bootstrapped.container);
-    await runTestingBootstrapLifecycle(bootstrapped, this.overrides);
-    await syncResolver.syncFromContainer();
-    return this.createTestingModuleRef(bootstrapped, syncResolver);
-  }
-  bootstrapTestingModule() {
     const bootstrapped = this.bootstrapWithModuleReplacements();
-    if (this.overrides.length > 0) {
-      bootstrapped.container.override(...this.overrides);
+    try {
+      if (this.overrides.length > 0) {
+        bootstrapped.container.override(...this.overrides);
+      }
+      const syncResolver = createSyncResolver(bootstrapped.container);
+      await runTestingBootstrapLifecycle(bootstrapped, this.overrides);
+      await syncResolver.syncFromContainer();
+      const resolve = bootstrapped.container.resolve.bind(bootstrapped.container);
+      bootstrapped.container.resolve = async token => {
+        const value = await resolve(token);
+        await syncResolver.syncFromContainer();
+        return value;
+      };
+      return this.createTestingModuleRef(bootstrapped, syncResolver);
+    } catch (error) {
+      try {
+        await bootstrapped.container.dispose();
+      } catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], 'Testing module compilation and container cleanup both failed.');
+      }
+      throw error;
     }
-    return bootstrapped;
   }
   bootstrapWithModuleReplacements() {
     return bootstrapModule(this.options.rootModule, this.createBootstrapModuleOptions());
@@ -545,11 +540,7 @@ class DefaultTestingModuleBuilder {
       ...bootstrapped,
       has: token => bootstrapped.container.has(token),
       get: token => syncResolver.get(token),
-      resolve: async token => {
-        const value = await bootstrapped.container.resolve(token);
-        await syncResolver.syncFromContainer();
-        return value;
-      },
+      resolve: token => bootstrapped.container.resolve(token),
       resolveAll: async tokens => {
         const results = [];
         const errors = [];
@@ -570,7 +561,6 @@ class DefaultTestingModuleBuilder {
           }) => `  - ${String(token)}: ${error instanceof Error ? error.message : String(error)}`).join('\n');
           throw new Error(`Failed to resolve ${errors.length} of ${tokens.length} tokens:\n${summary}`);
         }
-        await syncResolver.syncFromContainer();
         return results;
       },
       dispatch: async request => {

package/dist/portability/error-representation-abort-portability.d.ts

@@ -0,0 +1,36 @@
+import { type ModuleType } from '@fluojs/runtime';
+import type { NetworkHttpErrorRepresentationBootstrapOptions, WebHttpErrorRepresentationBootstrapOptions } from './error-representation-portability.js';
+type NetworkApp = {
+    close(): Promise<void>;
+    listen(): Promise<void>;
+};
+type WebApp = {
+    close(): Promise<void>;
+    dispatch(request: Request): Promise<Response>;
+};
+type NetworkHarnessOptions<TBootstrapOptions extends object, TApp extends NetworkApp> = {
+    readonly bootstrap: (rootModule: ModuleType, options: TBootstrapOptions) => Promise<TApp>;
+    readonly createBootstrapOptions: (options: NetworkHttpErrorRepresentationBootstrapOptions) => TBootstrapOptions;
+    readonly name: string;
+};
+type WebHarnessOptions<TBootstrapOptions extends object, TApp extends WebApp> = {
+    readonly bootstrap: (rootModule: ModuleType, options: TBootstrapOptions) => Promise<TApp>;
+    readonly createBootstrapOptions: (options: WebHttpErrorRepresentationBootstrapOptions) => TBootstrapOptions;
+    readonly name: string;
+};
+/**
+ * Verifies that a disconnected network request commits neither HTML nor canonical JSON fallback.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after native disconnect and no-representation-write checks pass.
+ */
+export declare function assertNetworkHttpErrorRepresentationAbortPortability<TBootstrapOptions extends object, TApp extends NetworkApp>(options: NetworkHarnessOptions<TBootstrapOptions, TApp>): Promise<void>;
+/**
+ * Verifies that an aborted Web request commits neither HTML nor canonical JSON fallback.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after Web abort and no-representation-write checks pass.
+ */
+export declare function assertWebHttpErrorRepresentationAbortPortability<TBootstrapOptions extends object, TApp extends WebApp>(options: WebHarnessOptions<TBootstrapOptions, TApp>): Promise<void>;
+export {};
+//# sourceMappingURL=error-representation-abort-portability.d.ts.map

package/dist/portability/error-representation-abort-portability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-representation-abort-portability.d.ts","sourceRoot":"","sources":["../../src/portability/error-representation-abort-portability.ts"],"names":[],"mappings":"AAKA,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEhE,OAAO,KAAK,EACV,8CAA8C,EAC9C,0CAA0C,EAC3C,MAAM,uCAAuC,CAAC;AAE/C,KAAK,UAAU,GAAG;IAChB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB,CAAC;AAEF,KAAK,MAAM,GAAG;IACZ,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CAC/C,CAAC;AAEF,KAAK,qBAAqB,CAAC,iBAAiB,SAAS,MAAM,EAAE,IAAI,SAAS,UAAU,IAAI;IACtF,QAAQ,CAAC,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1F,QAAQ,CAAC,sBAAsB,EAAE,CAC/B,OAAO,EAAE,8CAA8C,KACpD,iBAAiB,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,KAAK,iBAAiB,CAAC,iBAAiB,SAAS,MAAM,EAAE,IAAI,SAAS,MAAM,IAAI;IAC9E,QAAQ,CAAC,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1F,QAAQ,CAAC,sBAAsB,EAAE,CAC/B,OAAO,EAAE,0CAA0C,KAChD,iBAAiB,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,CAAC;AAoKF;;;;;GAKG;AACH,wBAAsB,oDAAoD,CACxE,iBAAiB,SAAS,MAAM,EAChC,IAAI,SAAS,UAAU,EACvB,OAAO,EAAE,qBAAqB,CAAC,iBAAiB,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BxE;AAED;;;;;GAKG;AACH,wBAAsB,gDAAgD,CACpE,iBAAiB,SAAS,MAAM,EAChC,IAAI,SAAS,MAAM,EACnB,OAAO,EAAE,iBAAiB,CAAC,iBAAiB,EAAE,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAwBpE"}

package/dist/portability/error-representation-abort-portability.js

@@ -0,0 +1,190 @@
+import { defineModule } from '@fluojs/runtime';
+function createDeferred() {
+  let resolve = () => {};
+  const promise = new Promise(resolvePromise => {
+    resolve = resolvePromise;
+  });
+  return {
+    promise,
+    resolve
+  };
+}
+function createAbortProbe() {
+  const providerAborted = createDeferred();
+  const providerStarted = createDeferred();
+  const requestFinished = createDeferred();
+  let providerCalls = 0;
+  const representationWrites = [];
+  const middleware = {
+    async handle(context, next) {
+      const send = context.response.send.bind(context.response);
+      context.response.send = body => {
+        if (body !== undefined) {
+          representationWrites.push(body);
+        }
+        return send(body);
+      };
+      await next();
+    }
+  };
+  const requestObserver = {
+    onRequestFinish() {
+      requestFinished.resolve();
+    }
+  };
+  const html = {
+    render({
+      request
+    }) {
+      providerCalls += 1;
+      providerStarted.resolve();
+      return new Promise((resolve, reject) => {
+        const signal = request.signal;
+        if (signal === undefined) {
+          reject(new Error('The adapter did not expose an AbortSignal to the HTML error provider.'));
+          return;
+        }
+        const completeAfterAbort = () => {
+          providerAborted.resolve();
+          resolve('<html><body>late error document</body></html>');
+        };
+        if (signal.aborted) {
+          completeAfterAbort();
+          return;
+        }
+        signal.addEventListener('abort', completeAfterAbort, {
+          once: true
+        });
+      });
+    }
+  };
+  return {
+    assertNoCommit(name) {
+      if (providerCalls !== 1) {
+        throw new Error(`${name} did not execute exactly one in-flight HTML error provider before abort.`);
+      }
+      if (representationWrites.length !== 0) {
+        throw new Error(`${name} committed an HTML or canonical JSON fallback response after abort: ${JSON.stringify(representationWrites)}.`);
+      }
+    },
+    bootstrapOptions: {
+      cors: false,
+      errorRepresentation: {
+        html
+      },
+      middleware: [middleware]
+    },
+    providerAborted: providerAborted.promise,
+    providerStarted: providerStarted.promise,
+    requestFinished: requestFinished.promise,
+    requestObserver
+  };
+}
+function hasListenTarget(value) {
+  return typeof value === 'object' && value !== null && 'getListenTarget' in value && typeof value.getListenTarget === 'function';
+}
+function resolveListeningUrl(app, name) {
+  const adapter = Reflect.get(app, 'adapter');
+  if (!hasListenTarget(adapter)) {
+    throw new Error(`${name} abort portability check could not resolve its listener URL.`);
+  }
+  return adapter.getListenTarget().url;
+}
+async function withTimeout(promise, name, phase) {
+  let timeout;
+  const timeoutPromise = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      reject(new Error(`${name} timed out while waiting for ${phase}.`));
+    }, 2_000);
+  });
+  try {
+    await Promise.race([promise, timeoutPromise]);
+  } finally {
+    if (timeout !== undefined) {
+      clearTimeout(timeout);
+    }
+  }
+}
+async function closeAfterAbortAssertion(app, name, assertion) {
+  let assertionError;
+  try {
+    await assertion();
+  } catch (error) {
+    assertionError = error;
+  }
+  try {
+    await app.close();
+  } catch (cleanupError) {
+    throw assertionError === undefined ? cleanupError : new AggregateError([assertionError, cleanupError], `${name} abort assertion and cleanup both failed.`);
+  }
+  if (assertionError !== undefined) {
+    throw assertionError;
+  }
+}
+function createEmptyModule() {
+  class AppModule {}
+  defineModule(AppModule, {});
+  return AppModule;
+}
+
+/**
+ * Verifies that a disconnected network request commits neither HTML nor canonical JSON fallback.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after native disconnect and no-representation-write checks pass.
+ */
+export async function assertNetworkHttpErrorRepresentationAbortPortability(options) {
+  const probe = createAbortProbe();
+  const app = await options.bootstrap(createEmptyModule(), options.createBootstrapOptions({
+    ...probe.bootstrapOptions,
+    observers: [probe.requestObserver],
+    port: 0
+  }));
+  await closeAfterAbortAssertion(app, options.name, async () => {
+    await app.listen();
+    const {
+      request
+    } = await import('node:http');
+    const clientRequest = request(`${resolveListeningUrl(app, options.name)}/abort-error-representation`, {
+      headers: {
+        accept: 'text/html'
+      }
+    });
+    clientRequest.on('error', () => {});
+    try {
+      clientRequest.end();
+      await withTimeout(probe.providerStarted, options.name, 'the HTML error provider to start');
+      clientRequest.destroy();
+      await withTimeout(probe.providerAborted, options.name, 'the provider request signal to abort');
+      await withTimeout(probe.requestFinished, options.name, 'the aborted request lifecycle to finish');
+      probe.assertNoCommit(options.name);
+    } finally {
+      clientRequest.destroy();
+    }
+  });
+}
+
+/**
+ * Verifies that an aborted Web request commits neither HTML nor canonical JSON fallback.
+ *
+ * @param options Adapter bootstrap and identity callbacks.
+ * @returns A promise that resolves after Web abort and no-representation-write checks pass.
+ */
+export async function assertWebHttpErrorRepresentationAbortPortability(options) {
+  const probe = createAbortProbe();
+  const app = await options.bootstrap(createEmptyModule(), options.createBootstrapOptions(probe.bootstrapOptions));
+  await closeAfterAbortAssertion(app, options.name, async () => {
+    const abortController = new AbortController();
+    const dispatch = app.dispatch(new Request('https://runtime.test/abort-error-representation', {
+      headers: {
+        accept: 'text/html'
+      },
+      signal: abortController.signal
+    }));
+    await withTimeout(probe.providerStarted, options.name, 'the HTML error provider to start');
+    abortController.abort();
+    await withTimeout(probe.providerAborted, options.name, 'the provider request signal to abort');
+    await withTimeout(dispatch.then(() => undefined), options.name, 'the aborted Web request dispatch to finish');
+    probe.assertNoCommit(options.name);
+  });
+}

package/dist/portability/error-representation-portability-fixture.d.ts

@@ -0,0 +1,58 @@
+import { type HttpErrorRepresentationOptions, type Middleware } from '@fluojs/http';
+import { type ModuleType } from '@fluojs/runtime';
+type ErrorRepresentationBootstrapOptions = {
+    readonly cors: false;
+    readonly errorRepresentation: HttpErrorRepresentationOptions | undefined;
+    readonly middleware: Middleware[];
+};
+type RepresentationResponses = {
+    readonly binary: Response;
+    readonly binaryHead: Response;
+    readonly committed: Response;
+    readonly head: Response;
+    readonly html: Response;
+    readonly json: Response;
+    readonly jsonHead: Response;
+    readonly plain: Response;
+    readonly plainHead: Response;
+    readonly success: Response;
+    readonly successHead: Response;
+    readonly unsupported: Response;
+    readonly unsupportedHead: Response;
+};
+/**
+ * Verifies provider-less canonical JSON metadata and body suppression for a HEAD response.
+ *
+ * @param name Adapter name included in assertion failures.
+ * @param response Provider-less HEAD response returned by the adapter.
+ * @returns A promise that resolves when the response preserves the portable contract.
+ */
+export declare function assertProviderlessHeadResponse(name: string, response: Response): Promise<void>;
+/**
+ * Verifies negotiated error and successful HEAD responses returned by an adapter.
+ *
+ * @param name Adapter name included in assertion failures.
+ * @param responses Responses collected from the shared representation fixture.
+ * @returns A promise that resolves when every response preserves the portable contract.
+ */
+export declare function assertRepresentationResponses(name: string, responses: RepresentationResponses): Promise<void>;
+/**
+ * Creates the shared application module used by error-representation portability checks.
+ *
+ * @returns A module containing success, error, HEAD, and committed-response routes.
+ */
+export declare function createRepresentationFixture(): ModuleType;
+/**
+ * Creates bootstrap options with the shared HTML error-representation provider enabled.
+ *
+ * @returns Common adapter bootstrap options for negotiated representation checks.
+ */
+export declare function createErrorRepresentationOptions(): ErrorRepresentationBootstrapOptions;
+/**
+ * Creates bootstrap options without an HTML error-representation provider.
+ *
+ * @returns Common adapter bootstrap options for canonical JSON fallback checks.
+ */
+export declare function createProviderlessErrorRepresentationOptions(): ErrorRepresentationBootstrapOptions;
+export {};
+//# sourceMappingURL=error-representation-portability-fixture.d.ts.map

package/dist/portability/error-representation-portability-fixture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-representation-portability-fixture.d.ts","sourceRoot":"","sources":["../../src/portability/error-representation-portability-fixture.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,8BAA8B,EACnC,KAAK,UAAU,EAGhB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAgB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAEhE,KAAK,mCAAmC,GAAG;IACzC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,mBAAmB,EAAE,8BAA8B,GAAG,SAAS,CAAC;IACzE,QAAQ,CAAC,UAAU,EAAE,UAAU,EAAE,CAAC;CACnC,CAAC;AAEF,KAAK,uBAAuB,GAAG;IAC7B,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC/B,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC;IAC/B,QAAQ,CAAC,eAAe,EAAE,QAAQ,CAAC;CACpC,CAAC;AAsCF;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAKpG;AAED;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,uBAAuB,GACjC,OAAO,CAAC,IAAI,CAAC,CAgEf;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,IAAI,UAAU,CAyDxD;AAED;;;;GAIG;AACH,wBAAgB,gCAAgC,IAAI,mCAAmC,CAYtF;AAED;;;;GAIG;AACH,wBAAgB,4CAA4C,IAAI,mCAAmC,CAMlG"}