cabloy 5.1.219 → 5.1.221

package/vona/packages-vona/vona-core/src/lib/core/testFreshness.test.ts

@@ -0,0 +1,379 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+
+import type { VonaApplication } from './application.ts';
+import type { TestFreshnessDependencies } from './testFreshness.ts';
+
+import { buildTestClaimResourceInventory } from './testClaim.ts';
+import {
+  assertFreshTestResources,
+  assertFreshTestResourcesReady,
+  createFreshnessDependencies,
+  hasFreshnessDatabase,
+  hasFreshnessRedis,
+  requiresFreshTestResources,
+  TEST_REQUIRE_FRESH_RESOURCES_ENV,
+} from './testFreshness.ts';
+import { resolveVonaLocalPaths } from './testIsolation.ts';
+
+function fixture() {
+  const root = mkdtempSync(path.join(realpathSync(tmpdir()), 'vona-freshness-'));
+  const runId = '20261019010203-a1b2c3d4';
+  const projectPath = path.join(root, 'vona');
+  const paths = resolveVonaLocalPaths(projectPath, 'test', runId);
+  for (const directory of [paths.dataRoot, paths.generatedRoot]) {
+    mkdirSync(directory, { recursive: true });
+    writeFileSync(path.join(directory, '.vona-test-owner'), `${runId}\n`);
+  }
+  const fixtureApp = {
+    projectPath,
+    name: `cabtest${runId}`,
+    meta: { env: { META_MODE: 'test', VONA_TEST_RUN_ID: runId, SERVER_LISTEN_PORT: '41234' } },
+    config: {
+      server: {
+        publicDir: paths.publicRoot,
+        workers: 1,
+        listen: { hostname: '127.0.0.1', port: 41234 },
+        serve: { protocol: 'http', host: '127.0.0.1:41234' },
+      },
+      logger: { baseDir: paths.logsRoot },
+      database: {
+        testDatabase: true,
+        base: {},
+        defaultClient: 'main',
+        clients: {
+          main: {
+            client: 'pg',
+            connection: { host: '127.0.0.1', port: 5432, database: 'postgres', user: 'synthetic' },
+          },
+          isolated: {
+            client: 'pg',
+            connection: { host: '127.0.0.1', port: 5433, database: 'postgres', user: 'synthetic' },
+          },
+        },
+      },
+      instance: { instances: { isolated: { id: 2, isolate: true, isolateClient: 'isolated' } } },
+      redis: {
+        base: {},
+        clients: {
+          worker: { keyPrefix: true },
+          queue: {},
+          broadcast: {},
+          redlock: {},
+          redlock2: { db: 2 },
+        },
+      },
+    },
+  };
+  const app = fixtureApp as unknown as VonaApplication & { config: typeof fixtureApp.config };
+  const events: string[] = [];
+  const readers: TestFreshnessDependencies = {
+    databaseExists: async plan => {
+      events.push(`db:${plan.scope}`);
+      return false;
+    },
+    redisExists: async resource => {
+      events.push(`redis:${resource.clientName}`);
+      return false;
+    },
+  };
+  return { root, paths, app, readers, events };
+}
+
+async function strict(fn: () => Promise<void>) {
+  const previous = process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+  process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'true';
+  try {
+    await fn();
+  } finally {
+    if (previous === undefined) delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+    else process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = previous;
+  }
+}
+
+test(
+  'strict freshness covers all targets before marking proof, without writes or resource identifiers',
+  { concurrency: false },
+  async () => {
+    await strict(async () => {
+      const f = fixture();
+      try {
+        assert.throws(() => assertFreshTestResourcesReady(f.app), /not established/);
+        mkdirSync(f.paths.publicRoot); // Config may already have created this empty directory.
+        await assertFreshTestResources(f.app, f.readers);
+        assert.deepEqual(f.events, [
+          'db:share',
+          'db:isolate-isolated',
+          'redis:worker',
+          'redis:queue',
+          'redis:redlock',
+          'redis:redlock2',
+        ]);
+        assert.doesNotThrow(() => assertFreshTestResourcesReady(f.app));
+        await assert.rejects(assertFreshTestResources(f.app, f.readers), /new isolated startup/);
+      } finally {
+        rmSync(f.root, { recursive: true, force: true });
+      }
+    });
+  },
+);
+
+test(
+  'strict freshness rejects a later isolate conflict or Redis residue without admitting startup',
+  { concurrency: false },
+  async () => {
+    await strict(async () => {
+      for (const conflict of ['db:isolate-isolated', 'redis:redlock2', 'read-error']) {
+        const f = fixture();
+        try {
+          f.readers.databaseExists = async plan => {
+            f.events.push(`db:${plan.scope}`);
+            if (conflict === 'read-error') throw new Error('synthetic-protected-driver-secret');
+            return conflict === `db:${plan.scope}`;
+          };
+          f.readers.redisExists = async resource => {
+            f.events.push(`redis:${resource.clientName}`);
+            return conflict === `redis:${resource.clientName}`;
+          };
+          await assert.rejects(assertFreshTestResources(f.app, f.readers), error => {
+            assert.equal((error as Error).message, 'Strict test resource freshness check failed');
+            assert.equal((error as Error).cause, undefined);
+            return true;
+          });
+          assert.throws(() => assertFreshTestResourcesReady(f.app), /not established/);
+          if (conflict.startsWith('db:')) {
+            assert.equal(
+              f.events.some(value => value.startsWith('redis:')),
+              false,
+            );
+          }
+        } finally {
+          rmSync(f.root, { recursive: true, force: true });
+        }
+      }
+    });
+  },
+);
+
+test(
+  'strict freshness rejects local residue, symlinks and preselected database targets before driver reads',
+  { concurrency: false },
+  async () => {
+    await strict(async () => {
+      for (const kind of ['public', 'runtime', 'sqlite', 'symlink', 'selected', 'unisolated']) {
+        const f = fixture();
+        try {
+          if (kind === 'selected') {
+            f.app.config.database.clients.main.connection.database = 'vona-test-preselected';
+          } else if (kind === 'unisolated') {
+            f.app.meta.env.VONA_TEST_RUN_ID = undefined;
+          } else if (kind === 'symlink') {
+            symlinkSync(f.paths.generatedRoot, f.paths.publicRoot);
+          } else {
+            const directory =
+              kind === 'public'
+                ? f.paths.publicRoot
+                : kind === 'runtime'
+                  ? f.paths.runtimeRoot
+                  : f.paths.sqliteRoot;
+            mkdirSync(directory);
+            writeFileSync(path.join(directory, 'synthetic-residue'), 'keep');
+          }
+          await assert.rejects(assertFreshTestResources(f.app, f.readers));
+          assert.deepEqual(f.events, []);
+        } finally {
+          rmSync(f.root, { recursive: true, force: true });
+        }
+      }
+    });
+  },
+);
+
+test(
+  'freshness is explicit and default lanes never invoke readers',
+  { concurrency: false },
+  async () => {
+    const previous = process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+    try {
+      delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+      const app = {} as VonaApplication;
+      assert.equal(requiresFreshTestResources(), false);
+      await assertFreshTestResources(app, {
+        databaseExists: async () => {
+          throw new Error('must not read');
+        },
+        redisExists: async () => {
+          throw new Error('must not read');
+        },
+      });
+      assert.doesNotThrow(() => assertFreshTestResourcesReady(app));
+      process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = 'false';
+      assert.throws(() => requiresFreshTestResources(), /Invalid strict/);
+    } finally {
+      if (previous === undefined) delete process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+      else process.env[TEST_REQUIRE_FRESH_RESOURCES_ENV] = previous;
+    }
+  },
+);
+
+test('read-only database inspection uses exact prefix bindings and always disposes', async () => {
+  const f = fixture();
+  try {
+    const plan = buildTestClaimResourceInventory(f.app).databases[0];
+    for (const dialect of ['pg', 'mysql', 'mysql2'] as const) {
+      for (const found of [false, true]) {
+        let closed = 0;
+        const result = await hasFreshnessDatabase(
+          {
+            raw: async (sql, bindings) => {
+              assert.match(sql, /^select .* limit 1$/);
+              assert.deepEqual(bindings, [plan.prefix.length, plan.prefix]);
+              const rows = found ? [{}] : [];
+              return dialect === 'pg' ? { rows } : [rows];
+            },
+            destroy: async () => {
+              closed++;
+            },
+          },
+          { ...plan, endpoint: { ...plan.endpoint, dialect } },
+        );
+        assert.equal(result, found);
+        assert.equal(closed, 1);
+      }
+    }
+    let closed = 0;
+    await assert.rejects(
+      hasFreshnessDatabase(
+        {
+          raw: async () => ({}),
+          destroy: async () => {
+            closed++;
+          },
+        },
+        plan,
+      ),
+      /Invalid freshness database response/,
+    );
+    assert.equal(closed, 1);
+  } finally {
+    rmSync(f.root, { recursive: true, force: true });
+  }
+});
+
+test('Redis freshness requires a completed cursor scan and rejects foreign/malformed/limited responses', async () => {
+  const prefix = 'synthetic_[*]?:';
+  const cursors: string[] = [];
+  assert.equal(
+    await hasFreshnessRedis(
+      {
+        scan: async (cursor, _match, pattern) => {
+          cursors.push(cursor);
+          assert.equal(pattern, 'synthetic_\\[\\*\\]\\?:*');
+          return [cursor === '0' ? '7' : '0', []];
+        },
+      },
+      prefix,
+    ),
+    false,
+  );
+  assert.deepEqual(cursors, ['0', '7']);
+  assert.equal(
+    await hasFreshnessRedis({ scan: async () => ['1', [`${prefix}key`]] }, prefix),
+    true,
+  );
+  for (const response of [undefined, ['bad', []], ['0', ['foreign']], ['0', [1]], ['0']]) {
+    await assert.rejects(
+      hasFreshnessRedis({ scan: async () => response }, prefix),
+      /Invalid Redis/,
+    );
+  }
+  await assert.rejects(
+    hasFreshnessRedis({ scan: async () => ['1', []] }, prefix, 2),
+    /limit exceeded/,
+  );
+  const failure = new Error('synthetic-ACL-error');
+  await assert.rejects(
+    hasFreshnessRedis(
+      {
+        scan: async () => {
+          throw failure;
+        },
+      },
+      prefix,
+    ),
+    value => value === failure,
+  );
+});
+
+test('direct readers project connection options, widen queue scan and dispose on failure', async () => {
+  const f = fixture();
+  try {
+    const inventory = buildTestClaimResourceInventory(f.app);
+    const plan = inventory.databases[0];
+    const resource = inventory.redis.find(item => item.clientName === 'queue')!;
+    let sqlClosed = 0;
+    let redisClosed = 0;
+    let fail = false;
+    const readers = createFreshnessDependencies(f.app.projectPath, name => {
+      if (name === 'knex') {
+        return (options: any) => {
+          assert.equal(options.connection.database, 'postgres');
+          assert.equal(options.connection.user, 'synthetic');
+          assert.equal(options.connection.password, 'synthetic-password');
+          assert.equal(options.connection.beforeConnect, undefined);
+          assert.equal(options.pool.afterCreate, undefined);
+          return {
+            raw: async () => ({ rows: [] }),
+            destroy: async () => {
+              sqlClosed++;
+            },
+          };
+        };
+      }
+      assert.equal(name, 'ioredis');
+      return {
+        Redis: class {
+          constructor(options: any) {
+            assert.equal(options.db, 0);
+            assert.equal(options.keyPrefix, undefined);
+            assert.equal(options.enableOfflineQueue, false);
+            assert.equal(options.retryStrategy(), null);
+            assert.equal(options.maxRetriesPerRequest, 0);
+          }
+
+          on() {}
+
+          async connect() {
+            if (fail) throw new Error('synthetic-driver-error');
+          }
+
+          async scan(_cursor: string, _match: string, pattern: string) {
+            assert.equal(pattern, `${resource.prefix.slice(0, -'queue:'.length)}*`);
+            return ['0', []];
+          }
+
+          disconnect() {
+            redisClosed++;
+          }
+        },
+      };
+    });
+    assert.equal(
+      await readers.databaseExists(plan, {
+        connection: { user: 'synthetic', password: 'synthetic-password', beforeConnect() {} },
+        pool: { afterCreate() {} },
+      }),
+      false,
+    );
+    assert.equal(sqlClosed, 1);
+    assert.equal(await readers.redisExists(resource, {}), false);
+    fail = true;
+    await assert.rejects(readers.redisExists(resource, {}), /synthetic-driver-error/);
+    assert.equal(redisClosed, 2);
+  } finally {
+    rmSync(f.root, { recursive: true, force: true });
+  }
+});

