@powersync/service-core 1.27.2 → 1.28.1

package/test/src/SyncConfigEngine.test.ts

@@ -0,0 +1,208 @@
+import type { RouteAPI } from '@/api/RouteAPI.js';
+import { ServiceContextContainer, ServiceContextMode } from '@/system/ServiceContext.js';
+import { SyncConfigEngine, SyncConfigRejectionReason, SyncConfigResultStatus } from '@/system/SyncConfigEngine.js';
+import { CompoundConfigCollector } from '@/util/config/compound-config-collector.js';
+import * as syncConfigParser from '@powersync/service-sync-rules';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it, vi } from 'vitest';
+import { mockServiceContext } from './routes/mocks.js';
+
+const CONTENT = /* yaml */ `
+  # sync config fixture.
+  config:
+    edition: 3
+  streams:
+    orders:
+      query: SELECT * FROM orders
+`;
+
+function source(): RouteAPI {
+  const adapter = mockServiceContext(null).routerEngine.getAPI();
+  adapter.getParseSyncRulesOptions = () => ({
+    defaultSchema: 'source_db',
+    connections: { default: { type: 'mongodb' } }
+  });
+  adapter.validateSourceCapabilities = async () => [];
+  return adapter;
+}
+
+describe('SyncConfigEngine', () => {
+  it('constructs the shared engine before source adapter registration', async () => {
+    const configuration = await new CompoundConfigCollector().collectConfig({
+      config_base64: Buffer.from(
+        JSON.stringify({ storage: { type: 'mongodb' }, sync_config: { content: CONTENT } })
+      ).toString('base64')
+    });
+    const context = new ServiceContextContainer({ serviceMode: ServiceContextMode.API, configuration });
+    const adapter = source();
+    const parseOptions = vi.spyOn(adapter, 'getParseSyncRulesOptions');
+    const engine = context.syncConfigEngine;
+    // Source modules register after context construction; creating the engine must not resolve the adapter.
+    context.routerEngine.registerAPI(adapter);
+    expect(context.syncConfigEngine).toBe(engine);
+    expect(parseOptions).not.toHaveBeenCalled();
+    expect((await engine.getConfigured()).status).toBe(SyncConfigResultStatus.ACCEPTED);
+    expect(parseOptions).toHaveBeenCalledOnce();
+  });
+
+  it('shares a single source-aware parse and capability result between concurrent consumers', async () => {
+    const adapter = source();
+    const capability = vi.spyOn(adapter, 'validateSourceCapabilities').mockImplementation(async (config) => {
+      expect(config.getSourceTables()[0].schema).toBe('source_db');
+      return [{ level: 'warning', message: 'Advisory' }];
+    });
+    const parse = vi.spyOn(syncConfigParser, 'parseSyncConfig');
+    try {
+      const settings = {
+        present: true,
+        exit_on_error: false,
+        content: CONTENT
+      };
+      const service = new SyncConfigEngine(settings, () => adapter);
+      // Startup and diagnostics can race on first use; both must share the same in-flight parse.
+      const first = service.getConfigured();
+      expect(service.getConfigured()).toBe(first);
+      const [replication, diagnostics] = await Promise.all([first, service.getConfigured()]);
+      expect(replication).toBe(diagnostics);
+      expect(replication.status).toBe(SyncConfigResultStatus.ACCEPTED);
+      expect(replication).toMatchObject({
+        diagnostics: [expect.objectContaining({ level: 'warning', message: 'Advisory' })]
+      });
+      expect(capability).toHaveBeenCalledOnce();
+      expect(parse).toHaveBeenCalledOnce();
+      settings.content = 'streams: [';
+      expect(await service.getConfigured()).toBe(replication);
+    } finally {
+      parse.mockRestore();
+    }
+  });
+
+  it('retains capability errors and locations in the common rejection decision', async () => {
+    const adapter = source();
+    vi.spyOn(adapter, 'validateSourceCapabilities').mockResolvedValue([
+      { level: 'fatal', message: 'Unsupported executor', location: { start_offset: 0, end_offset: 5 } }
+    ]);
+    const result = await new SyncConfigEngine({ present: false, exit_on_error: true }, () => adapter).validate(CONTENT);
+    expect(result).toMatchObject({
+      status: SyncConfigResultStatus.REJECTED,
+      reason: SyncConfigRejectionReason.CAPABILITY,
+      diagnostics: [expect.objectContaining({ level: 'fatal', location: { start_offset: 0, end_offset: 5 } })]
+    });
+    expect(result).not.toHaveProperty('compiled');
+  });
+
+  it.each([
+    { content: 'streams: [', hasParsedConfig: true },
+    { content: '# empty config\n', hasParsedConfig: false }
+  ])(
+    'checks capabilities for malformed input whenever a config was produced (parsed=$hasParsedConfig)',
+    async ({ content, hasParsedConfig }) => {
+      const adapter = source();
+      const capability = vi.spyOn(adapter, 'validateSourceCapabilities');
+      const result = await new SyncConfigEngine({ present: false, exit_on_error: false }, () => adapter).validate(
+        content
+      );
+      expect(result).toMatchObject({
+        status: SyncConfigResultStatus.REJECTED,
+        reason: SyncConfigRejectionReason.PARSE
+      });
+      expect(result.diagnostics.some((diagnostic) => diagnostic.level === 'fatal')).toBe(true);
+      // Partial parses still need capability diagnostics; a parser exception leaves no config to check.
+      expect(capability).toHaveBeenCalledTimes(hasParsedConfig ? 1 : 0);
+    }
+  );
+
+  it.each([{ capabilityCheckThrows: false }, { capabilityCheckThrows: true }])(
+    'collects source-capability failures alongside fatal parser diagnostics (throws=$capabilityCheckThrows)',
+    async ({ capabilityCheckThrows }) => {
+      const adapter = source();
+      const capability = vi.spyOn(adapter, 'validateSourceCapabilities').mockImplementation(async () => {
+        if (capabilityCheckThrows) {
+          throw new Error('Unsupported executor');
+        }
+        return [{ level: 'fatal', message: 'Unsupported executor' }];
+      });
+      const result = await new SyncConfigEngine({ present: false, exit_on_error: false }, () => adapter).validate(
+        CONTENT.replace('SELECT * FROM orders', 'SELECT FROM')
+      );
+      expect(capability).toHaveBeenCalledOnce();
+      expect(result).toMatchObject({
+        status: SyncConfigResultStatus.REJECTED,
+        reason: SyncConfigRejectionReason.PARSE
+      });
+      // Keep both failures for diagnostics, with parsing as the primary rejection reason.
+      const fatal = result.diagnostics.filter((diagnostic) => diagnostic.level === 'fatal');
+      expect(fatal.some((diagnostic) => diagnostic.message === 'Unsupported executor')).toBe(true);
+      expect(fatal.some((diagnostic) => diagnostic.message !== 'Unsupported executor')).toBe(true);
+      expect(result).not.toHaveProperty('compiled');
+    }
+  );
+
+  it('validates submissions without changing the API-managed snapshot', async () => {
+    const adapter = source();
+    const parseOptions = vi.spyOn(adapter, 'getParseSyncRulesOptions');
+    const getRouteAPI = vi.fn(() => adapter);
+    const service = new SyncConfigEngine({ present: false, exit_on_error: false }, getRouteAPI);
+    const configured = await service.getConfigured();
+    expect(getRouteAPI).not.toHaveBeenCalled();
+    expect(parseOptions).not.toHaveBeenCalled();
+    expect(configured.status).toBe(SyncConfigResultStatus.ABSENT);
+    // An API submission must not become this runner's configured snapshot.
+    expect((await service.validate('streams: [')).status).toBe(SyncConfigResultStatus.REJECTED);
+    expect((await service.validate(CONTENT)).status).toBe(SyncConfigResultStatus.ACCEPTED);
+    expect(await service.getConfigured()).toBe(configured);
+  });
+
+  it.each([
+    { inputKind: 'valid', initial: CONTENT },
+    { inputKind: 'invalid query', initial: CONTENT.replace('SELECT * FROM orders', 'SELECT FROM') }
+  ])('retains the first filesystem result until a new engine is created: $inputKind', async ({ initial }) => {
+    const dir = await mkdtemp(join(tmpdir(), 'sync-config-snapshot-'));
+    try {
+      const path = join(dir, 'sync-config.yaml');
+      const settings = { present: true, path, exit_on_error: false };
+      const adapter = source();
+      await writeFile(path, initial);
+      const engine = new SyncConfigEngine(settings, () => adapter);
+      const first = await engine.getConfigured();
+      expect(first.status).toBe(
+        initial === CONTENT ? SyncConfigResultStatus.ACCEPTED : SyncConfigResultStatus.REJECTED
+      );
+      const replacement = initial === CONTENT ? CONTENT.replace('SELECT * FROM orders', 'SELECT FROM') : CONTENT;
+      // File edits take effect after restart, represented here by constructing a new engine.
+      await writeFile(path, replacement);
+      expect(await engine.getConfigured()).toBe(first);
+      expect(await new SyncConfigEngine(settings, () => adapter).getConfigured()).toMatchObject({
+        content: replacement,
+        status: replacement === CONTENT ? SyncConfigResultStatus.ACCEPTED : SyncConfigResultStatus.REJECTED
+      });
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+
+  it('retains an unavailable file result until a new engine is created', async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'sync-config-unavailable-'));
+    try {
+      const settings = { present: true, path: join(dir, 'sync-config.yaml'), exit_on_error: false };
+      const adapter = source();
+      const parseOptions = vi.spyOn(adapter, 'getParseSyncRulesOptions');
+      const getRouteAPI = vi.fn(() => adapter);
+      const engine = new SyncConfigEngine(settings, getRouteAPI);
+      const first = await engine.getConfigured();
+      expect(first).toMatchObject({ status: SyncConfigResultStatus.UNAVAILABLE, error: expect.any(Error) });
+      // A file appearing later must not silently switch the running process to another snapshot.
+      await writeFile(settings.path, CONTENT);
+      expect(await engine.getConfigured()).toBe(first);
+      expect(getRouteAPI).not.toHaveBeenCalled();
+      expect(parseOptions).not.toHaveBeenCalled();
+      expect((await new SyncConfigEngine(settings, () => adapter).getConfigured()).status).toBe(
+        SyncConfigResultStatus.ACCEPTED
+      );
+    } finally {
+      await rm(dir, { recursive: true, force: true });
+    }
+  });
+});

