velocious 1.0.619 → 1.0.621

package/build/src/environment-handlers/node.js

@@ -144,6 +144,17 @@ export default class VelociousEnvironmentHandlerNode extends Base {
         owners.set(connection, owner);
         return this._sharedTransactionCoordinatorAsyncLocalStorage.run(owners, callback);
     }
+    /**
+     * Runs work without inherited shared-transaction coordinator ownership.
+     * @template T
+     * @param {() => T} callback - Detached work.
+     * @returns {T} - Callback result.
+     */
+    runWithoutSharedTransactionCoordinatorOwners(callback) {
+        if (!this._sharedTransactionCoordinatorAsyncLocalStorage)
+            return callback();
+        return this._sharedTransactionCoordinatorAsyncLocalStorage.run(new Map(), callback);
+    }
     /**
      * Runs work with async-safe test profile attribution.
      * @template T
@@ -1117,4 +1128,4 @@ export default class VelociousEnvironmentHandlerNode extends Base {
         await ensureFrontendModelWebsocketPublishersRegistered(configuration);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/environment-handlers/node.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport \"../database/annotations-async-hooks.js\"\nimport Base from \"./base.js\"\nimport BackgroundJobsClient from \"../background-jobs/client.js\"\nimport SqlBackgroundJobsAdapter from \"../background-jobs/sql-adapter.js\"\nimport CliCommandsDestroyMigration from \"./node/cli/commands/destroy/migration.js\"\nimport CliCommandsInit from \"./node/cli/commands/init.js\"\nimport CliCommandsGenerateBaseModels from \"./node/cli/commands/generate/base-models.js\"\nimport CliCommandsGenerateFrontendModels from \"./node/cli/commands/generate/frontend-models.js\"\nimport CliCommandsGenerateMigration from \"./node/cli/commands/generate/migration.js\"\nimport CliCommandsGenerateModel from \"./node/cli/commands/generate/model.js\"\nimport CliCommandsLintRelationships from \"./node/cli/commands/lint/relationships.js\"\nimport CliCommandsRoutes from \"./node/cli/commands/routes.js\"\nimport CliCommandsServer from \"./node/cli/commands/server.js\"\nimport CliCommandsTest from \"./node/cli/commands/test.js\"\nimport CliCommandsTestTimingManifestMerge from \"./node/cli/commands/test/timing-manifest/merge.js\"\nimport CliCommandsBackgroundJobsMain from \"./node/cli/commands/background-jobs-main.js\"\nimport CliCommandsBackgroundJobsWorker from \"./node/cli/commands/background-jobs-worker.js\"\nimport CliCommandsBackgroundJobsRunner from \"./node/cli/commands/background-jobs-runner.js\"\nimport CliCommandsBeacon from \"./node/cli/commands/beacon.js\"\nimport CliCommandsConsole from \"./node/cli/commands/console.js\"\nimport CliCommandsDbSchemaDump from \"./node/cli/commands/db/schema/dump.js\"\nimport CliCommandsDbSchemaLoad from \"./node/cli/commands/db/schema/load.js\"\nimport CliCommandsDbSeed from \"./node/cli/commands/db/seed.js\"\nimport CliCommandsRunner from \"./node/cli/commands/runner.js\"\nimport CliCommandsRunScript from \"./node/cli/commands/run-script.js\"\nimport frontendModelCommandRouteHook from \"../routes/hooks/frontend-model-command-route-hook.js\"\nimport {FRAMEWORK_SOURCE_DIRECTORY} from \"../utils/backtrace-cleaner-node.js\"\nimport {dirname} from \"path\"\nimport {fileURLToPath} from \"url\"\nimport fs from \"fs/promises\"\nimport * as inflection from \"inflection\"\nimport path from \"path\"\nimport {AsyncLocalStorage as NodeAsyncLocalStorage} from \"node:async_hooks\"\nimport {timingSafeEqual} from \"node:crypto\"\nimport requireContext from \"require-context\"\nimport AsyncTrackedMultiConnectionPool from \"../database/pool/async-tracked-multi-connection.js\"\nimport InitializerFromRequireContext from \"../database/initializer-from-require-context.js\"\nimport toImportSpecifier from \"../utils/to-import-specifier.js\"\nimport {validateTimeZone} from \"../time-zone.js\"\nimport AttachmentPathSource from \"./node/attachment-path-source.js\"\nimport { automaticSharedTransactionBrokerOmits, createSharedTransactionProxyDriver, sharedTransactionBrokerConfig } from \"../testing/shared-transaction-proxy-driver.js\"\n\n/**\n * Defines this typedef.\n * @typedef {{ability?: import(\"../authorization/ability.js\").default, offsetMinutes: number, requestTiming?: import(\"../http-server/client/request-timing.js\").default, tenant?: ReturnType<typeof JSON.parse>, testProfileContext?: import(\"../testing/test-profiler.js\").TestProfileAsyncContext, timeZone?: string}} TimezoneStore */\n\n/**\n * Runs path within allowed prefixes.\n * @param {string} filePath - Input file path.\n * @param {string[]} allowedPathPrefixes - Allowed path prefixes.\n * @returns {boolean} - Whether input path is inside an allowed prefix.\n */\nfunction pathWithinAllowedPrefixes(filePath, allowedPathPrefixes) {\n  const resolvedPath = path.resolve(filePath)\n\n  return allowedPathPrefixes.some((allowedPrefix) => {\n    const resolvedPrefix = path.resolve(allowedPrefix)\n    const relativePath = path.relative(resolvedPrefix, resolvedPath)\n\n    if (!relativePath) return true\n    if (relativePath.startsWith(\"..\")) return false\n    if (path.isAbsolute(relativePath)) return false\n\n    return true\n  })\n}\n\nexport default class VelociousEnvironmentHandlerNode extends Base{\n  /**\n   * Creates the built-in SQL persistence adapter.\n   * @param {{configuration: import(\"../configuration.js\").default}} args - Adapter options.\n   * @returns {SqlBackgroundJobsAdapter} - SQL adapter.\n   */\n  createBackgroundJobsAdapter({configuration}) {\n    return new SqlBackgroundJobsAdapter({configuration})\n  }\n\n  /**\n   * Preserves the Node TCP producer and main-process wake-up path. The main\n   * owns the configured persistence adapter; Node producers never bypass it.\n   * @param {{configuration: import(\"../configuration.js\").default}} args - Client options.\n   * @returns {import(\"../background-jobs/types.js\").BackgroundJobsProducer} - Producer client.\n   */\n  backgroundJobsClient({configuration}) {\n    return new BackgroundJobsClient({configuration})\n  }\n\n  /**\n   * Gives concurrent shared-transaction child jobs independent proxy sessions.\n   * A configured single-connection pool shares mutable transaction state between\n   * async jobs, while the broker requires one root-transaction lease per socket.\n   * @param {{configuredPoolType: typeof import(\"../database/pool/base.js\").default, databaseIdentifier: string}} args - Configured pool and logical database identifier.\n   * @returns {typeof import(\"../database/pool/base.js\").default} - Pool type for this context.\n   */\n  resolveTestSharedTransactionPoolType({configuredPoolType, databaseIdentifier}) {\n    const databaseConfiguration = this.getConfiguration().getDatabaseIdentifier(databaseIdentifier)\n    if (databaseConfiguration.tenantOnly && automaticSharedTransactionBrokerOmits(databaseIdentifier)) return configuredPoolType\n    if (!sharedTransactionBrokerConfig(databaseIdentifier)) return configuredPoolType\n\n    return AsyncTrackedMultiConnectionPool\n  }\n\n  /**\n   * Creates a test-only child proxy when TestRunner supplied an active broker.\n   * @param {{DriverClass: typeof import(\"../database/drivers/base.js\").default, config: import(\"../configuration-types.js\").DatabaseConfigurationType, configuration: import(\"../configuration.js\").default, databaseIdentifier: string, reuseKey?: string}} args - Connection details.\n   * @returns {Promise<import(\"../database/drivers/base.js\").default | undefined>} - Optional proxy.\n   */\n  async createTestSharedTransactionConnection({DriverClass, config, configuration, databaseIdentifier, reuseKey}) {\n    if (config.tenantOnly && automaticSharedTransactionBrokerOmits(databaseIdentifier)) return undefined\n    const brokerConfig = sharedTransactionBrokerConfig(databaseIdentifier)\n    if (!brokerConfig) return undefined\n    return createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, {\n      ...brokerConfig,\n      reuseKey: brokerConfig.allowDynamicIdentities ? reuseKey : undefined\n    })\n  }\n\n  /**\n   * Timezone async local storage.\n   * @type {import(\"node:async_hooks\").AsyncLocalStorage<TimezoneStore> | undefined} */\n  _timezoneAsyncLocalStorage = NodeAsyncLocalStorage ? new NodeAsyncLocalStorage() : undefined\n\n  /**\n   * Shared-transaction coordinator ownership by physical connection.\n   * @type {import(\"node:async_hooks\").AsyncLocalStorage<Map<object, symbol>> | undefined}\n   */\n  _sharedTransactionCoordinatorAsyncLocalStorage = NodeAsyncLocalStorage ? new NodeAsyncLocalStorage() : undefined\n\n  /**\n   * Gets the active shared-transaction coordinator owner for a connection.\n   * @param {object} connection - Parent physical connection.\n   * @returns {symbol | undefined} - Active coordinator owner.\n   */\n  getSharedTransactionCoordinatorOwner(connection) {\n    return this._sharedTransactionCoordinatorAsyncLocalStorage?.getStore()?.get(connection)\n  }\n\n  /**\n   * Runs work as the current shared-transaction coordinator owner.\n   * @template T\n   * @param {object} connection - Parent physical connection.\n   * @param {symbol} owner - Coordinator owner.\n   * @param {() => T} callback - Owned work.\n   * @returns {T} - Callback result.\n   */\n  runWithSharedTransactionCoordinatorOwner(connection, owner, callback) {\n    if (!this._sharedTransactionCoordinatorAsyncLocalStorage) return callback()\n\n    const owners = new Map(this._sharedTransactionCoordinatorAsyncLocalStorage.getStore())\n\n    owners.set(connection, owner)\n    return this._sharedTransactionCoordinatorAsyncLocalStorage.run(owners, callback)\n  }\n\n  /**\n   * Runs work with async-safe test profile attribution.\n   * @template T\n   * @param {import(\"../testing/test-profiler.js\").TestProfileAsyncContext | undefined} context - Captured profile context, or an explicit absence of attribution.\n   * @param {() => T} callback - Profiled work.\n   * @returns {T} - Callback result.\n   */\n  runWithTestProfileContext(context, callback) {\n    if (!this._timezoneAsyncLocalStorage) return callback()\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: context,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Gets the current async-safe test profile attribution context.\n   * @returns {import(\"../testing/test-profiler.js\").TestProfileAsyncContext | undefined} - Current context.\n   */\n  getCurrentTestProfileContext() {\n    return this._timezoneAsyncLocalStorage?.getStore()?.testProfileContext\n  }\n\n  /**\n   * Find commands result.\n   * @type {import(\"./base.js\").CommandFileObjectType[] | undefined} */\n  _findCommandsResult = undefined\n\n  /**\n   * Runs debug endpoint token matches.\n   * @param {string} providedToken - Token from the request.\n   * @param {string} expectedToken - Configured token.\n   * @returns {boolean} - Whether both tokens match.\n   */\n  debugEndpointTokenMatches(providedToken, expectedToken) {\n    const provided = Buffer.from(providedToken)\n    const expected = Buffer.from(expectedToken)\n\n    return provided.length === expected.length && timingSafeEqual(provided, expected)\n  }\n\n  /**\n   * Runs get framework source directory.\n   * @returns {string | undefined} - Velocious source directory used to filter framework stack frames.\n   */\n  getFrameworkSourceDirectory() {\n    return FRAMEWORK_SOURCE_DIRECTORY\n  }\n\n  /**\n   * Auto-discovers resource classes from src/resources/ in each backend project.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {Promise<void>}\n   */\n  async autoDiscoverResources(configuration) {\n    const {frontendModelResourceDefinitionIsClass} = await import(\"../frontend-models/resource-definition.js\")\n    const {default: AuthorizationBaseResource} = await import(\"../authorization/base-resource.js\")\n    const backendProjects = configuration.getBackendProjects()\n\n    for (const backendProject of backendProjects) {\n      if (backendProject.abilityResources) continue\n\n      const resourcesDir = backendProject.resourcesPath || path.join(backendProject.path, \"src\", \"resources\")\n      let files\n\n      try {\n        files = await fs.readdir(resourcesDir)\n      } catch {\n        continue\n      }\n\n      /**\n       * Discovered frontend-model resources keyed by model name.\n       * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n      const discovered = {}\n      /**\n       * Every discovered ability resource class (frontend-model and authorization).\n       * @type {Array<ReturnType<typeof JSON.parse>>} */\n      const abilityResourceClasses = []\n\n      for (const file of files) {\n        if (!file.endsWith(\".js\") && !file.endsWith(\".mjs\")) continue\n        if (file.startsWith(\"frontend-model-resources\")) continue\n\n        const filePath = path.join(resourcesDir, file)\n        const imported = await import(filePath)\n        const ResourceClass = imported.default\n\n        // Any authorization resource (frontend-model resources also extend it) that\n        // declares a `ModelClass`; skip abstract/common base resources without one.\n        const isAbilityResource = typeof ResourceClass === \"function\"\n          && (ResourceClass === AuthorizationBaseResource || ResourceClass.prototype instanceof AuthorizationBaseResource)\n\n        if (!isAbilityResource || !ResourceClass.ModelClass) continue\n\n        abilityResourceClasses.push(ResourceClass)\n\n        // Only frontend-model resources drive routing/generation/publisher discovery.\n        if (!frontendModelResourceDefinitionIsClass(ResourceClass)) continue\n\n        const baseName = file.replace(/\\.(js|mjs)$/, \"\")\n        const modelName = baseName.replace(/-resource$/, \"\")\n          .split(\"-\")\n          .map((/** @type {string} */ part) => part.charAt(0).toUpperCase() + part.slice(1))\n          .join(\"\")\n\n        discovered[modelName] = ResourceClass\n      }\n\n      if (!backendProject.frontendModels && Object.keys(discovered).length > 0) {\n        backendProject.frontendModels = discovered\n      }\n\n      if (abilityResourceClasses.length > 0) {\n        backendProject.abilityResources = abilityResourceClasses\n      }\n    }\n  }\n\n  /**\n   * Loads models contributed by registered packages into the model registry,\n   * after the app's own `initializeModels` hook. A package whose models directory\n   * is absent is skipped; a package model whose name collides with an\n   * already-registered different class throws. Node-only (uses the filesystem), so\n   * it lives here rather than in the browser-bundled Configuration.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializePackageModels(configuration) {\n    for (const velociousPackage of configuration.getPackages()) {\n      const modelsPath = velociousPackage.getModelsPath()\n\n      try {\n        await fs.access(modelsPath)\n      } catch {\n        continue\n      }\n\n      const packageRequireContext = /** @type {import(\"../database/initializer-from-require-context.js\").ModelClassRequireContextType} */ (requireContext(modelsPath, true, /^(.+)\\.js$/))\n      const modelClasses = configuration.getModelClasses()\n\n      for (const fileName of packageRequireContext.keys()) {\n        const modelClass = packageRequireContext(fileName)?.default\n        const existing = modelClass && modelClasses[modelClass.getModelName()]\n\n        if (existing && existing !== modelClass) {\n          throw new Error(`Package \"${velociousPackage.getName()}\" model \"${modelClass.getModelName()}\" collides with an already-registered model.`)\n        }\n      }\n\n      await configuration.ensureConnections({name: `Initialize ${velociousPackage.getName()} package models`}, async () => {\n        await new InitializerFromRequireContext({requireContext: packageRequireContext}).initialize({configuration})\n      })\n    }\n  }\n\n  /**\n   * Runs set configuration.\n   * @param {import(\"../configuration.js\").default} newConfiguration - New configuration.\n   * @returns {void} - No return value.\n   */\n  setConfiguration(newConfiguration) {\n    super.setConfiguration(newConfiguration)\n\n    if (!newConfiguration.getRouteResolverHooks().includes(frontendModelCommandRouteHook)) {\n      newConfiguration.addRouteResolverHook(frontendModelCommandRouteHook)\n    }\n  }\n\n  /**\n   * Runs read attachment input file.\n   * @param {string} filePath - File path.\n   * @returns {Promise<Buffer>} - File bytes.\n   */\n  async readAttachmentInputFile(filePath) {\n    return await fs.readFile(filePath)\n  }\n\n  /**\n   * Runs resolve attachment input path.\n   * @param {object} args - Args.\n   * @param {string[]} args.allowedPathPrefixes - Allowed path prefixes.\n   * @param {string} args.inputPath - Input path.\n   * @returns {Promise<AttachmentPathSource>} - Opened regular-file path source.\n   */\n  async resolveAttachmentInputPath({allowedPathPrefixes, inputPath}) {\n    const filePath = path.resolve(inputPath)\n    const prefixes = Array.isArray(allowedPathPrefixes)\n      ? allowedPathPrefixes.filter((entry) => typeof entry === \"string\" && entry.length > 0)\n      : []\n\n    if (prefixes.length > 0 && !pathWithinAllowedPrefixes(filePath, prefixes)) {\n      throw new Error(\"Attachment path is outside allowed directories\")\n    }\n\n    const fileHandle = await fs.open(filePath, \"r\")\n\n    try {\n      const fileStats = await fileHandle.stat()\n\n      if (!fileStats.isFile()) {\n        throw new Error(\"Attachment path must reference a regular file\")\n      }\n\n      return new AttachmentPathSource({\n        byteSize: fileStats.size,\n        fileHandle,\n        filePath\n      })\n    } catch (error) {\n      try {\n        await fileHandle.close()\n      } catch (closeError) {\n        throw new AggregateError(\n          [error, closeError],\n          `Attachment path validation and source close both failed for ${filePath}`,\n          {cause: closeError}\n        )\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs find commands.\n   * @returns {Promise<Array<import(\"./base.js\").CommandFileObjectType>>} - Resolves with the commands.\n   */\n  async findCommands() {\n    this._findCommandsResult ||= await this._actualFindCommands()\n\n    if (!this._findCommandsResult) throw new Error(\"Could not get commands\")\n\n    return this._findCommandsResult\n  }\n\n  /**\n   * Runs run with timezone offset.\n   * @param {number} offsetMinutes - Offset in minutes (Date#getTimezoneOffset).\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback to run.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Result of the callback.\n   */\n  async runWithTimezoneOffset(offsetMinutes, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await callback()\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes,\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs run with timezone.\n   * @param {string} timeZone - IANA timezone identifier.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback to run.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Result of the callback.\n   */\n  async runWithTimezone(timeZone, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithTimezone(timeZone, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: validateTimeZone(timeZone, \"timeZone\")\n    }, callback)\n  }\n\n  /**\n   * Runs set timezone offset.\n   * @param {number} offsetMinutes - Offset in minutes (Date#getTimezoneOffset).\n   * @returns {void} - No return value.\n   */\n  setTimezoneOffset(offsetMinutes) {\n    if (!this._timezoneAsyncLocalStorage) return\n\n    const store = this._timezoneAsyncLocalStorage.getStore()\n\n    if (store) {\n      store.offsetMinutes = offsetMinutes\n    } else {\n      const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability: existingStore?.ability,\n        offsetMinutes,\n        requestTiming: existingStore?.requestTiming,\n        tenant: existingStore?.tenant,\n        testProfileContext: existingStore?.testProfileContext,\n        timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n      })\n    }\n  }\n\n  /**\n   * Runs set timezone.\n   * @param {string} timeZone - IANA timezone identifier.\n   * @returns {void} - No return value.\n   */\n  setTimezone(timeZone) {\n    if (!this._timezoneAsyncLocalStorage) {\n      super.setTimezone(timeZone)\n      return\n    }\n\n    const normalizedTimeZone = validateTimeZone(timeZone, \"timeZone\")\n    const store = this._timezoneAsyncLocalStorage.getStore()\n\n    if (store) {\n      store.timeZone = normalizedTimeZone\n    } else {\n      const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability: existingStore?.ability,\n        offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n        requestTiming: existingStore?.requestTiming,\n        tenant: existingStore?.tenant,\n        testProfileContext: existingStore?.testProfileContext,\n        timeZone: normalizedTimeZone\n      })\n    }\n  }\n\n  /**\n   * Runs get timezone offset minutes.\n   * @param {import(\"../configuration.js\").default | undefined} configuration - Configuration instance.\n   * @returns {number} - Offset in minutes.\n   */\n  getTimezoneOffsetMinutes(configuration) {\n    if (this._timezoneAsyncLocalStorage) {\n      const store = this._timezoneAsyncLocalStorage.getStore()\n\n      if (store && typeof store.offsetMinutes === \"number\") {\n        return store.offsetMinutes\n      }\n    }\n\n    return super.getTimezoneOffsetMinutes(configuration)\n  }\n\n  /**\n   * Runs get timezone.\n   * @param {import(\"../configuration.js\").default | undefined} configuration - Configuration instance.\n   * @returns {string | undefined} - Timezone identifier.\n   */\n  getTimeZone(configuration) {\n    if (this._timezoneAsyncLocalStorage) {\n      const store = this._timezoneAsyncLocalStorage.getStore()\n\n      if (store && typeof store.timeZone === \"string\") {\n        return store.timeZone\n      }\n    }\n\n    return super.getTimeZone(configuration)\n  }\n\n  /**\n   * Runs run with ability.\n   * @param {import(\"../authorization/ability.js\").default | undefined} ability - Ability to set for callback scope.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Callback result.\n   */\n  async runWithAbility(ability, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithAbility(ability, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs set current ability.\n   * @param {import(\"../authorization/ability.js\").default | undefined} ability - Ability to set.\n   * @returns {void} - No return value.\n   */\n  setCurrentAbility(ability) {\n    if (!this._timezoneAsyncLocalStorage) {\n      super.setCurrentAbility(ability)\n      return\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    if (existingStore) {\n      existingStore.ability = ability\n    } else {\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability,\n        offsetMinutes: this.getTimezoneOffsetMinutes(this.getConfiguration()),\n        requestTiming: undefined,\n        tenant: undefined,\n        testProfileContext: undefined,\n        timeZone: this.getTimeZone(this.getConfiguration())\n      })\n    }\n  }\n\n  /**\n   * Runs get current ability.\n   * @returns {import(\"../authorization/ability.js\").default | undefined} - Current ability.\n   */\n  getCurrentAbility() {\n    if (!this._timezoneAsyncLocalStorage) {\n      return super.getCurrentAbility()\n    }\n\n    return this._timezoneAsyncLocalStorage.getStore()?.ability\n  }\n\n  /**\n   * Runs run with request timing.\n   * @param {import(\"../http-server/client/request-timing.js\").default | undefined} requestTiming - Request timing collector.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Callback result.\n   */\n  async runWithRequestTiming(requestTiming, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithRequestTiming(requestTiming, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs get current request timing.\n   * @returns {import(\"../http-server/client/request-timing.js\").default | undefined} - Current request timing collector.\n   */\n  getCurrentRequestTiming() {\n    if (!this._timezoneAsyncLocalStorage) {\n      return super.getCurrentRequestTiming()\n    }\n\n    return this._timezoneAsyncLocalStorage.getStore()?.requestTiming\n  }\n\n  /**\n   * Runs run with tenant.\n   * @param {ReturnType<typeof JSON.parse>} tenant - Tenant to set for callback scope.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Callback result.\n   */\n  async runWithTenant(tenant, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithTenant(tenant, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs set current tenant.\n   * @param {ReturnType<typeof JSON.parse>} tenant - Tenant to set.\n   * @returns {void} - No return value.\n   */\n  setCurrentTenant(tenant) {\n    if (!this._timezoneAsyncLocalStorage) {\n      super.setCurrentTenant(tenant)\n      return\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    if (existingStore) {\n      existingStore.tenant = tenant\n    } else {\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability: undefined,\n        offsetMinutes: this.getTimezoneOffsetMinutes(this.getConfiguration()),\n        requestTiming: undefined,\n        tenant,\n        testProfileContext: undefined,\n        timeZone: this.getTimeZone(this.getConfiguration())\n      })\n    }\n  }\n\n  /**\n   * Runs get current tenant.\n   * @returns {ReturnType<typeof JSON.parse>} - Current tenant.\n   */\n  getCurrentTenant() {\n    if (!this._timezoneAsyncLocalStorage) {\n      return super.getCurrentTenant()\n    }\n\n    return this._timezoneAsyncLocalStorage.getStore()?.tenant\n  }\n\n  /**\n   * Runs actual find commands.\n   * @returns {Promise<Array<import(\"./base.js\").CommandFileObjectType>>} - Resolves with discovered command files.\n   */\n  async _actualFindCommands() {\n    const basePath = await this.getBasePath()\n    const commandFiles = fs.glob(`${basePath}/src/cli/commands/**/*.js`)\n    const commands = []\n\n    for await (const aFilePath of commandFiles) {\n      const commandName = this.commandNameFromFilePath(aFilePath)\n\n      commands.push({name: commandName, file: aFilePath})\n    }\n\n    return commands\n  }\n\n  /**\n   * Runs command name from file path.\n   * @param {string} filePath - Full command file path.\n   * @returns {string} - Parsed command name.\n   */\n  commandNameFromFilePath(filePath) {\n    const aFilePathParts = filePath.split(/[\\\\/]/)\n    const commandPathLocation = aFilePathParts.indexOf(\"commands\")\n\n    if (commandPathLocation === -1) {\n      throw new Error(`Could not parse command file path: ${filePath}`)\n    }\n\n    const commandParts = aFilePathParts.slice(commandPathLocation + 1)\n    const lastPart = commandParts[commandParts.length - 1]\n    let name, paths\n\n    if (lastPart == \"index.js\") {\n      name = commandParts[commandParts.length - 2]\n      paths = commandParts.slice(0, -2)\n    } else {\n      name = lastPart.replace(\".js\", \"\")\n      paths = commandParts.slice(0, -1)\n    }\n\n    return `${paths.join(\":\")}${paths.length > 0 ? \":\" : \"\"}${name}`\n  }\n\n  /**\n   * Runs cli commands init.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsInit(command) {\n    return await this.forwardCommand(command, CliCommandsInit)\n  }\n\n  /**\n   * Runs cli commands migration generate.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsMigrationGenerate(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateMigration)\n  }\n\n  /**\n   * Runs cli commands migration destroy.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsMigrationDestroy(command) {\n    return await this.forwardCommand(command, CliCommandsDestroyMigration)\n  }\n\n  /**\n   * Runs cli commands generate base models.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsGenerateBaseModels(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateBaseModels)\n  }\n\n  /**\n   * Runs cli commands generate frontend models.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsGenerateFrontendModels(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateFrontendModels)\n  }\n\n  /**\n   * Runs cli commands generate model.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsGenerateModel(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateModel)\n  }\n\n  /**\n   * Runs cli commands lint relationships.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsLintRelationships(command) {\n    return await this.forwardCommand(command, CliCommandsLintRelationships)\n  }\n\n  /**\n   * Runs cli commands routes.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsRoutes(command) {\n    return await this.forwardCommand(command, CliCommandsRoutes)\n  }\n\n  /**\n   * Runs cli commands console.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsConsole(command) {\n    return await this.forwardCommand(command, CliCommandsConsole)\n  }\n\n  /**\n   * Runs cli commands server.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsServer(command) {\n    return await this.forwardCommand(command, CliCommandsServer)\n  }\n\n  /**\n   * Runs cli commands test.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsTest(command) {\n    return await this.forwardCommand(command, CliCommandsTest)\n  }\n\n  /**\n   * Runs cli commands test timing manifest merge.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsTestTimingManifestMerge(command) {\n    return await this.forwardCommand(command, CliCommandsTestTimingManifestMerge)\n  }\n\n  /**\n   * Runs cli commands background jobs main.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBackgroundJobsMain(command) {\n    return await this.forwardCommand(command, CliCommandsBackgroundJobsMain)\n  }\n\n  /**\n   * Runs cli commands background jobs worker.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBackgroundJobsWorker(command) {\n    return await this.forwardCommand(command, CliCommandsBackgroundJobsWorker)\n  }\n\n  /**\n   * Runs cli commands background jobs runner.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBackgroundJobsRunner(command) {\n    return await this.forwardCommand(command, CliCommandsBackgroundJobsRunner)\n  }\n\n  /**\n   * Runs cli commands beacon.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBeacon(command) {\n    return await this.forwardCommand(command, CliCommandsBeacon)\n  }\n\n  /**\n   * Runs load beacon client.\n   * @returns {Promise<typeof import(\"../beacon/client.js\").default>} - Beacon client class.\n   */\n  async loadBeaconClient() {\n    const {default: BeaconClient} = await import(\"../beacon/client.js\")\n\n    return BeaconClient\n  }\n\n  /**\n   * Runs load in process beacon client.\n   * @returns {Promise<typeof import(\"../beacon/in-process-client.js\").default>} - In-process client class.\n   */\n  async loadInProcessBeaconClient() {\n    const {default: InProcessBeaconClient} = await import(\"../beacon/in-process-client.js\")\n\n    return InProcessBeaconClient\n  }\n\n  /**\n   * Runs cli commands db schema dump.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsDbSchemaDump(command) {\n    return await this.forwardCommand(command, CliCommandsDbSchemaDump)\n  }\n\n  /**\n   * Runs cli commands db schema load.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsDbSchemaLoad(command) {\n    return await this.forwardCommand(command, CliCommandsDbSchemaLoad)\n  }\n\n  /**\n   * Runs cli commands db seed.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsDbSeed(command) {\n    return await this.forwardCommand(command, CliCommandsDbSeed)\n  }\n\n  /**\n   * Runs cli commands runner.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsRunner(command) {\n    return await this.forwardCommand(command, CliCommandsRunner)\n  }\n\n  /**\n   * Runs cli commands run script.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsRunScript(command) {\n    return await this.forwardCommand(command, CliCommandsRunScript)\n  }\n\n  /**\n   * Runs require command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.commandParts - Command parts.\n   * @returns {Promise<typeof import (\"../cli/base-command.js\").default>} - Resolves with the require command.\n   */\n  async requireCommand({commandParts}) {\n    const commands = await this.findCommands()\n    const commandName = commandParts.join(\":\")\n    const command = commands.find((aCommand) => aCommand.name === commandName)\n\n    if (!command) {\n      const possibleCommands = commands.map(aCommand => aCommand.name)\n\n      throw new Error(`Unknown command: ${commandParts.join(\":\")} which should have been one of: ${possibleCommands.sort().join(\", \")}`)\n    }\n\n    const commandClassImport = await import(toImportSpecifier(command.file))\n    const CommandClass = commandClassImport.default\n\n    return CommandClass\n  }\n\n  /**\n   * Runs find migrations.\n   * @returns {Promise<Array<import(\"./base.js\").MigrationObjectType>>} - Resolves with the migrations.\n   */\n  async findMigrations() {\n    const configuration = this.getConfiguration()\n    const migrationDirectories = [`${configuration.getDirectory()}/src/database/migrations`]\n\n    for (const velociousPackage of configuration.getPackages()) {\n      migrationDirectories.push(velociousPackage.getMigrationsPath())\n    }\n\n    /** @type {Array<import(\"./base.js\").MigrationObjectType>} */\n    const files = []\n\n    for (const migrationsPath of migrationDirectories) {\n      await this._collectMigrationsFromDirectory(migrationsPath, files)\n    }\n\n    this._ensureNoMigrationTimestampCollisions(files)\n\n    return files.sort((migration1, migration2) => migration1.date - migration2.date)\n  }\n\n  /**\n   * Collects migration files from one directory into `files`, preserving each\n   * file's real absolute path (so app and package migrations keep their own\n   * source location). A missing directory is skipped.\n   * @param {string} migrationsPath - Directory to scan.\n   * @param {Array<import(\"./base.js\").MigrationObjectType>} files - Accumulator to push into.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _collectMigrationsFromDirectory(migrationsPath, files) {\n    const glob = await fs.glob(`${migrationsPath}/**/*.js`)\n\n    try {\n      for await (const fullPath of glob) {\n        const file = await path.basename(fullPath)\n        const match = file.match(/^(\\d{14})-(.+)\\.js$/)\n\n        if (!match) continue\n\n        const date = parseInt(match[1])\n        const migrationName = match[2]\n        const migrationClassName = inflection.camelize(migrationName.replaceAll(\"-\", \"_\"))\n\n        files.push({file, fullPath, date, migrationClassName})\n      }\n    } catch (error) {\n      if (/** @type {Error & {code?: string}} */ (error)?.code !== \"ENOENT\") {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Throws if two migrations from different files share the same 14-digit\n   * timestamp. The `schema_migrations` ledger keys on the timestamp, so a silent\n   * collision (e.g. between the app and a package, or two packages) would leave\n   * the second migration un-run — a data bug. Fail loudly instead.\n   * @param {Array<import(\"./base.js\").MigrationObjectType>} files - Collected migrations.\n   * @returns {void} - No return value.\n   */\n  _ensureNoMigrationTimestampCollisions(files) {\n    /** @type {Map<number, string>} */\n    const pathsByDate = new Map()\n\n    for (const migration of files) {\n      if (!migration.fullPath) continue\n\n      const existing = pathsByDate.get(migration.date)\n\n      if (existing && existing !== migration.fullPath) {\n        throw new Error(`Two migrations share the timestamp ${migration.date}: ${existing} and ${migration.fullPath}. Migration timestamps must be unique across the app and all packages.`)\n      }\n\n      pathsByDate.set(migration.date, migration.fullPath)\n    }\n  }\n\n  /**\n   * Runs import application routes.\n   * @returns {Promise<import(\"../routes/index.js\").default>} - Resolves with the import application routes.\n   */\n  async importApplicationRoutes() {\n    const routesImport = await import(toImportSpecifier(`${this.getConfiguration().getDirectory()}/src/config/routes.js`))\n\n    return routesImport.default\n  }\n\n  /**\n   * Runs get velocious path.\n   * @returns {Promise<string>} - Resolves with the velocious path.\n   */\n  async getVelociousPath() {\n    if (!this._velociousPath) {\n      const __filename = fileURLToPath(import.meta.url)\n      const __dirname = dirname(__filename)\n\n      this._velociousPath = await fs.realpath(`${__dirname}/../..`)\n    }\n\n    return this._velociousPath\n  }\n\n  /**\n   * Runs import test files.\n   * @param {string[]} testFiles - Test files.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async importTestFiles(testFiles) {\n    for (const testFile of testFiles) {\n      await import(toImportSpecifier(testFile))\n    }\n  }\n\n  /**\n   * Runs get default log directory.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @returns {string} - The default log directory.\n   */\n  getDefaultLogDirectory({configuration}) {\n    return path.join(configuration.getDirectory(), \"log\")\n  }\n\n  /**\n   * Runs get log file path.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string | undefined} args.directory - Directory path.\n   * @param {string} args.environment - Environment.\n   * @returns {string | undefined} - The log file path.\n   */\n  getLogFilePath({configuration, directory, environment}) {\n    const actualDirectory = directory || configuration?.getDirectory?.()\n\n    if (!actualDirectory) return undefined\n\n    return path.join(actualDirectory, `${environment}.log`)\n  }\n\n  /**\n   * Runs write log to file.\n   * @param {object} args - Options object.\n   * @param {string} args.filePath - File path.\n   * @param {string} args.message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async writeLogToFile({filePath, message}) {\n    await fs.mkdir(path.dirname(filePath), {recursive: true})\n    await fs.appendFile(filePath, `${message}\\n`, \"utf8\")\n  }\n\n  async importTestingConfigPath() {\n    const testingConfigPath = this.getConfiguration().getTesting()\n\n    if (!testingConfigPath) return\n\n    const testingImport = await import(toImportSpecifier(testingConfigPath))\n    const testingDefault = testingImport.default\n\n    if (!testingDefault) throw new Error(\"Testing config must export a default function\")\n    if (typeof testingDefault !== \"function\") throw new Error(\"Testing config default export isn't a function\")\n\n    const result = await testingDefault()\n\n    if (typeof result === \"function\") {\n      await result()\n    }\n  }\n\n  /**\n   * Runs require migration.\n   * @param {string} filePath - File path.\n   * @returns {Promise<import(\"../database/migration/index.js\").default>} - Resolves with the require migration.\n   */\n  async requireMigration(filePath) {\n    const migrationImport = await import(toImportSpecifier(filePath))\n    const migrationImportDefault = migrationImport.default\n\n    if (!migrationImportDefault) throw new Error(\"Migration file must export a default migration class\")\n    if (typeof migrationImportDefault !== \"function\") throw new Error(\"Migration default export isn't a function (should be a class which is a function in JS)\")\n\n    return migrationImportDefault\n  }\n\n  async getBasePath() {\n    const __filename = fileURLToPath(import.meta.url)\n    const basePath = await fs.realpath(`${dirname(__filename)}/../..`)\n\n    return basePath\n  }\n\n  /**\n   * Ensures velocious' background-jobs schema exists on its configured database\n   * as part of `db:migrate`, so the framework's own tables (background_jobs +\n   * background_job_concurrency, execution_mode etc.) are created deterministically\n   * alongside app migrations and captured in the dumped structure SQL — rather than\n   * only appearing once a runtime store boots. Reuses the store's idempotent\n   * `_ensureSchema`, so it's safe to re-run against DBs that already have it.\n   * @param {object} args - Options object.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} args.dbs - Dbs being migrated.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async ensureFrameworkSchema({dbs}) {\n    // Migration passes its already checked-out DB into the adapter hook. Do not\n    // run runtime readiness here: SQL readiness would open a nested checkout and\n    // can deadlock a single-connection migration pool.\n    const adapter = this.getConfiguration().getBackgroundJobsAdapter()\n\n    await adapter.ensureFrameworkSchema({dbs})\n  }\n\n  /**\n   * Runs after migrations.\n   * @param {object} args - Options object.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} args.dbs - Dbs.\n   * @param {\"migration\" | \"schemaDump\"} [args.reason] - Why the structure write is being triggered.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async afterMigrations({dbs, reason = \"migration\"}) {\n    const configuration = this.getConfiguration()\n\n    if (!configuration.shouldWriteStructureSql({reason})) return\n\n    const dbDir = path.join(configuration.getDirectory(), \"db\")\n    const structureSqlByIdentifier = await this._structureSqlByIdentifier({dbs})\n\n    await fs.mkdir(dbDir, {recursive: true})\n\n    for (const identifier of Object.keys(structureSqlByIdentifier)) {\n      const structureSql = structureSqlByIdentifier[identifier]\n\n      if (!structureSql) continue\n\n      const filePath = path.join(dbDir, `structure-${identifier}.sql`)\n\n      await fs.writeFile(filePath, structureSql)\n    }\n  }\n\n  /**\n   * Runs structure sql by identifier.\n   * @param {object} args - Options object.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} args.dbs - Dbs.\n   * @returns {Promise<Record<string, string>>} - Resolves with SQL string.\n   */\n  async _structureSqlByIdentifier({dbs}) {\n    const sqlByIdentifier = /** @type {Record<string, string>} */ ({})\n\n    for (const identifier of Object.keys(dbs)) {\n      const db = dbs[identifier]\n\n      if (typeof db.structureSql !== \"function\") continue\n\n      const structureSql = await db.structureSql()\n\n      if (structureSql) {\n        const migrationInserts = await this._schemaMigrationsInsertSql({db})\n\n        sqlByIdentifier[identifier] = structureSql + migrationInserts\n      }\n    }\n\n    return sqlByIdentifier\n  }\n\n  /**\n   * Generates INSERT statements for every row in `schema_migrations` so the\n   * structure snapshot carries the migration ledger along with the DDL.  Without\n   * these rows a fresh DB loaded from the snapshot will re-run every migration,\n   * which fails when the snapshot already contains the post-migration schema.\n   * @param {object} args - Options object.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @returns {Promise<string>} - INSERT statements (empty string when none).\n   */\n  async _schemaMigrationsInsertSql({db}) {\n    const {default: MigrationsLedger} = await import(\"../database/migrations-ledger.js\")\n\n    if (!await MigrationsLedger.tableExists(db)) return \"\"\n\n    const versions = await MigrationsLedger.appliedVersions(db)\n\n    if (versions.length == 0) return \"\"\n\n    return versions.map((version) => `INSERT INTO schema_migrations (version) VALUES (${db.quote(version)});`).join(\"\\n\") + \"\\n\"\n  }\n\n  /**\n   * Registers frontend-model websocket channel publishers so lifecycle\n   * event hooks broadcast over the shared \"frontend-models\" channel.\n   * This is only implemented by the Node handler because the required\n   * modules (`frontend-model-controller`, `routes/resolver`) pull in\n   * server-only Node APIs that break browser bundlers.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeFrontendModelWebsocketPublishers(configuration) {\n    // Discover each backend project's resources before registering publishers. The publishers are\n    // derived from `backendProject.frontendModels`, which `autoDiscoverResources` populates. Without\n    // this, registration runs against an empty/partial resource set (only built-ins), so apps that\n    // resolve resources through an `abilityResolver` rather than a static ability-resource list never\n    // register lifecycle publishers and their realtime frontend-model updates silently stop. The\n    // lifecycle hooks are deduped per model class via a process-global set, so a later, fully\n    // discovered pass cannot retroactively add the missing publishers. `autoDiscoverResources` is\n    // idempotent (it skips backend projects whose `frontendModels` are already set).\n    await this.autoDiscoverResources(configuration)\n\n    const {ensureFrontendModelWebsocketPublishersRegistered} = await import(\"../frontend-models/websocket-publishers.js\")\n\n    await ensureFrontendModelWebsocketPublishersRegistered(configuration)\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/environment-handlers/node.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport \"../database/annotations-async-hooks.js\"\nimport Base from \"./base.js\"\nimport BackgroundJobsClient from \"../background-jobs/client.js\"\nimport SqlBackgroundJobsAdapter from \"../background-jobs/sql-adapter.js\"\nimport CliCommandsDestroyMigration from \"./node/cli/commands/destroy/migration.js\"\nimport CliCommandsInit from \"./node/cli/commands/init.js\"\nimport CliCommandsGenerateBaseModels from \"./node/cli/commands/generate/base-models.js\"\nimport CliCommandsGenerateFrontendModels from \"./node/cli/commands/generate/frontend-models.js\"\nimport CliCommandsGenerateMigration from \"./node/cli/commands/generate/migration.js\"\nimport CliCommandsGenerateModel from \"./node/cli/commands/generate/model.js\"\nimport CliCommandsLintRelationships from \"./node/cli/commands/lint/relationships.js\"\nimport CliCommandsRoutes from \"./node/cli/commands/routes.js\"\nimport CliCommandsServer from \"./node/cli/commands/server.js\"\nimport CliCommandsTest from \"./node/cli/commands/test.js\"\nimport CliCommandsTestTimingManifestMerge from \"./node/cli/commands/test/timing-manifest/merge.js\"\nimport CliCommandsBackgroundJobsMain from \"./node/cli/commands/background-jobs-main.js\"\nimport CliCommandsBackgroundJobsWorker from \"./node/cli/commands/background-jobs-worker.js\"\nimport CliCommandsBackgroundJobsRunner from \"./node/cli/commands/background-jobs-runner.js\"\nimport CliCommandsBeacon from \"./node/cli/commands/beacon.js\"\nimport CliCommandsConsole from \"./node/cli/commands/console.js\"\nimport CliCommandsDbSchemaDump from \"./node/cli/commands/db/schema/dump.js\"\nimport CliCommandsDbSchemaLoad from \"./node/cli/commands/db/schema/load.js\"\nimport CliCommandsDbSeed from \"./node/cli/commands/db/seed.js\"\nimport CliCommandsRunner from \"./node/cli/commands/runner.js\"\nimport CliCommandsRunScript from \"./node/cli/commands/run-script.js\"\nimport frontendModelCommandRouteHook from \"../routes/hooks/frontend-model-command-route-hook.js\"\nimport {FRAMEWORK_SOURCE_DIRECTORY} from \"../utils/backtrace-cleaner-node.js\"\nimport {dirname} from \"path\"\nimport {fileURLToPath} from \"url\"\nimport fs from \"fs/promises\"\nimport * as inflection from \"inflection\"\nimport path from \"path\"\nimport {AsyncLocalStorage as NodeAsyncLocalStorage} from \"node:async_hooks\"\nimport {timingSafeEqual} from \"node:crypto\"\nimport requireContext from \"require-context\"\nimport AsyncTrackedMultiConnectionPool from \"../database/pool/async-tracked-multi-connection.js\"\nimport InitializerFromRequireContext from \"../database/initializer-from-require-context.js\"\nimport toImportSpecifier from \"../utils/to-import-specifier.js\"\nimport {validateTimeZone} from \"../time-zone.js\"\nimport AttachmentPathSource from \"./node/attachment-path-source.js\"\nimport { automaticSharedTransactionBrokerOmits, createSharedTransactionProxyDriver, sharedTransactionBrokerConfig } from \"../testing/shared-transaction-proxy-driver.js\"\n\n/**\n * Defines this typedef.\n * @typedef {{ability?: import(\"../authorization/ability.js\").default, offsetMinutes: number, requestTiming?: import(\"../http-server/client/request-timing.js\").default, tenant?: ReturnType<typeof JSON.parse>, testProfileContext?: import(\"../testing/test-profiler.js\").TestProfileAsyncContext, timeZone?: string}} TimezoneStore */\n\n/**\n * Runs path within allowed prefixes.\n * @param {string} filePath - Input file path.\n * @param {string[]} allowedPathPrefixes - Allowed path prefixes.\n * @returns {boolean} - Whether input path is inside an allowed prefix.\n */\nfunction pathWithinAllowedPrefixes(filePath, allowedPathPrefixes) {\n  const resolvedPath = path.resolve(filePath)\n\n  return allowedPathPrefixes.some((allowedPrefix) => {\n    const resolvedPrefix = path.resolve(allowedPrefix)\n    const relativePath = path.relative(resolvedPrefix, resolvedPath)\n\n    if (!relativePath) return true\n    if (relativePath.startsWith(\"..\")) return false\n    if (path.isAbsolute(relativePath)) return false\n\n    return true\n  })\n}\n\nexport default class VelociousEnvironmentHandlerNode extends Base{\n  /**\n   * Creates the built-in SQL persistence adapter.\n   * @param {{configuration: import(\"../configuration.js\").default}} args - Adapter options.\n   * @returns {SqlBackgroundJobsAdapter} - SQL adapter.\n   */\n  createBackgroundJobsAdapter({configuration}) {\n    return new SqlBackgroundJobsAdapter({configuration})\n  }\n\n  /**\n   * Preserves the Node TCP producer and main-process wake-up path. The main\n   * owns the configured persistence adapter; Node producers never bypass it.\n   * @param {{configuration: import(\"../configuration.js\").default}} args - Client options.\n   * @returns {import(\"../background-jobs/types.js\").BackgroundJobsProducer} - Producer client.\n   */\n  backgroundJobsClient({configuration}) {\n    return new BackgroundJobsClient({configuration})\n  }\n\n  /**\n   * Gives concurrent shared-transaction child jobs independent proxy sessions.\n   * A configured single-connection pool shares mutable transaction state between\n   * async jobs, while the broker requires one root-transaction lease per socket.\n   * @param {{configuredPoolType: typeof import(\"../database/pool/base.js\").default, databaseIdentifier: string}} args - Configured pool and logical database identifier.\n   * @returns {typeof import(\"../database/pool/base.js\").default} - Pool type for this context.\n   */\n  resolveTestSharedTransactionPoolType({configuredPoolType, databaseIdentifier}) {\n    const databaseConfiguration = this.getConfiguration().getDatabaseIdentifier(databaseIdentifier)\n    if (databaseConfiguration.tenantOnly && automaticSharedTransactionBrokerOmits(databaseIdentifier)) return configuredPoolType\n    if (!sharedTransactionBrokerConfig(databaseIdentifier)) return configuredPoolType\n\n    return AsyncTrackedMultiConnectionPool\n  }\n\n  /**\n   * Creates a test-only child proxy when TestRunner supplied an active broker.\n   * @param {{DriverClass: typeof import(\"../database/drivers/base.js\").default, config: import(\"../configuration-types.js\").DatabaseConfigurationType, configuration: import(\"../configuration.js\").default, databaseIdentifier: string, reuseKey?: string}} args - Connection details.\n   * @returns {Promise<import(\"../database/drivers/base.js\").default | undefined>} - Optional proxy.\n   */\n  async createTestSharedTransactionConnection({DriverClass, config, configuration, databaseIdentifier, reuseKey}) {\n    if (config.tenantOnly && automaticSharedTransactionBrokerOmits(databaseIdentifier)) return undefined\n    const brokerConfig = sharedTransactionBrokerConfig(databaseIdentifier)\n    if (!brokerConfig) return undefined\n    return createSharedTransactionProxyDriver(DriverClass, config, configuration, databaseIdentifier, {\n      ...brokerConfig,\n      reuseKey: brokerConfig.allowDynamicIdentities ? reuseKey : undefined\n    })\n  }\n\n  /**\n   * Timezone async local storage.\n   * @type {import(\"node:async_hooks\").AsyncLocalStorage<TimezoneStore> | undefined} */\n  _timezoneAsyncLocalStorage = NodeAsyncLocalStorage ? new NodeAsyncLocalStorage() : undefined\n\n  /**\n   * Shared-transaction coordinator ownership by physical connection.\n   * @type {import(\"node:async_hooks\").AsyncLocalStorage<Map<object, symbol>> | undefined}\n   */\n  _sharedTransactionCoordinatorAsyncLocalStorage = NodeAsyncLocalStorage ? new NodeAsyncLocalStorage() : undefined\n\n  /**\n   * Gets the active shared-transaction coordinator owner for a connection.\n   * @param {object} connection - Parent physical connection.\n   * @returns {symbol | undefined} - Active coordinator owner.\n   */\n  getSharedTransactionCoordinatorOwner(connection) {\n    return this._sharedTransactionCoordinatorAsyncLocalStorage?.getStore()?.get(connection)\n  }\n\n  /**\n   * Runs work as the current shared-transaction coordinator owner.\n   * @template T\n   * @param {object} connection - Parent physical connection.\n   * @param {symbol} owner - Coordinator owner.\n   * @param {() => T} callback - Owned work.\n   * @returns {T} - Callback result.\n   */\n  runWithSharedTransactionCoordinatorOwner(connection, owner, callback) {\n    if (!this._sharedTransactionCoordinatorAsyncLocalStorage) return callback()\n\n    const owners = new Map(this._sharedTransactionCoordinatorAsyncLocalStorage.getStore())\n\n    owners.set(connection, owner)\n    return this._sharedTransactionCoordinatorAsyncLocalStorage.run(owners, callback)\n  }\n\n  /**\n   * Runs work without inherited shared-transaction coordinator ownership.\n   * @template T\n   * @param {() => T} callback - Detached work.\n   * @returns {T} - Callback result.\n   */\n  runWithoutSharedTransactionCoordinatorOwners(callback) {\n    if (!this._sharedTransactionCoordinatorAsyncLocalStorage) return callback()\n\n    return this._sharedTransactionCoordinatorAsyncLocalStorage.run(new Map(), callback)\n  }\n\n  /**\n   * Runs work with async-safe test profile attribution.\n   * @template T\n   * @param {import(\"../testing/test-profiler.js\").TestProfileAsyncContext | undefined} context - Captured profile context, or an explicit absence of attribution.\n   * @param {() => T} callback - Profiled work.\n   * @returns {T} - Callback result.\n   */\n  runWithTestProfileContext(context, callback) {\n    if (!this._timezoneAsyncLocalStorage) return callback()\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: context,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Gets the current async-safe test profile attribution context.\n   * @returns {import(\"../testing/test-profiler.js\").TestProfileAsyncContext | undefined} - Current context.\n   */\n  getCurrentTestProfileContext() {\n    return this._timezoneAsyncLocalStorage?.getStore()?.testProfileContext\n  }\n\n  /**\n   * Find commands result.\n   * @type {import(\"./base.js\").CommandFileObjectType[] | undefined} */\n  _findCommandsResult = undefined\n\n  /**\n   * Runs debug endpoint token matches.\n   * @param {string} providedToken - Token from the request.\n   * @param {string} expectedToken - Configured token.\n   * @returns {boolean} - Whether both tokens match.\n   */\n  debugEndpointTokenMatches(providedToken, expectedToken) {\n    const provided = Buffer.from(providedToken)\n    const expected = Buffer.from(expectedToken)\n\n    return provided.length === expected.length && timingSafeEqual(provided, expected)\n  }\n\n  /**\n   * Runs get framework source directory.\n   * @returns {string | undefined} - Velocious source directory used to filter framework stack frames.\n   */\n  getFrameworkSourceDirectory() {\n    return FRAMEWORK_SOURCE_DIRECTORY\n  }\n\n  /**\n   * Auto-discovers resource classes from src/resources/ in each backend project.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {Promise<void>}\n   */\n  async autoDiscoverResources(configuration) {\n    const {frontendModelResourceDefinitionIsClass} = await import(\"../frontend-models/resource-definition.js\")\n    const {default: AuthorizationBaseResource} = await import(\"../authorization/base-resource.js\")\n    const backendProjects = configuration.getBackendProjects()\n\n    for (const backendProject of backendProjects) {\n      if (backendProject.abilityResources) continue\n\n      const resourcesDir = backendProject.resourcesPath || path.join(backendProject.path, \"src\", \"resources\")\n      let files\n\n      try {\n        files = await fs.readdir(resourcesDir)\n      } catch {\n        continue\n      }\n\n      /**\n       * Discovered frontend-model resources keyed by model name.\n       * @type {Record<string, ReturnType<typeof JSON.parse>>} */\n      const discovered = {}\n      /**\n       * Every discovered ability resource class (frontend-model and authorization).\n       * @type {Array<ReturnType<typeof JSON.parse>>} */\n      const abilityResourceClasses = []\n\n      for (const file of files) {\n        if (!file.endsWith(\".js\") && !file.endsWith(\".mjs\")) continue\n        if (file.startsWith(\"frontend-model-resources\")) continue\n\n        const filePath = path.join(resourcesDir, file)\n        const imported = await import(filePath)\n        const ResourceClass = imported.default\n\n        // Any authorization resource (frontend-model resources also extend it) that\n        // declares a `ModelClass`; skip abstract/common base resources without one.\n        const isAbilityResource = typeof ResourceClass === \"function\"\n          && (ResourceClass === AuthorizationBaseResource || ResourceClass.prototype instanceof AuthorizationBaseResource)\n\n        if (!isAbilityResource || !ResourceClass.ModelClass) continue\n\n        abilityResourceClasses.push(ResourceClass)\n\n        // Only frontend-model resources drive routing/generation/publisher discovery.\n        if (!frontendModelResourceDefinitionIsClass(ResourceClass)) continue\n\n        const baseName = file.replace(/\\.(js|mjs)$/, \"\")\n        const modelName = baseName.replace(/-resource$/, \"\")\n          .split(\"-\")\n          .map((/** @type {string} */ part) => part.charAt(0).toUpperCase() + part.slice(1))\n          .join(\"\")\n\n        discovered[modelName] = ResourceClass\n      }\n\n      if (!backendProject.frontendModels && Object.keys(discovered).length > 0) {\n        backendProject.frontendModels = discovered\n      }\n\n      if (abilityResourceClasses.length > 0) {\n        backendProject.abilityResources = abilityResourceClasses\n      }\n    }\n  }\n\n  /**\n   * Loads models contributed by registered packages into the model registry,\n   * after the app's own `initializeModels` hook. A package whose models directory\n   * is absent is skipped; a package model whose name collides with an\n   * already-registered different class throws. Node-only (uses the filesystem), so\n   * it lives here rather than in the browser-bundled Configuration.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializePackageModels(configuration) {\n    for (const velociousPackage of configuration.getPackages()) {\n      const modelsPath = velociousPackage.getModelsPath()\n\n      try {\n        await fs.access(modelsPath)\n      } catch {\n        continue\n      }\n\n      const packageRequireContext = /** @type {import(\"../database/initializer-from-require-context.js\").ModelClassRequireContextType} */ (requireContext(modelsPath, true, /^(.+)\\.js$/))\n      const modelClasses = configuration.getModelClasses()\n\n      for (const fileName of packageRequireContext.keys()) {\n        const modelClass = packageRequireContext(fileName)?.default\n        const existing = modelClass && modelClasses[modelClass.getModelName()]\n\n        if (existing && existing !== modelClass) {\n          throw new Error(`Package \"${velociousPackage.getName()}\" model \"${modelClass.getModelName()}\" collides with an already-registered model.`)\n        }\n      }\n\n      await configuration.ensureConnections({name: `Initialize ${velociousPackage.getName()} package models`}, async () => {\n        await new InitializerFromRequireContext({requireContext: packageRequireContext}).initialize({configuration})\n      })\n    }\n  }\n\n  /**\n   * Runs set configuration.\n   * @param {import(\"../configuration.js\").default} newConfiguration - New configuration.\n   * @returns {void} - No return value.\n   */\n  setConfiguration(newConfiguration) {\n    super.setConfiguration(newConfiguration)\n\n    if (!newConfiguration.getRouteResolverHooks().includes(frontendModelCommandRouteHook)) {\n      newConfiguration.addRouteResolverHook(frontendModelCommandRouteHook)\n    }\n  }\n\n  /**\n   * Runs read attachment input file.\n   * @param {string} filePath - File path.\n   * @returns {Promise<Buffer>} - File bytes.\n   */\n  async readAttachmentInputFile(filePath) {\n    return await fs.readFile(filePath)\n  }\n\n  /**\n   * Runs resolve attachment input path.\n   * @param {object} args - Args.\n   * @param {string[]} args.allowedPathPrefixes - Allowed path prefixes.\n   * @param {string} args.inputPath - Input path.\n   * @returns {Promise<AttachmentPathSource>} - Opened regular-file path source.\n   */\n  async resolveAttachmentInputPath({allowedPathPrefixes, inputPath}) {\n    const filePath = path.resolve(inputPath)\n    const prefixes = Array.isArray(allowedPathPrefixes)\n      ? allowedPathPrefixes.filter((entry) => typeof entry === \"string\" && entry.length > 0)\n      : []\n\n    if (prefixes.length > 0 && !pathWithinAllowedPrefixes(filePath, prefixes)) {\n      throw new Error(\"Attachment path is outside allowed directories\")\n    }\n\n    const fileHandle = await fs.open(filePath, \"r\")\n\n    try {\n      const fileStats = await fileHandle.stat()\n\n      if (!fileStats.isFile()) {\n        throw new Error(\"Attachment path must reference a regular file\")\n      }\n\n      return new AttachmentPathSource({\n        byteSize: fileStats.size,\n        fileHandle,\n        filePath\n      })\n    } catch (error) {\n      try {\n        await fileHandle.close()\n      } catch (closeError) {\n        throw new AggregateError(\n          [error, closeError],\n          `Attachment path validation and source close both failed for ${filePath}`,\n          {cause: closeError}\n        )\n      }\n\n      throw error\n    }\n  }\n\n  /**\n   * Runs find commands.\n   * @returns {Promise<Array<import(\"./base.js\").CommandFileObjectType>>} - Resolves with the commands.\n   */\n  async findCommands() {\n    this._findCommandsResult ||= await this._actualFindCommands()\n\n    if (!this._findCommandsResult) throw new Error(\"Could not get commands\")\n\n    return this._findCommandsResult\n  }\n\n  /**\n   * Runs run with timezone offset.\n   * @param {number} offsetMinutes - Offset in minutes (Date#getTimezoneOffset).\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback to run.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Result of the callback.\n   */\n  async runWithTimezoneOffset(offsetMinutes, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await callback()\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes,\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs run with timezone.\n   * @param {string} timeZone - IANA timezone identifier.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback to run.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Result of the callback.\n   */\n  async runWithTimezone(timeZone, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithTimezone(timeZone, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: validateTimeZone(timeZone, \"timeZone\")\n    }, callback)\n  }\n\n  /**\n   * Runs set timezone offset.\n   * @param {number} offsetMinutes - Offset in minutes (Date#getTimezoneOffset).\n   * @returns {void} - No return value.\n   */\n  setTimezoneOffset(offsetMinutes) {\n    if (!this._timezoneAsyncLocalStorage) return\n\n    const store = this._timezoneAsyncLocalStorage.getStore()\n\n    if (store) {\n      store.offsetMinutes = offsetMinutes\n    } else {\n      const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability: existingStore?.ability,\n        offsetMinutes,\n        requestTiming: existingStore?.requestTiming,\n        tenant: existingStore?.tenant,\n        testProfileContext: existingStore?.testProfileContext,\n        timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n      })\n    }\n  }\n\n  /**\n   * Runs set timezone.\n   * @param {string} timeZone - IANA timezone identifier.\n   * @returns {void} - No return value.\n   */\n  setTimezone(timeZone) {\n    if (!this._timezoneAsyncLocalStorage) {\n      super.setTimezone(timeZone)\n      return\n    }\n\n    const normalizedTimeZone = validateTimeZone(timeZone, \"timeZone\")\n    const store = this._timezoneAsyncLocalStorage.getStore()\n\n    if (store) {\n      store.timeZone = normalizedTimeZone\n    } else {\n      const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability: existingStore?.ability,\n        offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n        requestTiming: existingStore?.requestTiming,\n        tenant: existingStore?.tenant,\n        testProfileContext: existingStore?.testProfileContext,\n        timeZone: normalizedTimeZone\n      })\n    }\n  }\n\n  /**\n   * Runs get timezone offset minutes.\n   * @param {import(\"../configuration.js\").default | undefined} configuration - Configuration instance.\n   * @returns {number} - Offset in minutes.\n   */\n  getTimezoneOffsetMinutes(configuration) {\n    if (this._timezoneAsyncLocalStorage) {\n      const store = this._timezoneAsyncLocalStorage.getStore()\n\n      if (store && typeof store.offsetMinutes === \"number\") {\n        return store.offsetMinutes\n      }\n    }\n\n    return super.getTimezoneOffsetMinutes(configuration)\n  }\n\n  /**\n   * Runs get timezone.\n   * @param {import(\"../configuration.js\").default | undefined} configuration - Configuration instance.\n   * @returns {string | undefined} - Timezone identifier.\n   */\n  getTimeZone(configuration) {\n    if (this._timezoneAsyncLocalStorage) {\n      const store = this._timezoneAsyncLocalStorage.getStore()\n\n      if (store && typeof store.timeZone === \"string\") {\n        return store.timeZone\n      }\n    }\n\n    return super.getTimeZone(configuration)\n  }\n\n  /**\n   * Runs run with ability.\n   * @param {import(\"../authorization/ability.js\").default | undefined} ability - Ability to set for callback scope.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Callback result.\n   */\n  async runWithAbility(ability, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithAbility(ability, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs set current ability.\n   * @param {import(\"../authorization/ability.js\").default | undefined} ability - Ability to set.\n   * @returns {void} - No return value.\n   */\n  setCurrentAbility(ability) {\n    if (!this._timezoneAsyncLocalStorage) {\n      super.setCurrentAbility(ability)\n      return\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    if (existingStore) {\n      existingStore.ability = ability\n    } else {\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability,\n        offsetMinutes: this.getTimezoneOffsetMinutes(this.getConfiguration()),\n        requestTiming: undefined,\n        tenant: undefined,\n        testProfileContext: undefined,\n        timeZone: this.getTimeZone(this.getConfiguration())\n      })\n    }\n  }\n\n  /**\n   * Runs get current ability.\n   * @returns {import(\"../authorization/ability.js\").default | undefined} - Current ability.\n   */\n  getCurrentAbility() {\n    if (!this._timezoneAsyncLocalStorage) {\n      return super.getCurrentAbility()\n    }\n\n    return this._timezoneAsyncLocalStorage.getStore()?.ability\n  }\n\n  /**\n   * Runs run with request timing.\n   * @param {import(\"../http-server/client/request-timing.js\").default | undefined} requestTiming - Request timing collector.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Callback result.\n   */\n  async runWithRequestTiming(requestTiming, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithRequestTiming(requestTiming, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming,\n      tenant: existingStore?.tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs get current request timing.\n   * @returns {import(\"../http-server/client/request-timing.js\").default | undefined} - Current request timing collector.\n   */\n  getCurrentRequestTiming() {\n    if (!this._timezoneAsyncLocalStorage) {\n      return super.getCurrentRequestTiming()\n    }\n\n    return this._timezoneAsyncLocalStorage.getStore()?.requestTiming\n  }\n\n  /**\n   * Runs run with tenant.\n   * @param {ReturnType<typeof JSON.parse>} tenant - Tenant to set for callback scope.\n   * @param {() => Promise<ReturnType<typeof JSON.parse>>} callback - Callback.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Callback result.\n   */\n  async runWithTenant(tenant, callback) {\n    if (!this._timezoneAsyncLocalStorage) {\n      return await super.runWithTenant(tenant, callback)\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    return await this._timezoneAsyncLocalStorage.run({\n      ability: existingStore?.ability,\n      offsetMinutes: existingStore?.offsetMinutes ?? this.getTimezoneOffsetMinutes(this.getConfiguration()),\n      requestTiming: existingStore?.requestTiming,\n      tenant,\n      testProfileContext: existingStore?.testProfileContext,\n      timeZone: existingStore?.timeZone ?? this.getTimeZone(this.getConfiguration())\n    }, callback)\n  }\n\n  /**\n   * Runs set current tenant.\n   * @param {ReturnType<typeof JSON.parse>} tenant - Tenant to set.\n   * @returns {void} - No return value.\n   */\n  setCurrentTenant(tenant) {\n    if (!this._timezoneAsyncLocalStorage) {\n      super.setCurrentTenant(tenant)\n      return\n    }\n\n    const existingStore = this._timezoneAsyncLocalStorage.getStore()\n\n    if (existingStore) {\n      existingStore.tenant = tenant\n    } else {\n      this._timezoneAsyncLocalStorage.enterWith({\n        ability: undefined,\n        offsetMinutes: this.getTimezoneOffsetMinutes(this.getConfiguration()),\n        requestTiming: undefined,\n        tenant,\n        testProfileContext: undefined,\n        timeZone: this.getTimeZone(this.getConfiguration())\n      })\n    }\n  }\n\n  /**\n   * Runs get current tenant.\n   * @returns {ReturnType<typeof JSON.parse>} - Current tenant.\n   */\n  getCurrentTenant() {\n    if (!this._timezoneAsyncLocalStorage) {\n      return super.getCurrentTenant()\n    }\n\n    return this._timezoneAsyncLocalStorage.getStore()?.tenant\n  }\n\n  /**\n   * Runs actual find commands.\n   * @returns {Promise<Array<import(\"./base.js\").CommandFileObjectType>>} - Resolves with discovered command files.\n   */\n  async _actualFindCommands() {\n    const basePath = await this.getBasePath()\n    const commandFiles = fs.glob(`${basePath}/src/cli/commands/**/*.js`)\n    const commands = []\n\n    for await (const aFilePath of commandFiles) {\n      const commandName = this.commandNameFromFilePath(aFilePath)\n\n      commands.push({name: commandName, file: aFilePath})\n    }\n\n    return commands\n  }\n\n  /**\n   * Runs command name from file path.\n   * @param {string} filePath - Full command file path.\n   * @returns {string} - Parsed command name.\n   */\n  commandNameFromFilePath(filePath) {\n    const aFilePathParts = filePath.split(/[\\\\/]/)\n    const commandPathLocation = aFilePathParts.indexOf(\"commands\")\n\n    if (commandPathLocation === -1) {\n      throw new Error(`Could not parse command file path: ${filePath}`)\n    }\n\n    const commandParts = aFilePathParts.slice(commandPathLocation + 1)\n    const lastPart = commandParts[commandParts.length - 1]\n    let name, paths\n\n    if (lastPart == \"index.js\") {\n      name = commandParts[commandParts.length - 2]\n      paths = commandParts.slice(0, -2)\n    } else {\n      name = lastPart.replace(\".js\", \"\")\n      paths = commandParts.slice(0, -1)\n    }\n\n    return `${paths.join(\":\")}${paths.length > 0 ? \":\" : \"\"}${name}`\n  }\n\n  /**\n   * Runs cli commands init.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsInit(command) {\n    return await this.forwardCommand(command, CliCommandsInit)\n  }\n\n  /**\n   * Runs cli commands migration generate.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsMigrationGenerate(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateMigration)\n  }\n\n  /**\n   * Runs cli commands migration destroy.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsMigrationDestroy(command) {\n    return await this.forwardCommand(command, CliCommandsDestroyMigration)\n  }\n\n  /**\n   * Runs cli commands generate base models.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsGenerateBaseModels(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateBaseModels)\n  }\n\n  /**\n   * Runs cli commands generate frontend models.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsGenerateFrontendModels(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateFrontendModels)\n  }\n\n  /**\n   * Runs cli commands generate model.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsGenerateModel(command) {\n    return await this.forwardCommand(command, CliCommandsGenerateModel)\n  }\n\n  /**\n   * Runs cli commands lint relationships.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsLintRelationships(command) {\n    return await this.forwardCommand(command, CliCommandsLintRelationships)\n  }\n\n  /**\n   * Runs cli commands routes.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsRoutes(command) {\n    return await this.forwardCommand(command, CliCommandsRoutes)\n  }\n\n  /**\n   * Runs cli commands console.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsConsole(command) {\n    return await this.forwardCommand(command, CliCommandsConsole)\n  }\n\n  /**\n   * Runs cli commands server.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsServer(command) {\n    return await this.forwardCommand(command, CliCommandsServer)\n  }\n\n  /**\n   * Runs cli commands test.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsTest(command) {\n    return await this.forwardCommand(command, CliCommandsTest)\n  }\n\n  /**\n   * Runs cli commands test timing manifest merge.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsTestTimingManifestMerge(command) {\n    return await this.forwardCommand(command, CliCommandsTestTimingManifestMerge)\n  }\n\n  /**\n   * Runs cli commands background jobs main.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBackgroundJobsMain(command) {\n    return await this.forwardCommand(command, CliCommandsBackgroundJobsMain)\n  }\n\n  /**\n   * Runs cli commands background jobs worker.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBackgroundJobsWorker(command) {\n    return await this.forwardCommand(command, CliCommandsBackgroundJobsWorker)\n  }\n\n  /**\n   * Runs cli commands background jobs runner.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBackgroundJobsRunner(command) {\n    return await this.forwardCommand(command, CliCommandsBackgroundJobsRunner)\n  }\n\n  /**\n   * Runs cli commands beacon.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsBeacon(command) {\n    return await this.forwardCommand(command, CliCommandsBeacon)\n  }\n\n  /**\n   * Runs load beacon client.\n   * @returns {Promise<typeof import(\"../beacon/client.js\").default>} - Beacon client class.\n   */\n  async loadBeaconClient() {\n    const {default: BeaconClient} = await import(\"../beacon/client.js\")\n\n    return BeaconClient\n  }\n\n  /**\n   * Runs load in process beacon client.\n   * @returns {Promise<typeof import(\"../beacon/in-process-client.js\").default>} - In-process client class.\n   */\n  async loadInProcessBeaconClient() {\n    const {default: InProcessBeaconClient} = await import(\"../beacon/in-process-client.js\")\n\n    return InProcessBeaconClient\n  }\n\n  /**\n   * Runs cli commands db schema dump.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsDbSchemaDump(command) {\n    return await this.forwardCommand(command, CliCommandsDbSchemaDump)\n  }\n\n  /**\n   * Runs cli commands db schema load.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsDbSchemaLoad(command) {\n    return await this.forwardCommand(command, CliCommandsDbSchemaLoad)\n  }\n\n  /**\n   * Runs cli commands db seed.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsDbSeed(command) {\n    return await this.forwardCommand(command, CliCommandsDbSeed)\n  }\n\n  /**\n   * Runs cli commands runner.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsRunner(command) {\n    return await this.forwardCommand(command, CliCommandsRunner)\n  }\n\n  /**\n   * Runs cli commands run script.\n   * @param {import(\"../cli/base-command.js\").default} command - Command.\n   * @returns {Promise<ReturnType<typeof JSON.parse>>} - Resolves with the command result.\n   */\n  async cliCommandsRunScript(command) {\n    return await this.forwardCommand(command, CliCommandsRunScript)\n  }\n\n  /**\n   * Runs require command.\n   * @param {object} args - Options object.\n   * @param {string[]} args.commandParts - Command parts.\n   * @returns {Promise<typeof import (\"../cli/base-command.js\").default>} - Resolves with the require command.\n   */\n  async requireCommand({commandParts}) {\n    const commands = await this.findCommands()\n    const commandName = commandParts.join(\":\")\n    const command = commands.find((aCommand) => aCommand.name === commandName)\n\n    if (!command) {\n      const possibleCommands = commands.map(aCommand => aCommand.name)\n\n      throw new Error(`Unknown command: ${commandParts.join(\":\")} which should have been one of: ${possibleCommands.sort().join(\", \")}`)\n    }\n\n    const commandClassImport = await import(toImportSpecifier(command.file))\n    const CommandClass = commandClassImport.default\n\n    return CommandClass\n  }\n\n  /**\n   * Runs find migrations.\n   * @returns {Promise<Array<import(\"./base.js\").MigrationObjectType>>} - Resolves with the migrations.\n   */\n  async findMigrations() {\n    const configuration = this.getConfiguration()\n    const migrationDirectories = [`${configuration.getDirectory()}/src/database/migrations`]\n\n    for (const velociousPackage of configuration.getPackages()) {\n      migrationDirectories.push(velociousPackage.getMigrationsPath())\n    }\n\n    /** @type {Array<import(\"./base.js\").MigrationObjectType>} */\n    const files = []\n\n    for (const migrationsPath of migrationDirectories) {\n      await this._collectMigrationsFromDirectory(migrationsPath, files)\n    }\n\n    this._ensureNoMigrationTimestampCollisions(files)\n\n    return files.sort((migration1, migration2) => migration1.date - migration2.date)\n  }\n\n  /**\n   * Collects migration files from one directory into `files`, preserving each\n   * file's real absolute path (so app and package migrations keep their own\n   * source location). A missing directory is skipped.\n   * @param {string} migrationsPath - Directory to scan.\n   * @param {Array<import(\"./base.js\").MigrationObjectType>} files - Accumulator to push into.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async _collectMigrationsFromDirectory(migrationsPath, files) {\n    const glob = await fs.glob(`${migrationsPath}/**/*.js`)\n\n    try {\n      for await (const fullPath of glob) {\n        const file = await path.basename(fullPath)\n        const match = file.match(/^(\\d{14})-(.+)\\.js$/)\n\n        if (!match) continue\n\n        const date = parseInt(match[1])\n        const migrationName = match[2]\n        const migrationClassName = inflection.camelize(migrationName.replaceAll(\"-\", \"_\"))\n\n        files.push({file, fullPath, date, migrationClassName})\n      }\n    } catch (error) {\n      if (/** @type {Error & {code?: string}} */ (error)?.code !== \"ENOENT\") {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Throws if two migrations from different files share the same 14-digit\n   * timestamp. The `schema_migrations` ledger keys on the timestamp, so a silent\n   * collision (e.g. between the app and a package, or two packages) would leave\n   * the second migration un-run — a data bug. Fail loudly instead.\n   * @param {Array<import(\"./base.js\").MigrationObjectType>} files - Collected migrations.\n   * @returns {void} - No return value.\n   */\n  _ensureNoMigrationTimestampCollisions(files) {\n    /** @type {Map<number, string>} */\n    const pathsByDate = new Map()\n\n    for (const migration of files) {\n      if (!migration.fullPath) continue\n\n      const existing = pathsByDate.get(migration.date)\n\n      if (existing && existing !== migration.fullPath) {\n        throw new Error(`Two migrations share the timestamp ${migration.date}: ${existing} and ${migration.fullPath}. Migration timestamps must be unique across the app and all packages.`)\n      }\n\n      pathsByDate.set(migration.date, migration.fullPath)\n    }\n  }\n\n  /**\n   * Runs import application routes.\n   * @returns {Promise<import(\"../routes/index.js\").default>} - Resolves with the import application routes.\n   */\n  async importApplicationRoutes() {\n    const routesImport = await import(toImportSpecifier(`${this.getConfiguration().getDirectory()}/src/config/routes.js`))\n\n    return routesImport.default\n  }\n\n  /**\n   * Runs get velocious path.\n   * @returns {Promise<string>} - Resolves with the velocious path.\n   */\n  async getVelociousPath() {\n    if (!this._velociousPath) {\n      const __filename = fileURLToPath(import.meta.url)\n      const __dirname = dirname(__filename)\n\n      this._velociousPath = await fs.realpath(`${__dirname}/../..`)\n    }\n\n    return this._velociousPath\n  }\n\n  /**\n   * Runs import test files.\n   * @param {string[]} testFiles - Test files.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async importTestFiles(testFiles) {\n    for (const testFile of testFiles) {\n      await import(toImportSpecifier(testFile))\n    }\n  }\n\n  /**\n   * Runs get default log directory.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @returns {string} - The default log directory.\n   */\n  getDefaultLogDirectory({configuration}) {\n    return path.join(configuration.getDirectory(), \"log\")\n  }\n\n  /**\n   * Runs get log file path.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {string | undefined} args.directory - Directory path.\n   * @param {string} args.environment - Environment.\n   * @returns {string | undefined} - The log file path.\n   */\n  getLogFilePath({configuration, directory, environment}) {\n    const actualDirectory = directory || configuration?.getDirectory?.()\n\n    if (!actualDirectory) return undefined\n\n    return path.join(actualDirectory, `${environment}.log`)\n  }\n\n  /**\n   * Runs write log to file.\n   * @param {object} args - Options object.\n   * @param {string} args.filePath - File path.\n   * @param {string} args.message - Message text.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async writeLogToFile({filePath, message}) {\n    await fs.mkdir(path.dirname(filePath), {recursive: true})\n    await fs.appendFile(filePath, `${message}\\n`, \"utf8\")\n  }\n\n  async importTestingConfigPath() {\n    const testingConfigPath = this.getConfiguration().getTesting()\n\n    if (!testingConfigPath) return\n\n    const testingImport = await import(toImportSpecifier(testingConfigPath))\n    const testingDefault = testingImport.default\n\n    if (!testingDefault) throw new Error(\"Testing config must export a default function\")\n    if (typeof testingDefault !== \"function\") throw new Error(\"Testing config default export isn't a function\")\n\n    const result = await testingDefault()\n\n    if (typeof result === \"function\") {\n      await result()\n    }\n  }\n\n  /**\n   * Runs require migration.\n   * @param {string} filePath - File path.\n   * @returns {Promise<import(\"../database/migration/index.js\").default>} - Resolves with the require migration.\n   */\n  async requireMigration(filePath) {\n    const migrationImport = await import(toImportSpecifier(filePath))\n    const migrationImportDefault = migrationImport.default\n\n    if (!migrationImportDefault) throw new Error(\"Migration file must export a default migration class\")\n    if (typeof migrationImportDefault !== \"function\") throw new Error(\"Migration default export isn't a function (should be a class which is a function in JS)\")\n\n    return migrationImportDefault\n  }\n\n  async getBasePath() {\n    const __filename = fileURLToPath(import.meta.url)\n    const basePath = await fs.realpath(`${dirname(__filename)}/../..`)\n\n    return basePath\n  }\n\n  /**\n   * Ensures velocious' background-jobs schema exists on its configured database\n   * as part of `db:migrate`, so the framework's own tables (background_jobs +\n   * background_job_concurrency, execution_mode etc.) are created deterministically\n   * alongside app migrations and captured in the dumped structure SQL — rather than\n   * only appearing once a runtime store boots. Reuses the store's idempotent\n   * `_ensureSchema`, so it's safe to re-run against DBs that already have it.\n   * @param {object} args - Options object.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} args.dbs - Dbs being migrated.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async ensureFrameworkSchema({dbs}) {\n    // Migration passes its already checked-out DB into the adapter hook. Do not\n    // run runtime readiness here: SQL readiness would open a nested checkout and\n    // can deadlock a single-connection migration pool.\n    const adapter = this.getConfiguration().getBackgroundJobsAdapter()\n\n    await adapter.ensureFrameworkSchema({dbs})\n  }\n\n  /**\n   * Runs after migrations.\n   * @param {object} args - Options object.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} args.dbs - Dbs.\n   * @param {\"migration\" | \"schemaDump\"} [args.reason] - Why the structure write is being triggered.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async afterMigrations({dbs, reason = \"migration\"}) {\n    const configuration = this.getConfiguration()\n\n    if (!configuration.shouldWriteStructureSql({reason})) return\n\n    const dbDir = path.join(configuration.getDirectory(), \"db\")\n    const structureSqlByIdentifier = await this._structureSqlByIdentifier({dbs})\n\n    await fs.mkdir(dbDir, {recursive: true})\n\n    for (const identifier of Object.keys(structureSqlByIdentifier)) {\n      const structureSql = structureSqlByIdentifier[identifier]\n\n      if (!structureSql) continue\n\n      const filePath = path.join(dbDir, `structure-${identifier}.sql`)\n\n      await fs.writeFile(filePath, structureSql)\n    }\n  }\n\n  /**\n   * Runs structure sql by identifier.\n   * @param {object} args - Options object.\n   * @param {Record<string, import(\"../database/drivers/base.js\").default>} args.dbs - Dbs.\n   * @returns {Promise<Record<string, string>>} - Resolves with SQL string.\n   */\n  async _structureSqlByIdentifier({dbs}) {\n    const sqlByIdentifier = /** @type {Record<string, string>} */ ({})\n\n    for (const identifier of Object.keys(dbs)) {\n      const db = dbs[identifier]\n\n      if (typeof db.structureSql !== \"function\") continue\n\n      const structureSql = await db.structureSql()\n\n      if (structureSql) {\n        const migrationInserts = await this._schemaMigrationsInsertSql({db})\n\n        sqlByIdentifier[identifier] = structureSql + migrationInserts\n      }\n    }\n\n    return sqlByIdentifier\n  }\n\n  /**\n   * Generates INSERT statements for every row in `schema_migrations` so the\n   * structure snapshot carries the migration ledger along with the DDL.  Without\n   * these rows a fresh DB loaded from the snapshot will re-run every migration,\n   * which fails when the snapshot already contains the post-migration schema.\n   * @param {object} args - Options object.\n   * @param {import(\"../database/drivers/base.js\").default} args.db - Database connection.\n   * @returns {Promise<string>} - INSERT statements (empty string when none).\n   */\n  async _schemaMigrationsInsertSql({db}) {\n    const {default: MigrationsLedger} = await import(\"../database/migrations-ledger.js\")\n\n    if (!await MigrationsLedger.tableExists(db)) return \"\"\n\n    const versions = await MigrationsLedger.appliedVersions(db)\n\n    if (versions.length == 0) return \"\"\n\n    return versions.map((version) => `INSERT INTO schema_migrations (version) VALUES (${db.quote(version)});`).join(\"\\n\") + \"\\n\"\n  }\n\n  /**\n   * Registers frontend-model websocket channel publishers so lifecycle\n   * event hooks broadcast over the shared \"frontend-models\" channel.\n   * This is only implemented by the Node handler because the required\n   * modules (`frontend-model-controller`, `routes/resolver`) pull in\n   * server-only Node APIs that break browser bundlers.\n   * @param {import(\"../configuration.js\").default} configuration - Configuration instance.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async initializeFrontendModelWebsocketPublishers(configuration) {\n    // Discover each backend project's resources before registering publishers. The publishers are\n    // derived from `backendProject.frontendModels`, which `autoDiscoverResources` populates. Without\n    // this, registration runs against an empty/partial resource set (only built-ins), so apps that\n    // resolve resources through an `abilityResolver` rather than a static ability-resource list never\n    // register lifecycle publishers and their realtime frontend-model updates silently stop. The\n    // lifecycle hooks are deduped per model class via a process-global set, so a later, fully\n    // discovered pass cannot retroactively add the missing publishers. `autoDiscoverResources` is\n    // idempotent (it skips backend projects whose `frontendModels` are already set).\n    await this.autoDiscoverResources(configuration)\n\n    const {ensureFrontendModelWebsocketPublishersRegistered} = await import(\"../frontend-models/websocket-publishers.js\")\n\n    await ensureFrontendModelWebsocketPublishersRegistered(configuration)\n  }\n}\n"]}

package/build/src/testing/shared-transaction-connection-coordinator.d.ts

@@ -1,7 +1,11 @@
+export type CoordinatorOwnerScope = {
+    ownedQueue: Promise<void>;
+};
 export type CoordinatorRegistration = {
+    connectionScope: CoordinatorOwnerScope;
     coordinator: (callback: () => Promise<unknown>) => Promise<unknown>;
-    ownedQueue: Promise<void>;
     owner: symbol;
+    ownerScopes: Map<symbol, CoordinatorOwnerScope>;
 };
 /**
  * Registers test-only serialization owned by the active broker.

package/build/src/testing/shared-transaction-connection-coordinator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared-transaction-connection-coordinator.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"AAEI,YAA2H,uBAAuB,GAAxI;IAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CAAyB;AA6BtJ;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,UAAU,EAJ/C,MAI+C,EAAE,WAAW,EAH5D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGO,GAF1D,MAAM,CAOlB;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAJjD,MAIiD,EAAE,WAAW,EAH9D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGS,GAF5D,IAAI,CAIhB;AAED;;;;;;;GAOG;AACH,wBAAsB,qCAAqC,CAN9C,CAAC,EAM8C,UAAU,EAL3D,OAAO,6BAA6B,EAAE,OAKqB,EAAE,QAAQ,EAJrE,MAAM,OAAO,CAAC,CAAC,CAIsD,EAAE,cAAc,AAH7F,CACA,EADQ,MAGqF,GAFnF,OAAO,CAAC,CAAC,CAAC,CAiBtB"}
+{"version":3,"file":"shared-transaction-connection-coordinator.d.ts","sourceRoot":"","sources":["../../../src/testing/shared-transaction-connection-coordinator.js"],"names":[],"mappings":"AAEI,YAAuC,qBAAqB,GAAlD;IAAC,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CAAC,CAAuB;AAC5D,YAAyL,uBAAuB,GAAtM;IAAC,eAAe,EAAE,qBAAqB,CAAC;IAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAAA;CAAC,CAAyB;AAkFpN;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,UAAU,EAJ/C,MAI+C,EAAE,WAAW,EAH5D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGO,GAF1D,MAAM,CAqBlB;AAED;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,UAAU,EAJjD,MAIiD,EAAE,WAAW,EAH9D,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAGS,GAF5D,IAAI,CAShB;AAED;;;;;;;GAOG;AACH,wBAAsB,qCAAqC,CAN9C,CAAC,EAM8C,UAAU,EAL3D,OAAO,6BAA6B,EAAE,OAKqB,EAAE,QAAQ,EAJrE,MAAM,OAAO,CAAC,CAAC,CAIsD,EAAE,cAAc,AAH7F,CACA,EADQ,MAGqF,GAFnF,OAAO,CAAC,CAAC,CAAC,CAyBtB"}