@openspecui/core 3.4.1 → 3.5.0

package/dist/notifications.mjs

@@ -0,0 +1,5 @@
+import "./sounds-C0dNSFm8.mjs";
+import { n as terminalNotificationEventToPublishInput, t as TerminalControlParser } from "./terminal-control-DtBprY6-.mjs";
+import { a as NotificationPublishInputSchema, c as NotificationSoundSchema, d as aggregateNotifications, f as getNotificationAggregateKey, h as groupNotifications, i as NotificationGroupKeySchema, l as NotificationSourceSchema, m as getNotificationGroupLabel, n as NOTIFICATION_SOUND_VALUES, o as NotificationRecordSchema, p as getNotificationGroupKey, r as NotificationActionSchema, s as NotificationSettingsSchema, t as NOTIFICATION_SOUND_OPTIONS, u as TerminalNotificationParser } from "./notifications-F81mmO55.mjs";
+
+export { NOTIFICATION_SOUND_OPTIONS, NOTIFICATION_SOUND_VALUES, NotificationActionSchema, NotificationGroupKeySchema, NotificationPublishInputSchema, NotificationRecordSchema, NotificationSettingsSchema, NotificationSoundSchema, NotificationSourceSchema, TerminalControlParser, TerminalNotificationParser, aggregateNotifications, getNotificationAggregateKey, getNotificationGroupKey, getNotificationGroupLabel, groupNotifications, terminalNotificationEventToPublishInput };

package/dist/opsx-display-path.d.mts

@@ -1,2 +1,2 @@
-import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-ElGeez1E.mjs";
+import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-CuQyGB_A.mjs";
 export { VIRTUAL_PROJECT_DIRNAME, toOpsxDisplayPath };

package/dist/opsx-display-path.mjs

@@ -1,3 +1,3 @@
-import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-DNqQo2uK.mjs";
+import { n as toOpsxDisplayPath, t as VIRTUAL_PROJECT_DIRNAME } from "./opsx-display-path-B6Owu17P.mjs";
 
 export { VIRTUAL_PROJECT_DIRNAME, toOpsxDisplayPath };

package/dist/sounds-C0dNSFm8.mjs

