@omg-dev/vite-plugin 0.4.24

package/src/prerender.ts

@@ -0,0 +1,106 @@
+// Build-time prerender (SSG) for user apps.
+//
+// Renders the app's root view (<App/> from src/App.tsx) to static HTML at build
+// time and bakes it into dist/index.html, so crawlers + first paint see real
+// content instead of an empty SPA shell. The client (src/main.tsx, createRoot)
+// mounts the full app over whatever HTML is in #root — so behavior is identical
+// whether or not the prerender ran; it only changes the initial bytes.
+//
+// FAIL-SOFT IS THE CONTRACT. This runs against arbitrary agent-generated code,
+// so anything can go wrong (a module-scope `window` reference, a render-time
+// throw, a missing App). Every failure path leaves dist/index.html exactly as
+// the client build produced it and returns normally — a prerender failure can
+// never fail a deploy. The worst case is "no prerender", never a broken page.
+import fs from "node:fs"
+import path from "node:path"
+
+const ROOT_MARKER = '<div id="root"></div>'
+
+export type PrerenderResult =
+  | { status: "baked"; bytes: number }
+  | { status: "skipped"; reason: string }
+
+// Renders src/App.tsx to HTML and bakes it into dist/index.html. Never throws.
+export async function prerenderApp(opts: {
+  root: string
+  distDir: string
+  vibesDir: string
+  log?: (msg: string) => void
+}): Promise<PrerenderResult> {
+  const { root, distDir, vibesDir } = opts
+  const log = opts.log ?? (() => {})
+  const htmlPath = path.join(distDir, "index.html")
+
+  try {
+    const appPath = path.join(root, "src", "App.tsx")
+    if (!fs.existsSync(appPath)) {
+      return done(log, { status: "skipped", reason: "src/App.tsx not found" })
+    }
+    if (!fs.existsSync(htmlPath)) {
+      return done(log, { status: "skipped", reason: "dist/index.html not found" })
+    }
+    const shell = fs.readFileSync(htmlPath, "utf-8")
+    if (!shell.includes(ROOT_MARKER)) {
+      return done(log, { status: "skipped", reason: "#root marker not found (custom index.html?)" })
+    }
+
+    // Build-generated SSR entry — lives in .vibes/ so we never add a file to the
+    // user's src tree, and works for apps that predate this feature. Imports the
+    // conventional app root (default export of src/App.tsx) and renders it in the
+    // same StrictMode wrapper the client uses (src/main.tsx), so the baked markup
+    // matches the client's first render.
+    const entryPath = path.join(vibesDir, "prerender.entry.tsx")
+    fs.writeFileSync(
+      entryPath,
+      [
+        "// AUTO-GENERATED by @omg-dev/vite-plugin. Do not edit.",
+        'import { StrictMode } from "react"',
+        'import { renderToString } from "react-dom/server"',
+        'import App from "../src/App.tsx"',
+        "export function render() {",
+        "  return renderToString(<StrictMode><App /></StrictMode>)",
+        "}",
+        "",
+      ].join("\n"),
+    )
+
+    // Use the app's own Vite config (react plugin, @/ alias, @omg-dev/vite-plugin)
+    // so SSR module resolution matches the client build. middlewareMode = no
+    // port binding; the vibes plugin's WS upgrade is guarded on httpServer (null
+    // here), so nothing tries to listen.
+    const { createServer } = await import("vite")
+    const vite = await createServer({
+      root,
+      appType: "custom",
+      server: { middlewareMode: true, hmr: false },
+      logLevel: "error",
+    })
+    try {
+      const mod = (await vite.ssrLoadModule("/.vibes/prerender.entry.tsx")) as {
+        render: () => string
+      }
+      const html = mod.render()
+      if (!html || !html.trim()) {
+        return done(log, { status: "skipped", reason: "empty render output" })
+      }
+      const out = shell.replace(ROOT_MARKER, `<div id="root">${html}</div>`)
+      fs.writeFileSync(htmlPath, out)
+      return done(log, { status: "baked", bytes: html.length })
+    } finally {
+      await vite.close()
+      fs.rmSync(entryPath, { force: true })
+    }
+  } catch (err) {
+    // Fail-soft: keep the un-prerendered shell, report why.
+    return done(log, { status: "skipped", reason: String(err).split("\n")[0] })
+  }
+}
+
+function done(log: (m: string) => void, r: PrerenderResult): PrerenderResult {
+  if (r.status === "baked") {
+    log(`prerender: ✓ baked app root into dist/index.html (+${r.bytes}B static HTML)`)
+  } else {
+    log(`prerender: SPA shell kept (no prerender) — ${r.reason}`)
+  }
+  return r
+}

