@koda-sl/baker-cli 0.39.29-dev.994437bd → 0.66.2

package/dist/engine/models/validateParams.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validateParams.js","sourceRoot":"","sources":["../../../src/engine/models/validateParams.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,cAAc,EAAmC,MAAM,eAAe,CAAC;AAWhG,MAAM,UAAU,GAAG,IAAI,GAAG,CAAW;IACnC,eAAe;IACf,oBAAoB;IACpB,gBAAgB;IAChB,gBAAgB;IAChB,uBAAuB;IACvB,cAAc;IACd,gBAAgB;IAChB,mBAAmB;IACnB,eAAe;IACf,KAAK;IACL,OAAO;IACP,UAAU;IACV,cAAc;CACf,CAAC,CAAC;AAEH,SAAS,iBAAiB,CAAC,QAAgB;IACzC,OAAO,UAAU,CAAC,GAAG,CAAC,QAAoB,CAAC,CAAC;AAC9C,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,mBAAmB,CAC1B,IAAqC,EACrC,MAA+B,EAC/B,KAAa;IAEb,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QAChC,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,SAAS,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;YACtD,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,wBAAwB;gBAC9B,KAAK,EAAE,GAAG;gBACV,OAAO,EAAE,2BAA2B,GAAG,gBAAgB,KAAK,GAAG;aAChE,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,gBAAgB,CACvB,IAA6C,EAC7C,MAA+B,EAC/B,KAAa;IAEb,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QAClD,IAAI,GAAG,KAAK,OAAO;YAAE,SAAS;QAC9B,IAAI,KAAK,KAAK,SAAS;YAAE,SAAS;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAChC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,eAAe;gBACrB,KAAK,EAAE,GAAG;gBACV,OAAO,EAAE,UAAU,GAAG,gCAAgC,KAAK,GAAG;aAC/D,CAAC,CAAC;YACH,SAAS;QACX,CAAC;QACD,MAAM,QAAQ,GAAG,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QAC1D,IAAI,QAAQ;YAAE,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,mBAAmB,CACjC,QAAkB,EAClB,KAAa,EACb,MAA+B;IAE/B,MAAM,IAAI,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;IAC7C,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,kBAAkB,KAAK,eAAe,QAAQ,GAAG,EAAE,CAAC;SAChG,CAAC;IACJ,CAAC;IAED,MAAM,MAAM,GAAG,CAAC,GAAG,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,GAAG,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IACvG,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACpD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;AACtB,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,QAAkB,EAClB,KAAa,EACb,aAAmC;IAEnC,MAAM,IAAI,GAAG,cAAc,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC;IAC7C,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,OAAO;YACL,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,kBAAkB,KAAK,eAAe,QAAQ,GAAG,EAAE,CAAC;SAChG,CAAC;IACJ,CAAC;IACD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC;IACpC,MAAM,MAAM,GAA2B,EAAE,CAAC;IAC1C,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QACpC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YAC9B,MAAM,CAAC,IAAI,CAAC;gBACV,IAAI,EAAE,eAAe;gBACrB,KAAK,EAAE,SAAS,CAAC,IAAI;gBACrB,OAAO,EAAE,UAAU,KAAK,6BAA6B,SAAS,CAAC,IAAI,GAAG;aACvE,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;IACpD,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;AACtB,CAAC;AAED,SAAS,mBAAmB,CAC1B,GAAW,EACX,KAAc,EACd,MAAgD,EAChD,KAAa;IAEb,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,0BAA0B,OAAO,KAAK,EAAE,EAAE,CAAC;IACxG,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAChD,OAAO;YACL,IAAI,EAAE,eAAe;YACrB,KAAK,EAAE,GAAG;YACV,OAAO,EAAE,GAAG,GAAG,MAAM,KAAK,qBAAqB,KAAK,eAAe,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;SAC7F,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,SAAS,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,SAAS,EAAE,CAAC;QACtE,OAAO;YACL,IAAI,EAAE,eAAe;YACrB,KAAK,EAAE,GAAG;YACV,OAAO,EAAE,GAAG,GAAG,KAAK,KAAK,CAAC,MAAM,2BAA2B,MAAM,CAAC,SAAS,SAAS,KAAK,GAAG;SAC7F,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,mBAAmB,CAC1B,GAAW,EACX,KAAc,EACd,MAAgD,EAChD,KAAa;IAEb,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACrD,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,0BAA0B,OAAO,KAAK,EAAE,EAAE,CAAC;IACxG,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAChD,OAAO;YACL,IAAI,EAAE,eAAe;YACrB,KAAK,EAAE,GAAG;YACV,OAAO,EAAE,GAAG,GAAG,KAAK,KAAK,oBAAoB,KAAK,eAAe,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;SAC3F,CAAC;IACJ,CAAC;IACD,IAAI,MAAM,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC;QACnD,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,KAAK,KAAK,cAAc,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC;IACpG,CAAC;IACD,IAAI,MAAM,CAAC,GAAG,KAAK,SAAS,IAAI,KAAK,GAAG,MAAM,CAAC,GAAG,EAAE,CAAC;QACnD,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,KAAK,KAAK,cAAc,MAAM,CAAC,GAAG,EAAE,EAAE,CAAC;IACpG,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,aAAa,CAAC,GAAW,EAAE,KAAc,EAAE,MAAmB,EAAE,KAAa;IACpF,QAAQ,MAAM,CAAC,IAAI,EAAE,CAAC;QACpB,KAAK,QAAQ;YACX,OAAO,mBAAmB,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QACxD,KAAK,QAAQ;YACX,OAAO,mBAAmB,CAAC,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;QACxD,KAAK,SAAS;YACZ,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC/B,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,2BAA2B,OAAO,KAAK,EAAE,EAAE,CAAC;YACzG,CAAC;YACD,OAAO,IAAI,CAAC;QACd,KAAK,MAAM;YACT,OAAO,IAAI,CAAC;QACd,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,WAAW,GAAU,MAAsB,CAAC;YAClD,OAAO,WAAW,CAAC;QACrB,CAAC;IACH,CAAC;AACH,CAAC;AAED,OAAO,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/engine/nodes/ingest.d.ts

