t3code-cli 0.13.0 → 0.14.0

package/dist/shared/logging.js

@@ -0,0 +1,2 @@
+import { D as RotatingFileSink, O as RotatingFileSinkConfigurationError, k as RotatingFileSinkError } from "../shared.js";
+export { RotatingFileSink, RotatingFileSinkConfigurationError, RotatingFileSinkError };

package/dist/shared/model.d.ts

@@ -0,0 +1,44 @@
+import { A_ as ModelSelection, Cd as ProviderOptionSelection, Kp as ProviderDriverKind, Qp as ProviderInstanceId, _d as ModelCapabilities, xd as ProviderOptionDescriptor } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/model.d.ts
+interface SelectableModelOption {
+  slug: string;
+  name: string;
+}
+declare function createModelCapabilities(input: {
+  optionDescriptors: ReadonlyArray<ProviderOptionDescriptor>;
+}): ModelCapabilities;
+declare function getProviderOptionSelectionValue(selections: ReadonlyArray<ProviderOptionSelection> | null | undefined, id: string): string | boolean | undefined;
+declare function getProviderOptionStringSelectionValue(selections: ReadonlyArray<ProviderOptionSelection> | null | undefined, id: string): string | undefined;
+declare function getProviderOptionBooleanSelectionValue(selections: ReadonlyArray<ProviderOptionSelection> | null | undefined, id: string): boolean | undefined;
+declare function getModelSelectionOptionValue(modelSelection: ModelSelection | null | undefined, id: string): string | boolean | undefined;
+declare function getModelSelectionStringOptionValue(modelSelection: ModelSelection | null | undefined, id: string): string | undefined;
+declare function getModelSelectionBooleanOptionValue(modelSelection: ModelSelection | null | undefined, id: string): boolean | undefined;
+declare function getProviderOptionDescriptors(input: {
+  caps: ModelCapabilities;
+  selections?: ReadonlyArray<ProviderOptionSelection> | null | undefined;
+}): ReadonlyArray<ProviderOptionDescriptor>;
+declare function getProviderOptionCurrentValue(descriptor: ProviderOptionDescriptor | null | undefined): string | boolean | undefined;
+declare function getProviderOptionCurrentLabel(descriptor: ProviderOptionDescriptor | null | undefined): string | undefined;
+declare function buildProviderOptionSelectionsFromDescriptors(descriptors: ReadonlyArray<ProviderOptionDescriptor> | null | undefined): Array<ProviderOptionSelection> | undefined;
+declare function getModelSelectionOptionDescriptors(modelSelection: ModelSelection | null | undefined, caps?: ModelCapabilities | null | undefined): ReadonlyArray<ProviderOptionDescriptor>;
+declare function isClaudeUltrathinkPrompt(text: string | null | undefined): boolean;
+declare function normalizeModelSlug(model: string | null | undefined, provider?: ProviderDriverKind): string | null;
+/** Custom model identifiers are provider-owned, so only trim them; never expand aliases. */
+declare function normalizeCustomModelSlug(model: string | null | undefined): string | null;
+declare function resolveSelectableModel(provider: ProviderDriverKind, value: string | null | undefined, options: ReadonlyArray<SelectableModelOption>): string | null;
+declare function resolveModelSlugForProvider(provider: ProviderDriverKind, model: string | null | undefined): string;
+/** Trim a string, returning null for empty/missing values. */
+declare function trimOrNull<T extends string>(value: T | null | undefined): T | null;
+declare function createModelSelection(instanceId: ProviderInstanceId, model: string, options?: ReadonlyArray<ProviderOptionSelection> | null): ModelSelection;
+/**
+ * Returns the effort value if it is a prompt-injected value according to
+ * any select descriptor in the given capabilities, or null otherwise.
+ *
+ * Unlike a single `find`, this checks every descriptor so that the
+ * correct descriptor's `promptInjectedValues` list is consulted even when
+ * multiple select descriptors exist.
+ */
+declare function resolvePromptInjectedEffort(caps: ModelCapabilities, rawEffort: string | null | undefined): string | null;
+declare function applyClaudePromptEffortPrefix(text: string, effort: string | null | undefined): string;
+//#endregion
+export { SelectableModelOption, applyClaudePromptEffortPrefix, buildProviderOptionSelectionsFromDescriptors, createModelCapabilities, createModelSelection, getModelSelectionBooleanOptionValue, getModelSelectionOptionDescriptors, getModelSelectionOptionValue, getModelSelectionStringOptionValue, getProviderOptionBooleanSelectionValue, getProviderOptionCurrentLabel, getProviderOptionCurrentValue, getProviderOptionDescriptors, getProviderOptionSelectionValue, getProviderOptionStringSelectionValue, isClaudeUltrathinkPrompt, normalizeCustomModelSlug, normalizeModelSlug, resolveModelSlugForProvider, resolvePromptInjectedEffort, resolveSelectableModel, trimOrNull };

