@builder.io/dev-tools 1.6.20-dev.202504032053.5a0a40ed → 1.6.22

package/types/_tests_/utils.d.ts

@@ -24,8 +24,9 @@ interface CLI {
         modified: string[];
     }>;
     npm(...args: string[]): Promise<number>;
+    spawn(command: string, args: string[]): Promise<number>;
 }
-export declare function testCLI(name: string, template: string | undefined, handler: (cli: Handler, expect: ExpectStatic) => Promise<void>, timeout?: number): void;
+export declare function testCLI(name: string, template: string | undefined, handler: (cli: Handler, expect: ExpectStatic) => Promise<void>, timeout?: number, skip?: boolean): void;
 type Handler = (cmd: "builderio" | "create-builderio", args: string[], options?: {
     debug?: boolean;
 }) => CLI;

package/types/cli/code-server.d.ts

@@ -0,0 +1,3 @@
+import type { DevToolsSys } from "../types";
+import type { DevToolsServer } from "../server";
+export declare function setupCodeServer(sys: DevToolsSys): Promise<DevToolsServer>;

package/types/cli/code-tools.d.ts

@@ -0,0 +1,11 @@
+import type { CodeGenTools, ContentMessageItemToolResult, ProjectFile } from "$/ai-utils";
+import type { DevToolsSys } from "../core";
+export interface LLMToolCalls {
+    name: CodeGenTools;
+    input: Record<string, any>;
+    id: string;
+}
+export declare function resolveToolCalls(sys: DevToolsSys, toolCalls: LLMToolCalls[]): Promise<{
+    toolResults: ContentMessageItemToolResult[];
+    projectFiles: ProjectFile[];
+}>;

package/types/cli/code.d.ts

@@ -1,49 +1,61 @@
 import type { DevToolsSys } from "../types";
 import type { CLIArgs } from "./index";
