@spacefast/common 0.0.2

package/dist/docs/skill-distribution.d.ts

@@ -0,0 +1,12 @@
+export declare const spacefastSkillName = "spacefast";
+export declare const spacefastSkillRepoOwner = "spacefast";
+export declare const spacefastSkillRepoName = "plugins";
+export declare const spacefastSkillRepoRef = "spacefast/plugins";
+export declare const spacefastSkillUrl: string;
+export declare const spacefastSkillInstallCommand: string;
+export declare const spacefastInstallCurlCommand: string;
+export declare const spacefastInstallPowerShellCommand: string;
+export declare const spacefastClaudePluginAddCommand = "claude plugin marketplace add spacefast/plugins";
+export declare const spacefastClaudePluginInstallCommand = "claude plugin install spacefast@spacefast";
+export declare const spacefastCodexSkillInstallCommand = "npx skills add spacefast/plugins --skill spacefast -g";
+export declare const spacefastAgentSetupPrompt: string;

package/dist/docs/skill-distribution.js

@@ -0,0 +1,18 @@
+import { BRAND } from "../brand.js";
+export const spacefastSkillName = "spacefast";
+export const spacefastSkillRepoOwner = "spacefast";
+export const spacefastSkillRepoName = "plugins";
+export const spacefastSkillRepoRef = `${spacefastSkillRepoOwner}/${spacefastSkillRepoName}`;
+export const spacefastSkillUrl = `${BRAND.apiOrigin}/skill`;
+export const spacefastSkillInstallCommand = `curl -fsSL ${spacefastSkillUrl}`;
+export const spacefastInstallCurlCommand = `curl -fsSL ${BRAND.websiteOrigin}/install.sh | bash`;
+export const spacefastInstallPowerShellCommand = `irm ${BRAND.websiteOrigin}/install.ps1 | iex`;
+export const spacefastClaudePluginAddCommand = `claude plugin marketplace add ${spacefastSkillRepoRef}`;
+export const spacefastClaudePluginInstallCommand = `claude plugin install ${spacefastSkillName}@${spacefastSkillName}`;
+export const spacefastCodexSkillInstallCommand = `npx skills add ${spacefastSkillRepoRef} --skill ${spacefastSkillName} -g`;
+export const spacefastAgentSetupPrompt = `I'd like you to set up ${BRAND.websiteOrigin}, the static host for AI agents.
+
+Install the ${BRAND.productName} CLI with: ${spacefastInstallCurlCommand}
+On Windows PowerShell, use: ${spacefastInstallPowerShellCommand}
+
+If your environment supports manual skill import, fetch the official ${BRAND.productName} skill from: ${spacefastSkillUrl}`;

