@khoavu882/doflow 2.0.0-beta.3 → 2.0.0-beta.4

package/src/runtime/lifecycle/{cli.ts → cli.js}

@@ -9,30 +9,30 @@
  * by the service and printed here, never thrown, so it cannot reach failure capture (NFR-005).
  */
 
-const { finishRuntime, usageError } = require('../cli-result.ts');
-const { projectRoot } = require('./root.ts');
-const followup = require('./followup.ts');
-const { StoreUnsafeError, StoreLockedError } = require('./event-store.ts');
-const { prepareStore } = require('./store-upkeep.ts');
-const { printSafe } = require('../mask.ts');
-const { buildOverview, initFeature, featureStatus } = require('./overview.ts');
-const { releaseFeatures, recordMerged } = require('./release.ts');
-const goal = require('./goal.ts');
+const { finishRuntime, usageError } = require('../cli-result.js');
+const { projectRoot } = require('./root.js');
+const followup = require('./followup.js');
+const { StoreUnsafeError, StoreLockedError } = require('./event-store.js');
+const { prepareStore } = require('./store-upkeep.js');
+const { printSafe } = require('../mask.js');
+const { buildOverview, initFeature, featureStatus } = require('./overview.js');
+const { releaseFeatures, recordMerged } = require('./release.js');
+const goal = require('./goal.js');
 
 const FOLLOWUP_ACTIONS = ['add', 'list', 'take', 'settle', 'promote', 'report'];
 const LIFECYCLE_ACTIONS = ['overview', 'init', 'release', 'status', 'merged'];
 const GOAL_ACTIONS = ['add', 'item', 'check', 'link', 'list', 'done'];
 /** The flags each goal action takes, besides --goal, --channel and --json; any other one given is a usage error. */