package/vona/packages-vona/vona-core/src/lib/core/testFreshness.ts

@@ -0,0 +1,232 @@
+import { lstat, readdir } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+import type { VonaApplication } from './application.ts';
+import type { TestClaimDatabasePlan, TestClaimRedis } from './testClaim.ts';
+
+import { assertIsolatedTestConfig, assertIsolatedTestPath } from './isolationGuard.ts';
+import {
+  buildTestClaimResourceInventory,
+  mergeTestClaimDatabaseOptions,
+  mergeTestClaimRedisOptions,
+} from './testClaim.ts';
+import { resolveVonaLocalPaths } from './testIsolation.ts';
+import { requiresFreshTestResources } from './testStrictMode.ts';
+
+export { requiresFreshTestResources, TEST_REQUIRE_FRESH_RESOURCES_ENV } from './testStrictMode.ts';
+
+const freshApps = new WeakSet<VonaApplication>();
+
+export function assertFreshTestResourcesReady(app: VonaApplication) {
+  if (!requiresFreshTestResources()) return;
+  if (!freshApps.has(app)) throw new Error('Strict test resource freshness was not established');
+}
+
+export interface TestFreshnessDependencies {
+  databaseExists(plan: TestClaimDatabasePlan, options: Record<string, any>): Promise<boolean>;
+  redisExists(resource: TestClaimRedis, options: Record<string, any>): Promise<boolean>;
+}
+
+async function assertEmptyDirectory(directory: string) {
+  assertIsolatedTestPath(directory, directory);
+  try {
+    if (!(await lstat(directory)).isDirectory() || (await readdir(directory)).length !== 0) {
+      throw new Error('Strict test local resource is not fresh');
+    }
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+  }
+}
+
+// Runs after configuration, before module loading (including worker-alive Redis writes).
+// This is a freshness snapshot, not a lease against independent external writers.
+export async function assertFreshTestResources(
+  app: VonaApplication,
+  dependencies?: TestFreshnessDependencies,
+) {
+  if (!requiresFreshTestResources()) return;
+  if (!app.meta.env.VONA_TEST_RUN_ID || app.meta.appReady || freshApps.has(app)) {
+    throw new Error('Strict test freshness requires a new isolated startup');
+  }
+  assertIsolatedTestConfig(app);
+  const config = app.config as typeof app.config & {
+    database: {
+      base: Record<string, unknown>;
+      clients: Record<string, Record<string, unknown>>;
+    };
+    redis: {
+      base: Record<string, unknown>;
+      clients: Record<string, Record<string, unknown>>;
+    };
+  };
+  const paths = resolveVonaLocalPaths(app.projectPath, 'test', app.meta.env.VONA_TEST_RUN_ID);
+  for (const directory of [paths.publicRoot, paths.runtimeRoot, paths.sqliteRoot]) {
+    await assertEmptyDirectory(directory);
+  }
+  const inventory = buildTestClaimResourceInventory(app);
+  const readers = dependencies ?? createFreshnessDependencies(app.projectPath);
+  try {
+    for (const plan of inventory.databases) {
+      if (plan.endpoint.dialect === 'better-sqlite3') continue;
+      const options = mergeTestClaimDatabaseOptions(
+        config.database.base,
+        undefined,
+        config.database.clients[plan.clientName],
+      );
+      if (await readers.databaseExists(plan, options)) {
+        throw new Error('Preexisting strict test database namespace');
+      }
+    }
+    for (const resource of inventory.redis) {
+      const options = mergeTestClaimRedisOptions(
+        config.redis.base,
+        config.redis.clients[resource.clientName],
+      );
+      if (await readers.redisExists(resource, options)) {
+        throw new Error('Preexisting strict test Redis namespace');
+      }
+    }
+  } catch {
+    // Driver messages may embed credentials, database names or Redis keys.
+    throw new Error('Strict test resource freshness check failed');
+  }
+  freshApps.add(app);
+}
+
+export interface FreshnessSqlConnection {
+  raw(sql: string, bindings: unknown[]): Promise<any>;
+  destroy(): Promise<unknown>;
+}
+
+export async function hasFreshnessDatabase(
+  connection: FreshnessSqlConnection,
+  plan: TestClaimDatabasePlan,
+) {
+  try {
+    const pg = plan.endpoint.dialect === 'pg';
+    if (!pg && !['mysql', 'mysql2'].includes(plan.endpoint.dialect)) {
+      throw new Error('Unsupported freshness database dialect');
+    }
+    const result = await connection.raw(
+      pg
+        ? 'select datname from pg_database where left(datname, ?) = ? limit 1'
+        : 'select schema_name from information_schema.schemata where left(schema_name, ?) = ? limit 1',
+      [plan.prefix.length, plan.prefix],
+    );
+    const rows = pg ? result?.rows : result?.[0];
+    if (!Array.isArray(rows)) throw new Error('Invalid freshness database response');
+    return rows.length !== 0;
+  } finally {
+    await connection.destroy();
+  }
+}
+
+export interface FreshnessRedisConnection {
+  scan(
+    cursor: string,
+    match: 'MATCH',
+    pattern: string,
+    count: 'COUNT',
+    size: number,
+  ): Promise<unknown>;
+}
+
+export async function hasFreshnessRedis(
+  connection: FreshnessRedisConnection,
+  prefix: string,
+  maxScans = 10000,
+) {
+  if (!prefix || !Number.isSafeInteger(maxScans) || maxScans < 1) {
+    throw new Error('Invalid Redis freshness bounds');
+  }
+  const pattern = `${prefix.replace(/[\\*?[\]]/g, '\\$&')}*`;
+  let cursor = '0';
+  for (let scans = 0; scans < maxScans; scans++) {
+    const result = await connection.scan(cursor, 'MATCH', pattern, 'COUNT', 128);
+    if (
+      !Array.isArray(result) ||
+      result.length !== 2 ||
+      typeof result[0] !== 'string' ||
+      !/^\d+$/.test(result[0]) ||
+      !Array.isArray(result[1]) ||
+      result[1].some(key => typeof key !== 'string' || !key.startsWith(prefix))
+    ) {
+      throw new Error('Invalid Redis freshness response');
+    }
+    if (result[1].length !== 0) return true;
+    cursor = result[0];
+    if (cursor === '0') return false;
+  }
+  throw new Error('Redis freshness scan limit exceeded');
+}
+
+export function createFreshnessDependencies(
+  projectPath: string,
+  load: (name: string) => any = createRequire(path.join(projectPath, 'package.json')),
+): TestFreshnessDependencies {
+  return {
+    async databaseExists(plan, options) {
+      const endpoint = plan.endpoint;
+      const source = options.connection;
+      const target: Record<string, any> = {
+        user: source.user,
+        password: source.password,
+        ssl: source.ssl,
+        database: endpoint.adminDatabase,
+        connectionTimeoutMillis: 10000,
+        connectTimeout: 10000,
+      };
+      if (endpoint.transport === 'tcp') {
+        target.host = endpoint.host;
+        target.port = endpoint.port;
+      } else if (endpoint.dialect === 'pg') {
+        target.host = endpoint.socketPath;
+        target.port = endpoint.port;
+      } else {
+        target.socketPath = endpoint.socketPath;
+      }
+      const knex = load('knex');
+      return await hasFreshnessDatabase(
+        knex({
+          client: endpoint.dialect,
+          connection: target,
+          pool: { min: 0, max: 1 },
+          acquireConnectionTimeout: 10000,
+        }),
+        plan,
+      );
+    },
+    async redisExists(resource, options) {
+      const endpoint = resource.endpoint;
+      const target =
+        endpoint.transport === 'socket'
+          ? { path: endpoint.socketPath }
+          : { host: endpoint.host, port: endpoint.port };
+      const Redis = load('ioredis').Redis;
+      const connection = new Redis({
+        ...target,
+        username: options.username,
+        password: options.password,
+        tls: options.tls,
+        db: endpoint.db,
+        keyPrefix: undefined,
+        lazyConnect: true,
+        connectTimeout: 10000,
+        commandTimeout: 10000,
+        retryStrategy: () => null,
+        maxRetriesPerRequest: 0,
+        enableOfflineQueue: false,
+      });
+      connection.on('error', () => {});
+      try {
+        await connection.connect();
+        const prefix =
+          resource.kind === 'queue' ? resource.prefix.slice(0, -'queue:'.length) : resource.prefix;
+        return await hasFreshnessRedis(connection, prefix);
+      } finally {
+        connection.disconnect();
+      }
+    },
+  };
+}

