@agent-native/core 0.157.10 → 0.157.12

package/corpus/templates/analytics/server/lib/first-party-analytics-purge.ts

@@ -1,7 +1,4 @@
 import { getDbExec } from "@agent-native/core/db";
-import { and, eq, gte, isNull, ne, or } from "drizzle-orm";
-
-import { getDb, schema } from "../db/index.js";
 
 export interface FirstPartyAnalyticsPurgeScope {
   userEmail: string;
@@ -19,34 +16,6 @@ export interface FirstPartyAnalyticsPurgeWindow {
   startEventDate: string;
 }
 
-function scopePredicate(
-  table: {
-    orgId: any;
-    ownerEmail: any;
-  },
-  scope: FirstPartyAnalyticsPurgeScope,
-  includeLegacyOwnerRows: boolean,
-) {
-  if (!includeLegacyOwnerRows) return eq(table.orgId, scope.orgId);
-  return or(
-    eq(table.orgId, scope.orgId),
-    and(isNull(table.orgId), eq(table.ownerEmail, scope.userEmail)),
-  );
-}
-
-function windowPredicate(
-  table: {
-    eventDate: any;
-    receivedAt?: any;
-  },
-  predicate: any,
-  window: FirstPartyAnalyticsPurgeWindow,
-) {
-  return table.receivedAt
-    ? and(predicate, gte(table.receivedAt, window.startReceivedAt))
-    : and(predicate, gte(table.eventDate, window.startEventDate));
-}
-
 type CountTable =
   | "analytics_events"
   | "analytics_event_daily_rollups"
@@ -54,6 +23,40 @@ type CountTable =
 
 type CountTimeColumn = "received_at" | "event_date";
 
+const PURGE_BATCH_SIZE = 10_000;
+const PURGE_BATCH_TIMEOUT_MS = 60_000;
+const PURGE_COUNT_TIMEOUT_MS = 60_000;
+
+function purgeWhereSql(
+  table: CountTable,
+  scope: FirstPartyAnalyticsPurgeScope,
+  includeLegacyOwnerRows: boolean,
+  window: FirstPartyAnalyticsPurgeWindow,
+): { sql: string; args: unknown[]; timeColumn: CountTimeColumn } {
+  const scopeSql = includeLegacyOwnerRows
+    ? "(org_id = ? OR (org_id IS NULL AND owner_email = ?))"
+    : "org_id = ?";
+  const args: unknown[] = includeLegacyOwnerRows
+    ? [scope.orgId, scope.userEmail]
+    : [scope.orgId];
+  const timeColumn =
+    table === "analytics_events" ? "received_at" : "event_date";
+  args.push(
+    timeColumn === "received_at"
+      ? window.startReceivedAt
+      : window.startEventDate,
+  );
+  const eventFilter =
+    table === "analytics_events"
+      ? " AND event_name IS DISTINCT FROM 'http.response'"
+      : "";
+  return {
+    sql: `${scopeSql}${eventFilter} AND ${timeColumn} >= ?`,
+    args,
+    timeColumn,
+  };
+}
+
 async function countScopedRows(
   table: CountTable,
   timeColumn: CountTimeColumn,
@@ -84,7 +87,7 @@ async function countScopedRows(
              ${eventFilter}
              AND ${timeColumn} >= ?`,
     args,
-    timeoutMs: 5_000,
+    timeoutMs: PURGE_COUNT_TIMEOUT_MS,
     maxAttempts: 1,
   });
   const rawCount = (rows[0] as { row_count?: unknown } | undefined)?.row_count;
@@ -136,49 +139,34 @@ export async function purgeFirstPartyAnalyticsPostgresRows(
     includeLegacyOwnerRows,
     window,
   );
-  await (getDb() as any).transaction(async (tx: any) => {
-    await tx
-      .delete(schema.analyticsEvents)
-      .where(
-        and(
-          windowPredicate(
-            schema.analyticsEvents,
-            scopePredicate(
-              schema.analyticsEvents,
-              scope,
-              includeLegacyOwnerRows,
-            ),
-            window,
-          ),
-          ne(schema.analyticsEvents.eventName, "http.response"),
-        ),
-      );
-    await tx
-      .delete(schema.analyticsEventDailyRollups)
-      .where(
-        windowPredicate(
-          schema.analyticsEventDailyRollups,
-          scopePredicate(
-            schema.analyticsEventDailyRollups,
-            scope,
-            includeLegacyOwnerRows,
-          ),
-          window,
-        ),
-      );
-    await tx
-      .delete(schema.analyticsUserDays)
-      .where(
-        windowPredicate(
-          schema.analyticsUserDays,
-          scopePredicate(
-            schema.analyticsUserDays,
-            scope,
-            includeLegacyOwnerRows,
-          ),
-          window,
-        ),
-      );
-  });
+
+  for (const table of [
+    "analytics_events",
+    "analytics_event_daily_rollups",
+    "analytics_user_days",
+  ] as const) {
+    const {
+      sql: whereSql,
+      args,
+      timeColumn,
+    } = purgeWhereSql(table, scope, includeLegacyOwnerRows, window);
+    while (true) {
+      const result = await getDbExec().execute({
+        sql: `WITH candidates AS (
+          SELECT id
+          FROM ${table}
+          WHERE ${whereSql}
+          ORDER BY ${timeColumn}, id
+          LIMIT ?
+        )
+        DELETE FROM ${table}
+        WHERE id IN (SELECT id FROM candidates)`,
+        args: [...args, PURGE_BATCH_SIZE],
+        timeoutMs: PURGE_BATCH_TIMEOUT_MS,
+        maxAttempts: 1,
+      });
+      if (Number(result.rowsAffected ?? 0) < PURGE_BATCH_SIZE) break;
+    }
+  }
   return counts;
 }

package/corpus/templates/slides/actions/export-pptx.ts

@@ -194,6 +194,29 @@ interface ParsedCssBorder {
   color: string;
 }
 
+/**
+ * PowerPoint's `a:spcPct val="100000"` is 100% of the font's *natural* line
+ * height, which CSS renders as `line-height: 1.2`, so the importer multiplies a
+ * declared percentage by that ratio. Writing the CSS value back out as `lnSpc`
+ * unchanged applied that correction a second time, and every imported paragraph
+ * came back 20% looser than the source. Neither copy of the constant is
+ * exported — `SINGLE_LINE_SPACING_RATIO` in packages/core/src/ingestion/pptx.ts
+ * and `DEFAULT_LINE_SPACING` in server/handlers/import/html-converter.ts — so
+ * all three have to move together.
+ */
+const SINGLE_LINE_SPACING_RATIO = 1.2;
+
+/** A CSS line-height ratio as the single-spacing multiple `lnSpc` measures. */
+function cssLineHeightToSpacingMultiple(
+  lineHeight: number | undefined,
+): number | undefined {
+  return lineHeight !== undefined &&
+    Number.isFinite(lineHeight) &&
+    lineHeight > 0
+    ? lineHeight / SINGLE_LINE_SPACING_RATIO
+    : undefined;
+}
+
 /** Parse a CSS `border` shorthand. `none`/`hidden` borders yield `undefined`. */
 function parseCssBorder(
   border: string | null | undefined,
@@ -320,6 +343,8 @@ interface ShapeElement {
   lineTransparency?: number; // 0-100, percent transparent
   lineWidth?: number; // in pt
   lineDashType?: NonNullable<PptxGenJS.ShapeLineProps["dashType"]>;
+  lineHeadType?: NonNullable<PptxGenJS.ShapeLineProps["beginArrowType"]>;
+  lineTailType?: NonNullable<PptxGenJS.ShapeLineProps["endArrowType"]>;
   /** A PowerPoint preset geometry name, or `custGeom` when `points` carry a traced outline. */
   shapeType?: string;
   rectRadius?: number; // inches; roundRect corner radius
@@ -591,6 +616,8 @@ export function parseSlideHtml(
         w: contentW,
         h: elHeight + 0.2,
         letterSpacing: letterSpacing ? parseFloat(letterSpacing) : undefined,
+        // Editor-authored HTML already uses the multiple pptxgenjs expects;
+        // the importer-only correction belongs in parseImportedSlideHtml.
         lineSpacingMultiple: lineH,
       });
 
@@ -748,6 +775,7 @@ function parseImportedSlideHtml(html: string, dims: SlideDims): ParsedSlide {
       const border = parseCssBorder(getStyle(style, "border"));
       const parsedLine = border ? colorToHex(border.color) : undefined;
       const outline = importedFreeformStroke(innerHtml, dims);
+      const line = importedLineStroke(style, innerHtml, dims);
       shapes.push({
         ...geometry,
         ...(parsedFill
@@ -770,6 +798,9 @@ function parseImportedSlideHtml(html: string, dims: SlideDims): ParsedSlide {
               }
             : {}),
         ...importedShapeGeometry(attrs, style, outline?.path, geometry, dims),
+        // A single-edge border is the importer's own verdict that this box is a
+        // line rather than an outline, so it settles the geometry too.
+        ...line,
         ...(rotate != null ? { rotate } : {}),
         order: match.index,
       });
@@ -818,7 +849,9 @@ function parseImportedSlideHtml(html: string, dims: SlideDims): ParsedSlide {
       bold: runs.length > 0 && runs.every((run) => run.options.bold === true),
       align:
         alignValue === "center" || alignValue === "right" ? alignValue : "left",
-      lineSpacingMultiple: lineHeight ? Number(lineHeight) : undefined,
+      lineSpacingMultiple: cssLineHeightToSpacingMultiple(
+        lineHeight ? Number(lineHeight) : undefined,
+      ),
       x: geometry.x,
       y: geometry.y,
       w: geometry.w,
@@ -998,6 +1031,93 @@ function importedFreeformStroke(
   };
 }
 
+/** The line axis each single-edge border the importer writes draws along. */
+const SINGLE_EDGE_BORDER_AXES = {
+  "border-top": "x",
+  "border-left": "y",
+} as const;
+
+/**
+ * The stroke of a `<p:cxnSp>` or a degenerate `<p:sp>` — a box with one
+ * dimension of zero. The importer draws those with a single `border-left` or
+ * `border-top` rather than the `border` shorthand (`strokeDecoration` in
+ * server/handlers/import/html-converter.ts), which `parseCssBorder` above
+ * cannot see, so every connector used to export as a `rect` of `cx="0"` with
+ * `<a:noFill/>` and an empty `<a:ln/>`: no width, no color, no ends, nothing
+ * drawn. Reading the edge the importer actually wrote gives back the real line.
+ */
+function importedLineStroke(
+  style: string,
+  innerHtml: string,
+  dims: SlideDims,
+):
+  | (Pick<
+      ShapeElement,
+      | "shapeType"
+      | "lineColor"
+      | "lineTransparency"
+      | "lineWidth"
+      | "lineDashType"
+      | "lineHeadType"
+      | "lineTailType"
+    > &
+      Partial<Pick<ShapeElement, "w" | "h">>)
+  | undefined {
+  for (const [property, axis] of Object.entries(SINGLE_EDGE_BORDER_AXES)) {
+    const border = parseCssBorder(getStyle(style, property));
+    if (!border) continue;
+    const color = colorToHex(border.color);
+    return {
+      shapeType: "line",
+      // A single-edge border is a line in the element's local coordinate
+      // system. Keep its perpendicular dimension collapsed after the box
+      // geometry has been parsed, or a thin rule becomes a diagonal line.
+      ...(axis === "x" ? { h: 0 } : { w: 0 }),
+      lineColor: color.hex,
+      lineTransparency: color.transparency,
+      // The same 0.5pt floor the outline paths use, for the same reason:
+      // `pxToPt` rounds, and a hairline that rounds to 0pt draws nothing.
+      lineWidth: Math.max(0.5, pxToPt(border.widthPx, dims)),
+      ...(border.dashType ? { lineDashType: border.dashType } : {}),
+      ...importedLineEndTypes(innerHtml, axis),
+    };
+  }
+  return undefined;
+}
+
+/**
+ * The `<a:headEnd>`/`<a:tailEnd>` the importer redraws as absolutely
+ * positioned `<circle>` overlays (`lineEndCaps` in html-converter.ts). It only
+ * ever reproduces `oval`, and it centers the overlay on the line, so a circle
+ * before the viewBox midpoint caps the head and one after it caps the tail —
+ * still true for a flipped source, because the importer swapped the two before
+ * drawing them.
+ */
+function importedLineEndTypes(
+  innerHtml: string,
+  axis: "x" | "y",
+): Pick<ShapeElement, "lineHeadType" | "lineTailType"> {
+  const svg = innerHtml.match(/<svg\b([^>]*)>([\s\S]*?)<\/svg>/i);
+  const viewBox = getAttribute(svg?.[1] ?? "", "viewBox")
+    ?.trim()
+    .split(/[\s,]+/)
+    .map(Number);
+  if (!svg || viewBox?.length !== 4 || !viewBox.every(Number.isFinite)) {
+    return {};
+  }
+  const middle = (axis === "x" ? viewBox[2] : viewBox[3]) / 2;
+  const ends: Pick<ShapeElement, "lineHeadType" | "lineTailType"> = {};
+  for (const circle of svg[2].matchAll(/<circle\b([^>]*)>/gi)) {
+    const alongAttribute = getAttribute(circle[1], axis === "x" ? "cx" : "cy");
+    if (alongAttribute == null) continue;
+    const along = Number(alongAttribute);
+    if (!Number.isFinite(along)) continue;
+    if (along < middle) ends.lineHeadType = "oval";
+    else ends.lineTailType = "oval";
+  }
+  return ends;
+}
+
 type CustomGeometryPoint = NonNullable<ShapeElement["points"]>[number];
 
 /** Numbers each SVG path command consumes. The importer emits only these. */
@@ -2021,6 +2141,12 @@ export default defineAction({
                       ...(shape.lineDashType
                         ? { dashType: shape.lineDashType }
                         : {}),
+                      ...(shape.lineHeadType
+                        ? { beginArrowType: shape.lineHeadType }
+                        : {}),
+                      ...(shape.lineTailType
+                        ? { endArrowType: shape.lineTailType }
+                        : {}),
                       ...(shape.lineTransparency != null
                         ? { transparency: shape.lineTransparency }
                         : {}),

package/corpus/templates/slides/server/routes/api/exports/google-slides.post.ts

@@ -14,10 +14,18 @@ const UPLOAD_URL =
   "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart&fields=id,webViewLink";
 
 /**
- * Uploads a browser-generated PPTX into the user's Drive, letting Drive convert
- * it to a native Google Slides deck. The PPTX comes from the client because the
- * browser export renders the real slide DOM — the server-side pptxgenjs export
- * is a lower-fidelity fallback and would ship a visibly worse deck to Google.
+ * Uploads a PPTX into the user's Drive, letting Drive convert it to a native
+ * Google Slides deck. The caller decides which exporter produced those bytes,
+ * and which one is higher fidelity depends on the deck:
+ *
+ * - Source-imported decks go through the server `export-pptx`, which writes the
+ *   source's own geometry as real vector shapes. The browser exporter cannot —
+ *   `dom-to-pptx` has no custom-geometry support at all and rasterizes every
+ *   vector shape to a bitmap, so Google receives silhouettes instead of curves.
+ * - Editor-authored decks go through the browser exporter, the only place
+ *   geometry positioned in the DOM is measurable.
+ *
+ * See "Export Behavior" in `templates/slides/AGENTS.md` for the routing rule.
  */
 export default defineEventHandler(async (event) => {
   const session = await getSession(event).catch(() => null);

package/dist/collab/struct-routes.d.ts

@@ -13,8 +13,8 @@
  * Body: { json: any, fieldName?: string, type?: "map"|"array", requestSource?: string }
  */
 export declare const postCollabJson: import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/dist/db/client.js

@@ -763,6 +763,7 @@ export async function withDbTimeout(op, run, ms = dbOpTimeoutMs(), onTimeout) {
  */
 export function isServerlessRuntime() {
     return (!!process.env.NETLIFY ||
+        !!process.env.NETLIFY_FUNCTION_NAME ||
         !!process.env.VERCEL ||
         !!process.env.AWS_LAMBDA_FUNCTION_NAME ||
         !!process.env.LAMBDA_TASK_ROOT ||

package/dist/file-upload/actions/upload-image.d.ts

@@ -17,11 +17,11 @@ declare const _default: import("../../action.js").ActionDefinition<{
     id?: undefined;
     provider?: undefined;
 } | {
-    error?: undefined;
     configured?: undefined;
     connectPath?: undefined;
     url: string;
     id: string;
     provider: string;
+    error?: undefined;
 }>;
 export default _default;

package/dist/integrations/plugin.js

@@ -708,12 +708,15 @@ export function createIntegrationsPlugin(options) {
             // sees the request. Keep the device secret in a dedicated TLS-only
             // header as a transport fallback; the value is still hashed and looked
             // up by authenticateRemoteDeviceToken, never persisted raw.
-            const token = extractBearerToken(getRequestHeader(event, "authorization")) ??
-                (getRequestHeader(event, "x-agent-native-device-token")?.trim() ||
-                    null);
-            const device = await authenticateRemoteDeviceToken(token);
-            if (device)
-                return device;
+            const candidates = [
+                getRequestHeader(event, "x-agent-native-device-token")?.trim() || null,
+                extractBearerToken(getRequestHeader(event, "authorization")),
+            ].filter((token, index, all) => Boolean(token) && all.indexOf(token) === index);
+            for (const token of candidates) {
+                const device = await authenticateRemoteDeviceToken(token);
+                if (device)
+                    return device;
+            }
             setResponseStatus(event, 401);
             return null;
         }

package/dist/mcp/screen-memory-stdio.d.ts

@@ -137,13 +137,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -159,6 +159,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -174,7 +175,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -190,6 +190,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
     inputSchema: {
         type: string;
         properties: {
+            count?: undefined;
             minutes: {
                 type: string;
                 description: string;
@@ -199,7 +200,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -216,6 +216,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query: {
                 type: string;
                 description: string;
@@ -234,7 +235,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
             };
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;
@@ -250,6 +250,7 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
@@ -263,7 +264,6 @@ export declare function screenMemoryMcpToolDefinitions(): ({
                 description: string;
             };
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             includeMicrophone?: undefined;
@@ -314,13 +314,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt: {
                 type: string;
                 description: string;
@@ -349,13 +349,13 @@ export declare function screenMemoryMcpToolDefinitions(): ({
         type: string;
         required: string[];
         properties: {
+            count?: undefined;
             query?: undefined;
             minutes?: undefined;
             limit?: undefined;
             clientHint?: undefined;
             timestamp?: undefined;
             chapterId?: undefined;
-            count?: undefined;
             startAt?: undefined;
             endAt?: undefined;
             reason?: undefined;

package/dist/notifications/routes.d.ts

@@ -16,18 +16,18 @@ export declare function createNotificationsHandler(): import("h3").EventHandlerW
     error?: undefined;
     ok?: undefined;
 } | {
+    count?: undefined;
     updated: number;
     error?: undefined;
     ok?: undefined;
-    count?: undefined;
 } | {
+    count?: undefined;
     updated?: undefined;
     error: string;
     ok?: undefined;
-    count?: undefined;
 } | {
+    count?: undefined;
     updated?: undefined;
     error?: undefined;
     ok: boolean;
-    count?: undefined;
 }>>;

package/dist/observability/routes.d.ts

@@ -42,22 +42,22 @@ export declare function createObservabilityHandler(): import("h3").EventHandlerW
     avgEvalScore: number;
 } | {
     error?: undefined;
-    ok?: undefined;
     summary: import("./types.js").TraceSummary;
     spans: import("./types.js").TraceSpan[];
     id?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
-    ok?: undefined;
     summary?: undefined;
     spans?: undefined;
     id: string;
-} | {
     ok?: undefined;
+} | {
     summary?: undefined;
     spans?: undefined;
     id?: undefined;
     error: any;
+    ok?: undefined;
 } | {
     error?: undefined;
     summary?: undefined;

package/dist/secrets/routes.d.ts

@@ -34,16 +34,16 @@ export declare function createListSecretsHandler(): import("h3").EventHandlerWit
 /** POST /_agent-native/secrets/:key — write a secret. */
 export declare function createWriteSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: string;
-    ok?: undefined;
     status?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;
     status: string;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;
@@ -54,9 +54,9 @@ export declare function createWriteSecretHandler(): import("h3").EventHandlerWit
  * or the current stored value without changing anything.
  */
 export declare function createTestSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
-    ok?: undefined;
     error: string;
     note?: undefined;
+    ok?: undefined;
 } | {
     error?: undefined;
     ok: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.157.10",
+  "version": "0.157.12",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {