@lobehub/edge-contract 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LobeHub
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,20 @@
-# Temporary Holding Version
+# @lobehub/edge-contract
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Edge logic that more than one LobeHub repository has to agree on, kept in exactly one place.
+The gateway, landing, lobehub-cloud and lobe-chat import it instead of carrying copies.
+
+| Subpath | What it owns |
+| --- | --- |
+| `./landing-locales` | The URL path prefixes landing serves, and the default (`en`, at the bare path). |
+| `./seo-topics` | The discover topics landing server-renders for `?q=`. |
+| `./request-locale` | The app locale list and how a request picks one (`hl`, then the `LOBE_LOCALE` cookie, then Accept-Language). |
+| `./last-workspace-cookie` | The `LOBE_LAST_WORKSPACE` cookie format. |
+| `./acquisition-context` | The signed `lh_acq` first-touch cookie, landing click ids and the attribution params lifted onto `/signin`. |
+
+`fixtures/*.json` are golden cases (`{ cases: [{ name, input, expected }] }`) captured from the
+implementations this package replaced. They are frozen: a change that fails one is a behavior
+change every consumer will see, so update the case on purpose, in the same commit.
+
+Design: `lobehub-gateway/docs/ryugi/specs/2026-11-06-logic-dedupe-design.md`.
+
+Releases: bump `version`, push a `v<version>` tag; CI publishes to npm.

package/dist/acquisition-context.d.ts

@@ -0,0 +1,12 @@
+export declare const ACQUISITION_CONTEXT_COOKIE = "lh_acq";
+export declare const ACQUISITION_CONTEXT_MAX_AGE_SECONDS: number;
+export interface AcquisitionContext {
+    capturedAt: string;
+    lhCid: string;
+}
+export declare const parseLandingClickId: (value: unknown) => string | undefined;
+export declare const captureAcquisitionContext: (request: Pick<Request, "url">, now?: Date) => AcquisitionContext | null;
+export declare const signAcquisitionContext: (context: AcquisitionContext, secret: string) => Promise<string>;
+export declare const verifyAcquisitionContext: (token: string, secret: string, now?: Date) => Promise<AcquisitionContext | null>;
+export declare const readAcquisitionContextCookie: (cookieHeader: string | null) => string | null;
+export declare const ATTRIBUTION_PARAMS: ReadonlySet<string>;

package/dist/acquisition-context.js