package/dist/shared/model.js

@@ -0,0 +1,2 @@
+import { A as applyClaudePromptEffortPrefix, B as getProviderOptionCurrentValue, F as getModelSelectionOptionDescriptors, G as normalizeCustomModelSlug, H as getProviderOptionSelectionValue, I as getModelSelectionOptionValue, J as resolvePromptInjectedEffort, K as normalizeModelSlug, L as getModelSelectionStringOptionValue, M as createModelCapabilities, N as createModelSelection, P as getModelSelectionBooleanOptionValue, R as getProviderOptionBooleanSelectionValue, U as getProviderOptionStringSelectionValue, V as getProviderOptionDescriptors, W as isClaudeUltrathinkPrompt, X as trimOrNull, Y as resolveSelectableModel, j as buildProviderOptionSelectionsFromDescriptors, q as resolveModelSlugForProvider, z as getProviderOptionCurrentLabel } from "../shared.js";
+export { applyClaudePromptEffortPrefix, buildProviderOptionSelectionsFromDescriptors, createModelCapabilities, createModelSelection, getModelSelectionBooleanOptionValue, getModelSelectionOptionDescriptors, getModelSelectionOptionValue, getModelSelectionStringOptionValue, getProviderOptionBooleanSelectionValue, getProviderOptionCurrentLabel, getProviderOptionCurrentValue, getProviderOptionDescriptors, getProviderOptionSelectionValue, getProviderOptionStringSelectionValue, isClaudeUltrathinkPrompt, normalizeCustomModelSlug, normalizeModelSlug, resolveModelSlugForProvider, resolvePromptInjectedEffort, resolveSelectableModel, trimOrNull };

package/dist/shared/oauthScope.d.ts

