t3code-cli 0.13.0 → 0.14.1

package/dist/shared/relayAuth.d.ts

@@ -0,0 +1,27 @@
+import * as Schema from "effect/Schema";
+//#region upstream-t3code/packages/shared/src/relayAuth.d.ts
+declare const ClerkPublishableKeyDecodeError_base: Schema.Class<ClerkPublishableKeyDecodeError, Schema.TaggedStruct<"ClerkPublishableKeyDecodeError", {
+  readonly keyPrefix: Schema.Literals<readonly ["pk_test", "pk_live", "unknown"]>;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class ClerkPublishableKeyDecodeError extends ClerkPublishableKeyDecodeError_base {
+  get message(): string;
+}
+declare const ClerkPublishableKeyFrontendApiError_base: Schema.Class<ClerkPublishableKeyFrontendApiError, Schema.TaggedStruct<"ClerkPublishableKeyFrontendApiError", {
+  readonly keyPrefix: Schema.Literals<readonly ["pk_test", "pk_live", "unknown"]>;
+  readonly frontendApi: Schema.String;
+  readonly reason: Schema.Literals<readonly ["empty", "contains-path", "invalid-url"]>;
+  readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+declare class ClerkPublishableKeyFrontendApiError extends ClerkPublishableKeyFrontendApiError_base {
+  get message(): string;
+}
+declare function clerkFrontendApiUrlFromPublishableKey(publishableKey: string): string;
+declare function clerkFrontendApiHostnameFromPublishableKey(publishableKey: string): string;
+declare function isAllowedClerkFrontendApiHostname(hostname: string, configuredHostname: string | null): boolean;
+declare function relayClerkTokenOptions(template: string): {
+  readonly template: string;
+  readonly skipCache: true;
+};
+//#endregion
+export { ClerkPublishableKeyDecodeError, ClerkPublishableKeyFrontendApiError, clerkFrontendApiHostnameFromPublishableKey, clerkFrontendApiUrlFromPublishableKey, isAllowedClerkFrontendApiHostname, relayClerkTokenOptions };

package/dist/shared/relayAuth.js

@@ -0,0 +1,83 @@
+import { GT as Defect, JT as Literals, QT as String, eE as TaggedErrorClass, uE as optional } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/relayAuth.ts
+const ClerkPublishableKeyPrefix = Literals([
+	"pk_test",
+	"pk_live",
+	"unknown"
+]);
+var ClerkPublishableKeyDecodeError = class extends TaggedErrorClass()("ClerkPublishableKeyDecodeError", {
+	keyPrefix: ClerkPublishableKeyPrefix,
+	cause: Defect()
+}) {
+	get message() {
+		return `Failed to decode Clerk publishable key (${this.keyPrefix}).`;
+	}
+};
+var ClerkPublishableKeyFrontendApiError = class extends TaggedErrorClass()("ClerkPublishableKeyFrontendApiError", {
+	keyPrefix: ClerkPublishableKeyPrefix,
+	frontendApi: String,
+	reason: Literals([
+		"empty",
+		"contains-path",
+		"invalid-url"
+	]),
+	cause: optional(Defect())
+}) {
+	get message() {
+		return `Invalid Clerk frontend API decoded from publishable key (${this.keyPrefix}; ${this.reason}).`;
+	}
+};
+function parseClerkFrontendApi(publishableKey) {
+	const keyPrefix = publishableKey.startsWith("pk_test_") ? "pk_test" : publishableKey.startsWith("pk_live_") ? "pk_live" : "unknown";
+	const encodedFrontendApi = publishableKey.split("_").slice(2).join("_");
+	let frontendApi;
+	try {
+		frontendApi = globalThis.atob(encodedFrontendApi).replace(/\$$/u, "");
+	} catch (cause) {
+		throw new ClerkPublishableKeyDecodeError({
+			keyPrefix,
+			cause
+		});
+	}
+	if (frontendApi.length === 0) throw new ClerkPublishableKeyFrontendApiError({
+		keyPrefix,
+		frontendApi,
+		reason: "empty"
+	});
+	if (frontendApi.includes("/")) throw new ClerkPublishableKeyFrontendApiError({
+		keyPrefix,
+		frontendApi,
+		reason: "contains-path"
+	});
+	const url = `https://${frontendApi}`;
+	try {
+		return {
+			hostname: new URL(url).hostname,
+			url
+		};
+	} catch (cause) {
+		throw new ClerkPublishableKeyFrontendApiError({
+			keyPrefix,
+			frontendApi,
+			reason: "invalid-url",
+			cause
+		});
+	}
+}
+function clerkFrontendApiUrlFromPublishableKey(publishableKey) {
+	return parseClerkFrontendApi(publishableKey).url;
+}
+function clerkFrontendApiHostnameFromPublishableKey(publishableKey) {
+	return parseClerkFrontendApi(publishableKey).hostname;
+}
+function isAllowedClerkFrontendApiHostname(hostname, configuredHostname) {
+	return hostname.endsWith(".clerk.accounts.dev") || hostname.endsWith(".clerk.accounts.com") || hostname === configuredHostname;
+}
+function relayClerkTokenOptions(template) {
+	return {
+		template,
+		skipCache: true
+	};
+}
+//#endregion
+export { ClerkPublishableKeyDecodeError, ClerkPublishableKeyFrontendApiError, clerkFrontendApiHostnameFromPublishableKey, clerkFrontendApiUrlFromPublishableKey, isAllowedClerkFrontendApiHostname, relayClerkTokenOptions };

package/dist/shared/relayClient.d.ts

@@ -0,0 +1,58 @@
+import { zC as RelayClientInstallProgressEvent } from "../shared.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+import * as Crypto from "effect/Crypto";
+import * as Path from "effect/Path";
+import * as FileSystem from "effect/FileSystem";
+import { ChildProcessSpawner } from "effect/unstable/process";
+//#region upstream-t3code/packages/shared/src/relayClient.d.ts
+declare const CLOUDFLARED_VERSION = "2026.5.2";
+declare const CLOUDFLARED_PATH_ENV_NAME = "T3CODE_CLOUDFLARED_PATH";
+type RelayClientExecutableSource = "override" | "managed" | "path";
+type RelayClientStatus = {
+  readonly status: "available";
+  readonly executablePath: string;
+  readonly source: RelayClientExecutableSource;
+  readonly version: string;
+} | {
+  readonly status: "missing";
+  readonly version: string;
+} | {
+  readonly status: "unsupported";
+  readonly platform: NodeJS.Platform;
+  readonly arch: string;
+  readonly version: string;
+};
+type AvailableRelayClient = Extract<RelayClientStatus, {
+  readonly status: "available";
+}>;
+declare const RelayClientInstallError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+  readonly _tag: "RelayClientInstallError";
+} & Readonly<A>;
+declare class RelayClientInstallError extends RelayClientInstallError_base<{
+  readonly reason: "download_failed" | "invalid_checksum" | "install_locked" | "override_missing" | "unsupported_platform" | "validation_failed" | "write_failed";
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
+interface CloudflaredReleaseAsset {
+  readonly url: string;
+  readonly sha256: string;
+  readonly archive: "binary" | "tgz";
+}
+interface CloudflaredRelayClientOptions {
+  readonly baseDir: string;
+  readonly releaseAsset?: CloudflaredReleaseAsset;
+}
+interface RelayClientShape {
+  readonly resolve: Effect.Effect<RelayClientStatus>;
+  readonly install: Effect.Effect<AvailableRelayClient, RelayClientInstallError>;
+  readonly installWithProgress: (report: (event: RelayClientInstallProgressEvent) => Effect.Effect<void>) => Effect.Effect<AvailableRelayClient, RelayClientInstallError>;
+}
+declare const RelayClient_base: Context.ServiceClass<RelayClient, "@t3tools/shared/relayClient", RelayClientShape>;
+declare class RelayClient extends RelayClient_base {}
+declare const makeCloudflaredRelayClient: (options: CloudflaredRelayClientOptions) => Effect.Effect<RelayClientShape, never, ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
+declare const layerCloudflared: (options: CloudflaredRelayClientOptions) => Layer.Layer<RelayClient, never, ChildProcessSpawner.ChildProcessSpawner | Crypto.Crypto | FileSystem.FileSystem | HttpClient.HttpClient | Path.Path>;
+//#endregion
+export { AvailableRelayClient, CLOUDFLARED_PATH_ENV_NAME, CLOUDFLARED_VERSION, CloudflaredRelayClientOptions, CloudflaredReleaseAsset, RelayClient, RelayClientExecutableSource, RelayClientInstallError, RelayClientShape, RelayClientStatus, layerCloudflared, makeCloudflaredRelayClient };

package/dist/shared/relayClient.js

@@ -0,0 +1,245 @@
+import { $D as flatMap$1, BT as string, Bk as isSome, CO as scoped, DO as suspend, EO as succeed, GO as currentTimeMillis, HC as get, HD as as, IC as HttpClient, KO as TaggedError, LT as all, Mk as flatMap, OE as FileSystem, QD as fail, QO as effect, RO as void_, RT as map, Rk as getOrUndefined, TE as Path, TO as sleep, Uk as none, VC as filterStatusOk, Wk as some, YD as catch_, ZD as ensuring, aO as gen, bE as ChildProcessSpawner, dO as mapError, eO as fn, gO as orDie, hO as option$1, jD as encodeHex, kk as Service, mD as make, oO as ignore, pE as Crypto, qD as catchTag, vE as make$1, w as HostProcessPlatform, y as HostProcessArchitecture, zT as option, zk as isNone } from "../shared.js";
+//#region upstream-t3code/packages/shared/src/relayClient.ts
+const CLOUDFLARED_VERSION = "2026.5.2";
+const CLOUDFLARED_PATH_ENV_NAME = "T3CODE_CLOUDFLARED_PATH";
+var RelayClientInstallError = class extends TaggedError("RelayClientInstallError") {};
+var CloudflaredCommandError = class extends TaggedError("CloudflaredCommandError") {};
+const CLOUDFLARED_RELEASE_ASSETS = {
+	"darwin-arm64": {
+		url: "https://github.com/cloudflare/cloudflared/releases/download/2026.5.2/cloudflared-darwin-arm64.tgz",
+		sha256: "ba94054c9fd4297645093d59d51442e5e546d07bb0516120e694a13d5b216d38",
+		archive: "tgz"
+	},
+	"darwin-x64": {
+		url: "https://github.com/cloudflare/cloudflared/releases/download/2026.5.2/cloudflared-darwin-amd64.tgz",
+		sha256: "7240f709506bc2c1eb9da4d89cf2555499c60280ecb854b7d80e8f17d4b7903d",
+		archive: "tgz"
+	},
+	"linux-arm64": {
+		url: "https://github.com/cloudflare/cloudflared/releases/download/2026.5.2/cloudflared-linux-arm64",
+		sha256: "5a4e8ce2701105271412059f44b6a0bf1ae4542b4d98ff3180c0c019443a5815",
+		archive: "binary"
+	},
+	"linux-x64": {
+		url: "https://github.com/cloudflare/cloudflared/releases/download/2026.5.2/cloudflared-linux-amd64",
+		sha256: "5286698547f03df745adb2355f04c12dde52ef425491e81f433642d695521886",
+		archive: "binary"
+	},
+	"win32-x64": {
+		url: "https://github.com/cloudflare/cloudflared/releases/download/2026.5.2/cloudflared-windows-amd64.exe",
+		sha256: "20b9638f685333d623798e733effbad2487093f15ba592f6c7752360ff3b7ab7",
+		archive: "binary"
+	}
+};
+const INSTALL_LOCK_RETRY_COUNT = 100;
+const INSTALL_LOCK_RETRY_DELAY = "100 millis";
+const INSTALL_LOCK_STALE_MS = 300 * 1e3;
+const trimmedString = (name) => string(name).pipe(option, map(flatMap((value) => {
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? some(trimmed) : none();
+})));
+const CloudflaredConfig = all({
+	executableOverride: trimmedString(CLOUDFLARED_PATH_ENV_NAME),
+	path: trimmedString("PATH")
+});
+var RelayClient = class extends Service()("@t3tools/shared/relayClient") {};
+function executableFileName(platform) {
+	return platform === "win32" ? "cloudflared.exe" : "cloudflared";
+}
+function resolveReleaseAsset(platform, arch) {
+	return CLOUDFLARED_RELEASE_ASSETS[`${platform}-${arch}`] ?? null;
+}
+function isAlreadyExists(error) {
+	return error.reason._tag === "AlreadyExists";
+}
+const wrapInstallFailure = (reason, message) => (effect) => effect.pipe(mapError((cause) => new RelayClientInstallError({
+	reason,
+	message,
+	cause
+})));
+const makeCloudflaredRelayClient = fn("cloudflared.make")(function* (options) {
+	const crypto = yield* Crypto;
+	const fileSystem = yield* FileSystem;
+	const httpClient = yield* HttpClient;
+	const path = yield* Path;
+	const spawner = yield* ChildProcessSpawner;
+	const installSemaphore = yield* make(1);
+	const platform = yield* HostProcessPlatform;
+	const arch = yield* HostProcessArchitecture;
+	const releaseAsset = options.releaseAsset ?? resolveReleaseAsset(platform, arch);
+	const loadCloudflaredConfig = suspend(() => CloudflaredConfig).pipe(orDie);
+	const managedPath = path.join(options.baseDir, "tools", "cloudflared", CLOUDFLARED_VERSION, `${platform}-${arch}`, executableFileName(platform));
+	const isExecutableFile = fn("cloudflared.isExecutableFile")(function* (executablePath) {
+		const info = yield* fileSystem.stat(executablePath).pipe(option$1);
+		if (isNone(info) || info.value.type !== "File") return false;
+		return platform === "win32" || (info.value.mode & 73) !== 0;
+	});
+	const resolvePathExecutable = gen(function* () {
+		const pathValue = getOrUndefined((yield* loadCloudflaredConfig).path);
+		if (!pathValue) return null;
+		const delimiter = platform === "win32" ? ";" : ":";
+		for (const directory of pathValue.split(delimiter)) {
+			const trimmed = directory.trim().replace(/^"|"$/gu, "");
+			if (trimmed.length === 0) continue;
+			const candidate = path.join(trimmed, executableFileName(platform));
+			if (yield* isExecutableFile(candidate)) return candidate;
+		}
+		return null;
+	});
+	const resolve = gen(function* () {
+		const config = yield* loadCloudflaredConfig;
+		if (isSome(config.executableOverride)) return (yield* isExecutableFile(config.executableOverride.value)) ? {
+			status: "available",
+			executablePath: config.executableOverride.value,
+			source: "override",
+			version: CLOUDFLARED_VERSION
+		} : {
+			status: "missing",
+			version: CLOUDFLARED_VERSION
+		};
+		if (yield* isExecutableFile(managedPath)) return {
+			status: "available",
+			executablePath: managedPath,
+			source: "managed",
+			version: CLOUDFLARED_VERSION
+		};
+		const pathExecutable = yield* resolvePathExecutable;
+		if (pathExecutable) return {
+			status: "available",
+			executablePath: pathExecutable,
+			source: "path",
+			version: CLOUDFLARED_VERSION
+		};
+		return releaseAsset ? {
+			status: "missing",
+			version: CLOUDFLARED_VERSION
+		} : {
+			status: "unsupported",
+			platform,
+			arch,
+			version: CLOUDFLARED_VERSION
+		};
+	});
+	const runCommand = fn("cloudflared.runCommand")(function* (command, args) {
+		const child = yield* spawner.spawn(make$1(command, args, {
+			shell: false,
+			stdout: "ignore",
+			stderr: "ignore"
+		}));
+		const exitCode = Number(yield* child.exitCode);
+		if (exitCode !== 0) return yield* new CloudflaredCommandError({
+			command,
+			exitCode
+		});
+	});
+	const downloadAsset = fn("cloudflared.downloadAsset")(function* (asset, report) {
+		yield* report("downloading");
+		const response = yield* httpClient.execute(get(asset.url)).pipe(flatMap$1(filterStatusOk), mapError((cause) => new RelayClientInstallError({
+			reason: "download_failed",
+			message: "Could not download the relay client.",
+			cause
+		})));
+		const bytes = new Uint8Array(yield* response.arrayBuffer.pipe(mapError((cause) => new RelayClientInstallError({
+			reason: "download_failed",
+			message: "Could not read the downloaded relay client binary.",
+			cause
+		}))));
+		yield* report("verifying");
+		if (encodeHex(yield* crypto.digest("SHA-256", bytes).pipe(mapError((cause) => new RelayClientInstallError({
+			reason: "validation_failed",
+			message: "Could not verify the downloaded relay client checksum.",
+			cause
+		})))) !== asset.sha256) return yield* new RelayClientInstallError({
+			reason: "invalid_checksum",
+			message: "Downloaded relay client checksum did not match the pinned release."
+		});
+		return bytes;
+	});
+	const acquireInstallLock = fn("cloudflared.acquireInstallLock")(function* (lockPath) {
+		for (let attempt = 0; attempt < INSTALL_LOCK_RETRY_COUNT; attempt += 1) {
+			if (yield* fileSystem.writeFileString(lockPath, "", { flag: "wx" }).pipe(as(true), catch_((error) => isAlreadyExists(error) ? succeed(false) : fail(error)))) return;
+			const now = yield* currentTimeMillis;
+			const mtime = flatMap(yield* fileSystem.stat(lockPath).pipe(option$1), (info) => info.mtime);
+			if (isSome(mtime) && now - mtime.value.getTime() > INSTALL_LOCK_STALE_MS) {
+				yield* fileSystem.remove(lockPath, { force: true });
+				continue;
+			}
+			yield* sleep(INSTALL_LOCK_RETRY_DELAY);
+		}
+		return yield* new RelayClientInstallError({
+			reason: "install_locked",
+			message: "Another relay client installation is still in progress."
+		});
+	});
+	const installUnlocked = fn("cloudflared.installUnlocked")(function* (report) {
+		yield* report("checking");
+		const existing = yield* resolve;
+		if (existing.status === "available") return existing;
+		if (isSome((yield* loadCloudflaredConfig).executableOverride)) return yield* new RelayClientInstallError({
+			reason: "override_missing",
+			message: `${CLOUDFLARED_PATH_ENV_NAME} does not point to an executable file.`
+		});
+		if (!releaseAsset) return yield* new RelayClientInstallError({
+			reason: "unsupported_platform",
+			message: `T3 Code does not provide a managed relay client binary for ${platform}-${arch}.`
+		});
+		const managedDirectory = path.dirname(managedPath);
+		const lockPath = `${managedPath}.lock`;
+		yield* fileSystem.makeDirectory(managedDirectory, { recursive: true }).pipe(wrapInstallFailure("write_failed", "Could not create the relay client tool directory."));
+		yield* report("waiting_for_lock");
+		yield* acquireInstallLock(lockPath).pipe(catchTag("PlatformError", (cause) => fail(new RelayClientInstallError({
+			reason: "write_failed",
+			message: "Could not acquire the relay client installation lock.",
+			cause
+		}))));
+		return yield* gen(function* () {
+			const afterLock = yield* resolve;
+			if (afterLock.status === "available") return afterLock;
+			const tempDirectory = yield* fileSystem.makeTempDirectoryScoped({
+				directory: managedDirectory,
+				prefix: ".install-"
+			});
+			const archivePath = path.join(tempDirectory, releaseAsset.archive === "tgz" ? "cloudflared.tgz" : executableFileName(platform));
+			const download = yield* downloadAsset(releaseAsset, report);
+			yield* report("installing");
+			yield* fileSystem.writeFile(archivePath, download).pipe(wrapInstallFailure("write_failed", "Could not write the relay client download."));
+			const executablePath = path.join(tempDirectory, executableFileName(platform));
+			if (releaseAsset.archive === "tgz") yield* runCommand("tar", [
+				"-xzf",
+				archivePath,
+				"-C",
+				tempDirectory
+			]).pipe(wrapInstallFailure("write_failed", "Could not extract the relay client."));
+			if (platform !== "win32") yield* fileSystem.chmod(executablePath, 493).pipe(wrapInstallFailure("write_failed", "Could not make the relay client executable."));
+			yield* report("validating");
+			yield* runCommand(executablePath, ["--version"]).pipe(wrapInstallFailure("validation_failed", "The downloaded relay client binary did not run."));
+			const stagedPath = `${managedPath}.${yield* crypto.randomUUIDv4}.tmp`;
+			yield* report("activating");
+			yield* fileSystem.rename(executablePath, stagedPath).pipe(wrapInstallFailure("write_failed", "Could not stage the relay client."));
+			yield* fileSystem.rename(stagedPath, managedPath).pipe(wrapInstallFailure("write_failed", "Could not activate the relay client."), ensuring(fileSystem.remove(stagedPath, { force: true }).pipe(ignore)));
+			return {
+				status: "available",
+				executablePath: managedPath,
+				source: "managed",
+				version: CLOUDFLARED_VERSION
+			};
+		}).pipe(scoped, ensuring(fileSystem.remove(lockPath, { force: true }).pipe(ignore)), catch_((cause) => cause instanceof RelayClientInstallError ? fail(cause) : fail(new RelayClientInstallError({
+			reason: "write_failed",
+			message: "Could not install the relay client.",
+			cause
+		}))));
+	});
+	const installWithProgress = (report) => installSemaphore.withPermit(installUnlocked((stage) => report({
+		type: "progress",
+		stage
+	})));
+	const install = installWithProgress(() => void_);
+	return RelayClient.of({
+		resolve,
+		install,
+		installWithProgress
+	});
+});
+const layerCloudflared = (options) => effect(RelayClient, makeCloudflaredRelayClient(options));
+//#endregion
+export { CLOUDFLARED_PATH_ENV_NAME, CLOUDFLARED_VERSION, RelayClient, RelayClientInstallError, layerCloudflared, makeCloudflaredRelayClient };

package/dist/shared/relayJwt.d.ts

@@ -0,0 +1,39 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { JWTPayload } from "jose";
+//#region upstream-t3code/packages/shared/src/relayJwt.d.ts
+declare const RELAY_LINK_PROOF_TYP = "t3-env-link+jwt";
+declare const RELAY_MINT_REQUEST_TYP = "t3-cloud-mint+jwt";
+declare const RELAY_HEALTH_REQUEST_TYP = "t3-cloud-health+jwt";
+declare const RELAY_MINT_RESPONSE_TYP = "t3-env-mint+jwt";
+declare const RELAY_HEALTH_RESPONSE_TYP = "t3-env-health+jwt";
+declare const RELAY_ACTIVITY_PUBLISH_TYP = "t3-env-activity+jwt";
+declare const RelayJwtError_base: Schema.Class<RelayJwtError, Schema.TaggedStruct<"RelayJwtError", {
+  readonly operation: Schema.Literals<readonly ["sign", "verify"]>;
+  readonly typ: Schema.String;
+  readonly issuer: Schema.optional<Schema.String>;
+  readonly audience: Schema.optional<Schema.String>;
+  readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+declare class RelayJwtError extends RelayJwtError_base {
+  get message(): string;
+  static diagnosticCode(error: RelayJwtError): string;
+}
+declare function normalizeRelayIssuer(value: string): string;
+declare function decodeRelayJwt(token: string): JWTPayload;
+declare function signRelayJwt(input: {
+  readonly privateKey: string;
+  readonly typ: string;
+  readonly payload: JWTPayload;
+}): Effect.Effect<string, RelayJwtError>;
+declare function verifyRelayJwt(input: {
+  readonly publicKey: string;
+  readonly token: string;
+  readonly typ: string;
+  readonly issuer: string;
+  readonly audience: string;
+  readonly nowEpochSeconds: number;
+  readonly maxTokenAge?: string | number;
+}): Effect.Effect<JWTPayload, RelayJwtError>;
+//#endregion
+export { RELAY_ACTIVITY_PUBLISH_TYP, RELAY_HEALTH_REQUEST_TYP, RELAY_HEALTH_RESPONSE_TYP, RELAY_LINK_PROOF_TYP, RELAY_MINT_REQUEST_TYP, RELAY_MINT_RESPONSE_TYP, RelayJwtError, decodeRelayJwt, normalizeRelayIssuer, signRelayJwt, verifyRelayJwt };

package/dist/shared/relayJwt.js

@@ -0,0 +1,2 @@
+import { $a as RELAY_HEALTH_REQUEST_TYP, Qa as RELAY_ACTIVITY_PUBLISH_TYP, ao as decodeRelayJwt, co as verifyRelayJwt, eo as RELAY_HEALTH_RESPONSE_TYP, io as RelayJwtError, no as RELAY_MINT_REQUEST_TYP, oo as normalizeRelayIssuer, ro as RELAY_MINT_RESPONSE_TYP, so as signRelayJwt, to as RELAY_LINK_PROOF_TYP } from "../shared.js";
+export { RELAY_ACTIVITY_PUBLISH_TYP, RELAY_HEALTH_REQUEST_TYP, RELAY_HEALTH_RESPONSE_TYP, RELAY_LINK_PROOF_TYP, RELAY_MINT_REQUEST_TYP, RELAY_MINT_RESPONSE_TYP, RelayJwtError, decodeRelayJwt, normalizeRelayIssuer, signRelayJwt, verifyRelayJwt };

package/dist/shared/relaySigning.d.ts

@@ -0,0 +1,4 @@
+//#region upstream-t3code/packages/shared/src/relaySigning.d.ts
+declare function stableStringify(value: unknown): string;
+//#endregion
+export { stableStringify };

package/dist/shared/relaySigning.js

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

package/dist/shared/relayTracing.d.ts

@@ -0,0 +1,25 @@
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Layer from "effect/Layer";
+import { HttpClient } from "effect/unstable/http";
+import * as Tracer from "effect/Tracer";
+//#region upstream-t3code/packages/shared/src/relayTracing.d.ts
+interface RelayClientTracingConfig {
+  readonly tracesUrl: string;
+  readonly tracesDataset: string;
+  readonly tracesToken: string;
+}
+interface RelayClientTracingResource {
+  readonly serviceName: string;
+  readonly serviceVersion?: string;
+  readonly runtime: string;
+  readonly client: string;
+  readonly component?: string;
+}
+declare const RelayClientTracer_base: Context.Reference<Option.Option<Tracer.Tracer>>;
+declare class RelayClientTracer extends RelayClientTracer_base {}
+declare const withRelayClientTracing: <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+declare function makeRelayClientTracingLayer(config: RelayClientTracingConfig | null, resource: RelayClientTracingResource): Layer.Layer<never, never, HttpClient.HttpClient>;
+//#endregion
+export { RelayClientTracer, RelayClientTracingConfig, RelayClientTracingResource, makeRelayClientTracingLayer, withRelayClientTracing };

package/dist/shared/relayTracing.js

@@ -0,0 +1,2 @@
+import { Jo as withRelayClientTracing, Ko as RelayClientTracer, qo as makeRelayClientTracingLayer } from "../shared.js";
+export { RelayClientTracer, makeRelayClientTracingLayer, withRelayClientTracing };

package/dist/shared/relayUrl.d.ts

@@ -0,0 +1,5 @@
+//#region upstream-t3code/packages/shared/src/relayUrl.d.ts
+declare function normalizeSecureRelayUrl(value: string): string | null;
+declare function isSecureRelayUrl(value: string): boolean;
+//#endregion
+export { isSecureRelayUrl, normalizeSecureRelayUrl };

package/dist/shared/relayUrl.js

@@ -0,0 +1,2 @@
+import { Xa as isSecureRelayUrl, Za as normalizeSecureRelayUrl } from "../shared.js";
+export { isSecureRelayUrl, normalizeSecureRelayUrl };

package/dist/shared/remote.d.ts

@@ -0,0 +1,57 @@
+import * as Schema from "effect/Schema";
+//#region upstream-t3code/packages/shared/src/remote.d.ts
+declare const readHashParams: (url: URL) => URLSearchParams;
+declare const RemoteBackendUrlMissingError_base: Schema.Class<RemoteBackendUrlMissingError, Schema.TaggedStruct<"RemoteBackendUrlMissingError", {}>, import("effect/Cause").YieldableError>;
+declare class RemoteBackendUrlMissingError extends RemoteBackendUrlMissingError_base {
+  get message(): string;
+}
+declare const RemotePairingUrlInvalidError_base: Schema.Class<RemotePairingUrlInvalidError, Schema.TaggedStruct<"RemotePairingUrlInvalidError", {
+  readonly cause: Schema.optional<Schema.Defect>;
+  readonly protocol: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class RemotePairingUrlInvalidError extends RemotePairingUrlInvalidError_base {
+  get message(): string;
+}
+declare const RemoteBackendUrlInvalidError_base: Schema.Class<RemoteBackendUrlInvalidError, Schema.TaggedStruct<"RemoteBackendUrlInvalidError", {
+  readonly source: Schema.Literals<readonly ["direct-host", "hosted-pairing-host"]>;
+  readonly cause: Schema.optional<Schema.Defect>;
+  readonly protocol: Schema.optional<Schema.String>;
+}>, import("effect/Cause").YieldableError>;
+declare class RemoteBackendUrlInvalidError extends RemoteBackendUrlInvalidError_base {
+  get message(): string;
+}
+declare const RemotePairingTokenMissingError_base: Schema.Class<RemotePairingTokenMissingError, Schema.TaggedStruct<"RemotePairingTokenMissingError", {
+  readonly host: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemotePairingTokenMissingError extends RemotePairingTokenMissingError_base {
+  get message(): string;
+}
+declare const RemotePairingCodeMissingError_base: Schema.Class<RemotePairingCodeMissingError, Schema.TaggedStruct<"RemotePairingCodeMissingError", {
+  readonly host: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+declare class RemotePairingCodeMissingError extends RemotePairingCodeMissingError_base {
+  get message(): string;
+}
+declare const RemotePairingTargetError: Schema.Union<readonly [typeof RemoteBackendUrlMissingError, typeof RemotePairingUrlInvalidError, typeof RemoteBackendUrlInvalidError, typeof RemotePairingTokenMissingError, typeof RemotePairingCodeMissingError]>;
+type RemotePairingTargetError = typeof RemotePairingTargetError.Type;
+interface ResolvedRemotePairingTarget {
+  readonly credential: string;
+  readonly httpBaseUrl: string;
+  readonly wsBaseUrl: string;
+}
+interface HostedPairingRequest {
+  readonly host: string;
+  readonly token: string;
+  readonly label: string;
+}
+declare const getPairingTokenFromUrl: (url: URL) => string | null;
+declare const stripPairingTokenFromUrl: (url: URL) => URL;
+declare const setPairingTokenOnUrl: (url: URL, credential: string) => URL;
+declare const readHostedPairingRequest: (url: URL) => HostedPairingRequest | null;
+declare const resolveRemotePairingTarget: (input: {
+  readonly pairingUrl?: string;
+  readonly host?: string;
+  readonly pairingCode?: string;
+}) => ResolvedRemotePairingTarget;
+//#endregion
+export { HostedPairingRequest, RemoteBackendUrlInvalidError, RemoteBackendUrlMissingError, RemotePairingCodeMissingError, RemotePairingTargetError, RemotePairingTokenMissingError, RemotePairingUrlInvalidError, ResolvedRemotePairingTarget, getPairingTokenFromUrl, readHashParams, readHostedPairingRequest, resolveRemotePairingTarget, setPairingTokenOnUrl, stripPairingTokenFromUrl };

package/dist/shared/remote.js

@@ -0,0 +1,2 @@
+import { Ca as readHostedPairingRequest, Ea as stripPairingTokenFromUrl, Sa as readHashParams, Ta as setPairingTokenOnUrl, _a as RemotePairingCodeMissingError, ba as RemotePairingUrlInvalidError, ga as RemoteBackendUrlMissingError, ha as RemoteBackendUrlInvalidError, va as RemotePairingTargetError, wa as resolveRemotePairingTarget, xa as getPairingTokenFromUrl, ya as RemotePairingTokenMissingError } from "../shared.js";
+export { RemoteBackendUrlInvalidError, RemoteBackendUrlMissingError, RemotePairingCodeMissingError, RemotePairingTargetError, RemotePairingTokenMissingError, RemotePairingUrlInvalidError, getPairingTokenFromUrl, readHashParams, readHostedPairingRequest, resolveRemotePairingTarget, setPairingTokenOnUrl, stripPairingTokenFromUrl };

package/dist/shared/schemaJson.d.ts

@@ -0,0 +1,35 @@
+import * as Schema from "effect/Schema";
+import * as Cause from "effect/Cause";
+import * as Result from "effect/Result";
+import * as SchemaGetter from "effect/SchemaGetter";
+import * as SchemaTransformation from "effect/SchemaTransformation";
+//#region upstream-t3code/packages/shared/src/schemaJson.d.ts
+declare const decodeJsonResult: <S extends Schema.Codec<unknown, unknown, never, never>>(schema: S) => (input: string) => Result.Result<never, Cause.Cause<Schema.SchemaError>> | Result.Result<S["Type"], never>;
+declare const decodeUnknownJsonResult: <S extends Schema.Codec<unknown, unknown, never, never>>(schema: S) => (input: unknown) => Result.Result<never, Cause.Cause<Schema.SchemaError>> | Result.Result<S["Type"], never>;
+declare const formatSchemaError: (cause: Cause.Cause<Schema.SchemaError>) => string;
+/**
+ * Schema transformation: lenient JSONC string ↔ unknown.
+ *
+ * Same API as `SchemaTransformation.fromJsonString`, but the decode side
+ * strips trailing commas and JS-style comments before parsing.
+ * Encoding produces strict JSON via `JSON.stringify`.
+ */
+declare const fromLenientJsonString: SchemaTransformation.Transformation<unknown, string, never, never>;
+declare const prettyJsonString: SchemaGetter.Getter<string, string, never>;
+/**
+ * Build a schema that decodes a lenient JSON string into `A`.
+ *
+ * Drop-in replacement for `Schema.fromJsonString(schema)` that tolerates
+ * trailing commas and comments in the input.
+ */
+declare const fromLenientJson: <S extends Schema.Top>(schema: S) => Schema.decodeTo<S, Schema.String, never, never>;
+declare function extractJsonObject(raw: string): string;
+/**
+ * Build a JSON string schema that encodes with stable 2-space formatting.
+ *
+ * Decode behavior matches `Schema.fromJsonString(schema)`. Encode behavior
+ * keeps the transformation schema-based while preserving human-readable JSON.
+ */
+declare const fromJsonStringPretty: <S extends Schema.Top>(schema: S) => Schema.decodeTo<Schema.fromJsonString<S>, Schema.toEncoded<Schema.fromJsonString<S>>, never, never>;
+//#endregion
+export { decodeJsonResult, decodeUnknownJsonResult, extractJsonObject, formatSchemaError, fromJsonStringPretty, fromLenientJson, fromLenientJsonString, prettyJsonString };

package/dist/shared/schemaJson.js

@@ -0,0 +1,2 @@
+import { _ as fromLenientJsonString, d as decodeJsonResult, f as decodeUnknownJsonResult, g as fromLenientJson, h as fromJsonStringPretty, m as formatSchemaError, p as extractJsonObject, v as prettyJsonString } from "../shared.js";
+export { decodeJsonResult, decodeUnknownJsonResult, extractJsonObject, formatSchemaError, fromJsonStringPretty, fromLenientJson, fromLenientJsonString, prettyJsonString };