vona-core 5.1.47 → 5.1.49

package/dist/index.js

@@ -1,4 +1,5 @@
 import '@cabloy/json5';
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { combineApiPathControllerAndActionRaw, combineApiPathControllerAndAction, combineApiPath, combineResourceName, forEach, forEachSync, sleep, isUndefined, isClass, isNilOrEmptyString, evaluateExpressions, catchErrorSync, isEmptyObject, catchError, hashkey } from '@cabloy/utils';
 import { toLowerCaseFirstChar, splitWords } from '@cabloy/word-utils';
 import path from 'node:path';
@@ -12,7 +13,6 @@ import { pathToFileURL, fileURLToPath } from 'node:url';
 import * as uuid from 'uuid';
 import { getPlatformArch as getPlatformArch$1 } from 'vona';
 import os from 'node:os';
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { isDeepStrictEqual } from 'node:util';
 import { setLocaleErrors, setLocaleAdapter, translateError } from '@cabloy/zod-errors-custom';
 import { ZodMetadata } from '@cabloy/zod-openapi';
@@ -27,7 +27,7 @@ import * as Winston from 'winston';
 import DailyRotateFile from 'winston-daily-rotate-file';
 import { MESSAGE, LEVEL } from 'triple-beam';
 import { createServer } from 'node:http';
-import { mkdir, open, rename, unlink, lstat } from 'node:fs/promises';
+import { mkdir, open, rename, unlink, lstat, readdir } from 'node:fs/promises';
 import { execFileSync, execFile } from 'node:child_process';
 import cluster from 'node:cluster';
 import React from 'react';
@@ -36,6 +36,179 @@ import { z } from 'zod';
 import * as Retry from 'retry';
 export { Retry };
 
