@usesocial/cli 0.11.4 → 0.11.6

package/dist/index.mjs

@@ -3,7 +3,6 @@ import { createRequire } from "node:module";
 import * as fs from "node:fs";
 import { createReadStream, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { Result, TaggedError } from "better-result";
 import { homedir } from "node:os";
 import { basename, dirname, extname, join, resolve } from "node:path";
 import { parseArgs, styleText } from "node:util";
@@ -16,7 +15,6 @@ import l__default, { createInterface } from "node:readline";
 import { AsyncLocalStorage } from "node:async_hooks";
 import process$1, { stdin, stdout } from "node:process";
 import { ReadStream } from "node:tty";
-import { spawn } from "node:child_process";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -41,6 +39,367 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
+//#region ../../node_modules/.bun/better-result@2.9.2/node_modules/better-result/dist/index.mjs
+function e(e, t) {
+	return e === 2 ? ((...e) => e.length >= 2 ? t(e[0], e[1]) : (n) => t(n, e[0])) : e === 3 ? ((...e) => e.length >= 3 ? t(e[0], e[1], e[2]) : (n) => t(n, e[0], e[1])) : e === 4 ? ((...e) => e.length >= 4 ? t(e[0], e[1], e[2], e[3]) : (n) => t(n, e[0], e[1], e[2])) : ((...n) => n.length >= e ? t(...n) : (e) => t(e, ...n));
+}
+const t = (e) => e instanceof Error ? {
+	name: e.name,
+	message: e.message,
+	stack: e.stack
+} : e;
+var n$1 = class e extends Error {
+	_tag = `Panic`;
+	static is(t) {
+		return t instanceof e;
+	}
+	constructor(e) {
+		if (super(e.message, e.cause === void 0 ? void 0 : { cause: e.cause }), Object.assign(this, e), Object.setPrototypeOf(this, new.target.prototype), this.name = `Panic`, e.cause instanceof Error && e.cause.stack) {
+			let t = e.cause.stack.replace(/\n/g, `
+  `);
+			this.stack = `${this.stack}\nCaused by: ${t}`;
+		}
+	}
+	toJSON() {
+		return {
+			...this,
+			_tag: this._tag,
+			name: this.name,
+			message: this.message,
+			cause: t(this.cause),
+			stack: this.stack
+		};
+	}
+	*[Symbol.iterator]() {
+		return yield* d$1(this), i$1(`Unreachable: Err yielded in Panic but generator continued`, this);
+	}
+};
+const i$1 = (e, t) => {
+	throw new n$1({
+		message: e,
+		cause: t
+	});
+}, a = (e, t) => {
+	try {
+		return e();
+	} catch (e) {
+		throw i$1(t, e);
+	}
+}, o = async (e, t) => {
+	try {
+		return await e();
+	} catch (e) {
+		throw i$1(t, e);
+	}
+};
+var s = class e {
+	status = `ok`;
+	constructor(e) {
+		this.value = e;
+	}
+	isOk() {
+		return !0;
+	}
+	isErr() {
+		return !1;
+	}
+	map(t) {
+		return a(() => new e(t(this.value)), `map callback threw`);
+	}
+	mapError(e) {
+		return this;
+	}
+	tryRecover(e) {
+		return this;
+	}
+	tryRecoverAsync(e) {
+		return Promise.resolve(this);
+	}
+	andThen(e) {
+		return a(() => e(this.value), `andThen callback threw`);
+	}
+	andThenAsync(e) {
+		return o(() => e(this.value), `andThenAsync callback threw`);
+	}
+	match(e) {
+		return a(() => e.ok(this.value), `match ok handler threw`);
+	}
+	unwrap(e) {
+		return this.value;
+	}
+	unwrapOr(e) {
+		return this.value;
+	}
+	tap(e) {
+		return a(() => (e(this.value), this), `tap callback threw`);
+	}
+	tapAsync(e) {
+		return o(async () => (await e(this.value), this), `tapAsync callback threw`);
+	}
+	tapError(e) {
+		return this;
+	}
+	tapErrorAsync(e) {
+		return Promise.resolve(this);
+	}
+	tapBoth(e) {
+		return a(() => (e.ok(this.value), this), `tapBoth ok callback threw`);
+	}
+	tapBothAsync(e) {
+		return o(async () => (await e.ok(this.value), this), `tapBothAsync ok callback threw`);
+	}
+	*[Symbol.iterator]() {
+		return this.value;
+	}
+}, c = class e {
+	status = `error`;
+	constructor(e) {
+		this.error = e;
+	}
+	isOk() {
+		return !1;
+	}
+	isErr() {
+		return !0;
+	}
+	map(e) {
+		return this;
+	}
+	mapError(t) {
+		return a(() => new e(t(this.error)), `mapError callback threw`);
+	}
+	tryRecover(e) {
+		return a(() => e(this.error), `tryRecover callback threw`);
+	}
+	tryRecoverAsync(e) {
+		return o(() => e(this.error), `tryRecoverAsync callback threw`);
+	}
+	andThen(e) {
+		return this;
+	}
+	andThenAsync(e) {
+		return Promise.resolve(this);
+	}
+	match(e) {
+		return a(() => e.err(this.error), `match err handler threw`);
+	}
+	unwrap(e) {
+		return i$1(e ?? `Unwrap called on Err: ${String(this.error)}`, this.error);
+	}
+	unwrapOr(e) {
+		return e;
+	}
+	tap(e) {
+		return this;
+	}
+	tapError(e) {
+		return a(() => (e(this.error), this), `tapError callback threw`);
+	}
+	tapAsync(e) {
+		return Promise.resolve(this);
+	}
+	tapErrorAsync(e) {
+		return o(async () => (await e(this.error), this), `tapErrorAsync callback threw`);
+	}
+	tapBoth(e) {
+		return a(() => (e.err(this.error), this), `tapBoth err callback threw`);
+	}
+	tapBothAsync(e) {
+		return o(async () => (await e.err(this.error), this), `tapBothAsync err callback threw`);
+	}
+	*[Symbol.iterator]() {
+		return yield this, i$1(`Unreachable: Err yielded in Result.gen but generator continued`, this.error);
+	}
+};
+function l$1(e) {
+	return new s(e);
+}
+const u$1 = (e) => e.status === `ok`, d$1 = (e) => new c(e), f = (e) => e.status === `error`, p = (e) => e instanceof Error ? {
+	name: e.name,
+	message: e.message,
+	stack: e.stack
+} : e, m = (e) => e instanceof Error && `_tag` in e && typeof e._tag == `string`, h = Object.assign((e) => () => {
+	class t extends Error {
+		_tag = e;
+		static is(e) {
+			return e instanceof t;
+		}
+		constructor(t) {
+			let n = t && `message` in t && typeof t.message == `string` ? t.message : void 0, r = t && `cause` in t ? t.cause : void 0;
+			if (super(n, r === void 0 ? void 0 : { cause: r }), t && Object.assign(this, t), Object.setPrototypeOf(this, new.target.prototype), this.name = e, r instanceof Error && r.stack) {
+				let e = r.stack.replace(/\n/g, `
+  `);
+				this.stack = `${this.stack}\nCaused by: ${e}`;
+			}
+		}
+		toJSON() {
+			return {
+				...this,
+				_tag: this._tag,
+				name: this.name,
+				message: this.message,
+				cause: p(this.cause),
+				stack: this.stack
+			};
+		}
+		*[Symbol.iterator]() {
+			return yield* d$1(this), i$1(`Unreachable: Err yielded in TaggedError but generator continued`, this);
+		}
+	}
+	return t;
+}, { is: m });
+var y = class extends h(`UnhandledException`)() {
+	constructor(e) {
+		let t = e.cause instanceof Error ? `Unhandled exception: ${e.cause.message}` : `Unhandled exception: ${String(e.cause)}`;
+		super({
+			message: t,
+			cause: e.cause
+		});
+	}
+}, b = class extends h(`ResultDeserializationError`)() {
+	constructor(e) {
+		super({
+			message: `Failed to deserialize value as Result: expected { status: "ok", value } or { status: "error", error }`,
+			value: e.value
+		});
+	}
+};
+const x = (e, t) => {
+	try {
+		return e();
+	} catch (e) {
+		throw i$1(t, e);
+	}
+}, S = (e, t) => {
+	let n = () => {
+		if (typeof e == `function`) try {
+			return l$1(e());
+		} catch (e) {
+			return d$1(new y({ cause: e }));
+		}
+		try {
+			return l$1(e.try());
+		} catch (t) {
+			try {
+				return d$1(e.catch(t));
+			} catch (e) {
+				throw i$1(`Result.try catch handler threw`, e);
+			}
+		}
+	}, r = t?.retry?.times ?? 0, a = n();
+	for (let e = 0; e < r && a.status === `error`; e++) a = n();
+	return a;
+}, C$1 = async (e, t) => {
+	let n = async () => {
+		if (typeof e == `function`) try {
+			return l$1(await e());
+		} catch (e) {
+			return d$1(new y({ cause: e }));
+		}
+		try {
+			return l$1(await e.try());
+		} catch (t) {
+			try {
+				return d$1(await e.catch(t));
+			} catch (e) {
+				throw i$1(`Result.tryPromise catch handler threw`, e);
+			}
+		}
+	}, r = t?.retry;
+	if (!r) return n();
+	let a = (e) => {
+		switch (r.backoff) {
+			case `constant`: return r.delayMs;
+			case `linear`: return r.delayMs * (e + 1);
+			case `exponential`: return r.delayMs * 2 ** e;
+		}
+	}, o = (e) => new Promise((t) => setTimeout(t, e)), s = await n(), c = r.shouldRetry ?? (() => !0);
+	for (let e = 0; e < r.times && s.status === `error`; e++) {
+		let t = s.error;
+		if (!x(() => c(t), `shouldRetry predicate threw`)) break;
+		await o(a(e)), s = await n();
+	}
+	return s;
+}, w = e(2, (e, t) => e.map(t)), T = e(2, (e, t) => e.mapError(t)), E = e(2, (e, t) => e.tryRecover(t)), D = e(2, (e, t) => e.andThen(t)), O = e(2, (e, t) => e.tryRecoverAsync(t)), k = e(2, (e, t) => e.andThenAsync(t)), A = e(2, (e, t) => e.match(t)), j = e(2, (e, t) => e.tap(t)), M = e(2, (e, t) => e.tapAsync(t)), N = e(2, (e, t) => e.tapError(t)), P = e(2, (e, t) => e.tapErrorAsync(t)), F = e(2, (e, t) => e.tapBoth(t)), I = e(2, (e, t) => e.tapBothAsync(t)), L = (e, t) => e.unwrap(t);
+function R$1(e) {
+	if (!(typeof e == `object` && e && `status` in e && (e.status === `ok` || e.status === `error`))) return i$1(`Result.gen body must return Result.ok() or Result.err(), got: ` + (e === null ? `null` : typeof e == `object` ? JSON.stringify(e) : String(e)));
+}
+const z = e(2, (e, t) => e.unwrapOr(t)), B = ((e, t) => {
+	let n = e.call(t);
+	if (Symbol.asyncIterator in n) return (async () => {
+		let e = n, t;
+		try {
+			t = await e.next();
+		} catch (e) {
+			throw i$1(`generator body threw`, e);
+		}
+		if (R$1(t.value), !t.done) try {
+			await e.return?.(void 0);
+		} catch (e) {
+			throw i$1(`generator cleanup threw`, e);
+		}
+		return t.value;
+	})();
+	let r = n, a;
+	try {
+		a = r.next();
+	} catch (e) {
+		throw i$1(`generator body threw`, e);
+	}
+	if (R$1(a.value), !a.done) try {
+		r.return?.(void 0);
+	} catch (e) {
+		throw i$1(`generator cleanup threw`, e);
+	}
+	return a.value;
+});
+async function* V$1(e) {
+	return yield* await e;
+}
+function H(e) {
+	return typeof e == `object` && !!e && `status` in e && (e.status === `ok` && `value` in e || e.status === `error` && `error` in e);
+}
+const U = (e) => e.status === `ok` ? {
+	status: `ok`,
+	value: e.value
+} : {
+	status: `error`,
+	error: e.error
+}, W$2 = (e) => H(e) ? e.status === `ok` ? new s(e.value) : new c(e.error) : d$1(new b({ value: e })), G = {
+	ok: l$1,
+	isOk: u$1,
+	err: d$1,
+	isError: f,
+	try: S,
+	tryPromise: C$1,
+	map: w,
+	mapError: T,
+	tryRecover: E,
+	andThen: D,
+	tryRecoverAsync: O,
+	andThenAsync: k,
+	match: A,
+	tap: j,
+	tapAsync: M,
+	tapError: N,
+	tapErrorAsync: P,
+	tapBoth: F,
+	tapBothAsync: I,
+	unwrap: L,
+	unwrapOr: z,
+	gen: B,
+	await: V$1,
+	serialize: U,
+	deserialize: W$2,
+	hydrate: (e) => W$2(e),
+	partition: (e) => {
+		let t = [], n = [];
+		for (let r of e) r.status === `ok` ? t.push(r.value) : n.push(r.error);
+		return [t, n];
+	},
+	flatten: (e) => e.status === `ok` ? e.value : e
+};
+//#endregion
 //#region ../../packages/constants/src/index.ts
 const org = "usesocial";
 const cliPackageName = `@${org}/cli`;
@@ -88,8 +447,8 @@ const cliBrand = {
 		skill: skillInstallCommand
 	}
 };
