teak-sdk 1.0.86 → 1.0.87

package/dist/sdk.js

@@ -1,12 +1,18 @@
-// ../convex/devUrls.ts
-var TEAK_DEV_DEPLOYMENT_NAME = "reminiscent-kangaroo-59";
-var DEFAULT_TEAK_DEV_CONVEX_URL = `https://${TEAK_DEV_DEPLOYMENT_NAME}.convex.cloud`;
-var DEFAULT_TEAK_DEV_CONVEX_SITE_URL = `https://${TEAK_DEV_DEPLOYMENT_NAME}.convex.site`;
-var isLocalDevelopmentHostname = (hostname) => {
-  const normalizedHostname = hostname.trim().toLowerCase();
-  return normalizedHostname === "localhost" || normalizedHostname === "127.0.0.1" || normalizedHostname.endsWith(".localhost");
+// ../convex/shared/utils/formatBytes.ts
+var BYTE_UNITS = ["B", "KB", "MB", "GB"];
+var formatBytes = (bytes) => {
+  if (!(bytes && Number.isFinite(bytes) && bytes > 0)) {
+    return "0 B";
+  }
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1024 && unit < BYTE_UNITS.length - 1) {
+    value /= 1024;
+    unit += 1;
+  }
+  const digits = unit > 0 && value < 10 ? 1 : 0;
+  return `${value.toFixed(digits)} ${BYTE_UNITS[unit]}`;
 };
-
 // ../convex/shared/boundedResponse.ts
 class ResponseSizeLimitError extends Error {
 }
@@ -40,28 +46,17 @@ var consumeResponseWithinLimit = async (response, maxBytes, consume) => {
 };
 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/devUrls.ts
+var TEAK_DEV_DEPLOYMENT_NAME = "reminiscent-kangaroo-59";
+var DEFAULT_TEAK_DEV_CONVEX_URL = `https://${TEAK_DEV_DEPLOYMENT_NAME}.convex.cloud`;
+var DEFAULT_TEAK_DEV_CONVEX_SITE_URL = `https://${TEAK_DEV_DEPLOYMENT_NAME}.convex.site`;
+var isLocalDevelopmentHostname = (hostname) => {
+  const normalizedHostname = hostname.trim().toLowerCase();
+  return normalizedHostname === "localhost" || normalizedHostname === "127.0.0.1" || normalizedHostname.endsWith(".localhost");
 };
 
-// ../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]";
+// ../convex/shared/oauthUrl.ts
+var isLoopbackHostname = (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);
@@ -71,22 +66,40 @@ var validateOAuthUrl = (raw, local = false) => {
     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))) {
+  if (url.username || url.password || url.hash || url.protocol !== "https:" && !(local && url.protocol === "http:" && isLoopbackHostname(url.hostname)) || !local && isLoopbackHostname(url.hostname) || privateHost(url.hostname) && !(local && isLoopbackHostname(url.hostname))) {
     throw new Error("Unsafe OAuth discovery URL");
   }
   return url;
 };
