@oh-my-pi/pi-utils 18.5.0 → 18.5.1

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## [Unreleased]
 
+## [18.5.1] - 2026-10-03
+
+### Added
+
+- Added utilities for detecting and scanning own-line display-math blocks in growing text, including identifying possible openers and closers efficiently.
+- Added an option to `TerminalQueryResponder` that lets PTY hosts provide cursor-position reports themselves.
+- Added `refreshShellConfigCache()` to rebuild the cached shell spawn environment from the current process environment.
+
+### Fixed
+
+- Fixed the Markdown lexer dropping text preceding U+2028 or U+2029 line-separator characters.
+
 ## [18.5.0] - 2026-10-03
 
 ### Added

package/dist/types/math-delimiters.d.ts

@@ -6,6 +6,8 @@
  */
 /** Opening delimiter. Each closer (`$`, `$$`, `\)`, `\]`) is as wide as its opener. */
 export type MathOpener = "$" | "$$" | "\\(" | "\\[";
+/** Opener of an own-line display block. */
+export type MathBlockOpener = "$$" | "\\[";
 /** A closed math span found in the source. */
 export interface MathSpan {
     opener: MathOpener;
@@ -65,3 +67,39 @@ export declare function mathSpanInContext(context: {
 }, src: string): MathSpan | undefined;
 /** The own-line display block starting at offset 0, or `undefined`. */
 export declare function mathBlockAt(source: string): MathBlock | undefined;
+/**
+ * {@link mathBlockAt} for many offsets of one `source`. An own-line opener
+ * whose closer line is missing means every later opener of the same kind
+ * misses one too, since its search covers a suffix of that search. The scan
+ * keeps that answer, so asking at every block start takes linear time instead
+ * of a scan to the end of `source` per unclosed opener.
+ */
+export declare class MathBlockScan {
+    #private;
+    constructor(source: string);
+    /** The own-line display block starting at `from`, or `undefined`. */
+    at(from: number): MathBlock | undefined;
+}
+/**
+ * The display opener alone on the line at `from` (up to 3 leading spaces,
+ * trailing spaces or tabs; the source's last line may be unterminated), or
+ * `undefined`.
+ */
+export declare function mathBlockOpenerAt(source: string, from?: number): MathBlockOpener | undefined;
+/**
+ * Whether the own-line display block opened at `from` in `source` is closed,
+ * or could still close once more text is appended: the text from `from`
+ * onward is a streaming prefix whose real closer may not have arrived. A
+ * closer on the unterminated last line has not arrived either, since the next
+ * append may extend it into text (`$$ E = mc^2 $$`). With no opener line at
+ * `from` it returns false before scanning, so a caller can ask at every block
+ * start.
+ */
+export declare function mathBlockMayCloseAt(source: string, from?: number): boolean;
+/**
+ * Offset of the first line of `source`, from the line start `from` on, that
+ * holds the closer of `opener` alone (up to 3 leading spaces, trailing spaces
+ * or tabs), the unterminated last line included, or `undefined`: the first
+ * line at which a block `opener` opened before `from` could close.
+ */
+export declare function mathBlockCloserIndex(source: string, from: number, opener: MathBlockOpener): number | undefined;

package/dist/types/procmgr.d.ts

@@ -70,6 +70,20 @@ export declare function resolveWindowsShell(env?: Record<string, string | undefi
  * `shellPath` mid-process immediately falls back to the platform default.
  */
 export declare function getShellConfig(customShellPath?: string, options?: ShellConfigOptions): ShellConfig;
+/**
+ * Capture the current process environment for child shells and drop both cached
+ * shell configs, so the next {@link getShellConfig} builds the spawn environment
+ * from that capture. Call right after code that changed `process.env` in a way
+ * child shells must see, such as extension session lifecycle handlers exporting
+ * session-scoped variables; later writes reach child shells only at the next call.
+ */
+export declare function refreshShellConfigCache(): void;
+/**
+ * Test-only: forget the capture and both cached shell configs, so the next
+ * {@link getShellConfig} builds from the live environment again. Production code
+ * MUST NOT call this; the capture's lifecycle is owned by {@link refreshShellConfigCache}.
+ */
+export declare function __resetShellConfigCacheForTests(): void;
 /**
  * Check if a process is running.
  */

package/dist/types/vterm/query-responder.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Options for {@link TerminalQueryResponder}.
+ */
+export interface TerminalQueryResponderOptions {
+    /**
+     * Reply to `CSI 6 n` (report cursor position) with the home position. Set to
+     * `false` when the PTY host answers cursor reports itself: the only `CSI 6 n`
+     * left on the stream is then the host's own session-start handshake, whose
+     * reply would be delivered to the supervised program as unsolicited input
+     * instead of being consumed by the host. Defaults to `true`.
+     */
+    cursorPosition?: boolean;
+}
 /**
  * Answers terminal capability queries emitted by programs on a headless PTY.
  *
@@ -16,6 +29,7 @@
  */
 export declare class TerminalQueryResponder {
     #private;
+    constructor(options?: TerminalQueryResponderOptions);
     /**
      * Feed one raw PTY output chunk. Returns the reply bytes to write back into
      * the PTY, or an empty string when the chunk held no answerable query.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-utils",
-	"version": "18.5.0",
+	"version": "18.5.1",
 	"description": "Shared utilities for pi packages",
 	"keywords": [
 		"cli",
@@ -57,7 +57,7 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/pi-natives": "18.5.0"
+		"@oh-my-pi/pi-natives": "18.5.1"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/marked/core.ts

@@ -820,8 +820,10 @@ function isBlockStart(lines: string[], index: number): boolean {
 	return false;
 }
 
+// `[^\n]`, not `.`: `.` stops at U+2028 and U+2029, which end no Markdown line,
+// and the match then skips the text in front of them.
 function lineArray(src: string): string[] {
-	return src.match(/.*(?:\n|$)/g)?.filter((line, index, all) => line !== "" || index < all.length - 1) ?? [];
+	return src.match(/[^\n]*(?:\n|$)/g)?.filter((line, index, all) => line !== "" || index < all.length - 1) ?? [];
 }
 function stripFinalNewline(value: string): string {
 	return value.endsWith("\n") ? value.slice(0, -1) : value;

package/src/math-delimiters.ts

@@ -8,6 +8,9 @@
 /** Opening delimiter. Each closer (`$`, `$$`, `\)`, `\]`) is as wide as its opener. */
 export type MathOpener = "$" | "$$" | "\\(" | "\\[";
 
+/** Opener of an own-line display block. */
+export type MathBlockOpener = "$$" | "\\[";
+
 /** A closed math span found in the source. */
 export interface MathSpan {
 	opener: MathOpener;
@@ -33,8 +36,8 @@ export interface MathBlock {
 // it. The own-line requirement leaves inline `$$…$$` inside prose to the span
 // grammar below. `\r?\n` at each line boundary keeps the grammar CRLF-safe for
 // direct callers; marked-fed renderers already normalize line endings first.
-const MATH_BLOCK_DOLLAR = /^ {0,3}\$\$[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\$\$[ \t]*(?:\r?\n|$)/;
-const MATH_BLOCK_BRACKET = /^ {0,3}\\\[[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\\\][ \t]*(?:\r?\n|$)/;
+const MATH_BLOCK_DOLLAR = / {0,3}\$\$[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\$\$[ \t]*(?:\r?\n|$)/y;
+const MATH_BLOCK_BRACKET = / {0,3}\\\[[ \t]*\r?\n([\s\S]+?)\r?\n {0,3}\\\][ \t]*(?:\r?\n|$)/y;
 
 /**
  * Leftmost offset at or after `from` where an opener could begin. A scan hint,
@@ -182,9 +185,110 @@ function spanOf(source: string, opener: MathOpener, bodyStart: number, closeAt:
 
 /** The own-line display block starting at offset 0, or `undefined`. */
 export function mathBlockAt(source: string): MathBlock | undefined {
-	const match = MATH_BLOCK_DOLLAR.exec(source) ?? MATH_BLOCK_BRACKET.exec(source);
-	if (!match || match[1].trim() === "") return undefined;
-	return { raw: match[0], body: match[1] };
+	MATH_BLOCK_DOLLAR.lastIndex = 0;
+	MATH_BLOCK_BRACKET.lastIndex = 0;
+	return blockOf(MATH_BLOCK_DOLLAR.exec(source) ?? MATH_BLOCK_BRACKET.exec(source));
+}
+
+/** The block a match of the block grammar describes; a whitespace-only body is no block. */
+function blockOf(match: RegExpExecArray | null): MathBlock | undefined {
+	return match === null || match[1].trim() === "" ? undefined : { raw: match[0], body: match[1] };
+}
+
+// An own-line display opener line (`$$` or `\[` after up to 3 spaces), capturing
+// the opener and the line's end: "" when it is the source's unterminated last line.
+const MATH_BLOCK_OPENER_LINE_RE = / {0,3}(\$\$|\\\[)[ \t]*(\r?\n|$)/y;
+
+/**
+ * {@link mathBlockAt} for many offsets of one `source`. An own-line opener
+ * whose closer line is missing means every later opener of the same kind
+ * misses one too, since its search covers a suffix of that search. The scan
+ * keeps that answer, so asking at every block start takes linear time instead
+ * of a scan to the end of `source` per unclosed opener.
+ */
+export class MathBlockScan {
+	readonly #source: string;
+	// Offset of the first `$$` / `\[` opener line found with no closer line after it.
+	#unclosedDollarFrom = Number.POSITIVE_INFINITY;
+	#unclosedBracketFrom = Number.POSITIVE_INFINITY;
+
+	constructor(source: string) {
+		this.#source = source;
+	}
+
+	/** The own-line display block starting at `from`, or `undefined`. */
+	at(from: number): MathBlock | undefined {
+		MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+		const line = MATH_BLOCK_OPENER_LINE_RE.exec(this.#source);
+		// An unterminated opener line opens no block.
+		if (line === null || line[2] === "") return undefined;
+		const dollar = line[1] === "$$";
+		if (from >= (dollar ? this.#unclosedDollarFrom : this.#unclosedBracketFrom)) return undefined;
+		const grammar = dollar ? MATH_BLOCK_DOLLAR : MATH_BLOCK_BRACKET;
+		grammar.lastIndex = from;
+		const match = grammar.exec(this.#source);
+		if (match === null) {
+			if (dollar) this.#unclosedDollarFrom = from;
+			else this.#unclosedBracketFrom = from;
+		}
+		return blockOf(match);
+	}
+}
+
+/**
+ * The display opener alone on the line at `from` (up to 3 leading spaces,
+ * trailing spaces or tabs; the source's last line may be unterminated), or
+ * `undefined`.
+ */
+export function mathBlockOpenerAt(source: string, from = 0): MathBlockOpener | undefined {
+	MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+	const line = MATH_BLOCK_OPENER_LINE_RE.exec(source);
+	return line === null ? undefined : line[1] === "$$" ? "$$" : "\\[";
+}
+
+/**
+ * Whether the own-line display block opened at `from` in `source` is closed,
+ * or could still close once more text is appended: the text from `from`
+ * onward is a streaming prefix whose real closer may not have arrived. A
+ * closer on the unterminated last line has not arrived either, since the next
+ * append may extend it into text (`$$ E = mc^2 $$`). With no opener line at
+ * `from` it returns false before scanning, so a caller can ask at every block
+ * start.
+ */
+export function mathBlockMayCloseAt(source: string, from = 0): boolean {
+	MATH_BLOCK_OPENER_LINE_RE.lastIndex = from;
+	const line = MATH_BLOCK_OPENER_LINE_RE.exec(source);
+	if (line === null) return false;
+	// The opener's own line is still being written.
+	if (line[2] === "") return true;
+	const grammar = line[1] === "$$" ? MATH_BLOCK_DOLLAR : MATH_BLOCK_BRACKET;
+	grammar.lastIndex = from;
+	const match = grammar.exec(source);
+	// No closer line yet, or only on the last line, which is still being written.
+	if (match === null || (from + match[0].length === source.length && !match[0].endsWith("\n"))) return true;
+	return blockOf(match) !== undefined;
+}
+
+// A display closer alone on its line, captured; the last line counts unterminated.
+const MATH_BLOCK_CLOSER_LINE_RE = /(?<=^|\n) {0,3}(\$\$|\\\])[ \t]*(?=\r?\n|$)/g;
+
+/**
+ * Offset of the first line of `source`, from the line start `from` on, that
+ * holds the closer of `opener` alone (up to 3 leading spaces, trailing spaces
+ * or tabs), the unterminated last line included, or `undefined`: the first
+ * line at which a block `opener` opened before `from` could close.
+ */
+export function mathBlockCloserIndex(source: string, from: number, opener: MathBlockOpener): number | undefined {
+	const closer = opener === "$$" ? "$$" : "\\]";
+	MATH_BLOCK_CLOSER_LINE_RE.lastIndex = from;
+	for (
+		let line = MATH_BLOCK_CLOSER_LINE_RE.exec(source);
+		line !== null;
+		line = MATH_BLOCK_CLOSER_LINE_RE.exec(source)
+	) {
+		if (line[1] === closer) return line.index;
+	}
+	return undefined;
 }
 
 /**

package/src/procmgr.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { Process, ProcessStatus } from "@oh-my-pi/pi-natives";
 import type { Subprocess } from "bun";
-import { getAgentDir, MAIN_CONFIG_FILENAMES } from "./dirs";
+import { getAgentDir, getProjectDir, MAIN_CONFIG_FILENAMES } from "./dirs";
 import { $env, filterChildShellEnv } from "./env";
 import { isExecutable } from "./executable";
 import { $which } from "./which";
@@ -20,18 +20,31 @@ export interface ShellConfigOptions {
 	/** File path or runtime layer that supplied the active shell setting. */
 	configSource?: string;
 }
-/** Auto-resolved shell (no custom path); stable for the process lifetime. */
+/** Auto-resolved shell (no custom path); kept until {@link refreshShellConfigCache}. */
 let cachedDefaultShellConfig: ShellConfig | null = null;
 /** Config for the most recent custom `shellPath`; never served once the path is cleared. */
 let cachedCustomShellConfig: ShellConfig | null = null;
+/**
+ * The child-shell environment {@link refreshShellConfigCache} last captured. Unset
+ * until the first refresh, so spawn environments are built from the live environment.
+ */
+let capturedChildShellEnv: Record<string, string> | undefined;
+/**
+ * Project whose dotenv values the spawn environment filters out: the one current
+ * when it was first built or captured.
+ * That is normally the launch project, whose dotenv files Bun and omp load into
+ * `process.env`; a later session in another project must not receive them.
+ */
+let spawnEnvProjectDir: string | undefined;
 
 /**
  * Build the spawn environment (cached).
  */
 function buildSpawnEnv(shell: string): Record<string, string> {
 	const noCI = $env.PI_BASH_NO_CI || $env.CLAUDE_BASH_NO_CI;
+	spawnEnvProjectDir ??= getProjectDir();
 	return {
-		...filterChildShellEnv(Bun.env),
+		...(capturedChildShellEnv ?? filterChildShellEnv(Bun.env, spawnEnvProjectDir)),
 		SHELL: shell,
 		GIT_EDITOR: "true",
 		GPG_TTY: "not a tty",
@@ -202,6 +215,32 @@ export function getShellConfig(customShellPath?: string, options: ShellConfigOpt
 	return cachedDefaultShellConfig;
 }
 
+/**
+ * Capture the current process environment for child shells and drop both cached
+ * shell configs, so the next {@link getShellConfig} builds the spawn environment
+ * from that capture. Call right after code that changed `process.env` in a way
+ * child shells must see, such as extension session lifecycle handlers exporting
+ * session-scoped variables; later writes reach child shells only at the next call.
+ */
+export function refreshShellConfigCache(): void {
+	spawnEnvProjectDir ??= getProjectDir();
+	capturedChildShellEnv = filterChildShellEnv(Bun.env, spawnEnvProjectDir);
+	cachedDefaultShellConfig = null;
+	cachedCustomShellConfig = null;
+}
+
+/**
+ * Test-only: forget the capture and both cached shell configs, so the next
+ * {@link getShellConfig} builds from the live environment again. Production code
+ * MUST NOT call this; the capture's lifecycle is owned by {@link refreshShellConfigCache}.
+ */
+export function __resetShellConfigCacheForTests(): void {
+	capturedChildShellEnv = undefined;
+	spawnEnvProjectDir = undefined;
+	cachedDefaultShellConfig = null;
+	cachedCustomShellConfig = null;
+}
+
 /** Platform shell discovery used when no custom `shellPath` is configured. */
 function resolveDefaultShell(): string {
 	if (process.platform === "win32") {

package/src/vterm/query-responder.ts

@@ -1,3 +1,17 @@
+/**
+ * Options for {@link TerminalQueryResponder}.
+ */
+export interface TerminalQueryResponderOptions {
+	/**
+	 * Reply to `CSI 6 n` (report cursor position) with the home position. Set to
+	 * `false` when the PTY host answers cursor reports itself: the only `CSI 6 n`
+	 * left on the stream is then the host's own session-start handshake, whose
+	 * reply would be delivered to the supervised program as unsolicited input
+	 * instead of being consumed by the host. Defaults to `true`.
+	 */
+	cursorPosition?: boolean;
+}
+
 /**
  * Answers terminal capability queries emitted by programs on a headless PTY.
  *
@@ -17,6 +31,11 @@
 export class TerminalQueryResponder {
 	/** Trailing bytes that may be the start of an unfinished query escape. */
 	#residual = "";
+	readonly #cursorPosition: boolean;
+
+	constructor(options: TerminalQueryResponderOptions = {}) {
+		this.#cursorPosition = options.cursorPosition ?? true;
+	}
 
 	/**
 	 * Feed one raw PTY output chunk. Returns the reply bytes to write back into
@@ -29,7 +48,7 @@ export class TerminalQueryResponder {
 		QUERY.lastIndex = 0;
 		for (let match = QUERY.exec(buffer); match !== null; match = QUERY.exec(buffer)) {
 			lastEnd = match.index + match[0].length;
-			replies += replyFor(match);
+			replies += replyFor(match, this.#cursorPosition);
 		}
 		// Keep only a short unmatched trailing escape: a query split across
 		// chunks completes on the next feed, while a long tail is ordinary output
@@ -51,7 +70,7 @@ const MAX_PARTIAL_QUERY = 32;
 const QUERY = /\x1b\[([?>=]?)([0-9;]*)([nc])|\x1b\](10|11);\?(\x07|\x1b\\)/gu;
 
 /** Reply a real xterm-class terminal would send for one matched query. */
-function replyFor(match: RegExpExecArray): string {
+function replyFor(match: RegExpExecArray, cursorPosition: boolean): string {
 	const final = match[3];
 	if (final !== undefined) {
 		const intermediate = match[1];
@@ -63,7 +82,7 @@ function replyFor(match: RegExpExecArray): string {
 		}
 		if (intermediate !== "") return ""; // private DSR forms (DECXCPR, appearance) stay unanswered
 		const selector = params.split(";", 1)[0];
-		if (selector === "6") return "\x1b[1;1R"; // cursor position: home, there is no screen
+		if (selector === "6") return cursorPosition ? "\x1b[1;1R" : ""; // cursor position: home, there is no screen
 		if (selector === "5") return "\x1b[0n"; // device status: OK
 		return "";
 	}