@koda-sl/baker-cli 0.294.0 → 0.295.0

package/README.md

@@ -4018,7 +4018,7 @@ Pick a `source` discriminator and declare the kind you expect. See [Ingestion](#
 
 **Params** — discriminated on `source`:
 
-`source: "url"` (yt-dlp / direct fetch / Handinger):
+`source: "url"` (yt-dlp / direct fetch / Firecrawl):
 
 | Name | Type | Required | Constraint |
 |---|---|---|---|
@@ -4038,7 +4038,7 @@ Pick a `source` discriminator and declare the kind you expect. See [Ingestion](#
 
 **Path-source notes:** the canvas is **not portable** to another machine without the file. Cache key folds the file's `mtime:size`, so editing the file invalidates the cache automatically. Supported extensions: `png`, `jpg`/`jpeg`, `webp`, `gif`, `avif`, `svg`, `mp4`, `webm`, `mov`, `m4v`, `mp3`, `wav`, `m4a`, `ogg`, `flac`, `json`, `txt`, `md`, `markdown`, `html`/`htm`, `csv`, `ttf`, `otf`, `woff`, `woff2`. Unknown extensions fall back to magic-byte sniffing for common image formats (and an SVG content sniff), else `kind_mismatch`. **Any `expect: "image"` in a format image-generation models can't read (SVG, AVIF, HEIC, TIFF, BMP) is normalized to PNG on ingest** — model-safe rasters (`jpeg`/`png`/`gif`/`webp`) pass through untouched, everything else is transcoded so a reference can never 400 a generation. This applies to **both `source: "path"` and `source: "url"`** (URL images are fetched and normalized locally, since the backend can't run the rasterizer). SVG gets density-aware upscaling (longest edge near 2048px, transparency preserved). The normalized asset carries `metadata.rasterized_from` set to the source format (e.g. `"svg"`, `"avif"`). **Video (`expect: "video"`) duration is probed from the file's ISO-BMFF (`mp4`/`mov`/`m4v`) header** and stamped as the canonical `duration_ms` (and `metadata.duration_ms`); other containers (e.g. `webm`) leave it unset. Downstream `video_deconstruct` uses this declared duration to size its ingest-poll timeout and preflight — without it those fall back to worst-case budgets and a single deconstruct step can hit the action time limit.
 
-**Cost:** 0 engine credits for direct fetch + yt-dlp + local file. Handinger charges per scrape.
+**Cost:** 0 engine credits for direct fetch + yt-dlp + local file. Firecrawl charges per scrape.
 
 ---
 
@@ -5352,10 +5352,10 @@ baker canvas catalog | jq '.compositions[].id'
 // URL source — YouTube audio-only (yt-dlp -x)
 { "id": "src", "type": "ingest", "params": { "source": "url", "url": "https://youtu.be/dQw4w9WgXcQ", "expect": "audio" } }
 
-// URL source — blog post → clean markdown (Handinger)
+// URL source — blog post → clean markdown (Firecrawl)
 { "id": "src", "type": "ingest", "params": { "source": "url", "url": "https://example.com/blog/post", "expect": "text" } }
 
-// URL source — PDF → markdown (Handinger handles PDFs)
+// URL source — PDF → markdown (Firecrawl handles PDFs)
 { "id": "src", "type": "ingest", "params": { "source": "url", "url": "https://example.com/whitepaper.pdf", "expect": "text" } }
 
 // URL source — raw markdown file (direct fetch)
@@ -5383,7 +5383,7 @@ baker canvas catalog | jq '.compositions[].id'
 | url      | video / audio | any                              | `yt_dlp` (works on platform URLs *and* direct file URLs via the generic extractor) |
 | url      | image / json / font | any                        | `direct_fetch` (HTTP GET) |
 | url      | text          | ends in `.txt` or `.md`          | `direct_fetch` |
-| url      | text          | anything else (HTML, PDF, …)     | `handinger` `/markdown` (extracted markdown — HTML/PDF made readable) |
+| url      | text          | anything else (HTML, PDF, …)     | `firecrawl` `/v2/scrape` (extracted markdown — HTML/PDF made readable) |
 
 If the bytes' mime contradicts `expect` (e.g. `expect: "image"` but the URL serves `text/html`, or a `.pdf` file is passed as `expect: "image"`), the node fails with a clear `kind_mismatch` error instead of forwarding bad bytes downstream.
 
@@ -5426,7 +5426,7 @@ If the bytes' mime contradicts `expect` (e.g. `expect: "image"` but the URL serv
     file_size?:   number,                     // bytes
     original_filename?: string,               // basename of the source path
 
-    strategy:     "direct_fetch" | "handinger" | "yt_dlp" | "local_file",
+    strategy:     "direct_fetch" | "firecrawl" | "yt_dlp" | "local_file",
     ingested_at:  string,                     // ISO 8601 timestamp
 
     // yt-dlp adds (when available from --dump-json):
@@ -5437,7 +5437,7 @@ If the bytes' mime contradicts `expect` (e.g. `expect: "image"` but the URL serv
     width?:                 number,
     height?:                number,
 
-    // Handinger adds:
+    // Firecrawl adds:
     word_count?:            number,
   },
 
@@ -5456,8 +5456,8 @@ The `url` is a stable R2 URL — remote downstream nodes (e.g. `video_lipsync`)
 |-----------------------|----------------|------------------------------------------------------------------------------|
 | `INVALID_PARAMS`      | engine validator | Missing/malformed fields, mixing `url` + `path`, unknown `source`, unknown `expect`. |
 | `kind_mismatch`       | url + direct_fetch | URL returned bytes whose mime doesn't match `expect`. Message: `ingest expect=<X> but <url> returned <mime> (kind=<Y>)`. |
-| `kind_mismatch`       | path + local_file | File mime (from extension or magic-byte sniff) doesn't match `expect`, *or* mime doesn't map to any of our kinds (e.g. local PDFs aren't supported as `text` — host them via URL for Handinger to extract). |
-| `provider_error`      | url + handinger / direct_fetch | Handinger `/markdown` non-2xx, or upstream `fetch` non-ok. |
+| `kind_mismatch`       | path + local_file | File mime (from extension or magic-byte sniff) doesn't match `expect`, *or* mime doesn't map to any of our kinds (e.g. local PDFs aren't supported as `text` — host them via URL for Firecrawl to extract). |
+| `provider_error`      | url + firecrawl / direct_fetch | Firecrawl `/v2/scrape` non-2xx or no markdown in the response, **or the target site answering 4xx/5xx** (Firecrawl reports that inside a 200 carrying the error page, so it is refused rather than stored as the page), or upstream `fetch` non-ok. Terminal: a bad host, a 404 and a block page fail identically on a retry and each retry is billed. Retried: a 429 from either side, a Firecrawl-side 5xx, a dropped connection. |
 | `file_not_found`      | path + local_file | `stat()` returned `ENOENT`. Error names the absolute resolved path. |
 | `not_a_file`          | path + local_file | Path exists but is a directory / block device / socket. |
 | `permission_denied`   | path + local_file | `stat()` or `readFile()` returned `EACCES`. |
@@ -5474,7 +5474,7 @@ All execution-time failures flow through `NodeExecutionError` so they appear in
 - **Engine-level cache** (`canvas/.cache/index/`) keys by node params + node version + node-supplied cache extras. Re-running the same canvas with the same params is a cache hit and skips the network/yt-dlp/local-read entirely.
 - **yt-dlp version is folded into the cache key** for `source: "url"` with `expect: video | audio`. Upgrading yt-dlp busts the cache automatically, since new versions can produce different bitstreams.
 - **Local file `mtime + size` is folded into the cache key** for `source: "path"`. Editing the file (any save bumps mtime) invalidates the cache so you get fresh ingestion. mtime+size is cheap to read at validate time; for cases where mtime is unreliable (`cp -p`, content-only changes), force-bypass with `--cache-policy bypass` or change the canvas's `cache_salt`.
-- **No TTL.** Handinger and direct fetch don't cache-bust on page changes — if the source page updates, use `--cache-policy bypass` or change `cache_salt`.
+- **No TTL.** Firecrawl and direct fetch don't cache-bust on page changes — if the source page updates, use `--cache-policy bypass` or change `cache_salt`.
 
 **Local files (`source: "path"`):**
 
@@ -5497,10 +5497,10 @@ ingest { source: "path", expect: "video" } → video_transcribe          # Local
 **Requirements:**
 
 - `yt-dlp` and `ffmpeg` on PATH for `source: "url"` with `expect: "video" | "audio"` (already in the E2B sandbox image; install locally with `pip install yt-dlp` and `brew install ffmpeg` / equivalent).
-- `HANDINGER_API_KEY` on the Convex backend for `source: "url"` with `expect: "text"` on non-`.md`/`.txt` URLs.
+- `FIRECRAWL_API_KEY` on the Convex backend for `source: "url"` with `expect: "text"` on non-`.md`/`.txt` URLs.
 - No additional dependencies for `source: "path"` — just filesystem access.
 
-**Cost:** zero engine credits for direct_fetch + yt_dlp. Handinger charges per scrape on your Handinger account (configured outside Baker).
+**Cost:** zero engine credits for direct_fetch + yt_dlp. Firecrawl charges per scrape on your Firecrawl account (configured outside Baker).
 
 ---
 

package/dist/{chunk-NNQDWCFG.js → chunk-YFQWCJX4.js}

@@ -757,6 +757,19 @@ async function parseErrorBody(res) {
   }
   return classifyHttpError(res.status, errObj, message2);
 }
+function providerVerdict(status, errObj, message2) {
+  if (errObj.provider === void 0 && errObj.code !== "provider_error") return null;
+  return {
+    kind: "provider",
+    status,
+    provider: errObj.provider,
+    code: errObj.code ?? "provider_error",
+    message: message2,
+    // A 4xx is terminal unless the backend says otherwise — the opposite
+    // default from the 502 branch, where the status itself means "try again".
+    retryable: errObj.retryable ?? false
+  };
+}
 function classifyHttpError(status, errObj, message2) {
   if (errObj.code === CONTENT_POLICY_CODE) {
     return { kind: "content_policy", status, provider: errObj.provider, message: message2 };
@@ -765,7 +778,7 @@ function classifyHttpError(status, errObj, message2) {
     return { kind: "unauthorized", status, message: message2 };
   }
   if (status === 400 || status === 422) {
-    return { kind: "validation", status, message: message2, details: errObj.details };
+    return providerVerdict(status, errObj, message2) ?? { kind: "validation", status, message: message2, details: errObj.details };
   }
   if (status === 502 || status === 504) {
     if (errObj.code === "provider_timeout" || status === 504) {
@@ -5936,7 +5949,7 @@ function resolveStrategy(params) {
     case "text": {
       const p = safePathname(params.url);
       const isRawText = RAW_TEXT_EXTENSIONS.some((ext) => p.endsWith(ext));
-      return isRawText ? "direct_fetch" : "handinger";
+      return isRawText ? "direct_fetch" : "firecrawl";
     }
     default: {
       params.expect;
@@ -5953,10 +5966,10 @@ function safePathname(rawUrl) {
 }
 var ingestNode = defineNode({
   id: "ingest",
-  version: "1.2.0",
+  version: "1.3.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 \u2192 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.",
+  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), Firecrawl for HTML/PDF pages \u2192 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` \u2192 `video_transcribe`).',
   inputs: IngestInputs,
   params: IngestParams,
@@ -5983,8 +5996,8 @@ function runStrategy(strategy, params, ctx) {
   switch (strategy) {
     case "direct_fetch":
       return execDirectFetch(params, ctx);
-    case "handinger":
-      return execHandinger(params, ctx);
+    case "firecrawl":
+      return execFirecrawl(params, ctx);
     case "yt_dlp":
       return execYtDlp(params, ctx);
     case "local_file":
@@ -6037,11 +6050,11 @@ async function ingestImageUrl(url, ctx) {
     ctx
   });
 }
-async function execHandinger(params, ctx) {
+async function execFirecrawl(params, ctx) {
   const result = await callBackendExec({
     nodeType: "ingest",
     nodeVersion: ingestNode.version,
-    params: { strategy: "handinger", url: params.url },
+    params: { strategy: "firecrawl", url: params.url },
     inputs: {},
     outputKinds: { asset: "text" },
     ctx
@@ -9199,4 +9212,4 @@ export {
   defaultRegistry,
   createEngineFromEnv
 };
-//# sourceMappingURL=chunk-NNQDWCFG.js.map
+//# sourceMappingURL=chunk-YFQWCJX4.js.map