@builder.io/ai-utils 0.84.0-dev.202607212345.137e4170f → 0.85.0-dev.202607231533.14c8ab346

package/package.json

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

package/src/events.d.ts

@@ -598,6 +598,8 @@ export type BotMentionGitHubInternalPrV1 = FusionEventVariant<"bot.mention.githu
     /** Numeric GitHub comment ID (for reaction / reply threading) */
     commentNumericId?: number;
     commentType: "issue" | "pr";
+    /** Whether the normal bot-mention pipeline should post successful agent text. */
+    postSuccessResultComment?: boolean;
     /** GitHub Enterprise hostname, if applicable */
     hostname?: string;
     /** For review comments: the comment being replied to */

package/src/projects.d.ts

@@ -1491,6 +1491,14 @@ export declare const ProjectHostingSchema: z.ZodObject<{
     }>>;
     publishedCommit: z.ZodOptional<z.ZodString>;
     autoDeploy: z.ZodOptional<z.ZodBoolean>;
+    unpublishTrigger: z.ZodOptional<z.ZodEnum<{
+        system: "system";
+        user: "user";
+    }>>;
+    systemUnpublishReason: z.ZodOptional<z.ZodEnum<{
+        "bandwidth-cap": "bandwidth-cap";
+        "web-request-cap": "web-request-cap";
+    }>>;
     domainIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type ProjectHosting = z.infer<typeof ProjectHostingSchema>;
@@ -1549,6 +1557,36 @@ export declare const HostingSlugSchema: z.ZodObject<{
     createdBy: z.ZodString;
 }, z.core.$strip>;
 export type HostingSlug = z.infer<typeof HostingSlugSchema>;