+
+// ../convex/shared/workosResources.ts
+var PRODUCTION_WORKOS_RESOURCE_ORIGIN = "https://teakvault.com";
+var workosResourcesFor = (url) => {
+  const { origin } = new URL(url);
+  return Object.freeze({ api: `${origin}/api`, mcp: `${origin}/mcp` });
+};
+var PRODUCTION_WORKOS_RESOURCES = workosResourcesFor(PRODUCTION_WORKOS_RESOURCE_ORIGIN);
+
+// ../convex/client/authDiscovery.ts
+var OAUTH_SURFACES = ["cli", "raycast", "chrome", "firefox"];
+var caches = new WeakMap;
+var object = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Invalid OAuth discovery document");
+  }
+  return value;
+};
 function discoverAuthServer(siteUrl, options = {}) {
   const site = validateOAuthUrl(siteUrl, true);
-  const siteIsLocal = loopback(site.hostname);
+  const siteIsLocal = isLoopbackHostname(site.hostname);
   const permittedLocalIssuer = options.localIssuer === undefined ? undefined : validateOAuthUrl(options.localIssuer, true);
-  if (permittedLocalIssuer && !loopback(permittedLocalIssuer.hostname)) {
+  if (permittedLocalIssuer && !isLoopbackHostname(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) {
+    if (isLoopbackHostname(url.hostname) && !siteIsLocal && url.origin !== permittedLocalIssuer?.origin) {
       throw new Error("Unapproved loopback OAuth server");
     }
     return url;
@@ -113,7 +126,7 @@ function discoverAuthServer(siteUrl, options = {}) {
   const read = async (url) => {
     const response = await fetchImpl(url, {
       method: "GET",
-      credentials: "omit",
+      ...{ credentials: "omit" },
       redirect: "error",
       headers: { Accept: "application/json" },
       signal: controller.signal
@@ -158,7 +171,7 @@ function discoverAuthServer(siteUrl, options = {}) {
         throw new Error("Missing OAuth client registration");
       }
     }
-    if (resource.resource !== WORKOS_RESOURCES.mcp) {
+    if (resource.resource !== PRODUCTION_WORKOS_RESOURCES.mcp && resource.resource !== workosResourcesFor(site.origin).mcp) {
       throw new Error("OAuth resource mismatch");
     }
     return Object.freeze({
@@ -196,7 +209,7 @@ var base64Url = (bytes) => {
 };
 var randomBase64Url = (byteLength) => base64Url(crypto.getRandomValues(new Uint8Array(byteLength)));
 var createPkceChallenge = async (verifier) => base64Url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))));
-var apiResource = (auth) => new URL("/api", auth.resource).href;
+var apiResource = (auth) => workosResourcesFor(auth.resource).api;
 var createConnectAuthorizeUrl = (auth, params) => {
   const url = new URL(auth.authorizationEndpoint);
   url.searchParams.set("response_type", "code");
@@ -211,7 +224,7 @@ var createConnectAuthorizeUrl = (auth, params) => {
 };
 var send = (url, init, local) => fetch(validateOAuthUrl(url, local).href, {
   ...init,
-  credentials: "omit",
+  ...{ credentials: "omit" },
   redirect: "error",
   signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
 });
@@ -304,8 +317,55 @@ var fetchConnectOwnerId = async (apiUrl, accessToken, options = {}) => {
 // ../convex/shared/markdown.ts
 var MARKDOWN_CONTENT_MAX_BYTES = 512 * 1024;
 
+// ../files-protocol/src/decisions.ts
+var CLEF_MODEL_ID = "@cf/cloudflare/clef";
+var CLEF_FLASH_MODEL_ID = "@cf/cloudflare/clef-flash";
+var CLEF_INPUT_USD_PER_MILLION = {
+  [CLEF_MODEL_ID]: 0.24,
+  [CLEF_FLASH_MODEL_ID]: 0.038
+};
+var RELEVANCE_LEVELS = [
+  "Not related",
+  "Loosely related",
+  "Relevant",
+  "Exactly what they are looking for"
+];
+var RELEVANCE_MAX_SCORE = RELEVANCE_LEVELS.length - 1;
+// ../files-protocol/src/embeddings.ts
+var ASCII_TOKEN_COST = 1 / 3;
+// ../files-protocol/src/storage.ts
+var FILES_UPLOAD_MAX_BYTES = 100 * 1024 * 1024;
+var FILES_SIGNED_URL_MIN_VALIDITY_SECONDS = 7 * 24 * 60 * 60;
+var FILE_CACHE_MAX_AGE_SECONDS = FILES_SIGNED_URL_MIN_VALIDITY_SECONDS - 24 * 60 * 60;
+var FILES_PRIVATE_CACHE_CONTROL = `private, max-age=${FILE_CACHE_MAX_AGE_SECONDS}, immutable`;
+var FILES_EDGE_CACHE_CONTROL = `public, max-age=${FILE_CACHE_MAX_AGE_SECONDS}, immutable`;
+var FILES_DEV_KEY_PREFIX = "dev/";
+var filesUserKeyRoot = (envPrefix) => `${envPrefix}users/`;
+var filesExportKeyRoot = (envPrefix) => `${envPrefix}exports/`;
+var FILES_OBJECT_KEY_ROOTS = ["", FILES_DEV_KEY_PREFIX].flatMap((envPrefix) => [filesUserKeyRoot(envPrefix), filesExportKeyRoot(envPrefix)]);
+
+// ../files-protocol/src/inspect.ts
+var FILES_INSPECT_MAX_ARCHIVE_BYTES = 25 * 1024 * 1024;
+var FILES_INSPECT_MAX_SOURCE_BYTES = 2 * 1024 * 1024;
+// ../files-protocol/src/remoteAsset.ts
+var FILES_REMOTE_ASSET_MAX_BYTES = {
+  image: 20 * 1024 * 1024,
+  video: 50 * 1024 * 1024
+};
+// ../files-protocol/src/workflows.ts
+var WORKFLOW_RPC_MAX_TTL_SECONDS = 5 * 60;
+var WORKFLOW_RPC_MAX_BODY_BYTES = 4 * 1024 * 1024;
+var RPC_KINDS = new Set(["action", "mutation", "query"]);
+// ../files-protocol/src/index.ts
+var FILES_UPLOAD_MAX_TTL_SECONDS = 15 * 60;
+var FILES_OP_MAX_TTL_SECONDS = 15 * 60;
+var FILES_OP_TTL_SECONDS = 10 * 60;
+var FILES_TRANSCRIPT_MAX_BYTES = 512 * 1024;
+var FILES_EXTRACTED_TEXT_MAX_CHARACTERS = 512 * 1024;
+var FILES_EXTRACTED_TEXT_MAX_BYTES = 512 * 1024;
+var FILES_IMPORT_PAGE_BYTES = 4 * 1024 * 1024;
+
 // ../convex/shared/fileFormats.ts
-var MAX_FILE_SIZE = 100 * 1024 * 1024;
 var GENERIC_MIME_TYPES = new Set([
   "",
   "application/binary",
@@ -764,6 +824,19 @@ var FILE_FORMATS = [
     preview: "audio"
   })
 ];
+// ../convex/shared/tags.ts
+var MAX_TAG_NAME_LENGTH = 64;
+var TAG_OPERATION_STALL_MS = 2 * 60000;
+var TAG_ERROR_MESSAGES = {
+  EMPTY_NAME: "Name the tag",
+  NAME_TOO_LONG: `Tags can be at most ${MAX_TAG_NAME_LENGTH} characters`,
+  NOT_FOUND: "Tag not found",
+  SAME_TAG: "Choose a different tag to merge into",
+  OPERATION_RUNNING: "Another tag change is still running",
+  OPERATION_NOT_FOUND: "Tag operation not found"
+};
+var HIDDEN_TAG_KEYS = ["secret", "hidden"];
+var hiddenTagKeys = new Set(HIDDEN_TAG_KEYS);
 // ../convex/shared/constants.ts
 var cardTypes = [
   "text",
@@ -775,7 +848,9 @@ var cardTypes = [
   "palette",
   "quote"
 ];
+var TRASH_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 var MULTIPART_UPLOAD_THRESHOLD = 8 * 1024 * 1024;
+var API_IDEMPOTENCY_KEY_TTL_MS = 24 * 60 * 60 * 1000;
 var CARD_TYPES = [...cardTypes];
 var CARD_TYPE_REGISTRY = {
   text: {
@@ -830,25 +905,40 @@ var RESERVED_KEYWORDS = [
 
 // ../convex/client/sdk.ts
 var CARD_TYPES2 = cardTypes;
-var CARD_SORTS = ["newest", "oldest"];
+var CARD_SORTS = ["newest", "oldest", "relevance", "shuffle"];
 var ERROR_CODES = [
   "AUTH_REQUIRED",
   "BAD_REQUEST",
+  "CARD_LIMIT_REACHED",
   "CONFIG_ERROR",
   "CONFLICT",
   "CONTENT_TOO_LARGE",
+  "FILE_TOO_LARGE",
+  "FOLDER_LIMIT",
+  "FORBIDDEN",
+  "IN_PROGRESS",
   "INTERNAL_ERROR",
   "INVALID_API_KEY",
   "INVALID_INPUT",
+  "INVALID_STORAGE_KEY",
   "INVALID_UTF8",
+  "LIMIT_REACHED",
   "METHOD_NOT_ALLOWED",
   "NETWORK_ERROR",
   "NOT_FOUND",
+  "NO_CONTENT",
+  "NOT_IN_TRASH",
   "PARSE_ERROR",
   "RATE_LIMITED",
   "REQUEST_FAILED",
+  "SERVICE_UNAVAILABLE",
+  "SMART_FOLDER",
+  "TAG_EXISTS",
+  "TAG_OPERATION_RUNNING",
   "TIMEOUT",
-  "UNAUTHORIZED"
+  "TYPE_MISMATCH",
+  "UNAUTHORIZED",
+  "UNSUPPORTED_TYPE"
 ];
 
 class TeakApiError extends Error {
@@ -931,6 +1021,9 @@ var buildCardsSearchParams = (input) => {
   if (input.tag?.trim()) {
     search.set("tag", input.tag.trim());
   }
+  if (input.folder?.trim()) {
+    search.set("folder", input.folder.trim());
+  }
   if (input.cursor?.trim()) {
     search.set("cursor", input.cursor.trim());
   }
@@ -943,8 +1036,20 @@ var buildCardsSearchParams = (input) => {
   if (input.trashed) {
     search.set("trashed", "true");
   }
-  if (input.sort === "oldest") {
-    search.set("sort", "oldest");
+  if (input.archived === "only" || input.archived === "include") {
+    search.set("archived", input.archived);
+  }
+  if (input.similarTo?.trim()) {
+    search.set("similarTo", input.similarTo.trim());
+  }
+  if (input.mode === "keyword" || input.mode === "semantic") {
+    search.set("mode", input.mode);
+  }
+  if (input.sort === "oldest" || input.sort === "shuffle") {
+    search.set("sort", input.sort);
+  }
+  if (input.sort === "shuffle" && typeof input.shuffleSeed === "number") {
+    search.set("shuffleSeed", String(input.shuffleSeed));
   }
   if (typeof input.createdAfter === "number") {
     search.set("createdAfter", String(input.createdAfter));
@@ -983,6 +1088,35 @@ var asPage = (value) => {
   }
   return value;
 };
+var asFolder = (value) => {
+  if (!isObject(value) || typeof value.id !== "string" || typeof value.name !== "string") {
+    throw new TeakApiError("PARSE_ERROR", "Teak returned an unexpected folder payload.");
+  }
+  return value;
+};
+var asFolders = (value) => {
+  if (!(isObject(value) && Array.isArray(value.items))) {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return { items: value.items.map(asFolder) };
+};
+var asFolderCards = (value) => {
+  if (!(isObject(value) && isStringArray(value.updatedIds) && isStringArray(value.failedIds))) {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return {
+    updatedIds: value.updatedIds,
+    failedIds: value.failedIds,
+    folderLimitIds: isStringArray(value.folderLimitIds) ? value.folderLimitIds : []
+  };
+};
+var asTagOperation = (value) => {
+  if (!isObject(value) || typeof value.id !== "string" || typeof value.status !== "string") {
+    throw new TeakApiError("PARSE_ERROR", "Teak returned an unexpected tag operation payload.");
+  }
+  const { operationId: _operationId, ...operation } = value;
+  return operation;
+};
 var asTags = (value) => {
   if (!(isObject(value) && Array.isArray(value.items))) {
     throw new TeakApiError("PARSE_ERROR");
@@ -1000,6 +1134,24 @@ var asCreate = (value) => {
   }
   return value;
 };
+var asRefresh = (value) => {
+  if (!isObject(value) || typeof value.cardId !== "string" || value.status !== "queued") {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return value;
+};
+var asSavedPdf = (value) => {
+  if (!isObject(value) || typeof value.cardId !== "string" || typeof value.created !== "boolean") {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return { cardId: value.cardId, created: value.created };
+};
+var asCardContent = (value) => {
+  if (!isObject(value) || typeof value.cardId !== "string" || typeof value.text !== "string" || typeof value.charCount !== "number" || typeof value.truncated !== "boolean" || !["document", "transcript", "content"].includes(String(value.kind))) {
+    throw new TeakApiError("PARSE_ERROR");
+  }
+  return value;
+};
 var asMe = (value) => {
   if (!(isObject(value) && isObject(value.data)) || typeof value.data.id !== "string") {
     throw new TeakApiError("PARSE_ERROR");
@@ -1074,6 +1226,25 @@ var createTeakClient = (options) => {
   const qs = (params) => buildCardsSearchParams(params);
   const idempotency = (requestOptions) => requestOptions?.idempotencyKey ? { "Idempotency-Key": requestOptions.idempotencyKey } : {};
   const cardPath = (id) => `/v1/cards/${encodeURIComponent(id)}`;
+  const folderPath = (id) => `/v1/folders/${encodeURIComponent(id)}`;
+  const 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 };
+  };
+  const createThumbnailUpload = (id, input) => request(`${cardPath(id)}/thumbnail/upload`, { body: JSON.stringify(input), method: "POST" }, asUpload);
+  const applyThumbnail = (id, fileKey) => request(`${cardPath(id)}/thumbnail`, { body: JSON.stringify({ fileKey }), method: "PUT" }, asCard);
   return {
     cards: {
       bulk: (operation, items, requestOptions) => request("/v1/cards/bulk", {
@@ -1091,13 +1262,43 @@ var createTeakClient = (options) => {
         headers: idempotency(requestOptions),
         method: "POST"
       }, asCreate),
+      content: (id) => request(`${cardPath(id)}/content`, { method: "GET" }, asCardContent),
       delete: (id, deleteOptions) => request(`${cardPath(id)}${deleteOptions?.permanent ? "?permanent=true" : ""}`, { method: "DELETE" }, () => null),
       duplicate: (url) => request(`/v1/cards/duplicate?${new URLSearchParams({ url }).toString()}`, { method: "GET" }, (v) => isObject(v) && typeof v.cardId === "string" ? v.cardId : null),
       favorites: (input = {}) => request(`/v1/cards?${qs({ include: "content,metadata", ...input, favorited: true })}`, { method: "GET" }, asPage),
       get: (id) => request(cardPath(id), { method: "GET" }, asCard),
+      links: (id) => request(cardPath(id), { method: "GET" }, (value) => {
+        const card = asCard(value);
+        return {
+          backlinks: card.backlinks ?? [],
+          backlinksTruncated: card.backlinksTruncated === true,
+          links: card.links ?? [],
+          linksTruncated: card.linksTruncated === true
+        };
+      }),
       list: (input = {}) => request(`/v1/cards?${qs(input)}`, { method: "GET" }, asPage),
+      createThumbnailUpload,
+      refresh: (id) => request(`${cardPath(id)}/refresh`, { method: "POST" }, asRefresh),
+      resetThumbnail: (id) => request(`${cardPath(id)}/thumbnail`, { method: "DELETE" }, asCard),
       restore: (id) => request(`${cardPath(id)}/restore`, { method: "POST" }, () => null),
+      similar: (id, input = {}) => request(`/v1/cards?${qs({ include: "content,metadata", ...input, similarTo: id })}`, { method: "GET" }, asPage),
       search: (input = {}) => request(`/v1/cards?${qs({ include: "content,metadata", ...input })}`, { method: "GET" }, asPage),
+      setArchived: (id, isArchived) => request(cardPath(id), { body: JSON.stringify({ isArchived }), method: "PATCH" }, asCard),
+      setThumbnail: async (id, image, mimeType) => {
+        if (isObject(image) && typeof image.fileKey === "string") {
+          return applyThumbnail(id, image.fileKey);
+        }
+        const bytes = image;
+        const fileSize = byteLengthForBody(bytes);
+        if (fileSize === null || !mimeType) {
+          throw new TeakApiError("INVALID_INPUT", "setThumbnail needs the image's bytes and its MIME type.");
+        }
+        const upload = await createThumbnailUpload(id, { fileSize, mimeType });
+        await putFile(upload.uploadUrl, bytes, mimeType);
+        return applyThumbnail(id, upload.fileKey);
+      },
+      savePdf: (id) => request(`${cardPath(id)}/save-pdf`, { method: "POST" }, asSavedPdf),
+      setDone: (id, done) => request(`${cardPath(id)}/done`, { method: done ? "POST" : "DELETE" }, asCard),
       setFavorite: (id, isFavorited) => request(`${cardPath(id)}/favorite`, { body: JSON.stringify({ isFavorited }), method: "PATCH" }, asCard),
       update: (id, input) => request(cardPath(id), { body: JSON.stringify(input), method: "PATCH" }, asCard)
     },
@@ -1105,28 +1306,26 @@ var createTeakClient = (options) => {
       latest: () => request("/v1/exports/latest", { method: "GET" }, asLatestExport),
       start: () => request("/v1/exports", { method: "POST" }, (v) => v.job)
     },
+    folders: {
+      addCards: (id, cardIds) => request(`${folderPath(id)}/cards`, { body: JSON.stringify({ cardIds }), method: "POST" }, asFolderCards),
+      create: (input) => request("/v1/folders", { body: JSON.stringify(input), method: "POST" }, asFolder),
+      delete: (id) => request(folderPath(id), { method: "DELETE" }, () => null),
+      get: (id) => request(folderPath(id), { method: "GET" }, asFolder),
+      list: () => request("/v1/folders", { method: "GET" }, asFolders),
+      removeCards: (id, cardIds) => request(`${folderPath(id)}/cards`, { body: JSON.stringify({ cardIds }), method: "DELETE" }, asFolderCards),
+      update: (id, input) => request(folderPath(id), { body: JSON.stringify(input), method: "PATCH" }, asFolder)
+    },
     me: () => request("/v1/me", { method: "GET" }, asMe),
     tags: {
-      list: () => request("/v1/tags", { method: "GET" }, asTags)
+      delete: (tag) => request("/v1/tags/delete", { body: JSON.stringify({ tag }), method: "POST" }, asTagOperation),
+      list: () => request("/v1/tags", { method: "GET" }, asTags),
+      merge: (from, into) => request("/v1/tags/merge", { body: JSON.stringify({ from, into }), method: "POST" }, asTagOperation),
+      operation: (id) => request(`/v1/tags/operations/${encodeURIComponent(id)}`, { method: "GET" }, asTagOperation),
+      rename: (from, to) => request("/v1/tags/rename", { body: JSON.stringify({ from, to }), method: "POST" }, asTagOperation)
     },
     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 };
-      }
+      putFile
     }
   };
 };
@@ -1146,6 +1345,7 @@ export {
   disconnectConnectGrant,
   discoverAuthServer,
   fetchConnectOwnerId,
+  formatBytes,
   isCardType,
   isStringList,
   normalizeLimit,

package/dist/types/client/authDiscovery.d.ts

@@ -1,4 +1,5 @@
-export declare const OAUTH_SURFACES: readonly ["cli", "raycast", "chrome", "firefox", "safari"];
+export { validateOAuthUrl } from "../shared/oauthUrl.js";
+export declare const OAUTH_SURFACES: readonly ["cli", "raycast", "chrome", "firefox"];
 export type OAuthSurface = (typeof OAUTH_SURFACES)[number];
 export interface AuthDiscovery {
     readonly authorizationEndpoint: string;
@@ -8,7 +9,6 @@ export interface AuthDiscovery {
     readonly resource: string;
     readonly tokenEndpoint: string;
 }
-export declare const validateOAuthUrl: (raw: unknown, local?: boolean) => URL;
 export declare function discoverAuthServer(siteUrl: string, options?: {
     fetch?: typeof fetch;
     forceRefresh?: boolean;

package/dist/types/client/sdk.d.ts

@@ -1,12 +1,19 @@
+export { formatBytes } from "../shared/utils/formatBytes.js";
 export { type AuthDiscovery, discoverAuthServer, type OAuthSurface, validateOAuthUrl, } from "./authDiscovery.js";
 export { type ConnectTokenResult, type ConnectTokens, createConnectAuthorizeUrl, createPkceChallenge, disconnectConnectGrant, fetchConnectOwnerId, randomBase64Url, requestConnectTokens, WORKOS_CONNECT_SCOPE, } from "./workosConnect.js";
 import { type CardType } from "../shared/constants.js";
 import type { FileKind, FilePreviewFacts } from "../shared/fileFormats.js";
+import type { FOLDER_COLORS } from "../shared/folders.js";
 export type { CardType } from "../shared/constants.js";
 export declare const CARD_TYPES: readonly ["text", "link", "image", "video", "audio", "document", "palette", "quote"];
-export declare const CARD_SORTS: readonly ["newest", "oldest"];
-export declare const ERROR_CODES: readonly ["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"];
+export declare const CARD_SORTS: readonly ["newest", "oldest", "relevance", "shuffle"];
+export declare const ERROR_CODES: readonly ["AUTH_REQUIRED", "BAD_REQUEST", "CARD_LIMIT_REACHED", "CONFIG_ERROR", "CONFLICT", "CONTENT_TOO_LARGE", "FILE_TOO_LARGE", "FOLDER_LIMIT", "FORBIDDEN", "IN_PROGRESS", "INTERNAL_ERROR", "INVALID_API_KEY", "INVALID_INPUT", "INVALID_STORAGE_KEY", "INVALID_UTF8", "LIMIT_REACHED", "METHOD_NOT_ALLOWED", "NETWORK_ERROR", "NOT_FOUND", "NO_CONTENT", "NOT_IN_TRASH", "PARSE_ERROR", "RATE_LIMITED", "REQUEST_FAILED", "SERVICE_UNAVAILABLE", "SMART_FOLDER", "TAG_EXISTS", "TAG_OPERATION_RUNNING", "TIMEOUT", "TYPE_MISMATCH", "UNAUTHORIZED", "UNSUPPORTED_TYPE"];
 export type CardSort = (typeof CARD_SORTS)[number];
+/**
+ * How a search finds cards: `hybrid` (the API's default) matches words and
+ * meaning, `keyword` words only, `semantic` meaning only.
+ */
+export type SearchMode = "hybrid" | "keyword" | "semantic";
 export type TeakApiErrorCode = (typeof ERROR_CODES)[number];
 export type FetchLike = typeof fetch;
 export interface TokenProvider {
@@ -18,11 +25,26 @@ export interface Card {
     aiTags: string[];
     aiTranscript: string | null;
     appUrl: string;
+    /** When the card was archived, or null. */
+    archivedAt: number | null;
+    /** Bar heights 0-100: 45 for a grid card, 200 for a player. */
+    audioWaveform: {
+        detail: number[];
+        grid: number[];
+    } | null;
+    /** Your cards that link to this one, most recently updated first. */
+    backlinks?: CardLinkRef[];
+    backlinksTruncated?: boolean;
     colors: Array<{
         hex: string;
         name?: string;
     }>;
     compactUrl: string | null;
+    /**
+     * When the link was marked read, watched, bought or done, or null.
+     * Servers that predate done states leave it out.
+     */
+    completedAt?: number | null;
     content: string;
     createdAt: number;
     detailUrl: string | null;
@@ -33,10 +55,25 @@ export interface Card {
     filePreview: FilePreviewFacts | null;
     fileSize: number | null;
     fileUrl: string | null;
+    /** Ids of the folders the card is in. */
+    folderIds: string[];
     id: string;
+    /** Archived cards are hidden from the library but still count. */
+    isArchived: boolean;
     isDeleted: boolean;
     isFavorited: boolean;
+    /**
+     * Tagged `secret` or `hidden`: left out of lists and searches unless the
+     * search names one of those tags (`#secret`). Servers that
+     * predate hidden cards leave it out.
+     */
+    isHidden?: boolean;
     linkAuthor: string | null;
+    /**
+     * What a link is (`article`, `movie`, `product`…), or null. A plain
+     * string: new categories are added over time.
+     */
+    linkCategory?: string | null;
     linkFacts: Array<{
         label: string;
         value: string;
@@ -53,9 +90,23 @@ export interface Card {
         posterWidth?: number;
         posterHeight?: number;
     }>;
+    /**
+     * A product link's price: `amount` in the page's currency, `currency` an
+     * ISO 4217 code or null. Null for cards without a price.
+     */
+    linkPrice: {
+        amount: number;
+        currency: string | null;
+    } | null;
     linkPublishedAt: string | null;
     linkPublisher: string | null;
     linkSiteName: string | null;
+    /**
+     * Cards this card links to with `[[Title|teak:<id>]]`, in order. Only on
+     * single-card responses (`cards.get`, update, favorite, done, create).
+     */
+    links?: CardLinkRef[];
+    linksTruncated?: boolean;
     metadataDescription: string | null;
     metadataStatus: string | null;
     metadataTitle: string | null;
@@ -64,11 +115,43 @@ export interface Card {
     placeholderUrl: string | null;
     processingStatus: Record<string, unknown> | null;
     screenshotUrl: string | null;
+    /**
+     * The title of the page in `sourceUrl`. Servers that predate sources
+     * leave it out.
+     */
+    sourceTitle?: string | null;
+    /**
+     * The page the card was saved from, such as the page a quote was selected
+     * on. Servers that predate sources leave it out.
+     */
+    sourceUrl?: string | null;
     tags: string[];
+    /** True when linkPreviewImageUrl is an image chosen for the link. */
+    thumbnailOverridden: boolean;
     thumbnailUrl: string | null;
     type: CardType | string;
     updatedAt: number;
     url: string | null;
+    /** Hover preview strip, `frames * frameWidth` wide; the URL expires. */
+    videoScrub: {
+        frameHeight: number;
+        frameWidth: number;
+        frames: number;
+        url: string;
+    } | null;
+}
+/** A linked card; `missing` when it's in Trash, deleted or not yours. */
+export interface CardLinkRef {
+    id: string;
+    missing: boolean;
+    title: string | null;
+    type: CardType | string | null;
+}
+export interface CardLinks {
+    backlinks: CardLinkRef[];
+    backlinksTruncated: boolean;
+    links: CardLinkRef[];
+    linksTruncated: boolean;
 }
 export type CardListItem = Partial<Card> & Pick<Card, "aiTags" | "appUrl" | "createdAt" | "id" | "isFavorited" | "tags" | "type" | "updatedAt">;
 export interface PageInfo {
@@ -78,6 +161,15 @@ export interface PageInfo {
 export interface CardsPage {
     items: CardListItem[];
     pageInfo: PageInfo;
+    /** With a query and `sort: "relevance"`: whether the top results were scored. */
+    relevanceRanked?: boolean;
+    /** With a query: the mode that ran (`keyword` when meaning search could not). */
+    searchMode?: SearchMode;
+    /**
+     * For similar cards: `pending` while the card is still being read, and
+     * `unavailable` for a card in Trash or not found.
+     */
+    similarity?: "ok" | "pending" | "unavailable";
 }
 export interface CardChangesResponse {
     deletedIds: string[];
@@ -88,21 +180,102 @@ export interface TagSummary {
     count: number;
     name: string;
 }
+export type FolderColor = (typeof FOLDER_COLORS)[number];
+export interface Folder {
+    /**
+     * Cards in a manual folder that are not archived or in Trash; null for a
+     * smart folder, whose cards are found when listed.
+     */
+    cardCount: number | null;
+    color: FolderColor | null;
+    createdAt: number;
+    id: string;
+    /** Manual folders hold the cards put in them; smart ones save a search. */
+    kind: "manual" | "smart";
+    name: string;
+    /** A smart folder's search; null for a manual folder. */
+    query: string | null;
+    updatedAt: number;
+}
+export type TagOperationKind = "rename" | "merge" | "delete";
+export type TagOperationStatus = "running" | "completed" | "failed";
+/** A library-wide tag rename, merge or delete, finished in the background. */
+export interface TagOperation {
+    /** Cards rewritten so far. */
+    changed: number;
+    completedAt: number | null;
+    createdAt: number;
+    error: string | null;
+    /** The tag being changed, lowercased. */
+    from: string;
+    id: string;
+    kind: TagOperationKind;
+    /** Cards looked at so far. */
+    processed: number;
+    status: TagOperationStatus;
+    /** The new name (rename) or the tag merged into (merge). */
+    to: string | null;
+    /** Cards carrying the tag when the change started. */
+    total: number;
+    updatedAt: number;
+}
+export interface FolderCardsResult {
+    failedIds: string[];
+    /** Failed cards that are already in the most folders a card can be in. */
+    folderLimitIds: string[];
+    updatedIds: string[];
+}
 export interface CreateCardInput {
+    /**
+     * Optional card type: `text`, `link`, `image`, `video`, `audio`,
+     * `document`, `palette` or `quote`. Set it to `text` to store raw Markdown
+     * exactly; omit it to keep automatic URL, quote, and palette detection.
+     * @default inferred
+     */
     cardType?: CardType;
+    /**
+     * Markdown or plain text body for the card. Prefer this for notes; use `url`
+     * when saving a link.
+     */
     content?: string;
+    /** The `ETag` the upload `PUT` returned, for a file card. */
     fileEtag?: string;
+    /** The `fileKey` from `uploads.create`, for a file card. */
     fileKey?: string;
+    /** The uploaded file's name, for a file card. */
     fileName?: string;
+    /** The uploaded file's size in bytes, for a file card. */
     fileSize?: number;
+    /** The uploaded file's MIME type, for a file card. */
     mimeType?: string;
+    /** Free-form notes attached to the card. */
     notes?: string | null;
+    /**
+     * A free label for what saved the card (extension, CLI, API, and so on),
+     * kept in its metadata. For the page the card came from, use `sourceUrl`.
+     */
     source?: string;
+    /** The page's title, beside `sourceUrl`; cut to 300 characters. */
+    sourceTitle?: string;
+    /**
+     * The page the card came from, such as the page a quote was selected on:
+     * an http or https URL of at most 2,048 characters. Unlike `url`, it never
+     * makes the card a link.
+     */
+    sourceUrl?: string;
+    /** Tags to apply on create. */
     tags?: string[];
+    /**
+     * URL to save as a link card. Teak may classify the type automatically when
+     * `cardType` is omitted.
+     */
     url?: string;
 }
 export interface UpdateCardInput {
     content?: string;
+    /** Replaces the card's folders; an empty list takes it out of every folder. */
+    folderIds?: string[];
+    isArchived?: boolean;
     metadataTitle?: string | null;
     notes?: string | null;
     /** AI tags to drop. `tags` replaces only the card's own tags. */
@@ -150,6 +323,11 @@ export interface CreateUploadInput {
     fileSize: number;
     mimeType: string;
 }
+/** A link image upload: JPEG, PNG, WebP, GIF or AVIF, under 20 MB. */
+export interface CreateThumbnailUploadInput {
+    fileSize: number;
+    mimeType: string;
+}
 export interface CreateUploadResponse {
     expiresIn: number;
     fileKey: string;
@@ -163,8 +341,37 @@ export interface CreateCardResponse {
     cardId: string;
     status: "created";
 }
+export interface RefreshCardResponse {
+    cardId: string;
+    requestedAt: number;
+    status: "queued";
+}
+/** An arXiv link's PDF saved as a document card (POST /v1/cards/:id/save-pdf). */
+export interface SavedPdf {
+    /** The document card holding the PDF. */
+    cardId: string;
+    /** False when an earlier save already made that card. */
+    created: boolean;
+}
+/** A card's full stored text (GET /v1/cards/:id/content). */
+export interface CardContent {
+    cardId: string;
+    /** Characters in the full stored text. */
+    charCount: number;
+    /**
+     * document: extracted from the card's file; transcript: its speech;
+     * content: a text or quote card's written text.
+     */
+    kind: "document" | "transcript" | "content";
+    text: string;
+    /** The document is longer than Teak keeps. */
+    truncated: boolean;
+}
+export type BulkCardsOperation = "create" | "update" | "favorite" | "delete" | "archive" | "unarchive" | "addTags" | "removeTags" | "restore";
 export interface BulkCardsResponse {
-    operation: "create" | "update" | "favorite" | "delete";
+    /** The `cardId` of every item that failed, to retry just those. */
+    failedIds: string[];
+    operation: BulkCardsOperation;
     results: unknown[];
     summary: {
         failed: number;
@@ -172,6 +379,8 @@ export interface BulkCardsResponse {
         total: number;
     };
 }
+/** Archived cards outside Trash: left out by default. */
+export type ArchivedFilter = "exclude" | "only" | "include";
 export declare class TeakApiError extends Error {
     code: TeakApiErrorCode;
     requestId?: string;
@@ -186,6 +395,9 @@ export declare class TeakApiError extends Error {
 export declare const staticTokenProvider: (token: string) => TokenProvider;
 export declare const normalizeLimit: (limit?: number) => number;
 export declare const buildCardsSearchParams: (input: {
+    archived?: ArchivedFilter;
+    /** Only cards in this folder id. */
+    folder?: string;
     createdAfter?: number;
     createdBefore?: number;
     cursor?: string;
@@ -194,7 +406,20 @@ export declare const buildCardsSearchParams: (input: {
     hue?: string | readonly string[];
     include?: string;
     limit?: number;
+    /** How `query` finds cards; the API defaults to `hybrid`. */
+    mode?: SearchMode;
+    /**
+     * Search text. Accepts qualifiers: `tag:design` or `#design`, `type:link`,
+     * `is:fav`, `is:archived`, `site:github.com`, `folder:"Reading list"`,
+     * `price:<100` (also `>`, `<=`, `>=` and `=`), `text:"total due"` (only
+     * the words Teak read in images, video thumbnails, link previews and scanned
+     * PDFs) and `"quoted phrases"`.
+     */
     query?: string;
+    /** Required with `sort: "shuffle"`: the same seed gives the same order. */
+    shuffleSeed?: number;
+    /** A card id: only the cards closest to it in meaning. */
+    similarTo?: string;
     sort?: CardSort;
     style?: string | readonly string[];
     tag?: string;
@@ -209,13 +434,18 @@ export declare const createTeakClient: (options: {
     userAgent?: string;
 }) => {
     cards: {
-        bulk: (operation: BulkCardsResponse["operation"], items: unknown[], requestOptions?: RequestOptions) => Promise<BulkCardsResponse>;
+        bulk: (operation: BulkCardsOperation, items: unknown[], requestOptions?: RequestOptions) => Promise<BulkCardsResponse>;
         changes: (input: {
             cursor?: string;
             limit?: number;
             since: number;
         }) => Promise<CardChangesResponse>;
         create: (input: CreateCardInput, requestOptions?: RequestOptions) => Promise<CreateCardResponse>;
+        /**
+         * The card's full stored text: document text, transcript, or a text
+         * card's content. Throws NO_CONTENT when the card has none.
+         */
+        content: (id: string) => Promise<CardContent>;
         /** Moves the card to Trash, or deletes it for good with `permanent`. */
         delete: (id: string, deleteOptions?: {
             permanent?: boolean;
@@ -224,9 +454,45 @@ export declare const createTeakClient: (options: {
         duplicate: (url: string) => Promise<string | null>;
         favorites: (input?: Parameters<(params: Parameters<typeof buildCardsSearchParams>[0]) => string>[0]) => Promise<CardsPage>;
         get: (id: string) => Promise<Card>;
+        /** Cards this card links to with `[[…]]`, and cards linking to it. */
+        links: (id: string) => Promise<CardLinks>;
         list: (input?: Parameters<(params: Parameters<typeof buildCardsSearchParams>[0]) => string>[0]) => Promise<CardsPage>;
+        /**
+         * A signed URL for a link card's new image; `setThumbnail` with bytes
+         * does this for you.
+         */
+        createThumbnailUpload: (id: string, input: CreateThumbnailUploadInput) => Promise<CreateUploadResponse>;
+        /** Refreshes summary, tags and link preview; it finishes in the background. */
+        refresh: (id: string) => Promise<RefreshCardResponse>;
+        /**
+         * Goes back to the image Teak found for a link card and deletes the one
+         * that replaced it. Changes nothing when the card has its own image.
+         */
+        resetThumbnail: (id: string) => Promise<Card>;
         restore: (id: string) => Promise<null>;
+        /** The cards closest in meaning to one card; never the card itself. */
+        similar: (id: string, input?: Parameters<(params: Parameters<typeof buildCardsSearchParams>[0]) => string>[0]) => Promise<CardsPage>;
         search: (input?: Parameters<(params: Parameters<typeof buildCardsSearchParams>[0]) => string>[0]) => Promise<CardsPage>;
+        /** Archives the card (hidden from the library, not deleted) or returns it. */
+        setArchived: (id: string, isArchived: boolean) => Promise<Card>;
+        /**
+         * Replaces a link card's image: uploads `bytes` (JPEG, PNG, WebP, GIF or
+         * AVIF, under 20 MB) and applies them. Pass `{ fileKey }` instead to
+         * apply an upload made with `createThumbnailUpload`.
+         */
+        setThumbnail: (id: string, image: BodyInit | {
+            fileKey: string;
+        }, mimeType?: string) => Promise<Card>;
+        /**
+         * Saves an arXiv link's paper as its own document card. Saving the same
+         * link again returns that card with `created: false`.
+         */
+        savePdf: (id: string) => Promise<SavedPdf>;
+        /**
+         * Marks a link card read, watched, bought or done (`done: true`), or
+         * not; repeating a call changes nothing. Only link cards can be marked.
+         */
+        setDone: (id: string, done: boolean) => Promise<Card>;
         setFavorite: (id: string, isFavorited: boolean) => Promise<Card>;
         update: (id: string, input: UpdateCardInput) => Promise<Card>;
     };
@@ -234,11 +500,60 @@ export declare const createTeakClient: (options: {
         latest: () => Promise<LatestExport>;
         start: () => Promise<ExportJob>;
     };
+    folders: {
+        /**
+         * Adds up to 100 cards; cards already in the folder are left as they
+         * are. A smart folder refuses cards (409 SMART_FOLDER).
+         */
+        addCards: (id: string, cardIds: string[]) => Promise<FolderCardsResult>;
+        /**
+         * Creates a folder; `{ kind: "smart", query }` saves a search, whose
+         * cards are whatever matches it when listed.
+         */
+        create: (input: {
+            color?: FolderColor;
+            kind?: "manual";
+            name: string;
+        } | {
+            color?: FolderColor;
+            kind: "smart";
+            name: string;
+            query: string;
+        }) => Promise<Folder>;
+        /** Deletes the folder; its cards are kept. */
+        delete: (id: string) => Promise<null>;
+        get: (id: string) => Promise<Folder>;
+        /** Every folder, sorted by name. */
+        list: () => Promise<{
+            items: Folder[];
+        }>;
+        removeCards: (id: string, cardIds: string[]) => Promise<FolderCardsResult>;
+        /**
+         * Renames or recolors; `color: null` clears the color. `query` changes
+         * a smart folder's search.
+         */
+        update: (id: string, input: {
+            color?: FolderColor | null;
+            name?: string;
+            query?: string;
+        }) => Promise<Folder>;
+    };
     me: () => Promise<Me>;
     tags: {
+        /**
+         * Deletes a tag from every card, including cards in Trash and Archive.
+         * It finishes in the background; poll with `operation`.
+         */
+        delete: (tag: string) => Promise<TagOperation>;
         list: () => Promise<{
             items: TagSummary[];
         }>;
+        /** Replaces `from` with `into` on every card; it finishes in the background. */
+        merge: (from: string, into: string) => Promise<TagOperation>;
+        /** A tag change's progress. */
+        operation: (id: string) => Promise<TagOperation>;
+        /** Renames a tag on every card; it finishes in the background. */
+        rename: (from: string, to: string) => Promise<TagOperation>;
     };
     uploads: {
         create: (input: CreateUploadInput) => Promise<CreateUploadResponse>;

package/dist/types/devUrls.d.ts

@@ -1,4 +1,3 @@
-/** The shared cloud dev deployment every checkout and cloud session uses. */
 export declare const TEAK_DEV_DEPLOYMENT_NAME = "reminiscent-kangaroo-59";
 export declare const DEFAULT_TEAK_DEV_APP_URL = "http://localhost:3000";
 export declare const DEFAULT_TEAK_DEV_CONVEX_URL = "https://reminiscent-kangaroo-59.convex.cloud";

package/dist/types/shared/constants.d.ts

@@ -1,33 +1,30 @@
 export declare const SIGNUPS_PAUSED_MESSAGE = "New sign-ups are paused right now. Please try again later.";
-export declare const ACCOUNT_CHANGES_PAUSED_MESSAGE = "Account changes are paused right now. Please try again later.";
 export declare const cardTypes: readonly ["text", "link", "image", "video", "audio", "document", "palette", "quote"];
 export type CardType = (typeof cardTypes)[number];
-export declare const VISUAL_STYLE_TAXONOMY: readonly ["abstract", "cinematic", "dark", "illustrative", "minimal", "monochrome", "moody", "pastel", "photographic", "retro", "surreal", "vintage", "vibrant"];
+export declare const VISUAL_STYLE_TAXONOMY: readonly ["abstract", "cinematic", "dark", "illustrative", "minimal", "monochrome", "moody", "pastel", "photographic", "retro", "surreal", "vintage", "vibrant", "typographic", "3d", "flat", "geometric", "hand-drawn", "futuristic"];
 export type VisualStyle = (typeof VISUAL_STYLE_TAXONOMY)[number];
 export declare const VISUAL_STYLE_LABELS: Record<VisualStyle, string>;
 export declare const VISUAL_STYLE_ALIAS_MAP: Record<string, VisualStyle>;
 export declare function normalizeVisualStyle(value: string): VisualStyle | null;
 export declare function normalizeVisualStyleFilters(values?: string[]): VisualStyle[];
 export declare function extractVisualStylesFromTags(tags?: string[]): VisualStyle[] | undefined;
+export declare const COLOR_CARD_TYPES: readonly CardType[];
+export declare const isColorCardType: (type: string) => boolean;
+export declare const VISUAL_STYLE_CARD_TYPES: readonly CardType[];
+export declare const isVisualStyleCardType: (type: string) => boolean;
+export declare const isVisualStyle: (value: string) => value is VisualStyle;
 export declare const COLOR_HUE_BUCKETS: readonly ["red", "orange", "yellow", "green", "teal", "cyan", "blue", "purple", "pink", "brown", "neutral"];
 export type ColorHueBucket = (typeof COLOR_HUE_BUCKETS)[number];
 export declare const COLOR_HUE_LABELS: Record<ColorHueBucket, string>;
 export declare const COLOR_HUE_ALIAS_MAP: Record<string, ColorHueBucket>;
 export declare function normalizeColorHueBucket(value: string): ColorHueBucket | null;
 export declare function normalizeHueFilters(values?: string[]): ColorHueBucket[];
-/**
- * Maximum number of cards allowed for free tier users
- */
 export declare const FREE_TIER_LIMIT = 200;
-/**
- * Maximum file size for uploads (100MB in bytes)
- */
+export declare const TRASH_RETENTION_MS: number;
 export { MAX_FILE_SIZE } from "./fileFormats.js";
-/**
- * Maximum number of files that can be uploaded at once
- */
-export declare const MAX_FILES_PER_UPLOAD = 5;
+export declare const MAX_FILES_PER_UPLOAD = 20;
 export declare const MULTIPART_UPLOAD_THRESHOLD: number;
+export declare const API_IDEMPOTENCY_KEY_TTL_MS: number;
 export declare const CARD_ERROR_CODES: {
     readonly CARD_LIMIT_REACHED: "CARD_LIMIT_REACHED";
     readonly CONTENT_TOO_LARGE: "CONTENT_TOO_LARGE";
@@ -40,45 +37,23 @@ export declare const CARD_ERROR_CODES: {
 };
 export type CardErrorCode = (typeof CARD_ERROR_CODES)[keyof typeof CARD_ERROR_CODES];
 export declare const CARD_ERROR_MESSAGES: Record<CardErrorCode, string>;
-/**
- * All card types as readonly array
- */
 export declare const CARD_TYPES: readonly CardType[];
-/**
- * Card type labels for UI display
- */
 export declare const CARD_TYPE_LABELS: Record<CardType, string>;
-/**
- * Card type icons mapping (for UI components)
- */
 export declare const CARD_TYPE_ICONS: Record<CardType, string>;
-/**
- * Card type configuration registry for centralized management
- */
 export interface CardTypeConfig {
     icon: string;
     label: string;
     searchLabel: string;
 }
 export declare const CARD_TYPE_REGISTRY: Record<CardType, CardTypeConfig>;
-/**
- * Helper functions for card type configuration
- */
 export declare function getCardTypeConfig(cardType: CardType): CardTypeConfig;
 export declare function getCardTypeIcon(cardType: CardType): string;
 export declare function getCardTypeLabel(cardType: CardType): string;
-/**
- * Typeahead option for search/filter dropdowns
- */
 export interface TypeaheadOption {
     label: string;
     value: CardType | "favorites" | "trash";
 }
-/**
- * Reserved keywords for search functionality
- */
 export declare const RESERVED_KEYWORDS: TypeaheadOption[];
-/**
- * Type guard to check if a value is a valid CardType
- */
 export declare function isCardType(value: unknown): value is CardType;
+export { TEAK_FILES_ORIGINS } from "./filesOrigins.js";
+export { HIDDEN_TAG_KEYS, isCardHidden, isHiddenTagList } from "./tags.js";

package/dist/types/shared/filesOrigins.d.ts

@@ -0,0 +1,4 @@
+export declare const TEAK_FILES_ORIGINS: {
+    readonly production: "https://files.teakvault.com";
+    readonly development: "https://teak-files-dev.praveenjuge.workers.dev";
+};

package/dist/types/shared/folders.d.ts

@@ -0,0 +1,27 @@
+export declare const MAX_FOLDERS_PER_USER = 500;
+export declare const MAX_FOLDERS_PER_CARD = 50;
+export declare const MAX_FOLDER_NAME_LENGTH = 300;
+export declare const MAX_FOLDER_CARD_IDS = 100;
+export declare const MAX_SMART_FOLDER_QUERY_LENGTH = 500;
+export type FolderKind = "manual" | "smart";
+export declare const FOLDER_COLORS: readonly ["gray", "red", "orange", "amber", "green", "teal", "blue", "violet", "pink"];
+export type FolderColor = (typeof FOLDER_COLORS)[number];
+export declare const isFolderColor: (value: unknown) => value is FolderColor;
+export declare const FOLDER_ERROR_MESSAGES: {
+    readonly DUPLICATE_NAME: "A folder with this name already exists";
+    readonly EMPTY_NAME: "Name the folder";
+    readonly NAME_TOO_LONG: "Folder names can be at most 300 characters";
+    readonly TOO_MANY_FOLDERS: "You can have up to 500 folders";
+    readonly TOO_MANY_FOLDERS_ON_CARD: "A card can be in up to 50 folders";
+    readonly NOT_FOUND: "Folder not found";
+    readonly EMPTY_QUERY: "Add a search for the smart folder";
+    readonly QUERY_TOO_LONG: "Smart folder searches can be at most 500 characters";
+    readonly SMART_FOLDER_IN_QUERY: "A smart folder's search can't use another smart folder";
+    readonly SMART_FOLDER_MEMBERSHIP: "Cards can't be added to a smart folder; it shows the cards that match its search";
+    readonly QUERY_ON_MANUAL_FOLDER: "Only smart folders have a search";
+    readonly SMART_FOLDER_TRASH: "Smart folders don't show Trash. To search for the word, put it in quotes";
+};
+export declare const normalizeFolderName: (name: string) => string;
+export declare const folderNameKey: (name: string) => string;
+export declare const explainInvalidFolderName: (name: string) => string | null;
+export declare const explainInvalidSmartFolderQuery: (canonical: string) => string | null;

package/dist/types/shared/oauthUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const isLoopbackHostname: (hostname: string) => boolean;
+export declare const validateOAuthUrl: (raw: unknown, local?: boolean) => URL;

package/dist/types/shared/tags.d.ts

@@ -0,0 +1,37 @@
+export declare const MAX_TAG_NAME_LENGTH = 64;
+export declare const TAG_OPERATION_COUNT_LIMIT = 10000;
+export declare const TAG_OPERATION_STALL_MS: number;
+export type TagOperationKind = "rename" | "merge" | "delete";
+export type TagOperationStatus = "running" | "completed" | "failed";
+export declare const TAG_ERROR_MESSAGES: {
+    readonly EMPTY_NAME: "Name the tag";
+    readonly NAME_TOO_LONG: "Tags can be at most 64 characters";
+    readonly NOT_FOUND: "Tag not found";
+    readonly SAME_TAG: "Choose a different tag to merge into";
+    readonly OPERATION_RUNNING: "Another tag change is still running";
+    readonly OPERATION_NOT_FOUND: "Tag operation not found";
+};
+export declare const tagKey: (tag: string) => string;
+export declare const HIDDEN_TAG_KEYS: readonly ["secret", "hidden"];
+export declare const isHiddenTagList: (tags: readonly string[] | null | undefined) => boolean;
+export declare const isCardHidden: (card: {
+    isHidden?: true;
+    tags?: readonly string[];
+}) => boolean;
+export declare const explainInvalidTagName: (name: string) => string | null;
+export declare const MAX_TAG_KEY_LENGTH = 256;
+export declare const explainInvalidTagSource: (name: string) => string | null;
+export declare const tagExistsMessage: (name: string) => string;
+export type TagRewrite = {
+    kind: "delete";
+    from: string;
+} | {
+    kind: "rename";
+    from: string;
+    to: string;
+} | {
+    kind: "merge";
+    from: string;
+    to: string;
+};
+export declare const rewriteTagList: (tags: readonly string[] | undefined, rewrite: TagRewrite) => string[] | null;

package/dist/types/shared/utils/codePoints.d.ts

@@ -0,0 +1,2 @@
+export declare const codePointLength: (text: string) => number;
+export declare const truncateCodePoints: (text: string, max: number) => string;

package/dist/types/shared/utils/formatBytes.d.ts

@@ -0,0 +1 @@
+export declare const formatBytes: (bytes?: number | null) => string;

package/dist/types/shared/workosResources.d.ts

@@ -1,4 +1,7 @@
-export declare const WORKOS_RESOURCES: {
-    readonly api: "https://teakvault.com/api";
-    readonly mcp: "https://teakvault.com/mcp";
-};
+export interface WorkosResources {
+    readonly api: string;
+    readonly mcp: string;
+}
+export declare const PRODUCTION_WORKOS_RESOURCE_ORIGIN = "https://teakvault.com";
+export declare const workosResourcesFor: (url: string) => WorkosResources;
+export declare const PRODUCTION_WORKOS_RESOURCES: WorkosResources;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teak-sdk",
-  "version": "1.0.86",
+  "version": "1.0.87",
   "description": "Teak API client and OAuth discovery for browser and Node applications.",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
   "devDependencies": {
     "@teak/convex": "workspace:*",
     "@types/bun": "^1.4.0",
-    "@types/node": "^26.2.0",
+    "@types/node": "^26.6.5",
     "typescript": "^6.0.3"
   },
   "publishConfig": {