@@ -0,0 +1,113 @@
+import { z } from "zod";
+import type { ExecCtx } from "../engine/context.ts";
+import type { AssetKind, AssetRef } from "../schema/refs.ts";
+declare const IngestParams: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"url">;
+    url: z.ZodString;
+    expect: z.ZodEnum<{
+        json: "json";
+        video: "video";
+        image: "image";
+        audio: "audio";
+        text: "text";
+        font: "font";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodLiteral<"path">;
+    path: z.ZodString;
+    expect: z.ZodEnum<{
+        json: "json";
+        video: "video";
+        image: "image";
+        audio: "audio";
+        text: "text";
+        font: "font";
+    }>;
+}, z.core.$strict>], "source">;
+type IngestParamsT = z.infer<typeof IngestParams>;
+type Strategy = "direct_fetch" | "handinger" | "yt_dlp" | "local_file";
+declare function resolveStrategy(params: IngestParamsT): Strategy;
+export declare const ingestNode: import("../engine/define.ts").NodeDefinition<Record<string, never>, {
+    source: "url";
+    url: string;
+    expect: "json" | "video" | "image" | "audio" | "text" | "font";
+} | {
+    source: "path";
+    path: string;
+    expect: "json" | "video" | "image" | "audio" | "text" | "font";
+}, {
+    asset: {
+        sha256: string;
+        mime: string;
+        kind: "image";
+        url?: string | undefined;
+        path?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+    } | {
+        sha256: string;
+        mime: string;
+        kind: "video";
+        url?: string | undefined;
+        path?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        width?: number | undefined;
+        height?: number | undefined;
+        duration_ms?: number | undefined;
+    } | {
+        sha256: string;
+        mime: string;
+        kind: "audio";
+        url?: string | undefined;
+        path?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        duration_ms?: number | undefined;
+    } | {
+        sha256: string;
+        mime: string;
+        kind: "json";
+        url?: string | undefined;
+        path?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | {
+        sha256: string;
+        mime: string;
+        kind: "text";
+        url?: string | undefined;
+        path?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | {
+        sha256: string;
+        mime: string;
+        kind: "font";
+        url?: string | undefined;
+        path?: string | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    };
+}>;
+declare function resolveLocalPath(input: string): string;
+export declare function inferMimeFromPath(absPath: string, sniffBytes: Buffer): string;
+export declare function rasterizeSvgToPng(bytes: Buffer): Promise<Buffer>;
+declare function inferKindFromMime(mime: string): AssetKind | null;
+type YtDlpInfo = Record<string, unknown>;
+declare function buildYtDlpMetadata(sourceUrl: string, info: YtDlpInfo): Record<string, unknown>;
+export declare function uploadAndIngest(args: {
+    bytes: Buffer;
+    kind: AssetKind;
+    mime: string;
+    metadata: Record<string, unknown>;
+    ctx: ExecCtx;
+}): Promise<AssetRef>;
+export declare const _internal: {
+    resolveStrategy: typeof resolveStrategy;
+    resolveLocalPath: typeof resolveLocalPath;
+    inferMimeFromPath: typeof inferMimeFromPath;
+    inferKindFromMime: typeof inferKindFromMime;
+    buildYtDlpMetadata: typeof buildYtDlpMetadata;
+    YT_DLP_EXT: Record<"json" | "video" | "image" | "audio" | "text" | "font", string>;
+    YT_DLP_MIME: Record<"json" | "video" | "image" | "audio" | "text" | "font", string>;
+    EXT_TO_MIME: Record<string, string>;
+};
+export {};
+//# sourceMappingURL=ingest.d.ts.map

package/dist/engine/nodes/ingest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ingest.d.ts","sourceRoot":"","sources":["../../../src/engine/nodes/ingest.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAGpD,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAc7D,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;8BAehB,CAAC;AAKH,KAAK,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAQlD,KAAK,QAAQ,GAAG,cAAc,GAAG,WAAW,GAAG,QAAQ,GAAG,YAAY,CAAC;AAIvE,iBAAS,eAAe,CAAC,MAAM,EAAE,aAAa,GAAG,QAAQ,CAoBxD;AAcD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBrB,CAAC;AAqEH,iBAAS,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ/C;AA+CD,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAQ7E;AAKD,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAatE;AAuBD,iBAAS,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAQzD;AAiJD,KAAK,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAuDzC,iBAAS,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAavF;AAMD,wBAAsB,eAAe,CAAC,IAAI,EAAE;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,GAAG,EAAE,OAAO,CAAC;CACd,GAAG,OAAO,CAAC,QAAQ,CAAC,CAuBpB;AAqFD,eAAO,MAAM,SAAS;;;;;;;;;CASrB,CAAC"}

package/dist/engine/nodes/ingest.js

@@ -0,0 +1,555 @@
+import { execFile as execFileCb, spawn } from "node:child_process";
+import { mkdtemp, readdir, readFile, rm, stat } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import { z } from "zod";
+import { defineNode } from "../engine/define.js";
+import { NodeExecutionError } from "../engine/errors.js";
+import { AssetRef as AssetRefSchema } from "../schema/refs.js";
+import { MAX_ASSET_BYTES } from "../storage/asset-store.js";
+import { sha256Hex } from "../storage/sha256.js";
+import { callBackendExec } from "./remote/delegate.js";
+const execFile = promisify(execFileCb);
+// ---------------------------------------------------------------------------
+// Schema — discriminated union on `source`
+// ---------------------------------------------------------------------------
+const ExpectEnum = z.enum(["image", "video", "audio", "text", "json", "font"]);
+const IngestParams = z.discriminatedUnion("source", [
+    z
+        .object({
+        source: z.literal("url"),
+        url: z.string().url(),
+        expect: ExpectEnum,
+    })
+        .strict(),
+    z
+        .object({
+        source: z.literal("path"),
+        path: z.string().min(1),
+        expect: ExpectEnum,
+    })
+        .strict(),
+]);
+const IngestInputs = z.object({}).strict();
+const IngestOutputs = z.object({ asset: AssetRefSchema }).strict();
+const RAW_TEXT_EXTENSIONS = [".txt", ".md"];
+function resolveStrategy(params) {
+    if (params.source === "path")
+        return "local_file";
+    switch (params.expect) {
+        case "video":
+        case "audio":
+            return "yt_dlp";
+        case "image":
+        case "json":
+        case "font":
+            return "direct_fetch";
+        case "text": {
+            const p = safePathname(params.url);
+            const isRawText = RAW_TEXT_EXTENSIONS.some((ext) => p.endsWith(ext));
+            return isRawText ? "direct_fetch" : "handinger";
+        }
+        default: {
+            params.expect;
+            throw new Error(`ingest: unhandled expect=${String(params.expect)}`);
+        }
+    }
+}
+function safePathname(rawUrl) {
+    try {
+        return new URL(rawUrl).pathname.toLowerCase();
+    }
+    catch {
+        return "";
+    }
+}
+// ---------------------------------------------------------------------------
+// Node definition
+// ---------------------------------------------------------------------------
+export const ingestNode = defineNode({
+    id: "ingest",
+    version: "1.1.0",
+    category: "io",
+    location: "local",
+    summary: "Ingest an external URL or a local file into the asset store. Declare the kind you expect (image/video/audio/text/json/font); the node picks the strategy. For source=url: yt-dlp for video/audio (YouTube/TikTok/Vimeo/etc. and direct file URLs), Handinger for HTML/PDF pages → markdown, direct HTTP fetch for binary URLs (images, fonts) and raw .txt/.md. For source=path: read from the local filesystem and upload to R2.",
+    when_to_use: 'Use as the on-ramp for any external asset a canvas needs. `expect` makes the output port statically typed so downstream wiring is checked before any byte is fetched. Pick `source: "url"` for portable canvas; pick `source: "path"` for local files (canvas is not portable across machines without the file). Compose with other nodes for richer pipelines (e.g. `ingest expect=video` → `video_transcribe`).',
+    inputs: IngestInputs,
+    params: IngestParams,
+    outputs: IngestOutputs,
+    cost: () => ({ credits: 0, seconds_estimate: 5 }),
+    // Output kind is declared in params, so validators/UI can type the port
+    // statically without running the node.
+    outputKinds: (params) => ({ asset: params.expect }),
+    async execute({ params, ctx }) {
+        const strategy = resolveStrategy(params);
+        const source = params.source === "url" ? params.url : params.path;
+        ctx.log(`ingest: ${strategy} (${params.expect}) ${source}`);
+        const asset = await runStrategy(strategy, params, ctx);
+        return { asset };
+    },
+});
+function runStrategy(strategy, params, ctx) {
+    if (params.source === "path") {
+        if (strategy !== "local_file") {
+            throw new Error(`ingest: invariant — source=path but strategy=${strategy}`);
+        }
+        return execLocalFile(params, ctx);
+    }
+    // params.source === "url" — narrowed
+    switch (strategy) {
+        case "direct_fetch":
+            return execDirectFetch(params, ctx);
+        case "handinger":
+            return execHandinger(params, ctx);
+        case "yt_dlp":
+            return execYtDlp(params, ctx);
+        case "local_file":
+            throw new Error(`ingest: invariant — source=url but strategy=local_file`);
+        default: {
+            strategy;
+            throw new Error(`ingest: unhandled strategy=${String(strategy)}`);
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// direct_fetch / handinger — both go through the backend
+// ---------------------------------------------------------------------------
+async function execDirectFetch(params, ctx) {
+    const result = await callBackendExec({
+        nodeType: "ingest",
+        nodeVersion: ingestNode.version,
+        params: { strategy: "direct_fetch", url: params.url, expect: params.expect },
+        inputs: {},
+        outputKinds: { asset: params.expect },
+        ctx,
+    });
+    return assertAssetOutput(result, params.expect);
+}
+async function execHandinger(params, ctx) {
+    const result = await callBackendExec({
+        nodeType: "ingest",
+        nodeVersion: ingestNode.version,
+        params: { strategy: "handinger", url: params.url },
+        inputs: {},
+        outputKinds: { asset: "text" },
+        ctx,
+    });
+    return assertAssetOutput(result, "text");
+}
+function assertAssetOutput(result, expected) {
+    const asset = result.asset;
+    if (!asset || typeof asset !== "object" || !("kind" in asset)) {
+        throw new Error(`ingest: backend returned no asset (got ${JSON.stringify(result)})`);
+    }
+    if (asset.kind !== expected) {
+        throw new Error(`ingest: backend returned kind=${asset.kind} but expected ${expected}`);
+    }
+    return asset;
+}
+// ---------------------------------------------------------------------------
+// local_file — read from disk, sniff mime, upload to R2 via presign
+// ---------------------------------------------------------------------------
+function resolveLocalPath(input) {
+    if (input.startsWith("~")) {
+        throw new Error(`ingest: ~ path expansion is not supported (got "${input}"). Use an absolute path or a cwd-relative path.`);
+    }
+    if (path.isAbsolute(input))
+        return input;
+    return path.resolve(process.cwd(), input);
+}
+const EXT_TO_MIME = {
+    png: "image/png",
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    webp: "image/webp",
+    gif: "image/gif",
+    avif: "image/avif",
+    mp4: "video/mp4",
+    webm: "video/webm",
+    mov: "video/quicktime",
+    m4v: "video/mp4",
+    mp3: "audio/mpeg",
+    wav: "audio/wav",
+    m4a: "audio/mp4",
+    ogg: "audio/ogg",
+    flac: "audio/flac",
+    json: "application/json",
+    txt: "text/plain",
+    md: "text/markdown",
+    markdown: "text/markdown",
+    html: "text/html",
+    htm: "text/html",
+    csv: "text/csv",
+    ttf: "font/ttf",
+    otf: "font/otf",
+    woff: "font/woff",
+    woff2: "font/woff2",
+    svg: "image/svg+xml",
+};
+const SVG_MIME = "image/svg+xml";
+// Crispness target for rasterized SVGs. SVGs (brand logos especially) are often authored at small
+// intrinsic sizes — sharp rasterizes at the intrinsic size unless we raise the render density, which
+// would leave a tiny, blurry logo. We measure the intrinsic size and scale the density so the longest
+// edge lands near SVG_TARGET_LONGEST_PX, clamped so a pathological viewBox can't blow up memory.
+const SVG_TARGET_LONGEST_PX = 2048;
+const SVG_BASE_DENSITY = 72;
+const SVG_MAX_DENSITY = 2400;
+function sniffSvg(buf) {
+    const head = buf.subarray(0, Math.min(buf.length, 512)).toString("utf8").trimStart();
+    return head.startsWith("<?xml") ? head.includes("<svg") : head.startsWith("<svg");
+}
+export function inferMimeFromPath(absPath, sniffBytes) {
+    const ext = path.extname(absPath).slice(1).toLowerCase();
+    const fromExt = EXT_TO_MIME[ext];
+    if (fromExt)
+        return fromExt;
+    const fromBytes = sniffImageMime(sniffBytes);
+    if (fromBytes)
+        return fromBytes;
+    if (sniffSvg(sniffBytes))
+        return SVG_MIME;
+    return "application/octet-stream";
+}
+// Image-generation models can't consume raw SVG markup, so an ingested SVG (e.g. a brand logo) is
+// rasterized to a transparent PNG here. Transparency is kept so the wordmark composites cleanly onto
+// any background downstream.
+export async function rasterizeSvgToPng(bytes) {
+    // `sharp` is a native module that can't load in the Convex runtime. This function only runs in the
+    // local execLocalFile path (the ingest node is location: "local"), so import it lazily — a top-level
+    // import would drag the native binary into the Convex bundle and break `convex deploy`.
+    const { default: sharp } = await import("sharp");
+    const base = await sharp(bytes).metadata();
+    const longest = Math.max(base.width ?? 0, base.height ?? 0);
+    let density = SVG_BASE_DENSITY;
+    if (longest > 0) {
+        const scaled = Math.round((SVG_BASE_DENSITY * SVG_TARGET_LONGEST_PX) / longest);
+        density = Math.min(SVG_MAX_DENSITY, Math.max(SVG_BASE_DENSITY, scaled));
+    }
+    return await sharp(bytes, { density }).png({ force: true, palette: false }).toBuffer();
+}
+function sniffImageMime(buf) {
+    if (buf.length < 4)
+        return null;
+    if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47)
+        return "image/png";
+    if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return "image/jpeg";
+    if (buf[0] === 0x47 && buf[1] === 0x49 && buf[2] === 0x46)
+        return "image/gif";
+    if (buf.length >= 12 &&
+        buf[0] === 0x52 &&
+        buf[1] === 0x49 &&
+        buf[2] === 0x46 &&
+        buf[3] === 0x46 &&
+        buf[8] === 0x57 &&
+        buf[9] === 0x45 &&
+        buf[10] === 0x42 &&
+        buf[11] === 0x50) {
+        return "image/webp";
+    }
+    return null;
+}
+function inferKindFromMime(mime) {
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("video/"))
+        return "video";
+    if (mime.startsWith("audio/"))
+        return "audio";
+    if (mime === "application/json")
+        return "json";
+    if (mime.startsWith("text/"))
+        return "text";
+    if (mime.startsWith("font/"))
+        return "font";
+    return null;
+}
+function localExecError(ctx, message) {
+    return new NodeExecutionError(ctx.nodeId, ctx.nodeType, {
+        kind: "local",
+        cause: new Error(`ingest: ${message}`),
+    });
+}
+async function execLocalFile(params, ctx) {
+    const absPath = resolveLocalPath(params.path);
+    let stats;
+    try {
+        stats = await stat(absPath);
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === "ENOENT") {
+            throw localExecError(ctx, `file_not_found: ${absPath}`);
+        }
+        if (code === "EACCES") {
+            throw localExecError(ctx, `permission_denied: ${absPath}`);
+        }
+        throw localExecError(ctx, `stat failed for ${absPath}: ${e.message}`);
+    }
+    if (!stats.isFile()) {
+        throw localExecError(ctx, `not_a_file: ${absPath} (isDirectory=${stats.isDirectory()})`);
+    }
+    if (stats.size > MAX_ASSET_BYTES) {
+        throw localExecError(ctx, `file_too_large: ${absPath} is ${stats.size} bytes (limit ${MAX_ASSET_BYTES})`);
+    }
+    let bytes;
+    try {
+        bytes = await readFile(absPath);
+    }
+    catch (e) {
+        if (e.code === "EACCES") {
+            throw localExecError(ctx, `permission_denied: ${absPath}`);
+        }
+        throw localExecError(ctx, `read failed for ${absPath}: ${e.message}`);
+    }
+    const mime = inferMimeFromPath(absPath, bytes);
+    const kind = inferKindFromMime(mime);
+    if (kind === null) {
+        throw localExecError(ctx, `kind_mismatch: ${absPath} has mime=${mime} which doesn't map to any ingest kind (image/video/audio/text/json/font). If this is a PDF and you want text extraction, host it via URL and use source="url".`);
+    }
+    if (kind !== params.expect) {
+        throw localExecError(ctx, `kind_mismatch: expect=${params.expect} but ${absPath} has mime=${mime} (kind=${kind})`);
+    }
+    ctx.log(`ingest: local file ${stats.size}B mime=${mime}`);
+    // SVG resolves to the image kind, but downstream image-generation models can't read SVG markup, so
+    // rasterize to a transparent PNG before upload. The kind check above guarantees expect === "image".
+    let outBytes = bytes;
+    let outMime = mime;
+    if (mime === SVG_MIME) {
+        outBytes = await rasterizeSvgToPng(bytes);
+        outMime = "image/png";
+        ctx.log(`ingest: rasterized SVG -> PNG (${outBytes.length}B)`);
+    }
+    return await uploadAndIngest({
+        bytes: outBytes,
+        kind: params.expect,
+        mime: outMime,
+        metadata: {
+            source_path: absPath,
+            strategy: "local_file",
+            ingested_at: new Date().toISOString(),
+            file_size: stats.size,
+            original_filename: path.basename(absPath),
+            ...(mime === SVG_MIME ? { rasterized_from: "svg" } : {}),
+        },
+        ctx,
+    });
+}
+// ---------------------------------------------------------------------------
+// yt_dlp — runs locally, then uploads to R2 via presign so remote downstream
+// nodes can fetch the asset by URL.
+// ---------------------------------------------------------------------------
+const YT_DLP_BIN = "yt-dlp";
+const YT_DLP_TIMEOUT_MS = 10 * 60 * 1000;
+const YT_DLP_MIME = {
+    image: "image/png",
+    video: "video/mp4",
+    audio: "audio/mp4",
+    text: "text/plain",
+    json: "application/json",
+    font: "font/ttf", // unreachable — resolveStrategy never routes font to yt_dlp
+};
+const YT_DLP_EXT = {
+    image: "png",
+    video: "mp4",
+    audio: "m4a",
+    text: "txt",
+    json: "json",
+    font: "ttf", // unreachable — resolveStrategy never routes font to yt_dlp
+};
+async function execYtDlp(params, ctx) {
+    if (params.expect !== "video" && params.expect !== "audio") {
+        // resolveStrategy guarantees this, but the runtime branch makes it explicit.
+        throw new Error(`ingest: yt_dlp only handles video/audio, got expect=${params.expect}`);
+    }
+    const workDir = await mkdtemp(path.join(tmpdir(), "ingest-yt-"));
+    try {
+        const { filePath, info } = await runYtDlp({
+            url: params.url,
+            audioOnly: params.expect === "audio",
+            workDir,
+            ctx,
+        });
+        const downloadedStats = await stat(filePath);
+        if (downloadedStats.size > MAX_ASSET_BYTES) {
+            throw localExecError(ctx, `file_too_large: yt-dlp output for ${params.url} is ${downloadedStats.size} bytes (limit ${MAX_ASSET_BYTES})`);
+        }
+        const bytes = await readFile(filePath);
+        const kind = params.expect;
+        const mime = YT_DLP_MIME[kind];
+        const metadata = buildYtDlpMetadata(params.url, info);
+        return await uploadAndIngest({ bytes, kind, mime, metadata, ctx });
+    }
+    finally {
+        await rm(workDir, { recursive: true, force: true }).catch((e) => {
+            ctx.log(`ingest: tmp cleanup failed (${e.message})`);
+        });
+    }
+}
+async function runYtDlp(args) {
+    const outTemplate = path.join(args.workDir, "out.%(ext)s");
+    const infoPath = path.join(args.workDir, "out.info.json");
+    const argv = [
+        args.url,
+        "--no-playlist",
+        "--no-progress",
+        "--no-warnings",
+        "--quiet",
+        "--write-info-json",
+        "-o",
+        outTemplate,
+    ];
+    if (args.audioOnly) {
+        argv.push("-x", "--audio-format", "m4a");
+    }
+    else {
+        argv.push("--format", "bv*+ba/b", "--merge-output-format", "mp4");
+    }
+    args.ctx.log(`ingest: spawning yt-dlp (${args.audioOnly ? "audio" : "video"})`);
+    const { code, stderr } = await spawnAndWait(YT_DLP_BIN, argv, YT_DLP_TIMEOUT_MS);
+    if (code !== 0) {
+        throw new NodeExecutionError(args.ctx.nodeId, args.ctx.nodeType, {
+            kind: "local",
+            cause: new Error(`yt-dlp exited ${code}\n${tail(stderr, 40)}`),
+        });
+    }
+    const files = await readdir(args.workDir);
+    const wanted = args.audioOnly ? ".m4a" : ".mp4";
+    const downloaded = files.find((f) => f.startsWith("out.") && f.endsWith(wanted));
+    if (!downloaded) {
+        throw new Error(`ingest: yt-dlp finished but no ${wanted} file in ${args.workDir} (saw: ${files.join(", ")})`);
+    }
+    let info = {};
+    try {
+        const raw = await readFile(infoPath, "utf-8");
+        info = JSON.parse(raw);
+    }
+    catch {
+        // info.json is best-effort — yt-dlp sometimes omits it for direct file URLs.
+    }
+    return { filePath: path.join(args.workDir, downloaded), info };
+}
+function buildYtDlpMetadata(sourceUrl, info) {
+    const out = {
+        source_url: sourceUrl,
+        strategy: "yt_dlp",
+        ingested_at: new Date().toISOString(),
+    };
+    if (typeof info.title === "string")
+        out.original_title = info.title;
+    if (typeof info.uploader === "string")
+        out.original_uploader = info.uploader;
+    if (typeof info.duration === "number")
+        out.original_duration_s = info.duration;
+    if (typeof info.webpage_url === "string")
+        out.webpage_url = info.webpage_url;
+    if (typeof info.width === "number")
+        out.width = info.width;
+    if (typeof info.height === "number")
+        out.height = info.height;
+    return out;
+}
+// ---------------------------------------------------------------------------
+// R2 upload + local ingest
+// ---------------------------------------------------------------------------
+export async function uploadAndIngest(args) {
+    const sha = sha256Hex(args.bytes);
+    const { putUrl, publicUrl } = await args.ctx.client.presignAssetUpload(sha, args.mime, args.ctx.signal);
+    const putRes = await fetch(putUrl, {
+        method: "PUT",
+        body: new Uint8Array(args.bytes),
+        headers: { "Content-Type": args.mime },
+        signal: args.ctx.signal,
+    });
+    if (!putRes.ok) {
+        throw new Error(`ingest: presigned PUT failed ${putRes.status} ${putRes.statusText}`);
+    }
+    const localRef = await args.ctx.assets.ingestBytes({
+        bytes: args.bytes,
+        kind: args.kind,
+        mime: args.mime,
+        metadata: args.metadata,
+    });
+    // ingestBytes leaves url undefined (LocalAssetStore is local-only). Overlay
+    // the public R2 URL so remote downstream nodes can pull this asset.
+    return { ...localRef, url: publicUrl };
+}
+function spawnAndWait(bin, argv, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, argv, { stdio: ["ignore", "pipe", "pipe"] });
+        const stderrChunks = [];
+        let stderrLen = 0;
+        const MAX_STDERR = 256 * 1024;
+        child.stdout.on("data", () => {
+            // discard
+        });
+        child.stderr.on("data", (chunk) => {
+            if (stderrLen < MAX_STDERR) {
+                stderrChunks.push(chunk);
+                stderrLen += chunk.length;
+            }
+        });
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            reject(new Error(`ingest: ${bin} timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            reject(new Error(`ingest: failed to spawn "${bin}" — ${err.message}`));
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code: code ?? -1, stderr: Buffer.concat(stderrChunks).toString("utf8") });
+        });
+    });
+}
+function tail(text, maxLines) {
+    const lines = text.split("\n");
+    return lines.slice(-maxLines).join("\n");
+}
+// Fold yt-dlp version into the cache key so upgrades bust cache automatically.
+async function ytDlpVersion() {
+    try {
+        const { stdout } = await execFile(YT_DLP_BIN, ["--version"], { encoding: "utf-8", maxBuffer: 64 * 1024 });
+        return stdout.trim();
+    }
+    catch {
+        return "yt-dlp:unknown";
+    }
+}
+// Attach cacheKeyExtras after definition so the helper can be referenced.
+ingestNode.cacheKeyExtras = async ({ params }) => {
+    const p = params;
+    const extras = {};
+    // For source=path: fold mtime+size into the cache key so editing the file
+    // invalidates the cache automatically. Failures (missing file, perms) are
+    // silently swallowed — execute will surface them with full context.
+    if (p.source === "path" && typeof p.path === "string") {
+        try {
+            const abs = resolveLocalPath(p.path);
+            const s = await stat(abs);
+            extras.local_file_signature = `${s.mtimeMs}:${s.size}`;
+        }
+        catch {
+            // ignore — execute will fail clearly
+        }
+    }
+    // For source=url with yt_dlp strategy: fold tool version so upgrades bust cache.
+    if (p.source === "url" && (p.expect === "video" || p.expect === "audio")) {
+        extras.yt_dlp_version = await ytDlpVersion();
+    }
+    return extras;
+};
+// Exported for unit tests.
+export const _internal = {
+    resolveStrategy,
+    resolveLocalPath,
+    inferMimeFromPath,
+    inferKindFromMime,
+    buildYtDlpMetadata,
+    YT_DLP_EXT,
+    YT_DLP_MIME,
+    EXT_TO_MIME,
+};
+//# sourceMappingURL=ingest.js.map