@astrohacker/factory 0.0.0-stage → 0.2.0

package/dist/ahfact.js

@@ -0,0 +1,2127 @@
+#!/usr/bin/env node
+
+// cli/ahfact.ts
+import { chmod, mkdir, readdir, readFile as readFile2, rm, writeFile } from "node:fs/promises";
+import { homedir, hostname } from "node:os";
+import { join as join2 } from "node:path";
+import { parseArgs } from "node:util";
+
+// node_modules/@orpc/shared/dist/index.mjs
+function resolveMaybeOptionalOptions(rest) {
+  return rest[0] ?? {};
+}
+function toArray(value) {
+  return Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
+}
+var DEFAULT_MAX_BIGINT_DIGITS = 4300;
+var BIGINT_PATTERN = /^-?(?:0|[1-9]\d*)$/;
+function parseBigIntString(value, maxDigits) {
+  const digits = value.startsWith("-") ? value.length - 1 : value.length;
+  if (digits > maxDigits || !BIGINT_PATTERN.test(value)) {
+    return;
+  }
+  return BigInt(value);
+}
+var ORPC_NAME = "orpc";
+var ORPC_SHARED_PACKAGE_NAME = "@orpc/shared";
+var ORPC_SHARED_PACKAGE_VERSION = "1.16.2";
+
+class AbortError extends Error {
+  constructor(...rest) {
+    super(...rest);
+    this.name = "AbortError";
+  }
+}
+function once(fn) {
+  let cached;
+  return () => {
+    if (cached) {
+      return cached.result;
+    }
+    const result = fn();
+    cached = { result };
+    return result;
+  };
+}
+function sequential(fn) {
+  let lastOperationPromise = Promise.resolve();
+  return (...args) => {
+    return lastOperationPromise = lastOperationPromise.catch(() => {}).then(() => {
+      return fn(...args);
+    });
+  };
+}
+var SPAN_ERROR_STATUS = 2;
+var GLOBAL_OTEL_CONFIG_KEY = `__${ORPC_SHARED_PACKAGE_NAME}@${ORPC_SHARED_PACKAGE_VERSION}/otel/config__`;
+function getGlobalOtelConfig() {
+  return globalThis[GLOBAL_OTEL_CONFIG_KEY];
+}
+function startSpan(name, options = {}, context) {
+  const tracer = getGlobalOtelConfig()?.tracer;
+  return tracer?.startSpan(name, options, context);
+}
+function setSpanError(span, error, options = {}) {
+  if (!span) {
+    return;
+  }
+  const exception = toOtelException(error);
+  span.recordException(exception);
+  if (!options.signal?.aborted || options.signal.reason !== error) {
+    span.setStatus({
+      code: SPAN_ERROR_STATUS,
+      message: exception.message
+    });
+  }
+}
+function toOtelException(error) {
+  if (error instanceof Error) {
+    const exception = {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+    if ("code" in error && (typeof error.code === "string" || typeof error.code === "number")) {
+      exception.code = error.code;
+    }
+    return exception;
+  }
+  return { message: String(error) };
+}
+async function runWithSpan({ name, context, ...options }, fn) {
+  const tracer = getGlobalOtelConfig()?.tracer;
+  if (!tracer) {
+    return fn();
+  }
+  const callback = async (span) => {
+    try {
+      return await fn(span);
+    } catch (e) {
+      setSpanError(span, e, options);
+      throw e;
+    } finally {
+      span.end();
+    }
+  };
+  if (context) {
+    return tracer.startActiveSpan(name, options, context, callback);
+  } else {
+    return tracer.startActiveSpan(name, options, callback);
+  }
+}
+async function runInSpanContext(span, fn) {
+  const otelConfig = getGlobalOtelConfig();
+  if (!span || !otelConfig) {
+    return fn();
+  }
+  const ctx = otelConfig.trace.setSpan(otelConfig.context.active(), span);
+  return otelConfig.context.with(ctx, fn);
+}
+function isAsyncIteratorObject(maybe) {
+  if (!maybe || typeof maybe !== "object") {
+    return false;
+  }
+  return "next" in maybe && typeof maybe.next === "function" && Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
+}
+var fallbackAsyncDisposeSymbol = Symbol.for("asyncDispose");
+var asyncDisposeSymbol = Symbol.asyncDispose ?? fallbackAsyncDisposeSymbol;
+
+class AsyncIteratorClass {
+  #isDone = false;
+  #isExecuteComplete = false;
+  #cleanup;
+  #next;
+  constructor(next, cleanup) {
+    this.#cleanup = cleanup;
+    this.#next = sequential(async () => {
+      if (this.#isDone) {
+        return { done: true, value: undefined };
+      }
+      try {
+        const result = await next();
+        if (result.done) {
+          this.#isDone = true;
+        }
+        return result;
+      } catch (err) {
+        this.#isDone = true;
+        throw err;
+      } finally {
+        if (this.#isDone && !this.#isExecuteComplete) {
+          this.#isExecuteComplete = true;
+          await this.#cleanup("next");
+        }
+      }
+    });
+  }
+  next() {
+    return this.#next();
+  }
+  async return(value) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("return");
+    }
+    return { done: true, value };
+  }
+  async throw(err) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("throw");
+    }
+    throw err;
+  }
+  async[asyncDisposeSymbol]() {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("dispose");
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
+}
+function asyncIteratorWithSpan({ name, ...options }, iterator) {
+  let span;
+  return new AsyncIteratorClass(async () => {
+    span ??= startSpan(name);
+    try {
+      const result = await runInSpanContext(span, () => iterator.next());
+      span?.addEvent(result.done ? "completed" : "yielded");
+      return result;
+    } catch (err) {
+      setSpanError(span, err, options);
+      throw err;
+    }
+  }, async (reason) => {
+    try {
+      if (reason !== "next") {
+        await runInSpanContext(span, () => iterator.return?.());
+      }
+    } catch (err) {
+      setSpanError(span, err, options);
+      throw err;
+    } finally {
+      span?.end();
+    }
+  });
+}
+function intercept(interceptors, options, main) {
+  const next = (options2, index) => {
+    const interceptor = interceptors[index];
+    if (!interceptor) {
+      return main(options2);
+    }
+    return interceptor({
+      ...options2,
+      next: (newOptions = options2) => next(newOptions, index + 1)
+    });
+  };
+  return next(options, 0);
+}
+function parseEmptyableJSON(text) {
+  if (!text) {
+    return;
+  }
+  return JSON.parse(text);
+}
+function stringifyJSON(value) {
+  return JSON.stringify(value);
+}
+function getConstructor(value) {
+  if (!isTypescriptObject(value)) {
+    return null;
+  }
+  return Object.getPrototypeOf(value)?.constructor;
+}
+function isObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || !proto || !proto.constructor;
+}
+function isTypescriptObject(value) {
+  return !!value && (typeof value === "object" || typeof value === "function");
+}
+function setOwn(object, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(object, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+function copyOnWrite(parent, key, original) {
+  const value = parent[key];
+  if (value !== original) {
+    return value;
+  }
+  let copy;
+  if (Array.isArray(value)) {
+    copy = value.slice();
+  } else if (isObject(value)) {
+    copy = { ...value };
+  } else {
+    return value;
+  }
+  setOwn(parent, key, copy);
+  return copy;
+}
+function value(value2, ...args) {
+  if (typeof value2 === "function") {
+    return value2(...args);
+  }
+  return value2;
+}
+function preventNativeAwait(target) {
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      const value2 = Reflect.get(target2, prop, receiver);
+      if (prop !== "then" || typeof value2 !== "function") {
+        return value2;
+      }
+      return new Proxy(value2, {
+        apply(targetFn, thisArg, args) {
+          if (args.length !== 2 || args.some((arg) => !isNativeFunction(arg))) {
+            return Reflect.apply(targetFn, thisArg, args);
+          }
+          let shouldOmit = true;
+          args[0].call(thisArg, preventNativeAwait(new Proxy(target2, {
+            get: (target3, prop2, receiver2) => {
+              if (shouldOmit && prop2 === "then") {
+                shouldOmit = false;
+                return;
+              }
+              return Reflect.get(target3, prop2, receiver2);
+            }
+          })));
+        }
+      });
+    }
+  });
+}
+var NATIVE_FUNCTION_REGEX = /^\s*function\s*\(\)\s*\{\s*\[native code\]\s*\}\s*$/;
+function isNativeFunction(fn) {
+  return typeof fn === "function" && NATIVE_FUNCTION_REGEX.test(fn.toString());
+}
+var REGEXP_FLAGS = /^[dgimsuvy]*$/;
+function isValidRegExpFlags(flags) {
+  return REGEXP_FLAGS.test(flags) && new Set(flags).size === flags.length && !(flags.includes("u") && flags.includes("v"));
+}
+function createLazyRegExp(pattern, flags) {
+  let compiled;
+  let lastIndex = 0;
+  const compile = () => {
+    if (compiled === undefined) {
+      compiled = new RegExp(pattern, flags);
+      compiled.lastIndex = lastIndex;
+    }
+    return compiled;
+  };
+  return new Proxy(Object.create(RegExp.prototype), {
+    get(_, prop) {
+      if (prop === Symbol.toStringTag) {
+        return "RegExp";
+      }
+      if (compiled === undefined) {
+        if (prop === "lastIndex") {
+          return lastIndex;
+        }
+        if (!(prop in RegExp.prototype)) {
+          return;
+        }
+      }
+      const target = compile();
+      const value = Reflect.get(target, prop, target);
+      return typeof value === "function" && prop !== "constructor" ? value.bind(target) : value;
+    },
+    set(_, prop, value) {
+      if (compiled === undefined && prop === "lastIndex") {
+        lastIndex = value;
+        return true;
+      }
+      const target = compile();
+      return Reflect.set(target, prop, value, target);
+    },
+    has(_, prop) {
+      if (compiled === undefined) {
+        return prop === "lastIndex" || prop in RegExp.prototype;
+      }
+      return Reflect.has(compiled, prop);
+    }
+  });
+}
+function tryDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+// node_modules/@orpc/client/dist/shared/client.DeR0HTYb.mjs
+var ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+var ORPC_CLIENT_PACKAGE_VERSION = "1.16.2";
+var RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
+  "bind",
+  "valueOf",
+  "toString",
+  "toJSON"
+]);
+var COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+var globalORPCErrorConstructors;
+
+class ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  static {
+    const GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL = Symbol.for(`__${ORPC_CLIENT_PACKAGE_NAME}@${ORPC_CLIENT_PACKAGE_VERSION}/error/ORPC_ERROR_CONSTRUCTORS__`);
+    globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL] ??= /* @__PURE__ */ new WeakSet;
+    globalORPCErrorConstructors = globalThis[GLOBAL_ORPC_ERROR_CONSTRUCTORS_SYMBOL];
+    globalORPCErrorConstructors.add(ORPCError);
+  }
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (options.status !== undefined && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
+    }
+    const message = fallbackORPCErrorMessage(code, options.message);
+    super(message, options);
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options.status);
+    this.defined = options.defined ?? false;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  static [Symbol.hasInstance](instance) {
+    if (globalORPCErrorConstructors.has(this)) {
+      const constructor = getConstructor(instance);
+      if (constructor && globalORPCErrorConstructors.has(constructor)) {
+        return true;
+      }
+    }
+    return super[Symbol.hasInstance](instance);
+  }
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function isORPCErrorJson(json) {
+  if (!isObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "status", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
+// node_modules/@orpc/standard-server/dist/index.mjs
+class EventEncoderError extends TypeError {
+}
+
+class EventDecoderError extends TypeError {
+}
+
+class ErrorEvent extends Error {
+  data;
+  constructor(options) {
+    super(options?.message ?? "An error event was received", options);
+    this.data = options?.data;
+  }
+}
+var LINE_ENDING_REGEX$1 = /\r\n|\r(?!\n)|\n/;
+var MESSAGE_DELIMITER_REGEX = /(?:\r\n|\r(?!\n)|\n){2}/;
+var MESSAGE_DELIMITER_GLOBAL_REGEX = /(?:\r\n|\r(?!\n)|\n){2}/g;
+var CR = 13;
+var LF = 10;
+var SPACE = 32;
+function decodeEventMessage(encoded) {
+  const message = {
+    data: undefined,
+    event: undefined,
+    id: undefined,
+    retry: undefined,
+    comments: []
+  };
+  for (const line of encoded.split(LINE_ENDING_REGEX$1)) {
+    if (line === "") {
+      continue;
+    }
+    const index = line.indexOf(":");
+    const value = index === -1 ? "" : line.slice(line.charCodeAt(index + 1) === SPACE ? index + 2 : index + 1);
+    if (index === 0) {
+      message.comments.push(value);
+      continue;
+    }
+    switch (index === -1 ? line : line.slice(0, index)) {
+      case "data":
+        message.data = message.data === undefined ? value : `${message.data}
+${value}`;
+        break;
+      case "event":
+        message.event = value;
+        break;
+      case "id":
+        message.id = value;
+        break;
+      case "retry": {
+        const maybeInteger = Number.parseInt(value, 10);
+        if (maybeInteger >= 0 && maybeInteger.toString() === value) {
+          message.retry = maybeInteger;
+        }
+        break;
+      }
+    }
+  }
+  return message;
+}
+
+class EventDecoder {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  pending = [];
+  tail = "";
+  discardLeadingLF = false;
+  feed(chunk) {
+    if (chunk === "") {
+      return;
+    }
+    if (this.discardLeadingLF) {
+      this.discardLeadingLF = false;
+      if (chunk.charCodeAt(0) === LF) {
+        chunk = chunk.slice(1);
+        if (chunk === "") {
+          return;
+        }
+      }
+    }
+    const scan = this.tail + chunk;
+    if (!MESSAGE_DELIMITER_REGEX.test(scan)) {
+      this.pending.push(chunk);
+      this.tail = scan.slice(-3);
+      return;
+    }
+    this.pending.push(chunk);
+    const buffered = this.pending.length === 1 ? chunk : this.pending.join("");
+    const offset = buffered.length - scan.length;
+    const parts = [];
+    let start = 0;
+    for (const match of scan.matchAll(MESSAGE_DELIMITER_GLOBAL_REGEX)) {
+      parts.push(buffered.slice(start, offset + match.index));
+      start = offset + match.index + match[0].length;
+    }
+    const incomplete = buffered.slice(start);
+    this.pending.length = 0;
+    this.tail = incomplete.slice(-3);
+    if (incomplete === "") {
+      this.discardLeadingLF = chunk.charCodeAt(chunk.length - 1) === CR;
+    } else {
+      this.pending.push(incomplete);
+    }
+    for (const encoded of parts) {
+      const message = decodeEventMessage(encoded);
+      if (this.options.onEvent) {
+        this.options.onEvent(message);
+      }
+    }
+  }
+  end() {
+    if (this.pending.length !== 0) {
+      throw new EventDecoderError("Event Iterator ended before complete");
+    }
+  }
+}
+
+class EventDecoderStream extends TransformStream {
+  constructor() {
+    let decoder;
+    super({
+      start(controller) {
+        decoder = new EventDecoder({
+          onEvent: (event) => {
+            controller.enqueue(event);
+          }
+        });
+      },
+      transform(chunk) {
+        decoder.feed(chunk);
+      },
+      flush() {
+        decoder.end();
+      }
+    });
+  }
+}
+var LINE_ENDING_REGEX = /\r\n|[\n\r]/;
+var LINE_ENDING_GLOBAL_REGEX = /\r\n|[\n\r]/g;
+function containsLineBreak(value) {
+  return LINE_ENDING_REGEX.test(value);
+}
+function assertEventId(id) {
+  if (containsLineBreak(id)) {
+    throw new EventEncoderError("Event's id must not contain a carriage return or newline character");
+  }
+}
+function assertEventName(event) {
+  if (containsLineBreak(event)) {
+    throw new EventEncoderError("Event's event must not contain a carriage return or newline character");
+  }
+}
+function assertEventRetry(retry) {
+  if (!Number.isInteger(retry) || retry < 0) {
+    throw new EventEncoderError("Event's retry must be a integer and >= 0");
+  }
+}
+function assertEventComment(comment) {
+  if (containsLineBreak(comment)) {
+    throw new EventEncoderError("Event's comment must not contain a carriage return or newline character");
+  }
+}
+function encodeEventData(data) {
+  if (data === undefined) {
+    return "";
+  }
+  return `data: ${data.replace(LINE_ENDING_GLOBAL_REGEX, `
+data: `)}
+`;
+}
+function encodeEventComments(comments) {
+  let output = "";
+  for (const comment of comments ?? []) {
+    assertEventComment(comment);
+    output += `: ${comment}
+`;
+  }
+  return output;
+}
+function encodeEventMessage(message) {
+  let output = "";
+  output += encodeEventComments(message.comments);
+  if (message.event !== undefined) {
+    assertEventName(message.event);
+    output += `event: ${message.event}
+`;
+  }
+  if (message.retry !== undefined) {
+    assertEventRetry(message.retry);
+    output += `retry: ${message.retry}
+`;
+  }
+  if (message.id !== undefined) {
+    assertEventId(message.id);
+    output += `id: ${message.id}
+`;
+  }
+  output += encodeEventData(message.data);
+  output += `
+`;
+  return output;
+}
+var EVENT_SOURCE_META_SYMBOL = Symbol("ORPC_EVENT_SOURCE_META");
+function withEventMeta(container, meta) {
+  if (meta.id === undefined && meta.retry === undefined && !meta.comments?.length) {
+    return container;
+  }
+  if (meta.id !== undefined) {
+    assertEventId(meta.id);
+  }
+  if (meta.retry !== undefined) {
+    assertEventRetry(meta.retry);
+  }
+  if (meta.comments !== undefined) {
+    for (const comment of meta.comments) {
+      assertEventComment(comment);
+    }
+  }
+  return new Proxy(container, {
+    get(target, prop, receiver) {
+      if (prop === EVENT_SOURCE_META_SYMBOL) {
+        return meta;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getEventMeta(container) {
+  return isTypescriptObject(container) ? Reflect.get(container, EVENT_SOURCE_META_SYMBOL) : undefined;
+}
+function generateContentDisposition(filename, disposition = "inline") {
+  const encodedFileName = filename.replace(/[^\x20-\x7E]/g, "_").replace(/"/g, "\\\"");
+  const encodedFilenameStar = encodeURIComponent(filename).replace(/['()*]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`).replace(/%(7C|60|5E)/g, (str, hex) => String.fromCharCode(Number.parseInt(hex, 16)));
+  return `${disposition}; filename="${encodedFileName}"; filename*=utf-8''${encodedFilenameStar}`;
+}
+function getFilenameFromContentDisposition(contentDisposition) {
+  const encodedFilenameStarMatch = contentDisposition.match(/filename\*=(UTF-8'')?([^;]*)/i);
+  if (encodedFilenameStarMatch && typeof encodedFilenameStarMatch[2] === "string") {
+    return tryDecodeURIComponent(encodedFilenameStarMatch[2]);
+  }
+  const encodedFilenameMatch = contentDisposition.match(/filename="((?:\\"|[^"])*)"/i);
+  if (encodedFilenameMatch && typeof encodedFilenameMatch[1] === "string") {
+    return encodedFilenameMatch[1].replace(/\\"/g, '"');
+  }
+}
+function mergeStandardHeaders(a, b) {
+  const merged = { ...a };
+  for (const key in b) {
+    if (Array.isArray(b[key])) {
+      merged[key] = [...toArray(merged[key]), ...b[key]];
+    } else if (b[key] !== undefined) {
+      if (Array.isArray(merged[key])) {
+        merged[key] = [...merged[key], b[key]];
+      } else if (merged[key] !== undefined) {
+        merged[key] = [merged[key], b[key]];
+      } else {
+        merged[key] = b[key];
+      }
+    }
+  }
+  return merged;
+}
+
+// node_modules/@orpc/client/dist/shared/client.BLtwTQUg.mjs
+function mapEventIterator(iterator, maps) {
+  const mapError = async (error) => {
+    let mappedError = await maps.error(error);
+    if (mappedError !== error) {
+      const meta = getEventMeta(error);
+      if (meta && isTypescriptObject(mappedError)) {
+        mappedError = withEventMeta(mappedError, meta);
+      }
+    }
+    return mappedError;
+  };
+  return new AsyncIteratorClass(async () => {
+    const { done, value } = await (async () => {
+      try {
+        return await iterator.next();
+      } catch (error) {
+        throw await mapError(error);
+      }
+    })();
+    let mappedValue = await maps.value(value, done);
+    if (mappedValue !== value) {
+      const meta = getEventMeta(value);
+      if (meta && isTypescriptObject(mappedValue)) {
+        mappedValue = withEventMeta(mappedValue, meta);
+      }
+    }
+    return { done, value: mappedValue };
+  }, async () => {
+    try {
+      await iterator.return?.();
+    } catch (error) {
+      throw await mapError(error);
+    }
+  });
+}
+
+// node_modules/@orpc/client/dist/index.mjs
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+  };
+}
+function createORPCClient(link, options = {}) {
+  const path = options.path ?? [];
+  const procedureClient = async (...[input, options2 = {}]) => {
+    return await link.call(path, input, resolveFriendlyClientOptions(options2));
+  };
+  const recursive = new Proxy(procedureClient, {
+    get(target, key) {
+      if (typeof key !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
+        return Reflect.get(target, key);
+      }
+      return createORPCClient(link, {
+        ...options,
+        path: [...path, key]
+      });
+    }
+  });
+  return preventNativeAwait(recursive);
+}
+
+// node_modules/@orpc/standard-server-fetch/dist/index.mjs
+function toEventIterator(stream, options = {}) {
+  const eventStream = stream?.pipeThrough(new TextDecoderStream).pipeThrough(new EventDecoderStream);
+  const reader = eventStream?.getReader();
+  let span;
+  let isCancelled = false;
+  return new AsyncIteratorClass(async () => {
+    span ??= startSpan("consume_event_iterator_stream");
+    try {
+      while (true) {
+        if (reader === undefined) {
+          return { done: true, value: undefined };
+        }
+        const { done, value } = await runInSpanContext(span, () => reader.read());
+        if (done) {
+          if (isCancelled) {
+            throw new AbortError("Stream was cancelled");
+          }
+          return { done: true, value: undefined };
+        }
+        const event = value.event ?? (value.data !== undefined ? "message" : undefined);
+        switch (event) {
+          case "message": {
+            let message = parseEmptyableJSON(value.data);
+            if (isTypescriptObject(message)) {
+              message = withEventMeta(message, value);
+            }
+            span?.addEvent("message");
+            return { done: false, value: message };
+          }
+          case "error": {
+            let error = new ErrorEvent({
+              data: parseEmptyableJSON(value.data)
+            });
+            error = withEventMeta(error, value);
+            span?.addEvent("error");
+            throw error;
+          }
+          case "done":
+          case "close": {
+            let done2 = parseEmptyableJSON(value.data);
+            if (isTypescriptObject(done2)) {
+              done2 = withEventMeta(done2, value);
+            }
+            span?.addEvent("done");
+            return { done: true, value: done2 };
+          }
+          default: {
+            span?.addEvent("maybe_keepalive");
+          }
+        }
+      }
+    } catch (e) {
+      if (!(e instanceof ErrorEvent)) {
+        setSpanError(span, e, options);
+      }
+      throw e;
+    }
+  }, async (reason) => {
+    try {
+      if (reason !== "next") {
+        isCancelled = true;
+        span?.addEvent("cancelled");
+      }
+      await runInSpanContext(span, () => reader?.cancel());
+    } catch (e) {
+      setSpanError(span, e, options);
+      throw e;
+    } finally {
+      span?.end();
+    }
+  });
+}
+function toEventStream(iterator, options = {}) {
+  const keepAliveEnabled = options.eventIteratorKeepAliveEnabled ?? true;
+  const keepAliveInterval = options.eventIteratorKeepAliveInterval ?? 5000;
+  const keepAliveComment = options.eventIteratorKeepAliveComment ?? "";
+  const initialCommentEnabled = options.eventIteratorInitialCommentEnabled ?? true;
+  const initialComment = options.eventIteratorInitialComment ?? "";
+  let cancelled = false;
+  let timeout;
+  let span;
+  const stream = new ReadableStream({
+    start(controller) {
+      span = startSpan("stream_event_iterator");
+      if (initialCommentEnabled) {
+        controller.enqueue(encodeEventMessage({
+          comments: [initialComment]
+        }));
+      }
+    },
+    async pull(controller) {
+      try {
+        if (keepAliveEnabled) {
+          timeout = setInterval(() => {
+            controller.enqueue(encodeEventMessage({
+              comments: [keepAliveComment]
+            }));
+            span?.addEvent("keepalive");
+          }, keepAliveInterval);
+        }
+        const value = await runInSpanContext(span, () => iterator.next());
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        const meta = getEventMeta(value.value);
+        if (!value.done || value.value !== undefined || meta !== undefined) {
+          const event = value.done ? "done" : "message";
+          controller.enqueue(encodeEventMessage({
+            ...meta,
+            event,
+            data: stringifyJSON(value.value)
+          }));
+          span?.addEvent(event);
+        }
+        if (value.done) {
+          controller.close();
+          span?.end();
+        }
+      } catch (err) {
+        clearInterval(timeout);
+        if (cancelled) {
+          return;
+        }
+        if (err instanceof ErrorEvent) {
+          controller.enqueue(encodeEventMessage({
+            ...getEventMeta(err),
+            event: "error",
+            data: stringifyJSON(err.data)
+          }));
+          span?.addEvent("error");
+          controller.close();
+        } else {
+          setSpanError(span, err);
+          controller.error(err);
+        }
+        span?.end();
+      }
+    },
+    async cancel() {
+      try {
+        cancelled = true;
+        clearInterval(timeout);
+        span?.addEvent("cancelled");
+        await runInSpanContext(span, () => iterator.return?.());
+      } catch (e) {
+        setSpanError(span, e);
+        throw e;
+      } finally {
+        span?.end();
+      }
+    }
+  }).pipeThrough(new TextEncoderStream);
+  return stream;
+}
+function toStandardBody(re, options = {}) {
+  return runWithSpan({ name: "parse_standard_body", signal: options.signal }, async () => {
+    const contentDisposition = re.headers.get("content-disposition");
+    if (typeof contentDisposition === "string") {
+      const fileName = getFilenameFromContentDisposition(contentDisposition) ?? "blob";
+      const blob2 = await re.blob();
+      return new File([blob2], fileName, {
+        type: blob2.type
+      });
+    }
+    const contentType = re.headers.get("content-type");
+    if (!contentType || contentType.startsWith("application/json")) {
+      const text = await re.text();
+      return parseEmptyableJSON(text);
+    }
+    if (contentType.startsWith("multipart/form-data")) {
+      return await re.formData();
+    }
+    if (contentType.startsWith("application/x-www-form-urlencoded")) {
+      const text = await re.text();
+      return new URLSearchParams(text);
+    }
+    if (contentType.startsWith("text/event-stream")) {
+      return toEventIterator(re.body, options);
+    }
+    if (contentType.startsWith("text/plain")) {
+      return await re.text();
+    }
+    const blob = await re.blob();
+    return new File([blob], "blob", {
+      type: blob.type
+    });
+  });
+}
+function toFetchBody(body, headers, options = {}) {
+  if (body instanceof ReadableStream) {
+    return body;
+  }
+  const currentContentDisposition = headers.get("content-disposition");
+  headers.delete("content-type");
+  headers.delete("content-disposition");
+  if (body === undefined) {
+    return;
+  }
+  if (body instanceof Blob) {
+    headers.set("content-type", body.type);
+    headers.set("content-length", body.size.toString());
+    headers.set("content-disposition", currentContentDisposition ?? generateContentDisposition(body instanceof File ? body.name : "blob"));
+    return body;
+  }
+  if (body instanceof FormData) {
+    return body;
+  }
+  if (body instanceof URLSearchParams) {
+    return body;
+  }
+  if (isAsyncIteratorObject(body)) {
+    headers.set("content-type", "text/event-stream");
+    return toEventStream(body, options);
+  }
+  headers.set("content-type", "application/json");
+  return stringifyJSON(body);
+}
+function toStandardHeaders(headers, standardHeaders = {}) {
+  headers.forEach((value, key) => {
+    if (Array.isArray(standardHeaders[key])) {
+      standardHeaders[key].push(value);
+    } else if (standardHeaders[key] !== undefined) {
+      standardHeaders[key] = [standardHeaders[key], value];
+    } else {
+      standardHeaders[key] = value;
+    }
+  });
+  return standardHeaders;
+}
+function toFetchHeaders(headers, fetchHeaders = new Headers) {
+  for (const [key, value] of Object.entries(headers)) {
+    if (Array.isArray(value)) {
+      for (const v of value) {
+        fetchHeaders.append(key, v);
+      }
+    } else if (value !== undefined) {
+      fetchHeaders.append(key, value);
+    }
+  }
+  return fetchHeaders;
+}
+function toFetchRequest(request, options = {}) {
+  const headers = toFetchHeaders(request.headers);
+  const body = toFetchBody(request.body, headers, options);
+  return new Request(request.url, {
+    signal: request.signal,
+    method: request.method,
+    headers,
+    body
+  });
+}
+function toStandardLazyResponse(response, options = {}) {
+  return {
+    body: once(() => toStandardBody(response, options)),
+    status: response.status,
+    get headers() {
+      const headers = toStandardHeaders(response.headers);
+      Object.defineProperty(this, "headers", { value: headers, writable: true });
+      return headers;
+    },
+    set headers(value) {
+      Object.defineProperty(this, "headers", { value, writable: true });
+    }
+  };
+}
+
+// node_modules/@orpc/client/dist/shared/client.BmCiDGqJ.mjs
+class CompositeStandardLinkPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
+
+class StandardLink {
+  constructor(codec, sender, options = {}) {
+    this.codec = codec;
+    this.sender = sender;
+    const plugin = new CompositeStandardLinkPlugin(options.plugins);
+    plugin.init(options);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
+  }
+  interceptors;
+  clientInterceptors;
+  call(path, input, options) {
+    return runWithSpan({ name: `${ORPC_NAME}.${path.join("/")}`, signal: options.signal }, (span) => {
+      span?.setAttribute("rpc.system", ORPC_NAME);
+      span?.setAttribute("rpc.method", path.join("."));
+      if (isAsyncIteratorObject(input)) {
+        input = asyncIteratorWithSpan({ name: "consume_event_iterator_input", signal: options.signal }, input);
+      }
+      return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+        const otelConfig = getGlobalOtelConfig();
+        let otelContext;
+        const currentSpan = otelConfig?.trace.getActiveSpan() ?? span;
+        if (currentSpan && otelConfig) {
+          otelContext = otelConfig?.trace.setSpan(otelConfig.context.active(), currentSpan);
+        }
+        const request = await runWithSpan({ name: "encode_request", context: otelContext }, () => this.codec.encode(path2, input2, options2));
+        const response = await intercept(this.clientInterceptors, { ...options2, input: input2, path: path2, request }, ({ input: input3, path: path3, request: request2, ...options3 }) => {
+          return runWithSpan({ name: "send_request", signal: options3.signal, context: otelContext }, () => this.sender.call(request2, options3, path3, input3));
+        });
+        const output = await runWithSpan({ name: "decode_response", context: otelContext }, () => this.codec.decode(response, options2, path2, input2));
+        if (isAsyncIteratorObject(output)) {
+          return asyncIteratorWithSpan({ name: "consume_event_iterator_output", signal: options2.signal }, output);
+        }
+        return output;
+      });
+    });
+  }
+}
+var STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES = {
+  BIGINT: 0,
+  DATE: 1,
+  NAN: 2,
+  UNDEFINED: 3,
+  URL: 4,
+  REGEXP: 5,
+  SET: 6,
+  MAP: 7
+};
+var BUILT_IN_TYPES = new Set(Object.values(STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES));
+var SERIALIZED_REGEXP_FORMAT = /^\/(.*)\/([a-z]*)$/;
+function invalidSerializedData(detail) {
+  return new TypeError(`Invalid RPC serialized data: ${detail}`);
+}
+function invalidSerializedType(type, name, expected) {
+  return invalidSerializedData(`type ${type} (${name}) expects ${expected}.`);
+}
+
+class StandardRPCJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+    if (this.customSerializers.length !== new Set(this.customSerializers.map((custom) => custom.type)).size) {
+      throw new Error("Custom serializer type must be unique.");
+    }
+  }
+  serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), segments, meta, maps, blobs);
+        meta.push([custom.type, ...segments]);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, meta, maps, blobs];
+    }
+    if (typeof data === "bigint") {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Date) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE, ...segments]);
+      if (Number.isNaN(data.getTime())) {
+        return [null, meta, maps, blobs];
+      }
+      return [data.toISOString(), meta, maps, blobs];
+    }
+    if (Number.isNaN(data)) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, ...segments]);
+      return [null, meta, maps, blobs];
+    }
+    if (data instanceof URL) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof RegExp) {
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP, ...segments]);
+      return [data.toString(), meta, maps, blobs];
+    }
+    if (data instanceof Set) {
+      const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET, ...segments]);
+      return result;
+    }
+    if (data instanceof Map) {
+      const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP, ...segments]);
+      return result;
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v, i) => {
+        if (v === undefined) {
+          meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED, ...segments, i]);
+          return null;
+        }
+        return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
+      });
+      return [json, meta, maps, blobs];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
+        json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
+      }
+      return [json, meta, maps, blobs];
+    }
+    return [data, meta, maps, blobs];
+  }
+  deserialize(json, meta, maps, getBlob) {
+    const ref = { data: json };
+    const input = { data: json };
+    if (maps && getBlob) {
+      maps.forEach((segments, i) => {
+        const blob = getBlob(i);
+        if (!(blob instanceof Blob)) {
+          throw invalidSerializedData(`blob ${i} is not a Blob.`);
+        }
+        let original = input;
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          original = original[preSegment];
+          currentRef = copyOnWrite(currentRef, preSegment, original);
+          preSegment = segment;
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw invalidSerializedData(`segment "${preSegment}" does not exist.`);
+          }
+        });
+        currentRef[preSegment] = blob;
+      });
+    }
+    for (const item of meta) {
+      const type = item[0];
+      const custom = this.customSerializers.find((custom2) => custom2.type === type);
+      if (custom === undefined && !BUILT_IN_TYPES.has(type)) {
+        continue;
+      }
+      let original = input;
+      let currentRef = ref;
+      let preSegment = "data";
+      for (let i = 1;i < item.length; i++) {
+        original = original[preSegment];
+        currentRef = copyOnWrite(currentRef, preSegment, original);
+        preSegment = item[i];
+        if (!Object.hasOwn(currentRef, preSegment)) {
+          throw invalidSerializedData(`segment "${preSegment}" does not exist.`);
+        }
+      }
+      if (custom !== undefined) {
+        currentRef[preSegment] = custom.deserialize(currentRef[preSegment]);
+        continue;
+      }
+      const serialized = currentRef[preSegment];
+      switch (type) {
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT: {
+          if (typeof serialized !== "string") {
+            throw invalidSerializedType(type, "bigint", "a string");
+          }
+          const value = parseBigIntString(serialized, DEFAULT_MAX_BIGINT_DIGITS);
+          if (value === undefined) {
+            throw invalidSerializedType(type, "bigint", `a decimal integer string of at most ${DEFAULT_MAX_BIGINT_DIGITS} digits`);
+          }
+          currentRef[preSegment] = value;
+          break;
+        }
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE:
+          if (typeof serialized !== "string" && serialized !== null) {
+            throw invalidSerializedType(type, "date", "a string or null");
+          }
+          currentRef[preSegment] = new Date(serialized ?? Number.NaN);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN:
+          if (serialized !== null) {
+            throw invalidSerializedType(type, "nan", "null");
+          }
+          currentRef[preSegment] = Number.NaN;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED:
+          if (serialized !== null) {
+            throw invalidSerializedType(type, "undefined", "null");
+          }
+          currentRef[preSegment] = undefined;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL:
+          if (typeof serialized !== "string") {
+            throw invalidSerializedType(type, "url", "a string");
+          }
+          currentRef[preSegment] = new URL(serialized);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP: {
+          if (typeof serialized !== "string") {
+            throw invalidSerializedType(type, "regexp", "a string");
+          }
+          const match = serialized.match(SERIALIZED_REGEXP_FORMAT);
+          if (match === null || !isValidRegExpFlags(match[2])) {
+            throw invalidSerializedData(`type ${type} (regexp) expects a "/pattern/flags" string.`);
+          }
+          currentRef[preSegment] = createLazyRegExp(match[1], match[2]);
+          break;
+        }
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET:
+          if (!Array.isArray(serialized)) {
+            throw invalidSerializedType(type, "set", "an array");
+          }
+          currentRef[preSegment] = new Set(serialized);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP:
+          if (!Array.isArray(serialized)) {
+            throw invalidSerializedType(type, "map", "an array");
+          }
+          currentRef[preSegment] = new Map(serialized);
+          break;
+      }
+    }
+    return ref.data;
+  }
+}
+function toHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
+function toStandardHeaders2(headers) {
+  if (typeof headers.forEach === "function") {
+    return toStandardHeaders(headers);
+  }
+  return headers;
+}
+function getMalformedResponseErrorCode(status) {
+  return Object.entries(COMMON_ORPC_ERROR_DEFS).find(([, def]) => def.status === status)?.[0] ?? "MALFORMED_ORPC_ERROR_RESPONSE";
+}
+
+class StandardRPCLinkCodec {
+  constructor(serializer, options) {
+    this.serializer = serializer;
+    this.baseUrl = options.url;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+  }
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  async encode(path, input, options) {
+    let headers = toStandardHeaders2(await value(this.headers, options, path, input));
+    if (options.lastEventId !== undefined) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const expectedMethod = await value(this.expectedMethod, options, path, input);
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const url = new URL(baseUrl);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${toHttpPath(path)}`;
+    const serialized = this.serializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
+      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(serialized));
+      if (getUrl.toString().length <= maxUrlLength) {
+        return {
+          body: undefined,
+          method: expectedMethod,
+          headers,
+          url: getUrl,
+          signal: options.signal
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decode(response) {
+    if (response.status >= 300 && response.status < 400) {
+      throw new Error(`Unexpected redirect response (status ${response.status}): RPCLink does not follow redirects.`);
+    }
+    const isOk = !isORPCErrorStatus(response.status);
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.body();
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid RPC response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        throw createORPCErrorFromJson(deserialized);
+      }
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: { ...response, body: deserialized }
+      });
+    }
+    return deserialized;
+  }
+}
+
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, false),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), false),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, true);
+  }
+  #serialize(data, enableFormData) {
+    const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
+    const meta = meta_.length === 0 ? undefined : meta_;
+    if (!enableFormData || blobs.length === 0) {
+      return {
+        json,
+        meta
+      };
+    }
+    const form = new FormData;
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#deserialize(value),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.#deserialize(e.data);
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#deserialize(data);
+  }
+  #deserialize(data) {
+    if (data === undefined) {
+      return;
+    }
+    if (!(data instanceof FormData)) {
+      return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    return this.jsonSerializer.deserialize(serialized.json, serialized.meta ?? [], serialized.maps, (i) => data.get(i.toString()));
+  }
+}
+
+class StandardRPCLink extends StandardLink {
+  constructor(linkClient, options) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const linkCodec = new StandardRPCLinkCodec(serializer, options);
+    super(linkCodec, linkClient, options);
+  }
+}
+
+// node_modules/@orpc/client/dist/adapters/fetch/index.mjs
+class CompositeLinkFetchPlugin extends CompositeStandardLinkPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
+
+class LinkFetchClient {
+  fetch;
+  toFetchRequestOptions;
+  adapterInterceptors;
+  constructor(options) {
+    const plugin = new CompositeLinkFetchPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.toFetchRequestOptions = options;
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+  }
+  async call(standardRequest, options, path, input) {
+    const request = toFetchRequest(standardRequest, this.toFetchRequestOptions);
+    const fetchResponse = await intercept(this.adapterInterceptors, { ...options, request, path, input, init: { redirect: "manual" } }, ({ request: request2, path: path2, input: input2, init, ...options2 }) => this.fetch(request2, init, options2, path2, input2));
+    const lazyResponse = toStandardLazyResponse(fetchResponse, { signal: request.signal });
+    return lazyResponse;
+  }
+}
+
+class RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new LinkFetchClient(options);
+    super(linkClient, options);
+  }
+}
+
+// app/lib/github.ts
+var NAME = /^[A-Za-z0-9_.-]+$/;
+function parseGitHubRemote(remote) {
+  const text = remote.trim();
+  let path = null;
+  const scp = /^(?:[A-Za-z0-9_.-]+@)?github\.com:(.+)$/i.exec(text);
+  if (scp) {
+    path = scp[1];
+  } else {
+    try {
+      const url = new URL(text);
+      if (!["https:", "http:", "ssh:", "git:"].includes(url.protocol))
+        return null;
+      if (url.hostname.toLowerCase() !== "github.com" && url.hostname.toLowerCase() !== "www.github.com")
+        return null;
+      path = url.pathname;
+    } catch {
+      return null;
+    }
+  }
+  const parts = path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "").split("/");
+  if (parts.length !== 2)
+    return null;
+  const [owner, name] = parts;
+  if (!NAME.test(owner) || !NAME.test(name) || name === "." || name === "..")
+    return null;
+  return `${owner}/${name}`;
+}
+
+// cli/github-read.ts
+import { execFile } from "node:child_process";
+var ISSUE_LIMIT = 300;
+var PR_LIMIT = 200;
+var ISSUE_FIELDS = "number,title,state,labels,url";
+var PR_FIELDS = "number,title,state,isDraft,headRefOid,headRefName,baseRefName,labels,closingIssuesReferences,author,url,mergeCommit";
+function mapIssue(i) {
+  return { number: i.number, title: i.title, state: i.state === "OPEN" ? "open" : "closed", labels: i.labels.map((l) => l.name), url: i.url };
+}
+function mapPullRequest(p, repo) {
+  const sameRepo = (url) => url === undefined || url.toLowerCase().startsWith(`https://github.com/${repo.toLowerCase()}/`);
+  return {
+    number: p.number,
+    title: p.title,
+    state: p.state === "MERGED" ? "merged" : p.state === "OPEN" ? "open" : "closed",
+    draft: p.isDraft,
+    headSha: p.headRefOid,
+    headRef: p.headRefName,
+    baseRef: p.baseRefName,
+    labels: p.labels.map((l) => l.name),
+    closingIssues: p.closingIssuesReferences.filter((r) => sameRepo(r.url)).map((r) => r.number),
+    author: p.author?.login ?? "",
+    url: p.url,
+    mergeCommit: p.mergeCommit?.oid ?? null
+  };
+}
+function gh(args) {
+  return new Promise((resolve, reject) => {
+    execFile("gh", args, { maxBuffer: 64 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error)
+        reject(new Error(`gh ${args.slice(0, 2).join(" ")} failed: ${(stderr || error.message).trim()}`));
+      else
+        resolve(stdout);
+    });
+  });
+}
+async function readGitHub(repo) {
+  const [issues, prs] = await Promise.all([
+    gh(["issue", "list", "--repo", repo, "--state", "all", "--limit", String(ISSUE_LIMIT), "--json", ISSUE_FIELDS]),
+    gh(["pr", "list", "--repo", repo, "--state", "all", "--limit", String(PR_LIMIT), "--json", PR_FIELDS])
+  ]);
+  return {
+    issues: JSON.parse(issues).map(mapIssue),
+    pullRequests: JSON.parse(prs).map((p) => mapPullRequest(p, repo))
+  };
+}
+
+// cli/repo.ts
+import { execFileSync, spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var HOOKS = ["setup", "check", "deploy"];
+
+class ConfigError extends Error {
+}
+function repoRoot(cwd = process.cwd()) {
+  try {
+    return execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function checkoutRepo(cwd = process.cwd()) {
+  try {
+    const url = execFileSync("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    return parseGitHubRemote(url);
+  } catch {
+    return null;
+  }
+}
+function parseRepoConfig(text, file = ".ahfact.json") {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new ConfigError(`${file} is not valid JSON: ${error.message}`);
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+    throw new ConfigError(`${file} must be a JSON object.`);
+  const obj = raw;
+  const config = { hooks: {} };
+  if (obj["project"] !== undefined) {
+    if (typeof obj["project"] !== "string")
+      throw new ConfigError(`${file}: "project" must be a string.`);
+    config.project = obj["project"];
+  }
+  const hooks = obj["hooks"] ?? {};
+  if (typeof hooks !== "object" || hooks === null || Array.isArray(hooks))
+    throw new ConfigError(`${file}: "hooks" must be an object.`);
+  for (const [name, command] of Object.entries(hooks)) {
+    if (!HOOKS.includes(name)) {
+      throw new ConfigError(`${file}: unknown hook "${name}". Known hooks: ${HOOKS.join(", ")}.`);
+    }
+    if (typeof command !== "string" || command.trim() === "")
+      throw new ConfigError(`${file}: hook "${name}" must be a command string.`);
+    config.hooks[name] = command;
+  }
+  return config;
+}
+async function loadRepoConfig(root) {
+  const file = join(root, ".ahfact.json");
+  let text;
+  try {
+    text = await readFile(file, "utf8");
+  } catch {
+    return { hooks: {} };
+  }
+  return parseRepoConfig(text, file);
+}
+var TAIL_LINES = 40;
+function runHook(root, hook, command, env = {}) {
+  const started = Date.now();
+  return new Promise((resolve) => {
+    const child = spawn("sh", ["-c", command], { cwd: root, env: { ...process.env, ...env }, stdio: ["ignore", "pipe", "pipe"] });
+    let output = "";
+    const collect = (chunk) => {
+      process.stderr.write(chunk);
+      output = (output + chunk.toString("utf8")).slice(-64000);
+    };
+    child.stdout.on("data", collect);
+    child.stderr.on("data", collect);
+    child.on("close", (code) => {
+      const exitCode = code ?? 1;
+      const tail = output.trimEnd().split(`
+`).slice(-TAIL_LINES).join(`
+`);
+      resolve({ hook, command, ok: exitCode === 0, exitCode, durationMs: Date.now() - started, tail });
+    });
+    child.on("error", (error) => {
+      resolve({ hook, command, ok: false, exitCode: 127, durationMs: Date.now() - started, tail: error.message });
+    });
+  });
+}
+
+// cli/ahfact.ts
+var DEFAULT_SERVER = "https://ahfact.com";
+var sleep = (ms) => new Promise((done) => setTimeout(done, ms));
+var HELP = `ahfact: work with the Astrohacker Factory from the command line.
+
+You, once per computer:
+  ahfact login [--machine M]           sign the CLI in; approve the code in the browser
+  ahfact logout                        revoke this computer's CLI token
+  ahfact whoami                        who the CLI acts as, and this checkout's project and worker
+
+Projects (a project is a GitHub repository):
+  ahfact project add [--slug S] [--name N] [--repo OWNER/NAME]
+                                       register this checkout's origin (or --repo)
+  ahfact project show                  this checkout's project
+  ahfact project list
+
+Workers (one per project, harness and computer):
+  ahfact worker start --harness H [--machine M]
+                                       create or reuse this checkout's worker and save its token
+  ahfact worker whoami                 the worker this checkout's commands act as
+  ahfact sync [--force]                read this project's GitHub issues and PRs with gh and report them;
+                                       ahfact.com turns them into jobs (one worker at a time, every 60s)
+  ahfact wait [--timeout SECONDS] [--no-sync]
+                                       sync when due, then lease the next job; repeat until one comes
+  ahfact next [--wait SECONDS]         one attempt, waiting at most 55 seconds; prints null if none
+  ahfact leases                        the worker's live leases, to resume after a restart
+  ahfact heartbeat                     say "still here"
+
+This checkout (hooks from .ahfact.json):
+  ahfact setup                         run the setup hook, such as installing dependencies
+  ahfact check                         run the check hook; prints {ok, exitCode, durationMs, tail}
+
+Jobs:
+  ahfact job create --kind K --subject S --title T [--harness H] [--machine M] [--exclude AGENT]...
+
+Subagents, for the lease they hold:
+  ahfact log LEASE MESSAGE             report progress; renews the lease
+  ahfact renew LEASE                   renew without a message
+  ahfact ref LEASE AGENT_ID            record the harness's id for this subagent
+  ahfact done LEASE [MESSAGE]          the job is finished
+  ahfact release LEASE [MESSAGE]       hand the job back to the queue
+
+Options and environment:
+  --server URL / AHFACT_URL            the factory (default ${DEFAULT_SERVER})
+  --worker NAME / AHFACT_WORKER        act as this worker
+  --harness H / AHFACT_HARNESS         pick this checkout's worker by harness
+  --machine M / AHFACT_MACHINE         this computer's short name (default: the one given at login)
+Credentials live in ~/.config/ahfact/, mode 0600.`;
+
+class UsageError extends Error {
+}
+function configDir() {
+  return join2(process.env["XDG_CONFIG_HOME"] ?? join2(homedir(), ".config"), "ahfact");
+}
+function hostOf(server) {
+  return new URL(server).host.replace(/[^A-Za-z0-9.-]/g, "_");
+}
+async function writePrivate(file, value) {
+  await mkdir(join2(file, ".."), { recursive: true, mode: 448 });
+  await writeFile(file, JSON.stringify(value, null, 2) + `
+`, { mode: 384 });
+  await chmod(file, 384);
+}
+async function readJson(file) {
+  try {
+    return JSON.parse(await readFile2(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+var personFile = (server) => join2(configDir(), "people", `${hostOf(server)}.json`);
+var workerFile = (worker) => join2(configDir(), "workers", `${worker}.json`);
+async function loadPerson(server) {
+  const cred = await readJson(personFile(server));
+  if (cred === null || cred.server !== server)
+    throw new UsageError(`Not signed in to ${server}. Run: ahfact login`);
+  return cred;
+}
+async function allWorkers(server) {
+  let files = [];
+  try {
+    files = (await readdir(join2(configDir(), "workers"))).filter((f) => f.endsWith(".json"));
+  } catch {}
+  const creds = [];
+  for (const f of files) {
+    const cred = await readJson(join2(configDir(), "workers", f));
+    if (cred !== null && cred.server === server)
+      creds.push(cred);
+  }
+  return creds;
+}
+function requireRepo(explicit) {
+  if (explicit) {
+    const repo = parseGitHubRemote(explicit) ?? (/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(explicit) ? explicit : null);
+    if (repo === null)
+      throw new UsageError(`Not a GitHub repository: ${explicit}`);
+    return repo;
+  }
+  const repo = checkoutRepo();
+  if (repo === null)
+    throw new UsageError("This directory has no GitHub origin. Run in a checkout, or pass --repo OWNER/NAME.");
+  return repo;
+}
+async function loadWorker(server, opts) {
+  const all = await allWorkers(server);
+  const named = opts.worker ?? process.env["AHFACT_WORKER"];
+  if (named) {
+    const found = all.find((c) => c.worker === named);
+    if (!found)
+      throw new UsageError(`Worker ${named} has no saved token for ${server}. Run: ahfact worker start --harness H`);
+    return found;
+  }
+  const repo = checkoutRepo();
+  const harness = opts.harness ?? process.env["AHFACT_HARNESS"];
+  let candidates = repo === null ? all : all.filter((c) => c.repo.toLowerCase() === repo.toLowerCase());
+  if (harness)
+    candidates = candidates.filter((c) => c.harness === harness);
+  if (candidates.length === 1)
+    return candidates[0];
+  if (candidates.length === 0) {
+    throw new UsageError(`No worker for ${repo ?? "this directory"}${harness ? ` on ${harness}` : ""}. Run: ahfact worker start --harness H`);
+  }
+  throw new UsageError(`Several workers match (${candidates.map((c) => c.worker).join(", ")}). Pick one with --worker, AHFACT_WORKER or AHFACT_HARNESS.`);
+}
+function client(server, token) {
+  const link = new RPCLink({
+    url: `${server}/rpc`,
+    headers: () => token ? { authorization: `Bearer ${token}` } : {}
+  });
+  return createORPCClient(link);
+}
+function print(value) {
+  process.stdout.write(JSON.stringify(value, null, 2) + `
+`);
+}
+function hint(text) {
+  process.stderr.write(text + `
+`);
+}
+function defaultMachine() {
+  return (process.env["AHFACT_MACHINE"] ?? hostname().split(".")[0]).toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32);
+}
+async function login(server, machineFlag) {
+  const machine = machineFlag ?? defaultMachine();
+  const api = client(server);
+  const started = await api.device.start({ machine });
+  hint(`To sign in the ahfact CLI on ${machine}, open:
+
+  ${started.verificationUrl}
+
+and check the code is ${started.userCode}. Waiting for approval…`);
+  for (;; ) {
+    if (Date.now() > new Date(started.expiresAt).getTime())
+      throw new UsageError("The sign-in request expired. Run login again.");
+    await sleep(started.interval * 1000);
+    const polled = await api.device.poll({ deviceCode: started.deviceCode });
+    if (polled.status === "pending")
+      continue;
+    if (polled.status !== "approved")
+      throw new UsageError(`Sign-in ${polled.status}.`);
+    const file = personFile(server);
+    await writePrivate(file, { server, email: polled.email, machine, token: polled.token });
+    hint(`Signed in as ${polled.email}. Token saved to ${file}.`);
+    print({ email: polled.email, machine, server });
+    return;
+  }
+}
+var str = (values, key) => {
+  const v = values[key];
+  return typeof v === "string" ? v : undefined;
+};
+async function main(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      server: { type: "string" },
+      worker: { type: "string" },
+      repo: { type: "string" },
+      slug: { type: "string" },
+      name: { type: "string" },
+      harness: { type: "string" },
+      machine: { type: "string" },
+      wait: { type: "string" },
+      timeout: { type: "string" },
+      kind: { type: "string" },
+      subject: { type: "string" },
+      title: { type: "string" },
+      exclude: { type: "string", multiple: true },
+      force: { type: "boolean" },
+      "no-sync": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  const [command, sub, ...rest] = positionals;
+  if (values.help || command === undefined || command === "help") {
+    hint(HELP);
+    return;
+  }
+  const server = (str(values, "server") ?? process.env["AHFACT_URL"] ?? DEFAULT_SERVER).replace(/\/+$/, "");
+  const asPerson = async () => client(server, (await loadPerson(server)).token);
+  const workerCred = () => loadWorker(server, { worker: values.worker, harness: values.harness });
+  const asWorker = async () => client(server, (await workerCred()).token);
+  const syncOnce = async (cred, force) => {
+    const api = client(server, cred.token);
+    const turn = await api.worker.syncBegin({ force });
+    if (!turn.due)
+      return { synced: false, ...turn };
+    const seen = await readGitHub(cred.repo);
+    const result = await api.worker.syncReport(seen);
+    return { synced: true, ...result };
+  };
+  const leaseArgs = [sub, ...rest];
+  const leaseId = () => {
+    const id = leaseArgs[0];
+    if (!id)
+      throw new UsageError(`${command} needs a lease id.`);
+    return id;
+  };
+  const message = (from) => leaseArgs.slice(from).join(" ");
+  switch (command) {
+    case "login":
+      return login(server, values.machine);
+    case "logout": {
+      const cred = await readJson(personFile(server));
+      if (cred !== null) {
+        try {
+          await client(server, cred.token).auth.logout();
+        } catch {}
+        await rm(personFile(server), { force: true });
+      }
+      return print({ signedOut: cred !== null, server });
+    }
+    case "setup":
+    case "check": {
+      const root = repoRoot();
+      if (root === null)
+        throw new UsageError(`${command} runs in a Git checkout.`);
+      const config = await loadRepoConfig(root);
+      const hook = command;
+      const script = config.hooks[hook];
+      if (!script)
+        throw new UsageError(`${root}/.ahfact.json has no "${hook}" hook.`);
+      hint(`ahfact ${hook}: ${script}`);
+      const result = await runHook(root, hook, script);
+      print(result);
+      if (!result.ok)
+        process.exit(1);
+      return;
+    }
+    case "whoami": {
+      const cred = await readJson(personFile(server));
+      const person = cred === null ? null : await client(server, cred.token).auth.me().catch(() => null);
+      const repo = checkoutRepo();
+      const workers = (await allWorkers(server)).filter((c) => repo !== null && c.repo.toLowerCase() === repo.toLowerCase());
+      return print({ server, person: person && { email: person.email, machine: cred.machine }, repo, workers: workers.map((w) => w.worker) });
+    }
+    case "project": {
+      const api = await asPerson();
+      if (sub === "add") {
+        return print(await api.projects.add({ repo: requireRepo(values.repo), slug: values.slug, name: values.name }));
+      }
+      if (sub === "show")
+        return print(await api.projects.get({ repo: requireRepo(values.repo) }));
+      if (sub === "list")
+        return print(await api.projects.list());
+      throw new UsageError("Usage: ahfact project add|show|list");
+    }
+    case "worker": {
+      if (sub === "whoami")
+        return print(await (await asWorker()).worker.whoami());
+      if (sub !== "start")
+        throw new UsageError("Usage: ahfact worker start --harness H | ahfact worker whoami");
+      const cred = await loadPerson(server);
+      const harness = values.harness ?? process.env["AHFACT_HARNESS"];
+      if (!harness)
+        throw new UsageError("worker start needs --harness (claude, codex, grok, …) or AHFACT_HARNESS.");
+      const machine = values.machine ?? process.env["AHFACT_MACHINE"] ?? cred.machine;
+      const repo = requireRepo(values.repo);
+      const started = await client(server, cred.token).workers.start({ project: { repo }, harness, machine });
+      const file = workerFile(started.worker);
+      await writePrivate(file, { server, worker: started.worker, token: started.token, repo, harness, machine });
+      hint(`Worker ${started.worker} is ready. Token saved to ${file}. Next: ahfact wait`);
+      return print({ worker: started.worker, repo, harness, machine });
+    }
+    case "heartbeat":
+      return print(await (await asWorker()).worker.heartbeat());
+    case "leases":
+      return print(await (await asWorker()).worker.leases());
+    case "next":
+      return print(await (await asWorker()).worker.next({ wait: Number(values.wait ?? 0) }));
+    case "sync": {
+      const cred = await workerCred();
+      return print(await syncOnce(cred, values.force === true));
+    }
+    case "wait": {
+      const cred = await workerCred();
+      const api = client(server, cred.token);
+      const timeout = values.timeout === undefined ? Infinity : Number(values.timeout) * 1000;
+      const deadline = Date.now() + timeout;
+      for (;; ) {
+        if (!values["no-sync"]) {
+          try {
+            const result = await syncOnce(cred, false);
+            if (result.synced && result.applied.length > 0) {
+              hint(`ahfact: synced GitHub: ${result.applied.map((a) => `${a.type} ${a.subject}`).join(", ")}`);
+            }
+          } catch (error) {
+            hint(`ahfact: sync failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        }
+        const left = Math.ceil((deadline - Date.now()) / 1000);
+        const claim = await api.worker.next({ wait: Math.max(0, Math.min(55, left)) });
+        if (claim !== null)
+          return print(claim);
+        if (Date.now() >= deadline)
+          return print(null);
+      }
+    }
+    case "job": {
+      if (sub !== "create")
+        throw new UsageError("Usage: ahfact job create --kind K --subject S --title T");
+      if (!values.kind || !values.subject || !values.title)
+        throw new UsageError("job create needs --kind, --subject and --title.");
+      const job = {
+        kind: values.kind,
+        subject: values.subject,
+        title: values.title,
+        requirements: { harness: values.harness, machine: values.machine },
+        excludedAgents: values.exclude ?? []
+      };
+      if (values.worker ?? process.env["AHFACT_WORKER"])
+        return print(await (await asWorker()).worker.createJob(job));
+      return print(await (await asPerson()).jobs.create({ ...job, project: { repo: requireRepo(values.repo) } }));
+    }
+    case "log": {
+      const text = message(1);
+      if (text === "")
+        throw new UsageError("log needs a message.");
+      return print(await (await asWorker()).lease.log({ leaseId: leaseId(), message: text }));
+    }
+    case "renew":
+      return print(await (await asWorker()).lease.renew({ leaseId: leaseId() }));
+    case "ref": {
+      const ref = leaseArgs[1];
+      if (!ref)
+        throw new UsageError("ref needs the subagent's id.");
+      return print(await (await asWorker()).lease.setAgentRef({ leaseId: leaseId(), ref }));
+    }
+    case "done":
+      return print(await (await asWorker()).lease.done({ leaseId: leaseId(), message: message(1) }));
+    case "release":
+      return print(await (await asWorker()).lease.release({ leaseId: leaseId(), message: message(1) }));
+    default:
+      throw new UsageError(`Unknown command ${command}. Run: ahfact help`);
+  }
+}
+try {
+  await main(process.argv.slice(2));
+} catch (error) {
+  if (error instanceof UsageError || error instanceof ConfigError) {
+    hint(`ahfact: ${error.message}`);
+    process.exit(2);
+  }
+  if (error instanceof ORPCError) {
+    process.stderr.write(JSON.stringify({ error: error.code, message: error.message }) + `
+`);
+    process.exit(1);
+  }
+  if (error instanceof Error && /fetch|ECONNREFUSED|Unable to connect/i.test(error.message)) {
+    hint(`ahfact: cannot reach the factory: ${error.message}`);
+    process.exit(3);
+  }
+  if (error instanceof Error && error.message.startsWith("gh ")) {
+    hint(`ahfact: ${error.message}`);
+    process.exit(4);
+  }
+  throw error;
+}