stitchkit 0.80.1 → 0.82.0

package/dist/geo.js

@@ -0,0 +1,245 @@
+import {
+  messageOf
+} from "./index-p13mwz16.js";
+import {
+  isPublicIp
+} from "./index-f9mb610r.js";
+import"./index-kzfs85xp.js";
+import {
+  isRecord
+} from "./index-77fekveh.js";
+
+// src/geo/maxmind.ts
+import { realpath, stat } from "node:fs/promises";
+var MAXMIND_PEER = "maxmind";
+async function revisionOf(paths) {
+  try {
+    const entries = await Promise.all([paths.city, paths.asn].filter((path) => path !== undefined).map(async (path) => {
+      const [resolved, metadata] = await Promise.all([realpath(path), stat(path)]);
+      return [
+        resolved,
+        metadata.dev,
+        metadata.ino,
+        metadata.size,
+        Math.trunc(metadata.mtimeMs)
+      ].join(":");
+    }));
+    return entries.join("|");
+  } catch {
+    return null;
+  }
+}
+function createMaxMindGeoIpLoader(options = {}) {
+  const loadPeer = options.loadPeer ?? (() => import(MAXMIND_PEER));
+  return {
+    revision: revisionOf,
+    async open(paths, expectedRevision) {
+      const before = await revisionOf(paths);
+      if (before === null)
+        throw new Error("GeoIP database is unavailable");
+      if (before !== expectedRevision) {
+        throw new Error("GeoIP database changed before opening a generation");
+      }
+      const peer = await loadPeer();
+      if (!peer || typeof peer.open !== "function") {
+        throw new Error("The optional maxmind peer does not expose open()");
+      }
+      const city = await peer.open(paths.city, { watchForUpdates: false });
+      let asn;
+      try {
+        if (paths.asn)
+          asn = await peer.open(paths.asn, { watchForUpdates: false });
+        const after = await revisionOf(paths);
+        if (after !== before)
+          throw new Error("GeoIP database changed while opening a generation");
+        return {
+          lookup(ip) {
+            const cityRecord = city.get(ip);
+            const asnRecord = asn?.get(ip);
+            if (!asnRecord || typeof asnRecord !== "object")
+              return cityRecord;
+            if (!cityRecord || typeof cityRecord !== "object")
+              return asnRecord;
+            return { ...cityRecord, ...asnRecord };
+          },
+          async close() {
+            await Promise.all([city.close?.(), asn?.close?.()]);
+          }
+        };
+      } catch (error) {
+        await Promise.allSettled([city.close?.(), asn?.close?.()]);
+        throw error;
+      }
+    }
+  };
+}
+// src/geo/resolver.ts
+function text(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function finite(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function record(value) {
+  return isRecord(value) ? value : undefined;
+}
+function mapGeoIpRecord(value) {
+  const root = record(value);
+  if (!root)
+    return null;
+  const country = record(root.country);
+  const subdivisions = Array.isArray(root.subdivisions) ? record(root.subdivisions[0]) : undefined;
+  const city = record(root.city);
+  const postal = record(root.postal);
+  const location = record(root.location);
+  const names = (entry) => record(entry?.names);
+  const result = {
+    countryCode: text(country?.iso_code),
+    countryName: text(names(country)?.en),
+    regionCode: text(subdivisions?.iso_code),
+    regionName: text(names(subdivisions)?.en),
+    city: text(names(city)?.en),
+    postalCode: text(postal?.code),
+    latitude: finite(location?.latitude),
+    longitude: finite(location?.longitude),
+    timezone: text(location?.time_zone),
+    autonomousSystemNumber: finite(root.autonomous_system_number),
+    autonomousSystemOrganization: text(root.autonomous_system_organization)
+  };
+  return Object.values(result).some((entry) => entry !== undefined) ? result : null;
+}
+var errorMessage = (error) => messageOf(error) || "unknown reload error";
+function createGeoIpResolver(options) {
+  const clock = options.clock ?? Date.now;
+  const map = options.map ?? mapGeoIpRecord;
+  let generation = null;
+  let snapshot = Object.freeze({ state: "uninitialized" });
+  let reloadChain = Promise.resolve(false);
+  let timer;
+  let closed = false;
+  const finishRetire = async (current) => {
+    if (current.closing)
+      return current.closePromise ?? Promise.resolve();
+    current.closing = true;
+    try {
+      await current.reader.close?.();
+    } catch (error) {
+      options.onError?.(error);
+    } finally {
+      current.closeResolve?.();
+    }
+  };
+  const retire = (current) => {
+    current.retired = true;
+    if (current.closePromise)
+      return current.closePromise;
+    if (current.lookups > 0) {
+      current.closePromise = new Promise((resolve) => {
+        current.closeResolve = resolve;
+      });
+      return current.closePromise;
+    }
+    current.closePromise = finishRetire(current);
+    return current.closePromise;
+  };
+  const swap = async () => {
+    if (closed)
+      return false;
+    let revision;
+    try {
+      revision = await options.loader.revision(options.paths);
+      if (revision === null)
+        throw new Error("GeoIP database is unavailable");
+      if (generation && revision === generation.revision) {
+        if (snapshot.reloadError) {
+          snapshot = Object.freeze({
+            state: "ready",
+            revision,
+            loadedAt: snapshot.loadedAt
+          });
+        }
+        return false;
+      }
+      const next = await options.loader.open(options.paths, revision);
+      if (closed) {
+        await next.close?.();
+        return false;
+      }
+      const previous = generation;
+      generation = { reader: next, revision, lookups: 0, retired: false };
+      snapshot = Object.freeze({ state: "ready", revision, loadedAt: clock() });
+      if (previous)
+        await retire(previous);
+      return true;
+    } catch (error) {
+      options.onError?.(error);
+      snapshot = generation ? Object.freeze({
+        state: "ready",
+        revision: generation.revision,
+        loadedAt: snapshot.loadedAt,
+        reloadError: errorMessage(error)
+      }) : Object.freeze({ state: "unavailable", reloadError: errorMessage(error) });
+      return false;
+    }
+  };
+  const reload = () => {
+    reloadChain = reloadChain.then(swap, swap);
+    return reloadChain;
+  };
+  const close = async () => {
+    closed = true;
+    if (timer)
+      clearInterval(timer);
+    timer = undefined;
+    await reloadChain.catch(() => {
+      return;
+    });
+    const current = generation;
+    generation = null;
+    if (current)
+      await retire(current);
+    snapshot = Object.freeze({ state: "uninitialized" });
+  };
+  return {
+    id: options.id ?? "geoip",
+    async start() {
+      closed = false;
+      await reload();
+      return { value: this };
+    },
+    activate() {
+      const intervalMs = options.reload === false ? undefined : options.reload?.intervalMs;
+      if (intervalMs !== undefined && intervalMs > 0 && !timer) {
+        timer = setInterval(() => void reload(), intervalMs);
+        timer.unref?.();
+      }
+    },
+    close,
+    force: close,
+    async resolve(ip) {
+      if (!isPublicIp(ip))
+        return null;
+      const current = generation;
+      if (!current)
+        return null;
+      current.lookups += 1;
+      try {
+        return map(await current.reader.lookup(ip));
+      } catch (error) {
+        options.onError?.(error);
+        return null;
+      } finally {
+        current.lookups -= 1;
+        if (current.retired && current.lookups === 0)
+          await finishRetire(current);
+      }
+    },
+    reload,
+    snapshot: () => snapshot
+  };
+}
+export {
+  mapGeoIpRecord,
+  createMaxMindGeoIpLoader,
+  createGeoIpResolver
+};

package/dist/{index-9s6z8vgf.js → index-1dd82z59.js}

@@ -29,7 +29,7 @@ import {
 import {
   ToolExecutionControlError,
   isToolExecutionControlError
-} from "./index-758zx2ha.js";
+} from "./index-dggwnnjv.js";
 import {
   isRecord,
   transportResult

package/dist/{index-vwp69871.js → index-27487ay5.js}

@@ -3,14 +3,14 @@ import {
 } from "./index-sbdmyz75.js";
 import {
   collectToolSurface
-} from "./index-2rwwmr7v.js";
+} from "./index-s4ckmrac.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-5mtc969c.js";
+} from "./index-fwbkp2jn.js";
 import {
   toolResultFromError
-} from "./index-758zx2ha.js";
+} from "./index-dggwnnjv.js";
 import {
   assertUniqueToolName,
   buildToolPresentationSchema,
@@ -25,7 +25,7 @@ import {
 import {
   formatZodError,
   validateDeclaredOutput
-} from "./index-fxz0v7vg.js";
+} from "./index-7evdsyez.js";
 import {
   isUnsafeKey,
   safeJsonParse

package/dist/{index-7ag81v2f.js → index-27gm3d6g.js}

@@ -3,336 +3,25 @@ import {
   inputIsQuery,
   parseSSE,
   readBoundedUtf8Lines
-} from "./index-hb5pf3s4.js";
+} from "./index-qmgs7y68.js";
 import {
-  createTraceContext,
-  formatTraceparent
-} from "./index-fxz0v7vg.js";
+  ApiError,
+  RequestCancellationError,
+  createRequestCancellation,
+  parseApiErrorBody,
+  refuseLocally,
+  responseTraceId
+} from "./index-3xwxfj4z.js";
 import {
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
   parseTrailingWildcard
-} from "./index-y01f4223.js";
+} from "./index-2bxcmqkb.js";
 import {
   isRecord,
   mapObject,
-  transportResult,
   typedEntries
 } from "./index-77fekveh.js";
