@rig-c/core 2.64.0 → 2.64.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rig-c/core",
-  "version": "2.64.0",
+  "version": "2.64.1",
   "description": "AI-authored 2D rigging and animation, verified before it is written. rigc compiles a rig spec into skeleton data in the Spine 4.3 format, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/cli/shared.ts

@@ -70,7 +70,7 @@ import { RepackError } from '../repack.ts';
 import { SplitError } from '../meshsplit.ts';
 import { SpineRuntimeError, SPINE_SIDE_ABSENT } from '../spine_side.ts';
 import type { CompileResult, DroppedState } from '../types.ts';
-import { StdoutWriteError } from './write_whole.ts';
+import { routeConsoleLogThroughWriteWhole, StdoutWriteError } from './write_whole.ts';
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path';
 
@@ -2968,6 +2968,8 @@ export function helpArgv(rest: readonly string[]): string[] | null {
  * always had, written once for both entries.
  */
 export function runCli(entry: CliEntry, argv: readonly string[]): void {
+  // Before anything prints: every line on stdout goes out whole, or is refused by name (issue #1493).
+  routeConsoleLogThroughWriteWhole();
   const docs = entryCommands(entry.linksRuntime);
   const known = docs.map((doc) => doc.name);
   const registered = Object.keys(entry.runs).sort();

package/src/cli/write_whole.ts

@@ -90,3 +90,35 @@ export function writeWhole(fd: number, text: string, plants: WriteWholePlants =
     wait(Math.min(2 ** (stalls - 1), STALL_WAIT_CAP_MS));
   }
 }
+
+/**
+ * The CLI's one stdout policy (issue #1493): `console.log` of this process,
+ * every call, through {@link writeWhole} on fd 1 — so the ~250 lines the
+ * commands print are written the way the guide's document is, and a
+ * non-blocking pipe gets all of them instead of the first ~64 KiB with exit 0.
+ * `runCli` installs it before anything prints, for both entries; calling it
+ * again changes nothing.
+ *
+ * ⚖️ One `writeWhole` per call, not a buffer flushed at exit or at a size:
+ * Bun's own `console.log` is synchronous per call on a blocking stdout — a
+ * line printed between two `console.error` lines lands between them under
+ * `2>&1`, to a file and to a pipe, on 1.2.0 and 1.4.2 (measured) — and a
+ * write per call keeps that order, keeps a long `render` or `check` printing
+ * as it goes, and leaves nothing behind for a `process.exit` to drop, or for a
+ * delegate's child, which writes to the same fd, to overtake. A buffer would
+ * have to answer all three and still reorders `2>&1`.
+ *
+ * The text is what Bun's `console.log` prints: the arguments joined by one
+ * space, a string as it is and anything else as `Bun.inspect` shows it, and a
+ * newline. Format directives (`%s` with a second argument) are not applied —
+ * every call in the CLI passes one string, so none has one to apply.
+ */
+let consoleLogRouted = false;
+
+export function routeConsoleLogThroughWriteWhole(): void {
+  if (consoleLogRouted) return;
+  consoleLogRouted = true;
+  console.log = (...args: unknown[]): void => {
+    writeWhole(1, `${args.map((arg) => (typeof arg === 'string' ? arg : Bun.inspect(arg))).join(' ')}\n`);
+  };
+}