@@ -0,0 +1,158 @@
+import { z } from "zod";
+
+//#region src/sounds.ts
+const SILENT_SOUND_ID = "silent";
+const DEFAULT_BELL_SOUND_ID = "builtin:Tink";
+const DEFAULT_NOTIFICATION_SOUND_ID = "builtin:Blow";
+const DEFAULT_SOUND_VOLUME = 1;
+const CUSTOM_SOUND_ADD_VALUE = "custom:add";
+const BUILTIN_SOUND_IDS = [
+	"builtin:Basso",
+	"builtin:Blow",
+	"builtin:Bottle",
+	"builtin:Frog",
+	"builtin:Funk",
+	"builtin:Glass",
+	"builtin:Hero",
+	"builtin:Morse",
+	"builtin:Ping",
+	"builtin:Pop",
+	"builtin:Purr",
+	"builtin:Sosumi",
+	"builtin:Submarine",
+	"builtin:Tink"
+];
+const BuiltinSoundIdSchema = z.enum(BUILTIN_SOUND_IDS);
+const CustomSoundHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+const CustomSoundIdSchema = z.custom((value) => typeof value === "string" && /^custom:[a-f0-9]{64}$/.test(value));
+const SoundIdSchema = z.union([
+	z.literal(SILENT_SOUND_ID),
+	BuiltinSoundIdSchema,
+	CustomSoundIdSchema
+]);
+const LEGACY_SOUND_ID_MAP = {
+	silent: SILENT_SOUND_ID,
+	bell: DEFAULT_BELL_SOUND_ID,
+	soft: DEFAULT_NOTIFICATION_SOUND_ID,
+	clear: "builtin:Glass",
+	pulse: "builtin:Tink"
+};
+function normalizeLegacySoundId(value) {
+	if (typeof value !== "string") return value;
+	if (Object.prototype.hasOwnProperty.call(LEGACY_SOUND_ID_MAP, value)) return LEGACY_SOUND_ID_MAP[value];
+	return value;
+}
+const SoundConfigIdSchema = z.preprocess(normalizeLegacySoundId, SoundIdSchema);
+const SoundVolumeSchema = z.number().min(0).max(1).default(DEFAULT_SOUND_VOLUME);
+const BUILTIN_SOUND_OPTIONS = [
+	{
+		id: "builtin:Basso",
+		label: "Basso",
+		filename: "Basso.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Blow",
+		label: "Blow",
+		filename: "Blow.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Bottle",
+		label: "Bottle",
+		filename: "Bottle.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Frog",
+		label: "Frog",
+		filename: "Frog.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Funk",
+		label: "Funk",
+		filename: "Funk.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Glass",
+		label: "Glass",
+		filename: "Glass.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Hero",
+		label: "Hero",
+		filename: "Hero.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Morse",
+		label: "Morse",
+		filename: "Morse.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Ping",
+		label: "Ping",
+		filename: "Ping.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Pop",
+		label: "Pop",
+		filename: "Pop.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Purr",
+		label: "Purr",
+		filename: "Purr.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Sosumi",
+		label: "Sosumi",
+		filename: "Sosumi.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Submarine",
+		label: "Submarine",
+		filename: "Submarine.wav",
+		mime: "audio/wav"
+	},
+	{
+		id: "builtin:Tink",
+		label: "Tink",
+		filename: "Tink.wav",
+		mime: "audio/wav"
+	}
+];
+const CustomSoundMetadataSchema = z.object({
+	id: CustomSoundHashSchema,
+	name: z.string().min(1),
+	mime: z.string().regex(/^audio\//),
+	size: z.number().int().nonnegative(),
+	createdAt: z.number().int().positive(),
+	updatedAt: z.number().int().positive()
+});
+const CustomSoundMetadataFileSchema = z.record(CustomSoundHashSchema, CustomSoundMetadataSchema);
+function soundIdFromCustomHash(hash) {
+	return `custom:${hash}`;
+}
+function customHashFromSoundId(soundId) {
+	if (!soundId.startsWith("custom:")) return null;
+	const hash = soundId.slice(7);
+	const parsed = CustomSoundHashSchema.safeParse(hash);
+	return parsed.success ? parsed.data : null;
+}
+function getBuiltinSoundUrl(soundId) {
+	if (soundId === SILENT_SOUND_ID || !soundId.startsWith("builtin:")) return null;
+	const option = BUILTIN_SOUND_OPTIONS.find((item) => item.id === soundId);
+	return option ? `/sounds/${option.filename}` : null;
+}
+
+//#endregion
+export { customHashFromSoundId as _, CustomSoundHashSchema as a, soundIdFromCustomHash as b, CustomSoundMetadataSchema as c, DEFAULT_SOUND_VOLUME as d, LEGACY_SOUND_ID_MAP as f, SoundVolumeSchema as g, SoundIdSchema as h, CUSTOM_SOUND_ADD_VALUE as i, DEFAULT_BELL_SOUND_ID as l, SoundConfigIdSchema as m, BUILTIN_SOUND_OPTIONS as n, CustomSoundIdSchema as o, SILENT_SOUND_ID as p, BuiltinSoundIdSchema as r, CustomSoundMetadataFileSchema as s, BUILTIN_SOUND_IDS as t, DEFAULT_NOTIFICATION_SOUND_ID as u, getBuiltinSoundUrl as v, normalizeLegacySoundId as y };

package/dist/sounds-CxwbTXZS.d.mts

@@ -0,0 +1,86 @@
+import { z } from "zod";
+
+//#region src/sounds.d.ts
+declare const SILENT_SOUND_ID = "silent";
+declare const DEFAULT_BELL_SOUND_ID = "builtin:Tink";
+declare const DEFAULT_NOTIFICATION_SOUND_ID = "builtin:Blow";
+declare const DEFAULT_SOUND_VOLUME = 1;
+declare const CUSTOM_SOUND_ADD_VALUE = "custom:add";
+declare const BUILTIN_SOUND_IDS: readonly ["builtin:Basso", "builtin:Blow", "builtin:Bottle", "builtin:Frog", "builtin:Funk", "builtin:Glass", "builtin:Hero", "builtin:Morse", "builtin:Ping", "builtin:Pop", "builtin:Purr", "builtin:Sosumi", "builtin:Submarine", "builtin:Tink"];
+declare const BuiltinSoundIdSchema: z.ZodEnum<["builtin:Basso", "builtin:Blow", "builtin:Bottle", "builtin:Frog", "builtin:Funk", "builtin:Glass", "builtin:Hero", "builtin:Morse", "builtin:Ping", "builtin:Pop", "builtin:Purr", "builtin:Sosumi", "builtin:Submarine", "builtin:Tink"]>;
+type BuiltinSoundId = z.infer<typeof BuiltinSoundIdSchema>;
+declare const CustomSoundHashSchema: z.ZodString;
+type CustomSoundHash = z.infer<typeof CustomSoundHashSchema>;
+declare const CustomSoundIdSchema: z.ZodType<`custom:${string}`, z.ZodTypeDef, `custom:${string}`>;
+type CustomSoundId = z.infer<typeof CustomSoundIdSchema>;
+declare const SoundIdSchema: z.ZodUnion<[z.ZodLiteral<"silent">, z.ZodEnum<["builtin:Basso", "builtin:Blow", "builtin:Bottle", "builtin:Frog", "builtin:Funk", "builtin:Glass", "builtin:Hero", "builtin:Morse", "builtin:Ping", "builtin:Pop", "builtin:Purr", "builtin:Sosumi", "builtin:Submarine", "builtin:Tink"]>, z.ZodType<`custom:${string}`, z.ZodTypeDef, `custom:${string}`>]>;
+type SoundId = z.infer<typeof SoundIdSchema>;
+declare const LEGACY_SOUND_ID_MAP: {
+  readonly silent: "silent";
+  readonly bell: "builtin:Tink";
+  readonly soft: "builtin:Blow";
+  readonly clear: "builtin:Glass";
+  readonly pulse: "builtin:Tink";
+};
+declare function normalizeLegacySoundId(value: unknown): unknown;
+declare const SoundConfigIdSchema: z.ZodEffects<z.ZodUnion<[z.ZodLiteral<"silent">, z.ZodEnum<["builtin:Basso", "builtin:Blow", "builtin:Bottle", "builtin:Frog", "builtin:Funk", "builtin:Glass", "builtin:Hero", "builtin:Morse", "builtin:Ping", "builtin:Pop", "builtin:Purr", "builtin:Sosumi", "builtin:Submarine", "builtin:Tink"]>, z.ZodType<`custom:${string}`, z.ZodTypeDef, `custom:${string}`>]>, "silent" | "builtin:Tink" | "builtin:Blow" | "builtin:Basso" | "builtin:Bottle" | "builtin:Frog" | "builtin:Funk" | "builtin:Glass" | "builtin:Hero" | "builtin:Morse" | "builtin:Ping" | "builtin:Pop" | "builtin:Purr" | "builtin:Sosumi" | "builtin:Submarine" | `custom:${string}`, unknown>;
+declare const SoundVolumeSchema: z.ZodDefault<z.ZodNumber>;
+type SoundVolume = z.infer<typeof SoundVolumeSchema>;
+interface BuiltinSoundOption {
+  id: BuiltinSoundId;
+  label: string;
+  filename: string;
+  mime: string;
+}
+declare const BUILTIN_SOUND_OPTIONS: readonly BuiltinSoundOption[];
+declare const CustomSoundMetadataSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  mime: z.ZodString;
+  size: z.ZodNumber;
+  createdAt: z.ZodNumber;
+  updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  name: string;
+  mime: string;
+  size: number;
+  createdAt: number;
+  updatedAt: number;
+}, {
+  id: string;
+  name: string;
+  mime: string;
+  size: number;
+  createdAt: number;
+  updatedAt: number;
+}>;
+type CustomSoundMetadata = z.infer<typeof CustomSoundMetadataSchema>;
+declare const CustomSoundMetadataFileSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  mime: z.ZodString;
+  size: z.ZodNumber;
+  createdAt: z.ZodNumber;
+  updatedAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+  id: string;
+  name: string;
+  mime: string;
+  size: number;
+  createdAt: number;
+  updatedAt: number;
+}, {
+  id: string;
+  name: string;
+  mime: string;
+  size: number;
+  createdAt: number;
+  updatedAt: number;
+}>>;
+type CustomSoundMetadataFile = z.infer<typeof CustomSoundMetadataFileSchema>;
+declare function soundIdFromCustomHash(hash: CustomSoundHash): CustomSoundId;
+declare function customHashFromSoundId(soundId: SoundId): CustomSoundHash | null;
+declare function getBuiltinSoundUrl(soundId: SoundId): string | null;
+//#endregion
+export { SoundVolume as C, normalizeLegacySoundId as D, getBuiltinSoundUrl as E, soundIdFromCustomHash as O, SoundIdSchema as S, customHashFromSoundId as T, DEFAULT_SOUND_VOLUME as _, BuiltinSoundOption as a, SoundConfigIdSchema as b, CustomSoundHashSchema as c, CustomSoundMetadata as d, CustomSoundMetadataFile as f, DEFAULT_NOTIFICATION_SOUND_ID as g, DEFAULT_BELL_SOUND_ID as h, BuiltinSoundIdSchema as i, CustomSoundId as l, CustomSoundMetadataSchema as m, BUILTIN_SOUND_OPTIONS as n, CUSTOM_SOUND_ADD_VALUE as o, CustomSoundMetadataFileSchema as p, BuiltinSoundId as r, CustomSoundHash as s, BUILTIN_SOUND_IDS as t, CustomSoundIdSchema as u, LEGACY_SOUND_ID_MAP as v, SoundVolumeSchema as w, SoundId as x, SILENT_SOUND_ID as y };