-export interface UserContext {
-    client: string;
-    clientVersion: string;
-    nodeVersion: string;
-    systemPlatform: string;
-    systemEOL: string;
-    systemArch: string;
-    frameworks: string[];
-    systemShell?: string;
-    inGitRepo?: boolean;
-    [key: string]: string[] | string | boolean | undefined;
+import { type Credentials } from "./credentials";
+import { type Checkpoint } from "./incremental-tsc";
+import { type IOService } from "./io-service";
+import type { ContentMessageItemToolResult, CustomInstruction, ProjectFile, UserContext } from "$/ai-utils";
+import prettier from "prettier";
+interface UndoState {
+    files: {
+        path: string;
+        content: Uint8Array | null;
+    }[];
+    isAgent: boolean;
+    url: string | undefined;
+    toolResults: ContentMessageItemToolResult[];
 }
-export interface CustomInstruction {
+interface CodeGenSearchResponse {
+    ranked: RankedResult[];
+    relevantPaths: string[];
+}
+interface RankedResult {
+    filePath: string;
+    startIndex: number;
+    endIndex: number;
+    score: number;
     id: string;
-    name: string;
-    content: string;
 }
-type CodegenUsage = {
-    total: number;
-    fast: number;
-    quality: number;
-    limits: {
-        aiGeneration: number;
-        aiGenerationContextWindow: number;
-    };
-};
-export interface ArtifactItem {
-    type: "file" | "text" | "delta" | "done" | "diff" | "request_file" | "thinking" | "user" | "continue";
-    id?: string;
-    content: string;
-    filePath?: string;
-    artifactTitle?: string;
-    actionTitle?: string;
-    synthetic?: boolean;
-    incomplete?: boolean;
-    nextUrl?: string;
-    actions?: ArtifactItem[];
-    stopReason?: "end" | "limit" | "error" | "max_tokens";
-    usage?: CodegenUsage;
+type State = "initial-with-url" | "initial-without-url" | "success" | "success-just-text" | "abort" | "error";
+export interface SessionContext {
+    sessionId: string;
+    undoStates: UndoState[];
+    selectedFilePaths: Map<string, number>;
+    customInstructions: CustomInstruction[];
+    userContext: UserContext;
+    prettierConfig: prettier.Config | null;
+    state: State;
+}
+export interface UserInput {
+    userPrompt: string;
+    sentiment: "positive" | "negative" | "undo";
+    files: ProjectFile[];
+    searchResponse: CodeGenSearchResponse | null;
+    rerankFiles?: number;
+    mostRelevantFile: string | null;
+    role: "user" | "agent";
+}
+export declare const runCodeCommand: (sys: DevToolsSys, subCommand: string, args: CLIArgs, io?: IOService) => Promise<void>;
+export declare const createSessionContext: (sys: DevToolsSys) => Promise<SessionContext>;
+export declare const runCodeGen: (sys: DevToolsSys, args: CLIArgs, io?: IOService) => Promise<void>;
+interface InteractiveAnswer {
+    command: "exit" | undefined;
+    userPrompt: string | undefined;
+    feedback: "positive" | "negative" | "undo" | undefined;
 }
-export declare const runCodeCommand: (sys: DevToolsSys, subCommand: string, args: CLIArgs) => Promise<void>;
-export declare const runCodeGen: (sys: DevToolsSys, args: CLIArgs) => Promise<undefined>;
+export declare function getUserInput(sys: DevToolsSys, credentials: Credentials, args: CLIArgs, sessionContext: SessionContext, answer: InteractiveAnswer, signal: AbortSignal | undefined, io?: IOService): Promise<UserInput>;
+export declare function agentCompletion(sys: DevToolsSys, credentials: Credentials, args: CLIArgs, sessionContext: SessionContext, userInput: UserInput, url: string | undefined, baselineCheckpoint: Checkpoint, signal: AbortSignal | undefined, io?: IOService): Promise<Checkpoint>;
 export declare function createApp(userId: string, spaceId: string, privateKey: string, body: any): Promise<void>;
 export declare function transformStream(body: ReadableStream<Uint8Array> | null): AsyncGenerator<string, void, unknown>;
-export declare function checkProjectRoot(sys: DevToolsSys, interactive: boolean): Promise<undefined>;
+export declare function checkProjectRoot(sys: DevToolsSys, interactive: boolean, io?: IOService): Promise<void>;
 export declare function getUserContext(sys: DevToolsSys): Promise<UserContext>;
 export {};

package/types/cli/download.d.ts

@@ -1,6 +1,6 @@
 import type { CLIArgs } from "./index";
 import type { DevToolsSys } from "../types";
-import { type FigmaBuilderLink } from "./figma-utils";
+import type { FigmaBuilderLink } from "$/ai-utils";
 interface KVGetRequest {
     privateKey: string;
     spaceId: string;

package/types/cli/figma-publish.d.ts

@@ -1,29 +1,18 @@
-import type { DevTools, DevToolsSys, RepoInfo } from "../types";
+import ts from "typescript";
+import type { DevTools, DevToolsSys } from "../types";
 import type { CLIArgs } from "./index";
-import { type FigmaBuilderLink } from "./figma-utils";
-import { type UserContext } from "./code";
+import type { FigmaBuilderLink, FigmaMapperFile } from "$/ai-utils";
 export declare const runFigmaPublish: (sys: DevToolsSys, args: CLIArgs) => Promise<undefined>;
 export declare const FIGMA_CONNECT_CALL = "figmaMapping";
 export declare function findAllMappingFiles(sys: DevToolsSys): Promise<string[]>;
-export interface FigmaBuilderData {
-    figmaBuilderLinks: FigmaBuilderLink[];
-}
 export declare function setPublicKey(sys: DevToolsSys, publicKey: string, devTools: DevTools | undefined, ensureFigmaImportPage?: boolean): Promise<boolean>;
-export interface PublishedMapping {
-    repoInfo: RepoInfo | undefined;
-    figmaBuilderLinks: FigmaBuilderLink[];
-    spaceId: string;
-    privateKey: string;
-    userId: string;
-    userContext: UserContext;
-}
-export declare function findMappingsFromFiles({ sys, force, mappingFiles, print, }: {
-    force?: boolean;
+export declare function findMappingsFromFiles({ sys, mappingFiles, typeCheck, }: {
     mappingFiles: string[];
-    print: boolean;
     sys: DevToolsSys;
+    typeCheck?: boolean;
 }): Promise<{
+    mapperFiles: FigmaMapperFile[];
     figmaBuilderLinks: FigmaBuilderLink[];
-    foundErrors: boolean;
+    diagnostics: ts.Diagnostic[];
     figmaLinksToResolve: string[];
 }>;

package/types/cli/figma-utils.d.ts

@@ -1,56 +1,32 @@
-import type { Credentials, FigmaAuth } from "./credentials";
-import type { ExportType } from "../types";
-export interface FigmaComponentInput {
-    id: string;
-    name: string;
-    value?: any;
-    type: string;
-    baseType: "text" | "variant" | "boolean" | "slot";
-    variantOptions?: string[];
-    isDefault: boolean;
-    ref?: string;
-}
-export interface FigmaBuilderLink {
-    builderName: string;
-    figmaName: string;
-    figmaKey: string;
-    figmaUrl?: string;
-    inputMapper?: string;
-    originalInputMapper?: string;
-    exportType?: ExportType;
-    importName?: string;
-    importPath?: string;
-    source: string;
-    loc?: string;
-}
-export interface FigmaComponentInfo {
-    documentName: string;
-    key: string;
-    tree: string;
-    jsx: string;
-    name: string;
-    inputs: FigmaComponentInput[];
-    description: string;
-    documentationLinks: string[];
-    instanceId: string;
-}
+import { type Credentials, type FigmaAuth } from "./credentials";
+import type { DevToolsSys } from "../types";
+import type { CLIArgs } from "./index";
+import type { FigmaBuilderLink, FigmaComponentInfo } from "$/ai-utils";
+type FigmaAPIOpts = {
+    auth: {
+        access_token: string;
+        oauth: boolean;
+    };
+    params?: Record<string, any>;
+};
 export declare const REMOVE_EMOJI: RegExp;
 export declare const parseFigmaURL: (str: string) => {
     fileID: string;
     nodeId: string;
 } | null;
-export declare const getFigmaNodeData: (auth: {
+export declare const figmaApi: (sys: DevToolsSys, args: CLIArgs, path: string, { auth, params }: FigmaAPIOpts) => Promise<any>;
+export declare const getFigmaNodeData: (sys: DevToolsSys, args: CLIArgs, auth: {
     access_token: string;
     oauth: boolean;
 }, fileId: string, nodeIds: string, depth?: number) => Promise<any>;
-export declare function getFigmaComponentName(name: string): string;
 export declare function getImportDataFromToken(credentials: Credentials, token: string, verbose: boolean): Promise<(readonly [string, FigmaComponentInfo])[]>;
 export declare function needsFigmaAuth(urls: string[]): boolean;
-export declare function getFigmaNodeDataFromURLs(figmaAuth: {
+export declare function getFigmaNodeDataFromURLs(sys: DevToolsSys, args: CLIArgs, figmaAuth: {
     access_token: string;
     oauth: boolean;
 } | undefined, builderAuth: {
     privateKey: string;
     spaceId: string;
 }, urls: string[]): Promise<(readonly [string, FigmaComponentInfo])[]>;
-export declare function inPlaceResolveFigmaURLs(figmaAuth: FigmaAuth, figmaBuilderLinks: FigmaBuilderLink[], figmaLinksToResolve: string[]): Promise<void>;
+export declare function inPlaceResolveFigmaURLs(sys: DevToolsSys, args: CLIArgs, figmaAuth: FigmaAuth, figmaBuilderLinks: FigmaBuilderLink[], figmaLinksToResolve: string[]): Promise<void>;
+export {};

package/types/cli/figma.d.ts

@@ -1,3 +1,4 @@
 import type { DevToolsSys } from "../types";
 import type { CLIArgs } from ".";
 export declare const runFigmaCommand: (sys: DevToolsSys, subCommand: string, args: CLIArgs) => Promise<void>;
+export declare function askToInstallBuilder(sys: DevToolsSys, args: CLIArgs): Promise<void>;

package/types/cli/generate.d.ts

@@ -1,15 +1,14 @@
 import type { ComponentInfo, ComponentRegistry, DevToolsSys } from "../types";
 import type { CLIArgs } from "./index";
-import { type UserContext } from "./code";
-import { type FigmaComponentInfo } from "./figma-utils";
+import { type FigmaComponentInfo, type UserContext } from "$/ai-utils";
 export declare const runFigmaGenerate: (sys: DevToolsSys, args: CLIArgs) => Promise<undefined>;
 export interface MappingCodeV3 {
-    figmaNode: FigmaComponentInfo;
-    registry: ComponentRegistry;
+    figmaNode?: FigmaComponentInfo;
+    registry?: ComponentRegistry;
     userContext?: UserContext;
-    figmaUrl: string;
+    figmaUrl?: string;
     docsUrl?: string;
-    registeredCmp: ComponentInfo;
+    registeredCmp?: ComponentInfo;
     previousCompletion?: string;
     userPrompt?: string;
     token?: string;

package/types/cli/index.d.ts

@@ -1,6 +1,8 @@
 export interface CLIArgs {
     /** Figma access token */
     figmaToken?: string;
+    /** GitHub access token */
+    githubToken?: string;
     /** Run in CI mode without interactive prompts */
     ci?: boolean;
     /** Show help text */
@@ -27,12 +29,32 @@ export interface CLIArgs {
     url?: string;
     /** Prompt text for non-interactive mode */
     prompt?: string;
-    /** Generation mode - either 'exact' for precise matches or 'creative' for more flexibility */
-    mode?: "precise" | "creative";
+    /** Generation mode */
+    mode?: "fast" | "quality" | "quality-v3";
     /** Working directory to run commands from */
     cwd?: string;
     /** Debug mode */
     debug?: boolean;
+    /** Port number for the dev server */
+    port?: number;
+    /** Port number for the dev server (shorthand) */
+    p?: number;
+    /** Command to execute */
+    command?: string;
+    /** Command to execute (shorthand) */
+    c?: string;
+    /** Skip authentication for testing purposes */
+    noAuth?: boolean;
+    /** Skip authentication for testing purposes (flag form) */
+    auth?: boolean;
+    /** Use development server instead of production for launch command */
+    dev?: boolean;
+    /** Skip browser auto-open */
+    noOpen?: boolean;
+    /** Skip browser auto-open (flag form) */
+    open?: boolean;
     /** Raw command line arguments */
     _: string[];
+    builderPublicKey?: string;
+    builderPrivateKey?: string;
 }

package/types/cli/indexing.d.ts

@@ -1,13 +1,5 @@
 import type { DevToolsSys } from "../types";
 import type { CLIArgs } from "./index";
 import { type Credentials } from "./credentials";
-export interface ArtifactItem {
-    type: "shell" | "file" | "text" | "delta" | "done";
-    id?: string;
-    content: string;
-    filePath?: string;
-    artifactTitle?: string;
-    incomplete?: boolean;
-}
 export declare const runCodeIndexing: (_sys: DevToolsSys, _args: CLIArgs) => Promise<void>;
 export declare const codeIndexing: (sys: DevToolsSys, credentials: Credentials) => Promise<void>;

package/types/cli/io-service.d.ts

@@ -0,0 +1,86 @@
+import { type SelectOptions, type ConfirmOptions, type TextOptions } from "@clack/prompts";
+import { spinner } from "./spinner";
+import type { WebSocket } from "ws";
+export interface IOService {
+    log(str: string): void;
+    info(str: string): void;
+    warn(str: string): void;
+    error(str: string): void;
+    write(text: string): void;
+    writeMetadata(metadata: Record<string, any>): void;
+    confirm(options: ConfirmOptions): Promise<boolean | symbol>;
+    text(options: TextOptions): Promise<string | symbol>;
+    select<Value>(options: SelectOptions<Value>): Promise<Value | symbol>;
+    createSpinner(): ReturnType<typeof spinner>;
+    isInteractive(): boolean;
+    isTTY(): boolean;
+    exit(code: number): Promise<void>;
+}
+export declare class ConsoleIOService implements IOService {
+    log(str: string): void;
+    info(str: string): void;
+    warn(str: string): void;
+    error(str: string): void;
+    write(text: string): void;
+    writeMetadata(_: Record<string, any>): void;
+    confirm(options: ConfirmOptions): Promise<boolean | symbol>;
+    text(options: TextOptions): Promise<string | symbol>;
+    select<Value>(options: SelectOptions<Value>): Promise<Value | symbol>;
+    createSpinner(): ReturnType<typeof spinner>;
+    isInteractive(): boolean;
+    isTTY(): boolean;
+    exit(code: number): Promise<void>;
+}
+export interface BaseMessage {
+    type: string;
+    [key: string]: any;
+}
+export interface LogMessage extends BaseMessage {
+    type: "log";
+    level: "info" | "warn" | "error";
+    message: string;
+}
+export interface WriteMessage extends BaseMessage {
+    type: "write";
+    text: string;
+}
+export interface SpinnerMessage extends BaseMessage {
+    type: "spinner";
+    status: "start" | "stop";
+    message: string;
+    code?: number;
+}
+export interface PromptRequest extends BaseMessage {
+    type: "prompt";
+    promptType: "text" | "confirm" | "select";
+    options: any;
+    requestId: string;
+}
+export interface PromptResponse extends BaseMessage {
+    type: "prompt_response";
+    requestId: string;
+    value: any;
+    cancelled?: boolean;
+}
+export declare class WebSocketIOService implements IOService {
+    private ws;
+    private promptCallbacks;
+    private messageQueue;
+    private isProcessing;
+    constructor(ws: WebSocket);
+    private sendMessage;
+    private prompt;
+    log(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    write(text: string): void;
+    writeMetadata(metadata: Record<string, any>): void;
+    confirm(options: ConfirmOptions): Promise<boolean | symbol>;
+    text(options: TextOptions): Promise<string | symbol>;
+    select<Value>(options: SelectOptions<Value>): Promise<Value | symbol>;
+    createSpinner(): ReturnType<typeof spinner>;
+    isInteractive(): boolean;
+    isTTY(): boolean;
+    exit(code: number): Promise<void>;
+}

package/types/cli/launch.d.ts

@@ -1,5 +1,4 @@
 import type { DevToolsSys } from "@builder.io/dev-tools/core";
 import type { CLIArgs } from "./index";
-export declare const API_PORT = 48753;
 export declare const PROXY_PORT = 48752;
 export declare function runLaunchCommand(sys: DevToolsSys, subCommand: string, args: CLIArgs): Promise<number>;

package/types/cli/report/figma-report.d.ts

@@ -0,0 +1,3 @@
+import type { CLIArgs } from "..";
+import type { DevToolsSys } from "../../core";
+export declare const runFigmaReport: (sys: DevToolsSys, args: CLIArgs) => Promise<void>;

package/types/cli/sync-utils.d.ts

@@ -4,8 +4,9 @@ export declare function extractSignatureInfo(content: string): {
     sessionKey?: string;
     snippetId?: string;
 };
-export declare function getAllProjectFiles(basePath: string): Promise<string[]>;
+export declare function getAllProjectFiles(basePath: string, globPattern?: string): Promise<string[]>;
 export declare function findBuilderFiles(basePath: string, targetContentId: string, targetSessionKey: string): Promise<FileNode[]>;
+export declare function filterNonImportantFiles(files: string[]): string[];
 export declare function getIgnorePatterns(basePath: string): (path: string) => boolean;
 export declare function watchDirectory(basePath: string, syncInfo: SyncInfo, onChange: (updatedSyncInfo: SyncInfo) => void): () => Promise<void>;
 export declare function setupSyncServer(sys: DevToolsSys, initialSyncInfo?: SyncInfo): Promise<void>;

package/types/common/ast/component-input-types.d.ts

@@ -17,7 +17,7 @@ export declare const NUMBER_TYPES: string[];
 export declare const BOOLEAN_TYPES: string[];
 export declare const ARRAY_TYPES: string[];
 export declare const OBJECT_TYPES: string[];
-export declare function getPrimitiveType(t: string): "number" | "object" | "string" | "boolean" | "array";
+export declare function getPrimitiveType(t: string): "number" | "string" | "boolean" | "object" | "array";
 export declare function removeQuotes(text: string): string;
 export declare const resolveType: (sys: DevToolsSys, checker: ts.TypeChecker, type: ts.Type) => string[] | undefined;
 export declare const typeToString: (sys: DevToolsSys, checker: ts.TypeChecker, type: ts.Type) => string;

package/types/common/ast/convert-values.d.ts

@@ -8,4 +8,4 @@ export declare function objectExpressionToObjectValue(sys: DevToolsSys, objectLi
 };
 export declare function convertArrayExpressionToJsArray(sys: DevToolsSys, arr: ts.ArrayLiteralExpression): any[];
 export declare function getTextOfPropertyName(sys: DevToolsSys, prop: ts.PropertyAssignment | ts.ObjectLiteralElementLike | undefined): string | undefined;
-export declare function valueToExpression(sys: DevToolsSys, val: any): ts.Identifier | ts.ObjectLiteralExpression | ts.ArrayLiteralExpression | ts.StringLiteral | ts.NumericLiteral | ts.TrueLiteral | ts.FalseLiteral;
+export declare function valueToExpression(sys: DevToolsSys, val: any): ts.ObjectLiteralExpression | ts.Identifier | ts.StringLiteral | ts.NumericLiteral | ts.TrueLiteral | ts.FalseLiteral | ts.ArrayLiteralExpression;

package/types/common/dotenv.d.ts

@@ -3,4 +3,4 @@ export declare function getDotEnvValue(sys: DevToolsSys, dotEnvFileNames: string
 export declare function setDotEnvValue(sys: DevToolsSys, dotEnvFileNames: string[], envKey: string, envValue: string): Promise<EnvInfo>;
 export declare function parseDotEnvFile(sys: DevToolsSys, envPath: string): Promise<Record<string, string> | null>;
 export declare function parseDotEnvContent(envContent: string): Record<string, string>;
-export declare function setDotEnvVar(sys: DevToolsSys, envPath: string, key: string, value: string): Promise<"create" | "update" | null>;
+export declare function setDotEnvVar(sys: DevToolsSys, envPath: string, key: string, value: string): Promise<"create" | "update" | "permission-error" | null>;

package/types/common/dotenv.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/common/test-utils.d.ts

@@ -1,7 +1,9 @@
 import type { DevToolsSys } from "../types";
 import ts from "typescript";
 export declare function codeEqual(sys: DevToolsSys, n: ts.Node | null | undefined | string, expectCode: string, removeComments?: boolean): Promise<void>;
-export declare function createTestFsSys(rootDir: string): Promise<DevToolsSys>;
+export declare function createTestFsSys(rootDir: string, options?: {
+    readOnlyPermissions?: boolean;
+}): Promise<DevToolsSys>;
 export declare function createTestMemSys(rootDir?: string): Promise<DevToolsSys>;
 export declare function createRemixTestMemSys(rootDir?: string): Promise<DevToolsSys>;
 export declare function createAngularTestMemSys(rootDir?: string): Promise<DevToolsSys>;

package/types/core/adapters/angular/index.d.ts

@@ -10,4 +10,5 @@ export interface AngularDevToolsSys extends DevToolsSys {
     typescriptEnabled: boolean;
     builderPageComponentPath: string;
     hasAppModule: boolean;
+    addExternalPackage: (pkgName: string) => void;
 }

package/types/core/adapters/react/react-api-key.d.ts

@@ -3,4 +3,4 @@ import type { ReactDevToolsSys } from ".";
 export declare function getReactApiKey(sys: ReactDevToolsSys): Promise<EnvInfo>;
 export declare function setReactApiKey(sys: ReactDevToolsSys, publicApiKey: string): Promise<EnvInfo>;
 export declare const REACT_VITE_BUILDER_KEY_ENV = "VITE_PUBLIC_BUILDER_KEY";
-export declare const REACT_WEBPACK_BUILDER_KEY_ENV = "YOUR_PUBLIC_BUILDER_KEY";
+export declare const REACT_WEBPACK_BUILDER_KEY_ENV = "PUBLIC_BUILDER_KEY";

package/types/figma/index.d.ts

@@ -1,14 +1,5 @@
+import type { FigmaComponentInput } from "$/ai-utils";
 export type FigmaNodeType = "COMPONENT" | "ELLIPSE" | "FRAME" | "GROUP" | "INSTANCE" | "LINE" | "POLYGON" | "RECTANGLE" | "STAR" | "TEXT" | "VECTOR";
-export interface FigmaComponentInput {
-    id: string;
-    name: string;
-    value?: any;
-    type: string;
-    baseType: "text" | "variant" | "boolean" | "slot";
-    variantOptions?: string[];
-    isDefault: boolean;
-    ref?: string;
-}
 export interface FigmaNode {
     "@type": "passedNode";
     $id: string;
@@ -58,11 +49,13 @@ export type FigmaURL = `https://www.figma.com/design/${string}/${string}${"?" |
 export interface FigmaMappingWithKeyMapper<T extends BaseFigmaProps> {
     url?: FigmaURL;
     componentKey: string;
+    componentName?: string;
     mapper?: (figma: T) => any;
 }
 export interface FigmaMappingWithUrlMapper<T extends BaseFigmaProps> {
     url: FigmaURL;
     componentKey?: string;
+    componentName?: string;
     mapper?: (figma: T) => any;
 }
 export interface FigmaGenericMapper {

package/types/server/builder-connect.d.ts

@@ -1,3 +1,6 @@
 import { type DevToolsServerContext, type ConnectedBuilder, type ValidatedBuilder, type SPACE_KIND_VALUES } from "../types";
-export declare function connectBuilder(ctx: DevToolsServerContext, publicApiKey: string, privateAuthKey: string, kind: SPACE_KIND_VALUES): Promise<ConnectedBuilder>;
+export declare function connectBuilder(ctx: DevToolsServerContext, publicApiKey: string, privateAuthKey: string, kind: SPACE_KIND_VALUES): Promise<ConnectedBuilder | {
+    success: boolean;
+    pathname: string;
+}>;
 export declare function validateBuilder(ctx: DevToolsServerContext): Promise<ValidatedBuilder>;