+/**
+ * Per-Neon-project charged-through watermarks inside a space's hosting usage
+ * snapshot. Storage folds root + child branch bytes-month into one field.
+ */
+export declare const HostingNeonProjectUsageSchema: z.ZodObject<{
+    computeUnitSecondsChargedThrough: z.ZodNumber;
+    storageBytesMonthChargedThrough: z.ZodNumber;
+    transferBytesChargedThrough: z.ZodNumber;
+}, z.core.$strip>;
+export type HostingNeonProjectUsage = z.infer<typeof HostingNeonProjectUsageSchema>;
+/**
+ * Reconciler idempotency watermark for a space's Netlify + Neon hosting costs,
+ * stored at `hostingUsageSnapshots/{spaceId}`. Netlify is one account-level
+ * scalar; Neon is a per-project map. `freeDeployCount` gates the free 5/mo
+ * deploy cap (cost itself is inside Netlify's partner_account_usage total).
+ */
+export declare const HostingUsageSnapshotSchema: z.ZodObject<{
+    ownerId: z.ZodString;
+    periodKey: z.ZodString;
+    netlifyConsumptionCycleStart: z.ZodString;
+    netlifyCreditsChargedThrough: z.ZodNumber;
+    neonByProject: z.ZodRecord<z.ZodString, z.ZodObject<{
+        computeUnitSecondsChargedThrough: z.ZodNumber;
+        storageBytesMonthChargedThrough: z.ZodNumber;
+        transferBytesChargedThrough: z.ZodNumber;
+    }, z.core.$strip>>;
+    freeDeployCount: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+export type HostingUsageSnapshot = z.infer<typeof HostingUsageSnapshotSchema>;
 /**
  * Deploy lease lock with fencing token, stored at
  * `hosting-locks/{projectId}__{checkoutBranch}` (the key uses the resolved ref
@@ -1724,9 +1762,21 @@ export declare const HostingDomainKindSchema: z.ZodEnum<{
 }>;
 export type HostingDomainKind = z.infer<typeof HostingDomainKindSchema>;
 /**
- * Custom domain record, stored at `hosting-domains/{domain}`.
+ * Custom domain record. The same shape backs two Firestore collections:
+ *
+ * - Lock doc `hosting-domains/{domain}` is the single exclusive owner. It
+ *   exists only once a project reaches `provisioning`/`active` (cert + route
+ *   created, DNS ownership proven) and is the cross-project serialization
+ *   point serving/deploy/unpublish read to answer "is this verified?".
+ *   `certId`/`certMapEntryName`/`httpRouteName`/`verifiedAt` are only ever
+ *   populated here.
+ * - Claim subdoc `hosting-domains/{domain}/claims/{projectId}` is a
+ *   non-exclusive, per-project verification attempt (`pending`/`verifying`/
+ *   `failed`). Multiple projects can hold a claim on the same domain at once;
+ *   whoever proves DNS ownership first wins the lock and the losers are swept
+ *   to `failed`.
+ *
  * 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;
@@ -1759,6 +1809,8 @@ export declare const HostingDomainSchema: z.ZodObject<{
         dns: "dns";
         https: "https";
     }>>;
+    routeError: z.ZodOptional<z.ZodString>;
+    routeErrorAt: z.ZodOptional<z.ZodNumber>;
     createdBy: z.ZodString;
 }, z.core.$strip>;
 export type HostingDomain = z.infer<typeof HostingDomainSchema>;
@@ -1817,6 +1869,22 @@ export declare const RemoveDomainResponseSchema: z.ZodObject<{
     success: z.ZodLiteral<true>;
 }, z.core.$strip>;
 export type RemoveDomainResponse = z.infer<typeof RemoveDomainResponseSchema>;
+export declare const RepairDomainRequestSchema: z.ZodObject<{
+    projectId: z.ZodString;
+    domain: z.ZodString;
+}, z.core.$strip>;
+export type RepairDomainRequest = z.infer<typeof RepairDomainRequestSchema>;
+export declare const RepairDomainResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<{
+        active: "active";
+        failed: "failed";
+        pending: "pending";
+        provisioning: "provisioning";
+        verifying: "verifying";
+    }>;
+    routeError: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RepairDomainResponse = z.infer<typeof RepairDomainResponseSchema>;
 export declare const CloneProjectOptionsSchema: z.ZodObject<{
     sourceProjectId: z.ZodString;
     sourceBranchName: z.ZodDefault<z.ZodString>;

package/src/projects.js

@@ -328,6 +328,26 @@ export const ProjectHostingSchema = z.object({
         .boolean()
         .optional()
         .meta({ description: "auto-deploy on push/merge" }),
+    /**
+     * Who last drove the site into `publishStatus: "unpublished"`. Absent is
+     * treated as `"user"`. `"system"` means free-tier usage-cap enforcement took
+     * the site down (deleted the HTTPRoute, kept the Netlify site) and the
+     * reconciler **may** auto-restore it — routing-only, no rebuild — once the cap
+     * clears. `"user"` (or absent) means the user unpublished, so the reconciler
+     * must leave it down. The publish/unpublish hosting lock keeps this honest:
+     * whichever operation wins the lock is the one that writes `publishStatus`
+     * and this field, so they never disagree.
+     */
+    unpublishTrigger: z.enum(["system", "user"]).optional().meta({
+        description: "Who last unpublished the site. Absent === user. 'system' lets the reconciler auto-restore a usage-cap takedown; 'user' does not.",
+    }),
+    /**
+     * Why the system unpublished the site. Set iff `unpublishTrigger === "system"`;
+     * drives the projects-grid "suspended" card and takedown observability.
+     */
+    systemUnpublishReason: z
+        .enum(["bandwidth-cap", "web-request-cap"])
+        .optional(),
     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.",
     }),
@@ -411,6 +431,42 @@ export const HostingSlugSchema = z.object({
         description: "user ID of the user who first clicked Publish on the project",
     }),
 });
