t3code-cli 0.12.0 → 0.14.0

package/dist/shared/shell.js

@@ -0,0 +1,408 @@
+import { EO as succeed, HD as as, KO as TaggedError, OE as FileSystem, Ok as Reference, TE as Path, _O as orElseSucceed, eO as fn, qD as catchTag, w as HostProcessPlatform, x as HostProcessEnvironment } from "../shared.js";
+import * as NodeOS from "node:os";
+import * as NodeChildProcess from "node:child_process";
+import * as NodeFS from "node:fs";
+import * as NodePath from "node:path";
+//#region upstream-t3code/packages/shared/src/shell.ts
+const PATH_CAPTURE_START = "__T3CODE_PATH_START__";
+const PATH_CAPTURE_END = "__T3CODE_PATH_END__";
+const SHELL_ENV_NAME_PATTERN = /^[A-Z0-9_]+$/;
+const WINDOWS_PATH_DELIMITER = ";";
+const POSIX_PATH_DELIMITER = ":";
+const WINDOWS_SHELL_CANDIDATES = ["pwsh.exe", "powershell.exe"];
+function canExecuteFile(filePath) {
+	try {
+		NodeFS.accessSync(filePath, NodeFS.constants.X_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+var CommandResolutionError = class extends TaggedError("CommandResolutionError") {};
+const WINDOWS_SHELL_META_CHARS = /([()\][%!^"`<>&|;, *?])/g;
+/**
+* Escapes a single argument for `cmd.exe` shell mode (`spawn(..., { shell: true })`
+* on Windows). Node joins the command and arguments with spaces and hands the
+* resulting string to `cmd.exe` without any quoting, so every dynamic argument
+* must be escaped to survive both cmd.exe parsing and the target program's
+* `CommandLineToArgvW` parsing. Mirrors cross-spawn's argument escaping.
+*/
+function escapeWindowsShellArg(arg) {
+	let escaped = arg.replace(/(\\*)"/g, "$1$1\\\"");
+	escaped = escaped.replace(/(\\*)$/, "$1$1");
+	escaped = `"${escaped}"`;
+	return escaped.replace(WINDOWS_SHELL_META_CHARS, "^$1");
+}
+/**
+* Escapes arguments for shell-mode spawns: applies {@link escapeWindowsShellArg}
+* when the platform is `win32` (where `shell: true` routes through `cmd.exe`)
+* and returns the arguments untouched everywhere else.
+*/
+function sanitizeShellModeArgsForPlatform(args, platform) {
+	return platform === "win32" ? args.map(escapeWindowsShellArg) : [...args];
+}
+function resolveSpawnExecutableWithNode(command, platform, env) {
+	const path = platform === "win32" ? NodePath.win32 : NodePath.posix;
+	const windowsPathExtensions = platform === "win32" ? resolveWindowsPathExtensions(env) : [];
+	const candidates = resolveCommandCandidates(command, platform, windowsPathExtensions, path.extname);
+	const isExecutable = (candidate) => {
+		try {
+			if (!NodeFS.statSync(candidate).isFile()) return false;
+			if (platform === "win32") return windowsPathExtensions.includes(path.extname(candidate).toUpperCase());
+			return canExecuteFile(candidate);
+		} catch {
+			return false;
+		}
+	};
+	if (command.includes("/") || command.includes("\\")) return candidates.find(isExecutable);
+	for (const pathEntry of (readEnvPath(env) ?? "").split(pathDelimiterForPlatform(platform))) {
+		const normalizedPathEntry = stripWrappingQuotes(pathEntry.trim());
+		if (normalizedPathEntry.length === 0) continue;
+		for (const candidate of candidates) {
+			const candidatePath = path.join(normalizedPathEntry, candidate);
+			if (isExecutable(candidatePath)) return candidatePath;
+		}
+	}
+}
+const SpawnExecutableResolution = Reference("@t3tools/shared/shell/SpawnExecutableResolution", { defaultValue: () => resolveSpawnExecutableWithNode });
+function trimNonEmpty(value) {
+	const trimmed = value?.trim();
+	return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function readUserLoginShell() {
+	try {
+		return trimNonEmpty(NodeOS.userInfo().shell);
+	} catch {
+		return;
+	}
+}
+function listLoginShellCandidates(platform, shell, userShell = readUserLoginShell()) {
+	const fallbackShell = platform === "darwin" ? "/bin/zsh" : platform === "linux" ? "/bin/bash" : void 0;
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	for (const candidate of [
+		trimNonEmpty(shell),
+		trimNonEmpty(userShell),
+		fallbackShell
+	]) {
+		if (!candidate || seen.has(candidate)) continue;
+		seen.add(candidate);
+		candidates.push(candidate);
+	}
+	return candidates;
+}
+function extractPathFromShellOutput(output) {
+	const startIndex = output.indexOf(PATH_CAPTURE_START);
+	if (startIndex === -1) return null;
+	const valueStartIndex = startIndex + 21;
+	const endIndex = output.indexOf(PATH_CAPTURE_END, valueStartIndex);
+	if (endIndex === -1) return null;
+	const pathValue = output.slice(valueStartIndex, endIndex).trim();
+	return pathValue.length > 0 ? pathValue : null;
+}
+function readPathFromLoginShell(shell, execFile = NodeChildProcess.execFileSync) {
+	return readEnvironmentFromLoginShell(shell, ["PATH"], execFile).PATH;
+}
+function readPathFromLaunchctl(execFile = NodeChildProcess.execFileSync) {
+	try {
+		return trimNonEmpty(execFile("/bin/launchctl", ["getenv", "PATH"], {
+			encoding: "utf8",
+			timeout: 2e3
+		}));
+	} catch {
+		return;
+	}
+}
+function mergePathEntries(preferredPath, inheritedPath, platform) {
+	const delimiter = platform === "win32" ? ";" : ":";
+	const merged = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const pathValue of [preferredPath, inheritedPath]) {
+		if (!pathValue) continue;
+		for (const entry of pathValue.split(delimiter)) {
+			const trimmedEntry = entry.trim();
+			if (!trimmedEntry || seen.has(trimmedEntry)) continue;
+			seen.add(trimmedEntry);
+			merged.push(trimmedEntry);
+		}
+	}
+	return merged.length > 0 ? merged.join(delimiter) : void 0;
+}
+function envCaptureStart(name) {
+	return `__T3CODE_ENV_${name}_START__`;
+}
+function envCaptureEnd(name) {
+	return `__T3CODE_ENV_${name}_END__`;
+}
+function buildEnvironmentCaptureCommand(names) {
+	return names.map((name) => {
+		if (!SHELL_ENV_NAME_PATTERN.test(name)) throw new Error(`Unsupported environment variable name: ${name}`);
+		return [
+			`printf '%s\\n' '${envCaptureStart(name)}'`,
+			`printenv ${name} || true`,
+			`printf '%s\\n' '${envCaptureEnd(name)}'`
+		].join("; ");
+	}).join("; ");
+}
+function buildWindowsEnvironmentCaptureCommand(names) {
+	return ["$ErrorActionPreference = 'Stop'", ...names.flatMap((name) => {
+		if (!SHELL_ENV_NAME_PATTERN.test(name)) throw new Error(`Unsupported environment variable name: ${name}`);
+		return [
+			`Write-Output '${envCaptureStart(name)}'`,
+			`$value = [Environment]::GetEnvironmentVariable('${name}')`,
+			"if ($null -ne $value -and $value.Length -gt 0) { Write-Output $value }",
+			`Write-Output '${envCaptureEnd(name)}'`
+		];
+	})].join("; ");
+}
+function extractEnvironmentValue(output, name) {
+	const startMarker = envCaptureStart(name);
+	const endMarker = envCaptureEnd(name);
+	const startIndex = output.indexOf(startMarker);
+	if (startIndex === -1) return void 0;
+	const valueStartIndex = startIndex + startMarker.length;
+	const endIndex = output.indexOf(endMarker, valueStartIndex);
+	if (endIndex === -1) return void 0;
+	const value = output.slice(valueStartIndex, endIndex).replace(/^\r?\n/, "").replace(/\r?\n$/, "");
+	return value.length > 0 ? value : void 0;
+}
+const readEnvironmentFromLoginShell = (shell, names, execFile = NodeChildProcess.execFileSync) => {
+	if (names.length === 0) return {};
+	const output = execFile(shell, ["-ilc", buildEnvironmentCaptureCommand(names)], {
+		encoding: "utf8",
+		timeout: 5e3
+	});
+	const environment = {};
+	for (const name of names) {
+		const value = extractEnvironmentValue(output, name);
+		if (value !== void 0) environment[name] = value;
+	}
+	return environment;
+};
+const WindowsShellEnvironment = Reference("@t3tools/shared/shell/WindowsShellEnvironment", { defaultValue: () => readEnvironmentFromWindowsShell });
+const CommandAvailability = Reference("@t3tools/shared/shell/CommandAvailability", { defaultValue: () => isCommandAvailable });
+function readEnvironmentFromWindowsShell(names, optionsOrExecFile, maybeExecFile) {
+	if (names.length === 0) return {};
+	const options = typeof optionsOrExecFile === "function" ? {} : optionsOrExecFile ?? {};
+	const execFile = typeof optionsOrExecFile === "function" ? optionsOrExecFile : maybeExecFile ?? NodeChildProcess.execFileSync;
+	const command = buildWindowsEnvironmentCaptureCommand(names);
+	const args = [
+		"-NoLogo",
+		...options.loadProfile ? [] : ["-NoProfile"],
+		"-NonInteractive",
+		"-Command",
+		command
+	];
+	for (const shell of WINDOWS_SHELL_CANDIDATES) try {
+		const output = execFile(shell, args, {
+			encoding: "utf8",
+			timeout: 5e3
+		});
+		const environment = {};
+		for (const name of names) {
+			const value = extractEnvironmentValue(output, name);
+			if (value !== void 0) environment[name] = value;
+		}
+		return environment;
+	} catch {
+		continue;
+	}
+	return {};
+}
+function stripWrappingQuotes(value) {
+	return value.replace(/^"+|"+$/g, "");
+}
+function pathDelimiterForPlatform(platform) {
+	return platform === "win32" ? WINDOWS_PATH_DELIMITER : POSIX_PATH_DELIMITER;
+}
+function normalizePathEntryForComparison(entry, platform) {
+	const normalized = stripWrappingQuotes(entry.trim());
+	return platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function mergePathValues(preferredPath, inheritedPath, platform) {
+	const delimiter = pathDelimiterForPlatform(platform);
+	const merged = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const rawValue of [preferredPath, inheritedPath]) {
+		if (!rawValue) continue;
+		for (const entry of rawValue.split(delimiter)) {
+			const trimmed = entry.trim();
+			if (trimmed.length === 0) continue;
+			const normalized = normalizePathEntryForComparison(trimmed, platform);
+			if (normalized.length === 0 || seen.has(normalized)) continue;
+			seen.add(normalized);
+			merged.push(trimmed);
+		}
+	}
+	return merged.length > 0 ? merged.join(delimiter) : void 0;
+}
+function readEnvPath(env) {
+	return env.PATH ?? env.Path ?? env.path;
+}
+function resolvePathEnvironmentVariable(env) {
+	return readEnvPath(env) ?? "";
+}
+function resolveWindowsPathExtensions(env) {
+	const rawValue = env.PATHEXT;
+	const fallback = [
+		".COM",
+		".EXE",
+		".BAT",
+		".CMD"
+	];
+	if (!rawValue) return fallback;
+	const parsed = [];
+	for (const entry of rawValue.split(";")) {
+		const trimmed = entry.trim();
+		if (trimmed.length === 0) continue;
+		parsed.push(trimmed.startsWith(".") ? trimmed.toUpperCase() : `.${trimmed.toUpperCase()}`);
+	}
+	return parsed.length > 0 ? Array.from(new Set(parsed)) : fallback;
+}
+function resolveCommandCandidates(command, platform, windowsPathExtensions, extname) {
+	if (platform !== "win32") return [command];
+	const extension = extname(command);
+	const normalizedExtension = extension.toUpperCase();
+	if (extension.length > 0 && windowsPathExtensions.includes(normalizedExtension)) {
+		const commandWithoutExtension = command.slice(0, -extension.length);
+		return Array.from(/* @__PURE__ */ new Set([
+			command,
+			`${commandWithoutExtension}${normalizedExtension}`,
+			`${commandWithoutExtension}${normalizedExtension.toLowerCase()}`
+		]));
+	}
+	const candidates = [];
+	for (const candidateExtension of windowsPathExtensions) {
+		candidates.push(`${command}${candidateExtension}`);
+		candidates.push(`${command}${candidateExtension.toLowerCase()}`);
+	}
+	return Array.from(new Set(candidates));
+}
+const isExecutableFile = fn("shell.isExecutableFile")(function* (filePath, platform, windowsPathExtensions) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const stat = yield* fileSystem.stat(filePath).pipe(orElseSucceed(() => null));
+	if (stat === null || stat.type !== "File") return false;
+	if (platform === "win32") {
+		const extension = path.extname(filePath);
+		if (extension.length === 0) return false;
+		return windowsPathExtensions.includes(extension.toUpperCase());
+	}
+	return canExecuteFile(filePath);
+});
+const resolveCommandPathForPlatform = fn("shell.resolveCommandPathForPlatform")(function* (command, options) {
+	const path = yield* Path;
+	const platform = options.platform;
+	const env = options.env ?? process.env;
+	const windowsPathExtensions = platform === "win32" ? resolveWindowsPathExtensions(env) : [];
+	const commandCandidates = resolveCommandCandidates(command, platform, windowsPathExtensions, path.extname);
+	if (command.includes("/") || command.includes("\\")) {
+		for (const candidate of commandCandidates) if (yield* isExecutableFile(candidate, platform, windowsPathExtensions)) return candidate;
+		return yield* new CommandResolutionError({
+			command,
+			reason: "not-found"
+		});
+	}
+	const pathValue = resolvePathEnvironmentVariable(env);
+	if (pathValue.length === 0) return yield* new CommandResolutionError({
+		command,
+		reason: "not-found"
+	});
+	const pathEntries = [];
+	for (const entry of pathValue.split(pathDelimiterForPlatform(platform))) {
+		const pathEntry = stripWrappingQuotes(entry.trim());
+		if (pathEntry.length > 0) pathEntries.push(pathEntry);
+	}
+	for (const pathEntry of pathEntries) for (const candidate of commandCandidates) {
+		const candidatePath = path.join(pathEntry, candidate);
+		if (yield* isExecutableFile(candidatePath, platform, windowsPathExtensions)) return candidatePath;
+	}
+	return yield* new CommandResolutionError({
+		command,
+		reason: "not-found"
+	});
+});
+const resolveCommandPath = fn("shell.resolveCommandPath")(function* (command, options = {}) {
+	return yield* resolveCommandPathForPlatform(command, {
+		env: options.env ?? (yield* HostProcessEnvironment),
+		platform: yield* HostProcessPlatform
+	});
+});
+const resolveSpawnCommand = fn("shell.resolveSpawnCommand")(function* (command, args, options = {}) {
+	const platform = yield* HostProcessPlatform;
+	if (platform !== "win32") return {
+		command,
+		args: [...args],
+		shell: false
+	};
+	const hostEnvironment = yield* HostProcessEnvironment;
+	const env = options.env === void 0 ? hostEnvironment : options.extendEnv ? {
+		...hostEnvironment,
+		...options.env
+	} : options.env;
+	const resolvedCommand = (yield* SpawnExecutableResolution)(command, platform, env) ?? command;
+	const extension = NodePath.win32.extname(resolvedCommand).toLowerCase();
+	if (extension !== ".cmd" && extension !== ".bat") return {
+		command: resolvedCommand,
+		args: [...args],
+		shell: false
+	};
+	return {
+		command: escapeWindowsShellArg(resolvedCommand),
+		args: sanitizeShellModeArgsForPlatform(args, platform),
+		shell: true
+	};
+});
+const isCommandAvailable = fn("shell.isCommandAvailable")(function* (command, options = {}) {
+	return yield* resolveCommandPath(command, options).pipe(as(true), catchTag("CommandResolutionError", () => succeed(false)));
+});
+function resolveKnownWindowsCliDirs(env) {
+	const appData = env.APPDATA?.trim();
+	const localAppData = env.LOCALAPPDATA?.trim();
+	const userProfile = env.USERPROFILE?.trim();
+	return [
+		...appData ? [`${appData}\\npm`] : [],
+		...localAppData ? [`${localAppData}\\Programs\\nodejs`, `${localAppData}\\Volta\\bin`] : [],
+		...localAppData ? [`${localAppData}\\pnpm`] : [],
+		...userProfile ? [`${userProfile}\\.bun\\bin`, `${userProfile}\\scoop\\shims`] : []
+	];
+}
+function readWindowsEnvironmentSafely(readEnvironment, names, options) {
+	try {
+		return readEnvironment(names, options);
+	} catch {
+		return {};
+	}
+}
+function mergeWindowsEnv(currentEnv, patch) {
+	const nextEnv = { ...currentEnv };
+	for (const [key, value] of Object.entries(patch)) if (value !== void 0) nextEnv[key] = value;
+	return nextEnv;
+}
+const resolveWindowsEnvironment = fn("shell.resolveWindowsEnvironment")(function* (env) {
+	const readEnvironment = yield* WindowsShellEnvironment;
+	const commandAvailable = yield* CommandAvailability;
+	const inheritedPath = readEnvPath(env);
+	const shellPath = readWindowsEnvironmentSafely(readEnvironment, ["PATH"], { loadProfile: false }).PATH;
+	const mergedPath = mergePathValues(shellPath, inheritedPath, "win32");
+	const baselinePath = mergePathValues(resolveKnownWindowsCliDirs(env).join(WINDOWS_PATH_DELIMITER), mergedPath, "win32");
+	const baselinePatch = baselinePath ? { PATH: baselinePath } : {};
+	if (yield* commandAvailable("node", { env: mergeWindowsEnv(env, baselinePatch) })) return baselinePatch;
+	const profiledEnvironment = readWindowsEnvironmentSafely(readEnvironment, [
+		"PATH",
+		"FNM_DIR",
+		"FNM_MULTISHELL_PATH"
+	], { loadProfile: true });
+	const profiledPath = mergePathValues(profiledEnvironment.PATH, baselinePath, "win32");
+	const profiledPatch = {
+		...profiledPath ? { PATH: profiledPath } : {},
+		...profiledEnvironment.FNM_DIR ? { FNM_DIR: profiledEnvironment.FNM_DIR } : {},
+		...profiledEnvironment.FNM_MULTISHELL_PATH ? { FNM_MULTISHELL_PATH: profiledEnvironment.FNM_MULTISHELL_PATH } : {}
+	};
+	return Object.keys(profiledPatch).length > 0 ? {
+		...baselinePatch,
+		...profiledPatch
+	} : baselinePatch;
+});
+//#endregion
+export { CommandAvailability, CommandResolutionError, SpawnExecutableResolution, WindowsShellEnvironment, extractPathFromShellOutput, isCommandAvailable, listLoginShellCandidates, mergePathEntries, mergePathValues, readEnvironmentFromLoginShell, readEnvironmentFromWindowsShell, readPathFromLaunchctl, readPathFromLoginShell, resolveCommandPath, resolveKnownWindowsCliDirs, resolveSpawnCommand, resolveWindowsEnvironment };

package/dist/shared/sourceControl.d.ts

@@ -0,0 +1,26 @@
+import { _C as SourceControlProviderKind, gC as SourceControlProviderInfo } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/sourceControl.d.ts
+interface ChangeRequestPresentation {
+  readonly icon: "github" | "gitlab" | "azure-devops" | "bitbucket" | "change-request";
+  readonly providerName: string;
+  readonly shortName: string;
+  readonly longName: string;
+  readonly pluralLongName: string;
+  readonly providerLongName: string;
+  readonly checkoutCommandExample?: string;
+  readonly urlExample: string;
+}
+interface ChangeRequestTerminology {
+  readonly shortLabel: string;
+  readonly singular: string;
+}
+declare const DEFAULT_CHANGE_REQUEST_TERMINOLOGY: ChangeRequestTerminology;
+declare function resolveChangeRequestPresentation(provider: SourceControlProviderInfo | null | undefined): ChangeRequestPresentation;
+declare function resolveChangeRequestPresentationForKind(kind: SourceControlProviderKind): ChangeRequestPresentation;
+declare function formatChangeRequestAction(verb: "View" | "Create", presentation: ChangeRequestPresentation): string;
+declare function formatCreateChangeRequestPhrase(presentation: ChangeRequestPresentation): string;
+declare function getChangeRequestTerminology(provider: SourceControlProviderInfo | null | undefined): ChangeRequestTerminology;
+declare function getChangeRequestTerminologyForKind(kind: SourceControlProviderKind): ChangeRequestTerminology;
+declare function detectSourceControlProviderFromRemoteUrl(remoteUrl: string): SourceControlProviderInfo | null;
+//#endregion
+export { ChangeRequestPresentation, ChangeRequestTerminology, DEFAULT_CHANGE_REQUEST_TERMINOLOGY, detectSourceControlProviderFromRemoteUrl, formatChangeRequestAction, formatCreateChangeRequestPhrase, getChangeRequestTerminology, getChangeRequestTerminologyForKind, resolveChangeRequestPresentation, resolveChangeRequestPresentationForKind };

package/dist/shared/sourceControl.js

@@ -0,0 +1,2 @@
+import { _t as resolveChangeRequestPresentationForKind, dt as detectSourceControlProviderFromRemoteUrl, ft as formatChangeRequestAction, gt as resolveChangeRequestPresentation, ht as getChangeRequestTerminologyForKind, mt as getChangeRequestTerminology, pt as formatCreateChangeRequestPhrase, ut as DEFAULT_CHANGE_REQUEST_TERMINOLOGY } from "../shared.js";
+export { DEFAULT_CHANGE_REQUEST_TERMINOLOGY, detectSourceControlProviderFromRemoteUrl, formatChangeRequestAction, formatCreateChangeRequestPhrase, getChangeRequestTerminology, getChangeRequestTerminologyForKind, resolveChangeRequestPresentation, resolveChangeRequestPresentationForKind };

package/dist/shared/t3ProjectFile.d.ts

@@ -0,0 +1,27 @@
+import * as Schema from "effect/Schema";
+//#region upstream-t3code/packages/shared/src/t3ProjectFile.d.ts
+/**
+ * Codec between the raw `t3.json` file contents (lenient JSONC string) and the
+ * decoded {@link T3ProjectFile}.
+ */
+declare const T3ProjectFileFromJson: Schema.decodeTo<Schema.Struct<{
+  readonly $schema: Schema.optionalKey<Schema.String>;
+  readonly iconPath: Schema.optionalKey<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+  readonly scripts: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly name: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly command: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly icon: Schema.optionalKey<Schema.Literals<readonly ["play", "test", "lint", "configure", "build", "debug"]>>;
+    readonly runOnWorktreeCreate: Schema.optionalKey<Schema.Boolean>;
+    readonly previewUrl: Schema.optionalKey<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly autoOpenPreview: Schema.optionalKey<Schema.Boolean>;
+  }>>>;
+}>, Schema.String, never, never>;
+/**
+ * Build the publishable JSON Schema document for `t3.json` (draft 2020-12).
+ *
+ * Served from the marketing site at {@link T3_PROJECT_FILE_SCHEMA_URL} so
+ * editors get LSP support via a `$schema` reference.
+ */
+declare function buildT3ProjectFileJsonSchema(): Record<string, unknown>;
+//#endregion
+export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema };

package/dist/shared/t3ProjectFile.js

@@ -0,0 +1,25 @@
+import { Iu as T3ProjectFile, fE as toJsonSchemaDocument, g as fromLenientJson, zu as T3_PROJECT_FILE_SCHEMA_URL } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/t3ProjectFile.ts
+/**
+* Codec between the raw `t3.json` file contents (lenient JSONC string) and the
+* decoded {@link T3ProjectFile}.
+*/
+const T3ProjectFileFromJson = fromLenientJson(T3ProjectFile);
+/**
+* Build the publishable JSON Schema document for `t3.json` (draft 2020-12).
+*
+* Served from the marketing site at {@link T3_PROJECT_FILE_SCHEMA_URL} so
+* editors get LSP support via a `$schema` reference.
+*/
+function buildT3ProjectFileJsonSchema() {
+	const document = toJsonSchemaDocument(T3ProjectFile);
+	const jsonSchema = {
+		$schema: "https://json-schema.org/draft/2020-12/schema",
+		$id: T3_PROJECT_FILE_SCHEMA_URL,
+		...document.schema
+	};
+	if (document.definitions && Object.keys(document.definitions).length > 0) jsonSchema.$defs = document.definitions;
+	return jsonSchema;
+}
+//#endregion
+export { T3ProjectFileFromJson, buildT3ProjectFileJsonSchema };

package/dist/shared/terminalLabels.d.ts

@@ -0,0 +1,16 @@
+import { ix as TerminalSummary } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/terminalLabels.d.ts
+/** Human-readable label for a terminal tab; matches mobile and web sidebars. */
+declare function getTerminalLabel(terminalId: string): string;
+/** Prefer server summary label when present; otherwise fall back to `getTerminalLabel`. */
+declare function resolveTerminalSessionLabel(terminalId: string, summary: Pick<TerminalSummary, "label"> | null | undefined): string;
+/**
+ * Client-side terminal id allocator. Ids are ALWAYS chosen by the client and sent explicitly
+ * on every `terminal.open` / `terminal.attach` call — the server never allocates.
+ *
+ * Returns the lowest unused `term-N` id (starting at `term-1`), skipping any ids already in
+ * `existingTerminalIds`.
+ */
+declare function nextTerminalId(existingTerminalIds: ReadonlyArray<string>): string;
+//#endregion
+export { getTerminalLabel, nextTerminalId, resolveTerminalSessionLabel };

package/dist/shared/terminalLabels.js

@@ -0,0 +1,28 @@
+//#region upstream-t3code/packages/shared/src/terminalLabels.ts
+/** Human-readable label for a terminal tab; matches mobile and web sidebars. */
+function getTerminalLabel(terminalId) {
+	const numericSuffix = /^term(?:inal)?-(\d+)$/i.exec(terminalId)?.[1];
+	if (numericSuffix) return `Terminal ${numericSuffix}`;
+	return terminalId;
+}
+/** Prefer server summary label when present; otherwise fall back to `getTerminalLabel`. */
+function resolveTerminalSessionLabel(terminalId, summary) {
+	const trimmed = summary?.label?.trim();
+	if (trimmed && trimmed.length > 0) return trimmed;
+	return getTerminalLabel(terminalId);
+}
+/**
+* Client-side terminal id allocator. Ids are ALWAYS chosen by the client and sent explicitly
+* on every `terminal.open` / `terminal.attach` call — the server never allocates.
+*
+* Returns the lowest unused `term-N` id (starting at `term-1`), skipping any ids already in
+* `existingTerminalIds`.
+*/
+function nextTerminalId(existingTerminalIds) {
+	const usedIds = new Set(existingTerminalIds.filter((id) => id.trim().length > 0));
+	let nextIndex = 1;
+	while (usedIds.has(`term-${nextIndex}`)) nextIndex += 1;
+	return `term-${nextIndex}`;
+}
+//#endregion
+export { getTerminalLabel, nextTerminalId, resolveTerminalSessionLabel };

package/dist/shared/toolActivity.d.ts

@@ -0,0 +1,16 @@
+import { jp as ToolLifecycleItemType } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/toolActivity.d.ts
+interface ToolActivityPresentationInput {
+  readonly itemType?: ToolLifecycleItemType | null | undefined;
+  readonly title?: string | null | undefined;
+  readonly detail?: string | null | undefined;
+  readonly data?: unknown;
+  readonly fallbackSummary?: string | null | undefined;
+}
+interface ToolActivityPresentation {
+  readonly summary: string;
+  readonly detail?: string | undefined;
+}
+declare function deriveToolActivityPresentation(input: ToolActivityPresentationInput): ToolActivityPresentation;
+//#endregion
+export { ToolActivityPresentation, ToolActivityPresentationInput, deriveToolActivityPresentation };