@starci/hfs 4.11.22 → 4.12.2

package/emit/type-schema.d.mts

@@ -0,0 +1,29 @@
+/**
+ * JSON Schema (2020-12, the dialect of OpenAPI 3.1) of a TypeScript type, read from the type checker.
+ *
+ * Deterministic: properties, enum members and union members are sorted; object types with a name become components (`$ref`) once,
+ * in the order they are met. Undecidable types are errors naming the path inside the type, never `{}`: `any`, `unknown`, `never`,
+ * `object`, an unbound generic, a function, a class of the standard library (Date, Map, Set, Promise), a bigint, a symbol, an
+ * object type with no members and no index signature, and a union with `undefined` where a member could not simply be absent.
+ * Pure: takes the TypeScript module and a checker.
+ */
+import type TypeScript from 'typescript';
+/** A JSON Schema (2020-12) object; its keywords are the schema's own, so values stay open here. */
+export type JsonSchema = Record<string, unknown>;
+/** Sorts object keys at every depth, so equal schemas print equal text. */
+export declare function stable(value: unknown): unknown;
+/**
+ * A builder over one checker; `components` fills as named object types are met. A schema-backed caller has already proved
+ * the wire schema is closed, so its inferred empty object is meaningful (for example z.strictObject({})). Other callers
+ * retain the strict type-only rule: an empty object type alone proves no wire shape.
+ */
+export declare function createSchemaBuilder({ ts, checker, schemaBacked }: {
+    ts: typeof TypeScript;
+    checker: TypeScript.TypeChecker;
+    schemaBacked?: boolean;
+}): {
+    schemaOf: (type: TypeScript.Type, path: string) => JsonSchema;
+    components: () => {
+        [k: string]: JsonSchema | null;
+    };
+};

package/emit/type-schema.mjs

@@ -1,158 +1,171 @@
-/**
- * JSON Schema (2020-12, the dialect of OpenAPI 3.1) of a TypeScript type, read from the type checker.
- *
- * Deterministic: properties, enum members and union members are sorted; object types with a name become components (`$ref`) once,
- * in the order they are met. Undecidable types are errors naming the path inside the type, never `{}`: `any`, `unknown`, `never`,
- * `object`, an unbound generic, a function, a class of the standard library (Date, Map, Set, Promise), a bigint, a symbol, an
- * object type with no members and no index signature, and a union with `undefined` where a member could not simply be absent.
- * Pure: takes the TypeScript module and a checker.
- */
 import { byCodeUnit } from '../report/order.mjs';
-
 /** Sorts object keys at every depth, so equal schemas print equal text. */
 export function stable(value) {
-  if (Array.isArray(value)) return value.map(stable);
-  if (value && typeof value === 'object') return Object.fromEntries(Object.keys(value).sort(byCodeUnit).map((key) => [key, stable(value[key])]));
-  return value;
+    if (Array.isArray(value))
+        return value.map(stable);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.keys(value).sort(byCodeUnit).map((key) => [key, stable(value[key])]));
+    return value;
 }
-
 const canonical = (value) => JSON.stringify(stable(value));
