@linzumi/cli 1.0.272 → 1.0.273

package/scripts/build-core-generation-overlap-parity-oracle.mjs

@@ -1,292 +0,0 @@
-// Spec: kandan/plans/2026-07-10-compute-nodes-rescript-commander-zero-ts-program.md
-// (M3 cluster 10, commander core) +
-// plans/2026-07-11-runner-generation-overlap-zero-downtime-updates.md
-// (the ported surface's own spec, CLI half #2981).
-// Relationship: Builds the TS-side PARITY ORACLE for the generation-overlap
-// slice of the ReScript commander port, the sibling of
-// build-pipeline-parity-oracle.mjs (cluster 9) and
-// build-session-registry-parity-oracle.mjs (cluster 6). The oracle bundles
-// the REAL TS generation-overlap module (src/generationOverlap.ts) - env
-// flag/readers, join-hello envelope, the supervisor<->child IPC codec, the
-// per-process overlap runtime, the dispatch gate's held-control queues,
-// and the cursor-persistence freeze - behind the cluster 1/2 one-shot
-// BATCH driver (a JSON array of cases on stdin, a JSON array of results on
-// stdout).
-//
-// Byte parity: envelopes, parsed/built IPC frames, and every scripted
-// trace entry are returned VERBATIM (the TS objects' own key order rides
-// JSON.stringify), so the ReScript side must reproduce field presence AND
-// insertion order exactly - the hello and IPC payloads are frozen wire
-// bytes. Determinism: nothing here reads env, clocks, or process.send -
-// env dicts are scripted per case, the runtime's send seam is injected,
-// and runtime/gate/freeze flows are driven by scripted op arrays.
-//
-// SECRETS: the oracle only ever sees the conformance suite's synthetic
-// payloads. The output is a local test artifact (.differential/ is
-// gitignored, never published) and stays unminified for debuggability.
-import { mkdir } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { build } from 'esbuild';
-
-const packageRoot = dirname(dirname(fileURLToPath(import.meta.url)));
-
-const driverSource = `
-import {
-  buildGenerationIpcMessage,
-  createGenerationDispatchGate,
-  createGenerationOverlapRuntime,
-  defaultGenerationStillbornWindowMs,
-  generationEpochEnvKey,
-  generationHandoffPidEnvKey,
-  generationHelloEnvelope,
-  generationOverlapFlagEnvKey,
-  generationStillbornWindowEnvKey,
-  generationTtyOwnerEnvKey,
-  isGenerationOverlapEnabled,
-  isGenerationTtyOwner,
-  parseGenerationIpcMessage,
-  readGenerationEpoch,
-  readGenerationHandoffPid,
-  resolveGenerationStillbornWindowMs,
-  withGenerationCursorFreeze,
-} from './src/generationOverlap';
-
-// Scripted runtime flow: hooks/log/send all trace-recording, ops drive the
-// REAL createGenerationOverlapRuntime.
-function runRuntimeCase(caseInput) {
-  const trace = [];
-  let sendOk = true;
-  const runtime = createGenerationOverlapRuntime({
-    env: caseInput.env,
-    log: (event, fields) => trace.push({ t: 'log', event, fields }),
-    send: (message) => {
-      trace.push({ t: 'send', message, ok: sendOk });
-      return sendOk;
-    },
-  });
-  if (runtime === undefined) {
-    return { created: false, trace };
-  }
-  if (caseInput.installHooks !== false) {
-    runtime.hooks.onOverlapDrain = (incomingEpoch) =>
-      trace.push({ t: 'hook.overlapDrain', incomingEpoch });
-    runtime.hooks.onOverlapAbort = () => trace.push({ t: 'hook.overlapAbort' });
-    runtime.hooks.onPinsReleased = (released) =>
-      trace.push({ t: 'hook.pinsReleased', released });
-    runtime.hooks.onPromote = () => trace.push({ t: 'hook.promote' });
-  }
-  for (const op of caseInput.ops ?? []) {
-    if (op.op === 'ipc') runtime.handleIpcMessage(op.value);
-    else if (op.op === 'beginDrain') runtime.beginOutgoingDrain(op.threadIds);
-    else if (op.op === 'send') {
-      const message = parseGenerationIpcMessage(op.message);
-      if (message === undefined) trace.push({ t: 'sendSkipped' });
-      else runtime.sendToSupervisor(message);
-    } else if (op.op === 'sendResult') sendOk = op.ok === true;
-    else if (op.op === 'pinOutgoing') runtime.outgoingPins.pin(op.threadId);
-    else if (op.op === 'releaseOutgoing')
-      trace.push({
-        t: 'released',
-        threadId: op.threadId,
-        released: runtime.outgoingPins.release(op.threadId),
-      });
-    else if (op.op === 'seams') {
-      runtime.requestUpdateDrain('parity-trigger');
-      trace.push({
-        t: 'seams',
-        cancel: runtime.cancelUpdateDrain('parity-reason'),
-        promote: runtime.promoteRunnerLock(),
-      });
-    } else if (op.op === 'query')
-      trace.push({
-        t: 'query',
-        epoch: runtime.epoch,
-        handoffFromPid: runtime.handoffFromPid ?? null,
-        outgoingDrainActive: runtime.outgoingDrainActive(),
-        pinsKnown: runtime.pinsKnown(),
-        role: runtime.currentRole() ?? null,
-        outgoingPins: runtime.outgoingPins.snapshot(),
-        incomingPins: runtime.incomingPins.snapshot(),
-      });
-  }
-  return { created: true, trace };
-}
-
-// Scripted gate flow: controls are plain JSON envelopes; the extractors
-// mirror the runner wiring (threadIdOf / controlTypeOf injected).
-function runGateCase(caseInput) {
-  const trace = [];
-  const runtime = createGenerationOverlapRuntime({
-    env: caseInput.env,
-    log: (event, fields) => trace.push({ t: 'log', event, fields }),
-    send: () => true,
-  });
-  if (runtime === undefined) {
-    return { created: false, trace };
-  }
-  const gate = createGenerationDispatchGate({
-    runtime,
-    threadIdOf: (control) =>
-      typeof control.threadId === 'string' ? control.threadId : undefined,
-    controlTypeOf: (control) =>
-      typeof control.type === 'string' ? control.type : '',
-    dispatch: (control, ack) => {
-      trace.push({
-        t: 'dispatched',
-        id: control.id ?? null,
-        threadId: typeof control.threadId === 'string' ? control.threadId : null,
-      });
-      ack();
-    },
-    log: (event, fields) => trace.push({ t: 'log', event, fields }),
-  });
-  for (const op of caseInput.ops ?? []) {
-    if (op.op === 'control') {
-      const control = op.control;
-      gate.dispatch(control, () =>
-        trace.push({ t: 'ack', id: control.id ?? null })
-      );
-    } else if (op.op === 'ipc') runtime.handleIpcMessage(op.value);
-    else if (op.op === 'beginDrain') runtime.beginOutgoingDrain(op.threadIds);
-    else if (op.op === 'dispatchUnpinned')
-      trace.push({ t: 'dispatchUnpinned', count: gate.dispatchUnpinned() });
-    else if (op.op === 'redispatch')
-      trace.push({ t: 'redispatch', count: gate.redispatchDeferredToIncoming() });
-    else if (op.op === 'held') {
-      const counts = gate.heldCounts();
-      trace.push({
-        t: 'held',
-        deferredToIncoming: counts.deferredToIncoming,
-        deferredPinned: counts.deferredPinned,
-      });
-    }
-  }
-  return { created: true, trace };
-}
-
-// Scripted cursor-freeze flow: the underlying store is trace-recording;
-// ops toggle the frozen predicate and drive the wrapped store.
-function runFreezeCase(caseInput) {
-  const trace = [];
-  let frozen = false;
-  const store = {
-    initial: (topic) => (caseInput.initialValues ?? {})[topic],
-    onAdvance: (topic, seq) => trace.push({ t: 'store.onAdvance', topic, seq }),
-    reset:
-      caseInput.hasReset === false
-        ? undefined
-        : (topic, seq) => trace.push({ t: 'store.reset', topic, seq }),
-    flush: () => trace.push({ t: 'store.flush' }),
-    epoch: () =>
-      typeof caseInput.storeEpoch === 'string' ? caseInput.storeEpoch : undefined,
-    adoptEpoch: (epoch) => {
-      trace.push({ t: 'store.adoptEpoch', epoch });
-      return caseInput.adoptResult === true;
-    },
-  };
-  const wrapped = withGenerationCursorFreeze(store, () => frozen);
-  for (const op of caseInput.ops ?? []) {
-    if (op.op === 'setFrozen') frozen = op.value === true;
-    else if (op.op === 'initial')
-      trace.push({ t: 'initial', topic: op.topic, value: wrapped.initial(op.topic) ?? null });
-    else if (op.op === 'advance') wrapped.onAdvance(op.topic, op.seq);
-    else if (op.op === 'reset') {
-      if (wrapped.reset === undefined) trace.push({ t: 'resetUnavailable' });
-      else wrapped.reset(op.topic, op.seq);
-    } else if (op.op === 'flush') wrapped.flush();
-    else if (op.op === 'epoch')
-      trace.push({ t: 'epoch', value: wrapped.epoch() ?? null });
-    else if (op.op === 'adoptEpoch')
-      trace.push({ t: 'adoptEpoch', result: wrapped.adoptEpoch(op.epoch) });
-  }
-  return { trace };
-}
-
-function runCase(input) {
-  switch (input.kind) {
-    case 'constants':
-      return {
-        flagKey: generationOverlapFlagEnvKey,
-        epochKey: generationEpochEnvKey,
-        handoffPidKey: generationHandoffPidEnvKey,
-        stillbornWindowKey: generationStillbornWindowEnvKey,
-        ttyOwnerKey: generationTtyOwnerEnvKey,
-        defaultStillbornWindowMs: defaultGenerationStillbornWindowMs,
-      };
-    case 'envRead': {
-      if (input.which === 'enabled') return isGenerationOverlapEnabled(input.env);
-      if (input.which === 'ttyOwner') return isGenerationTtyOwner(input.env);
-      if (input.which === 'epoch') return readGenerationEpoch(input.env) ?? null;
-      if (input.which === 'handoffPid')
-        return readGenerationHandoffPid(input.env) ?? null;
-      return resolveGenerationStillbornWindowMs(input.env);
-    }
-    case 'helloEnvelope':
-      return generationHelloEnvelope(input.env);
-    case 'parseIpc': {
-      const parsed = parseGenerationIpcMessage(input.value);
-      return parsed === undefined ? null : parsed;
-    }
-    case 'buildIpc': {
-      const parsed = parseGenerationIpcMessage(input.message);
-      return parsed === undefined ? { unparsable: true } : buildGenerationIpcMessage(parsed);
-    }
-    case 'runtimeRun':
-      return runRuntimeCase(input);
-    case 'gateRun':
-      return runGateCase(input);
-    case 'freezeRun':
-      return runFreezeCase(input);
-    default:
-      return { error: 'unknown case kind ' + String(input.kind) };
-  }
-}
-
-async function runBatch() {
-  const chunks = [];
-  for await (const chunk of process.stdin) chunks.push(chunk);
-  const cases = JSON.parse(Buffer.concat(chunks).toString('utf8'));
-  const results = [];
-  for (const testCase of cases) {
-    results.push(runCase(testCase));
-  }
-  process.stdout.write(JSON.stringify(results), () => {
-    process.exit(0);
-  });
-}
-
-runBatch().then(
-  () => {},
-  (error) => {
-    process.stderr.write(String(error && error.stack ? error.stack : error) + '\\n');
-    process.exit(1);
-  }
-);
-`;
-
-const outDir = join(packageRoot, '.differential');
-const outPath = join(outDir, 'core-generation-overlap-parity-oracle.mjs');
-
-await mkdir(outDir, { recursive: true });
-
-await build({
-  stdin: {
-    contents: driverSource,
-    resolveDir: packageRoot,
-    sourcefile: 'core-generation-overlap-parity-driver.ts',
-    loader: 'ts',
-  },
-  bundle: true,
-  platform: 'node',
-  target: 'node20',
-  format: 'esm',
-  outfile: outPath,
-  minify: false,
-  sourcemap: false,
-  legalComments: 'none',
-  logLevel: 'silent',
-  external: ['ws', 'undici', 'blessed', '@anthropic-ai/claude-agent-sdk'],
-});
-
-process.stdout.write(outPath + '\n');