@@ -0,0 +1,23 @@
+import * as Schema from "effect/Schema";
+//#region upstream-t3code/packages/shared/src/oauthScope.d.ts
+declare const OAuthScopeEncodingError_base: Schema.Class<OAuthScopeEncodingError, Schema.TaggedStruct<"OAuthScopeEncodingError", {
+  readonly scopes: Schema.$Array<Schema.String>;
+  readonly invalidScopes: Schema.$Array<Schema.String>;
+  readonly duplicateScopes: Schema.$Array<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class OAuthScopeEncodingError extends OAuthScopeEncodingError_base {
+  get message(): string;
+}
+/**
+ * Decodes an RFC 6749 `scope` value as a set while preserving its first-seen
+ * order for canonical responses and logs.
+ */
+declare function parseOAuthScope(value: string): ReadonlyArray<string> | null;
+declare function encodeOAuthScope(scopes: ReadonlyArray<string>): string;
+declare function oauthScopeSetEquals(value: string, expectedScopes: ReadonlyArray<string>): boolean;
+declare function parseAllowedOAuthScope<Scope extends string>(input: {
+  readonly value: string;
+  readonly allowedScopes: ReadonlySet<Scope>;
+}): ReadonlyArray<Scope> | null;
+//#endregion
+export { OAuthScopeEncodingError, encodeOAuthScope, oauthScopeSetEquals, parseAllowedOAuthScope, parseOAuthScope };

package/dist/shared/oauthScope.js

@@ -0,0 +1,2 @@
+import { Go as parseOAuthScope, Ho as encodeOAuthScope, Uo as oauthScopeSetEquals, Vo as OAuthScopeEncodingError, Wo as parseAllowedOAuthScope } from "../shared.js";
+export { OAuthScopeEncodingError, encodeOAuthScope, oauthScopeSetEquals, parseAllowedOAuthScope, parseOAuthScope };

package/dist/shared/observability.d.ts

@@ -0,0 +1,105 @@
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Cause from "effect/Cause";
+import * as Tracer from "effect/Tracer";
+import { OtlpTracer } from "effect/unstable/observability";
+//#region upstream-t3code/packages/shared/src/observability.d.ts
+type TraceAttributes = Readonly<Record<string, unknown>>;
+interface TraceRecordEvent {
+  readonly name: string;
+  readonly timeUnixNano: string;
+  readonly attributes: Readonly<Record<string, unknown>>;
+}
+interface TraceRecordLink {
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly attributes: Readonly<Record<string, unknown>>;
+}
+interface BaseTraceRecord {
+  readonly name: string;
+  readonly kind: string;
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parentSpanId?: string;
+  readonly sampled: boolean;
+  readonly startTimeUnixNano: string;
+  readonly endTimeUnixNano: string;
+  readonly durationMs: number;
+  readonly attributes: Readonly<Record<string, unknown>>;
+  readonly events: ReadonlyArray<TraceRecordEvent>;
+  readonly links: ReadonlyArray<TraceRecordLink>;
+}
+interface EffectTraceRecord extends BaseTraceRecord {
+  readonly type: "effect-span";
+  readonly exit: {
+    readonly _tag: "Success";
+  } | {
+    readonly _tag: "Interrupted";
+    readonly cause: string;
+  } | {
+    readonly _tag: "Failure";
+    readonly cause: string;
+  };
+}
+interface OtlpTraceRecord extends BaseTraceRecord {
+  readonly type: "otlp-span";
+  readonly resourceAttributes: Readonly<Record<string, unknown>>;
+  readonly scope: Readonly<{
+    readonly name?: string;
+    readonly version?: string;
+    readonly attributes: Readonly<Record<string, unknown>>;
+  }>;
+  readonly status?: {
+    readonly code?: string;
+    readonly message?: string;
+  } | undefined;
+}
+type TraceRecord = EffectTraceRecord | OtlpTraceRecord;
+declare function errorTag(error: unknown): string;
+declare function causeErrorTag(cause: Cause.Cause<unknown>): string;
+interface TraceSinkOptions {
+  readonly filePath: string;
+  readonly maxBytes: number;
+  readonly maxFiles: number;
+  readonly batchWindowMs: number;
+  readonly onFlush?: (stats: TraceSinkFlushStats) => Effect.Effect<void>;
+}
+interface TraceSinkFlushStats {
+  readonly logicalWriteBytes: number;
+  readonly count: number;
+  readonly durationMs: number;
+}
+interface TraceSink {
+  readonly filePath: string;
+  push: (record: TraceRecord) => void;
+  flush: Effect.Effect<void>;
+  close: () => Effect.Effect<void>;
+}
+interface LocalFileTracerOptions extends TraceSinkOptions {
+  readonly delegate?: Tracer.Tracer;
+  readonly sink?: TraceSink;
+}
+interface SerializableSpan {
+  readonly name: string;
+  readonly traceId: string;
+  readonly spanId: string;
+  readonly parent: Option.Option<Tracer.AnySpan>;
+  readonly status: Tracer.SpanStatus;
+  readonly sampled: boolean;
+  readonly kind: Tracer.SpanKind;
+  readonly attributes: ReadonlyMap<string, unknown>;
+  readonly links: ReadonlyArray<Tracer.SpanLink>;
+  readonly events: ReadonlyArray<readonly [name: string, startTime: bigint, attributes: Record<string, unknown>]>;
+}
+declare function compactTraceAttributes(attributes: Readonly<Record<string, unknown>>): TraceAttributes;
+declare function spanToTraceRecord(span: SerializableSpan): EffectTraceRecord;
+declare const makeTraceSink: (options: TraceSinkOptions) => Effect.Effect<{
+  filePath: string;
+  push(record: TraceRecord): void;
+  flush: Effect.Effect<void, never, never>;
+  close: () => Effect.Effect<void, never, never>;
+}, never, import("effect/Scope").Scope>;
+declare const makeLocalFileTracer: (options: LocalFileTracerOptions) => Effect.Effect<Tracer.Tracer, never, import("effect/Scope").Scope>;
+declare function decodeOtlpTraceRecords(payload: OtlpTracer.TraceData): ReadonlyArray<OtlpTraceRecord>;
+//#endregion
+export { EffectTraceRecord, LocalFileTracerOptions, OtlpTraceRecord, TraceAttributes, TraceRecord, TraceRecordEvent, TraceRecordLink, TraceSink, TraceSinkFlushStats, TraceSinkOptions, causeErrorTag, compactTraceAttributes, decodeOtlpTraceRecords, errorTag, makeLocalFileTracer, makeTraceSink, spanToTraceRecord };

package/dist/shared/observability.js

@@ -0,0 +1,346 @@
+import { $D as flatMap, BD as andThen, Bk as isSome, D as RotatingFileSink, JO as findErrorOption, OO as sync, RD as addFinalizer, RO as void_, Rk as getOrUndefined, TO as sleep, XO as pretty, YO as hasInterruptsOnly, dk as isSuccess, eO as fn, iO as forkScoped, mk as make, oO as ignore, pk as NativeSpan, rO as forever, zO as withTracerEnabled } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/observability.ts
+const FLUSH_BUFFER_THRESHOLD = 256;
+const textEncoder = new TextEncoder();
+function isStructuralTag(value) {
+	return typeof value === "string" && value.length > 0 && value.length <= 128 && /^[A-Za-z][A-Za-z0-9._:/-]*$/.test(value);
+}
+function errorTag(error) {
+	try {
+		if (typeof error === "object" && error !== null && "_tag" in error) return isStructuralTag(error._tag) ? error._tag : "TaggedError";
+		if (error instanceof Error) return isStructuralTag(error.name) ? error.name : "Error";
+	} catch {
+		return "UnknownError";
+	}
+	return typeof error;
+}
+function causeErrorTag(cause) {
+	const failure = findErrorOption(cause);
+	if (isSome(failure)) return errorTag(failure.value);
+	return cause.reasons[0]?._tag ?? "Empty";
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function markSeen(value, seen) {
+	if (seen.has(value)) return true;
+	seen.add(value);
+	return false;
+}
+function normalizeJsonValue(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return value ?? null;
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? "Invalid Date" : value.toISOString();
+	if (value instanceof Error) return {
+		name: value.name,
+		message: value.message,
+		...value.stack ? { stack: value.stack } : {}
+	};
+	if (Array.isArray(value)) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return value.map((entry) => normalizeJsonValue(entry, seen));
+	}
+	if (value instanceof Map) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return Object.fromEntries(Array.from(value.entries(), ([key, entryValue]) => [String(key), normalizeJsonValue(entryValue, seen)]));
+	}
+	if (value instanceof Set) {
+		if (markSeen(value, seen)) return "[Circular]";
+		return Array.from(value.values(), (entry) => normalizeJsonValue(entry, seen));
+	}
+	if (!isPlainObject(value)) return String(value);
+	if (markSeen(value, seen)) return "[Circular]";
+	return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, normalizeJsonValue(entryValue, seen)]));
+}
+function compactTraceAttributes(attributes) {
+	const entries = [];
+	for (const [key, value] of Object.entries(attributes)) if (value !== void 0) entries.push([key, normalizeJsonValue(value)]);
+	return Object.fromEntries(entries);
+}
+function formatTraceExit(exit) {
+	if (isSuccess(exit)) return { _tag: "Success" };
+	if (hasInterruptsOnly(exit.cause)) return {
+		_tag: "Interrupted",
+		cause: pretty(exit.cause)
+	};
+	return {
+		_tag: "Failure",
+		cause: pretty(exit.cause)
+	};
+}
+function spanToTraceRecord(span) {
+	const status = span.status;
+	const parentSpanId = getOrUndefined(span.parent)?.spanId;
+	return {
+		type: "effect-span",
+		name: span.name,
+		traceId: span.traceId,
+		spanId: span.spanId,
+		...parentSpanId ? { parentSpanId } : {},
+		sampled: span.sampled,
+		kind: span.kind,
+		startTimeUnixNano: String(status.startTime),
+		endTimeUnixNano: String(status.endTime),
+		durationMs: Number(status.endTime - status.startTime) / 1e6,
+		attributes: compactTraceAttributes(Object.fromEntries(span.attributes)),
+		events: span.events.map(([name, startTime, attributes]) => ({
+			name,
+			timeUnixNano: String(startTime),
+			attributes: compactTraceAttributes(attributes)
+		})),
+		links: span.links.map((link) => ({
+			traceId: link.span.traceId,
+			spanId: link.span.spanId,
+			attributes: compactTraceAttributes(link.attributes)
+		})),
+		exit: formatTraceExit(status.exit)
+	};
+}
+const makeTraceSink = fn("makeTraceSink")(function* (options) {
+	const sink = new RotatingFileSink({
+		filePath: options.filePath,
+		maxBytes: options.maxBytes,
+		maxFiles: options.maxFiles,
+		throwOnError: true
+	});
+	let buffer = [];
+	let pendingFlushStats = {
+		logicalWriteBytes: 0,
+		count: 0,
+		durationMs: 0
+	};
+	const flushUnsafe = () => {
+		if (buffer.length === 0) return;
+		const records = buffer;
+		buffer = [];
+		let persistedCount = 0;
+		while (persistedCount < records.length) {
+			const firstRecordBytes = textEncoder.encode(records[persistedCount]).byteLength;
+			if (firstRecordBytes > options.maxBytes) {
+				persistedCount += 1;
+				continue;
+			}
+			let nextIndex = persistedCount + 1;
+			let chunkBytes = firstRecordBytes;
+			while (nextIndex < records.length) {
+				const nextRecordBytes = textEncoder.encode(records[nextIndex]).byteLength;
+				if (chunkBytes + nextRecordBytes > options.maxBytes) break;
+				chunkBytes += nextRecordBytes;
+				nextIndex += 1;
+			}
+			const chunk = records.slice(persistedCount, nextIndex).join("");
+			const startedAt = performance.now();
+			try {
+				sink.write(chunk);
+			} catch {
+				buffer.unshift(...records.slice(persistedCount));
+				return;
+			}
+			pendingFlushStats = {
+				logicalWriteBytes: pendingFlushStats.logicalWriteBytes + chunkBytes,
+				count: pendingFlushStats.count + nextIndex - persistedCount,
+				durationMs: pendingFlushStats.durationMs + Math.max(0, performance.now() - startedAt)
+			};
+			persistedCount = nextIndex;
+		}
+	};
+	const flush = sync(() => {
+		flushUnsafe();
+		const stats = pendingFlushStats;
+		pendingFlushStats = {
+			logicalWriteBytes: 0,
+			count: 0,
+			durationMs: 0
+		};
+		return stats;
+	}).pipe(flatMap((stats) => stats.count > 0 && options.onFlush ? options.onFlush(stats).pipe(ignore) : void_), withTracerEnabled(false));
+	yield* addFinalizer(() => flush.pipe(ignore));
+	yield* forkScoped(sleep(`${options.batchWindowMs} millis`).pipe(andThen(flush), forever));
+	return {
+		filePath: options.filePath,
+		push(record) {
+			try {
+				buffer.push(`${JSON.stringify(record)}\n`);
+				if (buffer.length >= FLUSH_BUFFER_THRESHOLD) flushUnsafe();
+			} catch {
+				return;
+			}
+		},
+		flush,
+		close: () => flush
+	};
+});
+var LocalFileSpan = class {
+	_tag = "Span";
+	name;
+	spanId;
+	traceId;
+	parent;
+	annotations;
+	links;
+	sampled;
+	kind;
+	status;
+	attributes;
+	events;
+	delegate;
+	push;
+	constructor(options, delegate, push) {
+		this.delegate = delegate;
+		this.push = push;
+		this.name = delegate.name;
+		this.spanId = delegate.spanId;
+		this.traceId = delegate.traceId;
+		this.parent = options.parent;
+		this.annotations = options.annotations;
+		this.links = [...options.links];
+		this.sampled = delegate.sampled;
+		this.kind = delegate.kind;
+		this.status = {
+			_tag: "Started",
+			startTime: options.startTime
+		};
+		this.attributes = /* @__PURE__ */ new Map();
+		this.events = [];
+	}
+	end(endTime, exit) {
+		this.status = {
+			_tag: "Ended",
+			startTime: this.status.startTime,
+			endTime,
+			exit
+		};
+		this.delegate.end(endTime, exit);
+		if (this.sampled) this.push(spanToTraceRecord(this));
+	}
+	attribute(key, value) {
+		this.attributes.set(key, value);
+		this.delegate.attribute(key, value);
+	}
+	event(name, startTime, attributes) {
+		const nextAttributes = attributes ?? {};
+		this.events.push([
+			name,
+			startTime,
+			nextAttributes
+		]);
+		this.delegate.event(name, startTime, nextAttributes);
+	}
+	addLinks(links) {
+		this.links.push(...links);
+		this.delegate.addLinks(links);
+	}
+};
+const makeLocalFileTracer = fn("makeLocalFileTracer")(function* (options) {
+	const sink = options.sink ?? (yield* makeTraceSink({
+		filePath: options.filePath,
+		maxBytes: options.maxBytes,
+		maxFiles: options.maxFiles,
+		batchWindowMs: options.batchWindowMs,
+		...options.onFlush ? { onFlush: options.onFlush } : {}
+	}));
+	const delegate = options.delegate ?? make({ span: (spanOptions) => new NativeSpan(spanOptions) });
+	return make({
+		span(spanOptions) {
+			return new LocalFileSpan(spanOptions, delegate.span(spanOptions), sink.push);
+		},
+		...delegate.context ? { context: delegate.context } : {}
+	});
+});
+const SPAN_KIND_MAP = {
+	1: "internal",
+	2: "server",
+	3: "client",
+	4: "producer",
+	5: "consumer"
+};
+function decodeOtlpTraceRecords(payload) {
+	const records = [];
+	for (const resourceSpan of payload.resourceSpans) {
+		const resourceAttributes = decodeAttributes(resourceSpan.resource?.attributes ?? []);
+		for (const scopeSpan of resourceSpan.scopeSpans) for (const span of scopeSpan.spans) records.push(otlpSpanToTraceRecord({
+			resourceAttributes,
+			scopeAttributes: decodeAttributes("attributes" in scopeSpan.scope && Array.isArray(scopeSpan.scope.attributes) ? scopeSpan.scope.attributes : []),
+			scopeName: scopeSpan.scope.name,
+			scopeVersion: "version" in scopeSpan.scope && typeof scopeSpan.scope.version === "string" ? scopeSpan.scope.version : void 0,
+			span
+		}));
+	}
+	return records;
+}
+function otlpSpanToTraceRecord(input) {
+	return {
+		type: "otlp-span",
+		name: input.span.name,
+		traceId: input.span.traceId,
+		spanId: input.span.spanId,
+		...input.span.parentSpanId ? { parentSpanId: input.span.parentSpanId } : {},
+		sampled: true,
+		kind: normalizeSpanKind(input.span.kind),
+		startTimeUnixNano: input.span.startTimeUnixNano,
+		endTimeUnixNano: input.span.endTimeUnixNano,
+		durationMs: Number(parseBigInt(input.span.endTimeUnixNano) - parseBigInt(input.span.startTimeUnixNano)) / 1e6,
+		attributes: decodeAttributes(input.span.attributes),
+		resourceAttributes: input.resourceAttributes,
+		scope: {
+			...input.scopeName ? { name: input.scopeName } : {},
+			...input.scopeVersion ? { version: input.scopeVersion } : {},
+			attributes: input.scopeAttributes
+		},
+		events: decodeEvents(input.span.events),
+		links: decodeLinks(input.span.links),
+		status: decodeStatus(input.span.status)
+	};
+}
+function decodeStatus(input) {
+	const code = String(input.code);
+	const message = input.message;
+	return {
+		code,
+		...message ? { message } : {}
+	};
+}
+function decodeEvents(input) {
+	return input.map((current) => ({
+		name: current.name,
+		timeUnixNano: current.timeUnixNano,
+		attributes: decodeAttributes(current.attributes)
+	}));
+}
+function decodeLinks(input) {
+	return input.flatMap((current) => {
+		return {
+			traceId: current.traceId,
+			spanId: current.spanId,
+			attributes: decodeAttributes(current.attributes)
+		};
+	});
+}
+function decodeAttributes(input) {
+	const entries = {};
+	for (const attribute of input) entries[attribute.key] = decodeValue(attribute.value);
+	return compactTraceAttributes(entries);
+}
+function decodeValue(input) {
+	if (input == null) return null;
+	if ("stringValue" in input) return input.stringValue;
+	if ("boolValue" in input) return input.boolValue;
+	if ("intValue" in input) return input.intValue;
+	if ("doubleValue" in input) return input.doubleValue;
+	if ("bytesValue" in input) return input.bytesValue;
+	if (input.arrayValue) return input.arrayValue.values.map((entry) => decodeValue(entry));
+	if (input.kvlistValue) return decodeAttributes(input.kvlistValue.values);
+	return null;
+}
+function normalizeSpanKind(input) {
+	return SPAN_KIND_MAP[input] || "internal";
+}
+function parseBigInt(input) {
+	try {
+		return BigInt(input);
+	} catch {
+		return 0n;
+	}
+}
+//#endregion
+export { causeErrorTag, compactTraceAttributes, decodeOtlpTraceRecords, errorTag, makeLocalFileTracer, makeTraceSink, spanToTraceRecord };