package/vona/packages-vona/vona-core/src/lib/core/testStrictMode.ts

@@ -0,0 +1,9 @@
+export const TEST_REQUIRE_FRESH_RESOURCES_ENV = 'VONA_TEST_REQUIRE_FRESH_RESOURCES';
+
+export function requiresFreshTestResources(env: NodeJS.ProcessEnv = process.env) {
+  const value = env[TEST_REQUIRE_FRESH_RESOURCES_ENV];
+  if (value !== undefined && value !== 'true') {
+    throw new Error('Invalid strict test resource freshness flag');
+  }
+  return value === 'true';
+}

package/vona/packages-vona/vona-core/src/lib/framework/start.test.ts

@@ -19,6 +19,7 @@ const lifecycleSource = `
     '../../types/index.ts': 'export const EnumAppEvent = { AppStartError: "error", AppStarted: "started" };',
     '../core/isolationGuard.ts': 'export function assertIsolatedTestConfig() {}',
     '../core/testClaim.ts': 'export function registerTestClaimResourceInventory() {}',
+    '../core/testFreshness.ts': 'export async function assertFreshTestResources() { await globalThis.phase("Freshness"); }',
     '../module/loader.ts': 'export class ModuleLoader { async execute() { await globalThis.phase("Load"); } }',
     '../utils/util.ts': 'export function deepExtend(target, source) { Object.assign(target, source); }',
   };
@@ -62,7 +63,7 @@ const lifecycleSource = `
     },
   };
   const start = new Start(app);