package/dist/domain-exploration.d.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+export type DomainSuggestionSource = "exact" | "tld" | "hack" | "variant" | "ai";
+export type DomainSuggestionCategory = "best" | "fast" | "creative" | "ideas" | "short" | "classic" | "all";
+export type DomainSearchMode = "suggestions" | "short" | "all";
+export type DomainSuggestion = {
+    domain: string;
+    label: string;
+    sld: string;
+    tld: string;
+    source: DomainSuggestionSource;
+    category: DomainSuggestionCategory;
+    score: number;
+    supportedForPurchase: boolean;
+    purchasable: boolean;
+    connectable: boolean;
+    reason: string;
+};
+export type DomainSuggestionCheck = {
+    available?: boolean | null;
+    purchasable?: boolean | null;
+    supportedForPurchase?: boolean | null;
+};
+export type DomainAvailabilityStatus = "available" | "available_elsewhere" | "taken" | "unknown" | "unsupported_tld";
+export type DomainAvailabilitySource = "dsapi" | "rdap" | "local";
+export type DomainAvailabilityPrice = {
+    amount: number;
+    formatted: string;
+    currency: "USD";
+};
+export type DomainAvailability = {
+    domain: string;
+    available: boolean | null;
+    supportedForPurchase: boolean;
+    purchasable: boolean;
+    connectable: boolean;
+    price: DomainAvailabilityPrice | null;
+    premium: boolean;
+    status: DomainAvailabilityStatus;
+    source: DomainAvailabilitySource;
+    checkedAt: string;
+    error: string | null;
+};
+export declare const whoisLookupResultSchema: z.ZodObject<{
+    domain: z.ZodString;
+    source: z.ZodEnum<{
+        rdap: "rdap";
+        whois: "whois";
+    }>;
+    status: z.ZodArray<z.ZodString>;
+    registrar: z.ZodNullable<z.ZodString>;
+    nameservers: z.ZodArray<z.ZodString>;
+    events: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        date: z.ZodString;
+    }, z.core.$strip>>;
+    raw: z.ZodUnknown;
+}, z.core.$strip>;
+export type WhoisLookupResult = z.infer<typeof whoisLookupResultSchema>;
+export type DomainSuggestionRankingOptions = {
+    mode?: DomainSearchMode | undefined;
+    checks?: Record<string, DomainSuggestionCheck | undefined> | undefined;
+    showUnavailable?: boolean | undefined;
+    limit?: number | undefined;
+    stableOrder?: boolean | undefined;
+};
+export declare const DOMAIN_SEARCH_MODES: readonly ["suggestions", "short", "all"];
+export declare const DOMAIN_AVAILABILITY_BATCH_LIMIT = 80;
+export declare const PURCHASABLE_TLDS: readonly ["com", "net", "org", "blog", "art", "app", "dev", "io", "co", "ai", "me", "site", "online", "store", "xyz", "space", "studio", "design", "cloud", "tech", "agency", "digital", "social", "world", "live", "today", "works", "website", "email", "link", "page"];
+export declare function isRegistrableZone(zone: string): boolean;
+export declare const SEARCH_TLDS: string[];
+export declare function domainSuggestionLimitForMode(mode: DomainSearchMode, fallback?: number): number;
+export declare function domainParts(domain: string): {
+    sld: string;
+    tld: string;
+};
+export declare function isSupportedForDomainPurchase(tld: string): boolean;
+export declare function isKnownDomainZone(tld: string): boolean;
+export declare function domainSearchProfile(domain: string): {
+    domain: string;
+    normalized: string;
+    sld: string;
+    tld: string;
+    valid: boolean;
+    knownTld: boolean;
+    supportedForPurchase: boolean;
+    connectable: boolean;
+};
+export declare function domainAvailabilityStatus(input: {
+    available: boolean | null;
+    supportedForPurchase: boolean;
+    purchasable: boolean;
+    knownTld?: boolean | undefined;
+}): DomainAvailabilityStatus;
+export declare function localDomainAvailability(domain: string, input?: {
+    available?: boolean | null | undefined;
+    error?: string | null | undefined;
+    checkedAt?: string | undefined;
+}): DomainAvailability;
+export declare function uniqDomainSuggestions(items: DomainSuggestion[]): DomainSuggestion[];
+export declare function isShortDomainSuggestion(item: DomainSuggestion): boolean;
+export declare function domainSuggestionMatchesMode(item: DomainSuggestion, mode: DomainSearchMode): boolean;
+export declare function rankDomainSuggestions(items: DomainSuggestion[], { mode, checks, showUnavailable, limit, stableOrder, }?: DomainSuggestionRankingOptions): DomainSuggestion[];
+export declare function buildBrowserDomainSuggestions(query: string, { mode, limit, aiLimit, checks, showUnavailable, }?: DomainSuggestionRankingOptions & {
+    aiLimit?: number;
+}): DomainSuggestion[];
+export declare function buildAllTldDomainSuggestions(query: string): DomainSuggestion[];
+export declare function buildDomainSuggestions(query: string, limit?: number): DomainSuggestion[];
+export declare function buildAiStyleDomainSuggestions(query: string, limit?: number): DomainSuggestion[];

package/dist/domain-exploration.js