package/dist/sounds.d.mts

@@ -0,0 +1,2 @@
+import { C as SoundVolume, D as normalizeLegacySoundId, E as getBuiltinSoundUrl, O as soundIdFromCustomHash, S as SoundIdSchema, T as customHashFromSoundId, _ as DEFAULT_SOUND_VOLUME, a as BuiltinSoundOption, b as SoundConfigIdSchema, c as CustomSoundHashSchema, d as CustomSoundMetadata, f as CustomSoundMetadataFile, g as DEFAULT_NOTIFICATION_SOUND_ID, h as DEFAULT_BELL_SOUND_ID, i as BuiltinSoundIdSchema, l as CustomSoundId, m as CustomSoundMetadataSchema, n as BUILTIN_SOUND_OPTIONS, o as CUSTOM_SOUND_ADD_VALUE, p as CustomSoundMetadataFileSchema, r as BuiltinSoundId, s as CustomSoundHash, t as BUILTIN_SOUND_IDS, u as CustomSoundIdSchema, v as LEGACY_SOUND_ID_MAP, w as SoundVolumeSchema, x as SoundId, y as SILENT_SOUND_ID } from "./sounds-CxwbTXZS.mjs";
+export { BUILTIN_SOUND_IDS, BUILTIN_SOUND_OPTIONS, BuiltinSoundId, BuiltinSoundIdSchema, BuiltinSoundOption, CUSTOM_SOUND_ADD_VALUE, CustomSoundHash, CustomSoundHashSchema, CustomSoundId, CustomSoundIdSchema, CustomSoundMetadata, CustomSoundMetadataFile, CustomSoundMetadataFileSchema, CustomSoundMetadataSchema, DEFAULT_BELL_SOUND_ID, DEFAULT_NOTIFICATION_SOUND_ID, DEFAULT_SOUND_VOLUME, LEGACY_SOUND_ID_MAP, SILENT_SOUND_ID, SoundConfigIdSchema, SoundId, SoundIdSchema, SoundVolume, SoundVolumeSchema, customHashFromSoundId, getBuiltinSoundUrl, normalizeLegacySoundId, soundIdFromCustomHash };