package/dist/shared/orchestrationTiming.d.ts

@@ -0,0 +1,16 @@
+//#region upstream-t3code/packages/shared/src/orchestrationTiming.d.ts
+type LatestTurnTiming = {
+  readonly turnId: string | null;
+  readonly startedAt: string | null;
+  readonly completedAt: string | null;
+};
+type SessionActivityState = {
+  readonly orchestrationStatus: string;
+  readonly activeTurnId?: string | null;
+};
+declare function formatDuration(durationMs: number): string;
+declare function formatElapsed(startIso: string, endIso: string | undefined): string | null;
+declare function isLatestTurnSettled(latestTurn: LatestTurnTiming | null, session: SessionActivityState | null): boolean;
+declare function deriveActiveWorkStartedAt(latestTurn: LatestTurnTiming | null, session: SessionActivityState | null, sendStartedAt: string | null): string | null;
+//#endregion
+export { deriveActiveWorkStartedAt, formatDuration, formatElapsed, isLatestTurnSettled };

package/dist/shared/orchestrationTiming.js

@@ -0,0 +1,32 @@
+//#region upstream-t3code/packages/shared/src/orchestrationTiming.ts
+function formatDuration(durationMs) {
+	if (!Number.isFinite(durationMs) || durationMs < 0) return "0ms";
+	if (durationMs < 1e3) return `${Math.max(1, Math.round(durationMs))}ms`;
+	if (durationMs < 1e4) return `${(durationMs / 1e3).toFixed(1)}s`;
+	if (durationMs < 6e4) return `${Math.round(durationMs / 1e3)}s`;
+	const minutes = Math.floor(durationMs / 6e4);
+	const seconds = Math.round(durationMs % 6e4 / 1e3);
+	if (seconds === 0) return `${minutes}m`;
+	if (seconds === 60) return `${minutes + 1}m`;
+	return `${minutes}m ${seconds}s`;
+}
+function formatElapsed(startIso, endIso) {
+	if (!endIso) return null;
+	const startedAt = Date.parse(startIso);
+	const endedAt = Date.parse(endIso);
+	if (Number.isNaN(startedAt) || Number.isNaN(endedAt) || endedAt < startedAt) return null;
+	return formatDuration(endedAt - startedAt);
+}
+function isLatestTurnSettled(latestTurn, session) {
+	if (!latestTurn?.startedAt) return false;
+	if (!latestTurn.completedAt) return false;
+	if (!session) return true;
+	if (session.orchestrationStatus === "running") return false;
+	return true;
+}
+function deriveActiveWorkStartedAt(latestTurn, session, sendStartedAt) {
+	if (!isLatestTurnSettled(latestTurn, session)) return latestTurn?.startedAt ?? sendStartedAt;
+	return sendStartedAt;
+}
+//#endregion
+export { deriveActiveWorkStartedAt, formatDuration, formatElapsed, isLatestTurnSettled };

