teak-sdk 0.0.0-stage → 1.0.79

package/dist/sdk.js

@@ -0,0 +1,998 @@
+// ../convex/devUrls.ts
+var isLocalDevelopmentHostname = (hostname) => {
+  const normalizedHostname = hostname.trim().toLowerCase();
+  return normalizedHostname === "localhost" || normalizedHostname === "127.0.0.1" || normalizedHostname.endsWith(".localhost");
+};
+
+// ../convex/shared/boundedResponse.ts
+class ResponseSizeLimitError extends Error {
+}
+var consumeResponseWithinLimit = async (response, maxBytes, consume) => {
+  if (!(Number.isFinite(maxBytes) && maxBytes >= 0)) {
+    throw new RangeError("maxBytes must be a non-negative finite number");
+  }
+  if (!response.body) {
+    return consume(response);
+  }
+  let bytesRead = 0;
+  const boundedBody = response.body.pipeThrough(new TransformStream({
+    transform(chunk, controller) {
+      bytesRead += chunk.byteLength;
+      if (bytesRead > maxBytes) {
+        throw new ResponseSizeLimitError;
+      }
+      controller.enqueue(chunk);
+    }
+  }));
+  try {
+    return await consume(new Response(boundedBody, {
+      headers: response.headers
+    }));
+  } catch (error) {
+    if (error instanceof ResponseSizeLimitError) {
+      return null;
+    }
+    throw error;
+  }
+};
+var readResponseTextWithinLimit = (response, maxBytes) => consumeResponseWithinLimit(response, maxBytes, (boundedResponse) => boundedResponse.text());
+
+// ../convex/shared/workosResources.ts
+var WORKOS_RESOURCES = {
+  api: "https://teakvault.com/api",
+  mcp: "https://teakvault.com/mcp"
+};
+
+// ../convex/client/authDiscovery.ts
+var OAUTH_SURFACES = [
+  "cli",
+  "raycast",
+  "chrome",
+  "firefox",
+  "safari"
+];
+var caches = new WeakMap;
+var object = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid OAuth discovery document");
+  }
+  return value;
+};
+var loopback = (hostname) => isLocalDevelopmentHostname(hostname) || hostname === "[::1]";
+var privateHost = (hostname) => {
+  const octets = hostname.split(".").map(Number);
+  return hostname.endsWith(".localhost") || hostname.endsWith(".local") || hostname.startsWith("[") || octets.length === 4 && octets.every((n) => Number.isInteger(n) && n >= 0 && n <= 255) && (octets[0] === 0 || octets[0] === 10 || octets[0] === 100 && octets[1] >= 64 && octets[1] <= 127 || octets[0] === 127 || octets[0] === 169 && octets[1] === 254 || octets[0] === 172 && octets[1] >= 16 && octets[1] <= 31 || octets[0] === 192 && octets[1] === 168);
+};
+var validateOAuthUrl = (raw, local = false) => {
+  if (typeof raw !== "string") {
+    throw new Error("Missing OAuth discovery URL");
+  }
+  const url = new URL(raw);
+  if (url.username || url.password || url.hash || url.protocol !== "https:" && !(local && url.protocol === "http:" && loopback(url.hostname)) || !local && loopback(url.hostname) || privateHost(url.hostname) && !(local && loopback(url.hostname))) {
+    throw new Error("Unsafe OAuth discovery URL");
+  }
+  return url;
+};
+function discoverAuthServer(siteUrl, options = {}) {
+  const site = validateOAuthUrl(siteUrl, true);
+  const siteIsLocal = loopback(site.hostname);
+  const permittedLocalIssuer = options.localIssuer === undefined ? undefined : validateOAuthUrl(options.localIssuer, true);
+  if (permittedLocalIssuer && !loopback(permittedLocalIssuer.hostname)) {
+    throw new Error("Development issuer must use loopback");
+  }
+  const local = siteIsLocal || permittedLocalIssuer !== undefined;
+  const validateUrl = (raw) => {
+    const url = validateOAuthUrl(raw, local);
+    if (loopback(url.hostname) && !siteIsLocal && url.origin !== permittedLocalIssuer?.origin) {
+      throw new Error("Unapproved loopback OAuth server");
+    }
+    return url;
+  };
+  const cacheKey = `${site.origin}|${permittedLocalIssuer?.href ?? ""}`;
+  const fetchImpl = options.fetch ?? fetch;
+  let cache = caches.get(fetchImpl);
+  if (!cache) {
+    cache = new Map;
+    caches.set(fetchImpl, cache);
+  }
+  const previous = cache.get(cacheKey);
+  if (!options.forceRefresh && previous && previous.expiresAt > Date.now()) {
+    return previous.pending;
+  }
+  if (cache.size >= 16 && !cache.has(cacheKey)) {
+    const oldest = cache.keys().next().value;
+    if (oldest !== undefined) {
+      cache.delete(oldest);
+    }
+  }
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 1e4);
+  const read = async (url) => {
+    const response = await fetchImpl(url, {
+      method: "GET",
+      credentials: "omit",
+      redirect: "error",
+      headers: { Accept: "application/json" },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      throw new Error("OAuth discovery request failed");
+    }
+    const text = await readResponseTextWithinLimit(response, 64 * 1024);
+    if (text === null) {
+      throw new Error("OAuth discovery document is too large");
+    }
+    return object(JSON.parse(text));
+  };
+  const pending = (async () => {
+    const [resource, clientDocument] = await Promise.all([
+      read(`${site.origin}/.well-known/oauth-protected-resource/mcp`),
+      read(`${site.origin}/.well-known/teak-oauth-clients.json`)
+    ]);
+    const servers = resource.authorization_servers;
+    if (!Array.isArray(servers) || servers.length !== 1) {
+      throw new Error("Expected one OAuth authorization server");
+    }
+    const issuer = validateUrl(servers[0]);
+    if (issuer.search || clientDocument.issuer !== servers[0]) {
+      throw new Error("OAuth provider configuration changed; retry discovery");
+    }
+    const metadataUrl = new URL(issuer.origin);
+    metadataUrl.pathname = `/.well-known/oauth-authorization-server${issuer.pathname.replace(/\/$/, "")}`;
+    const metadata = await read(metadataUrl.href);
+    if (metadata.issuer !== servers[0]) {
+      throw new Error("OAuth issuer mismatch");
+    }
+    if (clientDocument.primary !== "betterauth" && clientDocument.primary !== "workos") {
+      throw new Error("Unknown OAuth provider");
+    }
+    if (!(Array.isArray(metadata.code_challenge_methods_supported) && metadata.code_challenge_methods_supported.includes("S256"))) {
+      throw new Error("OAuth server does not support S256 PKCE");
+    }
+    const clients = object(clientDocument.clients);
+    for (const surface of OAUTH_SURFACES) {
+      if (typeof clients[surface] !== "string" || !clients[surface].trim()) {
+        throw new Error("Missing OAuth client registration");
+      }
+    }
+    const expectedResource = clientDocument.primary === "workos" ? WORKOS_RESOURCES.mcp : `${site.origin}/mcp`;
+    if (resource.resource !== expectedResource) {
+      throw new Error("OAuth resource mismatch");
+    }
+    return Object.freeze({
+      primary: clientDocument.primary,
+      issuer: servers[0],
+      authorizationEndpoint: validateUrl(metadata.authorization_endpoint).href,
+      tokenEndpoint: validateUrl(metadata.token_endpoint).href,
+      ...metadata.revocation_endpoint === undefined ? {} : {
+        revocationEndpoint: validateUrl(metadata.revocation_endpoint).href
+      },
+      resource: resource.resource,
+      clients: Object.freeze(Object.fromEntries(OAUTH_SURFACES.map((surface) => [surface, clients[surface]])))
+    });
+  })().finally(() => {
+    controller.abort();
+    clearTimeout(timeout);
+  });
+  const entry = { expiresAt: Date.now() + 60000, pending };
+  cache.set(cacheKey, entry);
+  pending.catch(() => {
+    if (cache.get(cacheKey) === entry) {
+      cache.delete(cacheKey);
+    }
+  });
+  return pending;
+}
+// ../convex/shared/markdown.ts
+var MARKDOWN_CONTENT_MAX_BYTES = 512 * 1024;
+
+// ../convex/shared/fileFormats.ts
+var MAX_FILE_SIZE = 100 * 1024 * 1024;
+var GENERIC_MIME_TYPES = new Set([
+  "",
+  "application/binary",
+  "application/octet-stream",
+  "binary/octet-stream"
+]);
+var defineFormat = (definition) => ({
+  ...definition,
+  mimeType: definition.mimeType ?? definition.mimeTypes[0] ?? ""
+});
+var FILE_FORMATS = [
+  defineFormat({
+    id: "design-tokens",
+    suffixes: ["tokens.json"],
+    cardType: "document",
+    extension: "tokens.json",
+    kind: "tokens",
+    language: "json",
+    mimeTypes: ["application/json", "text/json", "text/plain"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "tailwind-config",
+    fileNames: ["tailwind.config.js"],
+    suffixes: [],
+    cardType: "document",
+    extension: "tailwind.config.js",
+    kind: "source",
+    language: "javascript",
+    mimeTypes: [
+      "application/javascript",
+      "text/javascript",
+      "application/x-javascript",
+      "text/plain"
+    ],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "css-variables",
+    fileNames: ["theme.css", "variables.css"],
+    suffixes: [],
+    cardType: "document",
+    extension: "css",
+    kind: "tokens",
+    language: "css",
+    mimeTypes: ["text/css", "text/plain"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "json",
+    suffixes: ["json"],
+    cardType: "document",
+    extension: "json",
+    kind: "source",
+    language: "json",
+    mimeTypes: ["application/json", "text/json", "application/ld+json"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "tsx",
+    suffixes: ["tsx"],
+    cardType: "document",
+    extension: "tsx",
+    kind: "source",
+    language: "tsx",
+    mimeTypes: [
+      "text/tsx",
+      "text/typescript",
+      "application/typescript",
+      "text/plain"
+    ],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "jsx",
+    suffixes: ["jsx"],
+    cardType: "document",
+    extension: "jsx",
+    kind: "source",
+    language: "jsx",
+    mimeTypes: [
+      "text/jsx",
+      "text/javascript",
+      "application/javascript",
+      "text/plain"
+    ],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "vue",
+    suffixes: ["vue"],
+    cardType: "document",
+    extension: "vue",
+    kind: "source",
+    language: "markup",
+    mimeTypes: ["text/x-vue", "application/x-vue", "text/plain"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "svelte",
+    suffixes: ["svelte"],
+    cardType: "document",
+    extension: "svelte",
+    kind: "source",
+    language: "markup",
+    mimeTypes: ["text/x-svelte", "application/x-svelte", "text/plain"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "html",
+    suffixes: ["html", "htm"],
+    cardType: "document",
+    extension: "html",
+    kind: "source",
+    language: "markup",
+    mimeTypes: ["text/html", "application/xhtml+xml", "text/plain"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "css",
+    suffixes: ["css"],
+    cardType: "document",
+    extension: "css",
+    kind: "source",
+    language: "css",
+    mimeTypes: ["text/css", "text/plain"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "markdown",
+    suffixes: ["md", "markdown"],
+    cardType: "text",
+    extension: "md",
+    kind: "markdown",
+    language: "markdown",
+    mimeTypes: ["text/markdown", "text/x-markdown", "text/plain"],
+    preview: "markdown"
+  }),
+  defineFormat({
+    id: "mdx",
+    suffixes: ["mdx"],
+    cardType: "document",
+    extension: "mdx",
+    kind: "markdown",
+    language: "mdx",
+    mimeTypes: ["text/mdx", "text/x-mdx", "text/markdown", "text/plain"],
+    preview: "markdown"
+  }),
+  defineFormat({
+    id: "text",
+    suffixes: ["txt"],
+    cardType: "document",
+    extension: "txt",
+    kind: "text",
+    language: "text",
+    mimeTypes: ["text/plain"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "rtf",
+    suffixes: ["rtf"],
+    cardType: "document",
+    extension: "rtf",
+    kind: "text",
+    language: "text",
+    mimeTypes: ["application/rtf", "text/rtf"],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "pdf",
+    suffixes: ["pdf"],
+    cardType: "document",
+    extension: "pdf",
+    kind: "pdf",
+    mimeTypes: ["application/pdf"],
+    preview: "pdf"
+  }),
+  defineFormat({
+    id: "word",
+    suffixes: ["docx"],
+    cardType: "document",
+    extension: "docx",
+    kind: "office",
+    mimeTypes: [
+      "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    ],
+    preview: "office"
+  }),
+  defineFormat({
+    id: "word-legacy",
+    suffixes: ["doc"],
+    cardType: "document",
+    extension: "doc",
+    kind: "office",
+    mimeTypes: ["application/msword"],
+    preview: "facts"
+  }),
+  defineFormat({
+    id: "powerpoint",
+    suffixes: ["pptx"],
+    cardType: "document",
+    extension: "pptx",
+    kind: "office",
+    mimeTypes: [
+      "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    ],
+    preview: "office"
+  }),
+  defineFormat({
+    id: "powerpoint-legacy",
+    suffixes: ["ppt"],
+    cardType: "document",
+    extension: "ppt",
+    kind: "office",
+    mimeTypes: ["application/vnd.ms-powerpoint"],
+    preview: "facts"
+  }),
+  defineFormat({
+    id: "excel",
+    suffixes: ["xlsx"],
+    cardType: "document",
+    extension: "xlsx",
+    kind: "office",
+    mimeTypes: [
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    ],
+    preview: "office"
+  }),
+  defineFormat({
+    id: "excel-legacy",
+    suffixes: ["xls"],
+    cardType: "document",
+    extension: "xls",
+    kind: "office",
+    mimeTypes: ["application/vnd.ms-excel"],
+    preview: "facts"
+  }),
+  defineFormat({
+    id: "csv",
+    suffixes: ["csv"],
+    cardType: "document",
+    extension: "csv",
+    kind: "text",
+    language: "csv",
+    mimeTypes: [
+      "text/csv",
+      "application/csv",
+      "text/plain",
+      "application/vnd.ms-excel"
+    ],
+    preview: "source"
+  }),
+  defineFormat({
+    id: "zip",
+    suffixes: ["zip"],
+    cardType: "document",
+    extension: "zip",
+    kind: "archive",
+    mimeTypes: ["application/zip", "application/x-zip-compressed"],
+    preview: "archive"
+  }),
+  defineFormat({
+    id: "figma",
+    suffixes: ["fig"],
+    cardType: "document",
+    extension: "fig",
+    kind: "design",
+    mimeTypes: ["application/x-figma", "application/figma"],
+    mimeType: "application/octet-stream",
+    preview: "facts"
+  }),
+  defineFormat({
+    id: "pages",
+    suffixes: ["pages"],
+    cardType: "document",
+    extension: "pages",
+    kind: "office",
+    mimeTypes: ["application/vnd.apple.pages"],
+    preview: "facts"
+  }),
+  defineFormat({
+    id: "numbers",
+    suffixes: ["numbers"],
+    cardType: "document",
+    extension: "numbers",
+    kind: "office",
+    mimeTypes: ["application/vnd.apple.numbers"],
+    preview: "facts"
+  }),
+  defineFormat({
+    id: "gif",
+    suffixes: ["gif"],
+    cardType: "video",
+    extension: "gif",
+    kind: "motion",
+    mimeTypes: ["image/gif"],
+    preview: "motion"
+  }),
+  defineFormat({
+    id: "webm",
+    suffixes: ["webm"],
+    cardType: "video",
+    extension: "webm",
+    kind: "motion",
+    mimeTypes: ["video/webm"],
+    preview: "motion"
+  }),
+  defineFormat({
+    id: "webm-audio",
+    suffixes: ["webm"],
+    cardType: "audio",
+    extension: "webm",
+    kind: "audio",
+    mimeTypes: ["audio/webm"],
+    preview: "audio"
+  }),
+  defineFormat({
+    id: "mp4",
+    suffixes: ["mp4"],
+    cardType: "video",
+    extension: "mp4",
+    kind: "motion",
+    mimeTypes: ["video/mp4", "application/mp4"],
+    preview: "motion"
+  }),
+  defineFormat({
+    id: "quicktime",
+    suffixes: ["mov", "m4v"],
+    cardType: "video",
+    extension: "mov",
+    kind: "motion",
+    mimeTypes: ["video/quicktime", "video/x-m4v"],
+    preview: "motion"
+  }),
+  defineFormat({
+    id: "video",
+    suffixes: ["mkv", "avi", "mpeg", "mpg", "wmv"],
+    cardType: "video",
+    extension: "video",
+    kind: "motion",
+    mimeTypes: [
+      "video/x-matroska",
+      "video/x-msvideo",
+      "video/mpeg",
+      "video/x-ms-wmv"
+    ],
+    preview: "motion"
+  }),
+  defineFormat({
+    id: "png",
+    suffixes: ["png"],
+    cardType: "image",
+    extension: "png",
+    kind: "image",
+    mimeTypes: ["image/png"],
+    preview: "image"
+  }),
+  defineFormat({
+    id: "jpeg",
+    suffixes: ["jpg", "jpeg"],
+    cardType: "image",
+    extension: "jpg",
+    kind: "image",
+    mimeTypes: ["image/jpeg", "image/jpg", "image/pjpeg"],
+    preview: "image"
+  }),
+  defineFormat({
+    id: "webp",
+    suffixes: ["webp"],
+    cardType: "image",
+    extension: "webp",
+    kind: "image",
+    mimeTypes: ["image/webp"],
+    preview: "image"
+  }),
+  defineFormat({
+    id: "avif",
+    suffixes: ["avif"],
+    cardType: "image",
+    extension: "avif",
+    kind: "image",
+    mimeTypes: ["image/avif"],
+    preview: "image"
+  }),
+  defineFormat({
+    id: "svg",
+    suffixes: ["svg"],
+    cardType: "image",
+    extension: "svg",
+    kind: "image",
+    language: "markup",
+    mimeTypes: ["image/svg+xml", "application/xml", "text/xml"],
+    preview: "image"
+  }),
+  defineFormat({
+    id: "heic",
+    suffixes: ["heic", "heif"],
+    cardType: "image",
+    extension: "heic",
+    kind: "image",
+    mimeTypes: ["image/heic", "image/heif", "image/heic-sequence"],
+    preview: "image"
+  }),
+  defineFormat({
+    id: "bitmap",
+    suffixes: ["bmp", "tif", "tiff"],
+    cardType: "image",
+    extension: "image",
+    kind: "image",
+    mimeTypes: ["image/bmp", "image/tiff"],
+    preview: "image"
+  }),
+  defineFormat({
+    id: "mpeg-audio",
+    suffixes: ["mp3"],
+    cardType: "audio",
+    extension: "mp3",
+    kind: "audio",
+    mimeTypes: ["audio/mpeg", "audio/mp3"],
+    preview: "audio"
+  }),
+  defineFormat({
+    id: "wave-audio",
+    suffixes: ["wav"],
+    cardType: "audio",
+    extension: "wav",
+    kind: "audio",
+    mimeTypes: ["audio/wav", "audio/x-wav"],
+    preview: "audio"
+  }),
+  defineFormat({
+    id: "mp4-audio",
+    suffixes: ["m4a", "mp4"],
+    cardType: "audio",
+    extension: "m4a",
+    kind: "audio",
+    mimeTypes: ["audio/mp4", "audio/x-m4a"],
+    preview: "audio"
+  }),
+  defineFormat({
+    id: "aac-audio",
+    suffixes: ["aac"],
+    cardType: "audio",
+    extension: "aac",
+    kind: "audio",
+    mimeTypes: ["audio/aac"],
+    preview: "audio"
+  }),
+  defineFormat({
+    id: "other-audio",
+    suffixes: ["flac", "ogg", "oga", "opus"],
+    cardType: "audio",
+    extension: "audio",
+    kind: "audio",
+    mimeTypes: ["audio/flac", "audio/ogg", "audio/opus"],
+    preview: "audio"
+  })
+];
+// ../convex/shared/constants.ts
+var cardTypes = [
+  "text",
+  "link",
+  "image",
+  "video",
+  "audio",
+  "document",
+  "palette",
+  "quote"
+];
+var MULTIPART_UPLOAD_THRESHOLD = 8 * 1024 * 1024;
+var CARD_TYPES = [...cardTypes];
+var CARD_TYPE_REGISTRY = {
+  text: {
+    label: "Text",
+    icon: "FileText",
+    searchLabel: "Text"
+  },
+  link: {
+    label: "Link",
+    icon: "Link",
+    searchLabel: "Links"
+  },
+  image: {
+    label: "Image",
+    icon: "Image",
+    searchLabel: "Images"
+  },
+  video: {
+    label: "Video",
+    icon: "Video",
+    searchLabel: "Videos"
+  },
+  audio: {
+    label: "Audio",
+    icon: "Volume2",
+    searchLabel: "Audio"
+  },
+  document: {
+    label: "Document",
+    icon: "File",
+    searchLabel: "Documents"
+  },
+  palette: {
+    label: "Palette",
+    icon: "Palette",
+    searchLabel: "Palettes"
+  },
+  quote: {
+    label: "Quote",
+    icon: "Quote",
+    searchLabel: "Quotes"
+  }
+};
+var RESERVED_KEYWORDS = [
+  ...cardTypes.map((cardType) => ({
+    value: cardType,
+    label: CARD_TYPE_REGISTRY[cardType].searchLabel
+  })),
+  { value: "favorites", label: "Favorites" },
+  { value: "trash", label: "Trash" }
+];
+
+// ../convex/client/sdk.ts
+var CARD_TYPES2 = cardTypes;
+var CARD_SORTS = ["newest", "oldest"];
+var ERROR_CODES = [
+  "AUTH_REQUIRED",
+  "BAD_REQUEST",
+  "CONFIG_ERROR",
+  "CONFLICT",
+  "CONTENT_TOO_LARGE",
+  "INTERNAL_ERROR",
+  "INVALID_API_KEY",
+  "INVALID_INPUT",
+  "INVALID_UTF8",
+  "METHOD_NOT_ALLOWED",
+  "NETWORK_ERROR",
+  "NOT_FOUND",
+  "PARSE_ERROR",
+  "RATE_LIMITED",
+  "REQUEST_FAILED",
+  "TIMEOUT",
+  "UNAUTHORIZED"
+];
+
+class TeakApiError extends Error {
+  code;
+  requestId;
+  retryAt;
+  status;
+  constructor(code, message, init) {
+    super(message || defaultErrorMessage(code));
+    this.name = "TeakApiError";
+    this.code = code;
+    this.requestId = init?.requestId;
+    this.retryAt = init?.retryAt;
+    this.status = init?.status;
+  }
+}
+var staticTokenProvider = (token) => ({
+  getAccessToken: () => token
+});
+var defaultErrorMessage = (code) => {
+  switch (code) {
+    case "AUTH_REQUIRED":
+    case "INVALID_API_KEY":
+    case "UNAUTHORIZED":
+      return "Authentication is required. Run `teak login` or set TEAK_API_KEY.";
+    case "RATE_LIMITED":
+      return "Too many requests. Wait a moment and try again.";
+    case "NETWORK_ERROR":
+      return "Unable to reach Teak.";
+    case "TIMEOUT":
+      return "The Teak request timed out.";
+    case "NOT_FOUND":
+      return "Teak could not find that resource.";
+    default:
+      return "The Teak request failed.";
+  }
+};
+var isObject = (value) => Boolean(value && typeof value === "object" && !Array.isArray(value));
+var isStringArray = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string");
+var codeFrom = (value, fallback) => typeof value === "string" && ERROR_CODES.includes(value) ? value : fallback;
+var normalizeLimit = (limit) => {
+  if (!Number.isFinite(limit)) {
+    return 50;
+  }
+  return Math.max(1, Math.min(Math.trunc(limit ?? 50), 100));
+};
+var byteLengthForBody = (bytes) => {
+  if (bytes instanceof ArrayBuffer) {
+    return bytes.byteLength;
+  }
+  if (ArrayBuffer.isView(bytes)) {
+    return bytes.byteLength;
+  }
+  if (typeof Blob !== "undefined" && bytes instanceof Blob) {
+    return bytes.size;
+  }
+  if (typeof bytes === "string") {
+    return new TextEncoder().encode(bytes).byteLength;
+  }
+  return null;
+};
+var buildCardsSearchParams = (input) => {
+  const search = new URLSearchParams;
+  if (input.query?.trim()) {
+    search.set("q", input.query.trim());
+  }
+  let types = [];
+  if (Array.isArray(input.type)) {
+    types = input.type;
+  } else if (typeof input.type === "string") {
+    types = [input.type];
+  }
+  for (const type of types) {
+    if (type.trim()) {
+      search.append("type", type.trim());
+    }
+  }
+  if (input.tag?.trim()) {
+    search.set("tag", input.tag.trim());
+  }
+  if (input.cursor?.trim()) {
+    search.set("cursor", input.cursor.trim());
+  }
+  if (input.include?.trim()) {
+    search.set("include", input.include.trim());
+  }
+  if (input.favorited) {
+    search.set("favorited", "true");
+  }
+  if (input.sort === "oldest") {
+    search.set("sort", "oldest");
+  }
+  if (typeof input.createdAfter === "number") {
+    search.set("createdAfter", String(input.createdAfter));
+  }
+  if (typeof input.createdBefore === "number") {
+    search.set("createdBefore", String(input.createdBefore));
+  }
+  search.set("limit", String(normalizeLimit(input.limit)));
+  return search.toString();
+};
+var parseJson = async (response) => {
+  if (response.status === 204) {
+    return null;
+  }
+  const text = await response.text();
+  if (!text.trim()) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new TeakApiError("PARSE_ERROR", "Teak returned malformed JSON.", {
+      status: response.status
+    });
+  }
+};
+var asCard = (value) => {
+  if (!isObject(value) || typeof value.id !== "string" || typeof value.content !== "string") {
+    throw new TeakApiError("PARSE_ERROR", "Teak returned an unexpected card payload.");
+  }
+  return value;
+};
+var asPage = (value) => {
+  if (!(isObject(value) && Array.isArray(value.items) && isObject(value.pageInfo))) {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return value;
+};
+var asTags = (value) => {
+  if (!(isObject(value) && Array.isArray(value.items))) {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return {
+    items: value.items.filter(isObject).map((tag) => ({
+      count: Number(tag.count) || 0,
+      name: String(tag.name || "")
+    }))
+  };
+};
+var asCreate = (value) => {
+  if (!isObject(value) || typeof value.cardId !== "string" || value.status !== "created") {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return value;
+};
+var asUpload = (value) => {
+  if (!isObject(value) || typeof value.uploadUrl !== "string" || typeof value.fileKey !== "string" || value.method !== "PUT" || typeof value.maxFileSize !== "number" || typeof value.expiresIn !== "number") {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return value;
+};
+var withoutTrailingSlashes = (value) => {
+  let end = value.length;
+  while (end > 0 && value.charCodeAt(end - 1) === 47) {
+    end -= 1;
+  }
+  return value.slice(0, end);
+};
+var createTeakClient = (options) => {
+  const baseUrl = withoutTrailingSlashes(options.baseUrl || "https://teakvault.com/api");
+  const fetchImpl = options.fetch ?? fetch;
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const request = async (path, init, parser, retry = true, accessToken) => {
+    const token = accessToken ?? await options.tokenProvider.getAccessToken();
+    if (!token) {
+      throw new TeakApiError("AUTH_REQUIRED");
+    }
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", `Bearer ${token}`);
+    headers.set("User-Agent", options.userAgent || "teak-cli");
+    if (init.body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    let response;
+    try {
+      response = await fetchImpl(`${baseUrl}${path}`, {
+        ...init,
+        headers,
+        signal: controller.signal
+      });
+    } catch (error) {
+      throw new TeakApiError(error instanceof DOMException && error.name === "AbortError" ? "TIMEOUT" : "NETWORK_ERROR");
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (response.status === 401 && retry && options.tokenProvider.onUnauthorized) {
+      const next = await options.tokenProvider.onUnauthorized(token);
+      if (next) {
+        return request(path, init, parser, false, next);
+      }
+    }
+    const payload = await parseJson(response);
+    if (!response.ok) {
+      const object = isObject(payload) ? payload : {};
+      throw new TeakApiError(codeFrom(object.code, response.status === 404 ? "NOT_FOUND" : "REQUEST_FAILED"), String(object.error || response.statusText), {
+        requestId: typeof object.requestId === "string" ? object.requestId : undefined,
+        retryAt: typeof object.retryAt === "number" ? object.retryAt : undefined,
+        status: response.status
+      });
+    }
+    return parser(payload);
+  };
+  const qs = (params) => buildCardsSearchParams(params);
+  return {
+    cards: {
+      bulk: (operation, items) => request("/v1/cards/bulk", { body: JSON.stringify({ items, operation }), method: "POST" }, (v) => v),
+      changes: (input) => {
+        const search = new URLSearchParams(qs(input));
+        search.set("since", String(input.since));
+        return request(`/v1/cards/changes?${search.toString()}`, { method: "GET" }, (v) => v);
+      },
+      create: (input) => request("/v1/cards", { body: JSON.stringify(input), method: "POST" }, asCreate),
+      delete: (id) => request(`/v1/cards/${encodeURIComponent(id)}`, { method: "DELETE" }, () => null),
+      favorites: (input = {}) => request(`/v1/cards?${qs({ ...input, favorited: true, include: "content,metadata" })}`, { method: "GET" }, asPage),
+      get: (id) => request(`/v1/cards/${encodeURIComponent(id)}`, { method: "GET" }, asCard),
+      list: (input = {}) => request(`/v1/cards?${qs(input)}`, { method: "GET" }, asPage),
+      search: (input = {}) => request(`/v1/cards?${qs({ ...input, include: "content,metadata" })}`, { method: "GET" }, asPage),
+      setFavorite: (id, isFavorited) => request(`/v1/cards/${encodeURIComponent(id)}/favorite`, { body: JSON.stringify({ isFavorited }), method: "PATCH" }, asCard),
+      update: (id, input) => request(`/v1/cards/${encodeURIComponent(id)}`, { body: JSON.stringify(input), method: "PATCH" }, asCard)
+    },
+    tags: {
+      list: () => request("/v1/tags", { method: "GET" }, asTags)
+    },
+    uploads: {
+      create: (input) => request("/v1/uploads", { body: JSON.stringify(input), method: "POST" }, asUpload),
+      putFile: async (uploadUrl, bytes, mimeType) => {
+        const headers = new Headers({ "Content-Type": mimeType });
+        const byteLength = byteLengthForBody(bytes);
+        if (byteLength !== null) {
+          headers.set("Content-Length", String(byteLength));
+        }
+        const response = await fetchImpl(uploadUrl, {
+          body: bytes,
+          headers,
+          method: "PUT"
+        });
+        if (!response.ok) {
+          throw new TeakApiError("REQUEST_FAILED", `Upload failed with status ${response.status}`, { status: response.status });
+        }
+        return { fileEtag: response.headers.get("etag") ?? undefined };
+      }
+    }
+  };
+};
+var parseTags = (value) => value === undefined ? undefined : Array.from(new Set(value.split(",").map((tag) => tag.trim()).filter(Boolean)));
+var isCardType = (value) => CARD_TYPES2.includes(value);
+var isStringList = isStringArray;
+export {
+  CARD_SORTS,
+  CARD_TYPES2 as CARD_TYPES,
+  ERROR_CODES,
+  TeakApiError,
+  buildCardsSearchParams,
+  createTeakClient,
+  discoverAuthServer,
+  isCardType,
+  isStringList,
+  normalizeLimit,
+  parseTags,
+  staticTokenProvider,
+  validateOAuthUrl
+};