@@ -0,0 +1,488 @@
+import { z } from "zod";
+import { normalizeDomainQuery } from "./domain-normalize.js";
+import { ALL_DOMAIN_ZONES } from "./domain-zones.js";
+export const whoisLookupResultSchema = z.object({
+    domain: z.string(),
+    source: z.enum(["rdap", "whois"]),
+    status: z.array(z.string()),
+    registrar: z.string().nullable(),
+    nameservers: z.array(z.string()),
+    events: z.array(z.object({ action: z.string(), date: z.string() })),
+    raw: z.unknown(),
+});
+export const DOMAIN_SEARCH_MODES = ["suggestions", "short", "all"];
+export const DOMAIN_AVAILABILITY_BATCH_LIMIT = 80;
+export const PURCHASABLE_TLDS = [
+    "com",
+    "net",
+    "org",
+    "blog",
+    "art",
+    "app",
+    "dev",
+    "io",
+    "co",
+    "ai",
+    "me",
+    "site",
+    "online",
+    "store",
+    "xyz",
+    "space",
+    "studio",
+    "design",
+    "cloud",
+    "tech",
+    "agency",
+    "digital",
+    "social",
+    "world",
+    "live",
+    "today",
+    "works",
+    "website",
+    "email",
+    "link",
+    "page",
+];
+const DOMAINR_BASE_ZONES = [
+    "com",
+    "net",
+    "org",
+    "co",
+    "io",
+    "us",
+    "de",
+    "at",
+    "nz",
+    "be",
+    "cl",
+    "se",
+    "si",
+    "ad",
+    "ею",
+    "ua",
+    "рф",
+    "co.us",
+];
+const KEYWORD_ZONES = [
+    { words: ["ai", "agent", "model", "prompt"], zones: ["ai", "app", "tools"] },
+    { words: ["app", "mobile", "saas", "tool"], zones: ["app", "io", "dev"] },
+    { words: ["code", "dev", "api", "cloud"], zones: ["dev", "cloud", "systems"] },
+    { words: ["studio", "brand", "design"], zones: ["studio", "design", "agency"] },
+    { words: ["shop", "store", "market"], zones: ["shop", "store", "co"] },
+    { words: ["coffee", "tea", "roast", "cafe"], zones: ["coffee", "cafe", "shop"] },
+    { words: ["video", "audio", "radio", "podcast"], zones: ["tv", "fm", "media"] },
+    { words: ["finance", "fund", "bank"], zones: ["finance", "capital", "co"] },
+    { words: ["game", "games", "guild"], zones: ["games", "gg", "app"] },
+];
+function unique(values) {
+    return [...new Set(values)];
+}
+function zonePriority(zone) {
+    const domainrIndex = DOMAINR_BASE_ZONES.indexOf(zone);
+    if (domainrIndex >= 0) {
+        return domainrIndex;
+    }
+    const purchasableIndex = PURCHASABLE_TLDS.indexOf(zone);
+    if (purchasableIndex >= 0) {
+        return 100 + purchasableIndex;
+    }
+    return 1_000;
+}
+// The raw zone list contains reverse-DNS (`*.in-addr.arpa`), numeric, and
+// punycode-less IDN entries (`001.рус`) that are never something a person
+// registers. Keep only ASCII zones of one or two letter-initial labels.
+const REGISTRABLE_LABEL = /^[a-z][a-z0-9-]*$/;
+export function isRegistrableZone(zone) {
+    if (zone.includes("arpa")) {
+        return false;
+    }
+    const labels = zone.split(".");
+    if (labels.length < 1 || labels.length > 2) {
+        return false;
+    }
+    const tld = labels[labels.length - 1] ?? "";
+    return tld.length >= 2 && labels.every((label) => REGISTRABLE_LABEL.test(label));
+}
+export const SEARCH_TLDS = unique([
+    ...DOMAINR_BASE_ZONES,
+    ...PURCHASABLE_TLDS,
+    ...ALL_DOMAIN_ZONES,
+])
+    .filter(isRegistrableZone)
+    .toSorted((left, right) => zonePriority(left) - zonePriority(right) || left.localeCompare(right));
+export function domainSuggestionLimitForMode(mode, fallback = 160) {
+    return mode === "all" ? SEARCH_TLDS.length + 1_000 : fallback;
+}
+const HACK_TLDS = new Set([
+    "ai",
+    "am",
+    "art",
+    "at",
+    "be",
+    "bio",
+    "co",
+    "de",
+    "fm",
+    "gg",
+    "io",
+    "is",
+    "it",
+    "me",
+    "so",
+    "to",
+    "tv",
+    "us",
+]);
+const purchaseSupportedSet = new Set(PURCHASABLE_TLDS);
+const zoneSet = new Set(SEARCH_TLDS);
+const matchableHackZones = SEARCH_TLDS.filter((zone) => !zone.includes(".") &&
+    !zone.includes("-") &&
+    !zone.endsWith("arpa") &&
+    zone.length >= 2 &&
+    zone.length <= 12).toSorted((left, right) => right.length - left.length || left.localeCompare(right));
+export function domainParts(domain) {
+    const normalized = normalizeDomainQuery(domain);
+    const labels = normalized.split(".").filter(Boolean);
+    if (labels.length < 2) {
+        return { sld: normalized.replace(/\./g, ""), tld: "" };
+    }
+    for (let index = 0; index < labels.length; index += 1) {
+        const zone = labels.slice(index).join(".");
+        if (!zoneSet.has(zone)) {
+            continue;
+        }
+        return {
+            sld: labels.slice(0, index).join("."),
+            tld: zone,
+        };
+    }
+    return {
+        sld: labels.slice(0, -1).join("."),
+        tld: labels[labels.length - 1] ?? "",
+    };
+}
+export function isSupportedForDomainPurchase(tld) {
+    return purchaseSupportedSet.has(tld.toLowerCase().replace(/^\./, ""));
+}
+export function isKnownDomainZone(tld) {
+    return zoneSet.has(tld.toLowerCase().replace(/^\./, ""));
+}
+export function domainSearchProfile(domain) {
+    const normalized = normalizeDomainQuery(domain);
+    const { sld, tld } = domainParts(normalized);
+    const valid = Boolean(sld && tld && sld.length <= 63 && normalized.length <= 253);
+    const supportedForPurchase = valid && isSupportedForDomainPurchase(tld);
+    return {
+        domain: valid ? `${sld}.${tld}` : normalized,
+        normalized,
+        sld,
+        tld,
+        valid,
+        knownTld: Boolean(tld && isKnownDomainZone(tld)),
+        supportedForPurchase,
+        connectable: valid && Boolean(tld && isKnownDomainZone(tld)),
+    };
+}
+export function domainAvailabilityStatus(input) {
+    if (input.available === true) {
+        return input.purchasable
+            ? "available"
+            : input.supportedForPurchase
+                ? "unknown"
+                : "available_elsewhere";
+    }
+    if (input.available === false) {
+        return "taken";
+    }
+    return input.supportedForPurchase || input.knownTld !== false ? "unknown" : "unsupported_tld";
+}
+export function localDomainAvailability(domain, input = {}) {
+    const profile = domainSearchProfile(domain);
+    const available = input.available ?? null;
+    const purchasable = false;
+    return {
+        domain: profile.domain,
+        available,
+        supportedForPurchase: profile.supportedForPurchase,
+        purchasable,
+        connectable: profile.connectable,
+        price: null,
+        premium: false,
+        status: domainAvailabilityStatus({
+            available,
+            supportedForPurchase: profile.supportedForPurchase,
+            purchasable,
+            knownTld: profile.knownTld,
+        }),
+        source: "local",
+        checkedAt: input.checkedAt ?? new Date().toISOString(),
+        error: input.error ?? null,
+    };
+}
+function zonesForTokens(tokens) {
+    const zones = [];
+    for (const token of tokens) {
+        for (const group of KEYWORD_ZONES) {
+            if (group.words.includes(token)) {
+                zones.push(...group.zones);
+            }
+        }
+    }
+    return unique(zones);
+}
+function domainHacks(values, base) {
+    const hacks = new Set();
+    for (const value of values) {
+        for (const zone of matchableHackZones) {
+            let offset = value.indexOf(zone);
+            while (offset >= 0) {
+                const left = value.slice(0, offset).replace(/^-+|-+$/g, "");
+                if (left.length > 0) {
+                    hacks.add(`${left}.${zone}`);
+                }
+                offset = value.indexOf(zone, offset + 1);
+            }
+        }
+    }
+    return [...hacks].toSorted((left, right) => hackWeight(left, base) - hackWeight(right, base) || left.localeCompare(right));
+}
+function hackWeight(domain, base) {
+    const leftLength = domain.split(".")[0]?.length ?? 0;
+    const exact = domain.replace(".", "") === base;
+    return (exact ? 0 : 18) + Math.max(0, leftLength - 4);
+}
+export function uniqDomainSuggestions(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        if (seen.has(item.domain)) {
+            return false;
+        }
+        seen.add(item.domain);
+        return true;
+    });
+}
+export function isShortDomainSuggestion(item) {
+    return item.source === "hack" || item.sld.replace(/-/g, "").length <= 8;
+}
+export function domainSuggestionMatchesMode(item, mode) {
+    if (mode === "short") {
+        // Hacks and compact names regardless of where they came from — AI ideas
+        // that happen to be short belong here too.
+        return isShortDomainSuggestion(item);
+    }
+    return true;
+}
+export function rankDomainSuggestions(items, { mode = "suggestions", checks = {}, showUnavailable = true, limit, stableOrder = false, } = {}) {
+    const ranked = uniqDomainSuggestions(items)
+        .toSorted((left, right) => {
+        // Score (then domain) is a pure function of the query, so this order is
+        // fully stable across availability updates.
+        const byScore = right.score - left.score || left.domain.localeCompare(right.domain);
+        if (stableOrder) {
+            return byScore;
+        }
+        const leftCheck = checks[left.domain];
+        const rightCheck = checks[right.domain];
+        const availabilityBoost = (rightCheck?.available === true ? 100 : 0) - (leftCheck?.available === true ? 100 : 0);
+        const purchasableBoost = (rightCheck?.purchasable || rightCheck?.supportedForPurchase ? 35 : 0) -
+            (leftCheck?.purchasable || leftCheck?.supportedForPurchase ? 35 : 0);
+        return availabilityBoost + purchasableBoost || byScore;
+    })
+        .filter((item) => {
+        const check = checks[item.domain];
+        if (!showUnavailable && check?.available === false) {
+            return false;
+        }
+        return domainSuggestionMatchesMode(item, mode);
+    });
+    return typeof limit === "number" ? ranked.slice(0, limit) : ranked;
+}
+export function buildBrowserDomainSuggestions(query, { mode = "suggestions", limit = domainSuggestionLimitForMode(mode), aiLimit = 24, checks, showUnavailable, } = {}) {
+    if (mode === "all") {
+        return rankDomainSuggestions(buildAllTldDomainSuggestions(query), {
+            mode,
+            checks,
+            showUnavailable,
+            limit: undefined,
+        });
+    }
+    const local = buildDomainSuggestions(query, domainSuggestionLimitForMode(mode, limit));
+    const ideas = buildAiStyleDomainSuggestions(query, aiLimit);
+    return rankDomainSuggestions([...local, ...ideas], {
+        mode,
+        checks,
+        showUnavailable,
+        limit,
+    });
+}
+export function buildAllTldDomainSuggestions(query) {
+    const normalized = normalizeDomainQuery(query);
+    if (!normalized) {
+        return [];
+    }
+    const requested = normalized.includes(".") ? domainParts(normalized) : null;
+    const sld = (requested?.sld || normalized).replace(/\./g, "").replace(/^-+|-+$/g, "");
+    if (!sld || sld.length > 63) {
+        return [];
+    }
+    return SEARCH_TLDS.map((tld, index) => {
+        const domain = `${sld}.${tld}`;
+        const supportedForPurchase = isSupportedForDomainPurchase(tld);
+        const classicBoost = ["com", "net", "org"].includes(tld) ? 16 : 0;
+        const tldBoost = supportedForPurchase ? 18 : 0;
+        return {
+            domain,
+            label: domain,
+            sld,
+            tld,
+            source: "tld",
+            category: "all",
+            score: Math.round(120 + tldBoost + classicBoost - index * 0.05),
+            supportedForPurchase,
+            purchasable: supportedForPurchase,
+            connectable: true,
+            reason: `Direct match on .${tld}.`,
+        };
+    });
+}
+export function buildDomainSuggestions(query, limit = 96) {
+    const normalized = normalizeDomainQuery(query);
+    if (!normalized) {
+        return [];
+    }
+    const requested = normalized.includes(".") ? domainParts(normalized) : null;
+    const base = requested?.sld || normalized.replace(/\./g, "");
+    const compact = base.replace(/-/g, "");
+    const variants = new Set([base, compact]);
+    const tokens = base.split("-").filter(Boolean);
+    if (tokens.length > 1) {
+        variants.add(tokens.join(""));
+        variants.add(tokens.join("-"));
+        variants.add(tokens.toReversed().join(""));
+    }
+    if (compact.length > 4) {
+        variants.add(`${compact}hq`);
+        variants.add(`get${compact}`);
+        variants.add(`${compact}app`);
+        variants.add(`${compact}labs`);
+    }
+    const suggestions = new Map();
+    const add = (sld, tld, source, reason, index) => {
+        if (!sld || !tld || sld.length > 63) {
+            return;
+        }
+        const domain = `${sld}.${tld}`;
+        if (suggestions.has(domain)) {
+            return;
+        }
+        const exact = source === "exact" || (sld === compact && tld === requested?.tld);
+        const short = sld.length <= 8;
+        const supportedForPurchase = isSupportedForDomainPurchase(tld);
+        const purchasable = supportedForPurchase;
+        const category = exact
+            ? "best"
+            : short
+                ? "short"
+                : HACK_TLDS.has(tld)
+                    ? "creative"
+                    : supportedForPurchase
+                        ? "fast"
+                        : "all";
+        const tldBoost = supportedForPurchase ? 18 : 0;
+        const classicBoost = ["com", "net", "org"].includes(tld) ? 16 : 0;
+        const hackBoost = HACK_TLDS.has(tld) ? 9 : 0;
+        const lengthPenalty = Math.max(0, sld.length - 10) * 1.4;
+        const baseScore = source === "exact" ? 180 : source === "hack" ? 126 : 100;
+        const score = Math.round(baseScore + tldBoost + classicBoost + hackBoost - index * 0.75 - lengthPenalty);
+        suggestions.set(domain, {
+            domain,
+            label: domain,
+            sld,
+            tld,
+            source,
+            category,
+            score,
+            supportedForPurchase,
+            purchasable,
+            connectable: true,
+            reason,
+        });
+    };
+    if (requested?.tld) {
+        add(requested.sld, requested.tld, "exact", "The exact domain you typed.", 0);
+    }
+    SEARCH_TLDS.forEach((tld, index) => add(compact, tld, "tld", `Direct match on .${tld}.`, index));
+    for (const hack of domainHacks([...variants], compact)) {
+        const parts = domainParts(hack);
+        add(parts.sld, parts.tld, "hack", `Domain hack using .${parts.tld}.`, hackWeight(hack, compact));
+    }
+    for (const zone of zonesForTokens(tokens)) {
+        add(compact, zone, "variant", "Keyword-matched extension.", 14);
+    }
+    let variantIndex = 0;
+    for (const variant of variants) {
+        for (const tld of ["com", "blog", "app", "dev", "io", "co", "ai", "studio", "site"]) {
+            add(variant, tld, "variant", "Name variation.", 18 + variantIndex++);
+        }
+    }
+    return Array.from(suggestions.values())
+        .toSorted((left, right) => right.score - left.score || left.domain.localeCompare(right.domain))
+        .slice(0, limit);
+}
+export function buildAiStyleDomainSuggestions(query, limit = 24) {
+    const normalized = normalizeDomainQuery(query);
+    const base = domainParts(normalized).sld || normalized;
+    if (!base) {
+        return [];
+    }
+    const compact = base.replace(/-/g, "");
+    const stems = [
+        `${compact}lab`,
+        `${compact}works`,
+        `use${compact}`,
+        `try${compact}`,
+        `${compact}stack`,
+        `${compact}base`,
+        `${compact}grid`,
+        `${compact}signal`,
+        `${compact}index`,
+        `${compact}run`,
+    ];
+    const tlds = ["com", "ai", "app", "dev", "io", "co", "studio", "world", "tools", "systems"];
+    const items = [];
+    // Score with the same components as buildDomainSuggestions so ideas
+    // interleave by merit in the merged "suggestions" view: base 96 puts the
+    // best idea (96 + 18 + 16 = 130) just under the direct .com match (134) and
+    // well under the exact query (180), while per-stem/per-tld decay spreads
+    // the tail through the TLD sweep instead of forming a separate block.
+    stems.forEach((stem, stemIndex) => {
+        tlds.forEach((tld, tldIndex) => {
+            const domain = `${stem}.${tld}`;
+            const supportedForPurchase = isSupportedForDomainPurchase(tld);
+            const tldBoost = supportedForPurchase ? 18 : 0;
+            const classicBoost = ["com", "net", "org"].includes(tld) ? 16 : 0;
+            const lengthPenalty = Math.max(0, stem.length - 10) * 1.4;
+            items.push({
+                domain,
+                label: domain,
+                sld: stem,
+                tld,
+                source: "ai",
+                category: "ideas",
+                score: Math.round(96 + tldBoost + classicBoost - stemIndex * 4 - tldIndex * 1.5 - lengthPenalty),
+                supportedForPurchase,
+                purchasable: supportedForPurchase,
+                connectable: true,
+                reason: "Generated name idea.",
+            });
+        });
+    });
+    // Scores are not monotonic with generation order (a later stem's .com beats
+    // an earlier stem's long-tail TLD), so build every stem × tld combination
+    // and cut by score — never by generation order — when applying the limit.
+    return items
+        .toSorted((left, right) => right.score - left.score || left.domain.localeCompare(right.domain))
+        .slice(0, limit);
+}

package/dist/domain-normalize.d.ts

@@ -0,0 +1 @@
+export declare function normalizeDomainQuery(query: string): string;

package/dist/domain-normalize.js

@@ -0,0 +1,14 @@
+export function normalizeDomainQuery(query) {
+    const value = query
+        .trim()
+        .toLowerCase()
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/^https?:\/\//, "")
+        .replace(/^www\./, "")
+        .split(/[/?#]/)[0] ?? "";
+    return value
+        .replace(/[^\p{L}\p{N}.-]+/gu, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-{2,}/g, "-");
+}