t3code-cli 0.13.0 → 0.14.0

package/dist/shared/dpopCommon.d.ts

@@ -0,0 +1,2 @@
+import { n as normalizeDpopHtu, t as DpopPublicJwk } from "../shared.js";
+export { DpopPublicJwk, normalizeDpopHtu };

package/dist/shared/dpopCommon.js

@@ -0,0 +1,2 @@
+import { n as normalizeDpopHtu, t as DpopPublicJwk } from "../shared.js";
+export { DpopPublicJwk, normalizeDpopHtu };

package/dist/shared/filePreview.d.ts

@@ -0,0 +1,8 @@
+//#region upstream-t3code/packages/shared/src/filePreview.d.ts
+declare const WORKSPACE_BROWSER_PREVIEW_EXTENSIONS: readonly [".htm", ".html", ".pdf"];
+declare const WORKSPACE_IMAGE_PREVIEW_EXTENSIONS: readonly [".avif", ".gif", ".ico", ".jpeg", ".jpg", ".png", ".svg", ".webp"];
+declare function isWorkspaceBrowserPreviewPath(path: string): boolean;
+declare function isWorkspaceImagePreviewPath(path: string): boolean;
+declare function isWorkspacePreviewEntryPath(path: string): boolean;
+//#endregion
+export { WORKSPACE_BROWSER_PREVIEW_EXTENSIONS, WORKSPACE_IMAGE_PREVIEW_EXTENSIONS, isWorkspaceBrowserPreviewPath, isWorkspaceImagePreviewPath, isWorkspacePreviewEntryPath };

package/dist/shared/filePreview.js

