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

package/src/embeddings.d.ts

@@ -0,0 +1,82 @@
+import { z } from "zod";
+export declare const BUILDER_EMBEDDING_MODEL = "builder-multimodal-embedding";
+export declare const BUILDER_EMBEDDING_DIMENSIONS = 1024;
+export declare const BUILDER_EMBEDDING_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+export declare const BuilderEmbeddingImageSchema: z.ZodObject<{
+    mimeType: z.ZodEnum<{
+        "image/gif": "image/gif";
+        "image/jpeg": "image/jpeg";
+        "image/png": "image/png";
+        "image/webp": "image/webp";
+    }>;
+    data: z.ZodString;
+}, z.core.$strip>;
+export declare const BuilderEmbeddingInputSchema: z.ZodObject<{
+    text: z.ZodOptional<z.ZodString>;
+    images: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        mimeType: z.ZodEnum<{
+            "image/gif": "image/gif";
+            "image/jpeg": "image/jpeg";
+            "image/png": "image/png";
+            "image/webp": "image/webp";
+        }>;
+        data: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export declare const BuilderEmbeddingsRequestSchema: z.ZodObject<{
+    model: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        "builder-multimodal-embedding": "builder-multimodal-embedding";
+    }>>;
+    inputType: z.ZodDefault<z.ZodEnum<{
+        document: "document";
+        query: "query";
+    }>>;
+    inputs: z.ZodArray<z.ZodObject<{
+        text: z.ZodOptional<z.ZodString>;
+        images: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            mimeType: z.ZodEnum<{
+                "image/gif": "image/gif";
+                "image/jpeg": "image/jpeg";
+                "image/png": "image/png";
+                "image/webp": "image/webp";
+            }>;
+            data: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    source: z.ZodOptional<z.ZodObject<{
+        appId: z.ZodOptional<z.ZodString>;
+        feature: z.ZodOptional<z.ZodString>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type BuilderEmbeddingsRequestInput = z.input<typeof BuilderEmbeddingsRequestSchema>;
+export type BuilderEmbeddingsRequest = z.output<typeof BuilderEmbeddingsRequestSchema>;
+export declare const BuilderEmbeddingsResponseSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"list">;
+    model: z.ZodObject<{
+        publicId: z.ZodLiteral<"builder-multimodal-embedding">;
+        provider: z.ZodLiteral<"voyage">;
+        providerModel: z.ZodLiteral<"voyage-multimodal-3.5">;
+        version: z.ZodLiteral<"3.5">;
+        dimensions: z.ZodLiteral<1024>;
+    }, z.core.$strip>;
+    inputType: z.ZodEnum<{
+        document: "document";
+        query: "query";
+    }>;
+    data: z.ZodArray<z.ZodObject<{
+        object: z.ZodLiteral<"embedding">;
+        index: z.ZodNumber;
+        embedding: z.ZodArray<z.ZodNumber>;
+    }, z.core.$strip>>;
+    usage: z.ZodObject<{
+        textTokens: z.ZodNumber;
+        imagePixels: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type BuilderEmbeddingsResponse = z.infer<typeof BuilderEmbeddingsResponseSchema>;

package/src/embeddings.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+export const BUILDER_EMBEDDING_MODEL = "builder-multimodal-embedding";
+export const BUILDER_EMBEDDING_DIMENSIONS = 1024;
+export const BUILDER_EMBEDDING_IMAGE_MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "image/gif",
+];
+const MAX_IMAGE_BASE64_LENGTH = 14000000;
+const MAX_REQUEST_BASE64_LENGTH = 24000000;
+const MAX_REQUEST_TEXT_LENGTH = 256000;
+export const BuilderEmbeddingImageSchema = z.object({
+    mimeType: z.enum(BUILDER_EMBEDDING_IMAGE_MIME_TYPES),
+    data: z
+        .string()
+        .min(1)
+        .max(MAX_IMAGE_BASE64_LENGTH)
+        .regex(/^[A-Za-z0-9+/]*={0,2}$/, "Image data must be raw base64."),
+});
+export const BuilderEmbeddingInputSchema = z
+    .object({
+    text: z.string().trim().min(1).max(32000).optional(),
+    images: z.array(BuilderEmbeddingImageSchema).max(6).default([]),
+})
+    .superRefine((input, ctx) => {
+    if (!input.text && input.images.length === 0) {
+        ctx.addIssue({
+            code: "custom",
+            message: "Each input must contain text, an image, or both.",
+        });
+    }
+});
+export const BuilderEmbeddingsRequestSchema = z
+    .object({
+    model: z.enum(["auto", BUILDER_EMBEDDING_MODEL]).default("auto"),
+    inputType: z.enum(["query", "document"]).default("document"),
+    inputs: z.array(BuilderEmbeddingInputSchema).min(1).max(32),
+    source: z
+        .object({
+        appId: z.string().max(100).optional(),
+        feature: z.string().max(100).optional(),
+        resourceId: z.string().max(200).optional(),
+        userId: z.string().max(200).optional(),
+    })
+        .optional(),
+    metadata: z.record(z.string().max(100), z.string().max(1000)).optional(),
+})
+    .superRefine((request, ctx) => {
+    var _a;
+    var _b;
+    let base64Length = 0;
+    let textLength = 0;
+    for (const input of request.inputs) {
+        textLength += (_b = (_a = input.text) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+        for (const image of input.images)
+            base64Length += image.data.length;
+    }
+    if (base64Length > MAX_REQUEST_BASE64_LENGTH) {
+        ctx.addIssue({
+            code: "too_big",
+            maximum: MAX_REQUEST_BASE64_LENGTH,
+            origin: "string",
+            inclusive: true,
+            message: "Combined image data is too large.",
+            path: ["inputs"],
+        });
+    }
+    if (textLength > MAX_REQUEST_TEXT_LENGTH) {
+        ctx.addIssue({
+            code: "too_big",
+            maximum: MAX_REQUEST_TEXT_LENGTH,
+            origin: "string",
+            inclusive: true,
+            message: "Combined text input is too large.",
+            path: ["inputs"],
+        });
+    }
+})
+    .meta({
+    description: "Request body for POST /agent-native/embeddings/v1/embeddings.",
+});
+export const BuilderEmbeddingsResponseSchema = z.object({
+    id: z.string(),
+    object: z.literal("list"),
+    model: z.object({
+        publicId: z.literal(BUILDER_EMBEDDING_MODEL),
+        provider: z.literal("voyage"),
+        providerModel: z.literal("voyage-multimodal-3.5"),
+        version: z.literal("3.5"),
+        dimensions: z.literal(BUILDER_EMBEDDING_DIMENSIONS),
+    }),
+    inputType: z.enum(["query", "document"]),
+    data: z.array(z.object({
+        object: z.literal("embedding"),
+        index: z.number().int().nonnegative(),
+        embedding: z
+            .array(z.number().finite())
+            .length(BUILDER_EMBEDDING_DIMENSIONS),
+    })),
+    usage: z.object({
+        textTokens: z.number().int().nonnegative(),
+        imagePixels: z.number().int().nonnegative(),
+        totalTokens: z.number().int().nonnegative(),
+    }),
+});

package/src/embeddings.spec.d.ts

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

package/src/embeddings.spec.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { BUILDER_EMBEDDING_MODEL, BuilderEmbeddingsRequestSchema, } from "./embeddings";
+describe("BuilderEmbeddingsRequestSchema", () => {
+    it("accepts retrieval text and multimodal inputs", () => {
+        var _a;
+        const parsed = BuilderEmbeddingsRequestSchema.parse({
+            model: BUILDER_EMBEDDING_MODEL,
+            inputType: "document",
+            inputs: [
+                { text: "A product launch slide" },
+                {
+                    text: "A warm editorial campaign",
+                    images: [{ mimeType: "image/png", data: "aGVsbG8=" }],
+                },
+            ],
+        });
+        expect(parsed.inputs).toHaveLength(2);
+        expect((_a = parsed.inputs[1]) === null || _a === void 0 ? void 0 : _a.images).toHaveLength(1);
+    });
+    it("rejects empty inputs and data URLs", () => {
+        expect(() => BuilderEmbeddingsRequestSchema.parse({ inputs: [{}] })).toThrow(/text, an image, or both/);
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: [
+                {
+                    images: [
+                        {
+                            mimeType: "image/png",
+                            data: "data:image/png;base64,aGVsbG8=",
+                        },
+                    ],
+                },
+            ],
+        })).toThrow(/raw base64/);
+    });
+    it("rejects unsupported image formats and oversized batches", () => {
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: [{ images: [{ mimeType: "image/svg+xml", data: "PHN2Zz4=" }] }],
+        })).toThrow();
+        expect(() => BuilderEmbeddingsRequestSchema.parse({
+            inputs: Array.from({ length: 33 }, () => ({ text: "text" })),
+        })).toThrow();
+    });
+});