+const boundaries = new WeakMap();
+const boundaryStorage = new AsyncLocalStorage();
+function createRequestBoundary(options) {
+  const onFailure = options?.onFailure;
+  const boundary = Object.freeze({});
+  let portFault = false;
+  let reporting = false;
+  const reported = new Set();
+  const capture = Object.freeze({
+    diagnostics: 'suppress',
+    reportFailure(failure) {
+      if (failure !== 'observer_failed' && failure !== 'diagnostic_failed' && failure !== 'late_callback_failed') {
+        portFault = true;
+        return;
+      }
+      portFault = true;
+      if (reported.has(failure)) return;
+      reported.add(failure);
+      if (reporting || !onFailure) return;
+      reporting = true;
+      try {
+        const result = onFailure(failure);
+        if (result && (typeof result === 'object' || typeof result === 'function')) {
+          const then = result.then;
+          if (typeof then === 'function') {
+            portFault = true;
+            void new Promise((resolve, reject) => {
+              then.call(result, resolve, reject);
+            }).catch(() => {});
+          }
+        }
+      } catch {
+        portFault = true;
+      } finally {
+        reporting = false;
+      }
+    },
+    snapshot() {
+      return Object.freeze({
+        portFault
+      });
+    }
+  });
+  boundaries.set(boundary, capture);
+  return boundary;
+}
+function runWithRequestBoundary(boundary, continuation) {
+  if (!boundaries.has(boundary)) throw new Error('Invalid request boundary');
+  const current = boundaryStorage.getStore();
+  if (current && current !== boundary) throw new Error('Request boundary cannot be replaced');
+  if (current === boundary) return continuation();
+  return boundaryStorage.run(boundary, continuation);
+}
+function getRequestBoundary() {
+  return boundaryStorage.getStore();
+}
+function captureRequestBoundary() {
+  const boundary = boundaryStorage.getStore();
+  return boundary ? boundaries.get(boundary) : undefined;
+}
+
+const loggingMethods = new Set(['log', 'error', 'warn', 'info', 'http', 'verbose', 'debug', 'silly']);
+function completeWrite(args) {
+  const callback = typeof args[1] === 'function' ? args[1] : args[2];
+  if (typeof callback === 'function') {
+    try {
+      callback();
+    } catch {
+      captureRequestBoundary()?.reportFailure('diagnostic_failed');
+    }
+  }
+  return true;
+}
+const suppressedLogger = createFacade();
+function getSuppressedDiagnosticLogger() {
+  return suppressedLogger;
+}
+function createDiagnosticLogger(raw) {
+  if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
+  return createFacade(raw);
+}
+function createFacade(raw) {
+  const methods = new Map();
+  const handlers = new WeakMap();
+  const inertProfiler = Object.freeze({
+    get logger() {
+      return getSuppressedDiagnosticLogger();
+    },
+    done: () => getSuppressedDiagnosticLogger()
+  });
+  const facade = new Proxy({}, {
+    get(_target, key) {
+      if (loggingMethods.has(key) || ['write', 'child', 'startTimer', 'profile'].includes(key)) {
+        if (!methods.has(key)) {
+          methods.set(key, (...args) => {
+            if (!raw || getRequestBoundary()) {
+              if (key === 'write') return completeWrite(args);
+              if (key === 'child') return getSuppressedDiagnosticLogger();
+              if (key === 'startTimer') return inertProfiler;
+              return facade;
+            }
+            const result = Reflect.apply(Reflect.get(raw, key, raw), raw, args);
+            if (key === 'child') return createFacade(result);
+            if (key === 'startTimer') return wrapProfiler(result, facade);
+            return result === raw ? facade : result;
+          });
+        }
+        return methods.get(key);
+      }
+      if (!raw) return undefined;
+      const value = Reflect.get(raw, key, raw);
+      if ((key === 'exceptions' || key === 'rejections') && value) {
+        if (!handlers.has(value)) handlers.set(value, wrapHandler(value, raw, facade));
+        return handlers.get(value);
+      }
+      if (typeof value !== 'function') return value;
+      if (!methods.has(key)) {
+        methods.set(key, (...args) => {
+          const result = Reflect.apply(value, raw, args);
+          return result === raw ? facade : result;
+        });
+      }
+      return methods.get(key);
+    },
+    set(_target, key, value) {
+      return raw ? Reflect.set(raw, key, value, raw) : true;
+    }
+  });
+  return facade;
+}
+function wrapHandler(raw, rawLogger, logger) {
+  const methods = new Map();
+  const handler = new Proxy({}, {
+    get(_target, key) {
+      if (key === 'logger') return logger;
+      const value = Reflect.get(raw, key, raw);
+      if (typeof value !== 'function') return value;
+      if (!methods.has(key)) {
+        methods.set(key, (...args) => {
+          const result = Reflect.apply(value, raw, args);
+          if (result === raw) return handler;
+          return result === rawLogger ? logger : result;
+        });
+      }
+      return methods.get(key);
+    },
+    set(_target, key, value) {
+      if (key === 'logger') return false;
+      return Reflect.set(raw, key, value, raw);
+    }
+  });
+  return handler;
+}
+function wrapProfiler(raw, logger) {
+  return new Proxy({}, {
+    get(_target, key) {
+      if (key === 'logger') return logger;
+      if (key === 'done') {
+        return (...args) => {
+          if (getRequestBoundary()) return logger;
+          const result = Reflect.apply(raw.done, raw, args);
+          return result === raw.logger ? logger : result;
+        };
+      }
+      return Reflect.get(raw, key, raw);
+    },
+    set(_target, key, value) {
+      if (key === 'logger') return false;
+      return Reflect.set(raw, key, value, raw);
+    }
+  });
+}
+
 function cast(source) {
   return source;
 }
