@xynogen/pix-runtime 0.5.1 → 0.5.3

package/README.md

@@ -58,8 +58,9 @@ to calculate the trigger; the default is `60` and `0` disables the self-trigger
 `compaction.minimumTokens` is the absolute floor for that calculation. The
 effective threshold is `max(contextWindow × triggerPercent, minimumTokens)`, so
 a 300K-context model at 10% waits for 100K tokens instead of compacting at 30K.
-The default floor is 100K; `/pix` offers 100K, 150K, 200K, 300K, 400K, 500K, and
-600K. pix-core consumes both settings.
+The default floor is 100K and the hard minimum is 25K (values below clamp up);
+`/pix` offers 25K, 50K, 100K, 150K, 200K, 300K, 400K, 600K, 800K, and 1M.
+pix-core consumes both settings.
 
 Collapse policy helpers:
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-runtime",
-	"version": "0.5.1",
+	"version": "0.5.3",
 	"description": "Pix shared runtime — versioned pix.json config, atomic persistence, typed change events",
 	"type": "module",
 	"main": "src/index.ts",

package/src/pix-command.ts

@@ -37,6 +37,23 @@ function row<T>(r: SettingRow<T>): SettingRow<unknown> {
 	return r as SettingRow<unknown>;
 }
 
+/** Render a token count as a compact label: 1_000_000 → "1M", 150_000 → "150k". */
+function formatTokens(tokens: number): string {
+	return tokens % 1_000_000 === 0 ? `${tokens / 1_000_000}M` : `${tokens / 1000}k`;
+}
+
+/** Parse a compact token label ("1M", "150k") back to an absolute count. */
+function parseTokens(label: string): number {
+	const raw = label.trim();
+	const m = raw.match(/^([0-9]*\.?[0-9]+)\s*([km])?$/i);
+	if (!m) return Number.NaN;
+	const numStr = m[1] ?? "";
+	const n = Number.parseFloat(numStr);
+	if (!Number.isFinite(n)) return Number.NaN;
+	const suf = (m[2] ?? "").toLowerCase();
+	return suf === "m" ? Math.round(n * 1_000_000) : Math.round(n * 1000);
+}
+
 const SETTINGS: SettingRow<unknown>[] = [
 	row({
 		section: "Pretty",
@@ -82,7 +99,8 @@ const SETTINGS: SettingRow<unknown>[] = [
 		section: "Compaction",
 		label: "Trigger (% ctx)",
 		handle: compactionSection,
-		values: ["0", "5", "10", "15", "20", "25", "30", "40", "50", "60", "70", "80", "90"],
+		// 0–100 in 5% steps.
+		values: Array.from({ length: 21 }, (_, i) => String(i * 5)),
 		read: (v) => String(v.triggerPercent),
 		patch: (value) => ({ triggerPercent: Number(value) }),
 	}),
@@ -90,9 +108,9 @@ const SETTINGS: SettingRow<unknown>[] = [
 		section: "Compaction",
 		label: "Minimum tokens",
 		handle: compactionSection,
-		values: ["100k", "150k", "200k", "300k", "400k", "500k", "600k"],
-		read: (v) => `${v.minimumTokens / 1000}k`,
-		patch: (value) => ({ minimumTokens: Number.parseInt(value, 10) * 1000 }),
+		values: ["25k", "50k", "100k", "150k", "200k", "300k", "400k", "600k", "800k", "1M"],
+		read: (v) => formatTokens(v.minimumTokens),
+		patch: (value) => ({ minimumTokens: parseTokens(value) }),
 	}),
 	row({
 		section: "Gate",
@@ -114,7 +132,7 @@ function buildSummary(runtime: PixRuntime): string {
 			lastSection = row.section;
 		}
 		const value = row.read(runtime.get(row.handle));
-		const isDefault = value === row.values[0];
+		const isDefault = value === row.read(row.handle.defaults);
 		lines.push(`  ${row.label}: ${value}${isDefault ? "" : " *"}`);
 	}
 	return lines.join("\n");
@@ -124,6 +142,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 	pi.registerCommand("pix", {
 		description: "pix: open shared settings (edit pix.json)",
 		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" });
 			const ui = ctx.ui as unknown as {
 				custom?: (f: unknown, opts?: unknown) => Promise<unknown>;
 				notify(m: string, t?: "info" | "warning" | "error"): void;
@@ -158,11 +178,29 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 					const cycle = (direction: -1 | 1) => {
 						const row = SETTINGS[selected];
 						if (!row) return;
-						const cur = row.values.indexOf(row.read(runtime.get(row.handle)));
-						const next = (cur + direction + row.values.length) % row.values.length;
-						const val = row.values[next];
-						if (val === undefined) return;
-						void runtime.update(row.handle, row.patch(val), { origin: "command", source: "pix" });
+						// 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);
+							let cur = row.values.indexOf(curVal);
+							// ponytail: unsupported custom values snap to section default on first change.
+							if (cur === -1) {
+								const def = row.read(row.handle.defaults);
+								const defIdx = row.values.indexOf(def);
+								cur = defIdx !== -1 ? defIdx - direction : -1;
+							}
+							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) };
+						};
+						// Re-render AFTER the commit lands; the synchronous render in
+						// handleInput fires before the queued write and shows a stale value.
+						void runtime
+							.update(row.handle, step, { origin: "command", source: "pix" })
+							.then(() => tui.requestRender())
+							.catch(() => ui.notify(`pix: failed to update ${row.label}`, "error"));
 					};
 					const move = (direction: -1 | 1) => {
 						selected = (selected + direction + SETTINGS.length) % SETTINGS.length;
@@ -176,7 +214,8 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 							const settingBodyLines: number[] = [];
 							let lastSection = "";
 							for (let i = 0; i < SETTINGS.length; i++) {
-								const row = SETTINGS[i]!;
+								const row = SETTINGS[i];
+								if (!row) continue;
 								if (row.section !== lastSection) {
 									if (lastSection) body.push("");
 									body.push(theme.fg("dim", `  ${row.section}`));
@@ -186,7 +225,7 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 								const cursor = sel ? theme.fg("accent", "→") : " ";
 								const label = theme.fg(sel ? "accent" : "text", row.label.padEnd(labelW));
 								const value = row.read(runtime.get(row.handle));
-								const isDefault = value === row.values[0];
+								const isDefault = value === row.read(row.handle.defaults);
 								settingBodyLines[i] = body.length;
 								body.push(`${cursor} ${label}  ${theme.fg(isDefault ? "dim" : "success", value)}`);
 							}
@@ -230,20 +269,15 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 							// matchesKey handles both legacy bytes and Kitty CSI-u encodings
 							// for letters and special keys alike — raw string compares like
 							// `data === "k"` silently fail under the Kitty keyboard protocol.
-							if (matchesKey(data, "k") || matchesKey(data, "up")) move(-1);
-							else if (matchesKey(data, "j") || matchesKey(data, "down")) move(1);
-							else if (matchesKey(data, "h") || matchesKey(data, "left")) cycle(-1);
-							else if (
-								matchesKey(data, "l") ||
-								matchesKey(data, "right") ||
-								matchesKey(data, "space") ||
-								matchesKey(data, "enter")
-							)
-								cycle(1);
-							else if (matchesKey(data, "escape") || matchesKey(data, "q")) {
+							if (kb.matches(data, "tui.select.cancel")) {
 								done(null);
 								return;
-							} else return;
+							}
+							if (kb.matches(data, "tui.select.up")) move(-1);
+							else if (kb.matches(data, "tui.select.down")) move(1);
+							else if (matchesKey(data, Key.left)) cycle(-1);
+							else if (matchesKey(data, Key.right)) cycle(1);
+							else return;
 							tui.requestRender();
 						},
 					};
@@ -346,12 +380,13 @@ function frameRows(
 	const dashes = "─".repeat(width - 2);
 	const SENTINEL = "\x00";
 	const bgOpen = bg(SENTINEL).split(SENTINEL)[0] ?? "";
-	const reassert = (s: string): string =>
-		bgOpen
-			? s.replace(/\x1b\[([0-9;]*)m/g, (seq, p: string) =>
-					p === "0" || p.split(";").includes("49") ? `${seq}${bgOpen}` : seq,
-				)
-			: s;
+	const reassert = (s: string): string => {
+		if (!bgOpen) return s;
+		return s.replace(/\x1b\[([0-9;]*)m/g, (seq, p: string) => {
+			if (p === "0" || p.split(";").includes("49")) return `${seq}${bgOpen}`;
+			return seq;
+		});
+	};
 	const row = (content: string): string => {
 		const fitted = truncateToWidth(content, inner, "…");
 		const padded = fitted + " ".repeat(Math.max(0, inner - visibleWidth(fitted)));

package/src/runtime.ts

@@ -347,12 +347,24 @@ class RuntimeImpl implements PixRuntime {
 		const values = new Map<string, unknown>();
 		for (const s of this.registry.all()) values.set(s.key, s.parse(base[s.key], ctx));
 
-		const currentValue = values.get(section.key) as Readonly<T>;
-		const nextValue =
+		// Guard against a version-skewed second runtime copy whose registry
+		// lacks this section (e.g. an old npm copy handling a new handle). The
+		// functional updater would otherwise crash the whole process on
+		// `undefined`. Fall back to the handle's own parse of the raw doc.
+		const currentValue = (
+			values.has(section.key)
+				? values.get(section.key)
+				: section.__section.parse(base[section.key], ctx)
+		) as Readonly<T>;
+		const mergedValue =
 			typeof updater === "function"
 				? (updater as (c: Readonly<T>) => T)(currentValue)
 				: deepMerge(currentValue as T, updater);
 
+		// Re-validate through the section's own parse so a bad patch (NaN,
+		// Infinity, wrong type) can never enter the live snapshot.
+		const nextValue = section.__section.parse(mergedValue, ctx) as T;
+
 		if (JSON.stringify(currentValue) === JSON.stringify(nextValue)) return undefined;
 		values.set(section.key, nextValue);
 

package/src/sections/compaction.ts

@@ -14,11 +14,12 @@ export interface CompactionConfig {
 	minimumTokens: number;
 }
 
-const MINIMUM_TOKEN_FLOOR = 100_000;
+const MINIMUM_TOKEN_FLOOR = 25_000;
+const MINIMUM_TOKEN_DEFAULT = 100_000;
 
 const DEFAULTS: Readonly<CompactionConfig> = {
 	triggerPercent: 60,
-	minimumTokens: MINIMUM_TOKEN_FLOOR,
+	minimumTokens: MINIMUM_TOKEN_DEFAULT,
 };
 
 /** Clamp to [0, 100]; non-numbers fall back. */
@@ -27,20 +28,38 @@ function pctOr(v: unknown, fallback: number): number {
 	return Math.min(100, Math.max(0, v));
 }
 
-/** Require a finite token floor of at least 100k. */
+/** Require a finite token floor of at least 25k. */
 function minimumTokensOr(v: unknown, fallback: number): number {
 	if (typeof v !== "number" || !Number.isFinite(v)) return fallback;
+	// Strings from older/hand-edited pix.json (e.g. "150k") → parse before clamping.
 	return Math.max(MINIMUM_TOKEN_FLOOR, Math.round(v));
 }
 
+function parseTokenString(label: string): number | undefined {
+	const raw = label.trim();
+	if (!raw) return undefined;
+	const m = raw.match(/^([0-9]*\.?[0-9]+)\s*([km])?$/i);
+	if (!m) return undefined;
+	const numStr = m[1] ?? "";
+	const n = Number.parseFloat(numStr);
+	if (!Number.isFinite(n)) return undefined;
+	const suf = (m[2] ?? "").toLowerCase();
+	if (suf === "m") return Math.round(n * 1_000_000);
+	if (suf === "k") return Math.round(n * 1000);
+	return Math.round(n);
+}
+
 export const compactionSection = defineSection<"compaction", CompactionConfig>({
 	key: "compaction",
 	defaults: DEFAULTS,
 	parse(raw) {
 		if (!isObj(raw)) return { ...DEFAULTS };
+		const rawMin = raw.minimumTokens;
+		const coercedMin =
+			typeof rawMin === "string" ? (parseTokenString(rawMin) ?? Number.NaN) : rawMin;
 		return {
 			triggerPercent: pctOr(raw.triggerPercent, DEFAULTS.triggerPercent),
-			minimumTokens: minimumTokensOr(raw.minimumTokens, DEFAULTS.minimumTokens),
+			minimumTokens: minimumTokensOr(coercedMin, DEFAULTS.minimumTokens),
 		};
 	},
 });