-
 /**
  * A builder over one checker; `components` fills as named object types are met. A schema-backed caller has already proved
  * the wire schema is closed, so its inferred empty object is meaningful (for example z.strictObject({})). Other callers
  * retain the strict type-only rule: an empty object type alone proves no wire shape.
  */
 export function createSchemaBuilder({ ts, checker, schemaBacked = false }) {
-  const F = ts.TypeFlags;
-  const components = new Map();
-  const nameOf = new Map();
-  const taken = new Set();
-  const fail = (path, why) => {
-    throw new Error(`${path}: ${why}`);
-  };
-
-  const isLibrary = (symbol) => (symbol?.getDeclarations?.() ?? []).some((declaration) => /[\\/]typescript[\\/]lib[\\/]lib\./.test(declaration.getSourceFile().fileName));
-
-  const componentName = (type) => {
-    const symbol = type.aliasSymbol ?? type.getSymbol();
-    const written = checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
-    const base = (symbol && !/^__/.test(symbol.getName()) && !isLibrary(symbol) ? written : null);
-    if (!base) return null;
-    const clean = base.replace(/[^A-Za-z0-9._-]+/g, '.').replace(/^\.+|\.+$/g, '');
-    let name = clean;
-    for (let n = 2; taken.has(name); n += 1) name = `${clean}_${n}`;
-    taken.add(name);
-    return name;
-  };
-
-  const withoutUndefined = (type) => (type.isUnion() ? type.types.filter((member) => !(member.flags & (F.Undefined | F.Void))) : [type]);
-
-  /** The schema of a set of union members (no `undefined` among them). */
-  function membersSchema(members, path) {
-    const hasTrue = members.some((member) => member.flags & F.BooleanLiteral && checker.typeToString(member) === 'true');
-    const hasFalse = members.some((member) => member.flags & F.BooleanLiteral && checker.typeToString(member) === 'false');
-    const parts = [];
-    let rest = members;
-    if (hasTrue && hasFalse) {
-      rest = members.filter((member) => !(member.flags & F.BooleanLiteral));
-      parts.push({ type: 'boolean' });
+    const F = ts.TypeFlags;
+    const components = new Map();
+    const nameOf = new Map();
+    const taken = new Set();
+    const fail = (path, why) => {
+        throw new Error(`${path}: ${why}`);
+    };
+    const isLibrary = (symbol) => (symbol?.getDeclarations?.() ?? []).some((declaration) => /[\\/]typescript[\\/]lib[\\/]lib\./.test(declaration.getSourceFile().fileName));
+    const componentName = (type) => {
+        const symbol = type.aliasSymbol ?? type.getSymbol();
+        const written = checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope);
+        const base = (symbol && !/^__/.test(symbol.getName()) && !isLibrary(symbol) ? written : null);
+        if (!base)
+            return null;
+        const clean = base.replace(/[^A-Za-z0-9._-]+/g, '.').replace(/^\.+|\.+$/g, '');
+        let name = clean;
+        for (let n = 2; taken.has(name); n += 1)
+            name = `${clean}_${n}`;
+        taken.add(name);
+        return name;
+    };
+    const withoutUndefined = (type) => (type.isUnion() ? type.types.filter((member) => !(member.flags & (F.Undefined | F.Void))) : [type]);
+    /** The schema of a set of union members (no `undefined` among them). */
+    function membersSchema(members, path) {
+        const hasTrue = members.some((member) => member.flags & F.BooleanLiteral && checker.typeToString(member) === 'true');
+        const hasFalse = members.some((member) => member.flags & F.BooleanLiteral && checker.typeToString(member) === 'false');
+        const parts = [];
+        let rest = members;
+        if (hasTrue && hasFalse) {
+            rest = members.filter((member) => !(member.flags & F.BooleanLiteral));
+            parts.push({ type: 'boolean' });
+        }
+        const consts = [];
+        for (const member of rest) {
+            if (member.flags & (F.StringLiteral | F.NumberLiteral))
+                consts.push(member.value); // a string or number literal, by the flag check above
+            else if (member.flags & F.BooleanLiteral)
+                consts.push(checker.typeToString(member) === 'true');
+            else
+                parts.push(schemaOf(member, path));
+        }
+        if (consts.length) {
+            const sorted = [...consts].sort((a, b) => (String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0));
+            const kinds = new Set(sorted.map((item) => typeof item));
+            parts.push(kinds.size === 1 && !kinds.has('boolean') ? { enum: sorted, type: kinds.has('string') ? 'string' : 'number' } : { enum: sorted });
+        }
+        const unique = [...new Map(parts.map((part) => [canonical(part), part])).values()].sort((a, b) => (canonical(a) < canonical(b) ? -1 : 1));
+        return unique.length === 1 ? unique[0] : { anyOf: unique };
     }
-    const consts = [];
-    for (const member of rest) {
-      if (member.flags & (F.StringLiteral | F.NumberLiteral)) consts.push(member.value);
-      else if (member.flags & F.BooleanLiteral) consts.push(checker.typeToString(member) === 'true');
-      else parts.push(schemaOf(member, path));
+    function unionSchema(type, path) {
+        if (type.types.some((member) => member.flags & (F.Undefined | F.Void)))
+            fail(path, 'undefined is not a wire value here (declare the member optional instead)');
+        return membersSchema(type.types, path);
     }
-    if (consts.length) {
-      const sorted = [...consts].sort((a, b) => (String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0));
-      const kinds = new Set(sorted.map((item) => typeof item));
-      parts.push(kinds.size === 1 && !kinds.has('boolean') ? { enum: sorted, type: kinds.has('string') ? 'string' : 'number' } : { enum: sorted });
+    function objectSchema(type, path) {
+        if (checker.isArrayType(type) || checker.isTupleType(type)) {
+            if (checker.isTupleType(type)) {
+                const items = checker.getTypeArguments(type).map((item, index) => schemaOf(item, `${path}[${index}]`));
+                return { type: 'array', prefixItems: items, minItems: items.length, maxItems: items.length };
+            }
+            return { type: 'array', items: schemaOf(checker.getTypeArguments(type)[0], `${path}[]`) };
+        }
+        if (type.getCallSignatures().length || type.getConstructSignatures().length)
+            fail(path, 'a function is not a wire value');
+        const own = type.getSymbol();
+        if (own && !own.getName().startsWith('__') && isLibrary(own) && !/^(Readonly)?Array$/.test(own.getName()))
+            fail(path, `${own.getName()} is not a JSON value (send a string or a plain object type)`);
+        const existing = nameOf.get(type);
+        if (existing)
+            return { $ref: `#/components/schemas/${existing}` };
+        const name = componentName(type);
+        if (name) {
+            nameOf.set(type, name);
+            components.set(name, null);
+        }
+        const built = plainObject(type, path);
+        if (!name)
+            return built;
+        components.set(name, built);
+        return { $ref: `#/components/schemas/${name}` };
     }
-    const unique = [...new Map(parts.map((part) => [canonical(part), part])).values()].sort((a, b) => (canonical(a) < canonical(b) ? -1 : 1));
-    return unique.length === 1 ? unique[0] : { anyOf: unique };
-  }
-
-  function unionSchema(type, path) {
-    if (type.types.some((member) => member.flags & (F.Undefined | F.Void))) fail(path, 'undefined is not a wire value here (declare the member optional instead)');
-    return membersSchema(type.types, path);
-  }
-
-  function objectSchema(type, path) {
-    if (checker.isArrayType(type) || checker.isTupleType(type)) {
-      if (checker.isTupleType(type)) {
-        const items = checker.getTypeArguments(type).map((item, index) => schemaOf(item, `${path}[${index}]`));
-        return { type: 'array', prefixItems: items, minItems: items.length, maxItems: items.length };
-      }
-      return { type: 'array', items: schemaOf(checker.getTypeArguments(type)[0], `${path}[]`) };
+    function indexSchema(index, path) {
+        // z.strictObject({}) infers Record<string, never>: this index forbids keys rather than admitting a never-valued field.
+        if (schemaBacked && (index.type.flags & F.Never) !== 0)
+            return false;
+        return schemaOf(index.type, `${path}[key]`);
     }
-    if (type.getCallSignatures().length || type.getConstructSignatures().length) fail(path, 'a function is not a wire value');
-    const own = type.getSymbol();
-    if (own && !own.getName().startsWith('__') && isLibrary(own) && !/^(Readonly)?Array$/.test(own.getName())) fail(path, `${own.getName()} is not a JSON value (send a string or a plain object type)`);
-    const existing = nameOf.get(type);
-    if (existing) return { $ref: `#/components/schemas/${existing}` };
-    const name = componentName(type);
-    if (name) {
-      nameOf.set(type, name);
-      components.set(name, null);
+    function plainObject(type, path) {
+        const properties = {};
+        const required = [];
+        const props = [...checker.getPropertiesOfType(type)].sort((a, b) => (a.getName() < b.getName() ? -1 : 1));
+        for (const prop of props) {
+            const propType = checker.getTypeOfSymbol(prop);
+            const optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+            const members = propType.isUnion() ? propType.types : [propType];
+            const kept = withoutUndefined(propType);
+            if (kept.length === 0)
+                fail(`${path}.${prop.getName()}`, 'undefined is not a wire value');
+            const hadUndefined = kept.length < members.length;
+            const propertyPath = `${path}.${prop.getName()}`;
+            const schema = !hadUndefined ? schemaOf(propType, propertyPath) : kept.length === 1 ? schemaOf(kept[0], propertyPath) : membersSchema(kept, propertyPath);
+            properties[prop.getName()] = schema;
+            if (!optional && !hadUndefined)
+                required.push(prop.getName());
+        }
+        const index = checker.getIndexInfosOfType(type).find((info) => info.keyType.flags & F.String);
+        if (props.length === 0 && !index && !schemaBacked)
+            fail(path, 'an object type with no members and no index signature says nothing');
+        const result = { type: 'object' };
+        if (props.length)
+            result.properties = properties;
+        if (required.length)
+            result.required = required;
+        if (index)
+            result.additionalProperties = indexSchema(index, path);
+        return result;
     }
-    const built = plainObject(type, path);
-    if (!name) return built;
-    components.set(name, built);
-    return { $ref: `#/components/schemas/${name}` };
-  }
-
-  function indexSchema(index, path) {
-    // z.strictObject({}) infers Record<string, never>: this index forbids keys rather than admitting a never-valued field.
-    if (schemaBacked && (index.type.flags & F.Never) !== 0) return false;
-    return schemaOf(index.type, `${path}[key]`);
-  }
-
-  function plainObject(type, path) {
-    const properties = {};
-    const required = [];
-    const props = [...checker.getPropertiesOfType(type)].sort((a, b) => (a.getName() < b.getName() ? -1 : 1));
-    for (const prop of props) {
-      const propType = checker.getTypeOfSymbol(prop);
-      const optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
-      const members = propType.isUnion() ? propType.types : [propType];
-      const kept = withoutUndefined(propType);
-      if (kept.length === 0) fail(`${path}.${prop.getName()}`, 'undefined is not a wire value');
-      const hadUndefined = kept.length < members.length;
-      const propertyPath = `${path}.${prop.getName()}`;
-      const schema = !hadUndefined ? schemaOf(propType, propertyPath) : kept.length === 1 ? schemaOf(kept[0], propertyPath) : membersSchema(kept, propertyPath);
-      properties[prop.getName()] = schema;
-      if (!optional && !hadUndefined) required.push(prop.getName());
+    function schemaOf(type, path) {
+        const f = type.flags;
+        if (f & F.Any)
+            fail(path, 'any');
+        if (f & F.Unknown)
+            fail(path, 'unknown');
+        if (f & F.Never)
+            fail(path, 'never');
+        if (f & (F.Undefined | F.Void))
+            fail(path, 'undefined is not a wire value');
+        if (f & F.TypeParameter)
+            fail(path, 'an unbound generic');
+        if (f & F.NonPrimitive)
+            fail(path, 'object with no declared members');
+        if (f & (F.BigInt | F.BigIntLiteral | F.ESSymbol | F.UniqueESSymbol))
+            fail(path, 'bigint and symbol are not JSON values');
+        if (f & F.StringLiteral)
+            return { const: type.value };
+        if (f & F.NumberLiteral)
+            return { const: type.value };
+        if (f & F.BooleanLiteral)
+            return { const: checker.typeToString(type) === 'true' };
+        if (f & F.String)
+            return { type: 'string' };
+        if (f & F.Number)
+            return { type: 'number' };
+        if (f & F.Boolean)
+            return { type: 'boolean' };
+        if (f & F.Null)
+            return { type: 'null' };
+        if (type.isUnion())
+            return unionSchema(type, path);
+        if (f & F.Object || f & F.Intersection)
+            return objectSchema(type, path);
+        return fail(path, `a type this reader cannot express (${checker.typeToString(type)})`);
     }
-    const index = checker.getIndexInfosOfType(type).find((info) => info.keyType.flags & F.String);
-    if (props.length === 0 && !index && !schemaBacked) fail(path, 'an object type with no members and no index signature says nothing');
-    const result = { type: 'object' };
-    if (props.length) result.properties = properties;
-    if (required.length) result.required = required;
-    if (index) result.additionalProperties = indexSchema(index, path);
-    return result;
-  }
-
-  function schemaOf(type, path) {
-    const f = type.flags;
-    if (f & F.Any) fail(path, 'any');
-    if (f & F.Unknown) fail(path, 'unknown');
-    if (f & F.Never) fail(path, 'never');
-    if (f & (F.Undefined | F.Void)) fail(path, 'undefined is not a wire value');
-    if (f & F.TypeParameter) fail(path, 'an unbound generic');
-    if (f & F.NonPrimitive) fail(path, 'object with no declared members');
-    if (f & (F.BigInt | F.BigIntLiteral | F.ESSymbol | F.UniqueESSymbol)) fail(path, 'bigint and symbol are not JSON values');
-    if (f & F.StringLiteral) return { const: type.value };
-    if (f & F.NumberLiteral) return { const: type.value };
-    if (f & F.BooleanLiteral) return { const: checker.typeToString(type) === 'true' };
-    if (f & F.String) return { type: 'string' };
-    if (f & F.Number) return { type: 'number' };
-    if (f & F.Boolean) return { type: 'boolean' };
-    if (f & F.Null) return { type: 'null' };
-    if (type.isUnion()) return unionSchema(type, path);
-    if (f & F.Object || f & F.Intersection) return objectSchema(type, path);
-    return fail(path, `a type this reader cannot express (${checker.typeToString(type)})`);
-  }
-
-  return { schemaOf, components: () => Object.fromEntries([...components.entries()].sort(([a], [b]) => (a < b ? -1 : 1))) };
+    return { schemaOf, components: () => Object.fromEntries([...components.entries()].sort(([a], [b]) => (a < b ? -1 : 1))) };
 }

package/lint/bound-sys.cjs

@@ -1,26 +1,16 @@
-// bound-sys.cjs - the typed ESLint run never reads types from above the app root.
-//
-// `starci app lint` starts ESLint with `node --require <this file>` and STARCI_LINT_BOUND set to the app root. typescript-eslint's
-// projectService builds its server host from `tsserver.sys` (typescript/lib/tsserverlibrary) and exposes no host through
-// parserOptions, so without a bound a typed rule reads types from an enclosing repository's node_modules and judges the app
-// greener than its own install allows. Here `sys` of the app's own TypeScript is patched, in place and before ESLint loads
-// the parser, to answer only for paths inside the app root and TypeScript's own lib directory (the same bound a typed
-// tsc program of the app keeps). realpath is the identity, so an install junctioned inside the app
-// stays inside it. Nothing is patched when STARCI_LINT_BOUND is unset or TypeScript is not installed (nothing typed runs).
-'use strict'
-const path = require('node:path')
-const { createRequire } = require('node:module')
-
-const key = (p) => path.resolve(String(p)).replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase()
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require('node:path');
+const { createRequire } = require('node:module');
+const key = (p) => path.resolve(String(p)).replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
 /** Patch `sys` (the TypeScript system object) so it answers only for paths inside `bound` and `libDir`. Returns `sys`. */
 function bindSys(sys, bound, libDir) {
-    const roots = [key(bound), key(libDir)]
+    const roots = [key(bound), key(libDir)];
     const inside = (p) => {
-        const k = key(p)
-        return roots.some((root) => k === root || k.startsWith(`${root}/`))
-    }
-    const base = { ...sys }
+        const k = key(p);
+        return roots.some((root) => k === root || k.startsWith(`${root}/`));
+    };
+    const base = { ...sys };
     return Object.assign(sys, {
         fileExists: (p) => inside(p) && base.fileExists(p),
         directoryExists: (p) => inside(p) && base.directoryExists(p),
@@ -28,23 +18,27 @@ function bindSys(sys, bound, libDir) {
         getDirectories: (p) => (inside(p) ? base.getDirectories(p) : []),
         readDirectory: (dir, ext, exclude, include, depth) => (inside(dir) ? base.readDirectory(dir, ext, exclude, include, depth).filter(inside) : []),
         realpath: (p) => p,
-    })
+    });
 }
-
 /** Bind the `sys` of every TypeScript entry the typed lint loads, resolved from `from` (a side folder of the app). */
 function bindTypeScript(bound, from) {
-    const require_ = createRequire(path.join(from, 'package.json'))
+    const require_ = createRequire(path.join(from, 'package.json'));
     const bound_ = [];
     for (const entry of ['typescript/lib/tsserverlibrary', 'typescript']) {
-        let ts
-        try { ts = require_(entry) } catch { continue }
-        if (!ts?.sys || bound_.includes(ts.sys)) continue
-        bindSys(ts.sys, bound, path.dirname(ts.getDefaultLibFilePath({})))
-        bound_.push(ts.sys)
+        let ts;
+        try {
+            ts = require_(entry);
+        }
+        catch {
+            continue;
+        }
+        if (!ts?.sys || bound_.includes(ts.sys))
+            continue;
+        bindSys(ts.sys, bound, path.dirname(ts.getDefaultLibFilePath({})));
+        bound_.push(ts.sys);
     }
-    return bound_.length
+    return bound_.length;
 }
-
-if (process.env.STARCI_LINT_BOUND) bindTypeScript(process.env.STARCI_LINT_BOUND, process.cwd())
-
-module.exports = { bindSys, bindTypeScript }
+if (process.env['STARCI_LINT_BOUND'])
+    bindTypeScript(process.env['STARCI_LINT_BOUND'], process.cwd());
+module.exports = { bindSys, bindTypeScript };

package/lint/chunk.d.mts

@@ -0,0 +1,17 @@
+/**
+ * Split `items` into consecutive chunks whose summed command-line cost stays within `budget` characters. Order is kept. An item that alone
+ * exceeds the budget gets a chunk of its own (the spawn then fails visibly instead of being dropped).
+ */
+export declare function chunkByChars<T>(items: readonly T[], budget?: number): T[][];
+/** Run `task(chunk)` for every chunk with at most `limit` in flight. Results keep the chunk order; a thrown task becomes `{ error }`. */
+export declare function mapBounded<C, R>(chunks: readonly C[], task: (chunk: C, index: number) => Promise<R> | R, limit?: number): Promise<(R | {
+    error: string;
+})[]>;
+/** Merge the `{ results, error }` records of the chunks, in chunk order: every result kept, every distinct error reported. */
+export declare function mergeRuns<R>(runs: readonly ({
+    results?: readonly R[];
+    error?: string;
+} | undefined)[]): {
+    results?: R[];
+    error?: string;
+};

package/lint/chunk.mjs

@@ -1,46 +1,56 @@
 // chunk.mjs - split a long argument list under the command-line limit (Windows allows 32,767 characters) and run the parts with bounded concurrency.
-
 /** The command-line characters one argument costs: its length, a separating space and a pair of quotes. */
 const cost = (arg) => String(arg).length + 3;
-
 /**
  * Split `items` into consecutive chunks whose summed command-line cost stays within `budget` characters. Order is kept. An item that alone
  * exceeds the budget gets a chunk of its own (the spawn then fails visibly instead of being dropped).
  */
 export function chunkByChars(items, budget = 24_000) {
-  const chunks = [];
-  let current = [], used = 0;
-  for (const item of items) {
-    const size = cost(item);
-    if (current.length && used + size > budget) { chunks.push(current); current = []; used = 0; }
-    current.push(item);
-    used += size;
-  }
-  if (current.length) chunks.push(current);
-  return chunks;
+    const chunks = [];
+    let current = [], used = 0;
+    for (const item of items) {
+        const size = cost(item);
+        if (current.length && used + size > budget) {
+            chunks.push(current);
+            current = [];
+            used = 0;
+        }
+        current.push(item);
+        used += size;
+    }
+    if (current.length)
+        chunks.push(current);
+    return chunks;
 }
-
 /** Run `task(chunk)` for every chunk with at most `limit` in flight. Results keep the chunk order; a thrown task becomes `{ error }`. */
 export async function mapBounded(chunks, task, limit = 3) {
-  const out = new Array(chunks.length);
-  let next = 0;
-  const worker = async () => {
-    while (next < chunks.length) {
-      const at = next++;
-      try { out[at] = await task(chunks[at], at); } catch (error) { out[at] = { error: `could not start a lint child: ${String(error?.message ?? error)}` }; }
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(limit, chunks.length) }, worker));
-  return out;
+    const out = new Array(chunks.length);
+    let next = 0;
+    const worker = async () => {
+        while (next < chunks.length) {
+            const at = next++;
+            try {
+                out[at] = await task(chunks[at], at);
+            }
+            catch (error) {
+                out[at] = { error: `could not start a lint child: ${String(error?.message ?? error)}` };
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, chunks.length) }, worker));
+    return out;
 }
-
 /** Merge the `{ results, error }` records of the chunks, in chunk order: every result kept, every distinct error reported. */
 export function mergeRuns(runs) {
-  const results = [], errors = [];
-  let any = false;
-  for (const run of runs) {
-    if (run?.results) { results.push(...run.results); any = true; }
-    if (run?.error && !errors.includes(run.error)) errors.push(run.error);
-  }
-  return { ...(any ? { results } : {}), ...(errors.length ? { error: errors.join(' ; ') } : {}) };
+    const results = [], errors = [];
+    let any = false;
+    for (const run of runs) {
+        if (run?.results) {
+            results.push(...run.results);
+            any = true;
+        }
+        if (run?.error && !errors.includes(run.error))
+            errors.push(run.error);
+    }
+    return { ...(any ? { results } : {}), ...(errors.length ? { error: errors.join(' ; ') } : {}) };
 }