@agent-native/core 0.85.6 → 0.86.0

package/corpus/templates/design/actions/connect-localhost.ts

@@ -3,7 +3,7 @@ import {
   getRequestOrgId,
   getRequestUserEmail,
 } from "@agent-native/core/server/request-context";
-import { and, eq } from "drizzle-orm";
+import { eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import { z } from "zod";
 
@@ -159,20 +159,26 @@ export default defineAction({
         status: "available" as const,
       }));
 
+    // The id may already be taken by a DIFFERENT user (legacy ids were derived
+    // from devServerUrl + rootPath without user scoping, so two users on the
+    // same devcontainer image collide). Detect that up front and fail with a
+    // clear error instead of crashing on the primary-key insert below.
     const existing = await db
       .select({
-        id: schema.designLocalhostConnections.id,
+        ownerEmail: schema.designLocalhostConnections.ownerEmail,
         bridgeToken: schema.designLocalhostConnections.bridgeToken,
       })
       .from(schema.designLocalhostConnections)
-      .where(
-        and(
-          eq(schema.designLocalhostConnections.id, id),
-          eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
-        ),
-      )
+      .where(eq(schema.designLocalhostConnections.id, id))
       .limit(1);
 
+    if (existing[0] && existing[0].ownerEmail !== ownerEmail) {
+      throw new Error(
+        `Connection id "${id}" already belongs to another user. ` +
+          "Omit id so a per-user connection id is derived instead.",
+      );
+    }
+
     const nextBridgeToken = args.bridgeToken?.trim() || undefined;
     const values = {
       id,
@@ -191,17 +197,18 @@ export default defineAction({
       updatedAt: now,
     };
 
-    if (existing[0]) {
-      await db
-        .update(schema.designLocalhostConnections)
-        .set(values)
-        .where(eq(schema.designLocalhostConnections.id, id));
-    } else {
-      await db.insert(schema.designLocalhostConnections).values({
-        ...values,
-        createdAt: now,
+    // Atomic upsert keyed on the id primary key — no check-then-insert race.
+    // setWhere keeps a concurrent insert by another user (TOCTOU on the
+    // ownership check above) from being overwritten: on a cross-user conflict
+    // the update filters to a no-op instead of hijacking the other row.
+    await db
+      .insert(schema.designLocalhostConnections)
+      .values({ ...values, createdAt: now })
+      .onConflictDoUpdate({
+        target: schema.designLocalhostConnections.id,
+        set: values,
+        setWhere: eq(schema.designLocalhostConnections.ownerEmail, ownerEmail),
       });
-    }
 
     return {
       id,

package/corpus/templates/design/actions/create-component.ts

@@ -50,6 +50,7 @@ import "../server/db/index.js"; // ensure registerShareableResource runs
 import { resolveSourceCapabilities } from "../shared/capability-resolver.js";
 import { buildCodeLayerProjection } from "../shared/code-layer.js";
 import type { CodeLayerNode, CodeLayerSource } from "../shared/code-layer.js";
+import { agentSelectionDescriptor } from "../shared/collab-selection.js";
 import {
   COMPONENT_NAME_ATTR,
   COMPONENT_PROP_PREFIX,
@@ -416,7 +417,10 @@ export default defineAction({
       });
 
       agentUpdateSelection(file.id, {
-        selection: node.selector,
+        selection: agentSelectionDescriptor(
+          { nodeId: node.id, selector: node.selector },
+          "Creating component",
+        ),
         nodeId: node.id,
         editingFile: file.filename,
         designId: file.designId,

package/corpus/templates/design/actions/create-fusion-app.ts

@@ -0,0 +1,202 @@
+/**
+ * create-fusion-app — start a brand-new full-app (fusion) design.
+ *
+ * Provisions a Builder Fusion branch (one branch per design) in the
+ * configured Builder branch project and hands the user's prompt to the
+ * Builder cloud agent to scaffold the app. The branch/container is not
+ * necessarily ready immediately — call `sync-fusion-app` to poll the
+ * container and pick up the preview URL once it boots.
+ *
+ * Gated behind `FULL_APP_BUILDING_ENABLED`. When Builder is not configured
+ * (no credentials or no branch project ID), returns the same graceful
+ * `{ status: "not-configured", cta, message }` shape as
+ * `migrate-inline-design-to-app` instead of throwing.
+ */
+
+import { defineAction } from "@agent-native/core";
+import {
+  runBuilderAgent,
+  resolveBuilderBranchProjectId,
+} from "@agent-native/core/server";
+import { getRequestUserEmail } from "@agent-native/core/server/request-context";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import "../server/db/index.js"; // ensure registerShareableResource runs
+import { resolveBuilderStatus } from "../shared/builder-app.js";
+import {
+  FULL_APP_BUILDING_ENABLED,
+  parseDesignDataBlob,
+  readFusionApp,
+  writeFusionApp,
+} from "../shared/full-app.js";
+
+const DEFAULT_BUILDER_APP_HOST = "https://builder.io";
+
+function resolveBuilderAppHost(): string {
+  return (
+    process.env.BUILDER_APP_HOST ||
+    process.env.BUILDER_PUBLIC_APP_HOST ||
+    DEFAULT_BUILDER_APP_HOST
+  );
+}
+
+function buildConnectUrl(origin: string): string {
+  const base = origin.replace(/\/+$/, "");
+  return `${base}/_agent-native/builder/connect`;
+}
+
+export default defineAction({
+  description:
+    "Create a brand-new full-app (fusion) design: provisions a Builder Fusion " +
+    "branch and hands the prompt to the Builder cloud agent to scaffold a real " +
+    "running app. Use this when the user wants a real app (not an HTML " +
+    "prototype) built from scratch for a design. Requires Builder.io to be " +
+    "connected with a branch project ID configured; when not configured " +
+    "returns a connect CTA — never throws. If the design already has a " +
+    "fusion app, returns the existing linkage instead of creating a second " +
+    "branch. The branch container may still be booting after this call — " +
+    "call sync-fusion-app to poll for the preview URL.",
+  schema: z.object({
+    designId: z.string().describe("Design project ID to back with a full app."),
+    prompt: z
+      .string()
+      .min(1)
+      .describe(
+        "What app to build, in the user's own words (features, pages, data model, etc.).",
+      ),
+    branchName: z
+      .string()
+      .optional()
+      .describe(
+        "Optional branch name for the Builder agent to use. If omitted, Builder generates one.",
+      ),
+  }),
+  run: async ({ designId, prompt, branchName }) => {
+    if (!FULL_APP_BUILDING_ENABLED) {
+      throw new Error("Full app building is not enabled");
+    }
+
+    const access = await assertAccess("design", designId, "editor");
+    const design = access.resource as typeof schema.designs.$inferSelect;
+
+    // Already app-backed: don't create a second branch.
+    const existingApp = readFusionApp(design.data);
+    if (existingApp) {
+      return {
+        status: existingApp.status,
+        designId,
+        projectId: existingApp.projectId,
+        branchName: existingApp.branchName,
+        editorUrl: existingApp.editorUrl,
+        message:
+          `This design is already backed by fusion branch ` +
+          `"${existingApp.branchName}". Call sync-fusion-app to check its ` +
+          `status, or send-fusion-message to continue building on it.`,
+      };
+    }
+
+    const builderStatus = await resolveBuilderStatus();
+    if (!builderStatus.connected || !builderStatus.builderEnabled) {
+      const connectUrl = buildConnectUrl(
+        process.env.APP_URL ??
+          process.env.VITE_APP_URL ??
+          process.env.BETTER_AUTH_URL ??
+          "",
+      );
+      const appHost = resolveBuilderAppHost();
+
+      if (!builderStatus.connected) {
+        return {
+          status: "not-configured" as const,
+          designId,
+          cta: {
+            kind: "connect-builder" as const,
+            label: "Build a real app",
+            description:
+              "Connect Builder.io to build this design as a real running app " +
+              "with a live container, branches, and deploys.",
+            primaryAction: "Connect Builder.io",
+            connectUrl,
+          },
+          message:
+            "Builder is not connected. Call connect-builder-app to start " +
+            "the OAuth flow, then retry create-fusion-app.",
+        };
+      }
+
+      return {
+        status: "not-configured" as const,
+        designId,
+        cta: {
+          kind: "configure-project" as const,
+          label: "Configure Builder project",
+          description:
+            "Builder credentials are present but no branch project ID is set. " +
+            "Set DISPATCH_BUILDER_PROJECT_ID, BUILDER_BRANCH_PROJECT_ID, or " +
+            "BUILDER_PROJECT_ID to enable full app building.",
+          primaryAction: "Open Builder settings",
+          connectUrl: `${appHost}/account-settings`,
+        },
+        message:
+          "Builder credentials are configured but no branch project ID is set. " +
+          "Set DISPATCH_BUILDER_PROJECT_ID to enable full app building.",
+      };
+    }
+
+    const projectId = await resolveBuilderBranchProjectId();
+    if (!projectId) {
+      throw new Error(
+        "Builder branch project ID is not configured. " +
+          "Set DISPATCH_BUILDER_PROJECT_ID, BUILDER_BRANCH_PROJECT_ID, or " +
+          "BUILDER_PROJECT_ID and try again.",
+      );
+    }
+
+    const ownerEmail = getRequestUserEmail();
+    const preamble =
+      `You are building a brand-new full application for the design project ` +
+      `"${design.title}". This is a fresh app — there is no existing code to ` +
+      `preserve beyond what you generate. Build exactly what the user asks for ` +
+      `below.\n\n## User request\n\n${prompt}`;
+
+    const result = await runBuilderAgent({
+      prompt: preamble,
+      projectId,
+      branchName: branchName?.trim() || undefined,
+      userEmail: ownerEmail ?? undefined,
+    });
+
+    const now = new Date().toISOString();
+    const db = getDb();
+    const nextData = writeFusionApp(parseDesignDataBlob(design.data), {
+      projectId: result.projectId,
+      branchName: result.branchName,
+      editorUrl: result.url,
+      status: "building",
+      statusMessage:
+        "App is being generated. Call sync-fusion-app to check progress.",
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await db
+      .update(schema.designs)
+      .set({ data: JSON.stringify(nextData), updatedAt: now })
+      .where(eq(schema.designs.id, designId));
+
+    return {
+      status: "building" as const,
+      designId,
+      projectId: result.projectId,
+      branchName: result.branchName,
+      editorUrl: result.url,
+      message:
+        `Started building "${design.title}" as a full app on branch ` +
+        `"${result.branchName}". Call sync-fusion-app to poll for the ` +
+        `preview URL once the container finishes booting.`,
+    };
+  },
+});

package/corpus/templates/design/actions/deploy-fusion-app.ts

@@ -0,0 +1,123 @@
+/**
+ * deploy-fusion-app — reserve a hosting slug (if needed) and trigger a hosted
+ * deploy of a fusion app's branch.
+ *
+ * On first deploy, derives a default `<slug>.builder.cloud` hosting slug from
+ * the design title unless the caller passes one explicitly. Reservation
+ * failures (slug already taken) surface clearly so the caller can retry with
+ * a different slug. Persists the reserved slug, deployed URL, and last deploy
+ * id/status on the fusion app linkage so get-fusion-deploy-status can poll
+ * without re-resolving them.
+ */
+
+import { defineAction } from "@agent-native/core";
+import {
+  deployFusionProject,
+  getFusionHostingUrl,
+  reserveFusionHostingSlug,
+} from "@agent-native/core/server";
+import { assertAccess } from "@agent-native/core/sharing";
+import { eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import "../server/db/index.js"; // ensure registerShareableResource runs
+import {
+  FULL_APP_BUILDING_ENABLED,
+  parseDesignDataBlob,
+  readFusionApp,
+  writeFusionApp,
+} from "../shared/full-app.js";
+
+const MAX_SLUG_LENGTH = 40;
+
+function defaultSlugFromTitle(title: string, designId: string): string {
+  const slug = title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, MAX_SLUG_LENGTH)
+    .replace(/-+$/g, "");
+  return slug || `app-${designId.slice(0, 8)}`;
+}
+
+export default defineAction({
+  description:
+    "Deploy a fusion (full-app) design to a public hosted URL. Reserves a " +
+    "<slug>.builder.cloud hosting slug (derived from the design title if not " +
+    "already reserved and no slug is given) and triggers a hosted deploy of " +
+    "the branch. If the slug is already taken, the error will say so — retry " +
+    "with a different slug. Poll get-fusion-deploy-status for progress " +
+    "(queued -> building -> uploading -> deploying -> live | failed).",
+  schema: z.object({
+    designId: z.string().describe("Design project ID backed by a fusion app."),
+    slug: z
+      .string()
+      .optional()
+      .describe(
+        "Hosting slug to reserve (results in <slug>.builder.cloud). Omit to " +
+          "use the design's already-reserved slug, or derive one from the title.",
+      ),
+  }),
+  run: async ({ designId, slug }) => {
+    if (!FULL_APP_BUILDING_ENABLED) {
+      throw new Error("Full app building is not enabled");
+    }
+
+    const access = await assertAccess("design", designId, "editor");
+    const design = access.resource as typeof schema.designs.$inferSelect;
+    const fusionApp = readFusionApp(design.data);
+    if (!fusionApp) {
+      throw new Error(
+        "This design has no fusion app linkage. Call create-fusion-app first.",
+      );
+    }
+
+    const requestedSlug =
+      slug?.trim() ||
+      fusionApp.hostingSlug ||
+      defaultSlugFromTitle(design.title, designId);
+
+    let reservedSlug: string;
+    try {
+      const reservation = await reserveFusionHostingSlug({
+        projectId: fusionApp.projectId,
+        slug: requestedSlug,
+      });
+      reservedSlug = reservation.slug;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Could not reserve hosting slug "${requestedSlug}": ${message}. ` +
+          "Pass a different slug and try again.",
+      );
+    }
+
+    const deploy = await deployFusionProject({
+      projectId: fusionApp.projectId,
+      checkoutBranch: fusionApp.branchName,
+    });
+
+    const deployedUrl = getFusionHostingUrl(reservedSlug);
+    const now = new Date().toISOString();
+    const db = getDb();
+    const nextData = writeFusionApp(parseDesignDataBlob(design.data), {
+      ...fusionApp,
+      hostingSlug: reservedSlug,
+      deployedUrl,
+      lastDeployId: deploy.deployId,
+      lastDeployStatus: deploy.status,
+      updatedAt: now,
+    });
+    await db
+      .update(schema.designs)
+      .set({ data: JSON.stringify(nextData), updatedAt: now })
+      .where(eq(schema.designs.id, designId));
+
+    return {
+      deployId: deploy.deployId,
+      status: deploy.status,
+      url: deployedUrl,
+    };
+  },
+});

package/corpus/templates/design/actions/edit-design.ts

@@ -290,23 +290,20 @@ export default defineAction({
     if (changed) {
       // Mark agent presence + selection so live viewers can see where the
       // agent is working before the update arrives via collab.
+      //
+      // No resolvable DOM selector is available here (search-replace targets
+      // source text, not a stamped node), so we publish `selection: null`
+      // rather than a fabricated `[data-edit-target=...]` selector that could
+      // never resolve against the rendered iframe. Region attribution instead
+      // rides on the `{ kind: "text", quote }` recentEdits descriptor that
+      // `applyText(..., "agent")` auto-publishes from the content diff below —
+      // clients render a lingering highlight over the changed text.
       agentEnterDocument(file.id);
-      if (resolvedMode === "search-replace" && applied > 0) {
-        const firstSearch = edits?.[0]?.search;
-        agentUpdateSelection(file.id, {
-          selection: firstSearch
-            ? `[data-edit-target="${firstSearch.slice(0, 40)}"]`
-            : null,
-          editingFile: file.filename,
-          designId,
-        });
-      } else {
-        agentUpdateSelection(file.id, {
-          selection: null,
-          editingFile: file.filename,
-          designId,
-        });
-      }
+      agentUpdateSelection(file.id, {
+        selection: null,
+        editingFile: file.filename,
+        designId,
+      });
 
       try {
         await db

package/corpus/templates/design/actions/export-pdf.ts

@@ -4,6 +4,7 @@ import { eq } from "drizzle-orm";
 import { z } from "zod";
 
 import { getDb, schema } from "../server/db/index.js";
+import { injectHiddenLayerExportStyle } from "../server/lib/design-export.js";
 import { isBoardFile } from "../shared/board-file.js";
 import "../server/db/index.js"; // ensure registerShareableResource runs
 
@@ -40,7 +41,13 @@ export default defineAction({
         id: f.id,
         filename: f.filename,
         fileType: f.fileType,
-        content: f.content,
+        // Layers toggled hidden in the editor are only suppressed by the live
+        // editor bridge; inject the same display:none rule so the client-side
+        // PDF render (html2canvas over this HTML) doesn't reveal them.
+        content:
+          f.fileType === "html" && f.content
+            ? injectHiddenLayerExportStyle(f.content)
+            : f.content,
       })),
       exportInfo: {
         format: "pdf",

package/corpus/templates/design/actions/export-zip.ts

@@ -6,6 +6,7 @@ import { z } from "zod";
 import { getDb, schema } from "../server/db/index.js";
 import {
   exportFilename,
+  injectHiddenLayerExportStyle,
   trySaveExportFile,
 } from "../server/lib/design-export.js";
 import { isBoardFile } from "../shared/board-file.js";
@@ -71,7 +72,15 @@ export default defineAction({
         file.filename,
         `design-file-${index + 1}.txt`,
       );
-      zip.file(filename, file.content ?? "");
+      // Layers toggled hidden in the editor are only suppressed by the live
+      // editor bridge; inject the same display:none rule into exported HTML
+      // files so opening them directly from the zip doesn't reveal layers
+      // the user hid in the editor.
+      const content =
+        file.fileType === "html"
+          ? injectHiddenLayerExportStyle(file.content ?? "")
+          : (file.content ?? "");
+      zip.file(filename, content);
     }
 
     // Add design data if present

package/corpus/templates/design/actions/get-fusion-deploy-status.ts

@@ -0,0 +1,86 @@
+/**
+ * get-fusion-deploy-status — read-only poll of a fusion app's last deploy.
+ *
+ * No DB writes: reads the persisted lastDeployId/deployedUrl off the fusion
+ * app linkage and asks Builder for the current deploy status.
+ */
+
+import { defineAction } from "@agent-native/core";
+import { getFusionDeploys } from "@agent-native/core/server";
+import { accessFilter } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import "../server/db/index.js"; // ensure registerShareableResource runs
+import {
+  FULL_APP_BUILDING_ENABLED,
+  readFusionApp,
+} from "../shared/full-app.js";
+
+function asString(value: unknown): string | undefined {
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+export default defineAction({
+  description:
+    "Read-only: check the status of a fusion (full-app) design's last hosted " +
+    "deploy (queued|building|migrating|uploading|deploying|live|failed|" +
+    "canceled). Call after deploy-fusion-app to poll for completion. Makes no " +
+    "database writes.",
+  schema: z.object({
+    designId: z.string().describe("Design project ID backed by a fusion app."),
+  }),
+  readOnly: true,
+  http: { method: "GET" },
+  run: async ({ designId }) => {
+    if (!FULL_APP_BUILDING_ENABLED) {
+      throw new Error("Full app building is not enabled");
+    }
+
+    const db = getDb();
+    const [design] = await db
+      .select({ data: schema.designs.data })
+      .from(schema.designs)
+      .where(
+        and(
+          accessFilter(schema.designs, schema.designShares),
+          eq(schema.designs.id, designId),
+        ),
+      )
+      .limit(1);
+    if (!design) {
+      const err = new Error("Design not found") as Error & {
+        statusCode: number;
+      };
+      err.statusCode = 404;
+      throw err;
+    }
+
+    const fusionApp = readFusionApp(design.data);
+    if (!fusionApp) {
+      throw new Error(
+        "This design has no fusion app linkage. Call create-fusion-app first.",
+      );
+    }
+    if (!fusionApp.lastDeployId) {
+      throw new Error(
+        "This fusion app has not been deployed yet. Call deploy-fusion-app first.",
+      );
+    }
+
+    const deploys = await getFusionDeploys({
+      projectId: fusionApp.projectId,
+      deployId: fusionApp.lastDeployId,
+    });
+    const deploy = deploys[0];
+    const status =
+      asString(deploy?.status) ?? fusionApp.lastDeployStatus ?? "unknown";
+
+    return {
+      deployId: fusionApp.lastDeployId,
+      status,
+      url: fusionApp.deployedUrl ?? null,
+    };
+  },
+});

package/corpus/templates/design/actions/get-motion-timeline.ts

@@ -1,5 +1,4 @@
 import { defineAction } from "@agent-native/core";
-import { getText, hasCollabState } from "@agent-native/core/collab";
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, desc, eq } from "drizzle-orm";
 import { z } from "zod";
@@ -10,6 +9,7 @@ import {
   extractManagedMotionCss,
   hashCss,
   parse,
+  parseFirstAnimationDurationMs,
 } from "../shared/motion-compiler.js";
 import type { MotionTrack } from "../shared/motion-timeline.js";
 
@@ -30,21 +30,6 @@ interface TimelineResult {
   updatedAt: string | null;
 }
 
-async function liveFileContent(
-  fileId: string,
-  storedContent: string,
-): Promise<string> {
-  try {
-    if (await hasCollabState(fileId)) {
-      const live = await getText(fileId, "content");
-      if (typeof live === "string") return live;
-    }
-  } catch {
-    // Best-effort; SQL is the fallback.
-  }
-  return storedContent;
-}
-
 function parseTrackJson(raw: string | null): MotionTrack[] {
   try {
     const parsed: unknown = JSON.parse(raw ?? "[]");
@@ -57,7 +42,12 @@ function parseTrackJson(raw: string | null): MotionTrack[] {
 async function readManagedCssForSource(args: {
   designId: string;
   sourceRef?: string;
-}): Promise<{ css: string; hash: string; tracks: MotionTrack[] } | null> {
+}): Promise<{
+  css: string;
+  hash: string;
+  tracks: MotionTrack[];
+  durationMs: number | null;
+} | null> {
   if (!args.sourceRef) return null;
 
   const db = getDb();
@@ -77,7 +67,13 @@ async function readManagedCssForSource(args: {
 
   if (!file) return null;
 
-  const content = await liveFileContent(file.id, file.content ?? "");
+  // Read the managed block from the SQL content, NOT a live collab snapshot:
+  // apply-motion-edit persists the managed <style> block to SQL only, so a
+  // live collab session's text lags the freshest motion CSS. Comparing the
+  // stored compiledHash against stale collab CSS would flag phantom
+  // "stored-css-drift" right after every save and replace fresh tracks with
+  // stale CSS-parsed ones. SQL is the motion block's source of truth.
+  const content = file.content ?? "";
   const css = extractManagedMotionCss(content);
   if (!css) return null;
 
@@ -88,7 +84,12 @@ async function readManagedCssForSource(args: {
   );
   if (tracks.length === 0) return null;
 
-  return { css, hash: hashCss(css), tracks };
+  return {
+    css,
+    hash: hashCss(css),
+    tracks,
+    durationMs: parseFirstAnimationDurationMs(css),
+  };
 }
 
 export default defineAction({
@@ -179,7 +180,9 @@ export default defineAction({
           sourceRef: sourceRef ?? null,
           filePath: null,
           tracks: managedCss.tracks,
-          durationMs: 1000,
+          // Recover the compiled animation-duration instead of inventing a
+          // default the next save would silently persist.
+          durationMs: managedCss.durationMs ?? 1000,
           defaultEase: "ease",
           compiledHash: managedCss.hash,
           cssHash: managedCss.hash,
@@ -191,6 +194,9 @@ export default defineAction({
         timelines[0] = {
           ...first,
           tracks: managedCss.tracks,
+          // In the drift case the CSS is the runtime truth — surface its
+          // compiled duration alongside its recovered tracks.
+          durationMs: managedCss.durationMs ?? first.durationMs,
           cssHash: managedCss.hash,
           source: "stored-css-drift",
         };