package/dist/shared/path.d.ts

@@ -0,0 +1,2 @@
+import { a as isWindowsAbsolutePath, c as normalizeProjectPathForDispatch, i as isUncPath, o as isWindowsDrivePath, r as isExplicitRelativePath, s as normalizeProjectPathForComparison } from "../shared.js";
+export { isExplicitRelativePath, isUncPath, isWindowsAbsolutePath, isWindowsDrivePath, normalizeProjectPathForComparison, normalizeProjectPathForDispatch };

package/dist/shared/path.js

@@ -0,0 +1,2 @@
+import { an as isUncPath, cn as normalizeProjectPathForComparison, in as isExplicitRelativePath, ln as normalizeProjectPathForDispatch, on as isWindowsAbsolutePath, sn as isWindowsDrivePath } from "../shared.js";
+export { isExplicitRelativePath, isUncPath, isWindowsAbsolutePath, isWindowsDrivePath, normalizeProjectPathForComparison, normalizeProjectPathForDispatch };

package/dist/shared/preview.d.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+//#region upstream-t3code/packages/shared/src/preview.d.ts
+/**
+ * Generate a fresh preview tab id. Lives in shared (not contracts) because
+ * the contracts package is schema-only — runtime helpers belong here.
+ */
+declare function newPreviewTabId(): string;
+/** Internal — used by `lsof` parsing where the host string is wire-formatted. */
+declare const LSOF_LOCAL_HOST_TOKENS: ReadonlySet<string>;
+declare function isLoopbackHost(host: string): boolean;
+/** True when a raw URL string looks like a loopback dev URL we can preview. */
+declare function isPreviewableUrl(rawUrl: string): boolean;
+declare const PreviewUrlNormalizationError_base: Schema.Class<PreviewUrlNormalizationError, Schema.TaggedStruct<"PreviewUrlNormalizationError", {
+  readonly inputLength: Schema.Number;
+  readonly reason: Schema.Literals<readonly ["empty", "parse", "unsupported-protocol"]>;
+  readonly protocol: Schema.optional<Schema.String>;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+declare class PreviewUrlNormalizationError extends PreviewUrlNormalizationError_base {
+  get message(): string;
+}
+declare const isPreviewUrlNormalizationError: <I>(input: I) => input is I & PreviewUrlNormalizationError;
+/**
+ * Normalise a free-form URL string into a fully-qualified `http(s)://` URL.
+ *
+ * - Bare loopback hosts (`localhost`, `localhost:5173`) become `http://...`.
+ * - Bare public hosts (`example.com`) become `https://...`.
+ * - Already-qualified URLs are validated and returned as `URL.href`.
+ *
+ * Throws `PreviewUrlNormalizationError` for empty, unparseable, or
+ * unsupported-protocol inputs.
+ */
+declare function normalizePreviewUrl(rawUrl: string): string;
+//#endregion
+export { LSOF_LOCAL_HOST_TOKENS, PreviewUrlNormalizationError, isLoopbackHost, isPreviewUrlNormalizationError, isPreviewableUrl, newPreviewTabId, normalizePreviewUrl };