package/src/pwa.test.ts

@@ -0,0 +1,138 @@
+import { describe, expect, test } from "bun:test"
+import {
+  APPLE_TOUCH_ICON,
+  MANIFEST_FILE,
+  PWA_ICONS,
+  buildWebManifest,
+  injectPwaTags,
+  isAppEntry,
+  resolvePwaConfig,
+} from "./pwa.ts"
+
+const HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <title>Tide Tracker</title>
+  </head>
+  <body><div id="root"></div></body>
+</html>`
+
+describe("resolvePwaConfig", () => {
+  test("name from <title>, 12-char short_name, default colors", () => {
+    const cfg = resolvePwaConfig(undefined, HTML)
+    expect(cfg.name).toBe("Tide Tracker")
+    expect(cfg.shortName).toBe("Tide Tracker") // exactly 12 chars
+    expect(cfg.themeColor).toBe("#ffffff")
+    expect(cfg.backgroundColor).toBe("#ffffff")
+    expect(cfg.autoPrompt).toBe(true)
+  })
+
+  test("long titles truncate short_name without trailing space", () => {
+    const cfg = resolvePwaConfig(undefined, "<title>My Wonderful Recipe Box</title>")
+    expect(cfg.shortName).toBe("My Wonderful")
+    expect(cfg.shortName.length).toBeLessThanOrEqual(12)
+  })
+
+  test("explicit options win over parsed html", () => {
+    const cfg = resolvePwaConfig(
+      { name: "Custom", themeColor: "#112233", autoPrompt: false },
+      HTML,
+    )
+    expect(cfg.name).toBe("Custom")
+    expect(cfg.shortName).toBe("Custom")
+    expect(cfg.themeColor).toBe("#112233")
+    expect(cfg.backgroundColor).toBe("#112233")
+    expect(cfg.autoPrompt).toBe(false)
+  })
+
+  test("picks up an existing theme-color meta", () => {
+    const cfg = resolvePwaConfig(
+      undefined,
+      `<title>X</title><meta name="theme-color" content="#15110D">`,
+    )
+    expect(cfg.themeColor).toBe("#15110D")
+  })
+
+  test("empty title falls back to App", () => {
+    const cfg = resolvePwaConfig(undefined, "<title></title>")
+    expect(cfg.name).toBe("App")
+  })
+})
+
+describe("buildWebManifest", () => {
+  test("emits only icons that exist", () => {
+    const cfg = resolvePwaConfig(undefined, HTML)
+    const manifest = JSON.parse(buildWebManifest(cfg, ["icons/pwa-192x192.png"]))
+    expect(manifest.display).toBe("standalone")
+    expect(manifest.start_url).toBe("/")
+    expect(manifest.icons).toEqual([
+      { src: "/icons/pwa-192x192.png", sizes: "192x192", type: "image/png" },
+    ])
+  })
+
+  test("full icon set includes maskable purpose", () => {
+    const cfg = resolvePwaConfig(undefined, HTML)
+    const all = PWA_ICONS.map((i) => i.file)
+    const manifest = JSON.parse(buildWebManifest(cfg, all))
+    expect(manifest.icons).toHaveLength(3)
+    expect(manifest.icons[2].purpose).toBe("maskable")
+  })
+})
+
+describe("injectPwaTags", () => {
+  const cfg = resolvePwaConfig(undefined, HTML)
+
+  test("injects manifest link, capable metas, apple-touch icon, theme-color", () => {
+    const out = injectPwaTags(HTML, cfg, { hasAppleIcon: true })
+    expect(out).toContain(`<link rel="manifest" href="/${MANIFEST_FILE}">`)
+    expect(out).toContain(`<meta name="mobile-web-app-capable" content="yes">`)
+    expect(out).toContain(`<meta name="apple-mobile-web-app-capable" content="yes">`)
+    expect(out).toContain(`<meta name="apple-mobile-web-app-title" content="Tide Tracker">`)
+    expect(out).toContain(`<link rel="apple-touch-icon" href="/${APPLE_TOUCH_ICON}">`)
+    expect(out).toContain(`<meta name="theme-color" content="#ffffff">`)
+    // injected inside <head>
+    expect(out.indexOf("</head>")).toBeGreaterThan(out.indexOf("rel=\"manifest\""))
+  })
+
+  test("no apple-touch link when the icon file is missing", () => {
+    const out = injectPwaTags(HTML, cfg, { hasAppleIcon: false })
+    expect(out).not.toContain("apple-touch-icon")
+  })
+
+  test("leaves apps with their own manifest link untouched", () => {
+    const html = `<head><link rel="manifest" href="/mine.webmanifest"><title>X</title></head>`
+    expect(injectPwaTags(html, cfg, { hasAppleIcon: true })).toBe(html)
+  })
+
+  test("respects a user manifest href", () => {
+    const out = injectPwaTags(HTML, cfg, { hasAppleIcon: false, manifestHref: "/manifest.json" })
+    expect(out).toContain(`<link rel="manifest" href="/manifest.json">`)
+  })
+
+  test("does not duplicate an existing theme-color meta", () => {
+    const html = `<head><meta name="theme-color" content="#000"><title>X</title></head>`
+    const out = injectPwaTags(html, cfg, { hasAppleIcon: false })
+    expect(out.match(/theme-color/g)).toHaveLength(1)
+  })
+
+  test("escapes quotes in app names", () => {
+    const evil = resolvePwaConfig(undefined, `<title>A"B</title>`)
+    const out = injectPwaTags(HTML, evil, { hasAppleIcon: false })
+    expect(out).toContain(`content="A&quot;B"`)
+  })
+})
+
+describe("isAppEntry", () => {
+  test("matches src/main.tsx under root", () => {
+    expect(isAppEntry("/app/src/main.tsx", "/app")).toBe(true)
+    expect(isAppEntry("/app/src/main.ts?v=123", "/app")).toBe(true)
+    expect(isAppEntry("/app/src/main.jsx", "/app")).toBe(true)
+  })
+
+  test("rejects other files, node_modules, and foreign roots", () => {
+    expect(isAppEntry("/app/src/App.tsx", "/app")).toBe(false)
+    expect(isAppEntry("/app/node_modules/x/src/main.tsx", "/app")).toBe(false)
+    expect(isAppEntry("/elsewhere/src/main.tsx", "/app")).toBe(false)
+  })
+})

