@agent-native/core 0.141.7 → 0.144.1

package/dist/db/ddl-guard.js

@@ -33,9 +33,9 @@ const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
 /**
  * True when running against Postgres AND the given table already exists in the
  * `public` schema. Returns `false` on SQLite (callers gate their own behaviour
- * there), for invalid identifiers, or when `information_schema` is unreadable —
- * the conservative answer "not known to exist" makes the caller fall through to
- * its idempotent `CREATE TABLE IF NOT EXISTS`, preserving today's behaviour.
+ * there), for invalid identifiers, and `undefined` when `information_schema`
+ * is unreadable. Unknown must stay distinct from absent: treating a timed-out
+ * probe as missing starts a DDL lock storm on a busy serverless database.
  *
  * This is a plain read (no lock), so it never blocks on an `ACCESS EXCLUSIVE`
  * lock the way `CREATE`/`ALTER` would.
@@ -57,15 +57,17 @@ export async function pgTableExists(table, injectedClient, dialectIsPostgres) {
         return rows.length > 0;
     }
     catch {
-        // information_schema unreadable (permissions / non-standard backend) —
-        // report "unknown" so the caller falls back to IF NOT EXISTS.
-        return false;
+        // coercion-ok: undefined is a typed unreadable state; callers throw rather
+        // than issuing DDL against an unverified schema.
+        // A failed probe is not evidence that the table is absent. Let the caller
+        // fail loudly rather than issuing DDL against a database it cannot read.
+        return undefined;
     }
 }
 /**
  * True when running against Postgres AND the given column already exists on the
  * given table in the `public` schema. Returns `false` on SQLite, for invalid
- * identifiers, or when `information_schema` is unreadable.
+ * identifiers, and `undefined` when `information_schema` is unreadable.
  *
  * Plain read — no lock taken.
  */
