cabloy 5.1.205 → 5.1.207

package/vona/src/suite-vendor/a-vona/modules/a-redis/test/redisCleanup.test.ts

@@ -0,0 +1,378 @@
+import type { VonaApplication } from 'vona';
+
+import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { registerHooks } from 'node:module';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+
+import { getRedisClientKeyPrefix } from '../src/lib/redis.ts';
+
+// Only bypass bean registration; exercise the real service and prefix helpers
+// with object mocks, without loading an app or connecting to Redis.
+const serviceUrl = new URL('../src/service/redis.ts', import.meta.url).href;
+const hooks = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (context.parentURL === serviceUrl && specifier === 'vona-module-a-bean') {
+      return {
+        url: 'data:text/javascript,export function Service() { return () => {}; }',
+        shortCircuit: true,
+      };
+    }
+    return nextResolve(specifier, context);
+  },
+});
+const { ServiceRedis } = await import('../src/service/redis.ts');
+hooks.deregister();
+
+const runId = '20261014010203-a1b2c3d4';
+const prefixedClients = ['default', 'cache', 'io', 'summer', 'model', 'worker', 'limiter'];
+const clientNames = ['queue', 'broadcast', 'redlock', 'redlockPeer', ...prefixedClients];
+
+type ClientConfig = {
+  keyPrefix?: string | true;
+  sentinels?: unknown[];
+  nodes?: unknown[];
+};
+
+function createFixture(mode = 'dev', isolated = false) {
+  const name = isolated ? `cabtest${runId}` : 'cleanup-app';
+  const config = {
+    meta: { mode },
+    redis: {
+      base: {} as { keyPrefix?: string },
+      clients: Object.fromEntries(
+        clientNames.map(clientName => [
+          clientName,
+          prefixedClients.includes(clientName) ? { keyPrefix: true } : {},
+        ]),
+      ) as Record<string, ClientConfig>,
+    },
+  };
+  const calls: { clientName: string; command: string; keys: string[] }[] = [];
+  const store = new Set<string>();
+  const clients: Record<
+    string,
+    {
+      options: { keyPrefix?: string };
+      keys: (pattern: string) => Promise<string[]>;
+      del: (keys: string[]) => Promise<number>;
+    }
+  > = {};
+  const app = {
+    name,
+    meta: { env: { META_MODE: mode, VONA_TEST_RUN_ID: isolated ? runId : undefined } },
+    config,
+    bean: {
+      redis: {
+        get(clientName: string) {
+          if (clientName === 'broadcast') {
+            throw new Error('Cleanup must not access the subscribed broadcast client');
+          }
+          return clients[clientName];
+        },
+      },
+    },
+  } as unknown as VonaApplication;
+  const prefix = (clientName: string) => getRedisClientKeyPrefix(clientName, app);
+  for (const clientName of clientNames) {
+    const keyPrefix = prefixedClients.includes(clientName) ? prefix(clientName) : undefined;
+    const client = {
+      options: { keyPrefix },
+      async keys(pattern: string) {
+        calls.push({ clientName, command: 'keys', keys: [pattern] });
+        assert.equal(pattern.endsWith('*'), true);
+        assert.equal(/[?[\]\\*]/.test(pattern.slice(0, -1)), false);
+        return [...store].filter(key => key.startsWith(pattern.slice(0, -1)));
+      },
+      async del(keys: string[]) {
+        calls.push({ clientName, command: 'del', keys });
+        for (const key of keys) store.delete(`${client.options.keyPrefix ?? ''}${key}`);
+        return keys.length;
+      },
+    };
+    clients[clientName] = client;
+  }
+  const service = Object.create(ServiceRedis.prototype) as InstanceType<typeof ServiceRedis>;
+  Object.defineProperty(service, 'app', { value: app });
+  return { app, service, config, clients, store, calls, prefix };
+}
+
+function addOwnedKeys(fixture: ReturnType<typeof createFixture>) {
+  for (const category of ['bull', 'redlock', ...prefixedClients]) {
+    fixture.store.add(`${fixture.prefix(category)}record`);
+  }
+}
+
+async function assertNoDeletion(
+  fixture: ReturnType<typeof createFixture>,
+  error: RegExp,
+  noLookup = true,
+) {
+  const before = [...fixture.store];
+  await assert.rejects(fixture.service.clearAllData(), error);
+  assert.deepEqual([...fixture.store], before);
+  assert.equal(
+    fixture.calls.some(call => call.command === 'del'),
+    false,
+  );
+  if (noLookup) assert.deepEqual(fixture.calls, []);
+}
+
+describe('Redis clearAllData ownership', () => {
+  // resolveTestRunId defaults an undefined fixture ID to the process ID. Under
+  // the isolated app runner, execute ordinary-app fixtures in their own pure
+  // process rather than mutating the runner's process-global environment.
+  if (process.env.VONA_TEST_RUN_ID !== undefined) {
+    it('runs ordinary-app ownership cases without inheriting the isolated runner ID', async () => {
+      const loader = import.meta.resolve('ts-node-maintained/esm');
+      const projectRoot = new URL('../../../../../../', import.meta.url);
+      const registerSource = `import { register } from 'node:module'; register(${JSON.stringify(loader)}, ${JSON.stringify(projectRoot.href)});`;
+      const env = Object.fromEntries(Object.entries(process.env)) as NodeJS.ProcessEnv;
+      delete env.VONA_TEST_RUN_ID;
+      delete env.NODE_TEST_CONTEXT;
+      env.TS_NODE_PROJECT = fileURLToPath(new URL('tsconfig.json', projectRoot));
+      const { stdout } = await promisify(execFile)(
+        process.execPath,
+        [
+          '--import',
+          `data:text/javascript,${encodeURIComponent(registerSource)}`,
+          '--test',
+          '--test-reporter=tap',
+          '--test-name-pattern=Redis clearAllData ownership',
+          fileURLToPath(import.meta.url),
+        ],
+        { env, timeout: 30_000 },
+      );
+      assert.match(stdout, /# fail 0\b/);
+      assert.match(stdout, /# pass 35\b/);
+    });
+    return;
+  }
+
+  for (const mode of ['dev', 'test', 'prod']) {
+    it(`cleans every category without touching other apps or broadcast in ${mode}`, async () => {
+      const fixture = createFixture(mode);
+      addOwnedKeys(fixture);
+      const preserved = [
+        `${fixture.prefix('broadcast')}subscription`,
+        'unprefixed-global-key',
+        ...['bull', 'redlock', ...prefixedClients].flatMap(category => [
+          `${category}_other-app${mode === 'prod' ? '' : '_local'}:record`,
+          `${category}_cleanup-app-sibling${mode === 'prod' ? '' : '_local'}:record`,
+          `${category}_cleanup-app${mode === 'prod' ? '_local' : ''}:record`,
+        ]),
+      ];
+      for (const key of preserved) fixture.store.add(key);
+
+      await fixture.service.clearAllData();
+
+      assert.deepEqual([...fixture.store].toSorted(), preserved.toSorted());
+      assert.deepEqual(
+        fixture.calls.filter(call => call.command === 'keys').map(call => call.clientName),
+        clientNames.filter(clientName => clientName !== 'broadcast'),
+      );
+      const firstDelete = fixture.calls.findIndex(call => call.command === 'del');
+      assert.equal(firstDelete, clientNames.length - 1);
+      for (const clientName of prefixedClients) {
+        assert.deepEqual(
+          fixture.calls.find(call => call.clientName === clientName && call.command === 'del')
+            ?.keys,
+          ['record'],
+        );
+      }
+      assert.deepEqual(
+        fixture.calls.find(call => call.clientName === 'queue' && call.command === 'del')?.keys,
+        [`${fixture.prefix('bull')}record`],
+      );
+      assert.deepEqual(
+        fixture.calls.find(call => call.clientName === 'redlock' && call.command === 'del')?.keys,
+        [`${fixture.prefix('redlock')}record`],
+      );
+    });
+  }
+
+  it('allows only bounded custom nesting and strips the complete client prefix for DEL', async () => {
+    const fixture = createFixture();
+    const prefix = `${fixture.prefix('cache')}nested:deeper:`;
+    fixture.config.redis.clients.cache.keyPrefix = prefix;
+    fixture.clients.cache.options.keyPrefix = prefix;
+    fixture.store.add(`${prefix}record`);
+    fixture.store.add(`${fixture.prefix('cache')}outside-custom-namespace`);
+    fixture.store.add(`${fixture.prefix('cache')}nested:deeper-sibling:record`);
+
+    await fixture.service.clearAllData();
+
+    assert.deepEqual(
+      fixture.calls.filter(call => call.command === 'del'),
+      [{ clientName: 'cache', command: 'del', keys: ['record'] }],
+    );
+    assert.deepEqual(
+      [...fixture.store],
+      [
+        `${fixture.prefix('cache')}outside-custom-namespace`,
+        `${fixture.prefix('cache')}nested:deeper-sibling:record`,
+      ],
+    );
+  });
+
+  it('does not DEL when all owned lookups are empty', async () => {
+    const fixture = createFixture();
+    fixture.store.add('cache_other-app_local:record');
+    await fixture.service.clearAllData();
+    assert.equal(
+      fixture.calls.some(call => call.command === 'del'),
+      false,
+    );
+    assert.deepEqual([...fixture.store], ['cache_other-app_local:record']);
+  });
+
+  for (const keyPrefix of [
+    undefined,
+    '',
+    '*',
+    'undefined',
+    'worker_other-app_local:',
+    'worker_cleanup-app_local',
+    'worker_cleanup-app_local-sibling:',
+    'worker_cleanup-app_local:unbounded',
+    'worker_cleanup-app_local:*:',
+    'worker_cleanup-app_local:?:',
+    'worker_cleanup-app_local:[ab]:',
+    'worker_cleanup-app_local:back\\slash:',
+    'worker_cleanup-app_local:\n:',
+  ]) {
+    it(`rejects unsafe later configured prefixes before any lookup (${JSON.stringify(keyPrefix)})`, async () => {
+      const fixture = createFixture();
+      addOwnedKeys(fixture);
+      fixture.config.redis.clients.worker.keyPrefix = keyPrefix;
+      fixture.clients.worker.options.keyPrefix = keyPrefix;
+      await assertNoDeletion(fixture, /prefix does not belong to this app/);
+    });
+  }
+
+  for (const keyPrefix of [
+    undefined,
+    '',
+    'worker_other-app_local:',
+    'worker_cleanup-app_local:nested:',
+  ]) {
+    it(`rejects config/actual-client prefix drift before any lookup (${JSON.stringify(keyPrefix)})`, async () => {
+      const fixture = createFixture();
+      addOwnedKeys(fixture);
+      fixture.clients.worker.options.keyPrefix = keyPrefix;
+      await assertNoDeletion(fixture, /unexpected client prefix/);
+    });
+  }
+
+  it('rejects a configured custom prefix when the actual client still uses the framework prefix', async () => {
+    const fixture = createFixture();
+    addOwnedKeys(fixture);
+    fixture.config.redis.clients.worker.keyPrefix = `${fixture.prefix('worker')}nested:`;
+    await assertNoDeletion(fixture, /unexpected client prefix/);
+  });
+
+  for (const clientName of ['queue', 'redlock', 'redlockPeer']) {
+    it(`rejects prefixed special client configuration for ${clientName}`, async () => {
+      const fixture = createFixture();
+      addOwnedKeys(fixture);
+      fixture.config.redis.clients[clientName].keyPrefix = true;
+      await assertNoDeletion(fixture, /requires an unprefixed client/);
+    });
+
+    it(`rejects an unexpected actual keyPrefix for ${clientName}`, async () => {
+      const fixture = createFixture();
+      addOwnedKeys(fixture);
+      fixture.clients[clientName].options.keyPrefix = 'foreign:';
+      await assertNoDeletion(fixture, /unexpected client prefix/);
+    });
+  }
+
+  it('rejects an unavailable later client without deleting already prepared categories', async () => {
+    const fixture = createFixture();
+    addOwnedKeys(fixture);
+    delete fixture.clients.worker;
+    await assertNoDeletion(fixture, /client is unavailable/);
+  });
+
+  for (const clientName of ['queue', 'redlockPeer', 'worker']) {
+    it(`validates all fetched full keys before DEL when ${clientName} returns a foreign key`, async () => {
+      const fixture = createFixture();
+      addOwnedKeys(fixture);
+      const originalKeys = fixture.clients[clientName].keys;
+      fixture.clients[clientName].keys = async pattern => [
+        ...(await originalKeys(pattern)),
+        'worker_other-app_local:record',
+      ];
+      await assertNoDeletion(fixture, /key outside the owned prefix/, false);
+    });
+  }
+
+  it('does not delete earlier fetched keys when a later lookup fails', async () => {
+    const fixture = createFixture();
+    addOwnedKeys(fixture);
+    fixture.clients.worker.keys = async () => {
+      throw new Error('mock lookup failure');
+    };
+    await assertNoDeletion(fixture, /mock lookup failure/, false);
+  });
+
+  it('rejects unsafe app identities before looking up any keys', async () => {
+    const fixture = createFixture();
+    Object.defineProperty(fixture.app, 'name', { value: 'cleanup*app' });
+    await assertNoDeletion(fixture, /prefix does not belong to this app/);
+  });
+});
+
+describe('isolated Redis cleanup', () => {
+  it('cleans the full run namespace while preserving sibling runs', async () => {
+    const fixture = createFixture('test', true);
+    addOwnedKeys(fixture);
+    const sibling = 'bull_cabtest20261014010203-d4e5f6a7_local:record';
+    fixture.store.add(sibling);
+    await fixture.service.clearAllData();
+    assert.deepEqual([...fixture.store], [sibling]);
+  });
+
+  it('rejects a run/app identity mismatch before cleanup', async () => {
+    const fixture = createFixture('test', true);
+    addOwnedKeys(fixture);
+    Object.defineProperty(fixture.app, 'name', { value: 'cleanup-app' });
+    await assertNoDeletion(fixture, /APP_NAME does not match its run ID/);
+  });
+
+  it('keeps the strict framework-managed prefix requirement even for bounded custom nesting', async () => {
+    const fixture = createFixture('test', true);
+    addOwnedKeys(fixture);
+    const prefix = `${fixture.prefix('worker')}nested:`;
+    fixture.config.redis.clients.worker.keyPrefix = prefix;
+    fixture.clients.worker.options.keyPrefix = prefix;
+    await assertNoDeletion(fixture, /requires a framework-managed Redis prefix/);
+  });
+
+  it('rejects inherited base prefixes before cleanup', async () => {
+    const fixture = createFixture('test', true);
+    addOwnedKeys(fixture);
+    fixture.config.redis.base.keyPrefix = 'foreign:';
+    await assertNoDeletion(fixture, /cannot inherit a Redis base keyPrefix/);
+  });
+
+  for (const clientName of ['queue', 'redlockPeer']) {
+    it(`retains the isolated undefined configured prefix rule for ${clientName}`, async () => {
+      const fixture = createFixture('test', true);
+      addOwnedKeys(fixture);
+      fixture.config.redis.clients[clientName].keyPrefix = '';
+      await assertNoDeletion(fixture, /requires a framework-managed Redis prefix/);
+    });
+  }
+
+  for (const property of ['sentinels', 'nodes'] as const) {
+    it(`rejects isolated ${property} clients before cleanup`, async () => {
+      const fixture = createFixture('test', true);
+      addOwnedKeys(fixture);
+      fixture.config.redis.clients.worker[property] = [];
+      await assertNoDeletion(fixture, /cannot use a Redis sentinel or cluster client/);
+    });
+  }
+});

package/vona/src/suite-vendor/a-vona/modules/a-startup/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-startup",
-  "version": "5.1.18",
+  "version": "5.1.19",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-startup/src/service/startup.ts

@@ -28,17 +28,22 @@ export class ServiceStartup extends BeanBase {
     }
     // clear keys
     await this._clearResources();
+    if (this.app.meta.isDev) {
+      await this.bean.executor.newCtx(
+        () => this.$scope.version.service.database.prepareDevDatabases(),
+        { dbInfo: { level: 1 }, instanceName: null },
+      );
+    }
 
     // run startups: not after
     for (const startup of this._startups) {
       const startupOptions = startup.beanOptions.options;
       if (!startupOptions?.instance && startupOptions?.after !== true) {
-        // A previous dev startup may have left databaseInit's debounce key in Redis.
-        // Only the explicit reset must bypass that key to guarantee recreation.
         const force =
           this.app.meta.isDev &&
-          process.env.VONA_DB_RESET === 'true' &&
-          startup.name === 'a-version:databaseInit';
+          startup.name === 'a-version:databaseInit' &&
+          (process.env.VONA_DB_RESET === 'true' ||
+            this.$scope.version.service.database.createdInstanceNames.length > 0);
         const run = () => this.runStartup(startup.name, null, force ? { force: true } : undefined);
         if (this.app.meta.env.VONA_TEST_RUN_ID && startup.name === 'a-version:databaseInit') {
           const defaultClient = this.app.config.database.defaultClient;
@@ -55,6 +60,25 @@ export class ServiceStartup extends BeanBase {
   }
 
   async appReady() {
+    const createdInstances = this.$scope.version.service.database.createdInstanceNames;
+    const preparingDev = this.app.meta.isDev && createdInstances.length > 0;
+    if (preparingDev) {
+      // Initialize and seed fresh instances before listeners or queue workers start.
+      const instanceNames = [
+        '',
+        ...createdInstances.filter(name => name !== ''),
+      ] as (keyof IInstanceRecord)[];
+      for (const instanceName of instanceNames) {
+        await this._appReadyInstanceStartup(instanceName, true, true);
+      }
+      for (const instanceName of instanceNames) {
+        await this.bean.executor.newCtx(() => this.runStartupInstanceAfter(instanceName), {
+          dbInfo: { level: 1 },
+          instanceName,
+        });
+      }
+    }
+
     // run startups: after
     for (const startup of this._startups) {
       const startupOptions = startup.beanOptions.options;
@@ -65,7 +89,7 @@ export class ServiceStartup extends BeanBase {
 
     // version init : force: should be false
     if (this.app.meta.isTest || this.app.meta.isDev) {
-      await this._appReadyInstanceStartup('', true);
+      if (!preparingDev) await this._appReadyInstanceStartup('', true);
     } else {
       // only start static instances (defined in config)
       for (const key in this.app.config.instance.instances) {
@@ -78,8 +102,8 @@ export class ServiceStartup extends BeanBase {
       }
     }
 
-    // Seed test runs and explicit development resets only, after instance initialization.
-    if (this.app.meta.isTest || (this.app.meta.isDev && process.env.VONA_DB_RESET === 'true')) {
+    // Test seeding retains its existing lifecycle; dev seeding belongs to fresh instances.
+    if (this.app.meta.isTest) {
       await this.seedDefaultInstance();
     }
   }
@@ -94,9 +118,17 @@ export class ServiceStartup extends BeanBase {
     );
   }
 
-  private async _appReadyInstanceStartup(instanceName: keyof IInstanceRecord, wait: boolean) {
+  private async _appReadyInstanceStartup(
+    instanceName: keyof IInstanceRecord,
+    wait: boolean,
+    deferAfter?: boolean,
+  ) {
     const res = this.$scope.instance.service.instance.instanceStartupIsolate(instanceName, {
-      force: this.app.meta.isDev && process.env.VONA_DB_RESET === 'true',
+      force:
+        this.app.meta.isDev &&
+        (process.env.VONA_DB_RESET === 'true' ||
+          this.$scope.version.service.database.createdInstanceNames.includes(instanceName)),
+      deferAfter,
     });
     if (wait) {
       await res;
@@ -182,6 +214,21 @@ export class ServiceStartup extends BeanBase {
         await this.runStartup(startup.name, instanceName, options);
       }
     }
+    if (
+      this.app.meta.isDev &&
+      this.$scope.version.service.database.createdInstanceNames.includes(instanceName)
+    ) {
+      await this.$scope.version.service.version.__instanceSeed(instanceName);
+      this.$scope.version.service.database.consumeCreatedInstance(instanceName);
+    }
+    if (options?.deferAfter) return;
+    await this.runStartupInstanceAfter(instanceName, options);
+  }
+
+  async runStartupInstanceAfter(
+    instanceName: keyof IInstanceRecord,
+    options?: IInstanceStartupOptions,
+  ) {
     // set flag
     this.app.meta.appReadyInstances[instanceName] = true;
     // run startups: after

package/vona/src/suite-vendor/a-vona/modules/a-startup/src/types/startup.ts

@@ -22,6 +22,7 @@ export interface IDecoratorStartupOptions
 
 export interface IInstanceStartupOptions {
   force?: boolean;
+  deferAfter?: boolean;
   configInstanceBase?: ConfigInstanceBase;
 }
 

package/vona/src/suite-vendor/a-vona/modules/a-startup/test/devSeed.test.ts

@@ -0,0 +1,104 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { ServiceStartup } from '../src/service/startup.ts';
+
+function fixture(created: string[] = []) {
+  const calls: string[] = [];
+  const pending = new Set(created);
+  const app = {
+    meta: { isDev: true, isTest: false, appReadyInstances: {} as Record<string, boolean> },
+    config: { server: { listen: { disable: false } } },
+  };
+  const service = Object.create(ServiceStartup.prototype) as ServiceStartup;
+  const startups = [
+    { name: 'a-version:instanceInit', beanOptions: { options: { instance: true } } },
+    { name: 'a-runtime:runtime', beanOptions: { options: { instance: true, after: true } } },
+    { name: 'a-queue:loadQueueWorkers', beanOptions: { options: { instance: true, after: true } } },
+    { name: 'a-web:listen', beanOptions: { options: { after: true } } },
+  ];
+  Object.defineProperties(service, {
+    app: { value: app },
+    _startups: { value: startups },
+    bean: { value: { executor: { newCtx: async (fn: () => Promise<unknown>) => fn() } } },
+    $scope: {
+      value: {
+        version: {
+          service: {
+            database: {
+              get createdInstanceNames() {
+                return [...pending];
+              },
+              consumeCreatedInstance: (name: string) => pending.delete(name),
+            },
+            version: {
+              __instanceSeed: async (name: string) => {
+                calls.push(`seed:${name}`);
+              },
+            },
+          },
+        },
+        instance: {
+          service: {
+            instance: {
+              instanceStartupIsolate: async (name: string, options: any) =>
+                service.runStartupInstance(name as never, options),
+            },
+          },
+        },
+      },
+    },
+    runStartup: {
+      value: async (name: string, instance: string) => {
+        calls.push(`${name}:${instance}`);
+      },
+    },
+  });
+  return { service, app, calls, pending };
+}
+
+describe('creation-driven dev seed', { concurrency: false }, () => {
+  it('seeds fresh instances before runtime, queues, and listening', async () => {
+    const { service, calls, pending, app } = fixture(['', 'isolateTest']);
+    await service.appReady();
+    assert.equal(pending.size, 0);
+    const lastSeed = calls.indexOf('seed:isolateTest');
+    assert.ok(lastSeed > calls.indexOf('seed:'));
+    for (const call of ['a-runtime:runtime:', 'a-queue:loadQueueWorkers:', 'a-web:listen:null']) {
+      assert.ok(calls.indexOf(call) > lastSeed, `${call} must follow all seeds`);
+    }
+    assert.equal(app.meta.appReadyInstances[''], true);
+    assert.equal(app.meta.appReadyInstances.isolateTest, true);
+    await service.runStartupInstance('' as never);
+    assert.equal(calls.filter(call => call === 'seed:').length, 1);
+  });
+
+  it('does not seed existing default when only an isolated database is new', async () => {
+    const { service, calls } = fixture(['isolateTest']);
+    await service.appReady();
+    assert.ok(calls.includes('seed:isolateTest'));
+    assert.ok(!calls.includes('seed:'));
+  });
+
+  it('does not seed when all databases are reused', async () => {
+    const { service, calls } = fixture();
+    await service.appReady();
+    assert.ok(!calls.some(call => call.startsWith('seed:')));
+  });
+
+  it('fails before after-startups and readiness if seeding fails', async () => {
+    const { service, app, calls, pending } = fixture(['']);
+    (service as any).$scope.version.service.version.__instanceSeed = async () => {
+      throw new Error('seed failed');
+    };
+    await assert.rejects(service.appReady(), /seed failed/);
+    assert.ok(pending.has(''));
+    assert.deepEqual(app.meta.appReadyInstances, {});
+    assert.ok(
+      !calls.some(
+        call =>
+          call.includes('runtime') || call.includes('listen') || call.includes('loadQueueWorkers'),
+      ),
+    );
+  });
+});

package/vona/src/suite-vendor/a-vona/modules/a-version/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-version",
-  "version": "5.1.19",
+  "version": "5.1.20",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona-module-a-version",
   "keywords": [