package/dist/sounds.mjs

@@ -0,0 +1,3 @@
+import { _ as customHashFromSoundId, a as CustomSoundHashSchema, b as soundIdFromCustomHash, c as CustomSoundMetadataSchema, d as DEFAULT_SOUND_VOLUME, f as LEGACY_SOUND_ID_MAP, g as SoundVolumeSchema, h as SoundIdSchema, i as CUSTOM_SOUND_ADD_VALUE, l as DEFAULT_BELL_SOUND_ID, m as SoundConfigIdSchema, n as BUILTIN_SOUND_OPTIONS, o as CustomSoundIdSchema, p as SILENT_SOUND_ID, r as BuiltinSoundIdSchema, s as CustomSoundMetadataFileSchema, t as BUILTIN_SOUND_IDS, u as DEFAULT_NOTIFICATION_SOUND_ID, v as getBuiltinSoundUrl, y as normalizeLegacySoundId } from "./sounds-C0dNSFm8.mjs";
+
+export { BUILTIN_SOUND_IDS, BUILTIN_SOUND_OPTIONS, BuiltinSoundIdSchema, CUSTOM_SOUND_ADD_VALUE, CustomSoundHashSchema, CustomSoundIdSchema, CustomSoundMetadataFileSchema, CustomSoundMetadataSchema, DEFAULT_BELL_SOUND_ID, DEFAULT_NOTIFICATION_SOUND_ID, DEFAULT_SOUND_VOLUME, LEGACY_SOUND_ID_MAP, SILENT_SOUND_ID, SoundConfigIdSchema, SoundIdSchema, SoundVolumeSchema, customHashFromSoundId, getBuiltinSoundUrl, normalizeLegacySoundId, soundIdFromCustomHash };