+/**
+ * Per-Neon-project charged-through watermarks inside a space's hosting usage
+ * snapshot. Storage folds root + child branch bytes-month into one field.
+ */
+export const HostingNeonProjectUsageSchema = z.object({
+    computeUnitSecondsChargedThrough: z.number(),
+    storageBytesMonthChargedThrough: z.number().meta({
+        description: "root + child branch bytes-month already billed",
+    }),
+    transferBytesChargedThrough: z.number().meta({
+        description: "public network transfer bytes already billed",
+    }),
+});
+/**
+ * Reconciler idempotency watermark for a space's Netlify + Neon hosting costs,
+ * stored at `hostingUsageSnapshots/{spaceId}`. Netlify is one account-level
+ * scalar; Neon is a per-project map. `freeDeployCount` gates the free 5/mo
+ * deploy cap (cost itself is inside Netlify's partner_account_usage total).
+ */
+export const HostingUsageSnapshotSchema = z.object({
+    ownerId: z.string(),
+    periodKey: z.string().meta({
+        description: "Builder billing cycle; resets the Neon watermarks",
+    }),
+    netlifyConsumptionCycleStart: z.string().meta({
+        description: "Netlify consumption_cycle_start_date; watermark resets when this advances",
+    }),
+    netlifyCreditsChargedThrough: z.number().meta({
+        description: "Netlify credits already billed this Netlify cycle",
+    }),
+    neonByProject: z.record(z.string(), HostingNeonProjectUsageSchema),
+    freeDeployCount: z.number().meta({
+        description: "Deploys this Builder cycle, for the free 5/mo cap",
+    }),
+    updatedAt: z.number(),
+});
 /**
  * Deploy lease lock with fencing token, stored at
  * `hosting-locks/{projectId}__{checkoutBranch}` (the key uses the resolved ref
@@ -625,9 +681,21 @@ export const HostingDomainStatusSchema = z.enum([
 ]);
 export const HostingDomainKindSchema = z.enum(["apex", "subdomain"]);
 /**
- * Custom domain record, stored at `hosting-domains/{domain}`.
+ * Custom domain record. The same shape backs two Firestore collections:
+ *
+ * - Lock doc `hosting-domains/{domain}` is the single exclusive owner. It
+ *   exists only once a project reaches `provisioning`/`active` (cert + route
+ *   created, DNS ownership proven) and is the cross-project serialization
+ *   point serving/deploy/unpublish read to answer "is this verified?".
+ *   `certId`/`certMapEntryName`/`httpRouteName`/`verifiedAt` are only ever
+ *   populated here.
+ * - Claim subdoc `hosting-domains/{domain}/claims/{projectId}` is a
+ *   non-exclusive, per-project verification attempt (`pending`/`verifying`/
+ *   `failed`). Multiple projects can hold a claim on the same domain at once;
+ *   whoever proves DNS ownership first wins the lock and the losers are swept
+ *   to `failed`.
+ *
  * 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
@@ -667,6 +735,12 @@ export const HostingDomainSchema = z.object({
     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.",
     }),
+    routeError: z.string().optional().meta({
+        description: "Non-fatal health signal on an otherwise verified (`provisioning`/`active`) domain: set when re-creating the Envoy HTTPRoute failed on republish, so the site's cert is valid but the custom domain has no live route (bare 404). `status` stays `active`; this drives a degraded banner + Fix action. Cleared once the route is recreated.",
+    }),
+    routeErrorAt: z.number().optional().meta({
+        description: "When `routeError` was last set.",
+    }),
     createdBy: z.string(),
 });
 export const AddDomainRequestSchema = z.object({
@@ -700,6 +774,14 @@ export const RemoveDomainRequestSchema = z.object({
 export const RemoveDomainResponseSchema = z.object({
     success: z.literal(true),
 });
+export const RepairDomainRequestSchema = z.object({
+    projectId: z.string(),
+    domain: z.string(),
+});
+export const RepairDomainResponseSchema = z.object({
+    status: HostingDomainStatusSchema,
+    routeError: z.string().optional(),
+});
 export const CloneProjectOptionsSchema = z.object({
     sourceProjectId: z.string().min(1).meta({
         description: "Project to clone from.",

package/src/perf-report.d.ts

@@ -1,116 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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),
-        })),
-    };
-}