@@ -0,0 +1,175 @@
+export const ACQUISITION_CONTEXT_COOKIE = 'lh_acq';
+export const ACQUISITION_CONTEXT_MAX_AGE_SECONDS = 30 * 24 * 60 * 60;
+const ACQUISITION_CONTEXT_VERSION = 1;
+const MAX_COOKIE_LENGTH = 1024;
+const MAX_FUTURE_SKEW_MS = 5 * 60 * 1000;
+const SIGNING_SCOPE = 'lh-acquisition-context.v1:';
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+const AUTH_PATHS = new Set(['/signin', '/signup']);
+// Landing issues lh_cid with crypto.randomUUID(). Treat it only as an opaque correlation ID.
+const LH_CID_PATTERN = /^[\da-f]{8}-[\da-f]{4}-4[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/i;
+export const parseLandingClickId = (value) => {
+    if (typeof value !== 'string' || !LH_CID_PATTERN.test(value))
+        return;
+    return value.toLowerCase();
+};
+const sanitizeCapturedAt = (value) => {
+    if (typeof value !== 'string')
+        return;
+    const timestamp = Date.parse(value);
+    if (!Number.isFinite(timestamp))
+        return;
+    return new Date(timestamp).toISOString();
+};
+const sanitizeContext = (value) => {
+    if (!value || typeof value !== 'object')
+        return null;
+    const candidate = value;
+    if (candidate.version !== ACQUISITION_CONTEXT_VERSION)
+        return null;
+    const capturedAt = sanitizeCapturedAt(candidate.capturedAt);
+    const lhCid = parseLandingClickId(candidate.lhCid);
+    if (!capturedAt || !lhCid)
+        return null;
+    return { capturedAt, lhCid };
+};
+const serializeContext = (context) => ({
+    capturedAt: context.capturedAt,
+    lhCid: context.lhCid,
+    version: ACQUISITION_CONTEXT_VERSION,
+});
+const encodeBase64Url = (value) => {
+    let binary = '';
+    for (const byte of value)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll('+', '-').replaceAll('/', '_').replace(/=+$/, '');
+};
+const decodeBase64Url = (value) => {
+    if (!/^[\w-]+$/.test(value))
+        throw new Error('Invalid base64url value');
+    const base64 = value.replaceAll('-', '+').replaceAll('_', '/');
+    const padded = base64.padEnd(base64.length + ((4 - (base64.length % 4)) % 4), '=');
+    const binary = atob(padded);
+    const decoded = new Uint8Array(binary.length);
+    for (let index = 0; index < binary.length; index += 1) {
+        decoded[index] = binary.charCodeAt(index);
+    }
+    return decoded;
+};
+const importSigningKey = (secret, usages) => crypto.subtle.importKey('raw', textEncoder.encode(secret), { hash: 'SHA-256', name: 'HMAC' }, false, usages);
+const getSigningInput = (payload) => textEncoder.encode(`${SIGNING_SCOPE}${payload}`).buffer;
+const getCaptureUrl = (requestUrl) => {
+    if (!AUTH_PATHS.has(requestUrl.pathname))
+        return requestUrl;
+    const callbackUrl = requestUrl.searchParams.get('callbackUrl');
+    if (!callbackUrl)
+        return requestUrl;
+    try {
+        const parsed = new URL(callbackUrl, requestUrl.origin);
+        return parsed.origin === requestUrl.origin ? parsed : requestUrl;
+    }
+    catch {
+        return requestUrl;
+    }
+};
+export const captureAcquisitionContext = (request, now = new Date()) => {
+    const requestUrl = new URL(request.url);
+    const captureUrl = getCaptureUrl(requestUrl);
+    const lhCid = parseLandingClickId(captureUrl.searchParams.get('lh_cid')) ??
+        parseLandingClickId(requestUrl.searchParams.get('lh_cid'));
+    if (!lhCid)
+        return null;
+    return {
+        capturedAt: now.toISOString(),
+        lhCid,
+    };
+};
+export const signAcquisitionContext = async (context, secret) => {
+    if (!secret)
+        throw new Error('Acquisition context signing secret is required');
+    const sanitized = sanitizeContext({
+        ...context,
+        version: ACQUISITION_CONTEXT_VERSION,
+    });
+    if (!sanitized)
+        throw new Error('Invalid acquisition context');
+    const payload = encodeBase64Url(textEncoder.encode(JSON.stringify(serializeContext(sanitized))));
+    const key = await importSigningKey(secret, ['sign']);
+    const signature = new Uint8Array(await crypto.subtle.sign('HMAC', key, getSigningInput(payload)));
+    const token = `${payload}.${encodeBase64Url(signature)}`;
+    if (token.length > MAX_COOKIE_LENGTH)
+        throw new Error('Acquisition context cookie is too large');
+    return token;
+};
+export const verifyAcquisitionContext = async (token, secret, now = new Date()) => {
+    if (!token || !secret || token.length > MAX_COOKIE_LENGTH)
+        return null;
+    try {
+        const parts = token.split('.');
+        if (parts.length !== 2)
+            return null;
+        const [payload, encodedSignature] = parts;
+        const key = await importSigningKey(secret, ['verify']);
+        const valid = await crypto.subtle.verify('HMAC', key, decodeBase64Url(encodedSignature), getSigningInput(payload));
+        if (!valid)
+            return null;
+        const context = sanitizeContext(JSON.parse(textDecoder.decode(decodeBase64Url(payload))));
+        if (!context)
+            return null;
+        const capturedAt = Date.parse(context.capturedAt);
+        const nowTimestamp = now.getTime();
+        if (capturedAt > nowTimestamp + MAX_FUTURE_SKEW_MS ||
+            nowTimestamp - capturedAt > ACQUISITION_CONTEXT_MAX_AGE_SECONDS * 1000) {
+            return null;
+        }
+        return context;
+    }
+    catch {
+        return null;
+    }
+};
+export const readAcquisitionContextCookie = (cookieHeader) => {
+    if (!cookieHeader)
+        return null;
+    for (const part of cookieHeader.split(';')) {
+        const separator = part.indexOf('=');
+        if (separator < 0)
+            continue;
+        const name = part.slice(0, separator).trim();
+        if (name !== ACQUISITION_CONTEXT_COOKIE)
+            continue;
+        const value = part.slice(separator + 1).trim();
+        try {
+            return decodeURIComponent(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+};
+// Non-utm_* attribution params posthog-js auto-captures (its CAMPAIGN_PARAMS minus the five
+// utm_* keys). Whoever redirects a visitor to /signin lifts these, plus every utm_*, onto the
+// top-level URL so PostHog's $pageview there records them.
+export const ATTRIBUTION_PARAMS = new Set([
+    'gad_source',
+    'mc_cid',
+    'gclid',
+    'gclsrc',
+    'dclid',
+    'gbraid',
+    'wbraid',
+    'fbclid',
+    'msclkid',
+    'twclid',
+    'li_fat_id',
+    'igshid',
+    'ttclid',
+    'rdt_cid',
+    'epik',
+    'qclid',
+    'sccid',
+    'irclid',
+    '_kx',
+]);

package/dist/landing-locales.d.ts

@@ -0,0 +1,4 @@
+export declare const landingLocales: readonly ["en", "zh", "zh-TW", "ja", "ko", "de", "es", "ar", "fr", "pt-BR", "ru", "tr", "pl", "nl", "it", "vi-VN", "bg"];
+export type LandingLocale = (typeof landingLocales)[number];
+export declare const DEFAULT_LANDING_LOCALE = "en";
+export declare const isLandingLocale: (value: string | undefined) => value is LandingLocale;

package/dist/landing-locales.js

@@ -0,0 +1,22 @@
+// The URL path prefixes landing serves. `en` is the default and lives at the bare path.
+export const landingLocales = [
+    'en',
+    'zh',
+    'zh-TW',
+    'ja',
+    'ko',
+    'de',
+    'es',
+    'ar',
+    'fr',
+    'pt-BR',
+    'ru',
+    'tr',
+    'pl',
+    'nl',
+    'it',
+    'vi-VN',
+    'bg',
+];
+export const DEFAULT_LANDING_LOCALE = 'en';
+export const isLandingLocale = (value) => Boolean(value && landingLocales.includes(value));

package/dist/last-workspace-cookie.d.ts

@@ -0,0 +1,7 @@
+export declare const LAST_WORKSPACE_COOKIE = "LOBE_LAST_WORKSPACE";
+export declare const LAST_WORKSPACE_COOKIE_MAX_AGE: number;
+export declare const LAST_WORKSPACE_SLUG_PATTERN: RegExp;
+export declare const LAST_WORKSPACE_SLUG_MIN = 3;
+export declare const LAST_WORKSPACE_SLUG_MAX = 32;
+export declare const formatLastWorkspaceCookie: (userId: string, slug: string) => string | null;
+export declare const parseLastWorkspaceCookie: (raw: string | undefined | null, userId: string | undefined | null) => string | null;

package/dist/last-workspace-cookie.js

@@ -0,0 +1,30 @@
+// Not httpOnly: the client rewrites it on every explicit workspace switch. It carries no
+// authority (workspace scope is the `X-Workspace-Id` header, checked against membership), so
+// a forged value only sends its own browser to a URL that 404s.
+export const LAST_WORKSPACE_COOKIE = 'LOBE_LAST_WORKSPACE';
+export const LAST_WORKSPACE_COOKIE_MAX_AGE = 60 * 60 * 24 * 90;
+// The same shape as lobehub-cloud's WORKSPACE_SLUG_PATTERN / _MIN / _MAX, kept here rather than
+// imported because that module also carries the reserved-slug tables, which no edge bundle
+// should pay for. Anything failing it is ignored rather than sanitized, so a tampered cookie
+// cannot smuggle `../`, a protocol or CRLF into a Location header.
+export const LAST_WORKSPACE_SLUG_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+export const LAST_WORKSPACE_SLUG_MIN = 3;
+export const LAST_WORKSPACE_SLUG_MAX = 32;
+const isValidSlug = (slug) => slug.length >= LAST_WORKSPACE_SLUG_MIN &&
+    slug.length <= LAST_WORKSPACE_SLUG_MAX &&
+    LAST_WORKSPACE_SLUG_PATTERN.test(slug);
+export const formatLastWorkspaceCookie = (userId, slug) => isValidSlug(slug) ? `${userId}:${slug}` : null;
+// Format and ownership only: whether the slug still names a workspace the user belongs to
+// needs the workspace list, so staleness is healed on the client.
+export const parseLastWorkspaceCookie = (raw, userId) => {
+    if (!raw || !userId)
+        return null;
+    // A userId never contains `:`, so the first one is the separator.
+    const separator = raw.indexOf(':');
+    if (separator <= 0)
+        return null;
+    if (raw.slice(0, separator) !== userId)
+        return null;
+    const slug = raw.slice(separator + 1);
+    return isValidSlug(slug) ? slug : null;
+};

package/dist/request-locale.d.ts

@@ -0,0 +1,13 @@
+export declare const appLocales: readonly ["ar", "bg-BG", "de-DE", "en-US", "es-ES", "fr-FR", "ja-JP", "ko-KR", "pt-BR", "ru-RU", "tr-TR", "zh-CN", "zh-TW", "vi-VN", "fa-IR", "it-IT", "pl-PL", "nl-NL"];
+export type AppLocale = (typeof appLocales)[number];
+export declare const DEFAULT_APP_LOCALE = "en-US";
+export declare const LOCALE_QUERY_PARAM = "hl";
+export declare const LOCALE_COOKIE = "LOBE_LOCALE";
+export interface LocaleVocabulary<T extends string> {
+    fallback: T;
+    tags: readonly T[];
+}
+export declare function matchLocaleTag(tag: string | undefined): AppLocale | undefined;
+export declare function matchLocaleTag<T extends string>(tag: string | undefined, tags: readonly T[]): T | undefined;
+export declare function resolveRequestLocale(request: Request): AppLocale;
+export declare function resolveRequestLocale<T extends string>(request: Request, vocabulary: LocaleVocabulary<T>): T;

package/dist/request-locale.js

@@ -0,0 +1,97 @@
+export const appLocales = [
+    'ar',
+    'bg-BG',
+    'de-DE',
+    'en-US',
+    'es-ES',
+    'fr-FR',
+    'ja-JP',
+    'ko-KR',
+    'pt-BR',
+    'ru-RU',
+    'tr-TR',
+    'zh-CN',
+    'zh-TW',
+    'vi-VN',
+    'fa-IR',
+    'it-IT',
+    'pl-PL',
+    'nl-NL',
+];
+export const DEFAULT_APP_LOCALE = 'en-US';
+export const LOCALE_QUERY_PARAM = 'hl';
+export const LOCALE_COOKIE = 'LOBE_LOCALE';
+const AUTO_LOCALE = 'auto';
+const APP_VOCABULARY = { fallback: DEFAULT_APP_LOCALE, tags: appLocales };
+const decodeCookieValue = (value) => {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+};
+const readCookie = (header, name) => {
+    if (!header)
+        return undefined;
+    for (const part of header.split(';')) {
+        const separator = part.indexOf('=');
+        if (separator === -1 || part.slice(0, separator).trim() !== name)
+            continue;
+        return decodeCookieValue(part.slice(separator + 1).trim());
+    }
+    return undefined;
+};
+// Accept-Language is case-insensitive but the vocabulary is canonical BCP 47: without this,
+// `zh-cn` misses `zh-CN` and silently degrades to the fallback.
+const canonicalizeTag = (tag) => {
+    const [language = '', ...rest] = tag.split('-');
+    return [
+        language.toLowerCase(),
+        ...rest.map((part) => (part.length === 2 ? part.toUpperCase() : part)),
+    ].join('-');
+};
+// Aliases resolve to a prefix rather than a fixed tag, so a vocabulary without the aliased
+// language simply finds nothing.
+const aliasPrefix = (lowerTag) => {
+    if (lowerTag.startsWith('ar'))
+        return 'ar';
+    if (lowerTag.startsWith('fa'))
+        return 'fa';
+    if (lowerTag.startsWith('cn'))
+        return 'zh-CN';
+    if (lowerTag.startsWith('zh-hans'))
+        return 'zh-CN';
+    if (lowerTag.startsWith('zh-hant'))
+        return 'zh-TW';
+    return undefined;
+};
+export function matchLocaleTag(tag, tags = appLocales) {
+    if (!tag)
+        return undefined;
+    const candidate = aliasPrefix(tag.toLowerCase()) ?? canonicalizeTag(tag);
+    return tags.find((supported) => supported.startsWith(candidate));
+}
+const parseAcceptLanguage = (header) => (header ?? '')
+    .split(',')
+    .map((part) => {
+    const [tag = '', ...params] = part.trim().split(';');
+    const quality = params.map((param) => param.trim()).find((param) => param.startsWith('q='));
+    const weight = quality ? Number(quality.slice(2)) : 1;
+    return { tag: tag.trim(), weight: Number.isFinite(weight) ? weight : 0 };
+})
+    .filter((candidate) => candidate.tag.length > 0 && candidate.tag !== '*')
+    .sort((a, b) => b.weight - a.weight)
+    .map((candidate) => candidate.tag);
+export function resolveRequestLocale(request, { fallback, tags } = APP_VOCABULARY) {
+    const explicit = new URL(request.url).searchParams.get(LOCALE_QUERY_PARAM) ||
+        readCookie(request.headers.get('cookie'), LOCALE_COOKIE);
+    if (explicit && explicit !== AUTO_LOCALE)
+        return matchLocaleTag(explicit, tags) ?? fallback;
+    for (const tag of parseAcceptLanguage(request.headers.get('accept-language'))) {
+        const matched = matchLocaleTag(tag, tags);
+        if (matched)
+            return matched;
+    }
+    return fallback;
+}

package/dist/seo-topics.d.ts

@@ -0,0 +1,261 @@
+export declare const SEO_TOPICS: {
+    readonly agent: {
+        readonly aliyun: "Aliyun";
+        readonly baichuan: "Baichuan";
+        readonly baidu: "Baidu";
+        readonly bilibili: "Bilibili";
+        readonly chatgpt: "ChatGPT";
+        readonly claude: "Claude";
+        readonly 'claude-code': "Claude Code";
+        readonly clawdbot: "ClawdBot";
+        readonly coding: "Coding";
+        readonly codx: "Codx";
+        readonly crewai: "CrewAI";
+        readonly cursor: "Cursor";
+        readonly deepseek: "DeepSeek";
+        readonly design: "Design";
+        readonly dingtalk: "DingTalk";
+        readonly discord: "Discord";
+        readonly doubao: "Doubao";
+        readonly douyin: "Douyin";
+        readonly education: "Education";
+        readonly excel: "Microsoft Excel";
+        readonly feishu: "Feishu";
+        readonly gemini: "Gemini";
+        readonly github: "GitHub";
+        readonly hunyuan: "Hunyuan";
+        readonly image: "Image";
+        readonly jd: "JD.com";
+        readonly kimi: "Kimi";
+        readonly kuaishou: "Kuaishou";
+        readonly langchain: "LangChain";
+        readonly line: "Line";
+        readonly manus: "Manus";
+        readonly marketing: "Marketing";
+        readonly memory: "Memory";
+        readonly moltbot: "MoltBot";
+        readonly notion: "Notion";
+        readonly office: "Office";
+        readonly ollama: "Ollama";
+        readonly openai: "OpenAI";
+        readonly openclaw: "OpenClaw";
+        readonly pdf: "PDF";
+        readonly pinduoduo: "Pinduoduo";
+        readonly programming: "Programming";
+        readonly qwen: "Qwen";
+        readonly rag: "RAG";
+        readonly reddit: "Reddit";
+        readonly research: "Research";
+        readonly slack: "Slack";
+        readonly taobao: "Taobao";
+        readonly telegram: "Telegram";
+        readonly tencent: "Tencent";
+        readonly tongyi: "Tongyi";
+        readonly toutiao: "Toutiao";
+        readonly translation: "Translation";
+        readonly vscode: "VS Code";
+        readonly wechat: "WeChat";
+        readonly wecom: "WeCom";
+        readonly weibo: "Weibo";
+        readonly wenxin: "Wenxin";
+        readonly writing: "Writing";
+        readonly xiaohongshu: "Xiaohongshu";
+        readonly youtube: "YouTube";
+        readonly zhipu: "Zhipu";
+        readonly 京东: "京东";
+        readonly 今日头条: "今日头条";
+        readonly 企业微信: "企业微信";
+        readonly 公众号: "公众号";
+        readonly 写作: "写作";
+        readonly 哔哩哔哩: "哔哩哔哩";
+        readonly 小红书: "小红书";
+        readonly 微信: "微信";
+        readonly 微博: "微博";
+        readonly 快手: "快手";
+        readonly 抖音: "抖音";
+        readonly 拼多多: "拼多多";
+        readonly 推特: "推特";
+        readonly 淘宝: "淘宝";
+        readonly 百度: "百度";
+        readonly 营销: "营销";
+        readonly 论文: "论文";
+        readonly 豆包: "豆包";
+        readonly 运营: "运营";
+        readonly 钉钉: "钉钉";
+        readonly 阿里云: "阿里云";
+        readonly 飞书: "飞书";
+    };
+    readonly mcp: {
+        readonly aliyun: "Aliyun";
+        readonly aws: "AWS";
+        readonly azure: "Azure";
+        readonly baidu: "Baidu";
+        readonly bilibili: "Bilibili";
+        readonly bitbucket: "Bitbucket";
+        readonly blender: "Blender";
+        readonly brave: "Brave";
+        readonly chrome: "Chrome";
+        readonly confluence: "Confluence";
+        readonly deepseek: "DeepSeek";
+        readonly dingtalk: "DingTalk";
+        readonly discord: "Discord";
+        readonly excel: "Microsoft Excel";
+        readonly feishu: "Feishu";
+        readonly fhir: "FHIR";
+        readonly figma: "Figma";
+        readonly firebase: "Firebase";
+        readonly firecrawl: "Firecrawl";
+        readonly gemini: "Gemini";
+        readonly git: "Git";
+        readonly github: "GitHub";
+        readonly gitlab: "GitLab";
+        readonly gmail: "Gmail";
+        readonly godot: "Godot";
+        readonly google: "Google";
+        readonly 'google-calendar': "Google Calendar";
+        readonly grafana: "Grafana";
+        readonly 'home-assistant': "Home Assistant";
+        readonly huawei: "Huawei";
+        readonly image: "Image";
+        readonly jd: "JD.com";
+        readonly jetbrains: "JetBrains";
+        readonly jira: "Jira";
+        readonly kuaishou: "Kuaishou";
+        readonly kubernetes: "Kubernetes";
+        readonly line: "Line";
+        readonly linkedin: "LinkedIn";
+        readonly memory: "Memory";
+        readonly mongo: "MongoDB";
+        readonly mysql: "MySQL";
+        readonly neo4j: "Neo4j";
+        readonly notion: "Notion";
+        readonly obsidian: "Obsidian";
+        readonly ollama: "Ollama";
+        readonly openapi: "OpenAPI";
+        readonly outlook: "Outlook";
+        readonly pdf: "PDF";
+        readonly perplexity: "Perplexity";
+        readonly playwright: "Playwright";
+        readonly postgres: "PostgreSQL";
+        readonly python: "Python";
+        readonly qdrant: "Qdrant";
+        readonly rag: "RAG";
+        readonly reddit: "Reddit";
+        readonly salesforce: "Salesforce";
+        readonly sheets: "Google Sheets";
+        readonly shopify: "Shopify";
+        readonly slack: "Slack";
+        readonly spotify: "Spotify";
+        readonly sql: "SQL";
+        readonly sqlite: "SQLite";
+        readonly steam: "Steam";
+        readonly stripe: "Stripe";
+        readonly supabase: "Supabase";
+        readonly taobao: "Taobao";
+        readonly tavily: "Tavily";
+        readonly telegram: "Telegram";
+        readonly tencent: "Tencent";
+        readonly unity: "Unity";
+        readonly 'unity-editor': "Unity Editor";
+        readonly vercel: "Vercel";
+        readonly wechat: "WeChat";
+        readonly wecom: "WeCom";
+        readonly whatsapp: "WhatsApp";
+        readonly word: "Microsoft Word";
+        readonly 'x-twitter': "X (Twitter)";
+        readonly youtube: "YouTube";
+        readonly zapier: "Zapier";
+        readonly zhihu: "Zhihu";
+        readonly 京东: "京东";
+        readonly 企业微信: "企业微信";
+        readonly 哔哩哔哩: "哔哩哔哩";
+        readonly 微信: "微信";
+        readonly 快手: "快手";
+        readonly 淘宝: "淘宝";
+        readonly 百度: "百度";
+        readonly 知乎: "知乎";
+        readonly 钉钉: "钉钉";
+        readonly 阿里云: "阿里云";
+        readonly 飞书: "飞书";
+    };
+    readonly skills: {
+        readonly aliyun: "Aliyun";
+        readonly aws: "AWS";
+        readonly baidu: "Baidu";
+        readonly bilibili: "Bilibili";
+        readonly chatgpt: "ChatGPT";
+        readonly claude: "Claude";
+        readonly 'claude-code': "Claude Code";
+        readonly clawdbot: "ClawdBot";
+        readonly cline: "Cline";
+        readonly codex: "Codex";
+        readonly codx: "Codx";
+        readonly copilot: "GitHub Copilot";
+        readonly cursor: "Cursor";
+        readonly database: "Database";
+        readonly dingtalk: "DingTalk";
+        readonly discord: "Discord";
+        readonly docker: "Docker";
+        readonly excel: "Microsoft Excel";
+        readonly feishu: "Feishu";
+        readonly figma: "Figma";
+        readonly firebase: "Firebase";
+        readonly git: "Git";
+        readonly github: "GitHub";
+        readonly huawei: "Huawei";
+        readonly image: "Image";
+        readonly jd: "JD.com";
+        readonly kuaishou: "Kuaishou";
+        readonly kubernetes: "Kubernetes";
+        readonly line: "Line";
+        readonly manus: "Manus";
+        readonly memory: "Memory";
+        readonly moltbot: "MoltBot";
+        readonly mysql: "MySQL";
+        readonly notion: "Notion";
+        readonly ollama: "Ollama";
+        readonly openclaw: "OpenClaw";
+        readonly pdf: "PDF";
+        readonly perplexity: "Perplexity";
+        readonly pinduoduo: "Pinduoduo";
+        readonly playwright: "Playwright";
+        readonly postgres: "PostgreSQL";
+        readonly python: "Python";
+        readonly rag: "RAG";
+        readonly reddit: "Reddit";
+        readonly redis: "Redis";
+        readonly search: "Search";
+        readonly slack: "Slack";
+        readonly sql: "SQL";
+        readonly supabase: "Supabase";
+        readonly taobao: "Taobao";
+        readonly tavily: "Tavily";
+        readonly telegram: "Telegram";
+        readonly tencent: "Tencent";
+        readonly vscode: "VS Code";
+        readonly wechat: "WeChat";
+        readonly wecom: "WeCom";
+        readonly windsurf: "Windsurf";
+        readonly youtube: "YouTube";
+        readonly zhihu: "Zhihu";
+        readonly 公众号: "公众号";
+        readonly 写作: "写作";
+        readonly 哔哩哔哩: "哔哩哔哩";
+        readonly 小红书: "小红书";
+        readonly 微信: "微信";
+        readonly 抖音: "抖音";
+        readonly 推特: "推特";
+        readonly 淘宝: "淘宝";
+        readonly 百度: "百度";
+        readonly 知乎: "知乎";
+        readonly 营销: "营销";
+        readonly 论文: "论文";
+        readonly 运营: "运营";
+        readonly 钉钉: "钉钉";
+        readonly 阿里云: "阿里云";
+        readonly 飞书: "飞书";
+    };
+};
+export type SeoTopicMarket = keyof typeof SEO_TOPICS;
+export declare const hasSeoTopic: (market: SeoTopicMarket, topic: string) => boolean;
+export declare const isClientOnlySearch: (market: SeoTopicMarket, q: unknown) => boolean;