@builder.io/ai-utils 0.83.0 → 0.84.0-dev.202607212345.137e4170f

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@builder.io/ai-utils",
-  "version": "0.83.0",
+  "version": "0.84.0-dev.202607212345.137e4170f",
   "description": "Builder.io AI utils",
   "files": [
     "src"

package/src/acl-schema.d.ts

@@ -0,0 +1,88 @@
+import { z } from "zod";
+export declare const PermissionSchema: z.ZodEnum<{
+    list: "list";
+    read: "read";
+    write: "write";
+}>;
+export type Permission = z.infer<typeof PermissionSchema>;
+export declare const AclEntrySchema: z.ZodObject<{
+    action: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>;
+    resource: z.ZodString;
+    permissions: z.ZodArray<z.ZodEnum<{
+        list: "list";
+        read: "read";
+        write: "write";
+    }>>;
+    description: z.ZodOptional<z.ZodString>;
+    principals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type AclEntry = z.infer<typeof AclEntrySchema>;
+export declare const AclPolicySchema: z.ZodObject<{
+    secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>;
+        resource: z.ZodString;
+        permissions: z.ZodArray<z.ZodEnum<{
+            list: "list";
+            read: "read";
+            write: "write";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        principals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+    denyDescription: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AclPolicy = z.infer<typeof AclPolicySchema>;
+export declare const AclDenialSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "command-allowlist": "command-allowlist";
+        "command-security": "command-security";
+        "file-access": "file-access";
+    }>;
+    reason: z.ZodEnum<{
+        "deny-pattern-matched": "deny-pattern-matched";
+        "no-allow-match": "no-allow-match";
+        "security-policy": "security-policy";
+        "shell-metacharacter": "shell-metacharacter";
+    }>;
+    resource: z.ZodString;
+    command: z.ZodOptional<z.ZodString>;
+    permission: z.ZodOptional<z.ZodEnum<{
+        list: "list";
+        read: "read";
+        write: "write";
+    }>>;
+    policy: z.ZodOptional<z.ZodString>;
+    matchedPattern: z.ZodOptional<z.ZodString>;
+    matchedEntry: z.ZodOptional<z.ZodObject<{
+        action: z.ZodEnum<{
+            allow: "allow";
+            deny: "deny";
+        }>;
+        resource: z.ZodString;
+        permissions: z.ZodArray<z.ZodEnum<{
+            list: "list";
+            read: "read";
+            write: "write";
+        }>>;
+        description: z.ZodOptional<z.ZodString>;
+        principals: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type AclDenial = z.infer<typeof AclDenialSchema>;
+export interface AccessResult {
+    allowed: boolean;
+    message: string;
+    matchedEntry?: AclEntry;
+    matchedPattern?: string;
+    reason?: "deny-pattern-matched" | "no-allow-match";
+    requestedResource?: string;
+    requestedPermission?: Permission;
+}

package/src/acl-schema.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+export const PermissionSchema = z
+    .enum(["read", "write", "list"])
+    .meta({ title: "Permission" });
+// One ACL rule
+export const AclEntrySchema = z
+    .object({
+    action: z
+        .enum(["allow", "deny"])
+        .meta({ description: "whether this rule allows or denies access" }),
+    resource: z
+        .string()
+        .meta({ description: "what — supports glob patterns like /files/*.txt" }),
+    permissions: z
+        .array(PermissionSchema)
+        .meta({ description: "actions this rule applies to" }),
+    description: z.string().optional().meta({
+        description: "custom message, in deny case, this is the error message. This will override denyDescription on AclPolicy if defined.",
+    }),
+    principals: z.array(z.string()).optional().meta({
+        description: "array of teams/roles this rule applies to (e.g., ['developer', 'admin'])",
+    }),
+})
+    .meta({ title: "AclEntry" });
+// A full ACL policy is just a list of rules
+export const AclPolicySchema = z
+    .object({
+    secrets: z.array(z.string()).optional(),
+    entries: z.array(AclEntrySchema).optional(),
+    denyDescription: z.string().optional().meta({
+        description: "Default message to use when a resource is denied access",
+    }),
+})
+    .meta({ title: "AclPolicy" });
+// Structured description of an ACL/policy denial. Travels with the tool result
+// so internal tools can show admins exactly which rule blocked a command/file,
+// and both UIs can render a distinct "blocked, did not run" treatment.
+export const AclDenialSchema = z
+    .object({
+    kind: z
+        .enum(["command-security", "command-allowlist", "file-access"])
+        .meta({ description: "which gate produced the denial" }),
+    reason: z
+        .enum([
+        "security-policy",
+        "deny-pattern-matched",
+        "no-allow-match",
+        "shell-metacharacter",
+    ])
+        .meta({ description: "why the denial happened" }),
+    resource: z.string().meta({
+        description: "the file path or command that was blocked",
+    }),
+    command: z.string().optional().meta({
+        description: "the full command, when the denial is command-related",
+    }),
+    permission: PermissionSchema.optional().meta({
+        description: "the requested permission, for file-access denials",
+    }),
+    policy: z.string().optional().meta({
+        description: "named security policy that matched, when applicable",
+    }),
+    matchedPattern: z.string().optional().meta({
+        description: "the glob/pattern that matched the resource or command",
+    }),
+    matchedEntry: AclEntrySchema.optional().meta({
+        description: "the full ACL entry that matched, for file-access denials",
+    }),
+    message: z.string().meta({ description: "human-readable explanation" }),
+})
+    .meta({ title: "AclDenial" });

package/src/claw.d.ts

@@ -101,6 +101,7 @@ export type ChannelType<P extends KnownPlatform> = (typeof CHANNEL_TYPES)[P][num
 /** Union of every channel sub-type across all platforms. */
 export type AnyChannelType = ChannelType<KnownPlatform>;
 export declare function isChannelType<P extends KnownPlatform>(platform: P, type: string): type is ChannelType<P>;
+export declare function isBuilderBranchChannelId(channelId: string): boolean;
 /** Platform recorded on a logged message; "unknown" when the channelId fails to parse. */
 export type ChannelSource = KnownPlatform | "unknown";
 /** Channel sub-type recorded on a logged message; "unknown" when parsing fails. */

package/src/claw.js

@@ -81,6 +81,15 @@ export const CHANNEL_TYPES = {
 export function isChannelType(platform, type) {
     return CHANNEL_TYPES[platform].includes(type);
 }
+export function isBuilderBranchChannelId(channelId) {
+    try {
+        const channel = parseChannelId(channelId);
+        return channel.platform === "builder" && channel.type === "branch";
+    }
+    catch (_a) {
+        return false;
+    }
+}
 /**
  * Converts a Builder channel_id URI to a clickable URL for the
  * corresponding platform (Slack, Jira, etc.).

package/src/claw.spec.js

@@ -1,5 +1,15 @@
 import { describe, it, expect } from "vitest";
-import { convertChannelIdToUrl, formatIncomingMessage, formatWorkerMessage, formatWorkerReport, } from "./claw";
+import { convertChannelIdToUrl, formatIncomingMessage, formatWorkerMessage, formatWorkerReport, isBuilderBranchChannelId, } from "./claw";
+describe("isBuilderBranchChannelId", () => {
+    it("recognizes Builder branch channel IDs", () => {
+        expect(isBuilderBranchChannelId("builder/branch/proj-id/my-branch")).toBe(true);
+    });
+    it("rejects other and invalid channel IDs", () => {
+        expect(isBuilderBranchChannelId("slack/channel/team/channel")).toBe(false);
+        expect(isBuilderBranchChannelId("builder/project/proj-id")).toBe(false);
+        expect(isBuilderBranchChannelId("invalid")).toBe(false);
+    });
+});
 describe("convertChannelIdToUrl", () => {
     describe("slack/thread format", () => {
         it("converts a thread channel ID to a Slack app_redirect URL", () => {

package/src/codegen.d.ts

@@ -6,6 +6,7 @@ import { type EnvironmentVariable, type SetupDependency } from "./common-schemas
 import type { ForcedBackup, GitDiagnostics, ProjectSkill } from "./projects";
 import type { Feature } from "./features";
 import type { CpuKind, BranchType } from "./projects";
+import type { FullLibrarySourceInput } from "./design-systems";
 export declare const GitSnapshotSchema: z.ZodString;
 export type GitSnapshot = z.infer<typeof GitSnapshotSchema>;
 export declare const ImportTypeSchema: z.ZodEnum<{
@@ -229,6 +230,10 @@ export declare const DevServerLogsInputSchema: z.ZodObject<{}, z.core.$strip>;
 export type DevServerLogsInput = z.infer<typeof DevServerLogsInputSchema>;
 export declare const GenerateDesignSystemAgentMdInputSchema: z.ZodObject<{}, z.core.$strip>;
 export type GenerateDesignSystemAgentMdInput = z.infer<typeof GenerateDesignSystemAgentMdInputSchema>;
+export declare const ComputeDocHashInputSchema: z.ZodObject<{
+    relevantFiles: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ComputeDocHashInput = z.infer<typeof ComputeDocHashInputSchema>;
 export declare const DevServerRestartInputSchema: z.ZodObject<{}, z.core.$strip>;
 export type DevServerRestartInput = z.infer<typeof DevServerRestartInputSchema>;
 export declare const BashToolInputSchema: z.ZodObject<{
@@ -1974,6 +1979,9 @@ export declare const CodeGenToolMapSchema: z.ZodObject<{
         purpose: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     GenerateDesignSystemAgentMd: z.ZodObject<{}, z.core.$strip>;
+    ComputeDocHash: z.ZodObject<{
+        relevantFiles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
 }, z.core.$strip>;
 export type CodeGenToolMap = z.infer<typeof CodeGenToolMapSchema>;
 export declare const CodeGenToolsSchema: z.ZodEnum<{
@@ -1984,6 +1992,7 @@ export declare const CodeGenToolsSchema: z.ZodEnum<{
     AskUserQuestion: "AskUserQuestion";
     Bash: "Bash";
     BuilderEdit: "BuilderEdit";
+    ComputeDocHash: "ComputeDocHash";
     ConnectMCP: "ConnectMCP";
     CreateProject: "CreateProject";
     DevServerControl: "DevServerControl";
@@ -2708,6 +2717,7 @@ export declare const CodeGenInputOptionsSchema: z.ZodObject<{
         AskUserQuestion: "AskUserQuestion";
         Bash: "Bash";
         BuilderEdit: "BuilderEdit";
+        ComputeDocHash: "ComputeDocHash";
         ConnectMCP: "ConnectMCP";
         CreateProject: "CreateProject";
         DevServerControl: "DevServerControl";
@@ -4235,6 +4245,7 @@ export interface FusionConfig {
      * `branchType === "design-system-indexing"` branches.
      */
     figmaDecodeJobId?: string;
+    designSystemIndexSources?: FullLibrarySourceInput[];
     featureBranch?: string;
     /** When set, init checks out this exact git commit after cloning featureBranch. */
     checkoutCommit?: string;

package/src/codegen.js

@@ -211,6 +211,25 @@ export const GenerateDesignSystemAgentMdInputSchema = z.object({}).meta({
         " globs `.builder/output/tokens/components/*.css` for component slugs." +
         " Call this as the final step after all CSS files have been written.",
 });
+export const ComputeDocHashInputSchema = z
+    .object({
+    relevantFiles: z
+        .array(z.string())
+        .min(1)
+        .meta({
+        description: "Workspace-relative paths of the source files that define this doc" +
+            " (the same `relevantFiles` recorded in the doc's meta.json). The" +
+            " hash is computed deterministically from these files' contents.",
+    }),
+})
+    .meta({
+    title: "ComputeDocHashInput",
+    description: "Deterministically computes the content hash for an indexed design-system" +
+        " doc from its `relevantFiles`, using the exact algorithm the repo-indexing" +
+        " CLI uses (sorted files, BOM-stripped contents joined with newlines," +
+        " SHA-256). Use this to fill the `hash` field of a component/token/icon" +
+        " meta.json — never invent a hash yourself.",
+});
 export const DevServerRestartInputSchema = z.object({}).meta({
     title: "DevServerRestartInput",
     description: "Restarts the dev server with current configuration.",
@@ -1229,7 +1248,7 @@ export const SendMessageToolInputSchema = z
         description: "When true, send the response as a voice message using text-to-speech. Only supported for Telegram channels. Only set to true when the user's original message was a voice/audio message (look for '[Voice message transcription]' or '[Audio' markers), the channel is Telegram, and the response is short and conversational with no URLs, code, lists, or other content that doesn't translate to audio. Default to false (text) for all text-originated messages.",
     }),
     from_user_id: z.string().optional().meta({
-        description: "Builder.io user ID this message is from / should be attributed to. Only allowed when channel_id is 'builder/branch/{project_id}/{branch_name}'. When set, the message is delivered to the target branch as coming from this user (role 'user') instead of from the agent. Use whenever the message represents user feedback/intent that should be assigned to someone — even if it was composed, summarized, or merged from multiple people.",
+        description: "Builder.io user ID this message is from / should be attributed to. Only allowed when channel_id is 'builder/branch/{project_id}/{branch_name}'. When set, the message is delivered to the target branch as coming from this user (role 'user') instead of from the agent. Defaults to the current requester when omitted. Set this explicitly when relaying a message on behalf of someone other than the person who sent the current message — even if it was composed, summarized, or merged from multiple people.",
     }),
 })
     .meta({ title: "SendMessageToolInput" });
@@ -1587,6 +1606,7 @@ export const CodeGenToolMapSchema = z.object({
     EnsurePR: EnsurePRToolInputSchema,
     EnableDatabase: EnableDatabaseToolInputSchema,
     GenerateDesignSystemAgentMd: GenerateDesignSystemAgentMdInputSchema,
+    ComputeDocHash: ComputeDocHashInputSchema,
 });
 export const CodeGenToolsSchema = CodeGenToolMapSchema.keyof().meta({
     title: "CodeGenTools",

package/src/design-systems.d.ts

@@ -11,64 +11,21 @@ export interface FigmaHydrationResponse {
     manifest: import("./events.js").FigmaFrameManifest | null;
     files: FigmaHydrationFile[];
 }
-export type GenerateDesignSystemAttachmentKind = "fig" | "image" | "pdf" | "text";
-export interface GenerateDesignSystemFormFields {
-    /**
-     * Human-friendly project name. If omitted, the server generates one from
-     * the uploaded `.fig` filenames.
-     */
-    projectName?: string;
-    devToolsVersion?: string;
-    /**
-     * Optional map of filename → page/frame GUIDs to restrict indexing.
-     * GUIDs are file-local, so they must be scoped per attachment.
-     */
-    selection?: Record<string, string[]>;
-    githubRepoUrl?: string;
-    /** Id of a connected Fusion project whose repo is cloned as supplementary context. Takes precedence over `githubRepoUrl`. */
-    connectedProjectId?: string;
-}
 /**
  * Accepts `https://github.com/<owner>/<repo>` (optionally with a trailing
- * `.git` or path segments). Used to gate the public-repo input on the
- * `/design-systems/v1/generate` endpoint.
+ * `.git` or path segments). Used to gate public-repo inputs before cloning.
  */
 export declare const GITHUB_REPO_URL_REGEX: RegExp;
-export interface GenerateDesignSystemRequest extends GenerateDesignSystemFormFields {
-    attachments: File[];
-}
-export interface GenerateDesignSystemResponse {
-    projectId: string;
-    /**
-     * Decode job id. Attachments are processed asynchronously in the
-     * `ai-queue-subscribers` worker. Clients should listen on the
-     * `figmaDecodeJobs/{jobId}` Firestore document for progress and the
-     * resolved `branchName` / `branchUrl`.
-     */
-    jobId: string;
-    designSystemId: string;
-}
-export interface GenerateDesignSystemErrorResponse {
-    error: string | Record<string, unknown>;
-}
 export declare const GENERATE_DESIGN_SYSTEM_MAX_FILE_BYTES: number;
 export declare const GENERATE_DESIGN_SYSTEM_MAX_ATTACHMENTS = 50;
 export declare const GENERATE_DESIGN_SYSTEM_MIN_ATTACHMENTS = 0;
-export declare const generateDesignSystemBodySchema: z.ZodObject<{
-    projectName: z.ZodOptional<z.ZodString>;
-    devToolsVersion: z.ZodOptional<z.ZodString>;
-    selection: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
-    githubRepoUrl: z.ZodOptional<z.ZodString>;
-    connectedProjectId: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type GenerateDesignSystemBody = z.infer<typeof generateDesignSystemBodySchema>;
 /**
  * Signed-URL upload flow.
  *
  * Clients no longer post `.fig` bytes through the service (Cloud Run caps
  * request bodies at 32 MiB). Instead they call `upload/start` to get a
  * temporary signed resumable-upload URL per attachment, stream the bytes
- * directly to GCS, then call `/generate` with the returned upload tokens.
+ * directly to GCS, then call `/index` with the returned upload tokens.
  * See `tech-specs/signed-url-figma-upload`.
  */
 /** A single attachment the client declares when starting an upload. */
@@ -89,7 +46,7 @@ export declare const uploadStartBodySchema: z.ZodObject<{
 export type UploadStartBody = z.infer<typeof uploadStartBodySchema>;
 /**
  * Claims encoded inside a signed `uploadToken`. Bound to the GCS object at
- * `upload/start` and verified at `/generate`, so a client cannot point the
+ * `upload/start` and verified at `/index`, so a client cannot point the
  * decode worker at an object it did not upload.
  */
 export declare const uploadTokenPayloadSchema: z.ZodObject<{
@@ -106,24 +63,167 @@ export interface UploadStartResponseItem {
     idx: number;
     /** Signed URL the client POSTs to (with `x-goog-resumable: start`) to begin the resumable upload. */
     uploadUrl: string;
-    /** Opaque signed token the client passes back to `/generate`. */
+    /** Opaque signed token the client passes back to `/index`. */
     uploadToken: string;
 }
 export interface UploadStartResponse {
     jobId: string;
     uploads: UploadStartResponseItem[];
 }
-/**
- * Request body for the signed-URL variant of `POST /design-systems/v1/generate`.
- * Same non-file fields as the legacy multipart form, plus the `uploads`
- * tokens returned by `upload/start` (one per attachment).
- */
-export declare const generateDesignSystemRequestSchema: z.ZodObject<{
-    projectName: z.ZodOptional<z.ZodString>;
-    devToolsVersion: z.ZodOptional<z.ZodString>;
-    selection: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
-    githubRepoUrl: z.ZodOptional<z.ZodString>;
-    connectedProjectId: z.ZodOptional<z.ZodString>;
-    uploads: z.ZodArray<z.ZodString>;
+export declare const indexDesignSystemScopeSchema: z.ZodEnum<{
+    global: "global";
+    organization: "organization";
+    space: "space";
+}>;
+export type IndexDesignSystemScope = z.infer<typeof indexDesignSystemScopeSchema>;
+export declare const fullLibrarySourceKindSchema: z.ZodEnum<{
+    "connected-repo": "connected-repo";
+    package: "package";
+    "public-repo": "public-repo";
+}>;
+export type FullLibrarySourceKind = z.infer<typeof fullLibrarySourceKindSchema>;
+export declare const fullLibrarySourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"connected-repo">;
+    fusionProjectId: z.ZodString;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"public-repo">;
+    repoUrl: z.ZodString;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"package">;
+    package: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type FullLibrarySourceInput = z.infer<typeof fullLibrarySourceSchema>;
+export type ConnectedRepoSourceInput = Extract<FullLibrarySourceInput, {
+    kind: "connected-repo";
+}>;
+export type PublicRepoSourceInput = Extract<FullLibrarySourceInput, {
+    kind: "public-repo";
+}>;
+export type PackageSourceInput = Extract<FullLibrarySourceInput, {
+    kind: "package";
+}>;
+export declare const fileSourceSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    uploadToken: z.ZodOptional<z.ZodString>;
+    uploadGcsPath: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FileSourceInput = z.infer<typeof fileSourceSchema>;
+export declare const designSystemSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"connected-repo">;
+    fusionProjectId: z.ZodString;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"public-repo">;
+    repoUrl: z.ZodString;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"package">;
+    package: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    uploadToken: z.ZodOptional<z.ZodString>;
+    uploadGcsPath: z.ZodOptional<z.ZodString>;
+    selection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    instructions: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+export type DesignSystemSourceInput = z.infer<typeof designSystemSourceSchema>;
+export declare const resolvePackageOptionsSchema: z.ZodObject<{
+    package: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    specifier: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ResolvePackageOptions = z.infer<typeof resolvePackageOptionsSchema>;
+export interface ResolvePackageResult {
+    /** Whether the package resolved successfully from the registry. */
+    ok: boolean;
+    package: string;
+    /** Registry actually queried (defaults to the public npm registry). */
+    registry: string;
+    /** Specifier requested (defaults to "latest"). */
+    specifier: string;
+    /** Concrete version the specifier resolved to, when ok. */
+    version?: string;
+    /** Tarball URL for the resolved version, when ok. */
+    tarball?: string;
+    /** Human-readable failure reason, when not ok. */
+    error?: string;
+}
+export declare const indexDesignSystemBodySchema: z.ZodObject<{
+    designSystemName: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        global: "global";
+        organization: "organization";
+        space: "space";
+    }>>;
+    sources: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"connected-repo">;
+        fusionProjectId: z.ZodString;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"public-repo">;
+        repoUrl: z.ZodString;
+        include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"package">;
+        package: z.ZodString;
+        registry: z.ZodOptional<z.ZodString>;
+        token: z.ZodOptional<z.ZodString>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"file">;
+        uploadToken: z.ZodOptional<z.ZodString>;
+        uploadGcsPath: z.ZodOptional<z.ZodString>;
+        selection: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        instructions: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type IndexDesignSystemBody = z.infer<typeof indexDesignSystemBodySchema>;
+export declare const sourceFileEntrySchema: z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    type: z.ZodEnum<{
+        dir: "dir";
+        file: "file";
+    }>;
+}, z.core.$strip>;
+export type SourceFileEntry = z.infer<typeof sourceFileEntrySchema>;
+export declare const listSourceFilesQuerySchema: z.ZodObject<{
+    projectId: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ListSourceFilesQuery = z.infer<typeof listSourceFilesQuerySchema>;
+export interface ListSourceFilesResponse {
+    /** The directory that was listed (repo-relative; "" for root). */
+    path: string;
+    entries: SourceFileEntry[];
+}
+export declare const listPublicSourceFilesQuerySchema: z.ZodObject<{
+    repoUrl: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type GenerateDesignSystemRequestBody = z.infer<typeof generateDesignSystemRequestSchema>;
+export type ListPublicSourceFilesQuery = z.infer<typeof listPublicSourceFilesQuerySchema>;