package/dist/terminal-audio-BoSdMyBY.d.mts

@@ -0,0 +1,13 @@
+import { x as SoundId } from "./sounds-CxwbTXZS.mjs";
+import * as zod0 from "zod";
+
+//#region src/terminal-audio.d.ts
+declare const TERMINAL_BELL_SOUND_VALUES: readonly ["silent", "bell", "soft", "clear", "pulse"];
+declare const TerminalBellSoundSchema: zod0.ZodEffects<zod0.ZodUnion<[zod0.ZodLiteral<"silent">, zod0.ZodEnum<["builtin:Basso", "builtin:Blow", "builtin:Bottle", "builtin:Frog", "builtin:Funk", "builtin:Glass", "builtin:Hero", "builtin:Morse", "builtin:Ping", "builtin:Pop", "builtin:Purr", "builtin:Sosumi", "builtin:Submarine", "builtin:Tink"]>, zod0.ZodType<`custom:${string}`, zod0.ZodTypeDef, `custom:${string}`>]>, "silent" | "builtin:Tink" | "builtin:Blow" | "builtin:Basso" | "builtin:Bottle" | "builtin:Frog" | "builtin:Funk" | "builtin:Glass" | "builtin:Hero" | "builtin:Morse" | "builtin:Ping" | "builtin:Pop" | "builtin:Purr" | "builtin:Sosumi" | "builtin:Submarine" | `custom:${string}`, unknown>;
+type TerminalBellSound = SoundId;
+declare const TERMINAL_BELL_SOUND_OPTIONS: readonly {
+  id: TerminalBellSound;
+  label: string;
+}[];
+//#endregion
+export { TerminalBellSoundSchema as i, TERMINAL_BELL_SOUND_VALUES as n, TerminalBellSound as r, TERMINAL_BELL_SOUND_OPTIONS as t };

package/dist/terminal-audio-DDwxz9sJ.mjs

@@ -0,0 +1,21 @@
+import { l as DEFAULT_BELL_SOUND_ID, m as SoundConfigIdSchema } from "./sounds-C0dNSFm8.mjs";
+
+//#region src/terminal-audio.ts
+const TERMINAL_BELL_SOUND_VALUES = [
+	"silent",
+	"bell",
+	"soft",
+	"clear",
+	"pulse"
+];
+const TerminalBellSoundSchema = SoundConfigIdSchema;
+const TERMINAL_BELL_SOUND_OPTIONS = [{
+	id: DEFAULT_BELL_SOUND_ID,
+	label: "Tink"
+}, {
+	id: "silent",
+	label: "Silent"
+}];
+
+//#endregion
+export { TERMINAL_BELL_SOUND_VALUES as n, TerminalBellSoundSchema as r, TERMINAL_BELL_SOUND_OPTIONS as t };

package/dist/terminal-audio.d.mts

@@ -0,0 +1,3 @@
+import "./sounds-CxwbTXZS.mjs";
+import { i as TerminalBellSoundSchema, n as TERMINAL_BELL_SOUND_VALUES, r as TerminalBellSound, t as TERMINAL_BELL_SOUND_OPTIONS } from "./terminal-audio-BoSdMyBY.mjs";
+export { TERMINAL_BELL_SOUND_OPTIONS, TERMINAL_BELL_SOUND_VALUES, TerminalBellSound, TerminalBellSoundSchema };

package/dist/terminal-audio.mjs

@@ -0,0 +1,4 @@
+import "./sounds-C0dNSFm8.mjs";
+import { n as TERMINAL_BELL_SOUND_VALUES, r as TerminalBellSoundSchema, t as TERMINAL_BELL_SOUND_OPTIONS } from "./terminal-audio-DDwxz9sJ.mjs";
+
+export { TERMINAL_BELL_SOUND_OPTIONS, TERMINAL_BELL_SOUND_VALUES, TerminalBellSoundSchema };