package/test/src/broadcast_iterable.test.ts

@@ -1,35 +1,43 @@
 import { BroadcastIterable, IterableSource } from '@/streams/BroadcastIterable.js';
-import { AsyncIterableX, interval } from 'ix/asynciterable/index.js';
-import { delayEach } from 'ix/asynciterable/operators/delayeach.js';
-import { take } from 'ix/asynciterable/operators/take.js';
-import { wrapWithAbort } from 'ix/asynciterable/operators/withabort.js';
-import { toArray } from 'ix/asynciterable/toarray.js';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 // The global setTimeout, not the one from timers/promises: vi.useFakeTimers() only replaces the global timers
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
+async function collect<T>(source: AsyncIterable<T>, options: { delayMs?: number; limit?: number } = {}): Promise<T[]> {
+  const results: T[] = [];
+  for await (const value of source) {
+    if (options.delayMs) await sleep(options.delayMs);
+    results.push(value);
+    if (results.length === options.limit) break;
+  }
+  return results;
+}
+
 describe('BroadcastIterable', () => {
   afterEach(() => {
     vi.useRealTimers();
   });
 
   it('should iterate', async () => {
-    const range = AsyncIterableX.from([1, 2, 3]);
-    const broadcast = new BroadcastIterable(() => range);
+    const range = async function* () {
+      yield* [1, 2, 3];
+    };
+    const broadcast = new BroadcastIterable(range);
 
-    const results = await toArray(broadcast);
+    const results = await collect(broadcast);
     expect(results).toEqual([1, 2, 3]);
     expect(broadcast.active).toBe(false);
   });
 
   it('should skip values if sink is slow', async () => {
-    const range = AsyncIterableX.from([1, 2, 3]);
-    const broadcast = new BroadcastIterable(() => range);
+    const range = async function* () {
+      yield* [1, 2, 3];
+    };
+    const broadcast = new BroadcastIterable(range);
 
     // Delay reading each element
-    const delayed = delayEach(1)(broadcast);
-    const results = await toArray(delayed);
+    const results = await collect(broadcast, { delayMs: 1 });
 
     // We only get a single value, then done.
     expect(results).toEqual([1]);
@@ -37,32 +45,58 @@ describe('BroadcastIterable', () => {
   });
 
   it('should abort', async () => {
-    const range = AsyncIterableX.from([1, 2, 3]);
+    const range = async function* () {
+      yield* [1, 2, 3];
+    };
     let recordedSignal: AbortSignal | undefined;
     const broadcast = new BroadcastIterable((signal) => {
       recordedSignal = signal;
-      return range;
+      return range();
     });
 
     const controller = new AbortController();
     const iter = broadcast[Symbol.asyncIterator](controller.signal);
     await iter.next();
     controller.abort();
-    await expect(iter.next()).rejects.toThrow('The operation has been aborted');
+    await expect(iter.next()).rejects.toBe(controller.signal.reason);
     expect(recordedSignal!.aborted).toEqual(true);
+    expect(recordedSignal!.reason).toBe(controller.signal.reason);
   });
 
+  it.each([new Error('subscriber cancelled'), 'cancelled', 0, false, null])(
+    'preserves subscriber abort reason %s when stopping the shared source',
+    async (reason) => {
+      let sourceSignal: AbortSignal | undefined;
+      const broadcast = new BroadcastIterable(async function* (signal) {
+        sourceSignal = signal;
+        yield 1;
+        if (!signal.aborted) {
+          await new Promise<void>((resolve) => signal.addEventListener('abort', () => resolve(), { once: true }));
+        }
+      });
+      const controller = new AbortController();
+      const iterator = broadcast[Symbol.asyncIterator](controller.signal);
+      await iterator.next();
+      controller.abort(reason);
+      await expect(iterator.next()).rejects.toBe(reason);
+      expect(sourceSignal!.reason).toBe(reason);
+    }
+  );
+
   it('should handle indefinite sources', async () => {
     vi.useFakeTimers();
-    const source: IterableSource<number> = (signal) => {
-      return wrapWithAbort(interval(1), signal);
+    const source: IterableSource<number> = async function* (signal) {
+      for (let i = 0; !signal.aborted; i++) {
+        await sleep(1);
+        signal.throwIfAborted();
+        yield i;
+      }
     };
 
     const broadcast = new BroadcastIterable(source);
 
-    const delayed = delayEach(10)(broadcast);
     expect(broadcast.active).toBe(false);
-    const resultsPromise = toArray(take(5)(delayed));
+    const resultsPromise = collect(broadcast, { delayMs: 10, limit: 5 });
     await vi.advanceTimersByTimeAsync(100);
     const results = await resultsPromise;
 
@@ -93,11 +127,9 @@ describe('BroadcastIterable', () => {
 
     const broadcast = new BroadcastIterable(source);
 
-    const delayed1 = delayEach(9)(broadcast);
-    const delayed2 = delayEach(10)(broadcast);
     expect(broadcast.active).toBe(false);
-    const results1Promise = toArray(take(5)(delayed1));
-    const results2Promise = toArray(take(5)(delayed2));
+    const results1Promise = collect(broadcast, { delayMs: 9, limit: 5 });
+    const results2Promise = collect(broadcast, { delayMs: 10, limit: 5 });
     await vi.advanceTimersByTimeAsync(100);
     const [results1, results2] = [await results1Promise, await results2Promise];
 
@@ -114,8 +146,7 @@ describe('BroadcastIterable', () => {
     expect(results2[4]).toBeLessThan(1045);
 
     // This starts a new source
-    const delayed3 = delayEach(10)(broadcast);
-    const results3Promise = toArray(take(5)(delayed3));
+    const results3Promise = collect(broadcast, { delayMs: 10, limit: 5 });
     await vi.advanceTimersByTimeAsync(100);
     const results3 = await results3Promise;
     expect(results3.length).toEqual(5);
@@ -146,11 +177,9 @@ describe('BroadcastIterable', () => {
 
     const broadcast = new BroadcastIterable(source);
 
-    const delayed1 = delayEach(9)(broadcast);
-    const delayed2 = delayEach(10)(broadcast);
     expect(broadcast.active).toBe(false);
-    const results1Promise = toArray(take(5)(delayed1)) as Promise<number[]>;
-    const results2Promise = toArray(take(5)(delayed2)) as Promise<number[]>;
+    const results1Promise = collect(broadcast, { delayMs: 9, limit: 5 }) as Promise<number[]>;
+    const results2Promise = collect(broadcast, { delayMs: 10, limit: 5 }) as Promise<number[]>;
 
     const settled = Promise.allSettled([results1Promise, results2Promise]);
     await vi.advanceTimersByTimeAsync(100);
@@ -162,8 +191,7 @@ describe('BroadcastIterable', () => {
     expect(broadcast.active).toBe(false);
 
     // This starts a new source
-    const delayed3 = delayEach(10)(broadcast);
-    const results3Promise = toArray(take(5)(delayed3));
+    const results3Promise = collect(broadcast, { delayMs: 10, limit: 5 });
     await vi.advanceTimersByTimeAsync(100);
     const results3 = await results3Promise;
     expect(results3.length).toEqual(5);

package/test/src/config.test.ts

@@ -1,5 +1,6 @@
 // Vitest Unit Tests
 import { CompoundConfigCollector } from '@/index.js';
+import fs from 'node:fs/promises';
 import { describe, expect, it, vi } from 'vitest';
 
 describe('Config', () => {
@@ -251,7 +252,7 @@ describe('Config', () => {
       config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
     });
 
-    expect(result.sync_rules).toEqual({
+    expect(result.sync_rules).toMatchObject({
       present: true,
       version_label: 'v6',
       exit_on_error: true,
@@ -281,7 +282,7 @@ describe('Config', () => {
       config_base64: Buffer.from(yamlConfig, 'utf-8').toString('base64')
     });
 
-    expect(result.sync_rules).toEqual({
+    expect(result.sync_rules).toMatchObject({
       present: true,
       exit_on_error: true,
       content: expect.stringContaining('edition: 2')
@@ -312,7 +313,7 @@ describe('Config', () => {
       sync_config_base64: Buffer.from(yamlSyncConfig, 'utf-8').toString('base64')
     });
 
-    expect(result.sync_rules).toEqual({
+    expect(result.sync_rules).toMatchObject({
       present: true,
       exit_on_error: true,
       content: expect.stringContaining('edition: 2')
@@ -345,3 +346,64 @@ describe('Config', () => {
     ).rejects.toThrow(/Both `sync_config` and `sync_rules` are present/);
   });
 });
+
+const LOADED_TEST_CONFIG = /* yaml */ `
+  # Input used to test source selection during configuration resolution.
+  config:
+    edition: 3
+  streams:
+    todos:
+      query: SELECT id FROM todos
+`;
+
+describe('resolved sync config input sources', () => {
+  it.each([
+    { name: 'omitted', sync: undefined, base64: false, present: false },
+    { name: 'empty section', sync: {}, base64: false, present: false },
+    { name: 'options without content', sync: { exit_on_error: false }, base64: false, present: false },
+    { name: 'inline', sync: { content: LOADED_TEST_CONFIG }, base64: false, present: true },
+    { name: 'Base64', sync: undefined, base64: true, present: true },
+    { name: 'empty section with Base64', sync: {}, base64: true, present: true }
+  ])('loads $name', async ({ sync, base64, present }) => {
+    const result = await new CompoundConfigCollector().collectConfig({
+      config_base64: Buffer.from(JSON.stringify({ storage: { type: 'mongodb' }, sync_config: sync })).toString(
+        'base64'
+      ),
+      sync_config_base64: base64 ? Buffer.from(LOADED_TEST_CONFIG).toString('base64') : undefined
+    });
+    expect(result.sync_rules.present).toBe(present);
+    expect(result.sync_rules.content).toBe(present ? LOADED_TEST_CONFIG : undefined);
+  });
+
+  it('defers configured file loading to the sync config engine', async () => {
+    // Configuration collection records the path; source-aware admission owns reading the file.
+    using readFile = vi.spyOn(fs, 'readFile');
+    const result = await new CompoundConfigCollector().collectConfig({
+      config_base64: Buffer.from(
+        JSON.stringify({
+          storage: { type: 'mongodb' },
+          sync_config: { path: '/nonexistent-powersync-source-test/sync-config.yaml' }
+        })
+      ).toString('base64')
+    });
+    expect(result.sync_rules.present).toBe(true);
+    expect(result.sync_rules.path).toBe('/nonexistent-powersync-source-test/sync-config.yaml');
+    expect(readFile).not.toHaveBeenCalled();
+  });
+});
+
+describe('deferred sync config parsing', () => {
+  it.each([{ exitOnError: true }, { exitOnError: false }])(
+    'preserves malformed input for source-aware validation (exit_on_error=$exitOnError)',
+    async ({ exitOnError }) => {
+      // Keep malformed input available for diagnostics regardless of the startup failure policy.
+      const content = '# empty sync config\n';
+      const config = await new CompoundConfigCollector().collectConfig({
+        config_base64: Buffer.from(
+          JSON.stringify({ storage: { type: 'mongodb' }, sync_config: { content, exit_on_error: exitOnError } })
+        ).toString('base64')
+      });
+      expect(config.sync_rules.content).toBe(content);
+    }
+  );
+});

package/test/src/connection-metrics-export.test.ts

@@ -0,0 +1,76 @@
+import {
+  createCoreAPIMetrics,
+  initializeCoreAPIMetrics,
+  MetricsEngine,
+  OpenTelemetryMetricsFactory,
+  recordSyncConnection,
+  SyncCloseReason,
+  SyncTransport
+} from '@/index.js';
+import { PrometheusExporter } from '@opentelemetry/exporter-prometheus';
+import { MeterProvider } from '@opentelemetry/sdk-metrics';
+import { ErrorCode, ServiceError } from '@powersync/lib-services-framework';
+import { createServer } from 'node:http';
+import { AddressInfo } from 'node:net';
+import { expect, it } from 'vitest';
+
+it('scrapes only observed connection series and omits error_code for ok closes', async () => {
+  const exporter = new PrometheusExporter({ preventServerStart: true });
+  const provider = new MeterProvider({ readers: [exporter] });
+  const engine = new MetricsEngine({
+    factory: new OpenTelemetryMetricsFactory(provider.getMeter('connection-metrics-test')),
+    disable_telemetry_sharing: true
+  });
+  createCoreAPIMetrics(engine);
+  initializeCoreAPIMetrics(engine);
+  const server = createServer((request, response) => exporter.getMetricsRequestHandler(request, response));
+  try {
+    await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve));
+    const address = server.address() as AddressInfo;
+    const scrape = async () => {
+      const response = await fetch(`http://127.0.0.1:${address.port}/metrics`, { signal: AbortSignal.timeout(2_000) });
+      expect(response.status).toBe(200);
+      return (await response.text()).split('\n').filter((line) => line.startsWith('powersync_sync_connections_total{'));
+    };
+    const errorSeries = (lines: string[]) =>
+      lines.find((line) =>
+        ['outcome="error"', 'close_reason="stream_error"', 'error_code="PSYNC_S2403"', 'transport="http_stream"'].every(
+          (label) => line.includes(label)
+        )
+      );
+
+    expect(await scrape()).toEqual([]);
+
+    recordSyncConnection(engine, {
+      transport: SyncTransport.HttpStream,
+      closeReason: SyncCloseReason.StreamError,
+      error: new ServiceError(ErrorCode.PSYNC_S2403, 'Storage query timed out')
+    });
+    const afterFailure = await scrape();
+    expect(afterFailure).toHaveLength(1);
+    expect(errorSeries(afterFailure)).toMatch(/ 1$/);
+
+    for (const [index, error] of [
+      undefined,
+      new ServiceError(ErrorCode.PSYNC_S2403, 'Ignored on an ok close')
+    ].entries()) {
+      recordSyncConnection(engine, {
+        transport: SyncTransport.HttpStream,
+        closeReason: SyncCloseReason.ClientClosed,
+        error
+      });
+
+      const afterClose = await scrape();
+      expect(afterClose).toHaveLength(2);
+      expect(errorSeries(afterClose)).toMatch(/ 1$/);
+      const okSeries = afterClose.find((line) => line.includes('outcome="ok"'));
+      expect(okSeries).toContain('close_reason="client_closed"');
+      expect(okSeries).toContain('transport="http_stream"');
+      expect(okSeries).not.toContain('error_code=');
+      expect(okSeries).toMatch(new RegExp(` ${index + 1}$`));
+    }
+  } finally {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+    await provider.shutdown();
+  }
+});