-TaggedError("InvalidPublicBaseURL")();
-TaggedError("InvalidPublicRoute")();
+h("InvalidPublicBaseURL")();
+h("InvalidPublicRoute")();
 const publicURLForLiteral = (route) => new URL(route, brandURLs.publicWebURL).toString();
 const publicRouteURLs = {
 	pricing: publicURLForLiteral(publicLinks.pricing),
@@ -222,7 +581,7 @@ function kebabCase$1(str) {
 const flagName = (name) => kebabCase$1(name.replace(/[._]/g, "-"));
 //#endregion
 //#region ../../packages/codegen/src/runtime/index.ts
-var RuntimeUsageProblem = class extends TaggedError("RuntimeUsageProblem")() {
+var RuntimeUsageProblem = class extends h("RuntimeUsageProblem")() {
 	constructor(input) {
 		super({
 			...input,
@@ -230,12 +589,12 @@ var RuntimeUsageProblem = class extends TaggedError("RuntimeUsageProblem")() {
 		});
 	}
 };
-var RuntimeBodyProblem = class extends TaggedError("RuntimeBodyProblem")() {
+var RuntimeBodyProblem = class extends h("RuntimeBodyProblem")() {
 	constructor(input) {
 		super(input);
 	}
 };
-var RuntimeMediaProblem = class extends TaggedError("RuntimeMediaProblem")() {
+var RuntimeMediaProblem = class extends h("RuntimeMediaProblem")() {
 	constructor(input) {
 		super(input);
 	}
@@ -262,19 +621,19 @@ const resolvePathTemplateResult = (template, values) => {
 			continue;
 		}
 		const value = values[name];
-		if (value === void 0) return Result.err(new RuntimeUsageProblem({
+		if (value === void 0) return G.err(new RuntimeUsageProblem({
 			kind: "missing_path_parameter",
 			paramName: name
 		}));
 		resolvedSegments.push(safePathSegment(value));
 	}
 	const resolvedPath = resolvedSegments.join("/");
-	if (!resolvedPath) return Result.ok(template.startsWith("/") ? "/" : "");
-	return Result.ok(`${template.startsWith("/") ? "/" : ""}${resolvedPath}`);
+	if (!resolvedPath) return G.ok(template.startsWith("/") ? "/" : "");
+	return G.ok(`${template.startsWith("/") ? "/" : ""}${resolvedPath}`);
 };
 const resolvePathTemplate = (template, values) => {
 	const resolved = resolvePathTemplateResult(template, values);
-	if (Result.isError(resolved)) throw new Error(resolved.error.message);
+	if (G.isError(resolved)) throw new Error(resolved.error.message);
 	return resolved.value;
 };
 const cliFlagNameFor$1 = (adapter, name) => adapter.cliFlagName?.(name) ?? flagName(name);
@@ -306,7 +665,7 @@ const validateMediaAttachmentsResult = (attachments, opts) => {
 	if (opts.rule === "post") {
 		const images = attachments.filter((attachment) => attachment.content_type.startsWith("image/")).length;
 		const others = attachments.length - images;
-		if (others > 0 && attachments.length > 1) return Result.err(new RuntimeMediaProblem({
+		if (others > 0 && attachments.length > 1) return G.err(new RuntimeMediaProblem({
 			kind: "post_attachment_mix",
 			imageCount: images,
 			otherCount: others,
@@ -314,13 +673,13 @@ const validateMediaAttachmentsResult = (attachments, opts) => {
 		}));
 	} else {
 		const total = attachments.reduce((sum, attachment) => sum + attachment.byteLength, 0);
-		if (total > 20 * 1024 * 1024) return Result.err(new RuntimeMediaProblem({
+		if (total > 20 * 1024 * 1024) return G.err(new RuntimeMediaProblem({
 			kind: "message_attachments_too_large",
 			totalBytes: total,
 			message: `LinkedIn message attachments cap at 20 MB combined; yours total ${(total / (1024 * 1024)).toFixed(1)} MB.`
 		}));
 	}
-	return Result.ok(attachments.map(({ content, content_type, filename }) => ({
+	return G.ok(attachments.map(({ content, content_type, filename }) => ({
 		content,
 		content_type,
 		filename
@@ -331,7 +690,7 @@ const mediaAttachmentsFrom = async (deps, paths, opts) => {
 	const attachments = [];
 	for (const path of paths) attachments.push(await deps.readMedia(path));
 	const validated = validateMediaAttachmentsResult(attachments, opts);
-	if (Result.isError(validated)) throw opts.usageError(validated.error.message);
+	if (G.isError(validated)) throw opts.usageError(validated.error.message);
 	return validated.value;
 };
 const trimTrailingNewline$1 = (value) => value.endsWith("\r\n") ? value.slice(0, -2) : value.endsWith("\n") ? value.slice(0, -1) : value;
@@ -340,9 +699,9 @@ const parseStdinBodyResult = (deps, bodyTextName, bodyTextKey, value) => {
 		JSON.parse(value);
 	} catch {
 		try {
-			return Result.ok({ [bodyTextKey]: deps.parseBodyText(`<${bodyTextName}>`, value) });
+			return G.ok({ [bodyTextKey]: deps.parseBodyText(`<${bodyTextName}>`, value) });
 		} catch (error) {
-			return Result.err(new RuntimeBodyProblem({
+			return G.err(new RuntimeBodyProblem({
 				kind: "body_parse_failed",
 				message: error instanceof Error ? error.message : "Could not parse stdin body text.",
 				cause: error
@@ -350,9 +709,9 @@ const parseStdinBodyResult = (deps, bodyTextName, bodyTextKey, value) => {
 		}
 	}
 	try {
-		return Result.ok(deps.parseJSONObject("stdin", value));
+		return G.ok(deps.parseJSONObject("stdin", value));
 	} catch (error) {
-		return Result.err(new RuntimeBodyProblem({
+		return G.err(new RuntimeBodyProblem({
 			kind: "body_parse_failed",
 			message: error instanceof Error ? error.message : "Could not parse stdin JSON body.",
 			cause: error
@@ -361,7 +720,7 @@ const parseStdinBodyResult = (deps, bodyTextName, bodyTextKey, value) => {
 };
 const parseStdinBody$2 = (deps, bodyTextName, bodyTextKey, value) => {
 	const parsed = parseStdinBodyResult(deps, bodyTextName, bodyTextKey, value);
-	if (Result.isError(parsed)) throw parsed.error.cause ?? parsed.error;
+	if (G.isError(parsed)) throw parsed.error.cause ?? parsed.error;
 	return parsed.value;
 };
 const hasStdinBodyText = (adapter, op) => op.config.bodyTextArg !== void 0 && adapter.bodyTextResolvesTarget?.(op) !== true;
@@ -449,16 +808,16 @@ const defaultArgAliases = (name) => new Set([name, flagName(name)]);
 const rejectUnsupportedRuntimeArgsResult = (adapter, op, args, allowedArgNames = Object.keys(buildRuntimeArgs(adapter, op))) => {
 	const allowed = new Set(["_"]);
 	for (const name of allowedArgNames) for (const alias of adapter.argAliases?.(name) ?? defaultArgAliases(name)) allowed.add(alias);
-	for (const [name, value] of Object.entries(args)) if (!allowed.has(name) && (adapter.ignoreUndefinedUnsupportedArgs !== true || value !== void 0)) return Result.err(new RuntimeUsageProblem({
+	for (const [name, value] of Object.entries(args)) if (!allowed.has(name) && (adapter.ignoreUndefinedUnsupportedArgs !== true || value !== void 0)) return G.err(new RuntimeUsageProblem({
 		kind: "unsupported_arg",
 		argName: name,
 		value
 	}));
-	return Result.ok();
+	return G.ok();
 };
 const rejectUnsupportedRuntimeArgs = (adapter, op, args, allowedArgNames = Object.keys(buildRuntimeArgs(adapter, op))) => {
 	const rejected = rejectUnsupportedRuntimeArgsResult(adapter, op, args, allowedArgNames);
-	if (Result.isError(rejected)) {
+	if (G.isError(rejected)) {
 		if (rejected.error.kind === "unsupported_arg" && rejected.error.argName !== void 0) throw adapter.unsupportedArgError(rejected.error.argName, rejected.error.value, op);
 		throw adapter.usageError(rejected.error.message);
 	}
@@ -535,8 +894,8 @@ const bodyRequiredPreparseProblem = (adapter, op) => new RuntimeBodyProblem({
 	message: op.config.bodyTextArg && Object.keys(op.config.bodyParams ?? {}).length === 0 ? `Pass <${bodyTextDisplayKeyFor(op) ?? op.config.bodyTextArg}>.` : "Pass required body positional arguments or --body."
 });
 const checkBodyRequiredResult = (adapter, op, args, bodyTextOptional) => {
-	if (!op.hasBody || adapter.checkBodyRequiredBeforeInput !== true) return Result.ok();
-	if (bodyTextOptional) return Result.ok();
+	if (!op.hasBody || adapter.checkBodyRequiredBeforeInput !== true) return G.ok();
+	if (bodyTextOptional) return G.ok();
 	const expressions = [];
 	const bodyTextArg = op.config.bodyTextArg;
 	if (bodyTextArg && op.config.bodyTextRequired !== false) expressions.push(args[bodyTextDisplayKeyFor(op) ?? bodyTextArg] === void 0);
@@ -544,25 +903,25 @@ const checkBodyRequiredResult = (adapter, op, args, bodyTextOptional) => {
 		const positionalValuePresent = param.positional && Array.isArray(args._) && args._.length > 0;
 		expressions.push(args[flagName(bodyParamArgFor(adapter, name, param))] === void 0 && !positionalValuePresent);
 	}
-	if (expressions.length > 0 && typeof args.body !== "string" && expressions.some(Boolean)) return Result.err(bodyRequiredPreparseProblem(adapter, op));
-	return Result.ok();
+	if (expressions.length > 0 && typeof args.body !== "string" && expressions.some(Boolean)) return G.err(bodyRequiredPreparseProblem(adapter, op));
+	return G.ok();
 };
 const throwRuntimeBodyProblem = (adapter, problem) => {
 	throw problem.cause ?? adapter.usageError(problem.message);
 };
 const checkBodyRequired = (adapter, op, args, bodyTextOptional) => {
 	const checked = checkBodyRequiredResult(adapter, op, args, bodyTextOptional);
-	if (Result.isError(checked)) throwRuntimeBodyProblem(adapter, checked.error);
+	if (G.isError(checked)) throwRuntimeBodyProblem(adapter, checked.error);
 };
 const buildBodyResult = (adapter, deps, op, input, bodyTextOptional) => {
 	const bodyTextArg = op.config.bodyTextArg;
 	const bodyParamEntries = Object.entries(op.config.bodyParams ?? {});
 	if (!bodyTextArg && bodyParamEntries.length === 0) {
-		if (input.body === void 0) return Result.ok(void 0);
+		if (input.body === void 0) return G.ok(void 0);
 		try {
-			return Result.ok(deps.parseJSONObject("--body", input.body));
+			return G.ok(deps.parseJSONObject("--body", input.body));
 		} catch (error) {
-			return Result.err(new RuntimeBodyProblem({
+			return G.err(new RuntimeBodyProblem({
 				kind: "body_parse_failed",
 				message: error instanceof Error ? error.message : "Could not parse --body JSON.",
 				cause: error
@@ -573,7 +932,7 @@ const buildBodyResult = (adapter, deps, op, input, bodyTextOptional) => {
 	if (input.body !== void 0) try {
 		bodyFromJSON = deps.parseJSONObject(hasStdinBodyText(adapter, op) ? "stdin" : "--body", input.body);
 	} catch (error) {
-		return Result.err(new RuntimeBodyProblem({
+		return G.err(new RuntimeBodyProblem({
 			kind: "body_parse_failed",
 			message: error instanceof Error ? error.message : "Could not parse request body JSON.",
 			cause: error
@@ -584,7 +943,7 @@ const buildBodyResult = (adapter, deps, op, input, bodyTextOptional) => {
 	if (bodyTextArg && input[bodyTextArg] !== void 0) try {
 		bodyText = deps.parseBodyText(`<${displayTextArg}>`, input[bodyTextArg]);
 	} catch (error) {
-		return Result.err(new RuntimeBodyProblem({
+		return G.err(new RuntimeBodyProblem({
 			kind: "body_parse_failed",
 			message: error instanceof Error ? error.message : "Could not parse body text.",
 			cause: error
@@ -597,7 +956,7 @@ const buildBodyResult = (adapter, deps, op, input, bodyTextOptional) => {
 		try {
 			bodyParamValues.set(name, value === void 0 ? param.default : param.kind === "array" ? deps.parseResourceIdList(displayName, Array.isArray(value) ? value : [value]) : deps.parseQueryString(displayName, value));
 		} catch (error) {
-			return Result.err(new RuntimeBodyProblem({
+			return G.err(new RuntimeBodyProblem({
 				kind: "body_parse_failed",
 				message: error instanceof Error ? error.message : `Could not parse ${displayName}.`,
 				cause: error
@@ -623,45 +982,45 @@ const buildBodyResult = (adapter, deps, op, input, bodyTextOptional) => {
 		input,
 		op
 	});
-	if (error) return Result.err(new RuntimeBodyProblem({
+	if (error) return G.err(new RuntimeBodyProblem({
 		kind: "body_validation_failed",
 		message: error.message,
 		cause: error
 	}));
-	return Result.ok(resolvedBody);
+	return G.ok(resolvedBody);
 };
 const buildBody = (adapter, deps, op, input, bodyTextOptional) => {
 	const built = buildBodyResult(adapter, deps, op, input, bodyTextOptional);
-	if (Result.isOk(built)) return built.value;
+	if (G.isOk(built)) return built.value;
 	throwRuntimeBodyProblem(adapter, built.error);
 };
 const resolveBodyTextFromStdinResult = async (adapter, op, deps, args, commandLabel, bodyTextOptional) => {
-	if (!hasStdinBodyText(adapter, op)) return Result.ok();
+	if (!hasStdinBodyText(adapter, op)) return G.ok();
 	const bodyTextArg = op.config.bodyTextArg;
-	if (bodyTextArg === void 0) return Result.ok();
+	if (bodyTextArg === void 0) return G.ok();
 	const displayTextArg = bodyTextDisplayKeyFor(op) ?? bodyTextArg;
 	const required = stdinBodyTextRequired(adapter, op) && !bodyTextOptional;
 	if (deps.isStdinTTY()) {
-		if (required) return Result.err(new RuntimeBodyProblem({
+		if (required) return G.err(new RuntimeBodyProblem({
 			kind: "stdin_body_required",
 			message: bodyTextPipeMessage(commandLabel)
 		}));
-		return Result.ok();
+		return G.ok();
 	}
 	const piped = trimTrailingNewline$1(await deps.readStdin());
 	if (piped.length > 0) {
 		const parsed = parseStdinBodyResult(deps, displayTextArg, bodyTextArg, piped);
-		if (Result.isError(parsed)) return Result.err(parsed.error);
+		if (G.isError(parsed)) return G.err(parsed.error);
 		args.body = JSON.stringify(parsed.value);
-	} else if (required) return Result.err(new RuntimeBodyProblem({
+	} else if (required) return G.err(new RuntimeBodyProblem({
 		kind: "stdin_body_required",
 		message: bodyTextPipeMessage(commandLabel)
 	}));
-	return Result.ok();
+	return G.ok();
 };
 const resolveBodyTextFromStdin = async (adapter, op, deps, args, commandLabel, bodyTextOptional) => {
 	const resolved = await resolveBodyTextFromStdinResult(adapter, op, deps, args, commandLabel, bodyTextOptional);
-	if (Result.isError(resolved)) throwRuntimeBodyProblem(adapter, resolved.error);
+	if (G.isError(resolved)) throwRuntimeBodyProblem(adapter, resolved.error);
 };
 const maximumItemsHintFor$2 = (adapter, op) => adapter.maximumItemsHintFor?.(op);
 const costFor = (adapter, op) => {
@@ -992,32 +1351,32 @@ const normalizeLiftedRow = (collection, row) => {
 	const columns = collectionColumns(collection);
 	const columnSet = new Set(columns);
 	const normalized = {};
-	for (const column of Object.keys(row)) if (!columnSet.has(column)) return Result.err({
+	for (const column of Object.keys(row)) if (!columnSet.has(column)) return G.err({
 		kind: "unsupportedValue",
 		column,
 		message: `${collection.key} produced unexpected column ${column}`
 	});
 	for (const column of columns) {
 		const value = row[column];
-		if (unsupportedRowValue(value)) return Result.err({
+		if (unsupportedRowValue(value)) return G.err({
 			kind: "unsupportedValue",
 			column,
 			message: `${collection.key} produced unsupported value for ${column}`
 		});
 		normalized[column] = value ?? null;
 	}
-	if (normalized.id === null || normalized.id === "") return Result.err({
+	if (normalized.id === null || normalized.id === "") return G.err({
 		kind: "missingId",
 		column: "id",
 		message: `${collection.key} row is missing id`
 	});
-	return Result.ok(normalized);
+	return G.ok(normalized);
 };
 const liftCollectionRow = (collection, item) => {
 	try {
 		return normalizeLiftedRow(collection, collection.lift(item));
 	} catch (error) {
-		return Result.err(normalizationErrorFrom(error));
+		return G.err(normalizationErrorFrom(error));
 	}
 };
 const withCollectionColumns = (collection) => ({
@@ -1828,7 +2187,7 @@ const metadataForPlatform = (platform) => {
 //#endregion
 //#region ../../packages/sqlsync/src/cursor.ts
 const PARTIAL_SYNC_CURSOR_PREFIX = "partial-sync-v1:";
-var CorruptPartialSyncCursor = class extends TaggedError("CorruptPartialSyncCursor")() {
+var CorruptPartialSyncCursor = class extends h("CorruptPartialSyncCursor")() {
 	constructor(args) {
 		super({
 			cursor: args.cursor,
@@ -1841,19 +2200,19 @@ const isRecord$12 = (value) => value !== null && typeof value === "object" && !A
 const validPartialSyncCursor = (value) => value.version === 1 && Number.isInteger(value.requestIndex) && typeof value.requestIndex === "number" && value.requestIndex >= 0 && typeof value.cursor === "string" && (typeof value.checkpoint === "string" || value.checkpoint === null) && (typeof value.newestId === "string" || value.newestId === null) && (typeof value.since === "number" || value.since === null) && (value.phase === void 0 || value.phase === "collection" || value.phase === "parent" || value.phase === "child") && (value.parentId === void 0 || typeof value.parentId === "string" || value.parentId === null);
 const encodePartialSyncCursor = (cursor) => `${PARTIAL_SYNC_CURSOR_PREFIX}${JSON.stringify(cursor)}`;
 const parsePartialSyncCursor = (value) => {
-	if (!value.startsWith("partial-sync-v1:")) return Result.err(new CorruptPartialSyncCursor({
+	if (!value.startsWith("partial-sync-v1:")) return G.err(new CorruptPartialSyncCursor({
 		cursor: value,
 		reason: "missing partial-sync-v1 prefix"
 	}));
 	try {
 		const parsed = JSON.parse(value.slice(16));
-		if (isRecord$12(parsed) && validPartialSyncCursor(parsed)) return Result.ok(parsed);
-		return Result.err(new CorruptPartialSyncCursor({
+		if (isRecord$12(parsed) && validPartialSyncCursor(parsed)) return G.ok(parsed);
+		return G.err(new CorruptPartialSyncCursor({
 			cursor: value,
 			reason: "payload does not match the partial cursor shape"
 		}));
 	} catch (error) {
-		return Result.err(new CorruptPartialSyncCursor({
+		return G.err(new CorruptPartialSyncCursor({
 			cursor: value,
 			reason: "payload is not valid JSON",
 			cause: error
@@ -1861,12 +2220,12 @@ const parsePartialSyncCursor = (value) => {
 	}
 };
 const readPartialSyncCursorResult = (value) => {
-	if (!value?.startsWith("partial-sync-v1:")) return Result.ok(void 0);
+	if (!value?.startsWith("partial-sync-v1:")) return G.ok(void 0);
 	return parsePartialSyncCursor(value);
 };
 const readPartialSyncCursor = (value) => {
 	const parsed = readPartialSyncCursorResult(value);
-	return Result.isError(parsed) ? void 0 : parsed.value;
+	return G.isError(parsed) ? void 0 : parsed.value;
 };
 const partialCursorMatchesSince = (cursor, since) => {
 	const requestedSince = since ?? null;
@@ -1931,7 +2290,7 @@ const readUserVersion = (db) => {
 const setUserVersion = (db, version) => {
 	db.exec(`PRAGMA user_version = ${version}`);
 };
-var MissingMigration = class extends TaggedError("MissingMigration")() {
+var MissingMigration = class extends h("MissingMigration")() {
 	constructor(index) {
 		super({
 			index,
@@ -1939,7 +2298,7 @@ var MissingMigration = class extends TaggedError("MissingMigration")() {
 		});
 	}
 };
-var StaleMigrationSchema = class extends TaggedError("StaleMigrationSchema")() {
+var StaleMigrationSchema = class extends h("StaleMigrationSchema")() {
 	constructor(currentVersion, finalVersion) {
 		super({
 			currentVersion,
@@ -1950,20 +2309,20 @@ var StaleMigrationSchema = class extends TaggedError("StaleMigrationSchema")() {
 };
 const migrateResult = (db) => {
 	const currentVersion = readUserVersion(db);
-	if (currentVersion >= MIGRATIONS.length) return Result.ok({
+	if (currentVersion >= MIGRATIONS.length) return G.ok({
 		fromVersion: currentVersion,
 		toVersion: currentVersion,
 		applied: 0
 	});
 	for (let index = currentVersion; index < MIGRATIONS.length; index += 1) {
 		const migration = MIGRATIONS[index];
-		if (!migration) return Result.err(new MissingMigration(index));
+		if (!migration) return G.err(new MissingMigration(index));
 		db.transaction(() => {
 			db.exec(migration.sql);
 			setUserVersion(db, index + 1);
 		});
 	}
-	return Result.ok({
+	return G.ok({
 		fromVersion: currentVersion,
 		toVersion: MIGRATIONS.length,
 		applied: MIGRATIONS.length - currentVersion
@@ -1972,8 +2331,8 @@ const migrateResult = (db) => {
 const migrate = (db) => migrateResult(db).unwrap();
 const assertAtLatestResult = (db) => {
 	const currentVersion = readUserVersion(db);
-	if (currentVersion < MIGRATIONS.length) return Result.err(new StaleMigrationSchema(currentVersion, MIGRATIONS.length));
-	return Result.ok(void 0);
+	if (currentVersion < MIGRATIONS.length) return G.err(new StaleMigrationSchema(currentVersion, MIGRATIONS.length));
+	return G.ok(void 0);
 };
 const assertAtLatest = (db) => {
 	assertAtLatestResult(db).unwrap();
@@ -2090,7 +2449,7 @@ const applyWriteThrough = (db, args) => {
 };
 //#endregion
 //#region ../../packages/sqlsync/src/cache.ts
-var UnknownCacheTable = class extends TaggedError("UnknownCacheTable")() {
+var UnknownCacheTable = class extends h("UnknownCacheTable")() {
 	constructor(args) {
 		super({
 			table: args.table,
@@ -2098,7 +2457,7 @@ var UnknownCacheTable = class extends TaggedError("UnknownCacheTable")() {
 		});
 	}
 };
-var ForbiddenCacheTableRead = class extends TaggedError("ForbiddenCacheTableRead")() {
+var ForbiddenCacheTableRead = class extends h("ForbiddenCacheTableRead")() {
 	constructor(args) {
 		const tables = [...args.tables].sort();
 		super({
@@ -2108,7 +2467,7 @@ var ForbiddenCacheTableRead = class extends TaggedError("ForbiddenCacheTableRead
 		});
 	}
 };
-var UnknownCachePlatform = class extends TaggedError("UnknownCachePlatform")() {
+var UnknownCachePlatform = class extends h("UnknownCachePlatform")() {
 	constructor(platform) {
 		super({
 			platform,
@@ -2121,40 +2480,40 @@ const resolveCachePath = (path) => path === ":memory:" ? path : resolve(path);
 const stringOrNull = (value) => typeof value === "string" ? value : null;
 const numberOrNull = (value) => typeof value === "number" ? value : null;
 const parseCachePlatform = (platform) => {
-	if (platform === "linkedin" || platform === "x") return Result.ok(platform);
-	return Result.err(new UnknownCachePlatform(platform));
+	if (platform === "linkedin" || platform === "x") return G.ok(platform);
+	return G.err(new UnknownCachePlatform(platform));
 };
 const requireCachePlatform = (platform) => {
 	const parsed = parseCachePlatform(platform);
-	if (Result.isError(parsed)) throw parsed.error;
+	if (G.isError(parsed)) throw parsed.error;
 	return parsed.value;
 };
 const parseCacheTable = (table) => {
-	if (!cacheTableNames.has(table)) return Result.err(new UnknownCacheTable({ table }));
-	return Result.ok(table);
+	if (!cacheTableNames.has(table)) return G.err(new UnknownCacheTable({ table }));
+	return G.ok(table);
 };
 const requireCacheTable = (table) => {
 	const parsed = parseCacheTable(table);
-	if (Result.isError(parsed)) throw parsed.error;
+	if (G.isError(parsed)) throw parsed.error;
 	return parsed.value;
 };
 const checkPlatformQuery = (sql, platform) => {
 	const allowedTables = tablesForPlatform(platform);
 	const rejectedTables = new Set(knownTableTokens(sql).filter((table) => !allowedTables.has(table)));
-	if (rejectedTables.size > 0) return Result.err(new ForbiddenCacheTableRead({
+	if (rejectedTables.size > 0) return G.err(new ForbiddenCacheTableRead({
 		platform,
 		tables: rejectedTables
 	}));
-	return Result.ok();
+	return G.ok();
 };
 const assertPlatformQuery = (sql, platform) => {
 	const checked = checkPlatformQuery(sql, platform);
-	if (Result.isError(checked)) throw checked.error;
+	if (G.isError(checked)) throw checked.error;
 };
 const classifyCacheRead = (sql, platform) => {
 	const checked = checkPlatformQuery(sql, platform);
-	if (Result.isError(checked)) return Result.err(checked.error);
-	return Result.ok({ tables: referencedTablesForRead(sql, platform) });
+	if (G.isError(checked)) return G.err(checked.error);
+	return G.ok({ tables: referencedTablesForRead(sql, platform) });
 };
 const unknownTableFromSQLiteError = (error) => {
 	return (error instanceof Error ? error.message : String(error)).match(/\bno such table: ([^\s]+)/)?.[1]?.replace(/^["'`]|["'`]$/g, "");
@@ -2299,7 +2658,7 @@ const createCache = (path, db) => ({
 	},
 	read: (sql, opts) => {
 		const classification = classifyCacheRead(sql, opts.platform);
-		if (Result.isError(classification)) return Result.err(classification.error);
+		if (G.isError(classification)) return G.err(classification.error);
 		const tables = classification.value.tables.map((name) => {
 			return {
 				name,
@@ -2311,10 +2670,10 @@ const createCache = (path, db) => ({
 			rows = db.prepare(sql).all();
 		} catch (error) {
 			const table = unknownTableFromSQLiteError(error);
-			if (table) return Result.err(new UnknownCacheTable({ table }));
+			if (table) return G.err(new UnknownCacheTable({ table }));
 			throw error;
 		}
-		return Result.ok({
+		return G.ok({
 			rows,
 			tables
 		});
@@ -7095,7 +7454,7 @@ const planPagePersistence = (state, page, opts) => {
 const profileTableFor = (platform) => platform === "x" ? "x_profiles_raw" : "li_profiles_raw";
 //#endregion
 //#region ../../packages/sqlsync/src/sync-plan.ts
-var SinceUnsupported = class extends TaggedError("SinceUnsupported")() {
+var SinceUnsupported = class extends h("SinceUnsupported")() {
 	constructor(collectionKey) {
 		super({
 			collectionKey,
@@ -7103,7 +7462,7 @@ var SinceUnsupported = class extends TaggedError("SinceUnsupported")() {
 		});
 	}
 };
-var FullInitialSyncRequired = class extends TaggedError("FullInitialSyncRequired")() {
+var FullInitialSyncRequired = class extends h("FullInitialSyncRequired")() {
 	constructor(collectionKey) {
 		super({
 			collectionKey,
@@ -7111,7 +7470,7 @@ var FullInitialSyncRequired = class extends TaggedError("FullInitialSyncRequired
 		});
 	}
 };
-var MissingParentCollection = class extends TaggedError("MissingParentCollection")() {
+var MissingParentCollection = class extends h("MissingParentCollection")() {
 	constructor(collectionKey, parentCollectionKey) {
 		super({
 			collectionKey,
@@ -7120,7 +7479,7 @@ var MissingParentCollection = class extends TaggedError("MissingParentCollection
 		});
 	}
 };
-var InvalidPartialCursor = class extends TaggedError("InvalidPartialCursor")() {
+var InvalidPartialCursor = class extends h("InvalidPartialCursor")() {
 	constructor(collectionKey, cursor, cause) {
 		super({
 			collectionKey,
@@ -7132,19 +7491,19 @@ var InvalidPartialCursor = class extends TaggedError("InvalidPartialCursor")() {
 };
 const parseStoredPartialCursor = (collectionKey, cursor) => {
 	const parsed = readPartialSyncCursorResult(cursor);
-	if (Result.isError(parsed)) return Result.err(new InvalidPartialCursor(collectionKey, cursor ?? "", parsed.error));
-	return Result.ok(parsed.value);
+	if (G.isError(parsed)) return G.err(new InvalidPartialCursor(collectionKey, cursor ?? "", parsed.error));
+	return G.ok(parsed.value);
 };
 const validateSyncOptions = (deps, opts) => {
 	const { collection } = opts;
-	if (opts.since != null && collection.sinceField === void 0) return Result.err(new SinceUnsupported(collection.key));
+	if (opts.since != null && collection.sinceField === void 0) return G.err(new SinceUnsupported(collection.key));
 	const storedState = deps.cache.getCursor(collection.key);
 	const storedPartialCursor = parseStoredPartialCursor(collection.key, storedState?.cursor);
-	if (Result.isError(storedPartialCursor)) return Result.err(storedPartialCursor.error);
-	if (opts.since != null && collection.requiresFullInitialSync && (storedState?.lastSynced == null || storedPartialCursor.value !== void 0)) return Result.err(new FullInitialSyncRequired(collection.key));
+	if (G.isError(storedPartialCursor)) return G.err(storedPartialCursor.error);
+	if (opts.since != null && collection.requiresFullInitialSync && (storedState?.lastSynced == null || storedPartialCursor.value !== void 0)) return G.err(new FullInitialSyncRequired(collection.key));
 	const parentCollection = collection.parentCollection === void 0 ? void 0 : collectionByKey(collection.parentCollection);
-	if (collection.parentCollection && !parentCollection) return Result.err(new MissingParentCollection(collection.key, collection.parentCollection));
-	return Result.ok({
+	if (collection.parentCollection && !parentCollection) return G.err(new MissingParentCollection(collection.key, collection.parentCollection));
+	return G.ok({
 		collection,
 		since: opts.since,
 		storedState,
@@ -7178,7 +7537,7 @@ const planCompletedCollectionCursor = (args) => ({
 //#region ../../packages/sqlsync/src/sync.ts
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 const pageDelayFor = (pageDelayMs, pagesCompleted) => typeof pageDelayMs === "function" ? pageDelayMs(pagesCompleted) : pageDelayMs;
-var UnsupportedSinceCollection = class extends TaggedError("UnsupportedSinceCollection")() {
+var UnsupportedSinceCollection = class extends h("UnsupportedSinceCollection")() {
 	constructor(collectionKey) {
 		super({
 			collectionKey,
@@ -7186,7 +7545,7 @@ var UnsupportedSinceCollection = class extends TaggedError("UnsupportedSinceColl
 		});
 	}
 };
-var InitialSyncRequired = class extends TaggedError("InitialSyncRequired")() {
+var InitialSyncRequired = class extends h("InitialSyncRequired")() {
 	constructor(collectionKey) {
 		super({
 			collectionKey,
@@ -7343,7 +7702,7 @@ const walkRequest = async (args) => {
 			break;
 		} catch (error) {
 			if (await waitForRateLimit(error)) continue;
-			return Result.err(pageError({
+			return G.err(pageError({
 				...pageContext,
 				cursorPersisted: persistPartialCursor() || partialCursorPersisted || void 0
 			}, error));
@@ -7354,7 +7713,7 @@ const walkRequest = async (args) => {
 		try {
 			json = await response.json();
 		} catch (error) {
-			return Result.err(pageError({
+			return G.err(pageError({
 				...pageContext,
 				creditsSpent: args.credits.spent
 			}, error));
@@ -7395,7 +7754,7 @@ const walkRequest = async (args) => {
 			break;
 		}
 	}
-	return Result.ok({
+	return G.ok({
 		ids,
 		newestId: state.newestId,
 		pages,
@@ -7419,10 +7778,10 @@ const parentIdsFromCache = (deps, collection, since) => {
 };
 const runSync = async (deps, opts) => {
 	const syncPlan = validateSyncOptions(deps, opts);
-	if (Result.isError(syncPlan)) {
-		if (syncPlan.error instanceof SinceUnsupported) return Result.err(new UnsupportedSinceCollection(syncPlan.error.collectionKey));
-		if (syncPlan.error instanceof FullInitialSyncRequired) return Result.err(new InitialSyncRequired(syncPlan.error.collectionKey));
-		return Result.err(syncPlan.error);
+	if (G.isError(syncPlan)) {
+		if (syncPlan.error instanceof SinceUnsupported) return G.err(new UnsupportedSinceCollection(syncPlan.error.collectionKey));
+		if (syncPlan.error instanceof FullInitialSyncRequired) return G.err(new InitialSyncRequired(syncPlan.error.collectionKey));
+		return G.err(syncPlan.error);
 	}
 	const { collection, parentCollection, storedPartialCursor } = syncPlan.value;
 	const credits = { spent: 0 };
@@ -7447,7 +7806,7 @@ const runSync = async (deps, opts) => {
 		deps.cache.setCursor(pending.collection, pending.cursor, pending.objectCount, pending.lastSynced);
 	};
 	if (collection.parentCollection) {
-		if (!parentCollection) return Result.err(new MissingParentCollection(collection.key, collection.parentCollection));
+		if (!parentCollection) return G.err(new MissingParentCollection(collection.key, collection.parentCollection));
 		let activePartialCursor = activeParentedPartialCursor({
 			storedPartialCursor,
 			since: opts.since
@@ -7487,7 +7846,7 @@ const runSync = async (deps, opts) => {
 					onPage: opts.onPage,
 					onProgress: opts.onProgress
 				});
-				if (Result.isError(result)) return Result.err(result.error);
+				if (G.isError(result)) return G.err(result.error);
 				addResult(result.value);
 				parentIds.push(...result.value.ids);
 				if (parentPersistsCheckpoint) parentCheckpoint = singleRequestCheckpoint({
@@ -7534,7 +7893,7 @@ const runSync = async (deps, opts) => {
 					onPage: opts.onPage,
 					onProgress: opts.onProgress
 				});
-				if (Result.isError(result)) return Result.err(result.error);
+				if (G.isError(result)) return G.err(result.error);
 				addResult(result.value);
 				if (activePartialCursor?.phase === "child" && activePartialCursor.parentId === parentId) activePartialCursor = void 0;
 			}
@@ -7572,7 +7931,7 @@ const runSync = async (deps, opts) => {
 				onPage: opts.onPage,
 				onProgress: opts.onProgress
 			});
-			if (Result.isError(result)) return Result.err(result.error);
+			if (G.isError(result)) return G.err(result.error);
 			addResult(result.value);
 			if (!preservesBroaderPartialOnSince(activePartialCursor, opts.since, result.value.stoppedReason) && useCheckpoint) pendingCursors.push(singleRequestCheckpoint({
 				collection,
@@ -7585,7 +7944,7 @@ const runSync = async (deps, opts) => {
 		})));
 	}
 	for (const pending of pendingCursors) writePendingCursor(pending);
-	return Result.ok({
+	return G.ok({
 		collection: collection.key,
 		objectsUpserted: upserted,
 		pages,
@@ -7844,7 +8203,7 @@ async function resolvePlugins(plugins) {
 function defineCommand(def) {
 	return def;
 }
-async function runCommand$1(cmd, opts) {
+async function runCommand(cmd, opts) {
 	const cmdArgs = await resolveValue$1(cmd.args || {});
 	const parsedArgs = parseArgs$1(opts.rawArgs, cmdArgs);
 	const context = {
@@ -7866,14 +8225,14 @@ async function runCommand$1(cmd, opts) {
 			if (explicitName) {
 				const subCommand = await _findSubCommand(subCommands, explicitName);
 				if (!subCommand) throw new CLIError(`Unknown command ${cyan(explicitName)}`, "E_UNKNOWN_COMMAND");
-				await runCommand$1(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
+				await runCommand(subCommand, { rawArgs: opts.rawArgs.slice(subCommandArgIndex + 1) });
 			} else {
 				const defaultSubCommand = await resolveValue$1(cmd.default);
 				if (defaultSubCommand) {
 					if (cmd.run) throw new CLIError(`Cannot specify both 'run' and 'default' on the same command.`, "E_DEFAULT_CONFLICT");
 					const subCommand = await _findSubCommand(subCommands, defaultSubCommand);
 					if (!subCommand) throw new CLIError(`Default sub command ${cyan(defaultSubCommand)} not found in subCommands.`, "E_UNKNOWN_COMMAND");
-					await runCommand$1(subCommand, { rawArgs: opts.rawArgs });
+					await runCommand(subCommand, { rawArgs: opts.rawArgs });
 				} else if (!cmd.run) throw new CLIError(`No command specified.`, "E_NO_COMMAND");
 			}
 		}
@@ -8012,14 +8371,14 @@ function renderDescription(arg, required) {
 }
 //#endregion
 //#region ../../packages/billing/src/pricing.ts
-var UnknownPricingCategory = class extends TaggedError("pricing_category_unknown")() {};
+var UnknownPricingCategory = class extends h("pricing_category_unknown")() {};
 const lookupCostBPSForCategoryResult = (table, category) => {
 	const costBPS = table.get(category);
-	if (costBPS === void 0) return Result.err(new UnknownPricingCategory({
+	if (costBPS === void 0) return G.err(new UnknownPricingCategory({
 		category,
 		message: `Unknown pricing category: ${category}`
 	}));
-	return Result.ok(costBPS);
+	return G.ok(costBPS);
 };
 const createPricing = (resources) => {
 	const table = new Map(resources.map((resource) => [resource.key, Math.round(resource.unitPriceUSD * 1e4)]));
@@ -10500,8 +10859,8 @@ _enum(FEEDBACK_TYPES);
 _enum(WRAPPED_STATUSES);
 string().trim().min(1).transform((email) => email.toLowerCase()).brand();
 union([number(), string().trim().min(1)]).transform((value) => Number(value)).pipe(number().int().nonnegative()).brand();
-TaggedError("InvalidBillingOverrideEmail")();
-TaggedError("InvalidNonnegativeAllowance")();
+h("InvalidBillingOverrideEmail")();
+h("InvalidNonnegativeAllowance")();
 const sqlStringLiteral = (value) => `'${value.replaceAll("'", "''")}'`;
 const sqlStringList = (values) => sql.raw(values.map(sqlStringLiteral).join(", "));
 const sqlCheckIn = (column, values) => sql`${column} in (${sqlStringList(values)})`;
@@ -10711,8 +11070,8 @@ pgTable("linkedin_connections", {
 	connectedAt: timestamptz("connected_at"),
 	createdAt: timestamptz("created_at").notNull().defaultNow()
 }, (table) => [uniqueIndex("linkedin_connections_of_profile_key").on(table.ofProfileId, table.profileId), index("linkedin_connections_profile_idx").on(table.profileId)]);
-TaggedError("ProfileStoreUnavailable")();
-TaggedError("InvalidProfileRow")();
+h("ProfileStoreUnavailable")();
+h("InvalidProfileRow")();
 //#endregion
 //#region ../../packages/lib/src/url.ts
 const stripTrailingSlashes = (value) => value.replace(/\/+$/, "");
@@ -10723,7 +11082,7 @@ const absoluteURLPathPattern = /^[a-z][a-z0-9+.-]*:/i;
 const protocolRelativeURLPathPattern = /^\/\//;
 const unsafeRelativeURLPathMessage = "createURL: path must be relative, not absolute or protocol-relative";
 /** Returned when a URL path is absolute or protocol-relative instead of relative. */
-var InvalidRelativeURLPath = class extends TaggedError("InvalidRelativeURLPath")() {
+var InvalidRelativeURLPath = class extends h("InvalidRelativeURLPath")() {
 	constructor({ path }) {
 		super({
 			path,
@@ -10731,7 +11090,7 @@ var InvalidRelativeURLPath = class extends TaggedError("InvalidRelativeURLPath")
 		});
 	}
 };
-var InvalidBaseURL = class extends TaggedError("InvalidBaseURL")() {
+var InvalidBaseURL = class extends h("InvalidBaseURL")() {
 	constructor({ baseURL }) {
 		super({
 			baseURL,
@@ -10742,25 +11101,25 @@ var InvalidBaseURL = class extends TaggedError("InvalidBaseURL")() {
 /** Parse a path that is safe to resolve against a caller-provided base URL. */
 const parseRelativeURLPath = (path) => {
 	const trimmedPath = path.trimStart();
-	if (absoluteURLPathPattern.test(trimmedPath) || protocolRelativeURLPathPattern.test(trimmedPath)) return Result.err(new InvalidRelativeURLPath({ path }));
-	return Result.ok(stripLeadingSlashes(path));
+	if (absoluteURLPathPattern.test(trimmedPath) || protocolRelativeURLPathPattern.test(trimmedPath)) return G.err(new InvalidRelativeURLPath({ path }));
+	return G.ok(stripLeadingSlashes(path));
 };
 const createURLResult = (baseURL, path) => {
 	const parsedPath = parseRelativeURLPath(path);
-	if (Result.isError(parsedPath)) return Result.err(parsedPath.error);
+	if (G.isError(parsedPath)) return G.err(parsedPath.error);
 	try {
-		return Result.ok(new URL(parsedPath.value, ensureTrailingSlash(stripTrailingSlashes(baseURL.toString()))));
+		return G.ok(new URL(parsedPath.value, ensureTrailingSlash(stripTrailingSlashes(baseURL.toString()))));
 	} catch {
-		return Result.err(new InvalidBaseURL({ baseURL: baseURL.toString() }));
+		return G.err(new InvalidBaseURL({ baseURL: baseURL.toString() }));
 	}
 };
 const createURL = (baseURL, path) => {
 	const url = createURLResult(baseURL, path);
-	if (Result.isError(url)) throw url.error;
+	if (G.isError(url)) throw url.error;
 	return url.value;
 };
 const createAbsoluteURL = (baseURL, path) => createURL(baseURL, path).toString();
-TaggedError("MissingPathTemplateParam")();
+h("MissingPathTemplateParam")();
 //#endregion
 //#region ../../node_modules/.bun/ky@2.0.2/node_modules/ky/distribution/errors/KyError.js
 /**
@@ -12047,8 +12406,8 @@ object({
 	status: number(),
 	type: string()
 });
-TaggedError("UnipileAPIError")();
-TaggedError("UnipileHostedAuthURLMissingError")();
+h("UnipileAPIError")();
+h("UnipileHostedAuthURLMissingError")();
 looseObject({
 	object: literal("HostedAuthLink"),
 	link: string()
@@ -12084,7 +12443,7 @@ const SocialTargetPrefixes = {
 	company_id: "company",
 	request_id: "request"
 };
-var InvalidSocialSelector = class extends TaggedError("InvalidSocialSelector")() {
+var InvalidSocialSelector = class extends h("InvalidSocialSelector")() {
 	constructor({ value, reason }) {
 		super({
 			value,
@@ -12145,42 +12504,42 @@ const linkedInURNKindFrom = (value) => {
 };
 const parseTypedSocialSelector = (value, options = {}) => {
 	const parsed = parseTypedSocialSelectorResult(value, options);
-	return Result.isOk(parsed) ? parsed.value : void 0;
+	return G.isOk(parsed) ? parsed.value : void 0;
 };
 const parseTypedSocialSelectorResult = (value, options = {}) => {
 	const trimmed = value.trim();
 	const colon = trimmed.indexOf(":");
-	if (colon <= 0) return Result.err(new InvalidSocialSelector({
+	if (colon <= 0) return G.err(new InvalidSocialSelector({
 		value,
 		reason: "missing-prefix"
 	}));
 	const prefix = trimmed.slice(0, colon);
-	if (!isSocialTargetPrefix(prefix)) return Result.err(new InvalidSocialSelector({
+	if (!isSocialTargetPrefix(prefix)) return G.err(new InvalidSocialSelector({
 		value,
 		reason: "unsupported-prefix"
 	}));
-	if (options.prefixes && !options.prefixes.includes(prefix)) return Result.err(new InvalidSocialSelector({
+	if (options.prefixes && !options.prefixes.includes(prefix)) return G.err(new InvalidSocialSelector({
 		value,
 		reason: "disallowed-prefix"
 	}));
 	const id = trimmed.slice(colon + 1).trim();
-	if (options.idMode === "lenient") return Result.ok({
+	if (options.idMode === "lenient") return G.ok({
 		prefix,
 		kind: SocialTargetPrefixes[prefix],
 		id
 	});
 	const parsed = plainResourceIdSchema(prefix).safeParse(id);
-	return parsed.success ? Result.ok({
+	return parsed.success ? G.ok({
 		prefix,
 		kind: SocialTargetPrefixes[prefix],
 		id: parsed.data
-	}) : Result.err(new InvalidSocialSelector({
+	}) : G.err(new InvalidSocialSelector({
 		value,
 		reason: "invalid-id"
 	}));
 };
-TaggedError("InvalidLinkedinUpstreamPlanInput")();
-TaggedError("InvalidUnipileCredentials")();
+h("InvalidLinkedinUpstreamPlanInput")();
+h("InvalidUnipileCredentials")();
 //#endregion
 //#region ../../packages/linkedin/src/profiles.ts
 const displayNameFrom = (firstName, lastName, username) => [firstName, lastName].filter(Boolean).join(" ").trim() || username || "";
@@ -12299,8 +12658,8 @@ looseObject({
 	data: array(GroupParticipant),
 	next_cursor: string().nullish()
 });
-TaggedError("ChatListParseError")();
-TaggedError("ChatParticipantsFetchError")();
+h("ChatListParseError")();
+h("ChatParticipantsFetchError")();
 const linkedinProfileExtractors = {
 	"GET /users/me": extractProfile$1,
 	"GET /users/:identifier": extractProfile$1,
@@ -14268,7 +14627,7 @@ const isoDatePattern = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
 const isoDateTimePattern = /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])T([01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d{1,3})?)?(?:Z|[+-]([01]\d|2[0-3]):[0-5]\d)?$/;
 const timezonePattern = /(Z|[+-]\d{2}:\d{2})$/;
 const invalidSinceMessage = "Invalid --since value. Use an ISO 8601 date like 2026-05-04 or datetime like 2026-05-04T00:00:00Z.";
-var InvalidSince = class extends TaggedError("InvalidSince")() {
+var InvalidSince = class extends h("InvalidSince")() {
 	constructor(input) {
 		super({
 			input,
@@ -14296,23 +14655,23 @@ const parseSinceResult = (input) => {
 	const isISODateTime = isoDateTimePattern.test(value);
 	const normalized = isISODateTime && !timezonePattern.test(value) ? `${value}Z` : value;
 	const parsed = (isISODate || isISODateTime) && hasValidDate(value) ? Date.parse(normalized) : NaN;
-	if (Number.isNaN(parsed)) return Result.err(new InvalidSince(input));
-	return Result.ok(parsed);
+	if (Number.isNaN(parsed)) return G.err(new InvalidSince(input));
+	return G.ok(parsed);
 };
 //#endregion
 //#region ../../packages/linkedin/src/cli/sync-plan.ts
-var UnknownLinkedinSyncCollection = class extends TaggedError("UnknownLinkedinSyncCollection")() {};
-var LinkedinSyncResetRequiresCollection = class extends TaggedError("LinkedinSyncResetRequiresCollection")() {
+var UnknownLinkedinSyncCollection = class extends h("UnknownLinkedinSyncCollection")() {};
+var LinkedinSyncResetRequiresCollection = class extends h("LinkedinSyncResetRequiresCollection")() {
 	constructor() {
 		super({ message: "--reset requires a collection" });
 	}
 };
-var LinkedinSyncResetWithSince = class extends TaggedError("LinkedinSyncResetWithSince")() {
+var LinkedinSyncResetWithSince = class extends h("LinkedinSyncResetWithSince")() {
 	constructor() {
 		super({ message: "--reset cannot be combined with --since" });
 	}
 };
-var LinkedinSyncUnsupportedSince = class extends TaggedError("LinkedinSyncUnsupportedSince")() {
+var LinkedinSyncUnsupportedSince = class extends h("LinkedinSyncUnsupportedSince")() {
 	constructor(collection) {
 		super({
 			collection,
@@ -14320,7 +14679,7 @@ var LinkedinSyncUnsupportedSince = class extends TaggedError("LinkedinSyncUnsupp
 		});
 	}
 };
-var LinkedinSyncMissingInitialFullSync = class extends TaggedError("LinkedinSyncMissingInitialFullSync")() {
+var LinkedinSyncMissingInitialFullSync = class extends h("LinkedinSyncMissingInitialFullSync")() {
 	constructor(collection) {
 		super({
 			collection,
@@ -14328,36 +14687,36 @@ var LinkedinSyncMissingInitialFullSync = class extends TaggedError("LinkedinSync
 		});
 	}
 };
-var InvalidLinkedinSyncSince = class extends TaggedError("InvalidLinkedinSyncSince")() {};
+var InvalidLinkedinSyncSince = class extends h("InvalidLinkedinSyncSince")() {};
 const linkedinSyncCollectionShortName = (collection) => collection.key.replace(/^(x|li)_/, "");
 const linkedinSyncCollectionFor = (collections, collection) => {
 	const found = collections.find((candidate) => linkedinSyncCollectionShortName(candidate) === collection || candidate.key === collection);
-	if (found) return Result.ok(found);
+	if (found) return G.ok(found);
 	const available = collections.map(linkedinSyncCollectionShortName);
-	return Result.err(new UnknownLinkedinSyncCollection({
+	return G.err(new UnknownLinkedinSyncCollection({
 		collection,
 		available,
 		message: `Unknown collection "${collection}". Available: ${available.join(", ")}`
 	}));
 };
 const planLinkedinSyncCommand = ({ args, collections, cursorState }) => {
-	if (!args.collection) return args.reset === true ? Result.err(new LinkedinSyncResetRequiresCollection()) : Result.ok({ mode: "list" });
+	if (!args.collection) return args.reset === true ? G.err(new LinkedinSyncResetRequiresCollection()) : G.ok({ mode: "list" });
 	const collection = linkedinSyncCollectionFor(collections, String(args.collection));
-	if (Result.isError(collection)) return Result.err(collection.error);
-	if (args.reset === true) return args.since == null ? Result.ok({
+	if (G.isError(collection)) return G.err(collection.error);
+	if (args.reset === true) return args.since == null ? G.ok({
 		mode: "reset",
 		collection: collection.value
-	}) : Result.err(new LinkedinSyncResetWithSince());
-	if (args.since == null) return Result.ok({
+	}) : G.err(new LinkedinSyncResetWithSince());
+	if (args.since == null) return G.ok({
 		mode: "run",
 		collection: collection.value
 	});
 	const shortName = linkedinSyncCollectionShortName(collection.value);
-	if (!collection.value.sinceField) return Result.err(new LinkedinSyncUnsupportedSince(shortName));
-	if (collection.value.requiresFullInitialSync && cursorState?.lastSynced == null) return Result.err(new LinkedinSyncMissingInitialFullSync(shortName));
+	if (!collection.value.sinceField) return G.err(new LinkedinSyncUnsupportedSince(shortName));
+	if (collection.value.requiresFullInitialSync && cursorState?.lastSynced == null) return G.err(new LinkedinSyncMissingInitialFullSync(shortName));
 	const parsedSince = parseSinceResult(String(args.since));
-	if (Result.isError(parsedSince)) return Result.err(new InvalidLinkedinSyncSince({ message: parsedSince.error.message }));
-	return Result.ok({
+	if (G.isError(parsedSince)) return G.err(new InvalidLinkedinSyncSince({ message: parsedSince.error.message }));
+	return G.ok({
 		mode: "run",
 		collection: collection.value,
 		since: parsedSince.value
@@ -14787,7 +15146,7 @@ const buildSync$1 = (deps, platform) => defineCommand({
 				}
 			})() : void 0
 		});
-		if (Result.isError(plan)) throw new UsageError(plan.error.message);
+		if (G.isError(plan)) throw new UsageError(plan.error.message);
 		if (plan.value.mode === "list") {
 			const cache = openLinkedinCache({
 				platform,
@@ -14864,7 +15223,7 @@ const buildSync$1 = (deps, platform) => defineCommand({
 				if (rateLimitError) throw rateLimitError;
 				throw error;
 			}
-			if (Result.isError(result)) {
+			if (G.isError(result)) {
 				progress.error();
 				const rateLimitError = enrichRateLimitSyncError$1({
 					error: result.error,
@@ -14973,7 +15332,7 @@ const buildSql$1 = (deps, platform) => defineCommand({
 			} catch (error) {
 				throw new UsageError(`Query failed (cache is read-only): ${error instanceof Error ? error.message : String(error)}`);
 			}
-			if (Result.isError(result)) throw new UsageError(`Query failed (cache is read-only): ${result.error.message}`);
+			if (G.isError(result)) throw new UsageError(`Query failed (cache is read-only): ${result.error.message}`);
 			await deps.printResult({
 				account: res.account,
 				contract,
@@ -19015,7 +19374,7 @@ const contractFor$1 = (op, commandName, group) => buildRuntimeContract(xRuntimeA
 const defineOperationCommand = (op, deps) => defineRuntimeOperationCommand(xRuntimeAdapter, op, deps);
 //#endregion
 //#region ../../packages/x/src/cli/sync-plan.ts
-var XSyncPlanError = class extends TaggedError("XSyncPlanError")() {
+var XSyncPlanError = class extends h("XSyncPlanError")() {
 	constructor(args) {
 		super(args);
 		this.name = "XSyncPlanError";
@@ -19024,30 +19383,30 @@ var XSyncPlanError = class extends TaggedError("XSyncPlanError")() {
 const shortSyncCollectionName = (collection) => collection.key.replace(/^(x|li)_/, "");
 const findSyncCollection = (collections, input) => collections.find((collection) => shortSyncCollectionName(collection) === input || collection.key === input);
 const parseTimeoutSeconds = (value) => {
-	if (value == null) return Result.ok(void 0);
+	if (value == null) return G.ok(void 0);
 	const timeoutSeconds = Number(value);
-	if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 1) return Result.err(new XSyncPlanError({
+	if (!Number.isInteger(timeoutSeconds) || timeoutSeconds < 1) return G.err(new XSyncPlanError({
 		kind: "invalid-timeout",
 		message: "--timeout must be at least 1."
 	}));
-	return Result.ok(timeoutSeconds);
+	return G.ok(timeoutSeconds);
 };
 const planXSync = (input) => {
 	const accountSelector = input.accountSelector;
-	if (accountSelector === void 0 || accountSelector.length === 0) return Result.err(new XSyncPlanError({
+	if (accountSelector === void 0 || accountSelector.length === 0) return G.err(new XSyncPlanError({
 		kind: "missing-account-selector",
 		message: "Selected X account is missing an account selector."
 	}));
 	const timeout = parseTimeoutSeconds(input.timeout);
-	if (Result.isError(timeout)) return Result.err(timeout.error);
+	if (G.isError(timeout)) return G.err(timeout.error);
 	const accountHeaders = { "x-social-account-id": accountSelector };
 	const collectionInput = typeof input.collection === "string" && input.collection.length > 0 ? input.collection : void 0;
 	if (collectionInput === void 0) {
-		if (input.reset === true) return Result.err(new XSyncPlanError({
+		if (input.reset === true) return G.err(new XSyncPlanError({
 			kind: "reset-without-collection",
 			message: "--reset requires a collection"
 		}));
-		return Result.ok({
+		return G.ok({
 			kind: "list",
 			accountHeaders,
 			accountSelector,
@@ -19055,19 +19414,19 @@ const planXSync = (input) => {
 		});
 	}
 	const collection = findSyncCollection(input.collections, collectionInput);
-	if (collection === void 0) return Result.err(new XSyncPlanError({
+	if (collection === void 0) return G.err(new XSyncPlanError({
 		kind: "unknown-collection",
 		collection: collectionInput,
 		message: `Unknown collection "${collectionInput}". Available: ${input.collections.map(shortSyncCollectionName).join(", ")}`
 	}));
 	if (input.reset === true) {
-		if (input.since != null) return Result.err(new XSyncPlanError({
+		if (input.since != null) return G.err(new XSyncPlanError({
 			kind: "reset-with-since",
 			collection: collection.key,
 			message: "--reset cannot be combined with --since"
 		}));
 		const resetCollections = resetTablesFor(collection);
-		return Result.ok({
+		return G.ok({
 			kind: "reset",
 			accountHeaders,
 			accountSelector,
@@ -19078,20 +19437,20 @@ const planXSync = (input) => {
 	}
 	let since;
 	if (input.since != null) {
-		if (!collection.sinceField) return Result.err(new XSyncPlanError({
+		if (!collection.sinceField) return G.err(new XSyncPlanError({
 			kind: "since-unsupported",
 			collection: collection.key,
 			message: `${shortSyncCollectionName(collection)} does not support --since`
 		}));
 		const parsedSince = parseSinceResult(String(input.since));
-		if (Result.isError(parsedSince)) return Result.err(new XSyncPlanError({
+		if (G.isError(parsedSince)) return G.err(new XSyncPlanError({
 			kind: "since-unsupported",
 			collection: collection.key,
 			message: parsedSince.error.message
 		}));
 		since = parsedSince.value;
 	}
-	return Result.ok({
+	return G.ok({
 		kind: "run",
 		accountHeaders,
 		accountSelector,
@@ -19102,7 +19461,7 @@ const planXSync = (input) => {
 };
 //#endregion
 //#region ../../packages/x/src/cli/write-plan.ts
-var XWritePlanError = class extends TaggedError("XWritePlanError")() {
+var XWritePlanError = class extends h("XWritePlanError")() {
 	constructor(args) {
 		super(args);
 		this.name = "XWritePlanError";
@@ -19124,16 +19483,16 @@ const responseString = (data, keys) => {
 const responseMediaIdResult = (data) => {
 	const root = isObjectRecord$1(data) ? data : void 0;
 	const id = (isObjectRecord$1(root?.data) ? root.data : void 0)?.id ?? root?.id;
-	if (typeof id !== "string" && typeof id !== "number") return Result.err(new XWritePlanError({
+	if (typeof id !== "string" && typeof id !== "number") return G.err(new XWritePlanError({
 		kind: "missing-media-id",
 		message: "Media upload did not return a media id."
 	}));
-	return Result.ok(String(id));
+	return G.ok(String(id));
 };
-const requiredTargetResult = (target) => target === void 0 ? Result.err(new XWritePlanError({
+const requiredTargetResult = (target) => target === void 0 ? G.err(new XWritePlanError({
 	kind: "missing-target",
 	message: "target is required."
-})) : Result.ok(target);
+})) : G.ok(target);
 const postMediaByExtension = {
 	".gif": {
 		mediaType: "image/gif",
@@ -19166,22 +19525,22 @@ const postMediaByExtension = {
 };
 const parsePostMediaFileResult = (path) => {
 	const media = postMediaByExtension[extname(path).toLowerCase()];
-	if (media === void 0) return Result.err(new XWritePlanError({
+	if (media === void 0) return G.err(new XWritePlanError({
 		kind: "invalid-media-type",
 		message: `Unsupported media type for ${path}. Supported types: jpg, jpeg, png, webp, gif, mp4, mov.`
 	}));
-	return Result.ok({
+	return G.ok({
 		...media,
 		path
 	});
 };
 const parsePostMediaIdResult = (value) => {
 	const mediaId = value.trim();
-	if (mediaId.length === 0) return Result.err(new XWritePlanError({
+	if (mediaId.length === 0) return G.err(new XWritePlanError({
 		kind: "empty-media-id",
 		message: "--media-id cannot be empty."
 	}));
-	return Result.ok(mediaId);
+	return G.ok(mediaId);
 };
 const postBodyHasText = (body) => {
 	const text = body?.text;
@@ -19193,7 +19552,7 @@ const postBodyMediaIds = (body) => {
 };
 const postBodyHasPoll = (body) => isObjectRecord$1(body?.poll);
 const validatePostMediaResult = (mediaFiles, mediaIds) => {
-	if (mediaFiles.length + mediaIds.length > 4) return Result.err(new XWritePlanError({
+	if (mediaFiles.length + mediaIds.length > 4) return G.err(new XWritePlanError({
 		kind: "invalid-media-mix",
 		message: "Attach at most 4 media items."
 	}));
@@ -19205,35 +19564,35 @@ const validatePostMediaResult = (mediaFiles, mediaIds) => {
 		gifCount > 0,
 		videoCount > 0
 	].filter(Boolean).length;
-	if (imageCount > 4) return Result.err(new XWritePlanError({
+	if (imageCount > 4) return G.err(new XWritePlanError({
 		kind: "invalid-media-mix",
 		message: "Attach at most 4 images."
 	}));
-	if (gifCount > 1) return Result.err(new XWritePlanError({
+	if (gifCount > 1) return G.err(new XWritePlanError({
 		kind: "invalid-media-mix",
 		message: "Attach at most 1 GIF."
 	}));
-	if (videoCount > 1) return Result.err(new XWritePlanError({
+	if (videoCount > 1) return G.err(new XWritePlanError({
 		kind: "invalid-media-mix",
 		message: "Attach at most 1 video."
 	}));
-	if (localCategoryCount > 1) return Result.err(new XWritePlanError({
+	if (localCategoryCount > 1) return G.err(new XWritePlanError({
 		kind: "invalid-media-mix",
 		message: "Do not mix images, GIFs, and videos in one post."
 	}));
-	return Result.ok();
+	return G.ok();
 };
 const validatePostPollMediaResult = (args) => {
 	const explicitMediaCount = args.mediaFiles.length + args.mediaIds.length;
 	const bodyMediaIds = explicitMediaCount > 0 ? [] : postBodyMediaIds(args.bodyFields);
 	const hasMedia = explicitMediaCount + bodyMediaIds.length > 0;
 	const hasPoll = args.poll !== void 0 || postBodyHasPoll(args.bodyFields);
-	if (hasPoll && hasMedia) return Result.err(new XWritePlanError({
+	if (hasPoll && hasMedia) return G.err(new XWritePlanError({
 		kind: "invalid-media-mix",
 		message: "--poll-option cannot be combined with media attachments."
 	}));
 	const media = validatePostMediaResult(args.mediaFiles, [...args.mediaIds, ...bodyMediaIds]);
-	return Result.isError(media) ? Result.err(media.error) : Result.ok({
+	return G.isError(media) ? G.err(media.error) : G.ok({
 		bodyMediaIds,
 		hasMedia,
 		hasPoll
@@ -19303,12 +19662,12 @@ const planPostRequest = (args) => {
 	};
 };
 const planMessageRequestResult = (args) => {
-	if (args.body === void 0) return Result.err(new XWritePlanError({
+	if (args.body === void 0) return G.err(new XWritePlanError({
 		kind: "missing-message-body",
 		message: "Message body is required."
 	}));
 	const text = typeof args.body.text === "string" ? args.body.text : void 0;
-	if (args.threadResolution !== void 0) return Result.ok({
+	if (args.threadResolution !== void 0) return G.ok({
 		method: "POST",
 		path: `x/dm_conversations/${encodeURIComponent(args.threadResolution.id)}/messages`,
 		headers: args.headers,
@@ -19320,11 +19679,11 @@ const planMessageRequestResult = (args) => {
 	});
 	if (args.recipients.length === 1) {
 		const [participant] = args.participantResolutions;
-		if (participant === void 0) return Result.err(new XWritePlanError({
+		if (participant === void 0) return G.err(new XWritePlanError({
 			kind: "missing-target",
 			message: "Pass at least one recipient."
 		}));
-		return Result.ok({
+		return G.ok({
 			method: "POST",
 			path: `x/dm_conversations/with/${encodeURIComponent(participant.id)}/messages`,
 			headers: args.headers,
@@ -19337,7 +19696,7 @@ const planMessageRequestResult = (args) => {
 	}
 	const participantIds = args.participantResolutions.map((resolution) => resolution.id);
 	const { text: bodyText, ...bodyFields } = args.body;
-	return Result.ok({
+	return G.ok({
 		method: "POST",
 		path: "x/dm_conversations",
 		headers: args.headers,
@@ -19816,7 +20175,7 @@ const buildSync = (deps, platform) => defineCommand({
 			since: args.since,
 			timeout: args.timeout
 		});
-		if (Result.isError(planned)) throw new UsageError(planned.error instanceof XSyncPlanError ? planned.error.message : String(planned.error));
+		if (G.isError(planned)) throw new UsageError(planned.error instanceof XSyncPlanError ? planned.error.message : String(planned.error));
 		const plan = planned.value;
 		if (plan.kind === "list") {
 			const cache = openXCacheFor(deps, {
@@ -19884,7 +20243,7 @@ const buildSync = (deps, platform) => defineCommand({
 				if (rateLimitError) throw rateLimitError;
 				throw error;
 			}
-			if (Result.isError(result)) {
+			if (G.isError(result)) {
 				const rateLimitError = enrichRateLimitSyncError({
 					error: result.error,
 					platform,
@@ -19991,7 +20350,7 @@ const buildSql = (deps, platform) => {
 				} catch (error) {
 					throw new UsageError(`Query failed (cache is read-only): ${errorMessageFrom(error)}`);
 				}
-				if (Result.isError(result)) throw new UsageError(`Query failed (cache is read-only): ${result.error.message}`);
+				if (G.isError(result)) throw new UsageError(`Query failed (cache is read-only): ${result.error.message}`);
 				await deps.printResult({
 					account: account.account,
 					contract: schemaContract,
@@ -20076,7 +20435,7 @@ const throwWritePlanError = (error) => {
 };
 const requireWriteTarget = (target) => {
 	const required = requiredTargetResult(target);
-	if (Result.isError(required)) return throwWritePlanError(required.error);
+	if (G.isError(required)) return throwWritePlanError(required.error);
 	return required.value;
 };
 const executeWriteRequest = (deps, plan) => plan.method === "POST" ? deps.api.post(plan.path, {
@@ -20129,7 +20488,7 @@ const repeatableValues = (name, value, rawArgs) => {
 };
 const parsePostMediaId = (deps, value) => {
 	const mediaId = parsePostMediaIdResult(value);
-	if (Result.isError(mediaId)) throw new UsageError(mediaId.error.message);
+	if (G.isError(mediaId)) throw new UsageError(mediaId.error.message);
 	return deps.parseResourceId("--media-id", mediaId.value);
 };
 const parsePostPoll = (deps, args, rawArgs) => {
@@ -20213,7 +20572,7 @@ const uploadPostMedia = async (deps, headers, media, timeoutSeconds) => {
 	initBody.set("total_bytes", String(file.byteLength));
 	initBody.set("media_category", media.category);
 	const mediaId = responseMediaIdResult(await (await postMediaForm(deps, "x/media/upload/init", headers, initBody)).json());
-	if (Result.isError(mediaId)) throw new UsageError(mediaId.error.message);
+	if (G.isError(mediaId)) throw new UsageError(mediaId.error.message);
 	for (let segmentIndex = 0, offset = 0; offset < file.byteLength; segmentIndex += 1, offset += postMediaChunkSize) {
 		const chunk = file.subarray(offset, offset + postMediaChunkSize);
 		const appendBody = new FormData();
@@ -20475,7 +20834,7 @@ const buildPost = (deps) => {
 			const commandArgs = args;
 			const mediaFiles = repeatableValues("media", commandArgs.media, rawArgs).map((path) => {
 				const media = parsePostMediaFileResult(path);
-				if (Result.isError(media)) throw new UsageError(media.error.message);
+				if (G.isError(media)) throw new UsageError(media.error.message);
 				return media.value;
 			});
 			const mediaIds = repeatableValues("media-id", commandArgs["media-id"], rawArgs).map((mediaId) => parsePostMediaId(deps, mediaId));
@@ -20487,7 +20846,7 @@ const buildPost = (deps) => {
 				mediaIds,
 				poll
 			});
-			if (Result.isError(postInputs)) throw new UsageError(postInputs.error.message);
+			if (G.isError(postInputs)) throw new UsageError(postInputs.error.message);
 			const timeoutSeconds = commandArgs.timeout === void 0 ? postMediaProcessingTimeoutSeconds : deps.parseIntegerString("--timeout", commandArgs.timeout, { min: 1 });
 			const stdinBody = await readPostStdinBody(deps, postInputs.value.hasMedia, bodyFields);
 			const account = typeof commandArgs.account === "string" ? commandArgs.account : void 0;
@@ -20799,7 +21158,7 @@ const buildMessage = (deps) => {
 				recipients,
 				threadResolution
 			});
-			if (Result.isError(request)) throw new UsageError(request.error.message);
+			if (G.isError(request)) throw new UsageError(request.error.message);
 			const response = await deps.api.post(request.value.path, {
 				headers: request.value.headers,
 				json: request.value.body
@@ -21080,10 +21439,10 @@ createXCommands({
 //#endregion
 //#region ../../packages/linkedin/src/cli/lifecycle-plan.ts
 const LINKEDIN_CONNECTED_STATUS = "connected";
-var InvalidLinkedinLifecycleTarget = class extends TaggedError("InvalidLinkedinLifecycleTarget")() {};
-var LinkedinLifecycleNoAccountMatch = class extends TaggedError("LinkedinLifecycleNoAccountMatch")() {};
-var LinkedinLifecycleAmbiguousAccount = class extends TaggedError("LinkedinLifecycleAmbiguousAccount")() {};
-var LinkedinLifecycleSeatTimeout = class extends TaggedError("LinkedinLifecycleSeatTimeout")() {
+var InvalidLinkedinLifecycleTarget = class extends h("InvalidLinkedinLifecycleTarget")() {};
+var LinkedinLifecycleNoAccountMatch = class extends h("LinkedinLifecycleNoAccountMatch")() {};
+var LinkedinLifecycleAmbiguousAccount = class extends h("LinkedinLifecycleAmbiguousAccount")() {};
+var LinkedinLifecycleSeatTimeout = class extends h("LinkedinLifecycleSeatTimeout")() {
 	constructor() {
 		super({ message: "billing_seat_timed_out" });
 	}
@@ -21093,22 +21452,22 @@ const parseLinkedinReconnectTarget = (value) => {
 	const trimmed = value.trim();
 	if (trimmed.startsWith("@")) {
 		const username = normalizeSocialIdentifier(trimmed);
-		if (username) return Result.ok({
+		if (username) return G.ok({
 			type: "username",
 			value: username
 		});
 	}
 	const profileSelector = parseTypedSocialSelector(trimmed, { prefixes: ["profile_id"] });
-	if (profileSelector) return Result.ok({
+	if (profileSelector) return G.ok({
 		type: "profileId",
 		value: profileSelector.id.toLowerCase()
 	});
 	const publicIdentifier = linkedInProfileIdentifierFromURL(trimmed);
-	if (publicIdentifier) return Result.ok({
+	if (publicIdentifier) return G.ok({
 		type: "username",
 		value: publicIdentifier
 	});
-	return Result.err(new InvalidLinkedinLifecycleTarget({
+	return G.err(new InvalidLinkedinLifecycleTarget({
 		value,
 		message: "LinkedIn reconnect account must be @username, a LinkedIn profile URL, or profile_id:<id>."
 	}));
@@ -21124,14 +21483,14 @@ const reconnectCommandTargetFor = (account) => {
 const connectedLinkedinLifecycleAccounts = (accounts) => accounts.filter((account) => account.status === LINKEDIN_CONNECTED_STATUS);
 const resolveLinkedinLifecycleAccount = (accounts, identifier) => {
 	const target = parseLinkedinReconnectTarget(identifier);
-	if (Result.isError(target)) return Result.err(target.error);
+	if (G.isError(target)) return G.err(target.error);
 	const matches = accounts.filter((candidate) => linkedinLifecycleAccountMatchesTarget(candidate, target.value));
-	if (matches.length === 1 && matches[0]) return Result.ok(matches[0]);
-	if (matches.length === 0) return Result.err(new LinkedinLifecycleNoAccountMatch({
+	if (matches.length === 1 && matches[0]) return G.ok(matches[0]);
+	if (matches.length === 0) return G.err(new LinkedinLifecycleNoAccountMatch({
 		value: identifier,
 		message: `No LinkedIn account matches "${identifier}".`
 	}));
-	return Result.err(new LinkedinLifecycleAmbiguousAccount({
+	return G.err(new LinkedinLifecycleAmbiguousAccount({
 		value: identifier,
 		message: `Multiple LinkedIn accounts match "${identifier}". Pass profile_id:<id>.`
 	}));
@@ -21139,9 +21498,9 @@ const resolveLinkedinLifecycleAccount = (accounts, identifier) => {
 const resolveLinkedinDisconnectAccount = (accounts, identifier) => {
 	if (identifier) return resolveLinkedinLifecycleAccount(accounts, identifier);
 	const connected = connectedLinkedinLifecycleAccounts(accounts);
-	if (connected.length === 1 && connected[0]) return Result.ok(connected[0]);
-	if (connected.length === 0) return Result.err(new LinkedinLifecycleNoAccountMatch({ message: "No connected LinkedIn accounts found." }));
-	return Result.err(new LinkedinLifecycleAmbiguousAccount({ message: "Multiple LinkedIn accounts are connected. Pass a public identifier." }));
+	if (connected.length === 1 && connected[0]) return G.ok(connected[0]);
+	if (connected.length === 0) return G.err(new LinkedinLifecycleNoAccountMatch({ message: "No connected LinkedIn accounts found." }));
+	return G.err(new LinkedinLifecycleAmbiguousAccount({ message: "Multiple LinkedIn accounts are connected. Pass a public identifier." }));
 };
 //#endregion
 //#region ../../packages/linkedin/src/cli/lifecycle.ts
@@ -21149,15 +21508,9 @@ const LINKEDIN_PLATFORM = "linkedin";
 const DEFAULT_POLL_INTERVAL_MS = 2e3;
 const DEFAULT_POLL_TIMEOUT_MS = 12e4;
 const SEAT_POLL_TIMEOUT_MS$2 = 600 * 1e3;
-const isInteractiveTerminal$1 = (deps) => deps.isInteractiveTerminal?.() ?? process.stdout.isTTY === true;
-const openURL = async (deps, url, options = {}) => {
+const surfaceURL$1 = (deps, url, options = {}) => {
 	const log = deps.log ?? console.error;
-	if (options.log ?? true) log(`Opening ${url}`);
-	if (!(isInteractiveTerminal$1(deps) && deps.openURL)) return {
-		opened: false,
-		url
-	};
-	return await Promise.resolve(deps.openURL(url));
+	if (options.log ?? true) log(`Open this URL: ${url}`);
 };
 const pollForSeat$2 = async (deps) => {
 	const intervalMs = deps.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
@@ -21173,7 +21526,7 @@ const prepareAccountConnect$1 = async (deps) => {
 	if ((await deps.client.billing.status()).canConnect) return;
 	const status = await deps.client.billing.prepareAccountConnect();
 	if (status.canConnect) return;
-	if (status.paymentURL) await openURL(deps, status.paymentURL);
+	if (status.paymentURL) surfaceURL$1(deps, status.paymentURL);
 	await pollForSeat$2(deps);
 };
 const accountUsername = (account) => account.username.replace(/^@+/, "");
@@ -21207,12 +21560,12 @@ const authURLFor$1 = async (deps, operation) => ({
 });
 const reconnectAccountForIdentifier = async (deps, identifier) => {
 	const account = resolveLinkedinLifecycleAccount(await listLinkedinLifecycleAccounts(deps), identifier);
-	if (Result.isError(account)) throw account.error;
+	if (G.isError(account)) throw account.error;
 	return account.value;
 };
 const resolveDisconnectTarget = async (deps, identifier) => {
 	const account = resolveLinkedinDisconnectAccount(await listLinkedinLifecycleAccounts(deps, Boolean(identifier)), identifier);
-	if (Result.isError(account)) throw account.error;
+	if (G.isError(account)) throw account.error;
 	return account.value;
 };
 const connectLinkedinAccount = async (deps) => {
@@ -21223,7 +21576,7 @@ const connectLinkedinAccount = async (deps) => {
 		platform: LINKEDIN_PLATFORM,
 		mode: "create"
 	})).url);
-	await openURL(deps, authURL.url, { log: !authURL.openingLogged });
+	surfaceURL$1(deps, authURL.url, { log: !authURL.openingLogged });
 	return {
 		platform: LINKEDIN_PLATFORM,
 		status: "connected",
@@ -21237,7 +21590,7 @@ const reconnectLinkedinAccount = async (deps, identifier) => {
 		mode: "reconnect",
 		account: reconnectCommandTargetFor(account)
 	})).url);
-	await openURL(deps, authURL.url, { log: !authURL.openingLogged });
+	surfaceURL$1(deps, authURL.url, { log: !authURL.openingLogged });
 	return {
 		platform: LINKEDIN_PLATFORM,
 		status: "connected",
@@ -21260,7 +21613,7 @@ const disconnectLinkedinAccount = async (deps, identifier) => {
 const CONNECT_TIMEOUT_MS = 300 * 1e3;
 const SEAT_POLL_TIMEOUT_MS$1 = 600 * 1e3;
 const POLL_INTERVAL_MS = 2 * 1e3;
-var XConnectTimedOut = class extends TaggedError("XConnectTimedOut")() {
+var XConnectTimedOut = class extends h("XConnectTimedOut")() {
 	constructor(args) {
 		super({
 			...args,
@@ -21269,7 +21622,7 @@ var XConnectTimedOut = class extends TaggedError("XConnectTimedOut")() {
 		this.name = "XConnectTimedOut";
 	}
 };
-var XBillingSeatTimedOut = class extends TaggedError("XBillingSeatTimedOut")() {
+var XBillingSeatTimedOut = class extends h("XBillingSeatTimedOut")() {
 	constructor() {
 		super({
 			operation: "prepareAccountConnect",
@@ -21279,7 +21632,7 @@ var XBillingSeatTimedOut = class extends TaggedError("XBillingSeatTimedOut")() {
 		this.name = "XBillingSeatTimedOut";
 	}
 };
-var XAccountNotFound = class extends TaggedError("XAccountNotFound")() {
+var XAccountNotFound = class extends h("XAccountNotFound")() {
 	constructor(args) {
 		super({
 			...args,
@@ -21288,9 +21641,9 @@ var XAccountNotFound = class extends TaggedError("XAccountNotFound")() {
 		this.name = "XAccountNotFound";
 	}
 };
-TaggedError("XAccountNotConnected")();
-TaggedError("XAccountRequired")();
-var XInvalidSelector = class extends TaggedError("XInvalidSelector")() {
+h("XAccountNotConnected")();
+h("XAccountRequired")();
+var XInvalidSelector = class extends h("XInvalidSelector")() {
 	constructor(args) {
 		super({
 			...args,
@@ -21309,20 +21662,16 @@ const throwXLifecycleError = (error) => {
 const defaultSleep = async (ms) => {
 	await new Promise((resolve) => setTimeout(resolve, ms));
 };
-const resolveWebBaseURL = async (deps) => {
-	return (typeof deps.webBaseURL === "function" ? await deps.webBaseURL() : deps.webBaseURL).replace(/\/+$/, "");
-};
 const connectURLFor = async (deps, reconnectProfileId) => {
-	const url = createURL(await resolveWebBaseURL(deps), "/connect/x/start");
-	if (reconnectProfileId) url.searchParams.set("reconnect", reconnectProfileId);
-	return url.toString();
+	return (await deps.client.accounts.reconnectURL({
+		platform: "x",
+		mode: reconnectProfileId ? "reconnect" : "create",
+		...reconnectProfileId ? { account: `profile_id:${reconnectProfileId}` } : {}
+	})).url;
 };
-const isInteractiveTerminal = (deps) => deps.isInteractiveTerminal?.() ?? process.stdout.isTTY === true;
-const openOrPrint = async (deps, url, options = {}) => {
+const surfaceURL = (deps, url, options = {}) => {
 	const log = deps.log ?? console.error;
-	if (options.log ?? true) log(`Opening ${url}`);
-	if (!(isInteractiveTerminal(deps) && deps.openBrowser)) return;
-	await deps.openBrowser(url);
+	if (options.log ?? true) log(`Open this URL: ${url}`);
 };
 const pollForAccount = async (deps, operation, matches) => {
 	const sleep = deps.sleep ?? defaultSleep;
@@ -21333,10 +21682,10 @@ const pollForAccount = async (deps, operation, matches) => {
 			platform: "x",
 			includeDisconnected: true
 		})).find(matches);
-		if (account) return Result.ok(account);
+		if (account) return G.ok(account);
 		await sleep(POLL_INTERVAL_MS);
 	}
-	return Result.err(new XConnectTimedOut({
+	return G.err(new XConnectTimedOut({
 		operation,
 		timeoutMS: CONNECT_TIMEOUT_MS
 	}));
@@ -21350,16 +21699,16 @@ const pollForSeat$1 = async (deps) => {
 	const now = deps.now ?? Date.now;
 	const startedAt = now();
 	while (now() - startedAt < SEAT_POLL_TIMEOUT_MS$1) {
-		if ((await deps.client.billing.status()).canConnect) return Result.ok();
+		if ((await deps.client.billing.status()).canConnect) return G.ok();
 		await sleep(POLL_INTERVAL_MS);
 	}
-	return Result.err(new XBillingSeatTimedOut());
+	return G.err(new XBillingSeatTimedOut());
 };
 const prepareAccountConnect = async (deps) => {
-	if ((await deps.client.billing.status()).canConnect) return Result.ok();
+	if ((await deps.client.billing.status()).canConnect) return G.ok();
 	const status = await deps.client.billing.prepareAccountConnect();
-	if (status.canConnect) return Result.ok();
-	if (status.paymentURL) await openOrPrint(deps, status.paymentURL);
+	if (status.canConnect) return G.ok();
+	if (status.paymentURL) surfaceURL(deps, status.paymentURL);
 	return pollForSeat$1(deps);
 };
 const accountKey = (account) => account.profileId;
@@ -21370,18 +21719,18 @@ const parseXAccountSelector = (target, operation) => {
 	const trimmed = target.trim();
 	if (trimmed.startsWith("profile_id:")) {
 		const profileId = trimmed.slice(11).trim();
-		if (profileId && !/[/?#%]/.test(profileId)) return Result.ok({
+		if (profileId && !/[/?#%]/.test(profileId)) return G.ok({
 			kind: "profileId",
 			normalized: profileId.toLowerCase(),
 			raw: target
 		});
 	}
-	if (trimmed.startsWith("@") && !/[/?#%]/.test(trimmed)) return Result.ok({
+	if (trimmed.startsWith("@") && !/[/?#%]/.test(trimmed)) return G.ok({
 		kind: "username",
 		normalized: normalizeIdentifier(trimmed),
 		raw: target
 	});
-	return Result.err(new XInvalidSelector({
+	return G.err(new XInvalidSelector({
 		operation,
 		account: target
 	}));
@@ -21390,7 +21739,7 @@ const findXLifecycleAccount = (accounts, selector) => {
 	if (selector.kind === "profileId") return accounts.find((account) => account.profileId.toLowerCase() === selector.normalized);
 	return accounts.find((account) => normalizeIdentifier(account.username) === selector.normalized);
 };
-const listXLifecycleAccounts = async (deps, includeDisconnected) => Result.ok(await deps.client.accounts.list({
+const listXLifecycleAccounts = async (deps, includeDisconnected) => G.ok(await deps.client.accounts.list({
 	platform: "x",
 	includeDisconnected
 }));
@@ -21401,14 +21750,14 @@ const listXLifecycleAccounts = async (deps, includeDisconnected) => Result.ok(aw
 const createXConnectURL = (deps, reconnectProfileId) => connectURLFor(deps, reconnectProfileId);
 const connectXAccount = async (deps) => {
 	const beforeResult = await listXLifecycleAccounts(deps, true);
-	if (Result.isError(beforeResult)) return Result.err(beforeResult.error);
+	if (G.isError(beforeResult)) return G.err(beforeResult.error);
 	const before = beforeResult.value;
 	const connectedBefore = new Set(before.filter((account) => account.status === "connected").map(accountKey));
 	const lastSeenBefore = new Map(before.filter((account) => account.status === "connected").map((account) => [accountKey(account), timestampMS(account.lastSeenAt)]));
 	const prepared = await prepareAccountConnect(deps);
-	if (Result.isError(prepared)) return Result.err(prepared.error);
+	if (G.isError(prepared)) return G.err(prepared.error);
 	const authURL = await authURLFor(deps, () => connectURLFor(deps));
-	await openOrPrint(deps, authURL.url, { log: !authURL.openingLogged });
+	surfaceURL(deps, authURL.url, { log: !authURL.openingLogged });
 	const account = await pollForAccount(deps, "connect", (candidate) => {
 		if (candidate.status !== "connected") return false;
 		if (!connectedBefore.has(candidate.profileId)) return true;
@@ -21416,8 +21765,8 @@ const connectXAccount = async (deps) => {
 		const currentLastSeen = timestampMS(candidate.lastSeenAt);
 		return previousLastSeen !== void 0 && currentLastSeen !== void 0 && currentLastSeen > previousLastSeen;
 	});
-	if (Result.isError(account)) return Result.err(account.error);
-	return Result.ok({
+	if (G.isError(account)) return G.err(account.error);
+	return G.ok({
 		platform: "x",
 		status: "connected",
 		account: account.value
@@ -21425,20 +21774,20 @@ const connectXAccount = async (deps) => {
 };
 const reconnectXAccount = async (deps, args) => {
 	const selector = parseXAccountSelector(args.account, "reconnect");
-	if (Result.isError(selector)) return Result.err(selector.error);
+	if (G.isError(selector)) return G.err(selector.error);
 	const accountsResult = await listXLifecycleAccounts(deps, true);
-	if (Result.isError(accountsResult)) return Result.err(accountsResult.error);
+	if (G.isError(accountsResult)) return G.err(accountsResult.error);
 	const accounts = accountsResult.value;
 	const existing = findXLifecycleAccount(accounts, selector.value);
-	if (!existing) return Result.err(new XAccountNotFound({
+	if (!existing) return G.err(new XAccountNotFound({
 		operation: "reconnect",
 		account: args.account
 	}));
 	const authURL = await authURLFor(deps, () => connectURLFor(deps, existing.profileId));
-	await openOrPrint(deps, authURL.url, { log: !authURL.openingLogged });
+	surfaceURL(deps, authURL.url, { log: !authURL.openingLogged });
 	const account = await pollForAccount(deps, "reconnect", (candidate) => candidate.profileId === existing.profileId && candidate.status === "connected");
-	if (Result.isError(account)) return Result.err(account.error);
-	return Result.ok({
+	if (G.isError(account)) return G.err(account.error);
+	return G.ok({
 		platform: "x",
 		status: "connected",
 		account: account.value
@@ -21446,12 +21795,12 @@ const reconnectXAccount = async (deps, args) => {
 };
 const disconnectXAccount = async (deps, target) => {
 	const selector = parseXAccountSelector(target, "disconnect");
-	if (Result.isError(selector)) return Result.err(selector.error);
+	if (G.isError(selector)) return G.err(selector.error);
 	const accountsResult = await listXLifecycleAccounts(deps);
-	if (Result.isError(accountsResult)) return Result.err(accountsResult.error);
+	if (G.isError(accountsResult)) return G.err(accountsResult.error);
 	const accounts = accountsResult.value;
 	const account = findXLifecycleAccount(accounts, selector.value);
-	if (!account) return Result.err(new XAccountNotFound({
+	if (!account) return G.err(new XAccountNotFound({
 		operation: "disconnect",
 		account: target
 	}));
@@ -21459,7 +21808,7 @@ const disconnectXAccount = async (deps, target) => {
 		platform: "x",
 		account: accountSelectorFor$1(account)
 	});
-	return Result.ok({
+	return G.ok({
 		platform: "x",
 		account,
 		result
@@ -22823,7 +23172,7 @@ function createEnv(opts) {
 }
 //#endregion
 //#region package.json
-var version$1 = "0.11.4";
+var version$1 = "0.11.6";
 //#endregion
 //#region src/lib/env.ts
 const URLWithTrailingSlash = url().transform(ensureTrailingSlash);
@@ -24018,22 +24367,21 @@ const createBillingCommand = (deps = {}) => {
 	const portal = defineCommand({
 		meta: commandMeta({
 			name: "portal",
-			description: "Open the hosted billing portal.",
+			description: "Print the hosted billing portal URL.",
 			capability: "read",
 			contract: readCLIContract({
 				outputSchema: BillingPortalOutput,
 				hazards: [{
 					code: "billing_portal_handoff",
-					message: "Hosted billing portal handoff; billing changes happen outside the CLI after the URL opens."
+					message: "Hosted billing portal handoff; billing changes happen outside the CLI after the URL is opened."
 				}]
 			})
 		}),
 		run: async () => {
 			const { url } = await clientFrom(deps).billing.portalURL();
-			const result = deps.isInteractiveTerminal?.() === true && deps.openURL !== void 0 ? await deps.openURL?.(url) : void 0;
 			await writeOutput$2(deps, {
-				url: result?.url ?? url,
-				opened: result?.opened === true
+				url,
+				opened: false
 			});
 		}
 	});
@@ -24062,11 +24410,11 @@ const CLI_SCOPE_ALIASES = ["read", "read,write"];
 `${productBrand.name}`, `${productBrand.name}`;
 const isCLIScopeAlias = (scope) => CLI_SCOPE_ALIASES.some((alias) => alias === scope);
 const parseDeviceScopeAlias = (scope) => {
-	if (!isCLIScopeAlias(scope)) return Result.err({
+	if (!isCLIScopeAlias(scope)) return G.err({
 		code: "invalid_device_authorization_scope",
 		scope
 	});
-	return Result.ok(scope);
+	return G.ok(scope);
 };
 const parseCLIScopeAlias = parseDeviceScopeAlias;
 const scopeAliasFromAccessChoices$1 = (choices) => choices.includes("write") ? "read,write" : "read";
@@ -29828,7 +30176,7 @@ const accessPhase = async (ctx) => {
 		data: { scopeAlias }
 	};
 };
-TaggedError("InvalidEmailHint")();
+h("InvalidEmailHint")();
 const base64URLFromText = (value) => {
 	const bytes = new TextEncoder().encode(value);
 	let binary = "";
@@ -29988,7 +30336,7 @@ const resolvePhoneNumber = async (ctx) => {
 };
 //#endregion
 //#region src/lib/expected-errors.ts
-var InvalidScope = class extends TaggedError("InvalidScope")() {
+var InvalidScope = class extends h("InvalidScope")() {
 	constructor(scope) {
 		super({
 			scope,
@@ -29996,7 +30344,7 @@ var InvalidScope = class extends TaggedError("InvalidScope")() {
 		});
 	}
 };
-var AccountNotFound = class extends TaggedError("AccountNotFound")() {
+var AccountNotFound = class extends h("AccountNotFound")() {
 	constructor({ account, platform }) {
 		super({
 			account,
@@ -30005,7 +30353,7 @@ var AccountNotFound = class extends TaggedError("AccountNotFound")() {
 		});
 	}
 };
-var NoConnectedAccount = class extends TaggedError("NoConnectedAccount")() {
+var NoConnectedAccount = class extends h("NoConnectedAccount")() {
 	constructor(platform) {
 		super({
 			platform,
@@ -30013,7 +30361,7 @@ var NoConnectedAccount = class extends TaggedError("NoConnectedAccount")() {
 		});
 	}
 };
-var LookupPayloadInvalid = class extends TaggedError("LookupPayloadInvalid")() {
+var LookupPayloadInvalid = class extends h("LookupPayloadInvalid")() {
 	constructor({ input, platform }) {
 		super({
 			input,
@@ -30022,7 +30370,7 @@ var LookupPayloadInvalid = class extends TaggedError("LookupPayloadInvalid")() {
 		});
 	}
 };
-var SchemaPathUnknown = class extends TaggedError("SchemaPathUnknown")() {
+var SchemaPathUnknown = class extends h("SchemaPathUnknown")() {
 	constructor({ message, path }) {
 		super({
 			message,
@@ -30030,7 +30378,7 @@ var SchemaPathUnknown = class extends TaggedError("SchemaPathUnknown")() {
 		});
 	}
 };
-var SchemaContractInvalid = class extends TaggedError("SchemaContractInvalid")() {
+var SchemaContractInvalid = class extends h("SchemaContractInvalid")() {
 	constructor({ label, message }) {
 		super({
 			label,
@@ -30038,7 +30386,7 @@ var SchemaContractInvalid = class extends TaggedError("SchemaContractInvalid")()
 		});
 	}
 };
-var UsagePaginationLimit = class extends TaggedError("UsagePaginationLimit")() {
+var UsagePaginationLimit = class extends h("UsagePaginationLimit")() {
 	constructor(limit) {
 		super({
 			limit,
@@ -30046,7 +30394,7 @@ var UsagePaginationLimit = class extends TaggedError("UsagePaginationLimit")() {
 		});
 	}
 };
-var LogoutRevocationFailed = class extends TaggedError("LogoutRevocationFailed")() {
+var LogoutRevocationFailed = class extends h("LogoutRevocationFailed")() {
 	constructor() {
 		super({ message: "Could not revoke the server-side session; local credentials were cleared." });
 	}
@@ -30055,16 +30403,16 @@ var LogoutRevocationFailed = class extends TaggedError("LogoutRevocationFailed")
 //#region src/login/phases/1.scope.ts
 const DEFAULT_SCOPE_ALIAS = "read,write";
 const parseScopeAliasResult = (value) => {
-	if (value === void 0 || value === null || value === "") return Result.ok(DEFAULT_SCOPE_ALIAS);
-	if (typeof value !== "string") return Result.err(new InvalidScope(String(value)));
+	if (value === void 0 || value === null || value === "") return G.ok(DEFAULT_SCOPE_ALIAS);
+	if (typeof value !== "string") return G.err(new InvalidScope(String(value)));
 	const scope = value === "write" ? DEFAULT_SCOPE_ALIAS : value;
 	const parsed = parseCLIScopeAlias(scope);
-	if (Result.isError(parsed)) return Result.err(new InvalidScope(scope));
-	return Result.ok(parsed.value);
+	if (G.isError(parsed)) return G.err(new InvalidScope(scope));
+	return G.ok(parsed.value);
 };
 const parseScopeAlias = (value) => {
 	const parsed = parseScopeAliasResult(value);
-	if (Result.isOk(parsed)) return parsed.value;
+	if (G.isOk(parsed)) return parsed.value;
 	throw new Error(parsed.error.message);
 };
 const scopePhase = async (ctx) => {
@@ -30075,85 +30423,6 @@ const scopePhase = async (ctx) => {
 	};
 };
 //#endregion
-//#region src/lib/browser.ts
-const WSL_VERSION = /microsoft|wsl/i;
-const BROWSER_TARGET_TIMEOUT_MS = 5e3;
-const LOCAL_HOSTS = new Set([
-	"localhost",
-	"127.0.0.1",
-	"::1"
-]);
-const displayURL = (url) => {
-	try {
-		const parsed = new URL(url);
-		parsed.searchParams.delete("token");
-		parsed.hash = "";
-		return parsed.toString();
-	} catch {
-		return url;
-	}
-};
-const hintFor = (url) => LOCAL_HOSTS.has(url.hostname) ? "Start the web app or local worker, or set SOCIAL_API_URL to your deployed social API." : "Check SOCIAL_API_URL and your connection, then try again.";
-const assertBrowserTargetReachable = async (url) => {
-	let parsed;
-	try {
-		parsed = new URL(url);
-	} catch {
-		return;
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return;
-	if (!LOCAL_HOSTS.has(parsed.hostname)) return;
-	const controller = new AbortController();
-	const timeout = setTimeout(() => controller.abort(), BROWSER_TARGET_TIMEOUT_MS);
-	const target = parsed.origin;
-	try {
-		const response = await fetch(target, {
-			method: "GET",
-			redirect: "manual",
-			signal: controller.signal
-		});
-		if (response.status >= 400) throw new Error(`social is reachable at ${displayURL(target)}, but it returned ${response.status}. Try again in a moment.`);
-	} catch (error) {
-		if (error instanceof Error && error.message.startsWith("social is reachable")) throw error;
-		throw new Error(`Can't reach ${displayURL(target)}. ${hintFor(parsed)}`);
-	} finally {
-		clearTimeout(timeout);
-	}
-};
-const runCommand = async (command) => await new Promise((resolve) => {
-	const [file, ...args] = command;
-	if (!file) {
-		resolve(false);
-		return;
-	}
-	const proc = spawn(file, args, { stdio: "ignore" });
-	proc.once("error", () => resolve(false));
-	proc.once("exit", (code) => resolve(code === 0));
-});
-const isWSL = async () => {
-	if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) return true;
-	const version = await readFile("/proc/version", "utf8").catch(() => "");
-	return WSL_VERSION.test(version);
-};
-const openBrowser = async (url) => {
-	await assertBrowserTargetReachable(url);
-	if (process.platform === "darwin") return await runCommand(["open", url]);
-	if (process.platform === "win32") return await runCommand([
-		"cmd",
-		"/c",
-		"start",
-		url
-	]);
-	if (await isWSL()) return await runCommand(["wslview", url]) || await runCommand([
-		"powershell.exe",
-		"-NoProfile",
-		"-Command",
-		"Start-Process",
-		url
-	]);
-	return await runCommand(["xdg-open", url]);
-};
-//#endregion
 //#region src/login/phases/2.seat.ts
 const SEAT_BILLING_DETAILS_URL = publicRouteURLs.pricing;
 const SEAT_PRICING_MESSAGE = `${productBrand.name} costs $20/month/account + usage. Full details at ${SEAT_BILLING_DETAILS_URL}. Continue?`;
@@ -30175,7 +30444,6 @@ const pollForSeat = async (ctx, deps = {}) => {
 	throw new Error("Billing checkout did not complete within 30 minutes. Finish checkout in the browser, then run `social account login` again.");
 };
 const runSeatPhase = async (ctx, deps = {}) => {
-	const openBrowser$1 = deps.openBrowser ?? openBrowser;
 	const status = await ctx.client.billing.status();
 	if (seatAvailable(status)) return {
 		status: "done",
@@ -30191,7 +30459,6 @@ const runSeatPhase = async (ctx, deps = {}) => {
 	};
 	const checkout = await ctx.client.billing.checkoutURL({ returnPath: SEAT_CHECKOUT_RETURN_PATH });
 	ctx.ui.info(checkout.url);
-	await openBrowser$1(checkout.url);
 	return {
 		status: "done",
 		data: await ctx.ui.spinElapsed("Waiting for billing checkout", () => pollForSeat(ctx, deps), "Billing ready")
@@ -30557,7 +30824,7 @@ const revokeServerSide = async (accessToken) => {
 		return false;
 	}
 };
-const logoutRevocationResult = (revoked) => revoked ? Result.ok(null) : Result.err(new LogoutRevocationFailed());
+const logoutRevocationResult = (revoked) => revoked ? G.ok(null) : G.err(new LogoutRevocationFailed());
 const logoutCommand = defineCommand({
 	meta: commandMeta({
 		name: "logout",
@@ -30586,7 +30853,7 @@ const logoutCommand = defineCommand({
 		const revoked = await revokeServerSide(credentials.accessToken);
 		await clearCredentials();
 		const revocation = logoutRevocationResult(revoked);
-		if (Result.isError(revocation)) throw new Error(revocation.error.message);
+		if (G.isError(revocation)) throw new Error(revocation.error.message);
 		analytics.capture("logout");
 		analytics.reset();
 	}
@@ -30725,7 +30992,7 @@ const fetchUsageLogs = async (client, input) => {
 	let nextCursor = null;
 	let pages = 0;
 	do {
-		if (pages >= USAGE_LOG_MAX_AUTO_PAGES) return Result.err(new UsagePaginationLimit(USAGE_LOG_MAX_AUTO_PAGES));
+		if (pages >= USAGE_LOG_MAX_AUTO_PAGES) return G.err(new UsagePaginationLimit(USAGE_LOG_MAX_AUTO_PAGES));
 		const remaining = input.limit === void 0 ? USAGE_LOG_PAGE_LIMIT : input.limit - items.length;
 		const usage = await client.usage.list({
 			platform: input.platform,
@@ -30739,7 +31006,7 @@ const fetchUsageLogs = async (client, input) => {
 		cursor = nextCursor ?? void 0;
 		pages += 1;
 	} while (nextCursor && (input.limit === void 0 || items.length < input.limit));
-	return Result.ok({
+	return G.ok({
 		items: input.limit === void 0 ? items : items.slice(0, input.limit),
 		cursor: nextCursor
 	});
@@ -30807,7 +31074,7 @@ const createUsageLogsCommand = (deps = {}) => defineCommand({
 				from,
 				to
 			});
-			if (Result.isError(usage)) throw new UsageError(usage.error.message);
+			if (G.isError(usage)) throw new UsageError(usage.error.message);
 			await writeOutput$1(deps, {
 				items: aggregateLogs(usage.value.items, sumBy),
 				meta: {
@@ -30825,7 +31092,7 @@ const createUsageLogsCommand = (deps = {}) => defineCommand({
 			from,
 			to
 		});
-		if (Result.isError(usage)) throw new UsageError(usage.error.message);
+		if (G.isError(usage)) throw new UsageError(usage.error.message);
 		await writeOutput$1(deps, {
 			items: usage.value.items,
 			meta: { cursor: usage.value.cursor }
@@ -30969,7 +31236,7 @@ const lifecycleDepsWithTextLogs = (deps) => ({
 			spinner.start(authHandshakeMessage);
 			try {
 				const url = await operation();
-				spinner.stop(`Opening ${url}`);
+				spinner.stop(`Open this URL: ${url}`);
 				return url;
 			} catch (error) {
 				spinner.error(authHandshakeMessage);
@@ -30978,7 +31245,7 @@ const lifecycleDepsWithTextLogs = (deps) => ({
 		}
 		writeText(deps, authHandshakeMessage);
 		const url = await operation();
-		writeText(deps, `Opening ${url}`);
+		writeText(deps, `Open this URL: ${url}`);
 		return url;
 	}
 });
@@ -31003,7 +31270,7 @@ const runConnectStep = async (deps, platform, listConnected, connectURL) => {
 		return;
 	}
 	const url = await connectURL();
-	writeText(deps, `Opening ${url}`);
+	writeText(deps, `Open this URL: ${url}`);
 	await writeOutput(deps, {
 		status: "pending_approval",
 		platform,
@@ -31064,14 +31331,14 @@ const createAccountCommand = (deps) => {
 					if (isInteractiveConnect(deps)) {
 						await runConnectOutput(deps, async (connectDeps) => {
 							const result = await connectXAccount(connectDeps);
-							if (Result.isError(result)) throwXLifecycleError(result.error);
+							if (G.isError(result)) throwXLifecycleError(result.error);
 							return result.value;
 						});
 						return;
 					}
 					await runConnectStep(deps, "x", async () => {
 						const result = await listXLifecycleAccounts(deps, true);
-						if (Result.isError(result)) throwXLifecycleError(result.error);
+						if (G.isError(result)) throwXLifecycleError(result.error);
 						return result.value;
 					}, () => createXConnectURL(deps));
 				})
@@ -31089,7 +31356,7 @@ const createAccountCommand = (deps) => {
 				x: createAccountPlatformCommand("x", "Reconnect an X account.", async (args) => {
 					await runConnectOutput(deps, async (connectDeps) => {
 						const result = await reconnectXAccount(connectDeps, { account: String(args.account) });
-						if (Result.isError(result)) throwXLifecycleError(result.error);
+						if (G.isError(result)) throwXLifecycleError(result.error);
 						return result.value;
 					});
 				}, { accountArg: xAccountArg })
@@ -31114,7 +31381,7 @@ const createAccountCommand = (deps) => {
 				}) }),
 				x: createAccountPlatformCommand("x", "Disconnect an X account.", async (args) => {
 					const result = await disconnectXAccount(deps, String(args.account));
-					if (Result.isError(result)) throwXLifecycleError(result.error);
+					if (G.isError(result)) throwXLifecycleError(result.error);
 					await writeOutput(deps, result.value);
 				}, {
 					accountArg: xAccountArg,
@@ -31258,12 +31525,12 @@ const selectAccountOutcome = ({ accounts, defaultAccount, explicitAccount }) =>
 	};
 };
 const requireSelectedAccount = (outcome, platform) => {
-	if (outcome.status === "selected") return Result.ok(outcome);
-	if (outcome.status === "missingExplicitAccount") return Result.err(new AccountNotFound({
+	if (outcome.status === "selected") return G.ok(outcome);
+	if (outcome.status === "missingExplicitAccount") return G.err(new AccountNotFound({
 		account: outcome.account,
 		platform
 	}));
-	return Result.err(new NoConnectedAccount(platform));
+	return G.err(new NoConnectedAccount(platform));
 };
 const isRecord$1 = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
 const stringField = (value, key) => {
@@ -31276,35 +31543,35 @@ const stringOrNumberField = (value, key) => {
 	return typeof field === "number" && Number.isFinite(field) ? String(field) : void 0;
 };
 const parseXLookupResponse = (data, input) => {
-	if (!(isRecord$1(data) && isRecord$1(data.data))) return Result.err(new LookupPayloadInvalid({
+	if (!(isRecord$1(data) && isRecord$1(data.data))) return G.err(new LookupPayloadInvalid({
 		input,
 		platform: "x"
 	}));
 	const id = stringOrNumberField(data.data, "id");
-	if (!id) return Result.err(new LookupPayloadInvalid({
+	if (!id) return G.err(new LookupPayloadInvalid({
 		input,
 		platform: "x"
 	}));
 	const inputUsername = input.replace(/^@+/, "");
 	const resolvedUsername = stringField(data.data, "username") ?? inputUsername;
-	return Result.ok({
+	return G.ok({
 		id,
 		url: `https://x.com/${resolvedUsername}`
 	});
 };
 const parseLinkedinProfileLookupResponse = (data, input) => {
 	const profile = isRecord$1(data) && isRecord$1(data.data) ? data.data : data;
-	if (!isRecord$1(profile)) return Result.err(new LookupPayloadInvalid({
+	if (!isRecord$1(profile)) return G.err(new LookupPayloadInvalid({
 		input,
 		platform: "linkedin"
 	}));
 	const id = stringOrNumberField(profile, "provider_id") ?? stringOrNumberField(profile, "providerId") ?? stringOrNumberField(profile, "id");
-	if (!id) return Result.err(new LookupPayloadInvalid({
+	if (!id) return G.err(new LookupPayloadInvalid({
 		input,
 		platform: "linkedin"
 	}));
 	const publicIdentifier = stringField(profile, "public_identifier") ?? stringField(profile, "publicIdentifier");
-	return Result.ok({
+	return G.ok({
 		id,
 		...publicIdentifier ? { url: `https://www.linkedin.com/in/${encodeURIComponent(publicIdentifier)}` } : {}
 	});
@@ -31322,7 +31589,7 @@ const headerValuesFromRawArgs = (rawArgs = []) => {
 		if (arg === "--") break;
 		if (arg === "--header" || arg === "-H") {
 			const value = rawArgs[index + 1];
-			if (value === void 0) return Result.err(headerError("missingHeaderValue", `Pass a value for ${arg}.`));
+			if (value === void 0) return G.err(headerError("missingHeaderValue", `Pass a value for ${arg}.`));
 			values.push(value);
 			index += 1;
 			continue;
@@ -31333,25 +31600,25 @@ const headerValuesFromRawArgs = (rawArgs = []) => {
 		}
 		if (arg?.startsWith("-H=")) values.push(arg.slice(3));
 	}
-	return Result.ok(values);
+	return G.ok(values);
 };
 const commandHeaderValuesFrom = ({ headers, rawArgs }) => {
 	const rawValues = headerValuesFromRawArgs(rawArgs);
-	if (Result.isError(rawValues)) return rawValues;
+	if (G.isError(rawValues)) return rawValues;
 	if (rawValues.value.length > 0) return rawValues;
-	if (headers === void 0) return Result.ok([]);
-	if (typeof headers === "string") return Result.ok([headers]);
-	if (Array.isArray(headers) && headers.every((header) => typeof header === "string")) return Result.ok(headers);
-	return Result.err(headerError("invalidHeaderList", "Pass --header as Name: value."));
+	if (headers === void 0) return G.ok([]);
+	if (typeof headers === "string") return G.ok([headers]);
+	if (Array.isArray(headers) && headers.every((header) => typeof header === "string")) return G.ok(headers);
+	return G.err(headerError("invalidHeaderList", "Pass --header as Name: value."));
 };
 const parsedHeaderFrom = (header) => {
 	const colon = header.indexOf(":");
-	if (colon <= 0) return Result.err(headerError("malformedHeader", "Pass --header as Name: value."));
+	if (colon <= 0) return G.err(headerError("malformedHeader", "Pass --header as Name: value."));
 	const name = header.slice(0, colon).trim();
 	const value = header.slice(colon + 1).trim();
 	const normalized = name.toLowerCase();
-	if (normalized === "authorization" || normalized === "content-type" || normalized.startsWith("x-social-")) return Result.err(headerError("reservedHeader", `Header ${name} is reserved and cannot be set with --header.`));
-	return Result.ok({
+	if (normalized === "authorization" || normalized === "content-type" || normalized.startsWith("x-social-")) return G.err(headerError("reservedHeader", `Header ${name} is reserved and cannot be set with --header.`));
+	return G.ok({
 		name,
 		value
 	});
@@ -31359,17 +31626,17 @@ const parsedHeaderFrom = (header) => {
 const commandHeadersFrom = (defaults, args = {}) => {
 	const headers = new Headers(defaults);
 	const rawHeaders = commandHeaderValuesFrom(args);
-	if (Result.isError(rawHeaders)) return Result.err(rawHeaders.error);
+	if (G.isError(rawHeaders)) return G.err(rawHeaders.error);
 	for (const rawHeader of rawHeaders.value) {
 		const parsed = parsedHeaderFrom(rawHeader);
-		if (Result.isError(parsed)) return Result.err(parsed.error);
+		if (G.isError(parsed)) return G.err(parsed.error);
 		try {
 			headers.set(parsed.value.name, parsed.value.value);
 		} catch {
-			return Result.err(headerError("invalidHeader", `Invalid header ${parsed.value.name}.`));
+			return G.err(headerError("invalidHeader", `Invalid header ${parsed.value.name}.`));
 		}
 	}
-	return Result.ok(Object.fromEntries(headers.entries()));
+	return G.ok(Object.fromEntries(headers.entries()));
 };
 //#endregion
 //#region ../../node_modules/.bun/@borewit+text-codec@0.2.2/node_modules/@borewit/text-codec/lib/index.js
@@ -36306,7 +36573,7 @@ const createCLIDeps = () => {
 			platform
 		});
 		const selected = requireSelectedAccount(outcome, platform);
-		if (Result.isOk(selected)) return selected.value;
+		if (G.isOk(selected)) return selected.value;
 		if (outcome.status === "missingExplicitAccount") throw new NotFoundError(`${platform}_account_not_found`);
 		throw new Error(`${platform}_account_not_connected`);
 	};
@@ -36321,7 +36588,7 @@ const createCLIDeps = () => {
 			...selectedAccount.selector === void 0 ? {} : { "x-social-account-id": selectedAccount.selector }
 		};
 		const parsed = parseXLookupResponse(await api.get(`x/users/by/username/${encodeURIComponent(inputUsername)}`, { headers }).json(), input);
-		if (Result.isError(parsed)) throw new Error(`Could not resolve X username ${input}.`);
+		if (G.isError(parsed)) throw new Error(`Could not resolve X username ${input}.`);
 		return parsed.value;
 	};
 	const lookupLinkedinProfile = async (input, account, selectedAccount) => {
@@ -36334,7 +36601,7 @@ const createCLIDeps = () => {
 			...resolvedAccount.selector === void 0 ? {} : { "x-social-account-id": resolvedAccount.selector }
 		};
 		const parsed = parseLinkedinProfileLookupResponse(await api.get(`linkedin/users/${encodeURIComponent(input)}`, { headers }).json(), input);
-		if (Result.isError(parsed)) throw new Error(`Could not resolve LinkedIn profile ${input}.`);
+		if (G.isError(parsed)) throw new Error(`Could not resolve LinkedIn profile ${input}.`);
 		return parsed.value;
 	};
 	return {
@@ -36344,6 +36611,7 @@ const createCLIDeps = () => {
 			disconnectAccount: client.accounts.disconnect,
 			accounts: {
 				list: client.accounts.list,
+				reconnectURL: client.accounts.reconnectURL,
 				disconnect: client.accounts.disconnect
 			},
 			billing: {
@@ -36393,7 +36661,7 @@ const createCLIDeps = () => {
 		}),
 		commandHeaders: async (args) => {
 			const headers = commandHeadersFrom({ "Cache-Control": await cacheControlHeaderFromConfig() }, args);
-			if (Result.isError(headers)) throw new UsageError(headers.error.message);
+			if (G.isError(headers)) throw new UsageError(headers.error.message);
 			return headers.value;
 		},
 		printData,
@@ -36434,17 +36702,8 @@ const createCLIDeps = () => {
 				providerId: profile.id
 			};
 		},
-		openBrowser,
 		isInteractiveTerminal: () => process.stdout.isTTY === true,
 		webBaseURL: () => env.SOCIAL_WEB_URL,
-		openURL: async (url) => {
-			const opened = await openBrowser(url);
-			if (!opened) console.error(url);
-			return {
-				opened,
-				url
-			};
-		},
 		writeOutput: printData,
 		ui: createUI(process.stdout.isTTY === true)
 	};
@@ -36828,7 +37087,7 @@ const schemaAtPath = (command, commandPathInput, options = {}) => {
 				command,
 				path: []
 			} : commandAtPath(command, parts);
-			return Result.ok({
+			return G.ok({
 				schemaVersion: "2.0",
 				commands: Object.fromEntries(leafSchemasForCommand(selectedCommand, path))
 			});
@@ -36838,31 +37097,31 @@ const schemaAtPath = (command, commandPathInput, options = {}) => {
 				command,
 				path: []
 			} : commandAtPath(command, parts);
-			return Result.ok({
+			return G.ok({
 				schemaVersion: "2.0",
 				commands: Object.fromEntries(compactLeafSchemasForCommand(selectedCommand, path))
 			});
 		}
-		if (parts.length === 0) return Result.ok({
+		if (parts.length === 0) return G.ok({
 			schemaVersion: "2.0",
 			...schemaTreeForCommand(command)
 		});
 		const { command: selectedCommand, path, positionalMatch } = commandAtPath(command, parts);
-		if (positionalMatch) return Result.ok({
+		if (positionalMatch) return G.ok({
 			schemaVersion: "2.0",
 			...schemaForCommand(selectedCommand, path),
 			...positionalMatch
 		});
-		if (selectedCommand.subCommands && typeof selectedCommand.run !== "function") return Result.ok({
+		if (selectedCommand.subCommands && typeof selectedCommand.run !== "function") return G.ok({
 			schemaVersion: "2.0",
 			...schemaTreeForCommand(selectedCommand, path)
 		});
-		return Result.ok({
+		return G.ok({
 			schemaVersion: "2.0",
 			...schemaForCommand(selectedCommand, path)
 		});
 	} catch (error) {
-		return Result.err(schemaErrorFor(error, parts));
+		return G.err(schemaErrorFor(error, parts));
 	}
 };
 const schemaCommand = defineCommand({
@@ -36897,7 +37156,7 @@ const schemaCommand = defineCommand({
 		if (!rootCommand) throw new Error("schema_root_command_unconfigured");
 		const commandPathInput = Array.isArray(args._) && args._.length > 1 ? args._ : args.commandPath;
 		const schema = schemaAtPath(rootCommand, commandPathInput, { mode: args.leaves === true ? "leaves" : args.list === true ? "list" : "leaf" });
-		if (Result.isError(schema)) throw new Error(schema.error.message);
+		if (G.isError(schema)) throw new Error(schema.error.message);
 		printData(schema.value);
 	}
 });
@@ -37129,7 +37388,7 @@ const runSocial = async ({ command = createSocialCommand(), now = Date.now, rawA
 	try {
 		const loginArgError = loginExtraArgError(rawArgs, path);
 		if (loginArgError) throw loginArgError;
-		await runCommand$1(command, { rawArgs });
+		await runCommand(command, { rawArgs });
 	} catch (error) {
 		if (error instanceof SilentExit) return await finish(error.code, telemetry, now);
 		if (isCittyUsageError(error) && process.stderr.isTTY) await printUsage(command, rawArgs);