@linxiraos/pi-utils 1.4.6 → 1.4.7

package/CHANGELOG.md

@@ -1,8 +1,18 @@
 ## [Unreleased]
 
+## [1.4.7] - 2026-10-30
+
+- Synced with upstream OMP v18.14.0; no package-specific user-visible changes.
+
 ## [1.4.6] - 2026-10-28
 
-- Released as part of Zeta 1.4.6; no package-specific user-visible changes.
+### Added
+
+- Added `logger.withContext(fields, fn)` to attach contextual fields to all records produced during a function and its asynchronous work, plus `logger.withoutContext(fn)` for work that should not inherit caller context.
+
+### Fixed
+
+- Fixed `untilAborted` so promises passed to an already-aborted signal are still observed, preventing later rejections from being reported as unhandled.
 
 ## [1.4.5] - 2026-10-28
 

package/README.md

@@ -29,7 +29,7 @@ Import from the root barrel or per-module subpaths (`@linxiraos/pi-utils/<module
 bun add @linxiraos/pi-utils
 ```
 
-Ships TypeScript source directly (no build step); requires Bun ≥ 1.3.14.
+Ships TypeScript source directly (no build step); requires Bun ≥ 1.4.4.
 
 ## References
 

package/dist/types/abortable.d.ts

@@ -16,7 +16,8 @@ export declare class AbortError extends Error {
 export declare function abortableSource<T>(stream: ReadableStream<T>, signal?: AbortSignal): AsyncGenerator<T>;
 /**
  * Runs a promise-returning function (`pr`). If the given AbortSignal is aborted before or during
- * execution, the promise is rejected with a standard error.
+ * execution, the promise is rejected with a standard error. A promise passed directly stays
+ * observed, so its later rejection is never unhandled.
  *
  * @param signal - Optional AbortSignal to cancel the operation
  * @param pr - Function returning a promise to run

package/dist/types/index.d.ts

@@ -10,7 +10,6 @@ export * from "./file-lock.js";
 export * from "./format.js";
 export * from "./frontmatter.js";
 export * from "./fs-error.js";
-export * from "./fs-open.js";
 export * from "./incoming-json.js";
 export * from "./json.js";
 export * from "./json-parse.js";

package/dist/types/logger.d.ts

@@ -11,6 +11,20 @@ export interface LogEvent {
 export type LogSink = (event: LogEvent) => void;
 /** Register an out-of-band log sink and return a disposer. */
 export declare function registerLogSink(sink: LogSink): () => void;
+/**
+ * Run `fn` with `context`'s fields on every record logged while it runs,
+ * including from the promises, timers and callbacks it starts. A nested call
+ * replaces the enclosing context, as a subagent's session replaces its
+ * parent's; a field passed to the log call itself wins. Fields are read as each
+ * record is written, so a getter stays current.
+ */
+export declare function withContext<T>(context: Readonly<Record<string, unknown>>, fn: () => T): T;
+/**
+ * Run `fn` outside any {@link withContext}: for process-wide work started on
+ * behalf of one caller, such as a shared server's read loop, whose later
+ * records belong to no single caller.
+ */
+export declare function withoutContext<T>(fn: () => T): T;
 /**
  * Write buffered file records to disk now. The file transport batches records
  * (one write per second or per 64 KiB) and writes `warn`/`error` records

package/dist/types/ports.d.ts

@@ -3,8 +3,9 @@
  *
  * OMP installs on the same machine use 30141/30142/3847, and common developer
  * tools squat on 3000/8080/8787/3847. Zeta therefore owns a dedicated block:
- * three uncommon ports, at least two apart, so a side-by-side OMP install and
- * unrelated services cannot take the gateway or the stats dashboard away.
+ * uncommon ports, at least two apart, so a side-by-side OMP install and
+ * unrelated services cannot take the gateway, stats dashboard, or browser
+ * relay away.
  *
  * Every default in the repository derives from these constants. The standalone
  * Electron shell (`desktop/src/main.ts`, not a Bun workspace package) carries
@@ -13,3 +14,4 @@
 export declare const ZETA_WEB_PORT = 43141;
 export declare const ZETA_GATEWAY_PORT = 43143;
 export declare const ZETA_STATS_PORT = 43147;
+export declare const ZETA_BROWSER_RELAY_PORT = 43153;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@linxiraos/pi-utils",
-	"version": "1.4.6",
+	"version": "1.4.7",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"utilities",
@@ -54,12 +54,12 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@linxiraos/pi-natives": "1.4.6"
+		"@linxiraos/pi-natives": "1.4.7"
 	},
 	"devDependencies": {
-		"@types/bun": "1.4.3"
+		"@types/bun": "1.4.4"
 	},
 	"engines": {
-		"bun": ">=1.3.14"
+		"bun": ">=1.4.4"
 	}
 }

package/src/abortable.ts

@@ -60,7 +60,8 @@ export async function* abortableSource<T>(stream: ReadableStream<T>, signal?: Ab
 
 /**
  * Runs a promise-returning function (`pr`). If the given AbortSignal is aborted before or during
- * execution, the promise is rejected with a standard error.
+ * execution, the promise is rejected with a standard error. A promise passed directly stays
+ * observed, so its later rejection is never unhandled.
  *
  * @param signal - Optional AbortSignal to cancel the operation
  * @param pr - Function returning a promise to run
@@ -71,7 +72,10 @@ export function untilAborted<T>(
 	pr: Promise<T> | (() => Promise<T>),
 ): Promise<T> {
 	if (!signal) return typeof pr === "function" ? pr() : pr;
-	if (signal.aborted) return Promise.reject(new AbortError(signal));
+	if (signal.aborted) {
+		if (typeof pr !== "function") void pr.catch(() => {});
+		return Promise.reject(new AbortError(signal));
+	}
 
 	const { promise, resolve, reject } = Promise.withResolvers<T>();
 	const onAbort = () => reject(new AbortError(signal));

package/src/index.ts

@@ -10,7 +10,6 @@ export * from "./file-lock";
 export * from "./format";
 export * from "./frontmatter";
 export * from "./fs-error";
-export * from "./fs-open";
 export * from "./incoming-json";
 export * from "./json";
 export * from "./json-parse";

package/src/logger/rotating-file.ts

@@ -3,7 +3,6 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { localDay } from "../dirs";
-import { openCloexecSync } from "../fs-open";
 
 /** Write batching for {@link RotatingFileSink}. */
 export interface RotatingFileBatchOptions {
@@ -87,7 +86,7 @@ export class RotatingFileSink {
 
 	#openFd(filePath: string): void {
 		this.#closeFd();
-		this.#fd = openCloexecSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND);
+		this.#fd = fs.openSync(filePath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND);
 		try {
 			this.#onRotate?.(filePath);
 		} catch {

package/src/logger.ts

@@ -7,11 +7,13 @@
  * transport so a process supervisor (pm2, journald, k8s) captures the logs.
  *
  * Each entry includes `process.pid` so concurrent zeta instances stay
- * traceable. The file is created on the first record written. Records are
- * batched — one write per second or per 64 KiB — while `warn`/`error` records
- * are written at once together with everything buffered before them; exit,
- * fatal, and signal paths flush the rest. `ZETA_LOG_LEVEL` optionally limits
- * the levels written to the file (default: all).
+ * traceable, and the fields of the enclosing {@link withContext} (a session's
+ * `sessionId`) so sessions sharing one process stay apart. The file is created
+ * on the first record written. Records are batched — one write per second or
+ * per 64 KiB — while `warn`/`error` records are written at once together with
+ * everything buffered before them; exit, fatal, and signal paths flush the
+ * rest. `ZETA_LOG_LEVEL` optionally limits the levels written to the file
+ * (default: all).
  */
 import { AsyncLocalStorage } from "node:async_hooks";
 import * as fs from "node:fs";
@@ -48,7 +50,18 @@ export function registerLogSink(sink: LogSink): () => void {
 
 function emitToSinks(level: LogLevel, message: string, context: Record<string, unknown> | undefined): void {
 	if (logSinks.size === 0) return;
-	const event: LogEvent = { level, message, context, timestamp: new Date() };
+	// The enclosing {@link withContext} fields reach sinks as they reach the file;
+	// call-site fields win, and a record outside any context keeps its own object.
+	const scoped = logContextStorage.getStore();
+	let merged = context;
+	if (scoped) {
+		try {
+			merged = { ...scoped, ...context };
+		} catch {
+			// A throwing getter must not turn a log call into a failure; sinks get the call's own fields.
+		}
+	}
+	const event: LogEvent = { level, message, context: merged, timestamp: new Date() };
 	for (const sink of logSinks) {
 		try {
 			sink(event);
@@ -251,6 +264,28 @@ function formatLocalTimestamp(date: Date): string {
 
 const FORMAT_TOKEN_PATTERN = /%[scdjifoO%]/;
 
+const logContextStorage = new AsyncLocalStorage<Readonly<Record<string, unknown>>>();
+
+/**
+ * Run `fn` with `context`'s fields on every record logged while it runs,
+ * including from the promises, timers and callbacks it starts. A nested call
+ * replaces the enclosing context, as a subagent's session replaces its
+ * parent's; a field passed to the log call itself wins. Fields are read as each
+ * record is written, so a getter stays current.
+ */
+export function withContext<T>(context: Readonly<Record<string, unknown>>, fn: () => T): T {
+	return logContextStorage.run(context, fn);
+}
+
+/**
+ * Run `fn` outside any {@link withContext}: for process-wide work started on
+ * behalf of one caller, such as a shared server's read loop, whose later
+ * records belong to no single caller.
+ */
+export function withoutContext<T>(fn: () => T): T {
+	return logContextStorage.exit(fn);
+}
+
 /** Serialize one log record: timestamp, level, pid, message, then context fields. */
 function formatLogRecord(
 	level: LogLevel,
@@ -266,6 +301,12 @@ function formatLogRecord(
 		pid: process.pid,
 		message: metadata?.message ? `${message} ${metadata.message}` : message,
 	};
+	const scoped = logContextStorage.getStore();
+	if (scoped) {
+		for (const key of Object.keys(scoped)) {
+			if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = scoped[key];
+		}
+	}
 	if (metadata) {
 		for (const key of Object.keys(metadata)) {
 			if (key !== "level" && key !== "timestamp" && key !== "message") entry[key] = metadata[key];

package/src/ports.ts

@@ -3,8 +3,9 @@
  *
  * OMP installs on the same machine use 30141/30142/3847, and common developer
  * tools squat on 3000/8080/8787/3847. Zeta therefore owns a dedicated block:
- * three uncommon ports, at least two apart, so a side-by-side OMP install and
- * unrelated services cannot take the gateway or the stats dashboard away.
+ * uncommon ports, at least two apart, so a side-by-side OMP install and
+ * unrelated services cannot take the gateway, stats dashboard, or browser
+ * relay away.
  *
  * Every default in the repository derives from these constants. The standalone
  * Electron shell (`desktop/src/main.ts`, not a Bun workspace package) carries
@@ -13,3 +14,4 @@
 export const ZETA_WEB_PORT = 43141;
 export const ZETA_GATEWAY_PORT = 43143;
 export const ZETA_STATS_PORT = 43147;
+export const ZETA_BROWSER_RELAY_PORT = 43153;

package/dist/types/fs-open.d.ts

@@ -1,17 +0,0 @@
-/**
- * `fs.openSync` with close-on-exec, matching Node's default.
- *
- * libuv adds `O_CLOEXEC` inside `uv__fs_open`, so on Node every `fs` descriptor
- * dies at `exec`. Bun's `fs.open*` did not before 1.4.3 (still allowed by the
- * `bun@>=1.4` pin), and descriptors it returns survive
- * into any child spawned through a path that does not close strays itself — the
- * bash tool's shell `fork`/`exec`s user commands and hands them the lot. Use
- * this for every descriptor kept open past such a spawn (session transcripts,
- * logs, spools); a child must never hold a writable handle to them (#13224).
- *
- * Flags are numeric only: the bit cannot be OR-ed into `"a"`/`"w+"` strings.
- *
- * @example
- * const fd = openCloexecSync(logPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND);
- */
-export declare function openCloexecSync(filePath: string, flags: number, mode?: number): number;

package/src/fs-open.ts

@@ -1,32 +0,0 @@
-/** Close-on-exec file opens for descriptors held past a child spawn. */
-import * as fs from "node:fs";
-
-/**
- * `O_CLOEXEC`, which neither Node nor Bun exposes in `fs.constants`.
- *
- * Kernel ABI values: `0o2000000` on Linux, `0x0100_0000` on Darwin. Windows has
- * no `exec` and its CRT handles are inherited only when a spawn explicitly asks
- * for it, so the bit is 0 there — as it is on any other platform, where adding
- * an unknown flag bit would be worse than leaving the descriptor inheritable.
- */
-const O_CLOEXEC = process.platform === "linux" ? 0o2000000 : process.platform === "darwin" ? 0x0100_0000 : 0;
-
-/**
- * `fs.openSync` with close-on-exec, matching Node's default.
- *
- * libuv adds `O_CLOEXEC` inside `uv__fs_open`, so on Node every `fs` descriptor
- * dies at `exec`. Bun's `fs.open*` did not before 1.4.3 (still allowed by the
- * `bun@>=1.4` pin), and descriptors it returns survive
- * into any child spawned through a path that does not close strays itself — the
- * bash tool's shell `fork`/`exec`s user commands and hands them the lot. Use
- * this for every descriptor kept open past such a spawn (session transcripts,
- * logs, spools); a child must never hold a writable handle to them (#13224).
- *
- * Flags are numeric only: the bit cannot be OR-ed into `"a"`/`"w+"` strings.
- *
- * @example
- * const fd = openCloexecSync(logPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND);
- */
-export function openCloexecSync(filePath: string, flags: number, mode?: number): number {
-	return fs.openSync(filePath, flags | O_CLOEXEC, mode);
-}