@gencow/core 0.1.28 → 0.1.29

package/src/reactive-realtime.ts

@@ -0,0 +1,267 @@
+import type { WSContext } from "hono/ws";
+import type { GencowCtx, RealtimeCtx, RealtimeNotifyEvent } from "./context.js";
+import { queryRegistry } from "./reactive-query.js";
+import type { QueryDef } from "./reactive-query-types.js";
+
+// ─── WS / subscription + subscription-key helpers (globalThis) ─
+//
+// globalThis 기반 — 서버 번들(인라인)과 node_modules/@gencow/core 양쪽에서
+// 동일한 레지스트리 인스턴스를 공유. Dual-Module Registry 버그 방지.
+// See: docs/analysis/analysis-dual-module-registry.md
+
+declare global {
+  var __gencow_subscribers: Map<string, Set<WSContext>>;
+  var __gencow_connectedClients: Set<WSContext>;
+}
+
+if (!globalThis.__gencow_subscribers) globalThis.__gencow_subscribers = new Map();
+if (!globalThis.__gencow_connectedClients) globalThis.__gencow_connectedClients = new Set();
+
+export const subscribers = globalThis.__gencow_subscribers;
+
+/**
+ * Every WebSocket client that ever establishes a connection is tracked here.
+ * This allows broadcasting invalidation events to clients that never subscribed
+ * to a specific query (e.g. the admin dashboard's raw WebSocket connection).
+ */
+export const connectedClients = globalThis.__gencow_connectedClients;
+
+const SUBSCRIPTION_KEY_SEPARATOR = "::";
+
+function normalizeForStableJson(value: unknown): unknown {
+  if (value === undefined) return undefined;
+  if (value === null) return null;
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map((item) => normalizeForStableJson(item));
+  if (typeof value === "object") {
+    const source = value as Record<string, unknown>;
+    const sorted: Record<string, unknown> = {};
+    for (const key of Object.keys(source).sort()) {
+      const normalized = normalizeForStableJson(source[key]);
+      if (normalized !== undefined) sorted[key] = normalized;
+    }
+    return sorted;
+  }
+  return value;
+}
+
+function isEmptyPlainObject(value: unknown): boolean {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+
+/** Stable subscription key for WebSocket / invalidate fanout (also used by crud for query keys). */
+export function buildQuerySubscriptionKey(queryKey: string, args?: unknown): string {
+  const normalized = normalizeForStableJson(args);
+  if (normalized === undefined || isEmptyPlainObject(normalized)) return queryKey;
+  return `${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}${JSON.stringify(normalized)}`;
+}
+
+export function subscriptionKeyMatchesQueryKey(subscriptionKey: string, queryKey: string): boolean {
+  return subscriptionKey === queryKey || subscriptionKey.startsWith(`${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}`);
+}
+
+export function subscribe(queryKey: string, ws: WSContext) {
+  connectedClients.add(ws);
+  if (!subscribers.has(queryKey)) {
+    subscribers.set(queryKey, new Set());
+  }
+  subscribers.get(queryKey)!.add(ws);
+}
+
+export function unsubscribe(ws: WSContext) {
+  connectedClients.delete(ws);
+  for (const clients of subscribers.values()) {
+    clients.delete(ws);
+  }
+}
+
+/** Register a raw WS connection without any query subscription (e.g. admin dashboard) */
+export function registerClient(ws: WSContext) {
+  connectedClients.add(ws);
+}
+
+export function deregisterClient(ws: WSContext) {
+  connectedClients.delete(ws);
+  for (const clients of subscribers.values()) {
+    clients.delete(ws);
+  }
+}
+
+function sendInvalidateToLocalSubscribers(queryKeys: string[]): void {
+  const targets = new Map<WSContext, Set<string>>();
+  for (const queryKey of queryKeys) {
+    for (const [subscriptionKey, clients] of subscribers) {
+      if (!subscriptionKeyMatchesQueryKey(subscriptionKey, queryKey)) continue;
+      for (const ws of clients) {
+        if (!targets.has(ws)) targets.set(ws, new Set());
+        targets.get(ws)!.add(subscriptionKey);
+      }
+    }
+  }
+
+  for (const [ws, keys] of targets) {
+    try {
+      ws.send(JSON.stringify({ type: "invalidate", queries: [...keys] }));
+    } catch {
+      deregisterClient(ws);
+    }
+  }
+}
+
+/**
+ * mutation 실행 시점에 생성되는 RealtimeCtx.
+ * emit(): 데이터를 직접 push (초고빈도 mutation용).
+ * refresh(): queryKey를 pending 큐에 추가, mutation 완료 후 서버가 query re-run하여 push.
+ *
+ * 💡 Batching: 같은 queryKey에 대한 emit이 50ms 내에 여러 번 호출되면
+ * 마지막 데이터만 push하여 불필요한 전송을 방지합니다.
+ *
+ * ⚠️ 매 mutation 호출마다 새로 생성해야 합니다 (debounce timer가 mutation scope에 격리).
+ *
+ * @param options.httpCallback  BaaS 모드: Platform WS Gateway에 HTTP로 emit 전달.
+ *                              설정되면 WS 직접 push 대신 이 콜백을 호출.
+ *                              로컬 dev에서는 미설정 → 기존 WS 직접 push 유지.
+ * @param options.queryMap      query 레지스트리 — refresh()에서 query handler를 찾아 re-run.
+ * @param options.buildCtxForRefresh  refresh 시 query handler에 전달할 ctx 생성 함수.
+ */
+export function buildRealtimeCtx(options?: {
+  httpCallback?: (event: RealtimeNotifyEvent) => void;
+  queryMap?: Map<string, QueryDef<any, any>>;
+  buildCtxForRefresh?: () => GencowCtx;
+}): RealtimeCtx & { _hasEmitted: boolean; _pendingRefresh: string[]; _flushRefresh: () => Promise<void> } {
+  const pendingEmits = new Map<string, { data: unknown; timer: ReturnType<typeof setTimeout> }>();
+  const _pendingRefresh: string[] = [];
+  let _hasEmitted = false;
+
+  return {
+    emit(queryKey: string, data: unknown) {
+      _hasEmitted = true;
+      // 기존 pending timer가 있으면 취소 (debounce)
+      const existing = pendingEmits.get(queryKey);
+      if (existing) clearTimeout(existing.timer);
+
+      const timer = setTimeout(() => {
+        pendingEmits.delete(queryKey);
+
+        // BaaS 모드: Platform WS Gateway에 HTTP callback
+        if (options?.httpCallback) {
+          options.httpCallback({ type: "emit", queryKey, data });
+          return;
+        }
+
+        // 로컬 dev: WS 직접 push (기존 동작)
+        const clients = subscribers.get(queryKey);
+        if (!clients || clients.size === 0) return;
+
+        const message = JSON.stringify({
+          type: "query:updated",
+          query: queryKey,
+          data,
+        });
+        for (const ws of clients) {
+          try {
+            ws.send(message);
+          } catch {
+            clients.delete(ws);
+          }
+        }
+      }, 50); // 50ms batch window
+
+      pendingEmits.set(queryKey, { data, timer });
+    },
+
+    invalidate(queryKey: string | string[]) {
+      _hasEmitted = true;
+      const queryKeys = Array.isArray(queryKey) ? [...new Set(queryKey)] : [queryKey];
+      if (options?.httpCallback) {
+        options.httpCallback({ type: "invalidate", queryKeys });
+        return;
+      }
+      sendInvalidateToLocalSubscribers(queryKeys);
+    },
+
+    refresh(queryKey: string) {
+      _hasEmitted = true; // 경고 억제
+      if (!_pendingRefresh.includes(queryKey)) {
+        _pendingRefresh.push(queryKey);
+      }
+    },
+
+    get _hasEmitted() {
+      return _hasEmitted;
+    },
+    get _pendingRefresh() {
+      return [..._pendingRefresh];
+    },
+
+    async _flushRefresh() {
+      if (_pendingRefresh.length === 0) return;
+
+      // queryMap이 없으면 refresh 동작 불가 (로그 경고)
+      const qMap = options?.queryMap ?? queryRegistry;
+
+      for (const key of _pendingRefresh) {
+        const queryDef = qMap.get(key);
+        if (!queryDef) {
+          console.warn(`[gencow] refresh("${key}"): query not found in registry. Skipping.`);
+          continue;
+        }
+        try {
+          // refresh용 ctx 생성 (mutation ctx와 동일한 DB/auth 스코프)
+          if (!options?.buildCtxForRefresh) {
+            console.warn(
+              `[gencow] ⚠️  refresh("${key}"): buildCtxForRefresh not provided. ` +
+                `Query handler will receive an empty ctx — ctx.db will be undefined. ` +
+                `This is a framework configuration error. ` +
+                `💡 Ensure buildRealtimeCtx() receives a buildCtxForRefresh callback.`,
+            );
+          }
+          const refreshCtx = options?.buildCtxForRefresh?.() ?? ({} as GencowCtx);
+          const result = await queryDef.handler(refreshCtx, {});
+
+          // emit과 동일한 경로로 push
+          if (options?.httpCallback) {
+            options.httpCallback({ type: "emit", queryKey: key, data: result });
+          } else {
+            const clients = subscribers.get(key);
+            if (clients && clients.size > 0) {
+              const message = JSON.stringify({
+                type: "query:updated",
+                query: key,
+                data: result,
+              });
+              for (const ws of clients) {
+                try {
+                  ws.send(message);
+                } catch {
+                  clients.delete(ws);
+                }
+              }
+            }
+          }
+        } catch (e) {
+          console.warn(`[gencow] refresh("${key}") failed:`, e instanceof Error ? e.message : e);
+        }
+      }
+      _pendingRefresh.length = 0;
+    },
+  };
+}
+
+export function handleWsMessage(ws: WSContext, raw: string | ArrayBuffer) {
+  try {
+    const msg = typeof raw === "string" ? JSON.parse(raw) : JSON.parse(raw.toString());
+
+    if (msg.type === "subscribe" && msg.query) {
+      subscribe(msg.query, ws);
+      ws.send(JSON.stringify({ type: "subscribed", query: msg.query }));
+    }
+
+    if (msg.type === "unsubscribe" && msg.query) {
+      const clients = subscribers.get(msg.query);
+      if (clients) clients.delete(ws);
+    }
+  } catch {
+    // ignore malformed messages
+  }
+}

package/src/runtime-env-policy.ts

@@ -37,7 +37,7 @@ const RESERVED_TENANT_RUNTIME_ENV_KEYS = new Set([
   "NODE_PATH",
 ]);
 
-const RESERVED_TENANT_RUNTIME_ENV_PREFIXES = ["__GENCOW_", "GENCOW_DOCUMENT_", "GENCOW_WARM_"];
+const RESERVED_TENANT_RUNTIME_ENV_PREFIXES = ["__GENCOW_", "GENCOW_DOCUMENT_", "GENCOW_TEMPLATE_", "GENCOW_WARM_"];
 
 export function isReservedTenantRuntimeEnvKey(key: string): boolean {
   const normalized = key.trim();

package/src/server.ts

@@ -6,5 +6,10 @@
  * bundled into user functions which run in Firecracker.
  */
 export { createStorage, storageRoutes } from "./storage.js";
-export type { StorageImageTierConfig, StoredFile } from "./storage.js";
+export type {
+  StorageImageTierConfig,
+  StorageImageTransformMetric,
+  StorageMeteringOptions,
+  StoredFile,
+} from "./storage.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";

package/src/storage-metering.ts

@@ -0,0 +1,35 @@
+import * as fs from "fs/promises";
+
+export interface StorageImageTransformMetric {
+  transformCount: number;
+  sourceBytes: number;
+  outputBytes: number;
+  format: string;
+  autoWebp: boolean;
+}
+
+export interface StorageMeteringOptions {
+  onImageTransform?: (metric: StorageImageTransformMetric) => void | Promise<void>;
+}
+
+export async function recordStorageImageTransform(
+  options: StorageMeteringOptions | undefined,
+  cachePath: string,
+  metric: Omit<StorageImageTransformMetric, "transformCount" | "outputBytes">,
+): Promise<{ size: number }> {
+  const stats = await fs.stat(cachePath);
+  if (!options?.onImageTransform) return stats;
+
+  try {
+    await options.onImageTransform({
+      ...metric,
+      transformCount: 1,
+      outputBytes: stats.size,
+    });
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.warn(`[storage] image transform metering failed: ${msg.slice(0, 120)}`);
+  }
+
+  return stats;
+}

package/src/storage.ts

@@ -9,8 +9,11 @@ import {
   loadStorageMeta,
 } from "./storage-shared.js";
 import type { Storage, StorageFile, StorageOptions, StoredFile } from "./storage-shared.js";
+import { recordStorageImageTransform } from "./storage-metering.js";
+import type { StorageMeteringOptions } from "./storage-metering.js";
 
 export type { Storage, StorageFile, StorageOptions, StoredFile } from "./storage-shared.js";
+export type { StorageImageTransformMetric, StorageMeteringOptions } from "./storage-metering.js";
 
 // ─── Implementation ─────────────────────────────────────
 
@@ -60,6 +63,8 @@ async function checkStorageQuota(
 ): Promise<void> {
   if (quota <= 0) return; // 무제한
 
+  await ensureFilesTable(rawSql);
+
   const rows = await rawSql(`SELECT COALESCE(SUM(CAST(size AS BIGINT)), 0) AS total FROM _system_files`);
   const currentUsage = Number((rows[0] as Record<string, string>)?.total || "0");
   const projectedUsage = currentUsage + newFileSize;
@@ -465,6 +470,7 @@ export function storageRoutes(
   rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>,
   storageDir?: string,
   tierConfig?: StorageImageTierConfig,
+  meteringOptions?: StorageMeteringOptions,
 ) {
   const baseTierConfig: Required<StorageImageTierConfig> = {
     autoWebp: tierConfig?.autoWebp ?? true,
@@ -736,15 +742,17 @@ export function storageRoutes(
 
         // 변환 실행 → 캐시에 저장
         await pipeline.toFile(cachePath);
+        const cacheStats = await recordStorageImageTransform(meteringOptions, cachePath, {
+          sourceBytes: meta.size,
+          format: outputFormat || meta.type.replace(/^image\//, ""),
+          autoWebp: isAutoWebp,
+        });
 
         // WebP/AVIF가 원본보다 큰 경우 → 캐시 삭제 + 원본 서빙
         // (Static Deploy와 동일 전략 — apps.ts L840-847)
-        if (isAutoWebp) {
-          const cacheStats = await fs.stat(cachePath);
-          if (cacheStats.size >= meta.size) {
-            await fs.unlink(cachePath).catch(() => {});
-            return serveOriginal(c, meta);
-          }
+        if (isAutoWebp && cacheStats.size >= meta.size) {
+          await fs.unlink(cachePath).catch(() => {});
+          return serveOriginal(c, meta);
         }
 
         return serveCachedFile(c, cachePath, transformParams, isAutoWebp, meta);

package/src/wake-app-result.ts

@@ -0,0 +1,37 @@
+export type WakeAppSuccessStatus = "already_running" | "woke";
+export type WakeAppDeferredStatus = "capacity_rejected" | "queue_timeout";
+
+export type WakeAppSuccessResult = {
+  ok: true;
+  status: WakeAppSuccessStatus;
+  port: number;
+};
+
+export type WakeAppDeferredResult = {
+  ok: false;
+  status: WakeAppDeferredStatus;
+  retryAfterSec: number;
+};
+
+export type WakeAppBootFailedResult = {
+  ok: false;
+  status: "boot_failed";
+  error: string;
+};
+
+export type WakeAppResult = WakeAppSuccessResult | WakeAppDeferredResult | WakeAppBootFailedResult;
+
+export const DEFAULT_WAKE_RETRY_AFTER_SEC = 30;
+
+export function buildWakeAppSuccessResult(status: WakeAppSuccessStatus, port: number): WakeAppSuccessResult {
+  return { ok: true, status, port };
+}
+
+export function buildWakeAppBootFailedResult(error: unknown): WakeAppBootFailedResult {
+  const message = error instanceof Error ? error.message : String(error);
+  return { ok: false, status: "boot_failed", error: message };
+}
+
+export function isWakeAppDeferredResult(result: WakeAppResult): result is WakeAppDeferredResult {
+  return !result.ok && (result.status === "capacity_rejected" || result.status === "queue_timeout");
+}

package/src/workflow-types.ts

@@ -1,4 +1,4 @@
-import type { GencowCtx } from "./reactive.js";
+import type { GencowCtx } from "./context.js";
 import type { WorkflowDocumentServicesCtx } from "./document-types.js";
 import type { InferArgs } from "./v.js";
 
@@ -29,6 +29,7 @@ export interface WorkflowSummary {
   derivedStatus: WorkflowDerivedStatus;
   currentStep: string | null;
   error: string | null;
+  errorCode: string | null;
   retryCount: number;
   maxRetries: number;
   maxDurationMs: number;
@@ -81,6 +82,9 @@ export interface WorkflowResumePayload {
 export interface WorkflowCtx extends Omit<GencowCtx, "services"> {
   workflowId: string;
   workflowName: string;
+  runId?: string;
+  attempt?: number;
+  stepAttempt?: number;
   services: GencowCtx["services"] & WorkflowDocumentServicesCtx;
   step<TResult>(name: string, run: () => Promise<TResult>): Promise<TResult>;
   sleep(duration: WorkflowDuration): Promise<void>;
@@ -95,7 +99,11 @@ export type WorkflowHandler<TArgs, TReturn> = (wf: WorkflowCtx, args: TArgs) =>
 export interface WorkflowOptions<TSchema = any, TReturn = any> {
   args?: TSchema;
   public?: boolean;
+  version?: string;
   maxDuration?: WorkflowDuration;
+  maxActiveDuration?: WorkflowDuration;
+  lifecycleTimeout?: WorkflowDuration;
+  concurrency?: number;
   retries?: number;
   handler: WorkflowHandler<InferArgs<TSchema>, TReturn>;
 }
@@ -104,7 +112,11 @@ export interface WorkflowDef<TSchema = any, TReturn = any> {
   name: string;
   argsSchema?: TSchema;
   isPublic: boolean;
+  version?: string;
   maxDurationMs: number;
+  maxActiveDurationMs: number;
+  lifecycleTimeoutMs: number | null;
+  concurrency: number | null;
   maxRetries: number;
   handler: WorkflowHandler<InferArgs<TSchema>, TReturn>;
 }

package/src/workflow.ts

@@ -1,6 +1,6 @@
 import { sql } from "drizzle-orm";
-import { mutation } from "./reactive.js";
-import type { MutationDef } from "./reactive.js";
+import { mutation } from "./reactive-mutation.js";
+import type { MutationDef } from "./reactive-mutation-types.js";
 import type {
   WorkflowDef,
   WorkflowDuration,
@@ -82,9 +82,137 @@ export function parseWorkflowDurationMs(raw: WorkflowDuration, label = "workflow
   return parseDurationString(raw, label);
 }
 
-function normalizeMaxDurationMs(maxDuration: WorkflowDuration | undefined): number {
+function normalizeMaxDurationMs(maxDuration: WorkflowDuration | undefined, label = "workflow() maxDuration"): number {
   if (maxDuration == null) return DEFAULT_WORKFLOW_MAX_DURATION_MS;
-  return parseWorkflowDurationMs(maxDuration, "workflow() maxDuration");
+  return parseWorkflowDurationMs(maxDuration, label);
+}
+
+function normalizeOptionalDurationMs(
+  duration: WorkflowDuration | undefined,
+  label: string,
+): number | null {
+  return duration == null ? null : parseWorkflowDurationMs(duration, label);
+}
+
+function normalizeConcurrency(concurrency: number | undefined): number | null {
+  if (concurrency == null) return null;
+  if (!Number.isFinite(concurrency) || concurrency <= 0) {
+    throw new Error(`workflow() concurrency must be a positive finite number, got "${concurrency}"`);
+  }
+  return Math.floor(concurrency);
+}
+
+function isMissingWorkflowV2SchemaError(error: unknown): boolean {
+  const code =
+    error && typeof error === "object" && "code" in error ? String((error as { code?: unknown }).code) : "";
+  const cause =
+    error && typeof error === "object" && "cause" in error ? (error as { cause?: unknown }).cause : null;
+  const causeCode =
+    cause && typeof cause === "object" && "code" in cause ? String((cause as { code?: unknown }).code) : "";
+  const message = error instanceof Error ? error.message : String(error);
+  return (
+    code === "42P01" ||
+    code === "42703" ||
+    causeCode === "42P01" ||
+    causeCode === "42703" ||
+    message.includes('relation "_gencow_workflow_runs_v2" does not exist') ||
+    message.includes("relation _gencow_workflow_runs_v2 does not exist") ||
+    message.includes('relation "_gencow_workflow_outbox_v2" does not exist') ||
+    message.includes("relation _gencow_workflow_outbox_v2 does not exist") ||
+    message.includes('column "max_active_duration_ms"') ||
+    message.includes('column "retry_count"') ||
+    message.includes('column "user_id"')
+  );
+}
+
+async function tryInsertWorkflowV2WakeOutbox(
+  db: { execute: (query: ReturnType<typeof sql>) => Promise<unknown> },
+  workflowId: string,
+): Promise<void> {
+  try {
+    await db.execute(sql`
+      INSERT INTO _gencow_workflow_outbox_v2 (
+        id,
+        run_id,
+        kind,
+        available_at,
+        status
+      )
+      VALUES (
+        ${`start:${workflowId}`},
+        ${workflowId},
+        'wake_run',
+        NOW(),
+        'pending'
+      )
+      ON CONFLICT (id) DO NOTHING
+    `);
+  } catch (error) {
+    if (!isMissingWorkflowV2SchemaError(error)) throw error;
+  }
+}
+
+async function tryInsertWorkflowV2Run(options: {
+  db: { execute: (query: ReturnType<typeof sql>) => Promise<unknown> };
+  workflowId: string;
+  workflowName: string;
+  workflowVersion?: string | null;
+  args: unknown;
+  userId: string | null;
+  maxActiveDurationMs: number;
+  lifecycleTimeoutMs: number | null;
+  maxRetries: number;
+}): Promise<boolean> {
+  try {
+    await options.db.execute(sql`
+      INSERT INTO _gencow_workflow_runs_v2 (
+        id,
+        workflow_name,
+        workflow_version,
+        args_json,
+        user_id,
+        max_active_duration_ms,
+        lifecycle_deadline_at,
+        retry_count,
+        max_retries,
+        max_attempts
+      )
+      VALUES (
+        ${options.workflowId},
+        ${options.workflowName},
+        ${options.workflowVersion ?? null},
+        ${JSON.stringify(options.args)}::jsonb,
+        ${options.userId},
+        ${options.maxActiveDurationMs},
+        CASE
+          WHEN ${options.lifecycleTimeoutMs}::bigint IS NULL THEN NULL
+          ELSE NOW() + (${options.lifecycleTimeoutMs}::bigint * INTERVAL '1 millisecond')
+        END,
+        0,
+        ${options.maxRetries},
+        ${options.maxRetries + 1}
+      )
+    `);
+    await tryInsertWorkflowV2WakeOutbox(options.db, options.workflowId);
+    return true;
+  } catch (error) {
+    if (isMissingWorkflowV2SchemaError(error)) return false;
+    throw error;
+  }
+}
+
+async function tryDeleteWorkflowV2Run(
+  db: { execute: (query: ReturnType<typeof sql>) => Promise<unknown> },
+  workflowId: string,
+): Promise<void> {
+  try {
+    await db.execute(sql`
+      DELETE FROM _gencow_workflow_runs_v2
+      WHERE id = ${workflowId}
+    `);
+  } catch (error) {
+    if (!isMissingWorkflowV2SchemaError(error)) throw error;
+  }
 }
 
 export function getWorkflowResumeActionName(name: string): string {
@@ -119,14 +247,25 @@ export function workflow<TSchema = any, TReturn = any>(
 ): MutationDef<TSchema, WorkflowStartResult> {
   registerWorkflowsApi();
 
-  const maxDurationMs = normalizeMaxDurationMs(options.maxDuration);
+  const maxActiveDurationMs = normalizeMaxDurationMs(
+    options.maxActiveDuration ?? options.maxDuration,
+    options.maxActiveDuration == null ? "workflow() maxDuration" : "workflow() maxActiveDuration",
+  );
+  const lifecycleTimeoutMs = normalizeOptionalDurationMs(
+    options.lifecycleTimeout,
+    "workflow() lifecycleTimeout",
+  );
   const maxRetries = clampRetries(options.retries);
 
   const def: WorkflowDef<TSchema, TReturn> = {
     name,
     argsSchema: options.args,
     isPublic: options.public === true,
-    maxDurationMs,
+    version: options.version,
+    maxDurationMs: maxActiveDurationMs,
+    maxActiveDurationMs,
+    lifecycleTimeoutMs,
+    concurrency: normalizeConcurrency(options.concurrency),
     maxRetries,
     handler: options.handler,
   };
@@ -159,16 +298,28 @@ export function workflow<TSchema = any, TReturn = any>(
                     ${workflowId},
                     ${name},
                     ${JSON.stringify(persistedArgs)}::jsonb,
-                    ${realtimeToken},
-                    'pending',
-                    0,
-                    ${maxRetries},
-                    ${maxDurationMs},
-                    ${ownerId}
+                  ${realtimeToken},
+                  'pending',
+                  0,
+                  ${maxRetries},
+                  ${maxActiveDurationMs},
+                  ${ownerId}
                 )
             `);
+      let insertedWorkflowV2 = false;
 
       try {
+        insertedWorkflowV2 = await tryInsertWorkflowV2Run({
+          db: ctx.unsafeDb,
+          workflowId,
+          workflowName: name,
+          workflowVersion: options.version ?? null,
+          args: persistedArgs,
+          userId: ownerId,
+          maxActiveDurationMs,
+          lifecycleTimeoutMs,
+          maxRetries,
+        });
         const scheduledJobId = ctx.scheduler.runAfter(0, resumeAction, { workflowId });
         return {
           id: workflowId,
@@ -181,6 +332,9 @@ export function workflow<TSchema = any, TReturn = any>(
                     DELETE FROM _gencow_workflows
                     WHERE id = ${workflowId}
                 `);
+        if (insertedWorkflowV2) {
+          await tryDeleteWorkflowV2Run(ctx.unsafeDb, workflowId);
+        }
         throw error;
       }
     },