package/dist/terminal-control-DtBprY6-.mjs

@@ -0,0 +1,236 @@
+//#region src/terminal-control.ts
+const MAX_OSC_BUFFER_LENGTH = 8192;
+function decodeOscText(input) {
+	return input.replace(/\r?\n/g, " ").trim();
+}
+function parseProgressState(value) {
+	if (value === "0") return "clear";
+	if (value === "1") return "set";
+	if (value === "2") return "error";
+	if (value === "3") return "indeterminate";
+	if (value === "4") return "warning";
+	return null;
+}
+function parseProgressValue(value) {
+	if (value === void 0 || value.trim() === "") return null;
+	const parsed = Number(value);
+	if (!Number.isFinite(parsed)) return null;
+	return Math.min(100, Math.max(0, Math.round(parsed)));
+}
+function parseFileUriPath(value) {
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	try {
+		const url = new URL(trimmed);
+		if (url.protocol !== "file:") return null;
+		return decodeURIComponent(url.pathname);
+	} catch {
+		return trimmed;
+	}
+}
+function parsePromptState(rest) {
+	const marker = rest[0];
+	const suffix = rest.slice(1);
+	if (marker === "A") return {
+		type: "prompt-state",
+		state: "prompt-start"
+	};
+	if (marker === "B") return {
+		type: "prompt-state",
+		state: "prompt-end"
+	};
+	if (marker === "C") return {
+		type: "prompt-state",
+		state: "command-start"
+	};
+	if (marker === "D") {
+		const exitCodeText = suffix.startsWith(";") ? suffix.slice(1).split(";")[0] : "";
+		const exitCode = exitCodeText ? Number(exitCodeText) : void 0;
+		return Number.isInteger(exitCode) ? {
+			type: "prompt-state",
+			state: "command-end",
+			exitCode
+		} : {
+			type: "prompt-state",
+			state: "command-end"
+		};
+	}
+	return null;
+}
+function parseVsCodeShellIntegration(rest) {
+	const marker = rest[0];
+	const suffix = rest.slice(1);
+	if (marker === "A") return {
+		type: "prompt-state",
+		state: "prompt-start"
+	};
+	if (marker === "B") return {
+		type: "prompt-state",
+		state: "prompt-end"
+	};
+	if (marker === "C") return {
+		type: "prompt-state",
+		state: "command-start"
+	};
+	if (marker === "D") {
+		const exitCodeText = suffix.startsWith(";") ? suffix.slice(1).split(";")[0] : "";
+		const exitCode = exitCodeText ? Number(exitCodeText) : void 0;
+		return Number.isInteger(exitCode) ? {
+			type: "prompt-state",
+			state: "command-end",
+			exitCode
+		} : {
+			type: "prompt-state",
+			state: "command-end"
+		};
+	}
+	if (marker === "P") {
+		if (!suffix.startsWith(";Cwd=")) return null;
+		const cwd = decodeOscText(suffix.slice(5));
+		return cwd ? {
+			type: "cwd",
+			cwd
+		} : null;
+	}
+	return null;
+}
+function parseITerm2Control(rest) {
+	if (!rest.startsWith("CurrentDir=")) return null;
+	const cwd = decodeOscText(rest.slice(11));
+	return cwd ? {
+		type: "cwd",
+		cwd
+	} : null;
+}
+function parseOscPayload(payload) {
+	const firstSeparator = payload.indexOf(";");
+	const command = firstSeparator === -1 ? payload : payload.slice(0, firstSeparator);
+	const rest = firstSeparator === -1 ? "" : payload.slice(firstSeparator + 1);
+	if (command === "0" || command === "1" || command === "2") {
+		const title$1 = decodeOscText(rest);
+		if (!title$1) return null;
+		return {
+			type: "title",
+			title: title$1,
+			target: command === "1" ? "icon" : command === "2" ? "window" : "both"
+		};
+	}
+	if (command === "7") {
+		const cwd = parseFileUriPath(rest);
+		return cwd ? {
+			type: "cwd",
+			cwd
+		} : null;
+	}
+	if (command === "9") {
+		if (rest.startsWith("4;")) {
+			const parts$1 = rest.slice(2).split(";");
+			const state = parseProgressState(parts$1[0] ?? "");
+			if (!state) return null;
+			return {
+				type: "progress",
+				state,
+				value: parseProgressValue(parts$1[1])
+			};
+		}
+		if (rest.startsWith("9;")) {
+			const cwd = decodeOscText(rest.slice(2));
+			return cwd ? {
+				type: "cwd",
+				cwd
+			} : null;
+		}
+		const body$1 = decodeOscText(rest);
+		return body$1 ? {
+			type: "notification",
+			protocol: "osc9",
+			body: body$1
+		} : null;
+	}
+	if (command === "133") return parsePromptState(rest);
+	if (command === "633") return parseVsCodeShellIntegration(rest);
+	if (command === "1337") return parseITerm2Control(rest);
+	if (command !== "777") return null;
+	const parts = rest.split(";");
+	if (parts[0]?.trim().toLowerCase() !== "notify") return null;
+	const title = decodeOscText(parts[1] ?? "");
+	const body = decodeOscText(parts.slice(2).join(";"));
+	return {
+		type: "notification",
+		protocol: "osc777",
+		title: title || "Terminal notification",
+		body
+	};
+}
+/**
+* Stateful parser for terminal control escape sequences.
+*
+* It extracts terminal-local control metadata separately from notification
+* intents so progress, title, cwd, and prompt-state protocols cannot leak into
+* the web notification platform.
+*/
+var TerminalControlParser = class {
+	pending = "";
+	push(chunk) {
+		const input = this.pending + chunk;
+		this.pending = "";
+		let output = "";
+		const events = [];
+		let index = 0;
+		while (index < input.length) {
+			const char = input[index];
+			if (char === "\x07") {
+				events.push({ type: "bell" });
+				index += 1;
+				continue;
+			}
+			if (char !== "\x1B" || input[index + 1] !== "]") {
+				output += char;
+				index += 1;
+				continue;
+			}
+			const sequenceStart = index;
+			const payloadStart = index + 2;
+			const belEnd = input.indexOf("\x07", payloadStart);
+			const stEnd = input.indexOf("\x1B\\", payloadStart);
+			const end = belEnd === -1 ? stEnd : stEnd === -1 ? belEnd : Math.min(belEnd, stEnd);
+			if (end === -1) {
+				const pending = input.slice(sequenceStart);
+				if (pending.length <= MAX_OSC_BUFFER_LENGTH) this.pending = pending;
+				else output += pending;
+				break;
+			}
+			const event = parseOscPayload(input.slice(payloadStart, end));
+			if (event) events.push(event);
+			else output += input.slice(sequenceStart, end + (end === stEnd ? 2 : 1));
+			index = end + (end === stEnd ? 2 : 1);
+		}
+		return {
+			output,
+			events
+		};
+	}
+};
+function terminalNotificationEventToPublishInput(input) {
+	const fallbackTitle = input.terminalTitle?.trim() || input.sessionId;
+	const source = {
+		type: "terminal",
+		sessionId: input.sessionId,
+		title: fallbackTitle
+	};
+	const actions = [{
+		type: "terminal.focus",
+		label: "Focus terminal",
+		target: { sessionId: input.sessionId }
+	}];
+	return {
+		title: input.event.title ?? fallbackTitle,
+		body: input.event.body,
+		source,
+		actions,
+		level: "info"
+	};
+}
+
+//#endregion
+export { terminalNotificationEventToPublishInput as n, TerminalControlParser as t };

package/dist/terminal-control.d.mts

@@ -0,0 +1,3 @@
+import "./sounds-CxwbTXZS.mjs";
+import { A as TerminalNotificationProtocol, D as TerminalControlEvent, M as TerminalPromptState, N as TerminalTitleTarget, O as TerminalControlParseResult, P as terminalNotificationEventToPublishInput, j as TerminalProgressState, k as TerminalControlParser } from "./notifications-DOQwtdfS.mjs";
+export { TerminalControlEvent, TerminalControlParseResult, TerminalControlParser, TerminalNotificationProtocol, TerminalProgressState, TerminalPromptState, TerminalTitleTarget, terminalNotificationEventToPublishInput };

package/dist/terminal-control.mjs

@@ -0,0 +1,3 @@
+import { n as terminalNotificationEventToPublishInput, t as TerminalControlParser } from "./terminal-control-DtBprY6-.mjs";
+
+export { TerminalControlParser, terminalNotificationEventToPublishInput };