@quandev104/pi-style 0.1.1

package/extension-src/pi-style/domain/status.ts

@@ -0,0 +1,430 @@
+import type { ResolvedTheme, SemanticToken } from "./theme.js";
+
+export const STATUS_SEGMENT_IDS = [
+	"pi",
+	"model",
+	"thinking",
+	"model_effort",
+	"path",
+	"git",
+	"context_pct",
+	"context_bar",
+	"context_total",
+	"auto_compact",
+	"token_in",
+	"token_out",
+	"cache_read",
+	"cache_write",
+	"cost",
+	"time_spent",
+	"time",
+	"hostname",
+	"session",
+	"extension_statuses",
+] as const;
+export type StatusSegmentId = (typeof STATUS_SEGMENT_IDS)[number] | (string & {});
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ContextState = "low" | "medium" | "high" | "critical";
+
+export interface GitSnapshot {
+	readonly available: boolean;
+	readonly branch: string | null;
+	readonly staged: number;
+	readonly unstaged: number;
+	readonly untracked: number;
+	readonly ahead?: number;
+	readonly behind?: number;
+	readonly refreshing: boolean;
+	readonly error?: string;
+}
+
+export interface ContextSnapshot {
+	readonly currentTokens?: number;
+	readonly windowTokens?: number;
+	readonly percent?: number;
+	readonly state?: ContextState;
+	readonly autoCompacting?: boolean;
+	readonly customCompaction?: string;
+}
+
+export interface UsageSnapshot {
+	readonly inputTokens: number;
+	readonly outputTokens: number;
+	readonly cacheReadTokens: number;
+	readonly cacheWriteTokens: number;
+	readonly cost?: number;
+	readonly currency?: string;
+	readonly subscriptionMode?: "api" | "subscription" | "unknown";
+	readonly streaming: boolean;
+}
+
+export interface ExtensionStatus {
+	readonly key: string;
+	readonly value: string;
+}
+
+export interface StatusSnapshot {
+	readonly model?: string;
+	/** Provider name for the active model (e.g. `deepseek`), when known. */
+	readonly provider?: string;
+	/** Whether the active model supports reasoning/thinking levels, when known. */
+	readonly reasoning?: boolean;
+	readonly thinkingLevel?: ThinkingLevel;
+	readonly cwd?: string;
+	readonly git?: GitSnapshot;
+	readonly context?: ContextSnapshot;
+	readonly usage?: UsageSnapshot;
+	readonly hostname?: string;
+	readonly sessionName?: string | undefined;
+	readonly sessionId?: string | undefined;
+	readonly sessionStartedAt?: number;
+	readonly extensionStatuses?: readonly ExtensionStatus[];
+}
+
+export interface StatusSegmentOptions {
+	readonly disabled?: boolean;
+	readonly label?: string;
+	readonly [key: string]: unknown;
+}
+
+export interface StatusCustomItem {
+	readonly id: string;
+	readonly statusKey: string;
+	readonly label?: string;
+	readonly priority?: number;
+	readonly placement?: "left" | "right" | "secondary";
+}
+
+export interface SegmentContext {
+	readonly snapshot: StatusSnapshot;
+	readonly theme: ResolvedTheme;
+	readonly options: Readonly<Record<string, StatusSegmentOptions | undefined>>;
+	readonly width: number;
+}
+
+export interface SegmentRenderResult {
+	readonly visible: boolean;
+	readonly content: string;
+	readonly compactContent?: string;
+	readonly minWidth?: number;
+	readonly truncatable?: boolean;
+}
+
+export interface StatusSegment {
+	readonly id: StatusSegmentId;
+	readonly defaultPriority: number;
+	readonly essential?: boolean;
+	readonly overflow?: "primary" | "secondary" | "drop";
+	render(context: SegmentContext): SegmentRenderResult;
+}
+
+export interface StatusLayout {
+	readonly left: readonly StatusSegmentId[];
+	readonly right: readonly StatusSegmentId[];
+	readonly secondary: readonly StatusSegmentId[];
+}
+
+export interface StatusRenderResult {
+	readonly primary: string;
+	readonly secondary?: string;
+	readonly lines: readonly string[];
+	readonly visibleSegments: readonly StatusSegmentId[];
+}
+
+function segment(
+	id: StatusSegmentId,
+	priority: number,
+	render: StatusSegment["render"],
+	essential = false,
+): StatusSegment {
+	return { id, defaultPriority: priority, essential, overflow: essential ? "primary" : "secondary", render };
+}
+
+export function createBuiltinSegments(): ReadonlyMap<StatusSegmentId, StatusSegment> {
+	const segments: StatusSegment[] = [
+		segment("pi", 10, ({ theme }) => ({
+			visible: true,
+			content: theme.apply("accent", `${theme.glyph("pi")} pi`),
+			compactContent: theme.apply("accent", theme.glyph("pi")),
+		})),
+		segment(
+			"model",
+			100,
+			({ snapshot, theme }) => ({
+				visible: Boolean(snapshot.model),
+				content: theme.apply("model", snapshot.model ?? ""),
+				compactContent: theme.apply("model", snapshot.model ?? ""),
+				truncatable: true,
+			}),
+			true,
+		),
+		segment(
+			"model_effort",
+			40,
+			({ snapshot, theme }) => {
+				const model = snapshot.model;
+				if (!model) return { visible: false, content: "" };
+				const label = snapshot.provider ? `(${snapshot.provider}) ${model}` : model;
+				const styledLabel = theme.apply("model", label);
+				const effort = effortLevel(snapshot);
+				if (!effort) {
+					return { visible: true, content: styledLabel, compactContent: theme.apply("model", model) };
+				}
+				return {
+					visible: true,
+					content: `${styledLabel} ${theme.apply("separator", "•")} ${styleEffort(theme, effort)}`,
+					compactContent: theme.apply("model", model),
+				};
+			},
+			false,
+		),
+		segment(
+			"thinking",
+			95,
+			({ snapshot, theme }) => {
+				const level = snapshot.thinkingLevel;
+				if (!level) return { visible: false, content: "" };
+				const label = thinkingLabel(level);
+				const text = `think:${label}`;
+				const compactText = `t:${label}`;
+				if (level === "high" || level === "xhigh" || level === "max") {
+					return { visible: true, content: theme.rainbow(text), compactContent: theme.rainbow(compactText) };
+				}
+				const token =
+					level === "minimal"
+						? "thinkingMinimal"
+						: level === "low"
+							? "thinkingLow"
+							: level === "medium"
+								? "thinkingMedium"
+								: "thinking";
+				return {
+					visible: true,
+					content: theme.apply(token, text),
+					compactContent: theme.apply(token, compactText),
+				};
+			},
+			true,
+		),
+		segment("path", 80, ({ snapshot, theme }) => {
+			const name = snapshot.cwd?.split(/[\\/]/).filter(Boolean).at(-1) ?? snapshot.cwd;
+			return {
+				visible: Boolean(snapshot.cwd),
+				content: theme.apply("path", name ?? ""),
+				compactContent: theme.apply("path", name ?? ""),
+				truncatable: true,
+			};
+		}),
+		segment("git", 75, ({ snapshot, theme }) => {
+			const git = snapshot.git;
+			if (!git?.available || !git.branch) return { visible: false, content: "" };
+			const counts = `${git.staged ? ` +${git.staged}` : ""}${git.unstaged ? ` *${git.unstaged}` : ""}${git.untracked ? ` ?${git.untracked}` : ""}`;
+			const token = git.staged || git.unstaged || git.untracked ? "gitDirty" : "gitClean";
+			return {
+				visible: true,
+				content: theme.apply(token, `${theme.glyph("git")} ${git.branch}${counts}`),
+				compactContent: theme.apply(token, `${theme.glyph("git")} ${git.branch}`),
+			};
+		}),
+		segment(
+			"context_pct",
+			90,
+			({ snapshot, theme }) => {
+				const percent = contextPercent(snapshot.context ?? {});
+				const state = contextState(percent);
+				const token =
+					state === "critical"
+						? "contextCritical"
+						: state === "high"
+							? "contextHigh"
+							: state === "medium"
+								? "contextMedium"
+								: "contextLow";
+				return {
+					visible: percent !== undefined,
+					content: percent === undefined ? "" : theme.apply(token, `ctx:${Math.round(percent)}%`),
+					compactContent: percent === undefined ? "" : theme.apply(token, `${Math.round(percent)}%`),
+				};
+			},
+			true,
+		),
+		segment("context_bar", 70, ({ snapshot, theme, options }) => {
+			const percent = contextPercent(snapshot.context ?? {});
+			if (percent === undefined) return { visible: false, content: "" };
+			const token = contextBarToken(percent);
+			const window = snapshot.context?.windowTokens;
+			const label = `ctx${window !== undefined ? ` (${formatTokens(window)})` : ""}:`;
+			const width = (options["context_bar"]?.width as number | undefined) ?? CONTEXT_BAR_WIDTH;
+			return {
+				visible: true,
+				content: `${theme.apply("muted", label)} ${theme.apply(token, contextBar(percent, width))} ${theme.apply(token, `${Math.round(percent)}%`)}`,
+				compactContent: theme.apply(token, `${Math.round(percent)}%`),
+			};
+		}),
+		segment("context_total", 60, ({ snapshot, theme }) => ({
+			visible: snapshot.context?.currentTokens !== undefined && snapshot.context.windowTokens !== undefined,
+			content:
+				snapshot.context?.currentTokens !== undefined && snapshot.context.windowTokens !== undefined
+					? theme.apply("contextLow", `${snapshot.context.currentTokens}/${snapshot.context.windowTokens}`)
+					: "",
+		})),
+		segment("auto_compact", 55, ({ snapshot, theme }) => ({
+			visible: Boolean(snapshot.context?.autoCompacting || snapshot.context?.customCompaction),
+			content: theme.apply("warning", snapshot.context?.customCompaction ?? "compacting"),
+			compactContent: theme.apply("warning", "compact"),
+		})),
+		segment("token_in", 50, ({ snapshot, theme }) => ({
+			visible: snapshot.usage?.inputTokens !== undefined,
+			content: theme.apply("tokens", `in:${snapshot.usage?.inputTokens ?? 0}`),
+			compactContent: theme.apply("tokens", `i:${snapshot.usage?.inputTokens ?? 0}`),
+		})),
+		segment("token_out", 50, ({ snapshot, theme }) => ({
+			visible: snapshot.usage?.outputTokens !== undefined,
+			content: theme.apply("tokens", `out:${snapshot.usage?.outputTokens ?? 0}`),
+			compactContent: theme.apply("tokens", `o:${snapshot.usage?.outputTokens ?? 0}`),
+		})),
+		segment("cache_read", 40, ({ snapshot, theme }) => ({
+			visible: Boolean(snapshot.usage?.cacheReadTokens),
+			content: theme.apply("cache", `cache:${snapshot.usage?.cacheReadTokens ?? 0}`),
+			compactContent: theme.apply("cache", `cr:${snapshot.usage?.cacheReadTokens ?? 0}`),
+		})),
+		segment("cache_write", 35, ({ snapshot, theme }) => ({
+			visible: Boolean(snapshot.usage?.cacheWriteTokens),
+			content: theme.apply("cache", `cw:${snapshot.usage?.cacheWriteTokens ?? 0}`),
+		})),
+		segment("cost", 65, ({ snapshot, theme }) => {
+			const cost = snapshot.usage?.cost;
+			const content = cost === undefined || cost <= 0 ? "" : theme.apply("cost", `$${cost.toFixed(3)}`);
+			return { visible: Boolean(content), content, compactContent: content };
+		}),
+		segment("time_spent", 25, ({ snapshot, theme }) => ({
+			visible: snapshot.sessionStartedAt !== undefined,
+			content:
+				snapshot.sessionStartedAt === undefined
+					? ""
+					: theme.apply("time", formatElapsed(Date.now() - snapshot.sessionStartedAt)),
+			compactContent:
+				snapshot.sessionStartedAt === undefined
+					? ""
+					: theme.apply("time", formatElapsed(Date.now() - snapshot.sessionStartedAt)),
+		})),
+		segment("time", 20, ({ theme }) => ({
+			visible: true,
+			content: theme.apply("time", new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })),
+			compactContent: theme.apply("time", new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" })),
+		})),
+		segment("hostname", 20, ({ snapshot, theme }) => ({
+			visible: Boolean(snapshot.hostname),
+			content: theme.apply("muted", snapshot.hostname ?? ""),
+		})),
+		segment("session", 20, ({ snapshot, theme }) => ({
+			visible: Boolean(snapshot.sessionName || snapshot.sessionId),
+			content: theme.apply("muted", snapshot.sessionName ?? snapshot.sessionId ?? ""),
+		})),
+		segment("extension_statuses", 30, ({ snapshot, theme }) => {
+			const statuses = snapshot.extensionStatuses;
+			if (!statuses || statuses.length === 0) return { visible: false, content: "" };
+			// Values already carry their display label (extensions publish via
+			// `ctx.ui.setStatus(key, text)` where text is the visible string).
+			// Mirror Pi's native footer: sort by key, join the values only.
+			const text = [...statuses]
+				.sort((a, b) => a.key.localeCompare(b.key))
+				.map((item) => item.value)
+				.join(" ");
+			return { visible: true, content: theme.apply("muted", text) };
+		}),
+	];
+	return new Map(segments.map((item) => [item.id, item]));
+}
+
+const CONTEXT_BAR_WIDTH = 10;
+
+function contextBar(percent: number, width = CONTEXT_BAR_WIDTH): string {
+	const filled = Math.max(0, Math.min(width, Math.round((percent / 100) * width)));
+	return "█".repeat(filled) + "░".repeat(width - filled);
+}
+
+/** Bar colors: green under 50%, yellow from 50% to 70%, red above 70%. */
+function contextBarToken(percent: number): SemanticToken {
+	if (percent > 70) return "error";
+	if (percent >= 50) return "warning";
+	return "success";
+}
+
+function formatTokens(value: number): string {
+	if (value >= 1_000_000) {
+		const millions = value / 1_000_000;
+		return `${Number.isInteger(millions) ? millions : millions.toFixed(1)}M`;
+	}
+	if (value >= 1_000) {
+		const thousands = value / 1_000;
+		return `${Number.isInteger(thousands) ? thousands : thousands.toFixed(1)}K`;
+	}
+	return String(value);
+}
+
+function effortLevel(snapshot: StatusSnapshot): ThinkingLevel | undefined {
+	const level = snapshot.thinkingLevel;
+	if (!level) return undefined;
+	// Reasoning models always surface an effort level (defaulting to off); other
+	// models only show a level when one is actively set.
+	if (snapshot.reasoning === true) return level;
+	return level === "off" ? undefined : level;
+}
+
+function styleEffort(theme: ResolvedTheme, level: ThinkingLevel): string {
+	if (level === "high" || level === "xhigh" || level === "max") return theme.rainbow(level);
+	const token =
+		level === "minimal"
+			? "thinkingMinimal"
+			: level === "low"
+				? "thinkingLow"
+				: level === "medium"
+					? "thinkingMedium"
+					: "thinking";
+	return theme.apply(token, level);
+}
+
+function formatElapsed(ms: number): string {
+	const seconds = Math.max(0, Math.floor(ms / 1000));
+	return `${Math.floor(seconds / 3600)}:${String(Math.floor((seconds % 3600) / 60)).padStart(2, "0")}:${String(seconds % 60).padStart(2, "0")}`;
+}
+
+function thinkingLabel(level: ThinkingLevel): string {
+	return level === "minimal" ? "min" : level === "medium" ? "med" : level;
+}
+
+export function contextState(percent: number | undefined): ContextState | undefined {
+	if (percent === undefined || !Number.isFinite(percent)) return undefined;
+	if (percent >= 90) return "critical";
+	if (percent >= 75) return "high";
+	if (percent >= 50) return "medium";
+	return "low";
+}
+
+export function normalizeThinkingLevel(value: unknown): ThinkingLevel {
+	return ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(value as string)
+		? (value as ThinkingLevel)
+		: "off";
+}
+
+export function contextPercent(
+	value: Pick<ContextSnapshot, "currentTokens" | "windowTokens" | "percent">,
+): number | undefined {
+	const percent =
+		value.percent ??
+		(value.currentTokens !== undefined && value.windowTokens
+			? (value.currentTokens / value.windowTokens) * 100
+			: undefined);
+	return percent === undefined ? undefined : Math.max(0, Math.min(100, percent));
+}
+
+export function contextSemanticToken(state: ContextState): SemanticToken {
+	return state === "critical"
+		? "contextCritical"
+		: state === "high"
+			? "contextHigh"
+			: state === "medium"
+				? "contextMedium"
+				: "contextLow";
+}