@@ -1185,6 +1358,7 @@ class BeanBase extends BeanBaseSimple {
     return this.$loggerClient('default');
   }
   $loggerClient(clientName = 'default') {
+    if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
     if (!this[SymbolLogger][clientName]) {
       this[SymbolLogger][clientName] = this.app.meta.logger.get(clientName).child({
         beanFullName: this.$beanFullName
@@ -1193,6 +1367,7 @@ class BeanBase extends BeanBaseSimple {
     return this[SymbolLogger][clientName];
   }
   $loggerChild(childName, clientName = 'default') {
+    if (getRequestBoundary()) return getSuppressedDiagnosticLogger();
     if (!this[SymbolLoggerChildren][clientName]) this[SymbolLoggerChildren][clientName] = {};
     if (!this[SymbolLoggerChildren][clientName][childName]) {
       this[SymbolLoggerChildren][clientName][childName] = this.app.meta.logger.get(clientName).child({
@@ -2456,21 +2631,72 @@ class VonaAsyncLocalStorage extends AsyncLocalStorage {
   constructor(app) {
     super();
     this.app = void 0;
+    this.observedRuns = new WeakMap();
     this.app = app;
   }
   async run(store, callback, ...args) {
     if (store === this.app.currentContext) {
       return await callback(...args);
     }
-    return super.run(store, async (...args) => {
+    if (this.observedRuns.has(store)) throw new Error('Context scope already owned');
+    return this._runOwned(store, () => callback(...args));
+  }
+  async runObserved(store, callback, observer) {
+    if (store === this.app.currentContext || this.observedRuns.has(store)) {
+      throw new Error('Context scope already owned');
+    }
+    const frame = {
+      settled: false
+    };
+    this.observedRuns.set(store, frame);
+    try {
+      return await this._runOwned(store, callback, observer);
+    } finally {
+      frame.settled = true;
+    }
+  }
+  _runOwned(store, callback, observer) {
+    const capture = captureRequestBoundary();
+    return super.run(store, async () => {
       try {
         this.app.meta.ctxCounter.increment();
-        return await callback(...args);
+        return await callback();
       } finally {
-        await store.bean.dispose();
-        this.app.meta.ctxCounter.decrement();
+        await this._disposeOwned(store, observer, capture);
       }
-    }, ...args);
+    });
+  }
+  async _disposeOwned(store, observer, capture) {
+    try {
+      await store.bean.dispose();
+    } catch (error) {
+      this._notifyScopeOutcome(observer, 'dispose_failed', capture);
+      throw error;
+    }
+    try {
+      this.app.meta.ctxCounter.decrement();
+    } catch (error) {
+      capture?.reportFailure('diagnostic_failed');
+      throw error;
+    }
+    this._notifyScopeOutcome(observer, 'disposed', capture);
+  }
+  _notifyScopeOutcome(observer, outcome, capture) {
+    if (!observer) return;
+    try {
+      const result = observer(outcome);
+      if (result && (typeof result === 'object' || typeof result === 'function')) {
+        const then = result.then;
+        if (typeof then === 'function') {
+          capture?.reportFailure('observer_failed');
+          void new Promise((resolve, reject) => {
+            then.call(result, resolve, reject);
+          }).catch(() => {});
+        }
+      }
+    } catch {
+      capture?.reportFailure('observer_failed');
+    }
   }
 }
 
@@ -2646,26 +2872,45 @@ class AppHmr extends BeanSimple {
   }
 }
 
+const TEST_REQUIRE_FRESH_RESOURCES_ENV = 'VONA_TEST_REQUIRE_FRESH_RESOURCES';
+function requiresFreshTestResources(env = 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';
+}
+
 const SymbolLoggerInstances = Symbol('SymbolLoggerInstances');
+const SymbolRawLoggerInstances = Symbol('SymbolRawLoggerInstances');
 class AppLogger extends BeanSimple {
   constructor(...args) {
     super(...args);
     this[SymbolLoggerInstances] = {};
+    this[SymbolRawLoggerInstances] = {};
   }
   async dispose() {
-    for (const key in this[SymbolLoggerInstances]) {
-      const logger = this[SymbolLoggerInstances][key];
+    for (const key in this[SymbolRawLoggerInstances]) {
+      const logger = this[SymbolRawLoggerInstances][key];
       await _closeLogger(logger);
     }
   }
   get(clientName) {
+    if (requiresFreshTestResources() || getRequestBoundary()) {
+      return getSuppressedDiagnosticLogger();
+    }
     clientName = clientName || 'default';
     if (!this[SymbolLoggerInstances][clientName]) {
-      this[SymbolLoggerInstances][clientName] = this._createClient(clientName);
+      const raw = this._createClient(clientName);
+      this[SymbolRawLoggerInstances][clientName] = raw;
+      this[SymbolLoggerInstances][clientName] = createDiagnosticLogger(raw);
     }
     return this[SymbolLoggerInstances][clientName];
   }
   child(childName, clientName) {
+    if (requiresFreshTestResources() || getRequestBoundary()) {
+      return getSuppressedDiagnosticLogger();
+    }
     const logger = this.get(clientName);
     if (!childName) return logger;
     return logger.child({
@@ -2721,6 +2966,9 @@ class AppLogger extends BeanSimple {
     }, Winston);
   }
   createTransportFile(fileName, clientInfo, options) {
+    if (requiresFreshTestResources()) {
+      throw new Error('Strict test file logger transport is disabled');
+    }
     const dirname = this.app.config.logger.baseDir;
     if (!fse.existsSync(dirname)) {
       const [_, err] = catchErrorSync(() => {
@@ -3081,10 +3329,16 @@ var localesDefault = {
 };
 
 const SymbolLoggerMessage = Symbol('SymbolLoggerMessage');
-const formatLoggerAxiosError = Winston.format((einfo, {
-  stack,
-  cause
-}) => {
+const formatLoggerBoundary = Winston.format(info => {
+  if (getRequestBoundary()) return false;
+  return info;
+});
+const formatLoggerAxiosError = Winston.format((einfo, opts) => {
+  if (getRequestBoundary()) return false;
+  const {
+    stack,
+    cause
+  } = opts;
   if (einfo instanceof Error && einfo.constructor.name.includes('AxiosError') || einfo.name === 'AxiosError' || einfo.isAxiosError) {
     const info = Object.assign({}, einfo, {
       level: einfo.level,
@@ -3104,9 +3358,11 @@ const formatLoggerAxiosError = Winston.format((einfo, {
   return einfo;
 });
 const formatLoggerErrors = opts => {
-  return Winston.format.combine(formatLoggerAxiosError(opts), Winston.format.errors(opts));
+  if (getRequestBoundary()) return formatLoggerBoundary();
+  return Winston.format.combine(formatLoggerBoundary(), formatLoggerAxiosError(opts), Winston.format.errors(opts));
 };
 const formatLoggerCtx = Winston.format((info, _opts) => {
+  if (getRequestBoundary()) return false;
   const app = useApp();
   if (!app.ctx) return info;
   if (app.ctx.method) info.method = app.ctx.method;
@@ -3123,11 +3379,13 @@ const formatLoggerCtx = Winston.format((info, _opts) => {
   return info;
 });
 const formatLoggerDummy = Winston.format(info => {
+  if (getRequestBoundary()) return false;
   const app = useApp();
   if (app.meta.env.LOGGER_DUMMY === 'true') return false;
   return info;
 });
 const formatLoggerFilter = Winston.format((info, opts) => {
+  if (getRequestBoundary()) return false;
   // check client
   const child = typeof opts.child === 'function' ? opts.child() : opts.child;
   if (child && !child.includes(info.name)) {
@@ -3147,16 +3405,18 @@ const formatLoggerFilter = Winston.format((info, opts) => {
   return false;
 });
 const formatLoggerConsole = clientInfo => {
-  return Winston.format.printf(({
-    timestamp,
-    level,
-    stack,
-    message,
-    name,
-    beanFullName,
-    durationMs,
-    ...meta
-  }) => {
+  return Winston.format.combine(formatLoggerBoundary(), Winston.format.printf(info => {
+    if (getRequestBoundary()) return '';
+    const {
+      timestamp,
+      level,
+      stack,
+      message,
+      name,
+      beanFullName,
+      durationMs,
+      ...meta
+    } = info;
     const textClientName = clientInfo.clientName === 'default' ? '' : ` ${chalk.cyan(`[${clientInfo.clientName}]`)}`;
     const textName = name ? ` ${chalk.cyan(`[${name}]`)}` : '';
     const textBeanFullName = beanFullName ? ` ${chalk.gray(`[${beanFullName}]`)}` : '';
@@ -3165,9 +3425,10 @@ const formatLoggerConsole = clientInfo => {
     const textDurationMs = durationMs !== undefined ? ` ${chalk.cyan(`+${durationMs}ms`)}` : '';
     const textStack = stack ? `\n${stack}` : '';
     return `${timestamp} ${level}${textClientName}${textName}${textBeanFullName}${textMeta}${textMessage}${textDurationMs}${textStack}`;
-  });
+  }));
 };
 function __formatLoggerFilterCheckInfo(info) {
+  if (getRequestBoundary()) return false;
   if (typeof info.message === 'function') {
     if (info.message[SymbolLoggerMessage] === undefined) {
       info.message[SymbolLoggerMessage] = info.message();
@@ -4237,6 +4498,156 @@ function assertTestClaimRedisClient(app, clientName, options) {
   if (plan.kind === 'client' ? options.keyPrefix !== plan.prefix : options.keyPrefix !== undefined) throw new Error('Unregistered managed Redis key prefix');
 }
 
+const freshApps = new WeakSet();
+function assertFreshTestResourcesReady(app) {
+  if (!requiresFreshTestResources()) return;
+  if (!freshApps.has(app)) throw new Error('Strict test resource freshness was not established');
+}
+async function assertEmptyDirectory(directory) {
+  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.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.
+async function assertFreshTestResources(app, dependencies) {
+  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;
+  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);
+}
+async function hasFreshnessDatabase(connection, plan) {
+  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();
+  }
+}
+async function hasFreshnessRedis(connection, prefix, 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');
+}
+function createFreshnessDependencies(projectPath, load = createRequire(path.join(projectPath, 'package.json'))) {
+  return {
+    async databaseExists(plan, options) {
+      const endpoint = plan.endpoint;
+      const source = options.connection;
+      const target = {
+        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();
+      }
+    }
+  };
+}
+
 function jsxEnhance() {
   const createElementOriginal = React.createElement;
   React.createElement = function (...args) {
@@ -4456,6 +4867,7 @@ 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();
@@ -4845,5 +5257,5 @@ async function retry(options, fn) {
 
 zodExtendOpenApi();
 
-export { $Class, $localeScope, $makeLocaleMagic, $protocolKey, AppHmr, AppHmrDeps, AppLocale, AppLogger, AppMeta, AppMetadata, AppResource, AppUtil, BeanAopBase, BeanAopMethodBase, BeanBase, BeanBaseSimple, BeanContainer, BeanInfo, BeanScopeBase, BeanScopeContainer, BeanScopeError, BeanScopeErrorImpl, BeanScopeLocale, BeanScopeScene, BeanScopeUtil, BeanSimple, EnumAppEvent, ErrorClass, Global, LocaleModuleNameSeparator, PickClassInner, ProxyDisable, SymbolBeanContainerInstances, SymbolBeanFullName, SymbolBeanInstanceKey, SymbolBeanInstancePropsLazy, SymbolCacheAopChains, SymbolCacheAopChainsKey, SymbolDecoratorBeanFullName, SymbolDecoratorBeanInfo, SymbolDecoratorGlobal, SymbolDecoratorProxyDisable, SymbolDecoratorUse, SymbolDecoratorVirtual, SymbolHmrStateLoad, SymbolHmrStateSave, SymbolMappedClassMetadataKeys, SymbolModuleBelong, SymbolModuleName, TEST_CLAIM_DIRECTORY, TEST_CLAIM_TOKEN_ENV, TEST_CLAIM_URL_ENV, TEST_CLAIM_WINDOWS_GUARDIAN_ENV, TEST_RUN_ID_ENV, TEST_RUN_OWNER_FILE, Use, Virtual, VonaApplication, __prepareInjectSelectorInfo, appHmrDeps, appMetadata, appResource, assertDisposableDatabaseName, assertIsolatedTestConfig, assertIsolatedTestDatabaseClient, assertIsolatedTestPath, assertTestAppIdentity, assertTestClaimDatabaseClient, assertTestClaimRedisClient, assertTestClaimSafePath, assertTestClaimWindowsJob, assertTestRunOwner, beanFullNameFromOnionName, bootstrap, buildTestClaimResourceInventory, cast, closeApp, closeProcessWorker, combineConfigDefault, combineFilePathSafe, compose, copyAddon, copyMetadataOfClasses, copyProperties, copyPropertiesOfClasses, createApp, createAppMaster, createBeanDecorator, createGeneralApp, createHash, createTestClaim, deepExtend, disposeInstance, errorsInternal, filterHeaders, formatLoggerAxiosError, formatLoggerConsole, formatLoggerCtx, formatLoggerDummy, formatLoggerErrors, formatLoggerFilter, functionNoop, getDatabaseTestPrefix, getHomeVonaAppDir, getLoggerPathPhysicalRoot, getMappedClassMetadataKeys, getPlatformArch, getPublicPathPhysicalRoot, getRuntimePathPhysicalRoot, getSqlite3DatabaseNameDefault, getTestAppName, getTestClaimCreatedAt, getTestClaimPaths, getTestClaimRedisPrefix, getTestRunIdFromEnv, hasTestClaimTransport, instanceDesp, isLocaleMagic, loadJSONFile, loadTestClaim, mergeTestClaimDatabaseOptions, mergeTestClaimRedisOptions, normalizeTestClaimDatabaseEndpoint, normalizeTestClaimRedisEndpoint, onionNameFromBeanFullName, pathToHref, polyfillDispose, prepareEnv, registerMappedClassMetadataKey, registerTestClaimDatabaseCreation, registerTestClaimResourceInventory, registerTestClaimWindowsJobVerifier, requireAddon, requireDynamic, resolveAddon, resolveTestRunId, resolveVonaLocalPaths, resolverSharp, resolverSharpLibvips, resolverSqlite3, retry, saveJSONFile, sendTestClaimEvent, setMappedClassMetadataKeys, startTestClaimBroker, text$1 as text, useApp, usePrepareArg, usePrepareArgs, uuidv4, validateTestClaim, withIsolatedTestDatabaseDiscovery, writeTestClaim };
+export { $Class, $localeScope, $makeLocaleMagic, $protocolKey, AppHmr, AppHmrDeps, AppLocale, AppLogger, AppMeta, AppMetadata, AppResource, AppUtil, BeanAopBase, BeanAopMethodBase, BeanBase, BeanBaseSimple, BeanContainer, BeanInfo, BeanScopeBase, BeanScopeContainer, BeanScopeError, BeanScopeErrorImpl, BeanScopeLocale, BeanScopeScene, BeanScopeUtil, BeanSimple, EnumAppEvent, ErrorClass, Global, LocaleModuleNameSeparator, PickClassInner, ProxyDisable, SymbolBeanContainerInstances, SymbolBeanFullName, SymbolBeanInstanceKey, SymbolBeanInstancePropsLazy, SymbolCacheAopChains, SymbolCacheAopChainsKey, SymbolDecoratorBeanFullName, SymbolDecoratorBeanInfo, SymbolDecoratorGlobal, SymbolDecoratorProxyDisable, SymbolDecoratorUse, SymbolDecoratorVirtual, SymbolHmrStateLoad, SymbolHmrStateSave, SymbolMappedClassMetadataKeys, SymbolModuleBelong, SymbolModuleName, TEST_CLAIM_DIRECTORY, TEST_CLAIM_TOKEN_ENV, TEST_CLAIM_URL_ENV, TEST_CLAIM_WINDOWS_GUARDIAN_ENV, TEST_REQUIRE_FRESH_RESOURCES_ENV, TEST_RUN_ID_ENV, TEST_RUN_OWNER_FILE, Use, Virtual, VonaApplication, __prepareInjectSelectorInfo, appHmrDeps, appMetadata, appResource, assertDisposableDatabaseName, assertFreshTestResources, assertFreshTestResourcesReady, assertIsolatedTestConfig, assertIsolatedTestDatabaseClient, assertIsolatedTestPath, assertTestAppIdentity, assertTestClaimDatabaseClient, assertTestClaimRedisClient, assertTestClaimSafePath, assertTestClaimWindowsJob, assertTestRunOwner, beanFullNameFromOnionName, bootstrap, buildTestClaimResourceInventory, captureRequestBoundary, cast, closeApp, closeProcessWorker, combineConfigDefault, combineFilePathSafe, compose, copyAddon, copyMetadataOfClasses, copyProperties, copyPropertiesOfClasses, createApp, createAppMaster, createBeanDecorator, createDiagnosticLogger, createFreshnessDependencies, createGeneralApp, createHash, createRequestBoundary, createTestClaim, deepExtend, disposeInstance, errorsInternal, filterHeaders, formatLoggerAxiosError, formatLoggerBoundary, formatLoggerConsole, formatLoggerCtx, formatLoggerDummy, formatLoggerErrors, formatLoggerFilter, functionNoop, getDatabaseTestPrefix, getHomeVonaAppDir, getLoggerPathPhysicalRoot, getMappedClassMetadataKeys, getPlatformArch, getPublicPathPhysicalRoot, getRequestBoundary, getRuntimePathPhysicalRoot, getSqlite3DatabaseNameDefault, getSuppressedDiagnosticLogger, getTestAppName, getTestClaimCreatedAt, getTestClaimPaths, getTestClaimRedisPrefix, getTestRunIdFromEnv, hasFreshnessDatabase, hasFreshnessRedis, hasTestClaimTransport, instanceDesp, isLocaleMagic, loadJSONFile, loadTestClaim, mergeTestClaimDatabaseOptions, mergeTestClaimRedisOptions, normalizeTestClaimDatabaseEndpoint, normalizeTestClaimRedisEndpoint, onionNameFromBeanFullName, pathToHref, polyfillDispose, prepareEnv, registerMappedClassMetadataKey, registerTestClaimDatabaseCreation, registerTestClaimResourceInventory, registerTestClaimWindowsJobVerifier, requireAddon, requireDynamic, requiresFreshTestResources, resolveAddon, resolveTestRunId, resolveVonaLocalPaths, resolverSharp, resolverSharpLibvips, resolverSqlite3, retry, runWithRequestBoundary, saveJSONFile, sendTestClaimEvent, setMappedClassMetadataKeys, startTestClaimBroker, text$1 as text, useApp, usePrepareArg, usePrepareArgs, uuidv4, validateTestClaim, withIsolatedTestDatabaseDiscovery, writeTestClaim };
 //# sourceMappingURL=index.js.map