@@ -86,13 +88,15 @@ export async function pgColumnExists(table, column, injectedClient) {
         return rows.length > 0;
     }
     catch {
-        return false;
+        // coercion-ok: undefined distinguishes an unreadable schema probe from an
+        // absent column, and ensureSchemaObject fails closed on it.
+        return undefined;
     }
 }
 /**
  * True when running against Postgres AND an index with the given name already
  * exists in the `public` schema. Returns `false` on SQLite, for invalid
- * identifiers, or when `pg_indexes` is unreadable.
+ * identifiers, and `undefined` when `pg_indexes` is unreadable.
  *
  * `CREATE INDEX` (without CONCURRENTLY) takes a `SHARE` lock that blocks
  * writes, so on a fresh background-worker process behind a concurrent
@@ -114,7 +118,9 @@ export async function pgIndexExists(indexName, injectedClient, dialectIsPostgres
         return rows.length > 0;
     }
     catch {
-        return false;
+        // coercion-ok: undefined distinguishes an unreadable schema probe from an
+        // absent index, and ensureSchemaObject fails closed on it.
+        return undefined;
     }
 }
 /**
@@ -145,8 +151,12 @@ export async function pgIndexExists(indexName, injectedClient, dialectIsPostgres
  */
 export async function ensureSchemaObject(options) {
     const { probe, ddl, label, lockTimeout, injectedClient, dialectIsPostgres } = options;
-    if (await probe())
+    const initiallyExists = await probe();
+    if (initiallyExists === true)
         return false;
+    if (initiallyExists === undefined) {
+        throw new Error(`ensureSchemaObject: could not probe required schema "${label}"; refusing to issue DDL`);
+    }
     const ran = await runGuardedDdl(ddl, {
         lockTimeout,
         injectedClient,
@@ -157,8 +167,12 @@ export async function ensureSchemaObject(options) {
     // The DDL was swallowed by a lock-timeout. The object is virtually always
     // already correct by the time a contended boot retries (a concurrent
     // connection created it), so re-probe before giving up.
-    if (await probe())
+    const existsAfterTimeout = await probe();
+    if (existsAfterTimeout === true)
         return true;
+    if (existsAfterTimeout === undefined) {
+        throw new Error(`ensureSchemaObject: could not re-probe required schema "${label}" after a lock-timed-out DDL`);
+    }
     // Still missing after a swallowed timeout: do NOT memoize success with absent
     // schema. Throw so the caller's init promise rejects and the next call
     // retries, rather than leaving ensureTable "initialized" against a table/
@@ -243,12 +257,26 @@ export async function runGuardedDdl(ddl, options = {}) {
         return true;
     }
     const lockTimeout = options.lockTimeout ?? "3s";
+    // Comfortably longer than any DDL this guard runs (it only ever executes
+    // statements already probed as necessary), so it can only fire on a
+    // transaction nobody is driving any more.
+    const idleInTransactionTimeout = options.idleInTransactionTimeout ?? "30s";
     try {
         if (typeof client.transaction === "function") {
             await client.transaction(async (tx) => {
                 // SET LOCAL is transaction-scoped: it reverts on COMMIT/ROLLBACK and
                 // never persists on the pooled connection.
                 await tx.execute(`SET LOCAL lock_timeout = '${lockTimeout}'`);
+                // A serverless worker that is killed mid-transaction — OOM, function
+                // wall, cold-start reap — never reaches COMMIT or ROLLBACK, and the
+                // pooled connection goes back to the pool still inside this
+                // transaction, holding its locks until something reaps it. Nothing
+                // does. Measured in production: 11 sessions stuck `idle in
+                // transaction` for up to 283s, every one of them last executing the
+                // SET LOCAL above, while ordinary queries on that database went from
+                // ~1.5s to 5-7s. Postgres reaps these itself when told to, and the
+                // timeout is the only part of this that survives the process dying.
+                await tx.execute(`SET LOCAL idle_in_transaction_session_timeout = '${idleInTransactionTimeout}'`);
                 await tx.execute(ddl);
             });
         }

package/dist/deploy/build.d.ts

@@ -74,6 +74,8 @@ export { copyDir };
 export declare function isServerlessNativePlatformPackage(packageName: string): boolean;
 type ServerlessFfmpegStaticArch = "arm64" | "x64";
 export declare function shouldBundleFfmpegStaticForServerless(hostPlatform?: NodeJS.Platform, hostArch?: NodeJS.Architecture, targetArch?: ServerlessFfmpegStaticArch | null): boolean;
+export declare function findInstalledPackageRoot(packageName: string, nodeModulesRoots: string[], fromPackageDir?: string): string | null;
+export declare function copyInstalledBrowserRuntimePackages(serverDir: string | undefined, projectCwd?: string): number;
 export declare function findInstalledFfmpegStaticPackage(nodeModulesRoots: string[]): string | null;
 export declare function findInstalledResvgPackages(nodeModulesRoots: string[]): Array<{
     packageName: string;

package/dist/deploy/build.js

@@ -1920,6 +1920,10 @@ const LIBSQL_NATIVE_PACKAGE_NAMES = [
 const FFMPEG_STATIC_PACKAGE_NAME = "ffmpeg-static";
 const RESVG_SCOPE = "@resvg";
 const RESVG_PACKAGE_PREFIX = "resvg-js";
+const SERVERLESS_BROWSER_RUNTIME_PACKAGES = [
+    "@sparticuz/chromium",
+    "playwright-core",
+];
 // Serverless functions only ever run on 64-bit Linux. The darwin/win32/android
 // and 32-bit-arm prebuilds of these native packages are ~100MB that can never
 // execute there, and Netlify copies the whole server dir again for every extra
@@ -1978,6 +1982,98 @@ function nodeModulesAncestors(startDir) {
     }
     return dirs;
 }
+function readPackageManifest(packageDir) {
+    const packageJsonPath = path.join(packageDir, "package.json");
+    if (!fs.existsSync(packageJsonPath))
+        return null;
+    const manifest = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+        return null;
+    }
+    return manifest;
+}
+function packageRootFromResolvedPath(packageName, resolvedPath) {
+    let current = path.dirname(resolvedPath);
+    while (true) {
+        const manifest = readPackageManifest(current);
+        if (manifest?.name === packageName)
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export function findInstalledPackageRoot(packageName, nodeModulesRoots, fromPackageDir) {
+    if (fromPackageDir) {
+        try {
+            const requireFromPackage = createRequire(path.join(fromPackageDir, "package.json"));
+            const resolvedPath = requireFromPackage.resolve(packageName);
+            const resolvedRoot = packageRootFromResolvedPath(packageName, resolvedPath);
+            if (resolvedRoot)
+                return resolvedRoot;
+            // coercion-ok: resolution failure means this optional store lookup is absent.
+        }
+        catch {
+            // The dependency may be available only through the workspace pnpm store.
+        }
+    }
+    const packagePath = packageName.split("/");
+    const pnpmPrefix = `${packageName.replace("/", "+")}@`;
+    for (const root of nodeModulesRoots) {
+        const direct = path.join(root, ...packagePath);
+        if (readPackageManifest(direct)?.name === packageName)
+            return direct;
+        const pnpmRoot = path.join(root, ".pnpm");
+        if (!fs.existsSync(pnpmRoot))
+            continue;
+        for (const entry of fs.readdirSync(pnpmRoot)) {
+            if (!entry.startsWith(pnpmPrefix))
+                continue;
+            const nested = path.join(pnpmRoot, entry, "node_modules", ...packagePath);
+            if (readPackageManifest(nested)?.name === packageName)
+                return nested;
+        }
+    }
+    return null;
+}
+function copyRuntimePackageTree(packageName, packageDir, serverDir, nodeModulesRoots, copiedPackages) {
+    if (copiedPackages.has(packageName))
+        return 0;
+    copiedPackages.add(packageName);
+    const destination = path.join(serverDir, "node_modules", ...packageName.split("/"));
+    copyDir(packageDir, destination);
+    const manifest = readPackageManifest(packageDir);
+    const dependencies = manifest?.dependencies;
+    if (!dependencies || typeof dependencies !== "object")
+        return 1;
+    let copiedCount = 1;
+    for (const dependencyName of Object.keys(dependencies)) {
+        const dependencyDir = findInstalledPackageRoot(dependencyName, nodeModulesRoots, packageDir);
+        if (!dependencyDir) {
+            throw new Error(`[deploy] Could not resolve ${dependencyName}, required by ${packageName}, for the serverless browser runtime.`);
+        }
+        copiedCount += copyRuntimePackageTree(dependencyName, dependencyDir, serverDir, nodeModulesRoots, copiedPackages);
+    }
+    return copiedCount;
+}
+export function copyInstalledBrowserRuntimePackages(serverDir, projectCwd = cwd) {
+    if (!serverDir || !fs.existsSync(serverDir))
+        return 0;
+    const nodeModulesRoots = nodeModulesAncestors(projectCwd);
+    const copiedPackages = new Set();
+    let copiedCount = 0;
+    for (const packageName of SERVERLESS_BROWSER_RUNTIME_PACKAGES) {
+        const packageDir = findInstalledPackageRoot(packageName, nodeModulesRoots);
+        if (!packageDir)
+            continue;
+        copiedCount += copyRuntimePackageTree(packageName, packageDir, serverDir, nodeModulesRoots, copiedPackages);
+    }
+    if (copiedCount > 0) {
+        console.log(`[deploy] Copied ${copiedCount} serverless browser runtime package(s) into the server bundle.`);
+    }
+    return copiedCount;
+}
 function findInstalledLibsqlNativePackage(nodeModulesRoots, packageName) {
     for (const root of nodeModulesRoots) {
         const direct = path.join(root, "@libsql", packageName);
@@ -2135,8 +2231,6 @@ const BACKGROUND_WARM_PATH = ${backgroundWarmPath};
 const REQUEST_TIMEOUT_MS = 25_000;
 
 function siteOrigin(request) {
-  const configured = process.env.URL || process.env.DEPLOY_URL;
-  if (configured) return configured;
   return new URL(request.url).origin;
 }
 
@@ -2228,8 +2322,6 @@ const PROCESSOR_ROUTE = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_ROUTE)};
 const PROCESSOR_ROUTE_FIELD = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD)};
 
 function siteOrigin(request) {
-  const configured = process.env.URL || process.env.DEPLOY_URL;
-  if (configured) return configured;
   return new URL(request.url).origin;
 }
 
@@ -3436,6 +3528,7 @@ export default bundle;
         copyInstalledLibsqlNativePackages(nitro.options.output.serverDir);
         copyInstalledResvgPackages(nitro.options.output.serverDir);
         copyInstalledFfmpegStaticPackage(nitro.options.output.serverDir);
+        copyInstalledBrowserRuntimePackages(nitro.options.output.serverDir);
         sanitizeServerlessFunctionPackageManifest(nitro.options.output.serverDir);
         bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
     }

package/dist/deploy/workspace-deploy.js

@@ -501,8 +501,6 @@ const PROCESSOR_ROUTE = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_ROUTE)};
 const PROCESSOR_ROUTE_FIELD = ${JSON.stringify(AGENT_BACKGROUND_PROCESSOR_ROUTE_FIELD)};
 
 function siteOrigin(request) {
-  const configured = process.env.URL || process.env.DEPLOY_URL;
-  if (configured) return configured;
   return new URL(request.url).origin;
 }
 

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/guards/no-env-credentials.js

@@ -34,6 +34,15 @@
 import { lineColForOffset, readFileSafe, relPosix, walk, } from "./scan-utils.js";
 const ALLOWLIST_EXACT = new Set([
     "DATABASE_URL",
+    // Direct (non-pooler) connection to the same database as DATABASE_URL, used by
+    // drizzle-kit for migrations. Builder-hosted apps get it unprefixed; the
+    // NETLIFY_DATABASE_URL_UNPOOLED spelling is covered by the NETLIFY_ prefix.
+    "DATABASE_URL_UNPOOLED",
+    // Builder/Fusion deploy metadata: which branch kind the app was built for.
+    // Exact, not a FUSION_ prefix — a prefix would let an app secret named
+    // FUSION_STRIPE_SECRET_KEY through, and this is the only FUSION_ key any
+    // generated app code reads.
+    "FUSION_BRANCH_KIND",
     "DATABASE_AUTH_TOKEN",
     "NODE_ENV",
     "CI",

package/dist/ingestion/index.d.ts

@@ -1,6 +1,6 @@
 export { acquireIngestionLease, assertInventoryComplete, consumeIngestionBudget, createIngestionBudgetState, createIngestionCheckpoint, ingestionBudgetStopReason, releaseIngestionLease, renewIngestionLease, type AcquireIngestionLeaseInput, type AcquireIngestionLeaseResult, type IngestionBudgetLimits, type IngestionBudgetState, type IngestionBudgetStopReason, type IngestionCheckpoint, type IngestionLease, type IngestionPhase, } from "./orchestration.js";
 export { detectOfficeDocumentType, normalizeDocumentText, parseOfficeDocument, type OfficeDocumentAst, type OfficeDocumentParser, type OfficeDocumentPart, type OfficeDocumentType, type ParsedOfficeDocument, type ParseOfficeDocumentInput, } from "./office.js";
-export { parsePptxPresentation, type ParsedPptxImage, type ParsedPptxPresentation, type ParsedPptxSlide, type ParsedPptxTextRun, } from "./pptx.js";
+export { parsePptxPresentation, type ParsedPptxImage, type ParsedPptxElement, type ParsedPptxGrid, type ParsedPptxParagraph, type ParsedPptxPresentation, type ParsedPptxSlide, type ParsedPptxTextRun, } from "./pptx.js";
 export { extractDocxSections, parseDocxDocument, sanitizeInertDocumentHtml, type ParsedDocxDocument, type ParsedDocxSection, } from "./docx.js";
 export { compositeFigmaColors, extractFigmaTopLevelFrames, figmaColorToHex, figmaContrastRatio, summarizeFigmaFrame, summarizeFigmaNode, type FigmaContextNode, type FigmaFrameSummary, type FigmaRgba, type SummarizeFigmaNodeResult, } from "./figma.js";
 export { cssBlendMode, gradientAngleDegreesFromHandles, gradientGeometryFromTransform, handlePositionsFromArrayTransform, handlePositionsFromObjectTransform, invert2x3, mat2x3FromArray, remapLinearStopPosition, resolveGradientHandles, vectorLength, type BlendModeResult, type BlendVerdict, type GradientGeometry, type GradientHandles, type GradientKind, type Mat2x3Array, type Mat2x3Object, type Vec2, } from "./figma-paint-math.js";

package/dist/ingestion/pptx.d.ts

@@ -4,7 +4,48 @@ export interface ParsedPptxTextRun {
     italic?: boolean;
     fontSize?: number;
     color?: string;
+    fontFamily?: string;
+    underline?: boolean;
 }
+export interface ParsedPptxParagraph {
+    runs: ParsedPptxTextRun[];
+    alignment?: "left" | "center" | "right" | "justify";
+    bulletChar?: string;
+    bulletColor?: string;
+    bulletFontFamily?: string;
+    bulletSize?: number;
+    level?: number;
+    marginLeftEmu?: number;
+    indentEmu?: number;
+    lineSpacing?: number;
+    spaceBeforePt?: number;
+    spaceAfterPt?: number;
+}
+export interface ParsedPptxElement {
+    id: string;
+    name?: string;
+    placeholderType?: string;
+    kind: "text" | "image" | "shape";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation?: number;
+    shapeType?: string;
+    fill?: string;
+    lineColor?: string;
+    lineWidth?: number;
+    padding?: {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    verticalAlign?: "top" | "middle" | "bottom";
+    paragraphs?: ParsedPptxParagraph[];
+    image?: ParsedPptxImage;
+}
+export type ParsedPptxTransition = "instant" | "none" | "fade" | "slide" | "zoom";
 export interface ParsedPptxImage {
     data: Uint8Array;
     mimeType: string;
@@ -13,12 +54,38 @@ export interface ParsedPptxImage {
     aspectRatio?: number;
     /** True when the picture shape covers at least ~85% of the slide's width and height — a full-bleed background photo rather than an inset card image. */
     fullBleed?: boolean;
+    crop?: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
 }
 export interface ParsedPptxSlide {
     texts: ParsedPptxTextRun[];
     images: ParsedPptxImage[];
+    elements: ParsedPptxElement[];
+    widthEmu?: number;
+    heightEmu?: number;
+    backgroundColor?: string;
+    /** A decorative grid inherited from the slide master, when one is present. */
+    backgroundGrid?: ParsedPptxGrid;
     notes?: string;
     layoutHint?: string;
+    transition?: ParsedPptxTransition;
+    splitByParagraph?: boolean;
+}
+export interface ParsedPptxGrid {
+    color: string;
+    stepXEmu: number;
+    stepYEmu: number;
+    offsetXEmu: number;
+    offsetYEmu: number;
+    lineWidthEmu: number;
+}
+export interface ParsedPptxSlideMetadata {
+    transition?: ParsedPptxTransition;
+    splitByParagraph?: boolean;
 }
 export interface ParsedPptxPresentation {
     title: string;
@@ -29,3 +96,4 @@ export interface ParsedPptxPresentation {
     };
 }
 export declare function parsePptxPresentation(fileBuffer: Uint8Array): Promise<ParsedPptxPresentation>;
+export declare function parsePptxSlideMetadata(value: unknown): ParsedPptxSlideMetadata;