@omg-dev/server 0.4.27 → 0.4.29

package/dist/index.mjs

@@ -953,7 +953,7 @@ function openDb(path) {
 let _dbInstance = null;
 const dbProxy = new Proxy({}, { get(_target, prop) {
 	if (!_dbInstance) throw new Error(`[vibes] db not initialized. Call createVibesServer() before using db.`);
-	return _dbInstance[prop];
+	return Reflect.get(_dbInstance, prop);
 } });
 function setDbInstance(instance) {
 	_dbInstance = instance;
@@ -1496,9 +1496,10 @@ async function registerTriggers(entries) {
 			storageHookHandlers.get(e.kind).add(e.handler);
 		}
 	}
-	const inProcessCron = vibesMode$1() === "dev" || cronDriver() === "in-process";
+	const inBuild = inBuildMode();
+	const inProcessCron = !inBuild && (vibesMode$1() === "dev" || cronDriver() === "in-process");
 	if (inProcessCron) scheduleAllCronInProcess();
-	console.log(`[vibes:triggers] registered ${entries.length} trigger(s) — mode=${vibesMode$1()}, cron=${inProcessCron ? "in-process" : "orchestrator"}`);
+	console.log(`[vibes:triggers] registered ${entries.length} trigger(s) — mode=${vibesMode$1()}, cron=${inBuild ? "unarmed (build)" : inProcessCron ? "in-process" : "orchestrator"}`);
 }
 /** Snapshot of the registry — used by the in-dev Inspect endpoints. */
 function listTriggers() {
@@ -1907,6 +1908,9 @@ function vibesMode$1() {
 	_vibesMode$1 = ((typeof process !== "undefined" ? process.env?.VIBES_MODE : void 0) ?? "") === "dev" ? "dev" : "prod";
 	return _vibesMode$1;
 }
+function inBuildMode() {
+	return (typeof process !== "undefined" ? process.env?.VIBES_BUILD : void 0) === "1";
+}
 function devInspectTriggers() {
 	return Array.from(triggerRegistry.values()).map(({ entry }, i) => ({
 		id: `trg_dev_${i}_${entry.handler}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omg-dev/server",
-  "version": "0.4.27",
+  "version": "0.4.29",
   "type": "module",
   "exports": {
     ".": {
@@ -14,13 +14,13 @@
   },
   "dependencies": {
     "@restatedev/restate-sdk": "1.14.5",
-    "@omg-dev/auth": "0.4.27",
-    "@omg-dev/schema": "0.4.27",
-    "@omg-dev/stream": "0.4.27",
+    "@omg-dev/auth": "0.4.29",
+    "@omg-dev/schema": "0.4.29",
+    "@omg-dev/stream": "0.4.29",
     "web-push": "^3.6.7"
   },
   "scripts": {
-    "build": "vp pack src/index.ts src/trigger-scan.ts",
+    "build": "vp pack src/index.ts src/trigger-scan.ts --no-dts",
     "test": "vp test run"
   },
   "license": "MIT",

package/src/auto-crud.ts

@@ -9,6 +9,7 @@
 // owned by someone else" the same (404) to avoid leaking row existence.
 
 import type { Schema, FieldType, CollectionConfig } from "@omg-dev/schema"
+import type { SQLQueryBindings } from "bun:sqlite"
 import { getDbInstance } from "./db.ts"
 import { invalidate } from "./broker.ts"
 import { notifyRowChange } from "./subscriptions.ts"
@@ -127,7 +128,7 @@ function makeCreateHandler(
 
     const cols = Object.keys(record)
     const placeholders = cols.map(() => "?").join(", ")
-    const values = Object.values(record)
+    const values = Object.values(record) as SQLQueryBindings[]
     db.raw().prepare(`INSERT INTO ${name} (${cols.join(", ")}) VALUES (${placeholders})`).run(...values)
 
     invalidate(name)
@@ -171,7 +172,7 @@ function makeUpdateHandler(
     updates.updated_at = new Date().toISOString()
 
     const setClauses = Object.keys(updates).map(k => `${k} = ?`).join(", ")
-    const values = [...Object.values(updates), params.id]
+    const values = [...Object.values(updates), params.id] as SQLQueryBindings[]
     db.raw().prepare(`UPDATE ${name} SET ${setClauses} WHERE id = ?`).run(...values)
 
     const merged = { ...existing, ...updates }

package/src/db.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite"
+import type { SQLQueryBindings } from "bun:sqlite"
 import { ctxStore } from "./ctx.ts"
 import { invalidate } from "./broker.ts"
 import { notifyRowChange } from "./subscriptions.ts"
@@ -83,7 +84,7 @@ export function openDb(path: string): VibesDb {
   const db: VibesDb = {
     async getAll(table: string, opts: GetAllOpts = {}): Promise<Record<string, unknown>[]> {
       const conditions: string[] = []
-      const params: unknown[] = []
+      const params: SQLQueryBindings[] = []
 
       if (isScoped(table)) {
         const owner = getOwner()
@@ -119,7 +120,7 @@ export function openDb(path: string): VibesDb {
 
     async get(table: string, id: string): Promise<Record<string, unknown> | null> {
       const conditions = ["id = ?"]
-      const params: unknown[] = [id]
+      const params: SQLQueryBindings[] = [id]
 
       if (isScoped(table)) {
         const owner = getOwner()
@@ -152,7 +153,7 @@ export function openDb(path: string): VibesDb {
 
       const columns = Object.keys(record)
       const placeholders = columns.map(() => "?").join(", ")
-      const values = Object.values(record)
+      const values = Object.values(record) as SQLQueryBindings[]
 
       const sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`
       bun.prepare(sql).run(...values)
@@ -174,7 +175,7 @@ export function openDb(path: string): VibesDb {
 
       const updates = { ...stripReserved(data), updated_at: now() }
       const setClauses = Object.keys(updates).map(k => `${k} = ?`).join(", ")
-      const values = [...Object.values(updates), id]
+      const values = [...Object.values(updates), id] as SQLQueryBindings[]
 
       // Belt-and-braces: db.get already filtered by _owner for scoped tables,
       // but include the same predicate in the UPDATE WHERE so the mutation
@@ -203,7 +204,7 @@ export function openDb(path: string): VibesDb {
       if (!existing) return false
 
       const conditions = ["id = ?"]
-      const params: unknown[] = [id]
+      const params: SQLQueryBindings[] = [id]
 
       if (isScoped(table)) {
         const owner = getOwner()
@@ -245,7 +246,7 @@ export const dbProxy = new Proxy({} as VibesDb, {
         `[vibes] db not initialized. Call createVibesServer() before using db.`
       )
     }
-    return (_dbInstance as Record<string, unknown>)[prop]
+    return Reflect.get(_dbInstance, prop)
   },
 })
 

package/src/notifications.ts

@@ -1,4 +1,5 @@
 import { collection, defineSchema, fields, type Schema } from "@omg-dev/schema"
+import type { SQLQueryBindings } from "bun:sqlite"
 import { ctx } from "./ctx.ts"
 import { getDbInstance, type VibesDb } from "./db.ts"
 import { invalidate } from "./broker.ts"
@@ -204,7 +205,7 @@ function patchRaw(db: VibesDb, table: string, id: string, patch: Record<string,
   const cols = Object.keys(write)
   db.raw()
     .prepare(`UPDATE ${table} SET ${cols.map((c) => `${c} = ?`).join(", ")} WHERE id = ?`)
-    .run(...cols.map((c) => write[c]), id)
+    .run(...cols.map((c) => write[c]) as SQLQueryBindings[], id)
   const after = { ...before, ...write }
   invalidate(table)
   void notifyRowChange(table, "update", before, after)

package/src/predicate.ts

@@ -18,6 +18,8 @@
 // so the WHERE clause stays interpolation-safe. Values are always bound as
 // parameters — never string-concatenated.
 
+import type { SQLQueryBindings } from "bun:sqlite"
+
 // ── Types ────────────────────────────────────────────────────────────────────
 
 export type Literal = string | number | boolean | null
@@ -175,16 +177,16 @@ export interface CompiledSql {
   /** Parenthesized SQL fragment safe to AND with other WHERE conditions. */
   sql: string
   /** Bound parameters in left-to-right order. */
-  params: unknown[]
+  params: SQLQueryBindings[]
 }
 
 export function compileToSql(pred: Predicate): CompiledSql {
-  const params: unknown[] = []
+  const params: SQLQueryBindings[] = []
   const sql = emitSql(pred, params)
   return { sql, params }
 }
 
-function emitSql(p: Predicate, params: unknown[]): string {
+function emitSql(p: Predicate, params: SQLQueryBindings[]): string {
   switch (p.op) {
     case "and":
       return `(${p.clauses.map(c => emitSql(c, params)).join(" AND ")})`
@@ -226,7 +228,7 @@ function emitSql(p: Predicate, params: unknown[]): string {
 
 // SQLite stores booleans as INTEGER 0/1 — coerce on the way to a bound param
 // so an `eq done true` predicate hits a `done = 1` row.
-function encodeLiteral(v: Literal): unknown {
+function encodeLiteral(v: Literal): SQLQueryBindings {
   if (typeof v === "boolean") return v ? 1 : 0
   return v
 }

package/src/subscriptions.ts

@@ -21,6 +21,7 @@
 // package in dev to that shape.
 
 import type { Schema } from "@omg-dev/schema"
+import type { SQLQueryBindings } from "bun:sqlite"
 import { getDbInstance } from "./db.ts"
 import { decodeRow } from "./codec.ts"
 import {
@@ -349,7 +350,7 @@ export function notifyRowChange(
       ? (newRowRaw?._owner as string | undefined) ?? (oldRowRaw?._owner as string | undefined) ?? null
       : null
 
-  const pending: Promise<void>[] = []
+  const pending: Promise<boolean>[] = []
   // Snapshot to a stable array — sends may evict clients mid-iteration.
   const targets = Array.from(set)
   for (const client of targets) {
@@ -499,7 +500,7 @@ async function sendSnapshot(client: SubClient, sub: ClientSub): Promise<void> {
 
   const scoped = col.scope === "user"
   const conditions: string[] = []
-  const params: unknown[] = []
+  const params: SQLQueryBindings[] = []
 
   if (scoped) {
     if (!client.ctx.userId) {

package/src/test/build-mode-cron.test.ts

@@ -0,0 +1,80 @@
+// Regression test for the vibes-build hang (confirmed: `[vibes-build] done.`
+// prints, process never exits when the project declares cron()/on()).
+//
+// Root cause: registerTriggers() arms an in-process setTimeout chain for
+// every cron() handler whenever vibesMode()==="dev" or cronDriver()===
+// "in-process" — including when createVibesServer() is constructed by the
+// vibes vite-plugin's configureServer hook, which prerenderApp() (part of
+// `vibes-build`) triggers indirectly via a nested Vite dev server. Those
+// timers keep the event loop alive forever with no caller left to clear
+// them, since a build process has no request loop to eventually close it.
+//
+// This can only be observed as a live-process behavior (does the process
+// exit on its own?), not through a return-value assertion on
+// registerTriggers() — so this test spawns a real Bun subprocess and checks
+// whether it terminates within a bounded window.
+
+import { describe, expect, test } from "bun:test"
+import fs from "node:fs"
+import os from "node:os"
+import path from "node:path"
+
+const triggersModulePath = path.join(import.meta.dir, "..", "triggers.ts")
+
+function writeRegisterScript(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "vibes-build-mode-cron-"))
+  const file = path.join(dir, "register.ts")
+  fs.writeFileSync(
+    file,
+    [
+      `import { registerTriggers } from ${JSON.stringify(triggersModulePath)}`,
+      "await registerTriggers([",
+      '  { handler: "trg.tick", kind: "cron", key: "* * * * *", module: "/dev/null", exportName: "tick", mod: { tick: async () => {} } },',
+      '  { handler: "trg.onEvt", kind: "on", key: "some.topic", module: "/dev/null", exportName: "onEvt", mod: { onEvt: async () => {} } },',
+      "])",
+      'console.log("REGISTERED")',
+      "",
+    ].join("\n"),
+  )
+  return file
+}
+
+// Runs `script` in a fresh Bun subprocess with `env` merged over the current
+// process env. Resolves `{ exited: true }` if the process exits within
+// `timeoutMs` on its own, or `{ exited: false }` (after force-killing it) if
+// it's still alive at the deadline — the exact symptom of the original bug.
+async function runAndWaitForExit(
+  script: string,
+  env: Record<string, string>,
+  timeoutMs: number,
+): Promise<{ exited: boolean }> {
+  const proc = Bun.spawn(["bun", "run", script], {
+    env: { ...process.env, ...env },
+    stdout: "pipe",
+    stderr: "pipe",
+  })
+  let timedOut = false
+  const timer = setTimeout(() => {
+    timedOut = true
+    proc.kill()
+  }, timeoutMs)
+  await proc.exited
+  clearTimeout(timer)
+  return { exited: !timedOut }
+}
+
+describe("registerTriggers build-mode cron gating", () => {
+  test("VIBES_BUILD=1: a cron()+on() project terminates on its own", async () => {
+    const script = writeRegisterScript()
+    const { exited } = await runAndWaitForExit(script, { VIBES_BUILD: "1", VIBES_MODE: "dev" }, 8000)
+    expect(exited).toBe(true)
+  }, 15000)
+
+  test("sanity: without VIBES_BUILD, dev-mode cron is still armed (stays alive)", async () => {
+    // Mirrors the fixed case above to prove the guard is scoped to build
+    // mode only — normal `bun dev` cron scheduling must be unaffected.
+    const script = writeRegisterScript()
+    const { exited } = await runAndWaitForExit(script, { VIBES_MODE: "dev" }, 2000)
+    expect(exited).toBe(false)
+  }, 15000)
+})

package/src/triggers.ts

@@ -242,12 +242,20 @@ export async function registerTriggers(entries: TriggerEntry[]): Promise<void> {
     }
   }
   void registeredFirstTime // suppress unused — kept for future HMR diff
-  const inProcessCron = vibesMode() === "dev" || cronDriver() === "in-process"
+  // vibes-build sets VIBES_BUILD=1 for its whole process, including the
+  // nested Vite dev server it spins up for prerender SSG. A build is not a
+  // runtime — nothing should ever arm a live setTimeout chain there, or the
+  // process hangs forever after writing its artifacts (confirmed hang: cron
+  // schedulers keep the event loop open with no caller left to clear them).
+  const inBuild = inBuildMode()
+  const inProcessCron = !inBuild && (vibesMode() === "dev" || cronDriver() === "in-process")
   if (inProcessCron) {
     scheduleAllCronInProcess()
   }
   console.log(
-    `[vibes:triggers] registered ${entries.length} trigger(s) — mode=${vibesMode()}, cron=${inProcessCron ? "in-process" : "orchestrator"}`,
+    `[vibes:triggers] registered ${entries.length} trigger(s) — mode=${vibesMode()}, cron=${
+      inBuild ? "unarmed (build)" : inProcessCron ? "in-process" : "orchestrator"
+    }`,
   )
 }
 
@@ -810,6 +818,15 @@ function vibesMode(): "dev" | "prod" {
   return _vibesMode
 }
 
+// Set for the whole lifetime of `vibes-build` (packages/vite-plugin/src/build.ts).
+// A build process has no caller left to clear timers once it "finishes" —
+// so cron must never be armed in-process while this is set, however
+// createVibesServer() got invoked (directly, or via prerender's nested dev
+// server).
+function inBuildMode(): boolean {
+  return (typeof process !== "undefined" ? process.env?.VIBES_BUILD : undefined) === "1"
+}
+
 // ── Dev Inspect data accessors ───────────────────────────────────────────────
 //
 // In dev mode, the dashboard's Inspect tabs read the in-memory rings