package/src/events.d.ts

@@ -1296,7 +1296,33 @@ export declare const McpPrototypePulledV1: {
     eventName: "mcp.prototype.pulled";
     version: "1";
 };
-export type FusionEvent = ClientDevtoolsSessionStartedEvent | ClientDevtoolsSessionIdleEventV1 | ClientDevtoolsToolCallRequestV1 | ClientDevtoolsToolCallV1 | ClientDevtoolsToolResultV1 | ClientDevtoolsBuildMigratedV1 | ClientDevtoolsBuildCompletedV1 | ClientDevtoolsBuildUploadedV1 | ClientDevtoolsBuildFailedV1 | FusionProjectCreatedV1 | SetupAgentCompletedV1 | GitPrMergedV1 | GitPrCreatedV1 | GitPrClosedV1 | ForceSetupAgentV1 | ClawMessageSentV1 | CodegenCompletionV1 | CodegenUserPromptV1 | GitWebhooksRegisterV1 | FusionProjectSettingsUpdatedV1 | VideoRecordingCompletedV1 | TimelineRecordingReadyV1 | FusionBranchCreatedV1 | FusionContainerStartedV1 | FusionContainerFailedV1 | FusionBranchFailedV1 | BotMentionGitHubExternalPrV1 | BotMentionGitHubInternalPrV1 | BotMentionGitLabPrV1 | BotMentionBitbucketPrV1 | BotMentionAzurePrV1 | ReviewSubmittedV1 | PrReviewRequestedV1 | FigmaDecodeJobV1 | ProjectSnapshotRefreshV1 | ProjectSnapshotCapturedV1 | ProjectSnapshotCreatedV1 | ProjectSnapshotFailedV1 | ProjectSnapshotReadyCheckV1 | ProjectSnapshotPodWatchV1 | McpPrototypePulledV1;
+export type HostingCustomDomainCertCheckV1 = FusionEventVariant<"hosting.custom-domain.cert-check", {
+    domain: string;
+    projectId: string;
+    certId: string;
+    startedAtMs: number;
+    timeoutMs: number;
+}, {
+    projectId: string;
+}, 1>;
+export declare const HostingCustomDomainCertCheckV1: {
+    eventName: "hosting.custom-domain.cert-check";
+    version: "1";
+};
+export type HostingCustomDomainDelegationCheckV1 = FusionEventVariant<"hosting.custom-domain.delegation-check", {
+    domain: string;
+    projectId: string;
+    attemptId: string;
+    startedAtMs: number;
+    timeoutMs: number;
+}, {
+    projectId: string;
+}, 1>;
+export declare const HostingCustomDomainDelegationCheckV1: {
+    eventName: "hosting.custom-domain.delegation-check";
+    version: "1";
+};
+export type FusionEvent = ClientDevtoolsSessionStartedEvent | ClientDevtoolsSessionIdleEventV1 | ClientDevtoolsToolCallRequestV1 | ClientDevtoolsToolCallV1 | ClientDevtoolsToolResultV1 | ClientDevtoolsBuildMigratedV1 | ClientDevtoolsBuildCompletedV1 | ClientDevtoolsBuildUploadedV1 | ClientDevtoolsBuildFailedV1 | FusionProjectCreatedV1 | SetupAgentCompletedV1 | GitPrMergedV1 | GitPrCreatedV1 | GitPrClosedV1 | ForceSetupAgentV1 | ClawMessageSentV1 | CodegenCompletionV1 | CodegenUserPromptV1 | GitWebhooksRegisterV1 | FusionProjectSettingsUpdatedV1 | VideoRecordingCompletedV1 | TimelineRecordingReadyV1 | FusionBranchCreatedV1 | FusionContainerStartedV1 | FusionContainerFailedV1 | FusionBranchFailedV1 | BotMentionGitHubExternalPrV1 | BotMentionGitHubInternalPrV1 | BotMentionGitLabPrV1 | BotMentionBitbucketPrV1 | BotMentionAzurePrV1 | ReviewSubmittedV1 | PrReviewRequestedV1 | FigmaDecodeJobV1 | ProjectSnapshotRefreshV1 | ProjectSnapshotCapturedV1 | ProjectSnapshotCreatedV1 | ProjectSnapshotFailedV1 | ProjectSnapshotReadyCheckV1 | ProjectSnapshotPodWatchV1 | McpPrototypePulledV1 | HostingCustomDomainCertCheckV1 | HostingCustomDomainDelegationCheckV1;
 export interface ModelPermissionRequiredEvent {
     type: "assistant.model.permission.required";
     data: {

package/src/events.js

@@ -162,3 +162,11 @@ export const McpPrototypePulledV1 = {
     eventName: "mcp.prototype.pulled",
     version: "1",
 };
+export const HostingCustomDomainCertCheckV1 = {
+    eventName: "hosting.custom-domain.cert-check",
+    version: "1",
+};
+export const HostingCustomDomainDelegationCheckV1 = {
+    eventName: "hosting.custom-domain.delegation-check",
+    version: "1",
+};

package/src/index.d.ts

@@ -21,4 +21,5 @@ export * from "./single-tenancy.js";
 export * from "./design-systems.js";
 export * from "./editor-ai.js";
 export * from "./realtime.js";
+export * from "./embeddings.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/index.js

@@ -21,4 +21,5 @@ export * from "./single-tenancy.js";
 export * from "./design-systems.js";
 export * from "./editor-ai.js";
 export * from "./realtime.js";
+export * from "./embeddings.js";
 export { connectivityErrorCodeToLikelyCause, mapConnectivityErrorMessage, } from "./connectivity/error-codes.js";

package/src/organization.d.ts

@@ -1,5 +1,11 @@
 import type { PrivacyMode, ReviewEffort } from "./codegen";
 import type { EnvironmentVariable } from "./common-schemas";
+export interface GitlabEnterpriseSetupValue {
+    host: string;
+    secondaryHost?: string;
+    setupType: "oauth" | "pat";
+    clientId?: string;
+}
 export interface GithubEnterpriseSetupValue {
     host: string;
     clientId: string;
@@ -19,6 +25,8 @@ export interface GitlabEnterprisePATValue {
     host: string;
     botUsername: string;
     secondaryHost?: string;
+    createdBy?: string;
+    createdAt?: number;
 }
 export interface GitlabCloudFallbackToken {
     token: string;
@@ -79,6 +87,7 @@ interface OrganizationSettings {
     isUserPluginIntegrationRequestGranted?: boolean;
     shopify?: boolean;
     githubEnterpriseSetupValue?: GithubEnterpriseSetupValue;
+    gitlabEnterpriseSetupValue?: GitlabEnterpriseSetupValue;
     gitlabEnterprisePAT?: GitlabEnterprisePATValue;
     gitlabCloudFallbackToken?: GitlabCloudFallbackToken;
     azureCloudFallbackToken?: AzureCloudFallbackToken;

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),
+        })),
+    };
+}