@@ -0,0 +1,31 @@
+//#region upstream-t3code/packages/shared/src/filePreview.ts
+const WORKSPACE_BROWSER_PREVIEW_EXTENSIONS = [
+	".htm",
+	".html",
+	".pdf"
+];
+const WORKSPACE_IMAGE_PREVIEW_EXTENSIONS = [
+	".avif",
+	".gif",
+	".ico",
+	".jpeg",
+	".jpg",
+	".png",
+	".svg",
+	".webp"
+];
+function hasPreviewExtension(path, extensions) {
+	const pathWithoutQuery = path.split(/[?#]/, 1)[0]?.toLowerCase() ?? "";
+	return extensions.some((extension) => pathWithoutQuery.endsWith(extension));
+}
+function isWorkspaceBrowserPreviewPath(path) {
+	return hasPreviewExtension(path, WORKSPACE_BROWSER_PREVIEW_EXTENSIONS);
+}
+function isWorkspaceImagePreviewPath(path) {
+	return hasPreviewExtension(path, WORKSPACE_IMAGE_PREVIEW_EXTENSIONS);
+}
+function isWorkspacePreviewEntryPath(path) {
+	return isWorkspaceBrowserPreviewPath(path) || isWorkspaceImagePreviewPath(path);
+}
+//#endregion
+export { WORKSPACE_BROWSER_PREVIEW_EXTENSIONS, WORKSPACE_IMAGE_PREVIEW_EXTENSIONS, isWorkspaceBrowserPreviewPath, isWorkspaceImagePreviewPath, isWorkspacePreviewEntryPath };

package/dist/shared/git.d.ts

@@ -0,0 +1,41 @@
+import { $S as VcsStatusLocalResult, XS as VcsRef, eC as VcsStatusRemoteResult, gC as SourceControlProviderInfo, nC as VcsStatusStreamEvent, tC as VcsStatusResult } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/git.d.ts
+declare const WORKTREE_BRANCH_PREFIX = "t3code";
+/**
+ * Sanitize an arbitrary string into a valid, lowercase git refName fragment.
+ * Strips quotes, collapses separators, limits to 64 chars.
+ */
+declare function sanitizeBranchFragment(raw: string): string;
+/**
+ * Sanitize a string into a `feature/…` refName name.
+ * Preserves an existing `feature/` prefix or slash-separated namespace.
+ */
+declare function sanitizeFeatureBranchName(raw: string): string;
+/**
+ * Resolve a unique `feature/…` refName name that doesn't collide with
+ * any existing refName. Appends a numeric suffix when needed.
+ */
+declare function resolveAutoFeatureBranchName(existingBranchNames: readonly string[], preferredBranch?: string): string;
+/**
+ * Strip the remote prefix from a remote ref such as `origin/feature/demo`.
+ */
+declare function deriveLocalBranchNameFromRemoteRef(branchName: string): string;
+declare function buildTemporaryWorktreeBranchName(randomHex: (byteLength: number) => string): string;
+declare function isTemporaryWorktreeBranch(refName: string): boolean;
+/**
+ * Normalize a git remote URL into a stable comparison key.
+ */
+declare function normalizeGitRemoteUrl(value: string): string;
+/**
+ * Best-effort parse of a GitHub `owner/repo` identifier from common remote URL shapes.
+ */
+declare function parseGitHubRepositoryNameWithOwnerFromRemoteUrl(url: string | null): string | null;
+/**
+ * Hide `origin/*` remote refs when a matching local refName already exists.
+ */
+declare function dedupeRemoteBranchesWithLocalMatches(refs: ReadonlyArray<VcsRef>): ReadonlyArray<VcsRef>;
+declare function detectSourceControlProviderFromGitRemoteUrl(remoteUrl: string): SourceControlProviderInfo | null;
+declare function mergeGitStatusParts(local: VcsStatusLocalResult, remote: VcsStatusRemoteResult | null): VcsStatusResult;
+declare function applyGitStatusStreamEvent(current: VcsStatusResult | null, event: VcsStatusStreamEvent): VcsStatusResult;
+//#endregion
+export { WORKTREE_BRANCH_PREFIX, applyGitStatusStreamEvent, buildTemporaryWorktreeBranchName, dedupeRemoteBranchesWithLocalMatches, deriveLocalBranchNameFromRemoteRef, detectSourceControlProviderFromGitRemoteUrl, isTemporaryWorktreeBranch, mergeGitStatusParts, normalizeGitRemoteUrl, parseGitHubRepositoryNameWithOwnerFromRemoteUrl, resolveAutoFeatureBranchName, sanitizeBranchFragment, sanitizeFeatureBranchName };

package/dist/shared/git.js

@@ -0,0 +1,2 @@
+import { $ as buildTemporaryWorktreeBranchName, Q as applyGitStatusStreamEvent, Z as WORKTREE_BRANCH_PREFIX, at as normalizeGitRemoteUrl, ct as sanitizeBranchFragment, et as dedupeRemoteBranchesWithLocalMatches, it as mergeGitStatusParts, lt as sanitizeFeatureBranchName, nt as detectSourceControlProviderFromGitRemoteUrl, ot as parseGitHubRepositoryNameWithOwnerFromRemoteUrl, rt as isTemporaryWorktreeBranch, st as resolveAutoFeatureBranchName, tt as deriveLocalBranchNameFromRemoteRef } from "../shared.js";
+export { WORKTREE_BRANCH_PREFIX, applyGitStatusStreamEvent, buildTemporaryWorktreeBranchName, dedupeRemoteBranchesWithLocalMatches, deriveLocalBranchNameFromRemoteRef, detectSourceControlProviderFromGitRemoteUrl, isTemporaryWorktreeBranch, mergeGitStatusParts, normalizeGitRemoteUrl, parseGitHubRepositoryNameWithOwnerFromRemoteUrl, resolveAutoFeatureBranchName, sanitizeBranchFragment, sanitizeFeatureBranchName };

package/dist/shared/hostProcess.d.ts

@@ -0,0 +1,13 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+//#region upstream-t3code/packages/shared/src/hostProcess.d.ts
+declare const HostProcessPlatform: Context.Reference<NodeJS.Platform>;
+declare const HostProcessArchitecture: Context.Reference<NodeJS.Architecture>;
+declare const HostProcessHostname: Context.Reference<string>;
+declare const HostProcessEnvironment: Context.Reference<NodeJS.ProcessEnv>;
+declare const HostProcessWorkingDirectory: Context.Reference<string>;
+declare const HostProcessExecutablePath: Context.Reference<string>;
+declare const HostProcessArguments: Context.Reference<readonly string[]>;
+declare const isHostWindows: Effect.Effect<boolean, never, never>;
+//#endregion
+export { HostProcessArchitecture, HostProcessArguments, HostProcessEnvironment, HostProcessExecutablePath, HostProcessHostname, HostProcessPlatform, HostProcessWorkingDirectory, isHostWindows };

package/dist/shared/hostProcess.js

@@ -0,0 +1,2 @@
+import { C as HostProcessHostname, E as isHostWindows, S as HostProcessExecutablePath, T as HostProcessWorkingDirectory, b as HostProcessArguments, w as HostProcessPlatform, x as HostProcessEnvironment, y as HostProcessArchitecture } from "../shared.js";
+export { HostProcessArchitecture, HostProcessArguments, HostProcessEnvironment, HostProcessExecutablePath, HostProcessHostname, HostProcessPlatform, HostProcessWorkingDirectory, isHostWindows };

package/dist/shared/httpObservability.d.ts

@@ -0,0 +1,5 @@
+import * as Layer from "effect/Layer";
+//#region upstream-t3code/packages/shared/src/httpObservability.d.ts
+declare const httpHeaderRedactionLayer: Layer.Layer<never, never, never>;
+//#endregion
+export { httpHeaderRedactionLayer };

package/dist/shared/httpObservability.js

@@ -0,0 +1,2 @@
+import { Fo as httpHeaderRedactionLayer } from "../shared.js";
+export { httpHeaderRedactionLayer };

package/dist/shared/httpReadiness.d.ts

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import { HttpClient } from "effect/unstable/http";
+//#region upstream-t3code/packages/shared/src/httpReadiness.d.ts
+declare const DEFAULT_HTTP_READY_PROBE_TIMEOUT_MS = 1000;
+/**
+ * Normalizes an arbitrary readiness probe failure into a plain, structured value
+ * suitable for diagnostic logging. Preserves the tagged-error `_tag` (and
+ * message/cause) shape for Effect tagged errors while recursing through nested
+ * `cause`/`reason` chains.
+ */
+declare function describeReadinessCause(cause: unknown): unknown;
+/**
+ * Generic HTTP readiness probe shared by the SSH tunnel and the desktop backend
+ * manager. Polls `baseUrl + path` until it returns a 2xx response or the overall
+ * `timeoutMs` elapses. Each individual probe is bounded by `probeTimeoutMs` so a
+ * single hung request cannot stall the retry loop, and the retry cadence is
+ * `intervalMs` bounded to roughly `timeoutMs / intervalMs` attempts.
+ *
+ * The error type is left to the caller via `makeError`, so each consumer keeps
+ * its own tagged error. `makeError` is called at every failure site; callers can
+ * inspect `cause` (which carries a `kind` discriminator for the probe-timeout and
+ * overall-timeout cases) to reproduce phase-specific messages, or ignore it.
+ */
+declare const waitForHttpReady: <E>(input: {
+  readonly baseUrl: string;
+  readonly path?: string;
+  readonly timeoutMs?: number;
+  readonly intervalMs?: number;
+  readonly probeTimeoutMs?: number;
+  readonly makeError: (info: {
+    readonly requestUrl: string;
+    readonly probeTimeoutMs: number;
+    readonly attempt: number;
+    readonly cause: unknown;
+  }) => E;
+}) => Effect.Effect<void, E, HttpClient.HttpClient>;
+//#endregion
+export { DEFAULT_HTTP_READY_PROBE_TIMEOUT_MS, describeReadinessCause, waitForHttpReady };

package/dist/shared/httpReadiness.js

@@ -0,0 +1,110 @@
+import { AO as tapError, BC as transform, EO as succeed, GC as set, HC as get, Hk as match, IC as HttpClient, LC as filterStatusOk, QD as fail, RC as retry, Tk as millis, UC as get$1, UO as spaced, WC as make, WO as upTo, aO as gen, cO as logDebug, dO as mapError, eO as fn, jO as timeoutOption, lO as logWarning, oO as ignore, zC as tap } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/httpReadiness.ts
+const DEFAULT_HTTP_READY_PROBE_TIMEOUT_MS = 1e3;
+/**
+* Normalizes an arbitrary readiness probe failure into a plain, structured value
+* suitable for diagnostic logging. Preserves the tagged-error `_tag` (and
+* message/cause) shape for Effect tagged errors while recursing through nested
+* `cause`/`reason` chains.
+*/
+function describeReadinessCause(cause) {
+	if (cause instanceof Error) {
+		const tag = cause._tag;
+		const nested = cause.cause;
+		return {
+			...typeof tag === "string" ? { _tag: tag } : { name: cause.name },
+			message: cause.message,
+			...nested === void 0 ? {} : { cause: describeReadinessCause(nested) }
+		};
+	}
+	if (typeof cause !== "object" || cause === null) return cause;
+	const record = cause;
+	return {
+		...typeof record._tag === "string" ? { _tag: record._tag } : {},
+		...typeof record.message === "string" ? { message: record.message } : {},
+		...record.reason === void 0 ? {} : { reason: describeReadinessCause(record.reason) },
+		...record.cause === void 0 ? {} : { cause: describeReadinessCause(record.cause) }
+	};
+}
+/**
+* Generic HTTP readiness probe shared by the SSH tunnel and the desktop backend
+* manager. Polls `baseUrl + path` until it returns a 2xx response or the overall
+* `timeoutMs` elapses. Each individual probe is bounded by `probeTimeoutMs` so a
+* single hung request cannot stall the retry loop, and the retry cadence is
+* `intervalMs` bounded to roughly `timeoutMs / intervalMs` attempts.
+*
+* The error type is left to the caller via `makeError`, so each consumer keeps
+* its own tagged error. `makeError` is called at every failure site; callers can
+* inspect `cause` (which carries a `kind` discriminator for the probe-timeout and
+* overall-timeout cases) to reproduce phase-specific messages, or ignore it.
+*/
+const waitForHttpReady = fn("shared.httpReadiness.waitForHttpReady")(function* (input) {
+	const timeoutMs = input.timeoutMs ?? 3e4;
+	const intervalMs = input.intervalMs ?? 100;
+	const probeTimeoutMs = input.probeTimeoutMs ?? 1e3;
+	const retryPolicy = spaced(millis(intervalMs)).pipe(upTo({ times: Math.max(0, Math.ceil(timeoutMs / intervalMs)) }));
+	const requestUrl = new URL(input.path ?? "/", input.baseUrl).toString();
+	const client = yield* HttpClient;
+	const lastProbeFailure = yield* make(null);
+	let attempt = 0;
+	const makeError = input.makeError;
+	const madeErrors = /* @__PURE__ */ new WeakSet();
+	const fail$1 = (cause) => {
+		const error = makeError({
+			requestUrl,
+			probeTimeoutMs,
+			attempt,
+			cause
+		});
+		if (typeof error === "object" && error !== null) madeErrors.add(error);
+		return error;
+	};
+	const isMadeError = (value) => typeof value === "object" && value !== null && madeErrors.has(value);
+	yield* logDebug("httpReadiness.start", {
+		baseUrl: input.baseUrl,
+		requestUrl,
+		timeoutMs,
+		intervalMs,
+		probeTimeoutMs
+	});
+	return yield* match(yield* client.pipe(filterStatusOk, transform((effect) => gen(function* () {
+		attempt += 1;
+		return yield* match(yield* effect.pipe(timeoutOption(millis(probeTimeoutMs)), mapError((cause) => fail$1(cause))), {
+			onSome: succeed,
+			onNone: () => fail(fail$1({
+				kind: "probe-timeout",
+				attempt,
+				probeTimeoutMs
+			}))
+		});
+	}).pipe(mapError((cause) => isMadeError(cause) ? cause : fail$1(cause)), tapError((cause) => set(lastProbeFailure, {
+		attempt,
+		cause: describeReadinessCause(cause)
+	})))), tap((response) => response.text.pipe(ignore)), retry(retryPolicy)).execute(get(requestUrl)).pipe(mapError((cause) => isMadeError(cause) ? cause : fail$1(cause)), timeoutOption(millis(timeoutMs))), {
+		onSome: () => logDebug("httpReadiness.succeeded", {
+			baseUrl: input.baseUrl,
+			requestUrl,
+			attempts: attempt
+		}),
+		onNone: () => gen(function* () {
+			const lastFailure = yield* get$1(lastProbeFailure);
+			yield* logWarning("httpReadiness.timedOut", {
+				baseUrl: input.baseUrl,
+				requestUrl,
+				timeoutMs,
+				intervalMs,
+				probeTimeoutMs,
+				attempts: attempt,
+				lastFailure
+			});
+			return yield* fail(fail$1({
+				kind: "overall-timeout",
+				baseUrl: input.baseUrl,
+				timeoutMs,
+				lastFailure
+			}));
+		})
+	});
+});
+//#endregion
+export { DEFAULT_HTTP_READY_PROBE_TIMEOUT_MS, describeReadinessCause, waitForHttpReady };

package/dist/shared/keybindings.d.ts

@@ -0,0 +1,35 @@
+import { Hu as KeybindingRule, Ku as KeybindingWhenNode, Uu as KeybindingShortcut, ad as ResolvedKeybindingsConfig, id as ResolvedKeybindingRule } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/keybindings.d.ts
+declare const DEFAULT_KEYBINDINGS: ReadonlyArray<KeybindingRule>;
+declare function parseKeybindingShortcut(value: string): KeybindingShortcut | null;
+declare function parseKeybindingWhenExpression(expression: string): KeybindingWhenNode | null;
+declare function compileResolvedKeybindingRule(rule: KeybindingRule): ResolvedKeybindingRule | null;
+declare function compileResolvedKeybindingsConfig(config: ReadonlyArray<KeybindingRule>): ResolvedKeybindingsConfig;
+declare const DEFAULT_RESOLVED_KEYBINDINGS: readonly {
+  readonly command: "chat.new" | "chat.newLocal" | "commandPalette.toggle" | "composer.stash" | "diff.toggle" | "editor.openFavorite" | "modelPicker.jump.1" | "modelPicker.jump.2" | "modelPicker.jump.3" | "modelPicker.jump.4" | "modelPicker.jump.5" | "modelPicker.jump.6" | "modelPicker.jump.7" | "modelPicker.jump.8" | "modelPicker.jump.9" | "modelPicker.toggle" | "preview.focusUrl" | "preview.refresh" | "preview.resetZoom" | "preview.toggle" | "preview.zoomIn" | "preview.zoomOut" | "rightPanel.toggle" | "sidebar.toggle" | "terminal.close" | "terminal.new" | "terminal.split" | "terminal.splitVertical" | "terminal.toggle" | "thread.jump.1" | "thread.jump.2" | "thread.jump.3" | "thread.jump.4" | "thread.jump.5" | "thread.jump.6" | "thread.jump.7" | "thread.jump.8" | "thread.jump.9" | "thread.next" | "thread.previous" | `script.${string}.run`;
+  readonly shortcut: {
+    readonly key: string;
+    readonly metaKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly shiftKey: boolean;
+    readonly altKey: boolean;
+    readonly modKey: boolean;
+  };
+  readonly whenAst?: {
+    readonly type: "identifier";
+    readonly name: string;
+  } | {
+    readonly type: "not";
+    readonly node: KeybindingWhenNode;
+  } | {
+    readonly type: "and";
+    readonly left: KeybindingWhenNode;
+    readonly right: KeybindingWhenNode;
+  } | {
+    readonly type: "or";
+    readonly left: KeybindingWhenNode;
+    readonly right: KeybindingWhenNode;
+  } | undefined;
+}[];
+//#endregion
+export { DEFAULT_KEYBINDINGS, DEFAULT_RESOLVED_KEYBINDINGS, compileResolvedKeybindingRule, compileResolvedKeybindingsConfig, parseKeybindingShortcut, parseKeybindingWhenExpression };

package/dist/shared/keybindings.js

@@ -0,0 +1,330 @@
+import { Nm as MODEL_PICKER_JUMP_KEYBINDING_COMMANDS, Rm as THREAD_JUMP_KEYBINDING_COMMANDS } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/keybindings.ts
+const DEFAULT_KEYBINDINGS = [
+	{
+		key: "mod+b",
+		command: "sidebar.toggle"
+	},
+	{
+		key: "mod+j",
+		command: "terminal.toggle"
+	},
+	{
+		key: "mod+alt+b",
+		command: "rightPanel.toggle"
+	},
+	{
+		key: "mod+d",
+		command: "terminal.split",
+		when: "terminalFocus"
+	},
+	{
+		key: "mod+shift+d",
+		command: "terminal.splitVertical",
+		when: "terminalFocus"
+	},
+	{
+		key: "mod+n",
+		command: "terminal.new",
+		when: "terminalFocus"
+	},
+	{
+		key: "mod+w",
+		command: "terminal.close",
+		when: "terminalFocus"
+	},
+	{
+		key: "mod+d",
+		command: "diff.toggle",
+		when: "!terminalFocus"
+	},
+	{
+		key: "mod+shift+j",
+		command: "preview.toggle"
+	},
+	{
+		key: "mod+r",
+		command: "preview.refresh",
+		when: "previewFocus"
+	},
+	{
+		key: "mod+l",
+		command: "preview.focusUrl",
+		when: "previewFocus"
+	},
+	{
+		key: "mod+=",
+		command: "preview.zoomIn",
+		when: "previewFocus"
+	},
+	{
+		key: "mod++",
+		command: "preview.zoomIn",
+		when: "previewFocus"
+	},
+	{
+		key: "mod+-",
+		command: "preview.zoomOut",
+		when: "previewFocus"
+	},
+	{
+		key: "mod+0",
+		command: "preview.resetZoom",
+		when: "previewFocus"
+	},
+	{
+		key: "mod+k",
+		command: "commandPalette.toggle",
+		when: "!terminalFocus"
+	},
+	{
+		key: "mod+s",
+		command: "composer.stash",
+		when: "!terminalFocus"
+	},
+	{
+		key: "mod+n",
+		command: "chat.new",
+		when: "!terminalFocus"
+	},
+	{
+		key: "mod+shift+o",
+		command: "chat.new",
+		when: "!terminalFocus"
+	},
+	{
+		key: "mod+shift+n",
+		command: "chat.newLocal",
+		when: "!terminalFocus"
+	},
+	{
+		key: "mod+shift+m",
+		command: "modelPicker.toggle",
+		when: "!terminalFocus"
+	},
+	{
+		key: "mod+o",
+		command: "editor.openFavorite"
+	},
+	{
+		key: "mod+shift+[",
+		command: "thread.previous"
+	},
+	{
+		key: "mod+shift+]",
+		command: "thread.next"
+	},
+	...THREAD_JUMP_KEYBINDING_COMMANDS.map((command, index) => ({
+		key: `mod+${index + 1}`,
+		command
+	})),
+	...MODEL_PICKER_JUMP_KEYBINDING_COMMANDS.map((command, index) => ({
+		key: `mod+${index + 1}`,
+		command,
+		when: "modelPickerOpen"
+	}))
+];
+function normalizeKeyToken(token) {
+	if (token === "space") return " ";
+	if (token === "esc") return "escape";
+	return token;
+}
+function parseKeybindingShortcut(value) {
+	const tokens = [...value.toLowerCase().split("+").map((token) => token.trim())];
+	let trailingEmptyCount = 0;
+	while (tokens[tokens.length - 1] === "") {
+		trailingEmptyCount += 1;
+		tokens.pop();
+	}
+	if (trailingEmptyCount > 0) tokens.push("+");
+	if (tokens.some((token) => token.length === 0)) return null;
+	if (tokens.length === 0) return null;
+	let key = null;
+	let metaKey = false;
+	let ctrlKey = false;
+	let shiftKey = false;
+	let altKey = false;
+	let modKey = false;
+	for (const token of tokens) switch (token) {
+		case "cmd":
+		case "meta":
+			metaKey = true;
+			break;
+		case "ctrl":
+		case "control":
+			ctrlKey = true;
+			break;
+		case "shift":
+			shiftKey = true;
+			break;
+		case "alt":
+		case "option":
+			altKey = true;
+			break;
+		case "mod":
+			modKey = true;
+			break;
+		default:
+			if (key !== null) return null;
+			key = normalizeKeyToken(token);
+	}
+	if (key === null) return null;
+	return {
+		key,
+		metaKey,
+		ctrlKey,
+		shiftKey,
+		altKey,
+		modKey
+	};
+}
+function tokenizeWhenExpression(expression) {
+	const tokens = [];
+	let index = 0;
+	while (index < expression.length) {
+		const current = expression[index];
+		if (!current) break;
+		if (/\s/.test(current)) {
+			index += 1;
+			continue;
+		}
+		if (expression.startsWith("&&", index)) {
+			tokens.push({ type: "and" });
+			index += 2;
+			continue;
+		}
+		if (expression.startsWith("||", index)) {
+			tokens.push({ type: "or" });
+			index += 2;
+			continue;
+		}
+		if (current === "!") {
+			tokens.push({ type: "not" });
+			index += 1;
+			continue;
+		}
+		if (current === "(") {
+			tokens.push({ type: "lparen" });
+			index += 1;
+			continue;
+		}
+		if (current === ")") {
+			tokens.push({ type: "rparen" });
+			index += 1;
+			continue;
+		}
+		const identifier = /^[A-Za-z_][A-Za-z0-9_.-]*/.exec(expression.slice(index));
+		if (!identifier) return null;
+		tokens.push({
+			type: "identifier",
+			value: identifier[0]
+		});
+		index += identifier[0].length;
+	}
+	return tokens;
+}
+function parseKeybindingWhenExpression(expression) {
+	const tokens = tokenizeWhenExpression(expression);
+	if (!tokens || tokens.length === 0) return null;
+	let index = 0;
+	const parsePrimary = (depth) => {
+		if (depth > 64) return null;
+		const token = tokens[index];
+		if (!token) return null;
+		if (token.type === "identifier") {
+			index += 1;
+			return {
+				type: "identifier",
+				name: token.value
+			};
+		}
+		if (token.type === "lparen") {
+			index += 1;
+			const expressionNode = parseOr(depth + 1);
+			const closeToken = tokens[index];
+			if (!expressionNode || !closeToken || closeToken.type !== "rparen") return null;
+			index += 1;
+			return expressionNode;
+		}
+		return null;
+	};
+	const parseUnary = (depth) => {
+		let notCount = 0;
+		while (tokens[index]?.type === "not") {
+			index += 1;
+			notCount += 1;
+			if (notCount > 64) return null;
+		}
+		let node = parsePrimary(depth);
+		if (!node) return null;
+		while (notCount > 0) {
+			node = {
+				type: "not",
+				node
+			};
+			notCount -= 1;
+		}
+		return node;
+	};
+	const parseAnd = (depth) => {
+		let left = parseUnary(depth);
+		if (!left) return null;
+		while (tokens[index]?.type === "and") {
+			index += 1;
+			const right = parseUnary(depth);
+			if (!right) return null;
+			left = {
+				type: "and",
+				left,
+				right
+			};
+		}
+		return left;
+	};
+	const parseOr = (depth) => {
+		let left = parseAnd(depth);
+		if (!left) return null;
+		while (tokens[index]?.type === "or") {
+			index += 1;
+			const right = parseAnd(depth);
+			if (!right) return null;
+			left = {
+				type: "or",
+				left,
+				right
+			};
+		}
+		return left;
+	};
+	const ast = parseOr(0);
+	if (!ast || index !== tokens.length) return null;
+	return ast;
+}
+function compileResolvedKeybindingRule(rule) {
+	const shortcut = parseKeybindingShortcut(rule.key);
+	if (!shortcut) return null;
+	if (rule.when !== void 0) {
+		const whenAst = parseKeybindingWhenExpression(rule.when);
+		if (!whenAst) return null;
+		return {
+			command: rule.command,
+			shortcut,
+			whenAst
+		};
+	}
+	return {
+		command: rule.command,
+		shortcut
+	};
+}
+function compileResolvedKeybindingsConfig(config) {
+	const compiled = [];
+	for (const rule of config) {
+		const result = compileResolvedKeybindingRule(rule);
+		if (result) compiled.push(result);
+	}
+	return compiled.slice(-256);
+}
+const DEFAULT_RESOLVED_KEYBINDINGS = compileResolvedKeybindingsConfig(DEFAULT_KEYBINDINGS);
+//#endregion
+export { DEFAULT_KEYBINDINGS, DEFAULT_RESOLVED_KEYBINDINGS, compileResolvedKeybindingRule, compileResolvedKeybindingsConfig, parseKeybindingShortcut, parseKeybindingWhenExpression };

package/dist/shared/logging.d.ts

@@ -0,0 +1,39 @@
+import * as Schema from "effect/Schema";
+//#region upstream-t3code/packages/shared/src/logging.d.ts
+interface RotatingFileSinkOptions {
+  readonly filePath: string;
+  readonly maxBytes: number;
+  readonly maxFiles: number;
+  readonly throwOnError?: boolean;
+}
+declare const RotatingFileSinkConfigurationError_base: Schema.Class<RotatingFileSinkConfigurationError, Schema.TaggedStruct<"RotatingFileSinkConfigurationError", {
+  readonly option: Schema.Literals<readonly ["maxBytes", "maxFiles"]>;
+  readonly received: Schema.Number;
+  readonly minimum: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+declare class RotatingFileSinkConfigurationError extends RotatingFileSinkConfigurationError_base {
+  get message(): string;
+}
+declare const RotatingFileSinkError_base: Schema.Class<RotatingFileSinkError, Schema.TaggedStruct<"RotatingFileSinkError", {
+  readonly operation: Schema.Literals<readonly ["initialize", "read", "write", "rotate", "prune"]>;
+  readonly filePath: Schema.String;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class RotatingFileSinkError extends RotatingFileSinkError_base {
+  get message(): string;
+}
+declare class RotatingFileSink {
+  private readonly filePath;
+  private readonly maxBytes;
+  private readonly maxFiles;
+  private readonly throwOnError;
+  private currentSize;
+  constructor(options: RotatingFileSinkOptions);
+  write(chunk: string | Buffer): void;
+  private rotate;
+  private pruneOverflowBackups;
+  private readCurrentSize;
+  private withSuffix;
+}
+//#endregion
+export { RotatingFileSink, RotatingFileSinkConfigurationError, RotatingFileSinkError, RotatingFileSinkOptions };