@nanobpm/urban 0.90.1 → 0.91.0

package/dist/cli.js

@@ -433,6 +433,30 @@ export async function main(argv) {
             return 1;
     }
 }
+/**
+ * Flush a Node writable stdio stream, resolving once its buffered writes have drained to the OS.
+ * `process.stdout`/`stderr` connected to a *pipe* is asynchronous in Node: `console.log` buffers
+ * the write and an immediate `process.exit()` abandons anything not yet handed to the OS, so a
+ * large reply (> the 64 KB pipe buffer on Linux) is silently truncated. Writing an empty chunk and
+ * waiting for its completion callback drains the prior writes first. Deno's stdio has no such
+ * `write(chunk, cb)` shape (its `console.log` is synchronous), so its absence is a no-op flush.
+ */
+function flushStream(stream) {
+    return new Promise((resolve) => {
+        if (!stream || typeof stream.write !== "function") {
+            resolve();
+            return;
+        }
+        stream.write("", () => resolve());
+    });
+}
+/** Drain both stdout and stderr before an explicit `process.exit` so no buffered output is lost. */
+async function flushStdio() {
+    const p = processGlobal();
+    if (!p)
+        return;
+    await Promise.all([flushStream(p.stdout), flushStream(p.stderr)]);
+}
 const proc = processGlobal();
 const deno = denoGlobal();
 const importMetaMain = Reflect.get(import.meta, "main");
@@ -450,11 +474,14 @@ if (importMetaMain === true || nodeMain) {
         else if (deno?.exit)
             deno.exit(code);
     };
-    main(argv).then((code) => {
-        if (code >= 0)
+    main(argv).then(async (code) => {
+        if (code >= 0) {
+            await flushStdio();
             exit(code);
-    }, (err) => {
+        }
+    }, async (err) => {
         console.error(errorMessage(err));
+        await flushStdio();
         exit(1);
     });
 }

package/dist/runtime/adapters/globals.d.ts

@@ -7,12 +7,23 @@ export interface DenoRuntimeGlobal {
     exit?: (code: number) => void;
     addSignalListener?: (sig: string, cb: () => void) => void;
 }
+/**
+ * The subset of a Node writable stdio stream (`process.stdout` / `process.stderr`) we depend on:
+ * a `write` that accepts a completion callback fired once the chunk has flushed to the OS. Deno's
+ * stdio streams do not expose this shape; callers treat its absence as "already synchronous, no
+ * flush needed" (see `flushStdio` in cli.ts).
+ */
+export interface WritableStdio {
+    write?: (chunk: string, cb: () => void) => void;
+}
 export interface ProcessRuntimeGlobal {
     argv?: string[];
     exit?: (code: number) => void;
     stdin?: AsyncIterable<Uint8Array | string> & {
         setEncoding?(encoding: string): void;
     };
+    stdout?: WritableStdio;
+    stderr?: WritableStdio;
     on?: (sig: string, cb: () => void) => void;
 }
 export declare function denoGlobal(): DenoRuntimeGlobal | undefined;