-const GOAL_FLAGS: Record<string, any> = {
+const GOAL_FLAGS                      = {
   add: ['statement', 'item'], item: ['text'], check: ['item', 'evidence', 'unmet'],
   link: ['slug', 'replace'], list: [], done: ['reason'],
 };
 
-function sourceText(source: any) {
+function sourceText(source     ) {
   return [source.kind, source.feature, source.taskClass, source.taskId, source.release, source.stage, source.ref].filter(Boolean).join(' ');
 }
 
-function followupLines(result: any) {
+function followupLines(result     ) {
   const lines = [];
   switch (result.action) {
     case 'add': for (const c of result.created) lines.push(`added ${c.id} (${sourceText(c.source)}): ${c.statement}`); break;
@@ -52,17 +52,17 @@ function followupLines(result: any) {
   return lines;
 }
 
-function overviewLines(r: any) {
+function overviewLines(r     ) {
   const lines = [`${r.mode} overview: ${r.followups.open} open follow-up${r.followups.open === 1 ? '' : 's'}, ${r.followups.shown} shown (release mode ${r.releaseMode}${r.integrationRef ? `, integration ref ${r.integrationRef}` : ''})`];
   for (const i of r.followups.items) lines.push(`  ${i.id}  (${sourceText(i.source)}, ${i.added})${i.promoted ? ` promoted to ${i.intent}` : ''}${i.pending === false ? ' settled this run' : ''}  ${i.statement}`);
   if (Array.isArray(r.failures)) {
     lines.push(`failures: ${r.failures.length} new or regressed`);
     for (const f of r.failures) lines.push(`  ${f.fp}  ${f.status}  x${f.count}  ${f.command} ${f.kind}${f.message ? `: ${f.message}` : ''}  (last seen ${f.lastSeen}, ${f.lastVersion})`);
   }
-  for (const g of r.goals) lines.push(`goal ${g.goal}: ${g.items.met}/${g.items.total} items met${g.proposeDone ? ' (propose done)' : ''}`, ...g.nudges.map((n: any) => `  ${n}`), ...(g.conflicts || []).map((c: any) => `  conflict: ${c.reason}${c.text ? ` (dropped text: ${JSON.stringify(c.text)})` : ''}`));
+  for (const g of r.goals) lines.push(`goal ${g.goal}: ${g.items.met}/${g.items.total} items met${g.proposeDone ? ' (propose done)' : ''}`, ...g.nudges.map((n     ) => `  ${n}`), ...(g.conflicts || []).map((c     ) => `  conflict: ${c.reason}${c.text ? ` (dropped text: ${JSON.stringify(c.text)})` : ''}`));
   const f = r.features;
   // The finished and awaiting-release lists only grow, so the text shows their bounded form.
-  const bounded = (key: any) => (r.featuresShown && r.featuresShown[key]) || { count: f[key].length, shown: f[key], more: 0 };
+  const bounded = (key     ) => (r.featuresShown && r.featuresShown[key]) || { count: f[key].length, shown: f[key], more: 0 };
   const names = [['finished', bounded('finished')], ['awaiting release', bounded('awaitingRelease')],
     ['in progress', { count: f.inProgress.length, shown: f.inProgress, more: 0 }], ['unknown', { count: f.unknown.length, shown: f.unknown, more: 0 }]].filter(([, b]) => b.count);
   for (const [label, b] of names) {
@@ -72,12 +72,12 @@ function overviewLines(r: any) {
   if (r.mode === 'maintain') lines.push(`pending: ${r.pending}`);
   if (r.note) lines.push(`note: ${r.note}`);
   if (r.conflicts.length) lines.push(`${r.conflicts.length} event conflict${r.conflicts.length === 1 ? '' : 's'} (see --json)`);
-  if (r.unreadable.length) lines.push(`unreadable event files: ${r.unreadable.map((n: any) => (r.unreadableReasons && r.unreadableReasons[n] ? `${n} (${r.unreadableReasons[n]})` : n)).join(', ')}`);
+  if (r.unreadable.length) lines.push(`unreadable event files: ${r.unreadable.map((n     ) => (r.unreadableReasons && r.unreadableReasons[n] ? `${n} (${r.unreadableReasons[n]})` : n)).join(', ')}`);
   for (const line of r.next) lines.push(`next: ${line}`);
   return lines;
 }
 
-function releaseLines(r: any) {
+function releaseLines(r     ) {
   const lines = [`${r.recorded ? 'recorded' : 'preview of'} release ${r.tag} (previous ${r.previousTag || 'none'}, bound ${r.bound})`];
   for (const c of r.candidates) if (!r.excluded.includes(c.slug)) lines.push(`  ships ${c.slug}  (${c.evidence}${c.ref ? ` ${c.ref}` : ''})`);
   if (r.added.length) lines.push(`added: ${r.added.join(', ')}`);
@@ -89,7 +89,7 @@ function releaseLines(r: any) {
   return lines;
 }
 
-function lifecycleLines(result: any) {
+function lifecycleLines(result     ) {
   switch (result.action) {
     case 'init': return [`${result.slug}: tracked ${result.tracked}${result.taken.length ? `, took ${result.taken.join(', ')}` : ''}${result.goal ? `, serves ${result.goal}` : ''}`, ...result.next];
     case 'status': return [`${result.slug}: ${result.status}${result.evidence ? ` (${result.evidence.kind}${result.evidence.ref ? ` ${result.evidence.ref}` : ''})` : ''}${result.release ? `, release ${result.release}` : ''}`, ...(result.note ? [`note: ${result.note}`] : [])];
@@ -99,12 +99,12 @@ function lifecycleLines(result: any) {
   }
 }
 
-function goalLines(r: any) {
-  const met = (g: any) => `${g.progress.met}/${g.progress.total} items met`;
+function goalLines(r     ) {
+  const met = (g     ) => `${g.progress.met}/${g.progress.total} items met`;
   switch (r.action) {
-    case 'add': return [`added goal ${r.goal}: ${r.outcome}`, ...r.items.map((i: any) => `  ${i.id}  ${i.text}`), ...r.next.map((n: any) => `next: ${n}`)];
-    case 'item': return [`added ${r.item.id} to ${r.goal}: ${r.item.text}`, ...r.next.map((n: any) => `next: ${n}`)];
-    case 'check': return [`${r.goal} ${r.item}: ${r.met ? 'met' : 'unmet'} (${r.evidence}); ${r.progress.met}/${r.progress.total} items met${r.proposeDone ? ' (propose done)' : ''}`, ...r.next.map((n: any) => `next: ${n}`)];
+    case 'add': return [`added goal ${r.goal}: ${r.outcome}`, ...r.items.map((i     ) => `  ${i.id}  ${i.text}`), ...r.next.map((n     ) => `next: ${n}`)];
+    case 'item': return [`added ${r.item.id} to ${r.goal}: ${r.item.text}`, ...r.next.map((n     ) => `next: ${n}`)];
+    case 'check': return [`${r.goal} ${r.item}: ${r.met ? 'met' : 'unmet'} (${r.evidence}); ${r.progress.met}/${r.progress.total} items met${r.proposeDone ? ' (propose done)' : ''}`, ...r.next.map((n     ) => `next: ${n}`)];
     case 'link': return [r.linked === 'already' ? `${r.slug} already serves ${r.goal}` : `${r.slug} now serves ${r.goal}${r.replaced ? ` (was ${r.replaced})` : ''}`];
     case 'done': return [`${r.goal} is done${r.unmet.length ? ` with ${r.unmet.join(', ')} unmet: ${r.reason}` : ''}`];
     default: {
@@ -119,13 +119,13 @@ function goalLines(r: any) {
         for (const c of g.conflicts || []) lines.push(`  conflict: ${c.reason}${c.text ? ` (dropped text: ${JSON.stringify(c.text)})` : ''}`);
       }
       if (r.reason) lines.push(`note: ${r.reason}`);
-      return [...lines, ...r.next.map((n: any) => `next: ${n}`)];
+      return [...lines, ...r.next.map((n     ) => `next: ${n}`)];
     }
   }
 }
 
 /** Prints a result and sets the exit status; shared by the verbs. */
-function emit(result: any, json: any, lines: any) {
+function emit(result     , json     , lines     ) {
   if (json) console.log(JSON.stringify(result, null, 2));
   else if (result.ok === false) console.log(printSafe(`${result.finding}: ${result.message}`));
   else for (const line of lines(result)) console.log(printSafe(line));
@@ -133,10 +133,10 @@ function emit(result: any, json: any, lines: any) {
 }
 
 /** Runs `fn`, turning a caller mistake into the exit-2 usage result and a lock that never came into the `store-locked` refusal. */
-function guarded(verb: any, action: any, json: any, fn: any) {
+function guarded(verb     , action     , json     , fn     ) {
   try {
     return fn();
-  } catch (error: any) {
+  } catch (error     ) {
     if (error instanceof followup.FollowupUsageError || error instanceof StoreUnsafeError) return usageError(verb, error.message, json);
     if (error instanceof StoreLockedError) return emit({ ok: false, action, finding: 'store-locked', message: error.message }, json, () => []);
     throw error;
@@ -144,13 +144,13 @@ function guarded(verb: any, action: any, json: any, fn: any) {
 }
 
 /** Runs the store upkeep for one invocation and prints its lines to stderr; returns its refusal, or null. */
-function upkeep(verb: any, action: any, root: any) {
+function upkeep(verb     , action     , root     ) {
   const prepared = prepareStore(root);
   for (const line of prepared.lines) console.error(printSafe(`doflow ${verb}: ${line}`));
   return prepared.ok ? null : { ok: false, action, finding: prepared.finding, message: prepared.message };
 }
 
-function refuseGlobal(verb: any, global: any, json: any) {
+function refuseGlobal(verb     , global     , json     ) {
   return global ? usageError(verb, `${verb} works on the project store at the repository root and refuses -g`, json) : null;
 }
 
@@ -162,7 +162,7 @@ function refuseGlobal(verb: any, global: any, json: any) {
  * @param {Object} options.flags parsed flag values: statement, stage, source, taskClass, taskId, release,
  *   batch, channel, state, ids, as, reason, evidence, title; for report also file, stdin, text, feature
  */
-function handleFollowupCommand({ action, cwd, global = false, slug = null, json = false, flags = {} }: any = {}) {
+function handleFollowupCommand({ action, cwd, global = false, slug = null, json = false, flags = {} }      = {}) {
   const refused = refuseGlobal('followup', global, json);
   if (refused !== null) return refused;
   return guarded('followup', action, json, () => {
@@ -213,7 +213,7 @@ function handleFollowupCommand({ action, cwd, global = false, slug = null, json
  * @param {Object} options.flags parsed flag values: take, intent, goal, maintain, since, tag, confirm,
  *   feature, exclude, reason, channel
  */
-function handleLifecycleCommand({ action, cwd, global = false, slug = null, json = false, flags = {} }: any = {}) {
+function handleLifecycleCommand({ action, cwd, global = false, slug = null, json = false, flags = {} }      = {}) {
   const refused = refuseGlobal('lifecycle', global, json);
   if (refused !== null) return refused;
   return guarded('lifecycle', action === undefined ? 'overview' : action, json, () => {
@@ -246,7 +246,7 @@ function handleLifecycleCommand({ action, cwd, global = false, slug = null, json
  * @param {Object} options.flags parsed flag values: goal, statement, item (a list), text, evidence, unmet,
  *   replace, reason, channel; `--slug` arrives as `slug`
  */
-function handleGoalCommand({ action, cwd, global = false, slug = null, json = false, flags = {} }: any = {}) {
+function handleGoalCommand({ action, cwd, global = false, slug = null, json = false, flags = {} }      = {}) {
   const refused = refuseGlobal('goal', global, json);
   if (refused !== null) return refused;
   return guarded('goal', action, json, () => {

package/src/runtime/lifecycle/{event-store.ts → event-store.js}

@@ -17,9 +17,9 @@
 const nodeFs = require('node:fs');
 const path = require('node:path');
 const crypto = require('node:crypto');
-const { acquireLock } = require('../task-state.ts');
-const { printSafe } = require('../mask.ts');
-const { foldInto, finalize, applyEvent } = require('./fold.ts');
+const { acquireLock } = require('../task-state.js');
+const { printSafe } = require('../mask.js');
+const { foldInto, finalize, applyEvent } = require('./fold.js');
 
 const LIFECYCLE_REL = path.join('.doflow', 'state', 'lifecycle');
 const EVENTS_REL = path.join(LIFECYCLE_REL, 'events');
@@ -39,39 +39,39 @@ const MAX_EVENT_BYTES = 256 * 1024;
 const MAX_JOURNAL_BYTES = 16 * 1024 * 1024;
 const READ_CHUNK = 64 * 1024;
 /** The decision register's channel vocabulary: who the caller says is acting. */
-const CHANNEL_BY: Record<string, string> = { question: 'user', gate: 'user', prompt: 'user', default: 'agent' };
+const CHANNEL_BY                         = { question: 'user', gate: 'user', prompt: 'user', default: 'agent' };
 
-function eventsDir(root: string): string { return path.join(root, EVENTS_REL); }
-function lockTarget(root: string): string { return path.join(root, EVENTS_REL); }
+function eventsDir(root        )         { return path.join(root, EVENTS_REL); }
+function lockTarget(root        )         { return path.join(root, EVENTS_REL); }
 
 /** @param {string} [channel] defaults to `default` @returns {'user'|'agent'|null} null for an unknown channel */
-function byFromChannel(channel: string = 'default'): string | null { return CHANNEL_BY[channel] ?? null; }
+function byFromChannel(channel         = 'default')                { return CHANNEL_BY[channel] ?? null; }
 
 /** `length` random characters of the lowercase Crockford base32 alphabet. */
-function randomChars(length: number): string {
+function randomChars(length        )         {
   const bytes = crypto.randomBytes(length);
   let out = '';
   for (const b of bytes) out += ALPHABET[b % 32];
   return out;
 }
 
-function idFor(at: string, random: (n: number) => string): string { return `${at.replace(/[-:.]/g, '')}-${random(6)}`; }
+function idFor(at        , random                       )         { return `${at.replace(/[-:.]/g, '')}-${random(6)}`; }
 
 /** Synchronous sleep without spinning, as the store lock waits. */
-function sleep(ms: number): void {
+function sleep(ms        )       {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
 
 /** DEC-045: `at` is a strict UTC timestamp that is a real instant, so year 10000 and "+275760-..." never parse. */
 const STRICT_AT = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
-function isStrictAt(at: any): boolean {
+function isStrictAt(at     )          {
   if (typeof at !== 'string' || !STRICT_AT.test(at)) return false;
   const ms = Date.parse(at);
   return Number.isFinite(ms) && new Date(ms).toISOString() === at;
 }
 
 /** An IC-002 envelope whose `at` is strict and equals the time prefix of its file id. */
-function isEnvelope(event: any, idFromName: string): boolean {
+function isEnvelope(event     , idFromName        )          {
   return event && typeof event === 'object' && event.v === 1 && event.id === idFromName
     && typeof event.type === 'string' && typeof event.by === 'string'
     && isStrictAt(event.at) && idFromName.startsWith(`${event.at.replace(/[-:.]/g, '')}-`)
@@ -84,7 +84,7 @@ class StoreUnsafeError extends Error {}
 /** The store lock could not be taken in time; the verb refuses with `store-locked` and writes nothing. */
 class StoreLockedError extends Error {}
 
-function assertStoreFolders(root: string, fsImpl: any): void {
+function assertStoreFolders(root        , fsImpl     )       {
   for (const rel of [path.join('.doflow'), path.join('.doflow', 'state'), LIFECYCLE_REL, EVENTS_REL]) {
     const folder = path.join(root, rel);
     let link = false;
@@ -99,9 +99,9 @@ function assertStoreFolders(root: string, fsImpl: any): void {
  * and again by `O_NOFOLLOW` where the platform has it; `O_NONBLOCK` keeps a FIFO swapped in after
  * the `lstat` from blocking the open, and the descriptor is checked again before any read.
  */
-function readEventFile(fsImpl: any, file: string, maxBytes: number = MAX_EVENT_BYTES): { reason?: string; text?: string } {
+function readEventFile(fsImpl     , file        , maxBytes         = MAX_EVENT_BYTES)                                     {
   const flags = nodeFs.constants;
-  let fd: number | undefined;
+  let fd                    ;
   try {
     if (!fsImpl.lstatSync(file).isFile()) return { reason: 'not a regular file' };
     fd = fsImpl.openSync(file, flags.O_RDONLY | (flags.O_NOFOLLOW || 0) | (flags.O_NONBLOCK || 0));
@@ -110,7 +110,7 @@ function readEventFile(fsImpl: any, file: string, maxBytes: number = MAX_EVENT_B
     const tooLarge = { reason: `larger than ${maxBytes / 1024} KiB` };
     if (st.size > maxBytes) return tooLarge;
     // Read in chunks up to one byte past the cap, so a file that grew after the fstat is still caught.
-    const chunks: Buffer[] = [];
+    const chunks           = [];
     let length = 0;
     while (length <= maxBytes) {
       const chunk = Buffer.allocUnsafe(Math.min(READ_CHUNK, maxBytes + 1 - length));
@@ -120,7 +120,7 @@ function readEventFile(fsImpl: any, file: string, maxBytes: number = MAX_EVENT_B
       length += n;
     }
     return length > maxBytes ? tooLarge : { text: Buffer.concat(chunks, length).toString('utf8') };
-  } catch (error: any) {
+  } catch (error     ) {
     return { reason: error.code || 'unreadable' };
   } finally {
     if (fd !== undefined) { try { fsImpl.closeSync(fd); } catch { /* read already done */ } }
@@ -128,16 +128,16 @@ function readEventFile(fsImpl: any, file: string, maxBytes: number = MAX_EVENT_B
 }
 
 /** The event with every string print-safe; a report excerpt is multi-line by design, so it keeps its line breaks (cli.js removes them when printing). */
-function cleanEvent(event: any): any {
+function cleanEvent(event     )      {
   const clean = printSafe(event);
   if (typeof event.data.excerpt === 'string') clean.data.excerpt = printSafe(event.data.excerpt, { keepLineBreaks: true });
   return clean;
 }
 
 /** Whether `name` is `<EVENT_ID>.json`. */
-function isEventName(name: string): boolean {
+function isEventName(name        )          {
   const match = /^(.+)\.json$/.exec(name);
-  return Boolean(match) && EVENT_ID.test((match as RegExpExecArray)[1]);
+  return Boolean(match) && EVENT_ID.test((match                   )[1]);
 }
 
 /**
@@ -146,39 +146,39 @@ function isEventName(name: string): boolean {
  * pending; a pending name that is not an event file name is ignored.
  * @returns {{generation: string|null, pending: string[]}}
  */
-function readJournal(root: string, fsImpl: any = nodeFs): { generation: string | null; pending: string[] } {
+function readJournal(root        , fsImpl      = nodeFs)                                                   {
   const read = readEventFile(fsImpl, path.join(root, JOURNAL_REL), MAX_JOURNAL_BYTES);
-  let journal: any;
-  try { journal = read.reason ? null : JSON.parse(read.text as string); } catch { journal = null; }
+  let journal     ;
+  try { journal = read.reason ? null : JSON.parse(read.text          ); } catch { journal = null; }
   if (!journal || typeof journal !== 'object' || journal.v !== 1) return { generation: null, pending: [] };
   return {
     generation: typeof journal.generation === 'string' ? journal.generation : null,
-    pending: Array.isArray(journal.pending) ? journal.pending.filter((name: any) => typeof name === 'string' && isEventName(name)) : [],
+    pending: Array.isArray(journal.pending) ? journal.pending.filter((name     ) => typeof name === 'string' && isEventName(name)) : [],
   };
 }
 
 /** One pass over the event files, leaving out the names in `hidden`. */
-function readEventFiles(root: string, fsImpl: any, hidden: Set<string>, shouldStop?: () => boolean): any {
+function readEventFiles(root        , fsImpl     , hidden             , shouldStop                )      {
   const dir = eventsDir(root);
-  let names: string[];
+  let names          ;
   try {
     names = fsImpl.readdirSync(dir);
-  } catch (error: any) {
+  } catch (error     ) {
     if (error.code === 'ENOENT' || error.code === 'ENOTDIR') return { events: [], unreadable: [], reasons: {} };
     throw error;
   }
   const orderedNames = names.sort();
   if (shouldStop?.()) return { events: [], unreadable: [], reasons: {}, incomplete: true };
-  const events: any[] = [];
-  const unreadable: string[] = [];
-  const reasons: Record<string, string> = {};
+  const events        = [];
+  const unreadable           = [];
+  const reasons                         = {};
   for (const name of orderedNames) {
     if (shouldStop?.()) return { events: [], unreadable: [], reasons: {}, incomplete: true };
     if (!isEventName(name) || hidden.has(name)) continue;
     const read = readEventFile(fsImpl, path.join(dir, name));
     if (read.reason) { unreadable.push(name); reasons[name] = read.reason; continue; }
     try {
-      const event = JSON.parse(read.text as string);
+      const event = JSON.parse(read.text          );
       // Someone else's file is shown as it is read, so its text is made print-safe here (stored bytes are not changed).
       if (isEnvelope(event, name.slice(0, -'.json'.length))) events.push(cleanEvent(event)); else unreadable.push(name);
     } catch {
@@ -204,7 +204,7 @@ function readEventFiles(root: string, fsImpl: any, hidden: Set<string>, shouldSt
  * StoreLockedError.
  * @returns {{events: Object[], unreadable: string[], reasons: Object<string,string>, incomplete?: true}}
  */
-function readEvents(root: string, { fsImpl = nodeFs, lockFallback = true, shouldStop }: any = {}): any {
+function readEvents(root        , { fsImpl = nodeFs, lockFallback = true, shouldStop }      = {})      {
   assertStoreFolders(root, fsImpl);
   if (shouldStop?.()) return { events: [], unreadable: [], reasons: {}, incomplete: true };
   for (let attempt = 1; attempt <= STABLE_READS; attempt += 1) {
@@ -220,10 +220,10 @@ function readEvents(root: string, { fsImpl = nodeFs, lockFallback = true, should
   }
   if (shouldStop?.()) return { events: [], unreadable: [], reasons: {}, incomplete: true };
   if (!lockFallback) throw new StoreLockedError('Lifecycle event store changed during a read; a stable snapshot was unavailable.');
-  let release: () => void;
+  let release            ;
   try {
     release = acquireLock(fsImpl, lockTarget(root));
-  } catch (error: any) {
+  } catch (error     ) {
     if (/^Could not lock/.test(error.message || '')) throw new StoreLockedError(`${error.message} Nothing was written.`);
     throw error;
   }
@@ -240,20 +240,20 @@ function readEvents(root: string, { fsImpl = nodeFs, lockFallback = true, should
  * @param {{hasBody?: Function, fsImpl?: Object}} [options]
  * @returns {Object} the fold result (see fold.js) plus `unreadable`
  */
-function readFold(root: string, { fsImpl = nodeFs, hasBody, now = new Date() }: any = {}): any {
+function readFold(root        , { fsImpl = nodeFs, hasBody, now = new Date() }      = {})      {
   const { events, unreadable, reasons } = readEvents(root, { fsImpl });
   return { ...finalize(foldInto(events, { now }), { hasBody }), unreadable, unreadableReasons: reasons };
 }
 
 /** Picks a free, valid id for each draft before any file is created, so a batch is all or nothing. */
-function allocateIds(fsImpl: any, dir: string, stamped: any[], random: (n: number) => string): string[] | null {
-  const chosen = new Set<string>();
-  const ids: string[] = [];
+function allocateIds(fsImpl     , dir        , stamped       , random                       )                  {
+  const chosen = new Set        ();
+  const ids           = [];
   for (const { at, id } of stamped) {
-    let candidate: string | null = id;
+    let candidate                = id;
     for (let attempt = 0; attempt <= COLLISION_RETRIES; attempt += 1) {
       if (attempt > 0) candidate = idFor(at, random);
-      if (EVENT_ID.test(candidate as string) && !chosen.has(candidate as string) && !fsImpl.existsSync(path.join(dir, `${candidate}.json`))) break;
+      if (EVENT_ID.test(candidate          ) && !chosen.has(candidate          ) && !fsImpl.existsSync(path.join(dir, `${candidate}.json`))) break;
       candidate = null;
     }
     if (!candidate) return null;
@@ -276,17 +276,17 @@ function allocateIds(fsImpl: any, dir: string, stamped: any[], random: (n: numbe
  *   conflict, with its own `code` in `conflict.code`), `id-collision`, `invalid-id` (the clock or
  *   the random source cannot produce an id of the IC-001 shape) and `store-locked`.
  */
-function appendEvents(root: string, drafts: any[], { now = new Date(), fsImpl = nodeFs, random = randomChars }: any = {}): any {
+function appendEvents(root        , drafts       , { now = new Date(), fsImpl = nodeFs, random = randomChars }      = {})      {
   const dir = eventsDir(root);
   // A write that would be refused leaves nothing behind, not even the store folder (IC-001: created
   // on the first write), so the check runs once before the folder and the lock and again under the lock.
   const early = planEvents(root, drafts, { now, fsImpl, random });
   if (early.refused) return early.refused;
   fsImpl.mkdirSync(dir, { recursive: true });
-  let release: () => void;
+  let release            ;
   try {
     release = acquireLock(fsImpl, lockTarget(root));
-  } catch (error: any) {
+  } catch (error     ) {
     if (/^Could not lock/.test(error.message || '')) return { ok: false, finding: 'store-locked', message: `${error.message} Nothing was written.` };
     throw error;
   }
@@ -295,8 +295,8 @@ function appendEvents(root: string, drafts: any[], { now = new Date(), fsImpl =
     if (refused) return refused;
     const ids = allocateIds(fsImpl, dir, stamped, random);
     if (!ids) return { ok: false, finding: 'id-collision', written: [], message: `could not find a free event id after ${COLLISION_RETRIES} tries. Nothing was written.` };
-    const written: any[] = [];
-    stamped.forEach(({ draft, at }: any, index: number) => {
+    const written        = [];
+    stamped.forEach(({ draft, at }     , index        ) => {
       const event = { v: 1, id: ids[index], type: draft.type, at, by: draft.by, data: draft.data };
       const file = path.join(dir, `${event.id}.json`);
       // The ids are free under the lock; the exclusive create only guards against a writer outside it.
@@ -310,15 +310,15 @@ function appendEvents(root: string, drafts: any[], { now = new Date(), fsImpl =
 }
 
 /** Folds the store, stamps each draft and applies it; `refused` is the whole call's refusal when any is illegal. */
-function planEvents(root: string, drafts: any[], { now, fsImpl, random }: any): any {
+function planEvents(root        , drafts       , { now, fsImpl, random }     )      {
   const state = foldInto(readEvents(root, { fsImpl }).events, { now });
   // An event dated far ahead is not in the fold (DEC-045), so it cannot push this stamp forward.
   let floor = state.newestAt === null ? -Infinity : state.newestAt + 1;
-  const stamped: any[] = [];
+  const stamped        = [];
   for (const draft of drafts) {
     const atMs = Math.max(now.getTime(), floor);
     floor = atMs + 1;
-    let at: string | null;
+    let at               ;
     try { at = new Date(atMs).toISOString(); } catch { at = null; }
     // The dry run draws the id the write will try first, so a conflict names the event it refuses.
     const id = at && isStrictAt(at) ? idFor(at, random) : null;