cabloy 5.1.220 → 5.1.222

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

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

package/vona/src/suite-vendor/a-vona/modules/a-logger/test/middlewareSystem.httpLog.test.ts

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { registerHooks } from 'node:module';
-import { test } from 'node:test';
+import { describe, test } from 'node:test';
 import ts from 'typescript';
 
 const middlewareUrl = new URL(
@@ -49,64 +49,66 @@ const hooks = registerHooks({
 const { MiddlewareSystemHttpLog } = await import(middlewareUrl);
 hooks.deregister();
 
-test('HTTP logger skips context and diagnostic access inside a request boundary', async () => {
-  const middleware = Object.create(MiddlewareSystemHttpLog.prototype);
-  for (const key of ['app', 'ctx', '$loggerChild']) {
-    Object.defineProperty(middleware, key, {
-      get() {
-        assert.fail('protected diagnostic access');
-      },
+describe('HTTP logger', { concurrency: false }, () => {
+  test('HTTP logger skips context and diagnostic access inside a request boundary', async () => {
+    const middleware = Object.create(MiddlewareSystemHttpLog.prototype);
+    for (const key of ['app', 'ctx', '$loggerChild']) {
+      Object.defineProperty(middleware, key, {
+        get() {
+          assert.fail('protected diagnostic access');
+        },
+      });
+    }
+    let calls = 0;
+    setBoundary({ diagnostics: 'suppress' });
+    try {
+      assert.equal(
+        await middleware.execute({}, async () => {
+          calls++;
+          return 23;
+        }),
+        23,
+      );
+      assert.equal(calls, 1);
+    } finally {
+      setBoundary(undefined);
+    }
+  });
+
+  for (const path of ['/health/ready', '/health/test-stop']) {
+    test(`HTTP logger redacts request authorization and response proof at ${path} without mutating headers`, async () => {
+      const headers = {
+        'x-vona-test-challenge': 'secret-challenge',
+        'X-Vona-Test-Stop-Authorization': 'secret-authorization',
+        'x-vona-test-stop-nonce': 'secret-nonce',
+        'accept': 'application/json',
+      };
+      const responseHeaders = {
+        'x-vona-test-proof': 'secret-readiness',
+        'X-Vona-Test-Stop-Proof': 'secret-ack',
+        'content-type': 'application/json',
+      };
+      const logs: string[] = [];
+      const middleware = Object.create(MiddlewareSystemHttpLog.prototype);
+      Object.assign(middleware, {
+        app: { meta: { env: { VONA_TEST_RUN_ID: '20261014010203-a1b2c3d4' } } },
+        ctx: {
+          path,
+          req: { url: path, headers },
+          res: { statusCode: 200, getHeaders: () => responseHeaders },
+        },
+        $loggerChild: () => ({
+          http: (message: () => string) => logs.push(message()),
+          startTimer: () => ({ done: ({ message }: { message: string }) => logs.push(message) }),
+        }),
+      });
+      await middleware.execute({}, async () => {});
+      assert.equal(logs.length, 2);
+      assert.equal(logs.join('\n').includes('secret-'), false);
+      assert.match(logs[0], /application\/json/);
+      assert.match(logs[1], /application\/json/);
+      assert.equal(headers['X-Vona-Test-Stop-Authorization'], 'secret-authorization');
+      assert.equal(responseHeaders['X-Vona-Test-Stop-Proof'], 'secret-ack');
     });
   }
-  let calls = 0;
-  setBoundary({ diagnostics: 'suppress' });
-  try {
-    assert.equal(
-      await middleware.execute({}, async () => {
-        calls++;
-        return 23;
-      }),
-      23,
-    );
-    assert.equal(calls, 1);
-  } finally {
-    setBoundary(undefined);
-  }
 });
-
-for (const path of ['/health/ready', '/health/test-stop']) {
-  test(`HTTP logger redacts request authorization and response proof at ${path} without mutating headers`, async () => {
-    const headers = {
-      'x-vona-test-challenge': 'secret-challenge',
-      'X-Vona-Test-Stop-Authorization': 'secret-authorization',
-      'x-vona-test-stop-nonce': 'secret-nonce',
-      'accept': 'application/json',
-    };
-    const responseHeaders = {
-      'x-vona-test-proof': 'secret-readiness',
-      'X-Vona-Test-Stop-Proof': 'secret-ack',
-      'content-type': 'application/json',
-    };
-    const logs: string[] = [];
-    const middleware = Object.create(MiddlewareSystemHttpLog.prototype);
-    Object.assign(middleware, {
-      app: { meta: { env: { VONA_TEST_RUN_ID: '20261014010203-a1b2c3d4' } } },
-      ctx: {
-        path,
-        req: { url: path, headers },
-        res: { statusCode: 200, getHeaders: () => responseHeaders },
-      },
-      $loggerChild: () => ({
-        http: (message: () => string) => logs.push(message()),
-        startTimer: () => ({ done: ({ message }: { message: string }) => logs.push(message) }),
-      }),
-    });
-    await middleware.execute({}, async () => {});
-    assert.equal(logs.length, 2);
-    assert.equal(logs.join('\n').includes('secret-'), false);
-    assert.match(logs[0], /application\/json/);
-    assert.match(logs[1], /application\/json/);
-    assert.equal(headers['X-Vona-Test-Stop-Authorization'], 'secret-authorization');
-    assert.equal(responseHeaders['X-Vona-Test-Stop-Proof'], 'secret-ack');
-  });
-}

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-mail",
-  "version": "5.1.14",
+  "version": "5.1.15",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

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

@@ -13,6 +13,11 @@ export class ServiceMail extends BeanBase {
   async sendById(id: TableIdentity) {
     const mail = await this.scope.model.mail.getById(id);
     if (!mail) return;
+    if (this.app.meta.isTest) {
+      await this.scope.model.mail.delete({ id });
+      this.$logger.info('Test mode: skipped external mail send.');
+      return;
+    }
     const clientName = mail.client;
     // client
     let client = this._getClient(clientName);

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

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

package/vona/src/suite-vendor/a-vona/modules/a-ormdialect/src/index.ts

@@ -1 +1,12 @@
 export * from './.metadata/index.ts';
+export { createProtectedSqliteRegistry } from './lib/protectedSqliteRegistry.ts';
+export type {
+  ProtectedSqliteRegistry,
+  ProtectedSqliteRegistryCloseResult,
+  ProtectedSqliteRegistryLookupOutcome,
+  ProtectedSqliteRegistryLookupResult,
+  ProtectedSqliteRegistryOptions,
+  ProtectedSqliteRegistryPrepareResult,
+  ProtectedSqliteRegistryRow,
+  ProtectedSqliteRegistrySnapshot,
+} from './lib/protectedSqliteRegistry.ts';

package/vona/src/suite-vendor/a-vona/modules/a-ormdialect/src/lib/protectedSqliteRegistry.ts

@@ -0,0 +1,356 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { getRequestBoundary } from 'vona';
+
+const MAX_NAME_BYTES = 256;
+const MAX_CONFIG_BYTES = 65_536;
+const LOOKUP_BUDGET_MS = 1_000;
+const PRIVATE_TIMEOUT_MS = 100;
+
+export const PROTECTED_SQLITE_REGISTRY_SQL = `SELECT
+  CASE WHEN typeof(id) = 'integer' AND id > 0 AND id <= 9007199254740991 THEN id ELSE NULL END AS id,
+  CASE WHEN typeof(name) = 'text' AND length(CAST(name AS BLOB)) <= 256 THEN name ELSE NULL END AS name,
+  CASE WHEN typeof(disabled) = 'integer' AND disabled IN (0, 1) THEN disabled ELSE NULL END AS disabled,
+  CASE WHEN typeof(isolate) = 'integer' AND isolate IN (0, 1) THEN isolate ELSE NULL END AS isolate,
+  CASE
+    WHEN config IS NULL THEN NULL
+    WHEN typeof(config) = 'text' AND length(CAST(config AS BLOB)) <= 65536 THEN config
+    ELSE NULL
+  END AS config,
+  CASE
+    WHEN typeof(id) = 'integer' AND id > 0 AND id <= 9007199254740991
+      AND typeof(name) = 'text' AND length(CAST(name AS BLOB)) <= 256
+      AND typeof(disabled) = 'integer' AND disabled IN (0, 1)
+      AND typeof(isolate) = 'integer' AND isolate IN (0, 1)
+      AND (config IS NULL OR (typeof(config) = 'text' AND length(CAST(config AS BLOB)) <= 65536))
+    THEN 1
+    ELSE 0
+  END AS __protected_valid
+FROM aInstance
+WHERE name COLLATE BINARY = ?
+  AND deleted = 0
+LIMIT 2`;
+
+type ProtectedSqliteState = 'new' | 'ready' | 'faulted' | 'closed';
+
+type ProtectedSqlitePrepareOutcome =
+  | 'ready'
+  | 'already_prepared'
+  | 'boundary_required'
+  | 'unsupported'
+  | 'unavailable';
+
+export interface ProtectedSqliteRegistryOptions {
+  readonly filename: string;
+}
+
+export interface ProtectedSqliteRegistryRow {
+  readonly id: number;
+  readonly name: string;
+  readonly disabled: boolean;
+  readonly isolate: boolean;
+  readonly config: string | null;
+}
+
+export interface ProtectedSqliteRegistryPrepareResult {
+  readonly outcome: ProtectedSqlitePrepareOutcome;
+}
+
+export type ProtectedSqliteRegistryLookupOutcome =
+  | 'found'
+  | 'missing'
+  | 'duplicate'
+  | 'disabled'
+  | 'invalid_input'
+  | 'expired'
+  | 'boundary_required'
+  | 'reentrant'
+  | 'unavailable';
+
+export type ProtectedSqliteRegistryLookupResult =
+  | Readonly<{
+      readonly outcome: 'found';
+      readonly row: ProtectedSqliteRegistryRow;
+    }>
+  | Readonly<{ readonly outcome: Exclude<ProtectedSqliteRegistryLookupOutcome, 'found'> }>;
+
+export interface ProtectedSqliteRegistryCloseResult {
+  readonly outcome: 'closed' | 'close_failed';
+}
+
+export interface ProtectedSqliteRegistrySnapshot {
+  readonly state: ProtectedSqliteState;
+  readonly active: boolean;
+  readonly closing: boolean;
+}
+
+export interface ProtectedSqliteRegistry {
+  readonly prepare: () => ProtectedSqliteRegistryPrepareResult;
+  readonly lookup: (name: string, deadlineAt?: number) => ProtectedSqliteRegistryLookupResult;
+  readonly close: () => Promise<ProtectedSqliteRegistryCloseResult>;
+  readonly snapshot: () => ProtectedSqliteRegistrySnapshot;
+}
+
+interface ProtectedSqliteStatement {
+  all(name: string): readonly unknown[];
+}
+
+interface ProtectedSqliteDatabase {
+  pragma(sql: string, options?: Readonly<{ readonly simple: true }>): unknown;
+  prepare(sql: string): ProtectedSqliteStatement;
+  close(): void;
+}
+
+interface ProtectedSqliteOpenOptions {
+  readonly readonly: true;
+  readonly fileMustExist: true;
+  readonly timeout: 100;
+}
+
+type ProtectedSqliteOpen = (
+  filename: string,
+  options: ProtectedSqliteOpenOptions,
+) => ProtectedSqliteDatabase;
+
+interface ProtectedSqliteDependencies {
+  readonly open: ProtectedSqliteOpen;
+  readonly now: () => number;
+  readonly hasRequestBoundary: () => boolean;
+}
+
+const productionDependencies: ProtectedSqliteDependencies = Object.freeze({
+  open: openNativeSqlite,
+  now: () => performance.now(),
+  hasRequestBoundary: () => getRequestBoundary() !== undefined,
+});
+
+export function createProtectedSqliteRegistry(
+  options: ProtectedSqliteRegistryOptions,
+): ProtectedSqliteRegistry {
+  return createProtectedSqliteRegistryInternal(options, productionDependencies);
+}
+
+// This seam is intentionally not exported by the package barrel. It makes lifecycle and
+// diagnostic-containment tests deterministic without accepting an alternate production driver.
+export function createProtectedSqliteRegistryForTest(
+  options: unknown,
+  dependencies: Readonly<
+    Partial<ProtectedSqliteDependencies> & { readonly open: ProtectedSqliteOpen }
+  >,
+): ProtectedSqliteRegistry {
+  return createProtectedSqliteRegistryInternal(options, {
+    open: dependencies.open,
+    now: dependencies.now ?? (() => performance.now()),
+    hasRequestBoundary:
+      dependencies.hasRequestBoundary ?? (() => getRequestBoundary() !== undefined),
+  });
+}
+
+export function createProtectedSqliteRegistryInternal(
+  options: unknown,
+  dependencies: ProtectedSqliteDependencies,
+): ProtectedSqliteRegistry {
+  const filename = readSupportedFilename(options);
+  let state: ProtectedSqliteState = 'new';
+  let attempted = false;
+  let active = false;
+  let closing = false;
+  let database: ProtectedSqliteDatabase | undefined;
+  let statement: ProtectedSqliteStatement | undefined;
+  let closePromise: Promise<ProtectedSqliteRegistryCloseResult> | undefined;
+  let closeResolve: ((result: ProtectedSqliteRegistryCloseResult) => void) | undefined;
+
+  const unavailable = (outcome: Exclude<ProtectedSqliteRegistryLookupOutcome, 'found'>) =>
+    Object.freeze({ outcome }) as ProtectedSqliteRegistryLookupResult;
+
+  const finalizeClose = (): ProtectedSqliteRegistryCloseResult => {
+    if (!database) {
+      state = 'closed';
+      return Object.freeze({ outcome: 'closed' });
+    }
+    try {
+      database.close();
+    } catch {
+      state = 'faulted';
+      return Object.freeze({ outcome: 'close_failed' });
+    }
+    database = undefined;
+    statement = undefined;
+    state = 'closed';
+    return Object.freeze({ outcome: 'closed' });
+  };
+
+  const settleDeferredClose = () => {
+    if (!closeResolve) return;
+    const resolve = closeResolve;
+    closeResolve = undefined;
+    resolve(finalizeClose());
+  };
+
+  const prepare = (): ProtectedSqliteRegistryPrepareResult => {
+    if (dependencies.hasRequestBoundary()) return Object.freeze({ outcome: 'boundary_required' });
+    if (closing || state === 'closed') return Object.freeze({ outcome: 'unavailable' });
+    if (attempted) return Object.freeze({ outcome: 'already_prepared' });
+    attempted = true;
+    if (!filename) {
+      state = 'faulted';
+      return Object.freeze({ outcome: 'unsupported' });
+    }
+    try {
+      database = dependencies.open(filename, {
+        readonly: true,
+        fileMustExist: true,
+        timeout: PRIVATE_TIMEOUT_MS,
+      });
+      const journalMode = database.pragma('journal_mode', { simple: true });
+      const busyTimeout = database.pragma('busy_timeout', { simple: true });
+      if (journalMode !== 'wal' || busyTimeout !== PRIVATE_TIMEOUT_MS) throw new Error();
+      statement = database.prepare(PROTECTED_SQLITE_REGISTRY_SQL);
+      const probe = statement.all('');
+      if (
+        !Array.isArray(probe) ||
+        probe.length > 2 ||
+        probe.some(row => !isValidProjectionRow(row))
+      ) {
+        throw new Error();
+      }
+      state = 'ready';
+      return Object.freeze({ outcome: 'ready' });
+    } catch {
+      state = 'faulted';
+      return Object.freeze({ outcome: 'unavailable' });
+    }
+  };
+
+  const lookup = (name: string, deadlineAt = dependencies.now() + LOOKUP_BUDGET_MS) => {
+    if (!dependencies.hasRequestBoundary()) return unavailable('boundary_required');
+    if (state !== 'ready' || closing || !database || !statement) return unavailable('unavailable');
+    if (!isBoundedText(name, MAX_NAME_BYTES)) {
+      return unavailable('invalid_input');
+    }
+    if (!Number.isFinite(deadlineAt) || dependencies.now() >= deadlineAt) {
+      return unavailable('expired');
+    }
+    if (active) return unavailable('reentrant');
+    active = true;
+    try {
+      const rows = statement.all(name);
+      if (closing || dependencies.now() >= deadlineAt) return unavailable('expired');
+      if (!Array.isArray(rows)) {
+        state = 'faulted';
+        return unavailable('unavailable');
+      }
+      if (rows.length > 2) {
+        state = 'faulted';
+        return unavailable('unavailable');
+      }
+      if (rows.length === 0) return unavailable('missing');
+      if (rows.length === 2) return unavailable('duplicate');
+      const row = rows[0];
+      if (!isValidProjectionRow(row)) {
+        state = 'faulted';
+        return unavailable('unavailable');
+      }
+      const projected = row as Record<string, unknown>;
+      if (projected.disabled === 1) return unavailable('disabled');
+      const result = Object.freeze({
+        outcome: 'found' as const,
+        row: Object.freeze({
+          id: projected.id as number,
+          name: projected.name as string,
+          disabled: projected.disabled === 1,
+          isolate: projected.isolate === 1,
+          config: projected.config as string | null,
+        }),
+      });
+      return result;
+    } catch {
+      state = 'faulted';
+      return unavailable('unavailable');
+    } finally {
+      active = false;
+      if (closing) settleDeferredClose();
+    }
+  };
+
+  const close = () => {
+    if (closePromise) return closePromise;
+    closing = true;
+    if (active) {
+      closePromise = new Promise<ProtectedSqliteRegistryCloseResult>(resolve => {
+        closeResolve = resolve;
+      });
+    } else {
+      closePromise = Promise.resolve(finalizeClose());
+    }
+    return closePromise;
+  };
+
+  return Object.freeze({
+    prepare,
+    lookup,
+    close,
+    snapshot: () => Object.freeze({ state, active, closing }),
+  });
+}
+
+function readSupportedFilename(options: unknown): string | undefined {
+  try {
+    if (!options || typeof options !== 'object' || Array.isArray(options)) return undefined;
+    const prototype = Object.getPrototypeOf(options);
+    if (prototype !== Object.prototype && prototype !== null) return undefined;
+    const keys = Reflect.ownKeys(options);
+    if (keys.length !== 1 || keys[0] !== 'filename') return undefined;
+    const descriptor = Object.getOwnPropertyDescriptor(options, 'filename');
+    if (!descriptor || !Object.hasOwn(descriptor, 'value')) return undefined;
+    const filename: unknown = descriptor.value;
+    if (
+      typeof filename !== 'string' ||
+      !filename.isWellFormed() ||
+      !path.isAbsolute(filename) ||
+      filename.includes('\0')
+    ) {
+      return undefined;
+    }
+    return filename;
+  } catch {
+    return undefined;
+  }
+}
+
+function isBoundedText(value: unknown, maxBytes: number): value is string {
+  return (
+    typeof value === 'string' &&
+    value.isWellFormed() &&
+    Buffer.byteLength(value, 'utf8') <= maxBytes
+  );
+}
+
+function isValidProjectionRow(row: unknown): boolean {
+  if (!row || typeof row !== 'object') return false;
+  const projected = row as Record<string, unknown>;
+  if (projected.__protected_valid !== 1) return false;
+  if (
+    typeof projected.id !== 'number' ||
+    !Number.isSafeInteger(projected.id) ||
+    projected.id <= 0
+  ) {
+    return false;
+  }
+  if (!isBoundedText(projected.name, MAX_NAME_BYTES)) return false;
+  if (projected.disabled !== 0 && projected.disabled !== 1) return false;
+  if (projected.isolate !== 0 && projected.isolate !== 1) return false;
+  return projected.config === null || isBoundedText(projected.config, MAX_CONFIG_BYTES);
+}
+
+function openNativeSqlite(
+  filename: string,
+  options: ProtectedSqliteOpenOptions,
+): ProtectedSqliteDatabase {
+  const require = createRequire(import.meta.url);
+  const BetterSqlite3 = require('better-sqlite3') as new (
+    filename: string,
+    options: ProtectedSqliteOpenOptions,
+  ) => ProtectedSqliteDatabase;
+  return new BetterSqlite3(filename, options);
+}

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

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

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

@@ -1,8 +1,38 @@
 import assert from 'node:assert/strict';
+import { execFile } from 'node:child_process';
+import { registerHooks } from 'node:module';
 import { afterEach, beforeEach, describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
 
-import { ServiceInstance } from '../../a-instance/src/service/instance.ts';
-import { ServiceStartup } from '../src/service/startup.ts';
+// Only bypass bean registration; exercise real startup methods with local fixtures.
+const serviceUrls = [
+  new URL('../../a-instance/src/service/instance.ts', import.meta.url).href,
+  new URL('../src/service/startup.ts', import.meta.url).href,
+];
+const hooks = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    if (serviceUrls.includes(context.parentURL!) && specifier === 'vona-module-a-bean') {
+      return {
+        url: 'data:text/javascript,export function Service() { return () => {}; }',
+        shortCircuit: true,
+      };
+    }
+    return nextResolve(specifier, context);
+  },
+});
+const { ServiceInstance, ServiceStartup } = await (async () => {
+  try {
+    return {
+      ...(await import('../../a-instance/src/service/instance.ts')),
+      ...(await import('../src/service/startup.ts')),
+    };
+  } finally {
+    hooks.deregister();
+  }
+})();
+type ServiceInstance = InstanceType<typeof ServiceInstance>;
+type ServiceStartup = InstanceType<typeof ServiceStartup>;
 
 function fixture(created: string[] = []) {
   const calls: string[] = [];
@@ -105,6 +135,35 @@ const isolateCalls = [
 ];
 
 describe('creation-driven dev seed', { concurrency: false }, () => {
+  // Keep reset-flag mutations out of the managed runner's concurrent test process.
+  if (process.env.VONA_TEST_RUN_ID !== undefined) {
+    it('runs dev seed cases in an isolated process', async () => {
+      const loader = import.meta.resolve('ts-node-maintained/esm');
+      const projectRoot = new URL('../../../../../../', import.meta.url);
+      const registerSource = `import { register } from 'node:module'; register(${JSON.stringify(loader)}, ${JSON.stringify(projectRoot.href)});`;
+      const env = Object.fromEntries(Object.entries(process.env)) as NodeJS.ProcessEnv;
+      delete env.VONA_TEST_RUN_ID;
+      delete env.NODE_TEST_CONTEXT;
+      delete env.VONA_DB_RESET;
+      env.TS_NODE_PROJECT = fileURLToPath(new URL('tsconfig.json', projectRoot));
+      const { stdout } = await promisify(execFile)(
+        process.execPath,
+        [
+          '--import',
+          `data:text/javascript,${encodeURIComponent(registerSource)}`,
+          '--test',
+          '--test-reporter=tap',
+          '--test-name-pattern=creation-driven dev seed',
+          fileURLToPath(import.meta.url),
+        ],
+        { env, timeout: 30_000 },
+      );
+      assert.match(stdout, /# fail 0\b/);
+      assert.match(stdout, /# pass 16\b/);
+    });
+    return;
+  }
+
   let previousReset: string | undefined;
   beforeEach(() => {
     previousReset = process.env.VONA_DB_RESET;

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-vona",
-  "version": "5.1.102",
+  "version": "5.1.104",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",

package/zova/package.original.json

@@ -14,7 +14,7 @@
     "url": "git+https://github.com/zovajs/zova.git"
   },
   "type": "module",
-  "packageManager": "pnpm@11.5.2",
+  "packageManager": "pnpm@12.14.0",
   "scripts": {
     "zova": "node ./packages-cli/cli/src/bin/zova.ts",
     "dev": "npm run dev:ssr:admin",
@@ -85,7 +85,6 @@
     "typescript": "^5.9.3",
     "vite": "^8.3.4",
     "vite-plugin-fake-server-turbo": "^3.0.18",
-    "vue-tsc": "^3.3.1",
     "zova-vite": "workspace:^",
     "textlint": "^15.7.0",
     "textlint-rule-en-no-mixed-period": "^3.0.2",
@@ -96,6 +95,7 @@
     "oxlint": "^1.77.0"
   },
   "engines": {
-    "node": ">=22.12.0"
+    "node": ">=24.4.0",
+    "pnpm": ">=11.5.2"
   }
 }

package/zova/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-cli",
-  "version": "1.2.116",
+  "version": "1.2.118",
   "gitHead": "6f675a8cc46d596142c591c28a40cc4d82fcc6cc",
   "description": "zova cli",
   "keywords": [
@@ -40,11 +40,11 @@
     "postpack": "clean-package restore"
   },
   "dependencies": {
-    "@cabloy/cli": "^3.1.29",
-    "@cabloy/process-helper": "^3.1.8",
+    "@cabloy/cli": "^3.1.30",
+    "@cabloy/process-helper": "^3.1.9",
     "fs-extra": "^11.3.5",
     "semver": "^7.6.2",
-    "zova-cli-set-front": "^1.2.114"
+    "zova-cli-set-front": "^1.2.116"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",