-
-// src/browser/http.ts
-import ky, {
-  isHTTPError,
-  isNetworkError,
-  isTimeoutError
-} from "ky";
-
-// src/browser/cancellation.ts
-class RequestCancellationError extends Error {
-  cause;
-  constructor(cause) {
-    super(cause === "caller" ? "Request was aborted" : "Request timed out");
-    this.cause = cause;
-    this.name = "RequestCancellationError";
-  }
-}
-function createRequestCancellation(caller, timeoutMs) {
-  if (!caller && timeoutMs === undefined) {
-    return { signal: undefined, run: (operation) => operation() };
-  }
-  const timeoutController = timeoutMs === undefined ? undefined : new AbortController;
-  const signal = caller && timeoutController ? AbortSignal.any([caller, timeoutController.signal]) : caller ?? timeoutController?.signal;
-  let cause;
-  let timer;
-  const abortFromCaller = () => {
-    if (cause)
-      return;
-    cause = "caller";
-  };
-  if (caller?.aborted)
-    abortFromCaller();
-  else
-    caller?.addEventListener("abort", abortFromCaller, { once: true });
-  if (timeoutMs !== undefined && timeoutController) {
-    timer = setTimeout(() => {
-      if (cause)
-        return;
-      cause = "timeout";
-      timeoutController.abort(new DOMException("Request timed out", "TimeoutError"));
-    }, timeoutMs);
-  }
-  return {
-    signal,
-    async run(operation) {
-      try {
-        if (cause === "caller")
-          throw cancellationError(cause);
-        return await operation(signal);
-      } catch (error) {
-        if (cause)
-          throw cancellationError(cause);
-        throw error;
-      } finally {
-        if (timer !== undefined)
-          clearTimeout(timer);
-        caller?.removeEventListener("abort", abortFromCaller);
-      }
-    }
-  };
-}
-function cancellationError(cause) {
-  return new RequestCancellationError(cause);
-}
-
-// src/browser/request-id.ts
-var REQUEST_ID_HEADER = "x-request-id";
-function responseTraceId(response) {
-  return response?.headers.get(REQUEST_ID_HEADER) ?? undefined;
-}
-
-// src/browser/http.ts
-var API_ERROR_BRAND = Symbol.for("stitchkit.ApiError");
-function messageForCode(code, message) {
-  return message !== undefined && message.length > 0 ? message : `${code} (no message supplied)`;
-}
-
-class ApiError extends Error {
-  code;
-  status;
-  details;
-  hint;
-  traceId;
-  constructor(code, status = 0, details, message, hint, traceId, options) {
-    super(messageForCode(code, message), options);
-    this.code = code;
-    this.status = status;
-    this.details = details;
-    this.hint = hint;
-    this.traceId = traceId;
-    this.name = "ApiError";
-    Object.defineProperty(this, API_ERROR_BRAND, { value: true });
-  }
-  static is(error) {
-    return typeof error === "object" && error !== null && API_ERROR_BRAND in error;
-  }
-}
-function refuseLocally(path, message) {
-  return new ApiError("VALIDATION_ERROR", 0, { issues: [{ path, code: "invalid_type", message }] }, message);
-}
-function shouldRetryBunNetworkError(error) {
-  if (ApiError.is(error) || isHTTPError(error) || isNetworkError(error) || isTimeoutError(error) || error instanceof RequestCancellationError || error instanceof DOMException && (error.name === "AbortError" || error.name === "TimeoutError")) {
-    return;
-  }
-  if (!(error instanceof Error))
-    return;
-  const code = Object.getOwnPropertyDescriptor(error, "code");
-  return code && "value" in code && code.value === "ConnectionRefused" ? true : undefined;
-}
-function parseApiErrorBody(body) {
-  if (!isRecord(body) || !isRecord(body.error))
-    return null;
-  const error = body.error;
-  if (typeof error.code !== "string")
-    return null;
-  return {
-    code: error.code,
-    message: typeof error.message === "string" ? error.message : undefined,
-    details: error.details,
-    hint: typeof error.hint === "string" ? error.hint : undefined
-  };
-}
-function createRetryAwareFetch(transportFetch, unix) {
-  const runtimeFetch = transportFetch;
-  let attempt = 0;
-  return (input, init) => {
-    attempt += 1;
-    if (unix === undefined && attempt === 1) {
-      return runtimeFetch(input, init);
-    }
-    if (!(input instanceof Request)) {
-      if (unix === undefined)
-        return runtimeFetch(input, init);
-      const unixInit = { ...init, unix };
-      return runtimeFetch(input, unixInit);
-    }
-    const streamedBody = input.body ? { body: input.body, duplex: "half" } : {};
-    const materialized = {
-      ...init,
-      ...unix !== undefined && { unix },
-      method: input.method,
-      headers: input.headers,
-      ...streamedBody,
-      cache: input.cache,
-      credentials: input.credentials,
-      integrity: input.integrity,
-      keepalive: input.keepalive,
-      mode: input.mode,
-      redirect: input.redirect,
-      referrer: input.referrer,
-      referrerPolicy: input.referrerPolicy,
-      signal: input.signal
-    };
-    return runtimeFetch(input.url, materialized);
-  };
-}
-function createHttpClient(config) {
-  if (config.fetch && config.unix) {
-    throw new TypeError("HttpClientConfig.fetch and unix are mutually exclusive");
-  }
-  if (config.unix !== undefined) {
-    if (!config.unix.startsWith("/") || config.unix.includes("\x00")) {
-      throw new TypeError("HttpClientConfig.unix must be an absolute Unix socket path");
-    }
-    if (typeof Reflect.get(globalThis, "Bun") !== "object") {
-      throw new TypeError("HttpClientConfig.unix requires Bun; on Bun or Node use createUnixClientTransport().fetch for an explicit portable transport");
-    }
-  }
-  let ssrCookies = null;
-  let isLoggedOut = false;
-  const listeners = new Set;
-  const suppressUnauthorizedFor = config.suppressUnauthorizedFor ?? [];
-  const parseError = config.parseError ?? parseApiErrorBody;
-  function emit(event) {
-    for (const fn of listeners) {
-      try {
-        fn(event);
-      } catch {}
-    }
-  }
-  const client = ky.create({
-    prefix: config.baseUrl,
-    credentials: config.credentials ?? "include",
-    timeout: false,
-    retry: {
-      limit: config.retry?.limit ?? 2,
-      methods: config.retry?.methods ?? ["get"],
-      statusCodes: config.retry?.statusCodes ?? [],
-      shouldRetry: ({ error }) => shouldRetryBunNetworkError(error)
-    },
-    hooks: {
-      beforeRequest: [
-        ({ request: request2 }) => {
-          if (ssrCookies) {
-            request2.headers.set("Cookie", ssrCookies);
-          }
-          const extra = typeof config.headers === "function" ? config.headers() : config.headers;
-          if (extra) {
-            for (const [key, value] of Object.entries(extra)) {
-              request2.headers.set(key, value);
-            }
-          }
-          if (config.trace && !request2.headers.has("traceparent")) {
-            request2.headers.set("traceparent", formatTraceparent(createTraceContext()));
-          }
-        }
-      ],
-      afterResponse: [
-        async ({ request: request2, response }) => {
-          if (response.status === 401) {
-            const url = new URL(request2.url).pathname;
-            if (!isLoggedOut && !suppressUnauthorizedFor.some((matches) => matches(url))) {
-              isLoggedOut = true;
-              emit({ type: "unauthorized" });
-            }
-          }
-          if (!response.ok) {
-            const body = await response.clone().json().catch(() => null);
-            if (body) {
-              const parsed = parseError(body);
-              if (parsed) {
-                throw new ApiError(parsed.code, response.status, parsed.details, parsed.message, parsed.hint, responseTraceId(response));
-              }
-            }
-          }
-        }
-      ]
-    }
-  });
-  async function request(method, url, data, options = {}) {
-    const cancellation = createRequestCancellation(options.signal, options.timeout ?? config.timeout ?? 30000);
-    const kyOptions = {
-      fetch: createRetryAwareFetch(config.fetch ?? globalThis.fetch.bind(globalThis), config.unix),
-      timeout: false,
-      signal: cancellation.signal
-    };
-    if (options.params) {
-      const searchParams = new URLSearchParams;
-      for (const [key, value] of Object.entries(options.params)) {
-        if (value === undefined)
-          continue;
-        if (Array.isArray(value)) {
-          for (const item of value)
-            searchParams.append(key, String(item));
-        } else {
-          searchParams.set(key, String(value));
-        }
-      }
-      if (searchParams.size > 0) {
-        kyOptions.searchParams = searchParams;
-      }
-    }
-    if (data instanceof FormData) {
-      kyOptions.body = data;
-    } else if (data !== undefined) {
-      kyOptions.json = data;
-    }
-    try {
-      return await cancellation.run(async () => {
-        if (options.responseType === "blob") {
-          return transportResult(await client[method](url, kyOptions).blob());
-        }
-        if (options.responseType === "response") {
-          return transportResult(await client[method](url, kyOptions));
-        }
-        const response = await client[method](url, kyOptions);
-        if (options.responseType === "void") {
-          const text = await response.text();
-          if (text.length > 0) {
-            throw new Error("Server returned data for an endpoint with no output contract");
-          }
-        }
-        if (options.responseType === "void" || response.status === 204 || response.headers.get("content-length") === "0") {
-          return transportResult(undefined);
-        }
-        return await response.json();
-      });
-    } catch (error) {
-      if (error instanceof RequestCancellationError) {
-        throw new ApiError(error.cause === "caller" ? "REQUEST_ABORTED" : "REQUEST_TIMEOUT", 0, undefined, error.message);
-      }
-      if (ApiError.is(error))
-        throw error;
-      emit({ type: "network_error" });
-      const response = isHTTPError(error) ? error.response : undefined;
-      const status = response?.status ?? 0;
-      const msg = error instanceof Error ? error.message : undefined;
-      throw new ApiError("UNKNOWN_ERROR", status, msg ? { message: msg } : undefined, msg, undefined, responseTraceId(response), { cause: error });
-    }
-  }
-  return {
-    baseUrl: config.baseUrl,
-    get: (url, options) => request("get", url, undefined, options),
-    head: (url, options) => request("head", url, undefined, options),
-    post: (url, data, options) => request("post", url, data, options),
-    put: (url, data, options) => request("put", url, data, options),
-    patch: (url, data, options) => request("patch", url, data, options),
-    delete: (url, options) => request("delete", url, undefined, options),
-    setServerContext(cookies) {
-      ssrCookies = cookies;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    logout() {
-      isLoggedOut = true;
-      emit({ type: "logout" });
-    },
-    resetLogoutState() {
-      isLoggedOut = false;
-    }
-  };
-}
 // src/browser/stream.ts
 function parseFailure(raw, error, onParseError) {
   const failure = error instanceof Error ? error : new Error(String(error));
@@ -955,4 +644,4 @@ function createScopedUrlBuilders(contracts, source, scopeConfigs) {
   return buildScopedRegistry(contracts, scopeConfigs, "URL builder", (contract, config) => createUrlBuilder(contract, source, config));
 }
 
-export { ApiError, createHttpClient, parseNDJSON, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };
+export { parseNDJSON, contractEndpointMatchers, createClient, createClients, createScopedClients, createUrlBuilder, createUrlBuilders, createScopedUrlBuilders };