@builder.io/ai-utils 0.81.3 → 0.83.0-dev.202607211718.99c5f9cf8

package/src/perf-report.d.ts

@@ -0,0 +1,116 @@
+import { z } from "zod";
+export declare const CURRENT_PERF_REPORT_SCHEMA_VERSION = 1;
+export declare const PerfIncidentTypeSchema: z.ZodEnum<{
+    hang: "hang";
+    "memory-pressure": "memory-pressure";
+    "recovered-hang": "recovered-hang";
+    "recovered-unclean-exit": "recovered-unclean-exit";
+    "renderer-crash": "renderer-crash";
+}>;
+export type PerfIncidentType = z.infer<typeof PerfIncidentTypeSchema>;
+export declare const PerfProcessSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        browser: "browser";
+        child: "child";
+        gpu: "gpu";
+        renderer: "renderer";
+        utility: "utility";
+    }>;
+    pid: z.ZodNumber;
+    memoryKb: z.ZodNumber;
+    cpuPercent: z.ZodNumber;
+    tabId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PerfProcess = z.infer<typeof PerfProcessSchema>;
+export declare const PerfTabSchema: z.ZodObject<{
+    tabId: z.ZodString;
+    route: z.ZodOptional<z.ZodString>;
+    feature: z.ZodOptional<z.ZodString>;
+    jsHeapUsedKb: z.ZodOptional<z.ZodNumber>;
+    jsHeapLimitKb: z.ZodOptional<z.ZodNumber>;
+    subsystems: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    livenessLatencyMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type PerfTab = z.infer<typeof PerfTabSchema>;
+export declare const PerfSampleSchema: z.ZodObject<{
+    t: z.ZodNumber;
+    desktopFootprintKb: z.ZodNumber;
+    freeMemoryKb: z.ZodNumber;
+    perTabHeapKb: z.ZodRecord<z.ZodString, z.ZodNumber>;
+}, z.core.$strip>;
+export type PerfSample = z.infer<typeof PerfSampleSchema>;
+export declare const PerfReportSchema: z.ZodObject<{
+    schemaVersion: z.ZodNumber;
+    incidentType: z.ZodEnum<{
+        hang: "hang";
+        "memory-pressure": "memory-pressure";
+        "recovered-hang": "recovered-hang";
+        "recovered-unclean-exit": "recovered-unclean-exit";
+        "renderer-crash": "renderer-crash";
+    }>;
+    sessionId: z.ZodString;
+    deviceId: z.ZodString;
+    appVersion: z.ZodString;
+    platform: z.ZodEnum<{
+        darwin: "darwin";
+        linux: "linux";
+        win32: "win32";
+    }>;
+    channel: z.ZodEnum<{
+        alpha: "alpha";
+        stable: "stable";
+    }>;
+    timestamp: z.ZodNumber;
+    machine: z.ZodObject<{
+        totalMemoryKb: z.ZodNumber;
+        freeMemoryKb: z.ZodNumber;
+        desktopFootprintKb: z.ZodNumber;
+    }, z.core.$strip>;
+    processes: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            browser: "browser";
+            child: "child";
+            gpu: "gpu";
+            renderer: "renderer";
+            utility: "utility";
+        }>;
+        pid: z.ZodNumber;
+        memoryKb: z.ZodNumber;
+        cpuPercent: z.ZodNumber;
+        tabId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    tabs: z.ZodArray<z.ZodObject<{
+        tabId: z.ZodString;
+        route: z.ZodOptional<z.ZodString>;
+        feature: z.ZodOptional<z.ZodString>;
+        jsHeapUsedKb: z.ZodOptional<z.ZodNumber>;
+        jsHeapLimitKb: z.ZodOptional<z.ZodNumber>;
+        subsystems: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        livenessLatencyMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    crash: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        oom: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    hang: z.ZodOptional<z.ZodObject<{
+        startedAt: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        recovered: z.ZodBoolean;
+        surface: z.ZodString;
+    }, z.core.$strip>>;
+    samples: z.ZodArray<z.ZodObject<{
+        t: z.ZodNumber;
+        desktopFootprintKb: z.ZodNumber;
+        freeMemoryKb: z.ZodNumber;
+        perTabHeapKb: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type PerfReport = z.infer<typeof PerfReportSchema>;
+/**
+ * Collapses opaque identifiers out of a route/URL so a report can't carry a
+ * project/space id. Keeps the structural shape (which screen was open) while
+ * masking the specific resource.
+ */
+export declare function redactPerfRoute(route: string | undefined): string | undefined;
+export declare function redactPerfReport(report: PerfReport): PerfReport;

package/src/perf-report.js

@@ -0,0 +1,122 @@
+import { z } from "zod";
+// ============================================================================
+// Desktop performance & crash monitoring wire contract.
+//
+// Canonical schema. The Electron desktop app lives in a separate workspace and
+// cannot import this file, so it keeps a hand-mirrored TypeScript type in
+// code/packages/electron-app/src/perf-report.types.ts. Keep the two in sync and
+// bump CURRENT_PERF_REPORT_SCHEMA_VERSION on any breaking shape change.
+// ============================================================================
+export const CURRENT_PERF_REPORT_SCHEMA_VERSION = 1;
+export const PerfIncidentTypeSchema = z.enum([
+    "renderer-crash",
+    "hang",
+    "recovered-hang",
+    "memory-pressure",
+    "recovered-unclean-exit",
+]);
+export const PerfProcessSchema = z.object({
+    kind: z.enum(["browser", "renderer", "gpu", "utility", "child"]),
+    pid: z.number(),
+    memoryKb: z.number(),
+    cpuPercent: z.number(),
+    tabId: z.string().optional(),
+});
+export const PerfTabSchema = z.object({
+    tabId: z.string(),
+    route: z.string().optional(),
+    feature: z.string().optional(),
+    jsHeapUsedKb: z.number().optional(),
+    jsHeapLimitKb: z.number().optional(),
+    subsystems: z.record(z.string(), z.number()),
+    livenessLatencyMs: z.number().optional(),
+});
+export const PerfSampleSchema = z.object({
+    t: z.number(),
+    desktopFootprintKb: z.number(),
+    freeMemoryKb: z.number(),
+    perTabHeapKb: z.record(z.string(), z.number()),
+});
+export const PerfReportSchema = z.object({
+    schemaVersion: z.number(),
+    incidentType: PerfIncidentTypeSchema,
+    sessionId: z.string(),
+    deviceId: z.string(),
+    appVersion: z.string(),
+    platform: z.enum(["darwin", "win32", "linux"]),
+    channel: z.enum(["stable", "alpha"]),
+    timestamp: z.number(),
+    machine: z.object({
+        totalMemoryKb: z.number(),
+        freeMemoryKb: z.number(),
+        desktopFootprintKb: z.number(),
+    }),
+    processes: z.array(PerfProcessSchema),
+    tabs: z.array(PerfTabSchema),
+    crash: z
+        .object({
+        reason: z.string(),
+        exitCode: z.number().optional(),
+        oom: z.boolean().optional(),
+    })
+        .optional(),
+    hang: z
+        .object({
+        startedAt: z.number(),
+        durationMs: z.number(),
+        recovered: z.boolean(),
+        surface: z.string(),
+    })
+        .optional(),
+    samples: z.array(PerfSampleSchema),
+});
+// ---------------------------------------------------------------------------
+// Route/URL redaction. The desktop client redacts before sending; this runs
+// again at ingest (defense in depth) because the service cannot import the
+// renderer's redactSnapshot helper across the workspace boundary.
+// ---------------------------------------------------------------------------
+const PROJECT_ID_SEGMENTS = new Set([
+    "projects",
+    "content",
+    "fusion",
+    "space",
+    "org",
+    "organization",
+]);
+/**
+ * Collapses opaque identifiers out of a route/URL so a report can't carry a
+ * project/space id. Keeps the structural shape (which screen was open) while
+ * masking the specific resource.
+ */
+export function redactPerfRoute(route) {
+    if (!route) {
+        return route;
+    }
+    const [pathPart] = route.split("?");
+    const segments = pathPart.split("/");
+    const redacted = segments.map((segment, index) => {
+        var _a;
+        if (!segment) {
+            return segment;
+        }
+        const previous = (_a = segments[index - 1]) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        if (previous && PROJECT_ID_SEGMENTS.has(previous)) {
+            return ":id";
+        }
+        // Bare id-looking segments (uuids, long hex/base62 tokens).
+        if (/^[0-9a-f]{16,}$/i.test(segment) || /^[0-9a-z]{20,}$/i.test(segment)) {
+            return ":id";
+        }
+        return segment;
+    });
+    return redacted.join("/");
+}
+export function redactPerfReport(report) {
+    return {
+        ...report,
+        tabs: report.tabs.map((tab) => ({
+            ...tab,
+            route: redactPerfRoute(tab.route),
+        })),
+    };
+}

package/src/projects.d.ts

@@ -153,7 +153,7 @@ export interface ReadyMessage extends BaseMessage {
 }
 export type MachineState = "unknown" | "created" | "starting" | "started" | "stopping" | "stopped" | "suspending" | "suspended" | "replacing" | "destroying" | "destroyed" | "not-found" | "running" | "failed";
 export type FlyVolumeState = "unknown" | "creating" | "created" | "extending" | "restoring" | "enabling_remote_export" | "hydrating" | "recovering" | "scheduling_destroy" | "pending_destroy" | "failed";
-export type GitAuthErrorCode = "git-auth-failed" | "git-auth-failed-root-repo" | "git-auth-failed-folder-added-by" | "git-auth-failed-folder-created-by" | "git-auth-failed-repo-not-found" | "git-auth-failed-repo-renamed" | "git-auth-failed-folder-server-token" | "git-auth-failed-root-repo-server-token" | "git-auth-failed-ghes-unreachable";
+export type GitAuthErrorCode = "git-auth-failed" | "git-auth-failed-root-repo" | "git-auth-failed-folder-added-by" | "git-auth-failed-folder-created-by" | "git-auth-failed-repo-not-found" | "git-auth-failed-repo-renamed" | "git-auth-failed-folder-server-token" | "git-auth-failed-root-repo-server-token" | "git-auth-failed-ghes-unreachable" | "git-auth-reauth-required";
 /**
  * Git provider types for diagnostics.
  */
@@ -909,12 +909,6 @@ export interface Project {
     deletedAt?: InMigrationDateNullable;
     /** User ID of whoever deleted the project. */
     deletedBy?: string;
-    /**
-     * When true, branches are stored in the standalone `branches` collection
-     * instead of embedded in project.branches field.
-     * Defaults to false for backwards compatibility with existing projects.
-     */
-    useBranchesCollection?: boolean;
     /** When true, the project is in code-only mode */
     codeOnlyMode?: boolean;
     /**
@@ -1075,8 +1069,6 @@ export interface CreateProjectOptions {
     autoApplySetup?: boolean;
     templateId?: string;
     useInternalHost?: boolean;
-    /** Store branches in the standalone `branches` collection vs embedded in the project doc. */
-    useBranchesCollection?: boolean;
     /** @internal Read-only source repo cloned to bootstrap the project. Carried through to Firestore. */
     templateRepoUrl?: string;
     /** @internal First-class hosting config copied from the template. Carried through to Firestore. */
@@ -1497,9 +1489,8 @@ export declare const ProjectHostingSchema: z.ZodObject<{
         uploading: "uploading";
     }>>;
     publishedCommit: z.ZodOptional<z.ZodString>;
-    customDomain: z.ZodOptional<z.ZodString>;
-    customDomainVerified: z.ZodOptional<z.ZodBoolean>;
     autoDeploy: z.ZodOptional<z.ZodBoolean>;
+    domainIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type ProjectHosting = z.infer<typeof ProjectHostingSchema>;
 /**
@@ -1718,6 +1709,113 @@ export declare const GetDeploysResponseSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type GetDeploysResponse = z.infer<typeof GetDeploysResponseSchema>;
+export declare const HostingDomainStatusSchema: z.ZodEnum<{
+    active: "active";
+    failed: "failed";
+    pending: "pending";
+    provisioning: "provisioning";
+    verifying: "verifying";
+}>;
+export type HostingDomainStatus = z.infer<typeof HostingDomainStatusSchema>;
+export declare const HostingDomainKindSchema: z.ZodEnum<{
+    apex: "apex";
+    subdomain: "subdomain";
+}>;
+export type HostingDomainKind = z.infer<typeof HostingDomainKindSchema>;
+/**
+ * Custom domain record, stored at `hosting-domains/{domain}`.
+ * The normalized domain is the doc key — global uniqueness comes for free.
+ * This doc is both the record AND the claim for the domain.
+ */
+export declare const HostingDomainSchema: z.ZodObject<{
+    domain: z.ZodString;
+    kind: z.ZodEnum<{
+        apex: "apex";
+        subdomain: "subdomain";
+    }>;
+    projectId: z.ZodString;
+    ownerId: z.ZodString;
+    status: z.ZodEnum<{
+        active: "active";
+        failed: "failed";
+        pending: "pending";
+        provisioning: "provisioning";
+        verifying: "verifying";
+    }>;
+    dnsAuthId: z.ZodString;
+    delegationTarget: z.ZodString;
+    trafficTarget: z.ZodOptional<z.ZodString>;
+    certId: z.ZodOptional<z.ZodString>;
+    certMapEntryName: z.ZodOptional<z.ZodString>;
+    httpRouteName: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    pendingSince: z.ZodNumber;
+    verifyingSince: z.ZodOptional<z.ZodNumber>;
+    attemptId: z.ZodOptional<z.ZodString>;
+    verifiedAt: z.ZodOptional<z.ZodNumber>;
+    error: z.ZodOptional<z.ZodString>;
+    failedStep: z.ZodOptional<z.ZodEnum<{
+        dns: "dns";
+        https: "https";
+    }>>;
+    createdBy: z.ZodString;
+}, z.core.$strip>;
+export type HostingDomain = z.infer<typeof HostingDomainSchema>;
+export declare const AddDomainRequestSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export type AddDomainRequest = z.infer<typeof AddDomainRequestSchema>;
+export declare const AddDomainResponseSchema: z.ZodObject<{
+    domain: z.ZodString;
+    kind: z.ZodEnum<{
+        apex: "apex";
+        subdomain: "subdomain";
+    }>;
+    records: z.ZodObject<{
+        traffic: z.ZodObject<{
+            recordType: z.ZodEnum<{
+                A: "A";
+                CNAME: "CNAME";
+            }>;
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>;
+        validation: z.ZodObject<{
+            recordType: z.ZodEnum<{
+                A: "A";
+                CNAME: "CNAME";
+            }>;
+            name: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type AddDomainResponse = z.infer<typeof AddDomainResponseSchema>;
+export declare const VerifyDomainRequestSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export type VerifyDomainRequest = z.infer<typeof VerifyDomainRequestSchema>;
+export declare const VerifyDomainResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        active: "active";
+        failed: "failed";
+        pending: "pending";
+        provisioning: "provisioning";
+        verifying: "verifying";
+    }>;
+}, z.core.$strip>;
+export type VerifyDomainResponse = z.infer<typeof VerifyDomainResponseSchema>;
+export declare const RemoveDomainRequestSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export type RemoveDomainRequest = z.infer<typeof RemoveDomainRequestSchema>;
+export declare const RemoveDomainResponseSchema: z.ZodObject<{
+    success: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export type RemoveDomainResponse = z.infer<typeof RemoveDomainResponseSchema>;
 export declare const CloneProjectOptionsSchema: z.ZodObject<{
     sourceProjectId: z.ZodString;
     sourceBranchName: z.ZodDefault<z.ZodString>;
@@ -1728,7 +1826,6 @@ export declare const CloneProjectOptionsSchema: z.ZodObject<{
     }>;
     userEmail: z.ZodOptional<z.ZodString>;
     useKube: z.ZodDefault<z.ZodBoolean>;
-    useBranchesCollection: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type CloneProjectOptions = z.infer<typeof CloneProjectOptionsSchema>;
 export declare const DuplicateBranchOptionsSchema: z.ZodObject<{

package/src/projects.js

@@ -322,12 +322,13 @@ export const ProjectHostingSchema = z.object({
     lastDeployStatus: DeployStatusSchema.optional(),
     /** Git commit currently live at the project's hosting URL (set on go-live). */
     publishedCommit: z.string().optional(),
-    customDomain: z.string().optional(),
-    customDomainVerified: z.boolean().optional(),
     autoDeploy: z
         .boolean()
         .optional()
         .meta({ description: "auto-deploy on push/merge" }),
+    domainIds: z.array(z.string()).optional().meta({
+        description: "Doc keys (normalized domains) in `hosting-domains` attached to this project. The domain docs are the source of truth; this is only the back-pointer.",
+    }),
 });
 /**
  * Canonical "is this project hostable" predicate. Keys off the explicit
@@ -613,6 +614,90 @@ export const GetDeploysRequestSchema = z.object({
 export const GetDeploysResponseSchema = z.object({
     deploys: z.array(DeployListItemSchema),
 });
+export const HostingDomainStatusSchema = z.enum([
+    "pending",
+    "verifying",
+    "provisioning",
+    "active",
+    "failed",
+]);
+export const HostingDomainKindSchema = z.enum(["apex", "subdomain"]);
+/**
+ * Custom domain record, stored at `hosting-domains/{domain}`.
+ * The normalized domain is the doc key — global uniqueness comes for free.
+ * This doc is both the record AND the claim for the domain.
+ */
+export const HostingDomainSchema = z.object({
+    domain: z
+        .string()
+        .meta({ description: "Doc key — normalized (punycode) domain." }),
+    kind: HostingDomainKindSchema,
+    projectId: z.string(),
+    ownerId: z.string(),
+    status: HostingDomainStatusSchema,
+    dnsAuthId: z
+        .string()
+        .meta({ description: "GCP DNS authorization resource name." }),
+    delegationTarget: z.string().meta({
+        description: "_acme-challenge CNAME value the customer must add.",
+    }),
+    trafficTarget: z.string().optional().meta({
+        description: "The traffic record value: ALB anycast IP for apex domains, `cname.builder.cloud` for subdomains. Persisted so the UI can reconstruct both DNS records after page reload.",
+    }),
+    certId: z
+        .string()
+        .optional()
+        .meta({ description: "Certificate Manager cert resource name." }),
+    certMapEntryName: z.string().optional(),
+    httpRouteName: z.string().optional(),
+    createdAt: z.number(),
+    pendingSince: z.number().meta({
+        description: "TTL anchor: set on entering `pending`, re-stamped on `failed`→`pending`.",
+    }),
+    verifyingSince: z.number().optional().meta({
+        description: "Set when the delegation-check poll loop starts (on entering `verifying`). Used for the poll timeout and UI. Cleared on promotion to `provisioning` or on failure.",
+    }),
+    attemptId: z.string().optional().meta({
+        description: "Per-verify-attempt nonce, set on entering `verifying`. Delegation-check polls whose attemptId no longer matches are stale (a newer retry superseded them) and stop early.",
+    }),
+    verifiedAt: z.number().optional(),
+    error: z.string().optional(),
+    failedStep: z.enum(["dns", "https"]).optional().meta({
+        description: "Which setup step failed, set alongside `status: failed` so the UI can attribute the failure. `dns` = delegation verification, `https` = cert/route provisioning.",
+    }),
+    createdBy: z.string(),
+});
+export const AddDomainRequestSchema = z.object({
+    projectId: z.string(),
+    domain: z.string(),
+});
+const DnsRecordSchema = z.object({
+    recordType: z.enum(["A", "CNAME"]),
+    name: z.string(),
+    value: z.string(),
+});
+export const AddDomainResponseSchema = z.object({
+    domain: z.string(),
+    kind: HostingDomainKindSchema,
+    records: z.object({
+        traffic: DnsRecordSchema,
+        validation: DnsRecordSchema,
+    }),
+});
+export const VerifyDomainRequestSchema = z.object({
+    projectId: z.string(),
+    domain: z.string(),
+});
+export const VerifyDomainResponseSchema = z.object({
+    status: HostingDomainStatusSchema,
+});
+export const RemoveDomainRequestSchema = z.object({
+    projectId: z.string(),
+    domain: z.string(),
+});
+export const RemoveDomainResponseSchema = z.object({
+    success: z.literal(true),
+});
 export const CloneProjectOptionsSchema = z.object({
     sourceProjectId: z.string().min(1).meta({
         description: "Project to clone from.",
@@ -640,13 +725,6 @@ export const CloneProjectOptionsSchema = z.object({
     useKube: z.boolean().default(false).meta({
         description: "Whether to provision on cloud-v2 (Kubernetes). Defaults to false.",
     }),
-    useBranchesCollection: z
-        .boolean()
-        .default(false)
-        .meta({
-        description: "Whether the new project stores branches in the standalone `branches` " +
-            "collection rather than embedded in the project doc. Defaults to false.",
-    }),
 });
 export const DuplicateBranchOptionsSchema = z.object({
     projectId: z.string().min(1).meta({

package/src/proxy.d.ts

@@ -20,7 +20,7 @@ export interface ProxyConfig {
  *
  * `proxyDestination` is always passed through unchanged.
  */
-export declare function getProxyConfig({ devServerUrl, proxyOrigin, proxyDefaultOrigin, proxyDestination }: ProxyConfig): {
+export declare function getProxyConfig({ devServerUrl, proxyOrigin, proxyDefaultOrigin, proxyDestination, }: ProxyConfig): {
     proxyOrigin: string | undefined;
     proxyDefaultOrigin: string | undefined;
     proxyDestination: string | undefined;