cabloy 5.1.220 → 5.1.221

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

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-core",
-  "version": "5.1.62",
+  "version": "5.1.63",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "keywords": [

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-vona",
-  "version": "5.1.102",
+  "version": "5.1.103",
   "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",
@@ -96,6 +96,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.117",
   "gitHead": "6f675a8cc46d596142c591c28a40cc4d82fcc6cc",
   "description": "zova cli",
   "keywords": [
@@ -44,7 +44,7 @@
     "@cabloy/process-helper": "^3.1.8",
     "fs-extra": "^11.3.5",
     "semver": "^7.6.2",
-    "zova-cli-set-front": "^1.2.114"
+    "zova-cli-set-front": "^1.2.115"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

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

@@ -1,6 +1,6 @@
 {
   "name": "zova-cli-set-front",
-  "version": "1.2.114",
+  "version": "1.2.115",
   "gitHead": "6f675a8cc46d596142c591c28a40cc4d82fcc6cc",
   "description": "zova cli-set-front",
   "keywords": [

package/zova/packages-cli/cli-set-front/src/lib/common/restDependencyVersions.ts

@@ -29,7 +29,7 @@ export async function extractRestDependencyVersions(
 ): Promise<Record<string, string>> {
   const lockfilePath = path.join(projectPath, 'pnpm-lock.yaml');
   const lockfileContent = await fse.readFile(lockfilePath, 'utf8');
-  const parsedLockfile = yaml.parse(lockfileContent) as ParsedLockfile;
+  const parsedLockfile = parseWorkspaceLockfile(lockfileContent);
   const depsVersion: Record<string, string> = {};
 
   for (const dep of deps) {
@@ -66,6 +66,27 @@ export async function extractRestDependencyVersions(
   return depsVersion;
 }
 
+function parseWorkspaceLockfile(content: string): ParsedLockfile {
+  const documents = yaml.parseAllDocuments(content);
+  for (const document of documents) {
+    if (document.errors.length) throw document.errors[0];
+  }
+
+  // pnpm 12 places the workspace lock after its package-manager/config dependency lock.
+  const document = documents.findLast(({ contents }) => {
+    return (
+      contents !== null &&
+      !(yaml.isScalar(contents) && contents.value === null && contents.source === '')
+    );
+  });
+  if (!document || !yaml.isMap(document.contents) || !yaml.isMap(document.get('importers', true))) {
+    throw new Error(
+      'Invalid pnpm-lock.yaml: expected a workspace document with an importers mapping.',
+    );
+  }
+  return document.toJS() as ParsedLockfile;
+}
+
 function getPackageDependencyRangeFromLock(
   parsedLockfile: ParsedLockfile,
   packageName: string,

package/zova/packages-cli/cli-set-front/test/restDependencies.test.ts

@@ -238,6 +238,143 @@ import Alias = Existing.Value;
 });
 
 describe('extractRestDependencyVersions', () => {
+  const managementLockfile = `---
+lockfileVersion: '9.0'
+importers:
+  .:
+    configDependencies: {}
+    packageManagerDependencies:
+      pnpm:
+        specifier: 12.14.0
+        version: 12.14.0
+    dependencies:
+      root-package:
+        version: 99.0.0
+      management-only:
+        version: 99.0.0
+`;
+  const workspaceLockfile = `lockfileVersion: '9.0'
+importers:
+  .:
+    dependencies:
+      root-package:
+        version: 1.2.3
+      alias-package:
+        specifier: npm:@scope/package@^2.0.0
+        version: '@scope/package@2.0.4'
+  src/module/example:
+    dependencies:
+      owned-package:
+        version: 3.1.7(vue@3.5.42)
+`;
+
+  for (const trailingDocument of ['', '---\n# empty document\n']) {
+    it(`uses the workspace document of a pnpm 12 lockfile${trailingDocument ? ' with a trailing empty document' : ''}`, async () => {
+      await withFixture(async projectPath => {
+        await writeLockfile(
+          projectPath,
+          `${managementLockfile}---\n${workspaceLockfile}${trailingDocument}`,
+        );
+        assert.deepEqual(
+          await extractRestDependencyVersions(
+            projectPath,
+            ['root-package', 'alias-package', 'owned-package'],
+            ['src/module/example'],
+          ),
+          {
+            'root-package': '^1.2.3',
+            'alias-package': 'npm:@scope/package@^2.0.0',
+            'owned-package': '^3.1.7',
+          },
+        );
+        for (const dependency of ['management-only', 'pnpm']) {
+          await assert.rejects(
+            extractRestDependencyVersions(projectPath, [dependency]),
+            /Unable to resolve REST dependency version/,
+          );
+        }
+      });
+    });
+  }
+
+  it('accepts a single workspace document with an explicit start marker', async () => {
+    await withFixture(async projectPath => {
+      await writeLockfile(projectPath, `---\n${workspaceLockfile}`);
+      assert.deepEqual(await extractRestDependencyVersions(projectPath, ['root-package']), {
+        'root-package': '^1.2.3',
+      });
+    });
+  });
+
+  for (const [label, invalidDocument, code] of [
+    ['malformed YAML', 'importers: [\n', 'BAD_INDENT'],
+    ['duplicate keys', 'importers: {}\nimporters: {}\n', 'DUPLICATE_KEY'],
+  ]) {
+    for (const position of ['management', 'workspace']) {
+      it(`rejects ${label} in the ${position} document before installed-package fallback`, async () => {
+        await withFixture(async projectPath => {
+          const content =
+            position === 'management'
+              ? `${invalidDocument}---\n${workspaceLockfile}`
+              : `${managementLockfile}---\n${invalidDocument}`;
+          await writeLockfile(projectPath, content);
+          await writePackage(projectPath, 'node_modules/root-package', { version: '5.0.0' });
+          await assert.rejects(extractRestDependencyVersions(projectPath, ['root-package']), {
+            name: 'YAMLParseError',
+            code,
+          });
+        });
+      });
+    }
+  }
+
+  for (const [label, invalidDocument] of [
+    ['empty', ''],
+    ['comment-only', '# no lockfile\n'],
+    ['empty marked', '---\n# no lockfile\n'],
+    ['null', 'null\n'],
+    ['tilde null', '~\n'],
+    ['empty string', '""\n'],
+    ['scalar', 'invalid\n'],
+    ['sequence', '- invalid\n'],
+    ['missing importers', "lockfileVersion: '9.0'\n"],
+    ['null importers', 'importers: null\n'],
+    ['scalar importers', 'importers: invalid\n'],
+    ['sequence importers', 'importers: []\n'],
+  ]) {
+    it(`rejects a ${label} workspace document`, async () => {
+      await withFixture(async projectPath => {
+        await writePackage(projectPath, 'node_modules/root-package', { version: '5.0.0' });
+        await writeLockfile(projectPath, invalidDocument);
+        await assert.rejects(
+          extractRestDependencyVersions(projectPath, ['root-package']),
+          /Invalid pnpm-lock.yaml: expected a workspace document with an importers mapping/,
+        );
+        if (
+          invalidDocument.trim() &&
+          !invalidDocument.startsWith('#') &&
+          !invalidDocument.startsWith('---')
+        ) {
+          await writeLockfile(projectPath, `${workspaceLockfile}---\n${invalidDocument}`);
+          await assert.rejects(
+            extractRestDependencyVersions(projectPath, ['root-package']),
+            /Invalid pnpm-lock.yaml: expected a workspace document with an importers mapping/,
+          );
+        }
+      });
+    });
+  }
+
+  it('allows installed-package fallback with an empty workspace importer map', async () => {
+    await withFixture(async projectPath => {
+      await writeLockfile(projectPath, `${managementLockfile}---\nimporters: {}\n`);
+      await writePackage(projectPath, 'node_modules/root-package', { version: '5.0.0' });
+      assert.deepEqual(await extractRestDependencyVersions(projectPath, ['root-package']), {
+        'root-package': '^5.0.0',
+      });
+    });
+  });
+
   it('uses the root importer range when the dependency is declared there', async () => {
     await withFixture(async projectPath => {
       await writeLockfile(