@agent-native/core 0.157.10 → 0.157.11

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,88 @@ 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"
+    >
+  | 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",
+      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 +2136,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/awareness.d.ts

@@ -62,11 +62,11 @@ export declare const postAwareness: import("h3").EventHandlerWithFetch<import("h
     error: string;
     states?: undefined;
 } | {
-    error?: undefined;
     states: {
         clientId: number;
         state: string;
     }[];
+    error?: undefined;
 }>>;
 /**
  * GET /_agent-native/collab/:docId/users
@@ -77,9 +77,9 @@ export declare const getActiveUsers: import("h3").EventHandlerWithFetch<import("
     error: string;
     users?: undefined;
 } | {
-    error?: undefined;
     users: {
         clientId: number;
         lastSeen: number;
     }[];
+    error?: undefined;
 }>>;

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/observability/routes.d.ts

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

package/dist/secrets/routes.d.ts

@@ -34,37 +34,37 @@ 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;
+    error?: undefined;
 } | {
-    ok?: undefined;
     error: string;
     removed?: undefined;
+    ok?: undefined;
 } | {
-    error?: undefined;
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;
 /**
  * POST /_agent-native/secrets/:key/test — validate an optional candidate value
  * 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;
     note?: undefined;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     note: string;
+    error?: undefined;
 } | {
     note?: undefined;
     ok: boolean;
@@ -95,11 +95,11 @@ export interface AdHocSecretPayload {
 export declare function createAdHocSecretHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<AdHocSecretPayload[] | {
     error: string;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
-} | {
     error?: undefined;
+} | {
     ok: boolean;
     removed: boolean;
+    error?: undefined;
 }>>;

package/dist/server/agent-engine-api-key-route.d.ts

@@ -27,10 +27,10 @@ export declare function resolveAgentEngineApiKeyWriteTarget(event: H3Event, scop
 export declare function createAgentEngineApiKeyHandler(): import("h3").EventHandlerWithFetch<import("h3").EventHandlerRequest, Promise<{
     error: any;
 } | {
-    error?: undefined;
     ok: boolean;
     key: string;
     baseUrlKey?: string;
     scope: AgentEngineApiKeyScope;
+    error?: undefined;
 }>>;
 export {};

package/dist/server/transcribe-voice.d.ts

@@ -20,6 +20,6 @@ export declare function createTranscribeVoiceHandler(): import("h3").EventHandle
     error: string;
     text?: undefined;
 } | {
-    text: string;
     error?: undefined;
+    text: string;
 }>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.157.10",
+  "version": "0.157.11",
   "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": {