@xynogen/pix-runtime 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-runtime",
-	"version": "0.8.0",
+	"version": "0.8.2",
 	"description": "Pix shared runtime — versioned pix.json config, atomic persistence, typed change events",
 	"type": "module",
 	"main": "src/index.ts",
@@ -9,7 +9,7 @@
 	},
 	"files": [
 		"src",
-		"!src/**/*.test.ts",
+		"!src/**/*.test.*",
 		"README.md",
 		"DESIGN.md",
 		"LICENSE"
@@ -21,6 +21,7 @@
 	},
 	"exports": {
 		".": "./src/index.ts",
+		"./atomic-write": "./src/atomic-write.ts",
 		"./config": "./src/runtime.ts",
 		"./sections": "./src/sections/index.ts",
 		"./collapse": "./src/collapse.ts",

package/src/atomic-write.ts

@@ -0,0 +1,35 @@
+/**
+ * atomic-write.ts — write a file so readers never see a partial result.
+ *
+ * Writes to a unique sibling temp file, then renames over the target (rename is
+ * atomic on the same filesystem). A crash mid-write leaves the old file intact.
+ * Parent dirs are created.
+ *
+ * NOT a replacement for pix-runtime's ConfigStorage.writeAtomic, which adds a
+ * cross-process lock. Use this for plain single-writer files (per-tool JSON
+ * state, caches).
+ */
+
+import { mkdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+/** Atomically write `contents` to `target`. Mode defaults to 0o600. */
+export function writeFileAtomicSync(
+	target: string,
+	contents: string | Uint8Array,
+	mode = 0o600,
+): void {
+	mkdirSync(dirname(target), { recursive: true });
+	const tmp = `${target}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		writeFileSync(tmp, contents, { mode });
+		renameSync(tmp, target);
+	} catch (err) {
+		try {
+			rmSync(tmp, { force: true });
+		} catch {
+			/* best-effort cleanup */
+		}
+		throw err;
+	}
+}

package/src/index.ts

@@ -1,3 +1,4 @@
+export { writeFileAtomicSync } from "./atomic-write.ts";
 export { collapseDelayMs, shouldCollapse } from "./collapse.ts";
 export type {
 	ConfigChange,

package/src/pix-command.ts

@@ -205,6 +205,7 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 		handler: async (_args: string, ctx: ExtensionCommandContext) => {
 			// Re-parse pix.json so section parsers remain the single validation source.
 			await runtime.reload({ origin: "command", source: "pix" });
+			// SAFETY: Runtime UI supports custom overlays beyond the published command context type.
 			const ui = ctx.ui as unknown as {
 				custom?: (f: unknown, opts?: unknown) => Promise<unknown>;
 				notify(m: string, t?: "info" | "warning" | "error"): void;
@@ -227,8 +228,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 					done: (v: null) => void,
 				) => {
 					const guide = (key: string, action: string) =>
-						theme.fg("text", key) + theme.fg("dim", ` ${action}`);
-					const guideSep = theme.fg("dim", " · ");
+						theme.fg("text", key) + theme.fg("muted", ` ${action}`);
+					const guideSep = theme.fg("muted", " · ");
 					let selected = 0;
 					let bodyOffset = 0;
 					let visibleBodyLines = 1;
@@ -241,8 +242,11 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 						// Functional updater: the runtime queue serializes writes, and the
 						// callback sees the latest committed value — so rapid presses each
 						// advance exactly one step instead of collapsing on a stale snapshot.
-						const step = (current: unknown): unknown => {
-							const curVal = row.read(current);
+						type SettingsState = Record<string, unknown>;
+						const step = (current: unknown): SettingsState => {
+							const state: SettingsState =
+								current !== null && typeof current === "object" ? { ...(current as object) } : {};
+							const curVal = row.read(state);
 							let cur = row.values.indexOf(curVal);
 							// ponytail: unsupported custom values snap to section default on first change.
 							if (cur === -1) {
@@ -252,8 +256,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 							}
 							const next = (cur + direction + row.values.length) % row.values.length;
 							const val = row.values[next];
-							if (val === undefined) return current;
-							return { ...(current as object), ...(row.patch(val) as object) };
+							if (val === undefined) return state;
+							return { ...state, ...(row.patch(val) as object) };
 						};
 						// Re-render AFTER the commit lands; the synchronous render in
 						// handleInput fires before the queued write and shows a stale value.