package/extension-src/pi-style/domain/theme.ts

@@ -0,0 +1,232 @@
+import type { NormalizedPiStyleConfig } from "./config-types.js";
+
+export type GlyphMode = "nerd" | "unicode" | "ascii";
+export type SemanticToken =
+	| "surface"
+	| "surfaceRaised"
+	| "surfaceMuted"
+	| "text"
+	| "muted"
+	| "dim"
+	| "accent"
+	| "accentStrong"
+	| "border"
+	| "borderMuted"
+	| "borderActive"
+	| "success"
+	| "warning"
+	| "error"
+	| "model"
+	| "thinking"
+	| "thinkingMinimal"
+	| "thinkingLow"
+	| "thinkingMedium"
+	| "thinkingHigh"
+	| "thinkingXhigh"
+	| "thinkingMax"
+	| "path"
+	| "gitClean"
+	| "gitDirty"
+	| "contextLow"
+	| "contextMedium"
+	| "contextHigh"
+	| "contextCritical"
+	| "tokens"
+	| "cache"
+	| "cost"
+	| "time"
+	| "separator";
+
+/** Structural view of Pi's theme. fg/bg follow Pi's `(color, text) => string` shape. */
+export interface ActiveTheme {
+	fg?: (color: string, text: string) => string;
+	bg?: (color: string, text: string) => string;
+	colors?: Record<string, string>;
+}
+
+export interface ResolvedTheme {
+	/** ANSI color prefix for a semantic token, or "" when uncolored. */
+	readonly color: (token: SemanticToken) => string;
+	/** Prefix + text + reset; returns plain text when the token is uncolored. */
+	readonly apply: (token: SemanticToken, text: string) => string;
+	/** Rainbow gradient text (used for high thinking levels); plain when uncolored. */
+	readonly rainbow: (text: string) => string;
+	readonly glyph: (name: keyof typeof GLYPHS.unicode) => string;
+	readonly mode: GlyphMode;
+	readonly noColor: boolean;
+}
+
+/**
+ * Default semantic colors — hex values render without any Pi theme; theme names resolve through Pi's theme.
+ */
+const SEMANTIC_COLORS: Record<SemanticToken, string> = {
+	surface: "",
+	surfaceRaised: "",
+	surfaceMuted: "",
+	text: "text",
+	muted: "muted",
+	dim: "dim",
+	accent: "accent",
+	accentStrong: "accent",
+	border: "border",
+	borderMuted: "borderMuted",
+	borderActive: "borderAccent",
+	success: "success",
+	warning: "warning",
+	error: "error",
+	model: "#d787af",
+	thinking: "thinkingOff",
+	thinkingMinimal: "thinkingMinimal",
+	thinkingLow: "thinkingLow",
+	thinkingMedium: "thinkingMedium",
+	thinkingHigh: "thinkingHigh",
+	thinkingXhigh: "thinkingXhigh",
+	thinkingMax: "thinkingMax",
+	path: "#00afaf",
+	gitClean: "success",
+	gitDirty: "warning",
+	contextLow: "dim",
+	contextMedium: "warning",
+	contextHigh: "error",
+	contextCritical: "error",
+	tokens: "muted",
+	cache: "muted",
+	cost: "text",
+	time: "muted",
+	separator: "dim",
+};
+
+const GLYPHS = {
+	nerd: {
+		pi: "π",
+		git: "\uE0A0",
+		path: "\uF07B",
+		context: "\u{F035B}",
+		separator: "\uE0B0",
+		powerlineLeft: "\uE0B0",
+		powerlineRight: "\uE0B2",
+		powerlineThinLeft: "\uE0B1",
+		powerlineThinRight: "\uE0B3",
+	},
+	unicode: {
+		pi: "π",
+		git: "⎇",
+		path: "⌂",
+		context: "◫",
+		separator: "│",
+		powerlineLeft: "›",
+		powerlineRight: "‹",
+		powerlineThinLeft: "│",
+		powerlineThinRight: "│",
+	},
+	ascii: {
+		pi: "pi",
+		git: "git",
+		path: "path",
+		context: "ctx",
+		separator: "|",
+		powerlineLeft: ">",
+		powerlineRight: "<",
+		powerlineThinLeft: "|",
+		powerlineThinRight: "|",
+	},
+} as const;
+
+function isHex(color: string): color is `#${string}` {
+	return /^#[0-9a-fA-F]{6}$/.test(color);
+}
+
+export function hexToAnsiPrefix(hex: string): string {
+	const value = hex.replace("#", "");
+	const r = Number.parseInt(value.slice(0, 2), 16);
+	const g = Number.parseInt(value.slice(2, 4), 16);
+	const b = Number.parseInt(value.slice(4, 6), 16);
+	return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+/** Rainbow gradient for high thinking levels. */
+const RAINBOW_COLORS = [
+	"#b281d6",
+	"#d787af",
+	"#febc38",
+	"#e4c00f",
+	"#89d281",
+	"#00afaf",
+	"#178fb9",
+	"#b281d6",
+] as const;
+
+function rainbowAnsi(text: string): string {
+	let result = "";
+	let colorIndex = 0;
+	for (const char of text) {
+		if (char === " " || char === ":") {
+			result += char;
+		} else {
+			result += hexToAnsiPrefix(RAINBOW_COLORS[colorIndex % RAINBOW_COLORS.length] ?? "#b281d6") + char;
+			colorIndex++;
+		}
+	}
+	return `${result}\x1b[0m`;
+}
+
+function colorPrefixFor(
+	active: ActiveTheme | undefined,
+	config: NormalizedPiStyleConfig,
+	noColor: boolean,
+	token: SemanticToken,
+): string {
+	if (noColor) return "";
+	const raw = config.theme.colors[token] ?? SEMANTIC_COLORS[token];
+	if (!raw) return "";
+	if (isHex(raw)) return hexToAnsiPrefix(raw);
+	if (active?.fg) {
+		try {
+			// Pi's fg returns `\x1b[38;5;Nm` + text + `\x1b[39m`; keep only the prefix.
+			const styled = active.fg(raw, "");
+			return styled.endsWith("\x1b[39m") ? styled.slice(0, -5) : styled;
+		} catch {
+			return "";
+		}
+	}
+	return "";
+}
+
+export function detectGlyphMode(
+	config: NormalizedPiStyleConfig,
+	env: Record<string, string | undefined> = {},
+): GlyphMode {
+	if (env.PI_STYLE_NERD_FONTS === "1") return "nerd";
+	if (env.PI_STYLE_NERD_FONTS === "0") return "unicode";
+	if (config.theme.nerdFonts === "on") return "nerd";
+	if (config.theme.nerdFonts === "off") return "unicode";
+	if (env.GHOSTTY_RESOURCES_DIR) return "nerd";
+	// Conservative heuristic: known terminals commonly ship with a Nerd Font. An explicit override stays authoritative.
+	const term = (env.TERM_PROGRAM ?? "").toLowerCase();
+	if (["iterm", "wezterm", "kitty", "ghostty", "alacritty", "warp"].some((name) => term.includes(name))) {
+		return "nerd";
+	}
+	return config.preset === "ascii" ? "ascii" : "unicode";
+}
+
+export function resolveTheme(
+	active: ActiveTheme | undefined,
+	config: NormalizedPiStyleConfig,
+	env: Record<string, string | undefined> = {},
+): ResolvedTheme {
+	const noColor = Object.hasOwn(env, "NO_COLOR") && env.NO_COLOR !== "" && config.theme.colors.colorOverride !== "on";
+	const mode = config.preset === "ascii" ? "ascii" : detectGlyphMode(config, env);
+	const color = (token: SemanticToken) => colorPrefixFor(active, config, noColor, token);
+	return {
+		mode,
+		noColor,
+		color,
+		apply: (token, text) => {
+			const prefix = color(token);
+			return prefix ? `${prefix}${text}\x1b[0m` : text;
+		},
+		rainbow: (text) => (noColor ? text : rainbowAnsi(text)),
+		glyph: (name) => config.theme.glyphs[name] ?? GLYPHS[mode][name],
+	};
+}
+export { GLYPHS };