@vzn/vx 0.0.643 → 0.0.644

package/src/settings.ts

@@ -17,7 +17,8 @@ export type SettingKind =
   | { readonly type: 'concurrency' }
   // `zero`: 0 is a value ("wait for nothing not already done"), not a typo.
   | { readonly type: 'duration'; readonly timer?: true; readonly zero?: true }
-  | { readonly type: 'size' }
+  // `off`: `false` is a value, 0 bytes (the thing the size bounds is off).
+  | { readonly type: 'size'; readonly off?: true }
   | { readonly type: 'bool' }
   | { readonly type: 'enum'; readonly values: readonly string[] }
   | { readonly type: 'string' }
@@ -115,18 +116,6 @@ export const SETTINGS: readonly Setting[] = [
     doc: 'Where the cache lives, relative to the workspace root; named, it holds the whole cache.',
     flag: { verb: 'run', name: '--cache-dir' },
   },
-  {
-    path: 'cache.retention.maxSize',
-    kind: { type: 'size' },
-    default: 'none',
-    doc: "Evict least-recently-used entries at each run's end until the cache is under this (`'10GB'`).",
-  },
-  {
-    path: 'cache.retention.olderThan',
-    kind: { type: 'duration' },
-    default: 'none',
-    doc: "Evict entries unused for this long at each run's end (`'30d'`).",
-  },
   {
     path: 'cache.policy',
     kind: { type: 'string' },
@@ -141,6 +130,27 @@ export const SETTINGS: readonly Setting[] = [
     doc: "A branch's remote entries (`'vznjs/vx:feat-x'`): tasks the branch changed read the scope's key, the rest the default key; the local cache never uses it. Empty: no scope.",
     config: false,
   },
+  {
+    path: 'cache.concurrency.download',
+    kind: { type: 'int', min: 1 },
+    default: 'min(96, max(cores × 3, 64))',
+    doc: 'Remote downloads at once.',
+    flag: { verb: 'run', name: '--cache-concurrency-download' },
+  },
+  {
+    path: 'cache.concurrency.upload',
+    kind: { type: 'int', min: 1 },
+    default: 'min(96, max(cores × 3, 64))',
+    doc: 'Uploads at once, per remote.',
+    flag: { verb: 'run', name: '--cache-concurrency-upload' },
+  },
+  {
+    path: 'cache.concurrency.restore',
+    kind: { type: 'int', min: 1 },
+    default: 'twice `run.concurrency`',
+    doc: 'Local hits restoring outputs at once.',
+    flag: { verb: 'run', name: '--cache-concurrency-restore' },
+  },
   {
     path: 'cache.download',
     kind: { type: 'enum', values: ['all', 'toplevel', 'none'] },
@@ -170,6 +180,24 @@ export const SETTINGS: readonly Setting[] = [
     task: 'cache.outputs.clean',
     env: false,
   },
+  {
+    path: 'cache.store.embeddings',
+    kind: { type: 'size', off: true },
+    default: "'32KiB'",
+    doc: 'Keep an entry up to this size inside the cache index, one zstd tar, rather than as files; `false` keeps none.',
+  },
+  {
+    path: 'cache.store.decompress',
+    kind: { type: 'bool' },
+    default: 'true',
+    doc: 'Keep a larger entry as its plain files, which a hit copies or clones out; off, as one `.tar.zst`.',
+  },
+  {
+    path: 'cache.store.verify',
+    kind: { type: 'enum', values: ['stat', 'hash', 'none'] },
+    default: 'stat',
+    doc: "What a hit on plain files checks first: each file's size and mtime, every byte, or nothing.",
+  },
   {
     path: 'cache.upload.failures',
     kind: { type: 'enum', values: ['ci', 'local', 'always'] },
@@ -250,7 +278,7 @@ export function kindHint(kind: SettingKind): string {
         ? "a duration like '500ms', '30s' or '5m', at most 24 days"
         : "a duration like '45s', '12h' or '30d'"
     case 'size':
-      return "a size like '500MB' or '10GB'"
+      return kind.off === true ? "false, or a size like '32KiB'" : "a size like '500MB' or '10GB'"
     case 'bool':
       return 'true or false'
     case 'enum':
@@ -298,6 +326,7 @@ export function parseSettingValue(kind: SettingKind, raw: unknown): unknown {
       return kind.timer === true && n > MAX_TIMEOUT_MS ? null : n
     }
     case 'size':
+      if (kind.off === true && (raw === false || raw === 'false')) return 0
       return typeof raw === 'string' ? parseSize(raw) : null
     case 'bool':
       if (typeof raw === 'boolean') return raw

package/src/util/index.ts

@@ -55,6 +55,7 @@ export {
   EXTGLOB,
   grantPrefix,
   isLiteralPattern,
+  literalPath,
   GLOB_WILDCARDS,
   normalizeBunGlob,
   normalizeGlob,

package/src/util/paths.ts

@@ -48,7 +48,15 @@ export function relPosix(from: string, to: string): string {
  * Every glob reaching here is user-written, so every one takes the rule.
  */
 export function staticPrefix(rawGlob: string): string {
-  return prefixOf(normalizeGlob(rawGlob), GLOB_WILDCARDS)
+  // An escaped character is part of the prefix and names itself:
+  // `app/\[id\]/**` is rooted at the directory `app/[id]`.
+  const g = normalizeGlob(rawGlob)
+  if (!g.includes('\\')) return prefixOf(g, GLOB_WILDCARDS)
+  const masked = g.replace(/\\./g, '\0\0')
+  const prefix = prefixOf(masked, GLOB_WILDCARDS)
+  return prefix === '.' || prefix === '/'
+    ? prefix
+    : g.slice(0, prefix.length).replace(/\\(.)/g, '$1')
 }
 
 /**
@@ -98,10 +106,10 @@ export function wholeSubtreePrefixes(globs: readonly string[]): string[] | null
   if (globs.length === 0) return null
   const out: string[] = []
   for (const g of globs.map(normalizeGlob)) {
-    const m = /^([^*?{}!]+?)\/\*\*$/.exec(g)
-    const whole = m?.[1] ?? (isLiteralPattern(g) && !g.startsWith('!') ? g : null)
-    if (whole === null) return null
-    const dir = whole.replace(/\/+$/, '')
+    const named = /^(.+?)\/\*\*$/.exec(g)?.[1] ?? g
+    if (g.startsWith('!') || !namesOnePath(named)) return null
+    // An escaped bracket names itself: `app/\[id\]/**` is the tree `app/[id]`.
+    const dir = named.replace(/\\(.)/g, '$1').replace(/\/+$/, '')
     if (dir === '' || dir === '.' || dir.startsWith('/') || dir.split('/').includes('..'))
       return null
     out.push(dir)
@@ -136,10 +144,6 @@ function normalizeWith(glob: string, wildcards: RegExp): string {
   let g = neg ? glob.slice(1) : glob
   g = g.replace(/\/{2,}/g, '/').replace(/(^|\/)(\.\/)+/g, '$1')
   if (g === '.') g = ''
-  // Where a bracket is literal, Turbo's escaped spelling `\[id\]` names the
-  // same path as `[id]`; one spelling is what lets every literal fast path
-  // (string compare, `settleLiterals`, `asTrees`) see it as a literal.
-  if (wildcards === GLOB_WILDCARDS && g.includes('\\')) g = g.replace(/\\([[\]])/g, '$1')
   if (wildcards.test(g) && g.endsWith('/')) g = `${g.replace(/\/+$/, '')}/**`
   return neg ? `!${g}` : g
 }
@@ -172,21 +176,19 @@ export function isLiteralPattern(glob: string): boolean {
  * class written out nine times — a spelling that drifts is how two guards
  * come to answer differently for one pattern.
  *
- * `[` and `]` are NOT in it: a bracket is a literal character in a task
- * glob, and there are no character classes (item 667). Route directories
- * are named `[id]` across Next.js, SvelteKit and Astro, and read as a class
- * `app/[id]/**` matched `app/i/…` and `app/d/…` and never the route: the
- * file never entered the key (a stale hit) and the output clean deleted an
- * unrelated `app/i/page.js`. {@link taskGlob} is how such a glob reaches
- * `Bun.Glob`, whose own alphabet still reads the class.
+ * A task glob is a standard glob (M, 2026-10-18): `[...]` is a character
+ * class and `\[id\]` names the route directory `[id]`. An escape counts as
+ * a wildcard too: such a pattern is matched by `Bun.Glob`, which reads the
+ * escape, never compared as a string; `asTrees` still reads an escaped-only
+ * pattern as one path.
  */
-export const GLOB_WILDCARDS = /[*?{}]/
+export const GLOB_WILDCARDS = /[*?{}[\]\\]/
 
 /**
- * `Bun.Glob`'s own alphabet, the class included, for the globs vx does not
- * own: package-manager workspace members and `--filter` path globs follow
- * npm/pnpm semantics, and a sandbox grant's prefix must stop where the scan
- * that expands the grant (`Bun.Glob`, `MOUNT_WILDCARDS`) sees a wildcard.
+ * `Bun.Glob`'s own alphabet, for the globs vx does not own: package-manager
+ * workspace members and `--filter` path globs follow npm/pnpm semantics,
+ * and a sandbox grant's prefix must stop where the scan that expands the
+ * grant (`Bun.Glob`, `MOUNT_WILDCARDS`) sees a wildcard.
  */
 export const BUN_GLOB_WILDCARDS = /[*?[\]{}]/
 
@@ -200,11 +202,7 @@ export const BUN_GLOB_WILDCARDS = /[*?[\]{}]/
  */
 export const EXTGLOB = /[!@+*?]\(/
 
-/**
- * Compile a task glob for `Bun.Glob`, with every bare bracket escaped so it
- * matches itself (item 667). Every task glob is compiled here and nowhere
- * else: one site that forgot is a route directory that keys nothing.
- */
+/** Compile a task glob for `Bun.Glob`. Every task glob is compiled here and nowhere else. */
 export function taskGlob(pattern: string): Bun.Glob {
   const memo = memoFor(taskGlobs)
   let glob = memo.get(pattern)
@@ -230,9 +228,7 @@ function memoFor<T>(memos: WeakMap<object, Map<string, T>>): Map<string, T> {
 }
 
 function compileTaskGlob(pattern: string): Bun.Glob {
-  // A `]` with no `[` before it is already literal to `Bun.Glob`.
-  const source = pattern.includes('[') ? pattern.replace(/(?<!\\)[[\]]/g, '\\$&') : pattern
-  const glob = new Bun.Glob(source)
+  const glob = new Bun.Glob(pattern)
   const alternatives = braceAlternatives(pattern)
   if (alternatives.length > 1) {
     const any = anyTaskGlob(alternatives)
@@ -288,12 +284,12 @@ const REGEXP_SYNTAX = /[\\^$.*+?()[\]{}|]/g
  * The RegExp source of a task glob, matching what `Bun.Glob` matches
  * (`tests/util-paths.test.ts` holds the two to the same verdict on every
  * shape): `*` any run within a name, `?` one character, a `**` segment any
- * number of directories, a bracket itself. Null for the syntax left to
- * `Bun.Glob`: a brace, an escape, a leading `!`, an empty, `.` or `..`
+ * number of directories. Null for the syntax left to `Bun.Glob`: a brace,
+ * a character class, an escape, a leading `!`, an empty, `.` or `..`
  * segment, a `**` inside a name, or two `**` segments in a row.
  */
 function regExpSource(pattern: string): string | null {
-  if (/[\\{}]/.test(pattern) || pattern.startsWith('!')) return null
+  if (/[\\{}[\]]/.test(pattern) || pattern.startsWith('!')) return null
   const segments = pattern.split('/')
   let out = ''
   for (let i = 0; i < segments.length; i++) {
@@ -342,7 +338,7 @@ export function asTrees(patterns: readonly string[]): string[] {
   const out: string[] = []
   for (const raw of patterns) {
     const p = normalizeGlob(raw)
-    if (!isLiteralPattern(p)) {
+    if (!namesOnePath(p)) {
       out.push(p)
       continue
     }
@@ -353,6 +349,19 @@ export function asTrees(patterns: readonly string[]): string[] {
   return out
 }
 
+/**
+ * The one path a task glob names, an escaped one included (`app/\[id\]`
+ * names `app/[id]`), or null for a pattern.
+ */
+export function literalPath(glob: string): string | null {
+  if (isLiteralPattern(glob)) return glob
+  return isLiteralPattern(glob.replace(/\\./g, '_')) ? glob.replace(/\\(.)/g, '$1') : null
+}
+
+function namesOnePath(glob: string): boolean {
+  return literalPath(glob) !== null
+}
+
 /**
  * An output list's positive globs, and what its `!` entries take back
  * (A-44). A reader that only needs where outputs MIGHT land (an overlap

package/src/util/size.ts

@@ -4,13 +4,13 @@ import { parseDecimalInt } from './num.js'
 
 /**
  * Parse a byte-size string: a bare integer (`"1048576"`) or an integer
- * with a K/M/G/T suffix, powers of 1024, optional trailing `B`
- * (`"512MB"`, `"8G"`). Returns `null` for anything else — including
+ * with a K/M/G/T suffix, powers of 1024, optional trailing `B` or `iB`
+ * (`"512MB"`, `"8G"`, `"32KiB"`). Returns `null` for anything else — including
  * fractional sizes (`"1.5GB"`); callers wanting fractions must express
  * them in a smaller unit.
  */
 export function parseSize(input: string): number | null {
-  const m = input.match(/^(\d+)([KMGT])?B?$/i)
+  const m = input.match(/^(\d+)(?:([KMGT])(?:i?B)?|B)?$/i)
   if (!m) return null
   // Digits past 2^53 parse to a different number than the user typed.
   const n = parseDecimalInt(m[1]!)
@@ -49,8 +49,7 @@ export function parseDuration(input: string): number | null {
 
 /**
  * Human-readable byte size with KB/MB/GB/TB/PB suffixes and one
- * decimal of precision below 10 of any unit. Used by `vx info`, `vx cache clean` and the
- * run's `cacheRetention` line.
+ * decimal of precision below 10 of any unit. Used by `vx info` and `vx cache clean`.
  */
 export function formatBytes(n: number): string {
   if (n < 1024) return `${n} B`

package/src/workspace/config-schema.ts

@@ -19,8 +19,6 @@ import {
   CORE_VERBS,
   nearest,
   normalizeGlob,
-  parseDuration,
-  parseSize,
   UserError,
   BUN_GLOB_WILDCARDS,
   EXTGLOB,
@@ -203,15 +201,6 @@ function validateDependencyRules(value: unknown, where: string): void {
 /** `value` as the setting at `path` takes it, refused in `where`'s words. */
 function validateSettingValue(value: unknown, path: string, where: string): void {
   const { kind } = setting(path)
-  // The bound `vx cache clean` refuses too: each run would empty the cache,
-  // the entries it just saved included, so nothing ever hits (item 969).
-  if (
-    path === 'cache.retention.olderThan' &&
-    typeof value === 'string' &&
-    parseDuration(value) === 0
-  ) {
-    throw new UserError(`${where} of 0 evicts every entry after every run`)
-  }
   // A file's values are typed: a count or a switch is no string (only a
   // share of the cores is), as a variable's or a flag's must be.
   const untyped =
@@ -237,7 +226,6 @@ function validateSettingsExtra(config: WorkspaceConfig, configPath: string): voi
   }
   // `policy`'s grammar is the cache module's (`parseCachePolicy`), which
   // this module may not import: the run parses it before any task (prepare.ts).
-  if (config.cache?.retention !== undefined) validateRetention(config.cache.retention, configPath)
 }
 
 /**
@@ -250,30 +238,6 @@ function shown(v: unknown): string {
   return typeof v === 'bigint' ? `${v}n` : (JSON.stringify(v) ?? String(v))
 }
 
-function validateRetention(
-  retention: NonNullable<NonNullable<WorkspaceConfig['cache']>['retention']>,
-  configPath: string,
-): void {
-  const { olderThan, maxSize } = retention
-  // An empty object would load and evict nothing, which reads as a policy.
-  if (olderThan === undefined && maxSize === undefined) {
-    throw new UserError(
-      `${configPath}: \`cache.retention\` names neither \`olderThan\` nor \`maxSize\``,
-    )
-  }
-  // As for olderThan (item 969).
-  if (maxSize !== undefined && parseSize(maxSize) === 0) {
-    throw new UserError(
-      `${configPath}: \`cache.retention.maxSize\` of 0 evicts every entry after every run`,
-    )
-  }
-  if (maxSize !== undefined && /^\d+$/.test(maxSize)) {
-    throw new UserError(
-      `${configPath}: \`cache.retention.maxSize\` '${maxSize}' reads as ${maxSize} bytes — give a unit (e.g. '${maxSize}MB', '${maxSize}GB')`,
-    )
-  }
-}
-
 /** A `plugins` entry that stands for no plugin: `undefined`, `null` or `false`. */
 export function isSkippedPlugin(p: unknown): p is undefined | null | false {
   return p === undefined || p === null || p === false