-  const order = ['Config', 'Load', 'Start', 'Ready', 'Started'];
+  const order = ['Config', 'Freshness', 'Load', 'Start', 'Ready', 'Started'];
   if (failingPhase) {
     await assert.rejects(start.start(), error => error === failure);
     assert.equal(app.meta.appStartError, failure);
@@ -85,13 +86,13 @@ const lifecycleSource = `
     ...(failingPhase ? ['error'] : []),
   ]);
   if (reachesStarted) {
-    assert.deepEqual(events[0].phases, ['Config', 'Load', 'Start', 'Ready']);
+    assert.deepEqual(events[0].phases, ['Config', 'Freshness', 'Load', 'Start', 'Ready']);
   }
   assert.equal(await readFile(lockPath, 'utf8'), lockContents);
   console.log('verified');
 `;
 
-for (const failingPhase of ['', 'Config', 'Load', 'Start', 'Ready', 'Started']) {
+for (const failingPhase of ['', 'Config', 'Freshness', 'Load', 'Start', 'Ready', 'Started']) {
   test(`Start ignores the legacy preparation lock on ${failingPhase ? `${failingPhase} failure` : 'success'}`, async () => {
     const root = await mkdtemp(path.join(await realpath(tmpdir()), 'vona-start-'));
     try {

package/vona/packages-vona/vona-core/src/lib/framework/start.ts

@@ -4,6 +4,7 @@ import type { VonaApplication } from '../core/application.ts';
 import { EnumAppEvent } from '../../types/index.ts';
 import { assertIsolatedTestConfig } from '../core/isolationGuard.ts';
 import { registerTestClaimResourceInventory } from '../core/testClaim.ts';
+import { assertFreshTestResources } from '../core/testFreshness.ts';
 import { ModuleLoader } from '../module/loader.ts';
 import { deepExtend } from '../utils/util.ts';
 
@@ -18,6 +19,7 @@ export class Start {
     const app = this.app;
     try {
       await this._start_appConfig();
+      await assertFreshTestResources(app);
       await this._start_appLoad();
       await this._start_appStart();
       await this._start_appReady();

package/vona/packages-vona/vona-mock/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-mock",
-  "version": "6.1.47",
+  "version": "6.1.49",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona mock",
   "keywords": [