package/src/pwa.ts

@@ -0,0 +1,132 @@
+// PWA installability for published apps (default ON; vibes({ pwa: false })
+// to opt out). At build time this:
+//   1. emits /manifest.webmanifest (name from <title>, standalone display)
+//   2. injects manifest/apple-touch/meta tags into index.html
+//   3. appends `import "@omg-dev/pwa/auto"` to the app entry — the soft
+//      install prompt that mounts outside the app's React tree
+//
+// Dev (`command === "serve"`) is untouched: the preview always runs inside
+// the dashboard iframe where installing makes no sense.
+//
+// Icons are NOT generated here — the template ships default PNGs under
+// public/icons/ and the build agent is instructed to replace them. Manifest
+// entries are emitted only for icon files that actually exist, so an app
+// missing them still gets a valid (if degraded) manifest instead of 404ing
+// icon links.
+
+export interface PwaOptions {
+  /** Manifest `name` (default: the app's <title>). */
+  name?: string
+  /** Manifest `short_name` (default: `name` truncated to 12 chars). */
+  shortName?: string
+  /** Manifest + <meta> theme color (default: existing theme-color meta, else "#ffffff"). */
+  themeColor?: string
+  /** Manifest background_color (default: themeColor). */
+  backgroundColor?: string
+  /** Inject the @omg-dev/pwa/auto soft install prompt (default: true). */
+  autoPrompt?: boolean
+}
+
+export interface ResolvedPwaConfig {
+  name: string
+  shortName: string
+  themeColor: string
+  backgroundColor: string
+  autoPrompt: boolean
+}
+
+/** Icon set contract shared with templates/react-ts/public/icons/. */
+export const PWA_ICONS = [
+  { file: "icons/pwa-192x192.png", sizes: "192x192", purpose: "any" },
+  { file: "icons/pwa-512x512.png", sizes: "512x512", purpose: "any" },
+  { file: "icons/pwa-512x512-maskable.png", sizes: "512x512", purpose: "maskable" },
+] as const
+
+export const APPLE_TOUCH_ICON = "icons/apple-touch-icon.png"
+export const MANIFEST_FILE = "manifest.webmanifest"
+
+export function resolvePwaConfig(opts: PwaOptions | undefined, indexHtml: string): ResolvedPwaConfig {
+  const title = /<title[^>]*>([^<]*)<\/title>/i.exec(indexHtml)?.[1]?.trim()
+  const metaTheme = /<meta[^>]+name=["']theme-color["'][^>]*content=["']([^"']+)["']/i.exec(indexHtml)?.[1]
+    ?? /<meta[^>]+content=["']([^"']+)["'][^>]*name=["']theme-color["']/i.exec(indexHtml)?.[1]
+  const name = opts?.name ?? (title || "App")
+  const themeColor = opts?.themeColor ?? metaTheme ?? "#ffffff"
+  return {
+    name,
+    shortName: opts?.shortName ?? (name.length > 12 ? name.slice(0, 12).trimEnd() : name),
+    themeColor,
+    backgroundColor: opts?.backgroundColor ?? themeColor,
+    autoPrompt: opts?.autoPrompt !== false,
+  }
+}
+
+export function buildWebManifest(cfg: ResolvedPwaConfig, availableIconFiles: string[]): string {
+  const available = new Set(availableIconFiles)
+  const icons = PWA_ICONS.filter((i) => available.has(i.file)).map((i) => ({
+    src: `/${i.file}`,
+    sizes: i.sizes,
+    type: "image/png",
+    ...(i.purpose === "maskable" ? { purpose: "maskable" } : {}),
+  }))
+  return JSON.stringify(
+    {
+      name: cfg.name,
+      short_name: cfg.shortName,
+      start_url: "/",
+      scope: "/",
+      display: "standalone",
+      background_color: cfg.backgroundColor,
+      theme_color: cfg.themeColor,
+      icons,
+    },
+    null,
+    2,
+  )
+}
+
+function escapeAttr(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/"/g, "&quot;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+}
+
+/** Inject PWA tags into built index.html. Idempotent: an app that already
+ * declares a manifest link (hand-rolled PWA) is left entirely alone. */
+export function injectPwaTags(
+  html: string,
+  cfg: ResolvedPwaConfig,
+  opts: { hasAppleIcon: boolean; manifestHref?: string },
+): string {
+  if (/rel=["']manifest["']/i.test(html)) return html
+  const tags: string[] = [
+    `<link rel="manifest" href="${opts.manifestHref ?? `/${MANIFEST_FILE}`}">`,
+    `<meta name="mobile-web-app-capable" content="yes">`,
+  ]
+  if (!/name=["']apple-mobile-web-app-capable["']/i.test(html)) {
+    tags.push(`<meta name="apple-mobile-web-app-capable" content="yes">`)
+  }
+  if (!/name=["']apple-mobile-web-app-title["']/i.test(html)) {
+    tags.push(`<meta name="apple-mobile-web-app-title" content="${escapeAttr(cfg.shortName)}">`)
+  }
+  if (opts.hasAppleIcon && !/rel=["']apple-touch-icon["']/i.test(html)) {
+    tags.push(`<link rel="apple-touch-icon" href="/${APPLE_TOUCH_ICON}">`)
+  }
+  if (!/name=["']theme-color["']/i.test(html)) {
+    tags.push(`<meta name="theme-color" content="${escapeAttr(cfg.themeColor)}">`)
+  }
+  const block = `\n    ${tags.join("\n    ")}`
+  return /<\/head>/i.test(html)
+    ? html.replace(/<\/head>/i, `${block}\n  </head>`)
+    : block + html
+}
+
+/** True when `id` is the app's client entry (src/main.*) — the injection
+ * point for the auto install prompt import. */
+export function isAppEntry(id: string, root: string): boolean {
+  const clean = id.split("?")[0]
+  if (!clean.startsWith(root)) return false
+  if (clean.includes("node_modules")) return false
+  return /[\\/]src[\\/]main\.(tsx|ts|jsx|js)$/.test(clean)
+}

package/src/scanner-billing.ts

@@ -0,0 +1,127 @@
+import fs from "node:fs"
+import path from "node:path"
+
+// ── scanBilling ────────────────────────────────────────────────────────────
+//
+// Discovers the app's @omg-dev/billing declaration the same way scanFunctions
+// discovers routes: walk the source tree, find the module that calls
+// `defineBilling(...)`, import it, and serialize the resulting Billing object
+// to the canonical catalog JSON the Go enforcer reads (deploys.catalog_json).
+//
+// Convention is intentionally loose — the config can live anywhere (the
+// vibes-pricing skill writes src/billing.ts, but root-level pricing.ts etc.
+// are equally valid) — so we SCAN rather than hard-code a path. We only look
+// at .ts files: a .tsx is almost certainly a component and importing it at
+// build time could trigger DOM/React side effects, whereas a billing config
+// is pure data.
+
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".vibes",
+  "dist",
+  ".git",
+  "coverage",
+  ".next",
+  "functions", // route handlers, not billing config
+])
+
+// A defineBilling() result (see @omg-dev/billing Billing interface). Duck-typed —
+// instance identity across module copies doesn't matter, serializeCatalog only
+// reads plain properties.
+function isBillingObject(v: unknown): boolean {
+  if (!v || typeof v !== "object") return false
+  const o = v as Record<string, unknown>
+  const provider = o.provider as Record<string, unknown> | undefined
+  return (
+    !!provider &&
+    typeof provider.name === "string" &&
+    Array.isArray(o.plans) &&
+    Array.isArray(o.features) &&
+    !!o.credit
+  )
+}
+
+/** Recursively collect .ts files whose source calls defineBilling(...). */
+function findBillingModules(dir: string, out: string[]): void {
+  let entries: fs.Dirent[]
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true })
+  } catch {
+    return
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.name !== ".") continue
+    const full = path.join(dir, entry.name)
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name)) continue
+      findBillingModules(full, out)
+      continue
+    }
+    if (!entry.name.endsWith(".ts") || entry.name.endsWith(".d.ts")) continue
+    let source: string
+    try {
+      source = fs.readFileSync(full, "utf-8")
+    } catch {
+      continue
+    }
+    // Cheap pre-filter — only import modules that actually declare billing.
+    if (/\bdefineBilling\s*\(/.test(source)) out.push(full)
+  }
+}
+
+export interface FoundBilling {
+  module: string
+  exportName: string
+  /** The serialized canonical catalog JSON (deploys.catalog_json contract). */
+  catalogJson: string
+}
+
+/**
+ * Locate + serialize the app's billing catalog. Returns null when the app
+ * declares no billing. Throws (fail-loud, like defineBilling itself) when the
+ * declaration is invalid or ambiguous — a broken catalog must fail the BUILD,
+ * never ship a deploy the enforcer then chokes on at runtime.
+ */
+export async function scanBilling(root: string): Promise<FoundBilling | null> {
+  const candidates: string[] = []
+  findBillingModules(root, candidates)
+  if (candidates.length === 0) return null
+
+  // Import each candidate and collect every export that is a Billing object.
+  // Importing the module also runs defineBilling's own validation, so an
+  // invalid config throws here and fails the build.
+  const found: { module: string; exportName: string; billing: unknown }[] = []
+  for (const mod of candidates) {
+    const ns = (await import(mod)) as Record<string, unknown>
+    for (const [exportName, value] of Object.entries(ns)) {
+      if (isBillingObject(value)) found.push({ module: mod, exportName, billing: value })
+    }
+  }
+
+  if (found.length === 0) return null
+
+  // Resolve ambiguity deterministically: prefer the conventional `billing`
+  // named export, then a default export, otherwise require exactly one.
+  let chosen = found.length === 1 ? found[0] : undefined
+  if (!chosen) chosen = found.find((f) => f.exportName === "billing")
+  if (!chosen) chosen = found.find((f) => f.exportName === "default")
+  if (!chosen) {
+    const list = found.map((f) => `${path.relative(root, f.module)}#${f.exportName}`).join(", ")
+    throw new Error(
+      `@omg-dev/vite-plugin: multiple billing declarations found ([${list}]); ` +
+        `export exactly one as \`billing\` so the catalog is unambiguous`,
+    )
+  }
+
+  // serializeCatalog lives in @omg-dev/billing/catalog; resolve it from the app's
+  // deps (the app necessarily depends on @omg-dev/billing to have called
+  // defineBilling). Done lazily so apps with no billing never need the dep.
+  const { serializeCatalog } = (await import("@omg-dev/billing/catalog")) as {
+    serializeCatalog: (b: unknown) => string
+  }
+  return {
+    module: chosen.module,
+    exportName: chosen.exportName,
+    catalogJson: serializeCatalog(chosen.billing),
+  }
+}

package/src/scanner-triggers.ts

@@ -0,0 +1,15 @@
+// Trigger scanner — moved to @omg-dev/server (src/trigger-scan.ts) so non-vite
+// hosts (control-plane container, self-host bundles) can scan + write
+// .vibes/triggers.json at boot. This module stays as a re-export so the
+// plugin's internal imports (codegen.ts, build.ts) keep working unchanged.
+//
+// Import the standalone subpath, NOT the main bundle: @omg-dev/server's index
+// top-level-imports bun:sqlite and cannot load under a Node-run vite build.
+// trigger-scan.mjs is pure node:fs/path.
+export {
+  scanTriggers,
+  extractTriggers,
+  TriggerScanError,
+  type ScannedTrigger,
+  type TriggerKind,
+} from "@omg-dev/server/trigger-scan"

package/src/scanner-workflows.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from "vitest"
+import { extractWorkflows, WorkflowScanError } from "./scanner-workflows.ts"
+
+describe("extractWorkflows", () => {
+  it("extracts a basic workflow declaration", () => {
+    const src = `
+import { workflow } from "@omg-dev/server"
+export const onboarding = workflow("onboarding", async (step, payload) => {
+  return 1
+})
+`
+    const out = extractWorkflows(src, "/app/functions/flows.ts", "flows")
+    expect(out).toEqual([
+      {
+        name: "onboarding",
+        handler: "flows.onboarding",
+        module: "/app/functions/flows.ts",
+        exportName: "onboarding",
+      },
+    ])
+  })
+
+  it("extracts multiple workflows and tolerates type annotations", () => {
+    const src = `
+export const a = workflow("flowA", async (step) => {})
+export const b: SomeType = workflow('flow_b', handler)
+`
+    const out = extractWorkflows(src, "/f/x.ts", "x")
+    expect(out.map((w) => w.name)).toEqual(["flowA", "flow_b"])
+  })
+
+  it("throws on dashes in names (Restate handler-name contract)", () => {
+    const src = `export const w = workflow("has-dash", fn)`
+    expect(() => extractWorkflows(src, "/f/x.ts", "x")).toThrow(WorkflowScanError)
+  })
+
+  it("ignores commented-out declarations", () => {
+    const src = `
+// export const dead = workflow("dead", async () => {})
+/* export const dead2 = workflow("dead2", fn) */
+export const live = workflow("live", fn)
+`
+    const out = extractWorkflows(src, "/f/x.ts", "x")
+    expect(out.map((w) => w.name)).toEqual(["live"])
+  })
+
+  it("throws on a non-literal name", () => {
+    const src = `export const w = workflow(dynamicName, fn)`
+    expect(() => extractWorkflows(src, "/f/x.ts", "x")).toThrow(WorkflowScanError)
+  })
+
+  it("throws on a template-literal name", () => {
+    const src = "export const w = workflow(`tpl-${x}`, fn)"
+    expect(() => extractWorkflows(src, "/f/x.ts", "x")).toThrow(WorkflowScanError)
+  })
+
+  it("throws on an invalid name charset", () => {
+    const src = `export const w = workflow("has space", fn)`
+    expect(() => extractWorkflows(src, "/f/x.ts", "x")).toThrow(WorkflowScanError)
+  })
+
+  it("does not match cron/on/other call sites", () => {
+    const src = `
+export const c = cron("0 3 * * *", fn)
+export const o = on("user.signup", fn)
+`
+    expect(extractWorkflows(src, "/f/x.ts", "x")).toEqual([])
+  })
+})