@gencow/core 0.1.27 → 0.1.29

package/dist/reactive.js

@@ -18,6 +18,40 @@ const subscribers = globalThis.__gencow_subscribers;
  * to a specific query (e.g. the admin dashboard's raw WebSocket connection).
  */
 const connectedClients = globalThis.__gencow_connectedClients;
+const SUBSCRIPTION_KEY_SEPARATOR = "::";
+function normalizeForStableJson(value) {
+    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;
+        const sorted = {};
+        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) {
+    return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+export function buildQuerySubscriptionKey(queryKey, args) {
+    const normalized = normalizeForStableJson(args);
+    if (normalized === undefined || isEmptyPlainObject(normalized))
+        return queryKey;
+    return `${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}${JSON.stringify(normalized)}`;
+}
+export function subscriptionKeyMatchesQueryKey(subscriptionKey, queryKey) {
+    return subscriptionKey === queryKey || subscriptionKey.startsWith(`${queryKey}${SUBSCRIPTION_KEY_SEPARATOR}`);
+}
 // ─── Public API (Convex-style) ──────────────────────────
 export function query(key, handlerOrDef) {
     let handler;
@@ -167,6 +201,28 @@ export function deregisterClient(ws) {
         clients.delete(ws);
     }
 }
+function sendInvalidateToLocalSubscribers(queryKeys) {
+    const targets = new Map();
+    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용).
@@ -221,6 +277,15 @@ export function buildRealtimeCtx(options) {
             }, 50); // 50ms batch window
             pendingEmits.set(queryKey, { data, timer });
         },
+        invalidate(queryKey) {
+            _hasEmitted = true;
+            const queryKeys = Array.isArray(queryKey) ? [...new Set(queryKey)] : [queryKey];
+            if (options?.httpCallback) {
+                options.httpCallback({ type: "invalidate", queryKeys });
+                return;
+            }
+            sendInvalidateToLocalSubscribers(queryKeys);
+        },
         refresh(queryKey) {
             _hasEmitted = true; // 경고 억제
             if (!_pendingRefresh.includes(queryKey)) {

package/dist/rls-db.d.ts

@@ -1,4 +1,3 @@
-import type { PgAsyncDatabase } from "drizzle-orm/pg-core";
 /**
  * RLS DB wrapper — execution paths for `withRlsConnection`:
  * 1. **Reuse outer Drizzle transaction** (`reuseOuterConnection`): same connection, apply GUCs then run `fn`.
@@ -24,6 +23,13 @@ export type RlsSessionContext = {
      */
     vars?: Record<string, string>;
 };
+type RlsDrizzleDatabaseLike = {
+    session: unknown;
+    _: {
+        session?: unknown;
+    };
+    transaction: (callback: (tx: unknown) => unknown | Promise<unknown>, ...rest: unknown[]) => Promise<unknown>;
+};
 /**
  * pg `Pool.connect()`-style client: BEGIN → apply RLS GUCs → `fn` → COMMIT on success,
  * or ROLLBACK if anything fails (including failed COMMIT). Always `release()` in `finally`.
@@ -44,4 +50,5 @@ export declare function withRlsLeasedConnection<T>(leased: {
  *
  * `db.transaction()` still injects the same variables at the start of the callback transaction.
  */
-export declare function createRlsDb(db: PgAsyncDatabase<any, any, any, any>, rls: RlsSessionContext): PgAsyncDatabase<any, any, any, any>;
+export declare function createRlsDb<TDb extends RlsDrizzleDatabaseLike>(db: TDb, rls: RlsSessionContext): TDb;
+export {};

package/dist/runtime-env-policy.d.ts

@@ -0,0 +1,5 @@
+export declare function isReservedTenantRuntimeEnvKey(key: string): boolean;
+export declare function filterTenantRuntimeEnvVars(vars: Record<string, string>): {
+    allowed: Record<string, string>;
+    rejectedKeys: string[];
+};

package/dist/runtime-env-policy.js

@@ -0,0 +1,56 @@
+const RESERVED_TENANT_RUNTIME_ENV_KEYS = new Set([
+    "PORT",
+    "DATABASE_URL",
+    "GENCOW_DB_URL",
+    "BETTER_AUTH_SECRET",
+    "BETTER_AUTH_URL",
+    "IS_PLATFORM",
+    "GENCOW_PLATFORM_CONFIG_FILE",
+    "GENCOW_PLATFORM_URL",
+    "GENCOW_PLATFORM_DB",
+    "PLATFORM_OPENAI_KEY",
+    "PLATFORM_GOOGLE_KEY",
+    "PLATFORM_INTERNAL_SECRET",
+    "INVITE_ONLY",
+    "RUNNER_TYPE",
+    "PGBOUNCER_PORT",
+    "GENCOW_FUNCTIONS",
+    "GENCOW_STORAGE",
+    "GENCOW_MIGRATIONS",
+    "GENCOW_APP_NAME",
+    "GENCOW_APP_DATA_DIR",
+    "GENCOW_INTERNAL_TOKEN",
+    "GENCOW_CRON_TOKEN",
+    "GENCOW_AI_PROXY_URL",
+    "GENCOW_AI_PROXY_URL_ALT",
+    "GENCOW_AI_PROXY_TOKEN",
+    "GENCOW_METERING_URL",
+    "GENCOW_METERING_URL_ALT",
+    "GENCOW_START_REASON",
+    "GENCOW_RESTART_ID",
+    "GENCOW_SHUTDOWN_MARKER_PATH",
+    "GENCOW_SKIP_MIGRATION",
+    "GENCOW_DB_MAX_CONNECTIONS",
+    "GENCOW_MEMORY_MB",
+    "BUN_JSC_forceRAMSize",
+    "MIMALLOC_PURGE_DELAY",
+    "NODE_PATH",
+]);
+const RESERVED_TENANT_RUNTIME_ENV_PREFIXES = ["__GENCOW_", "GENCOW_DOCUMENT_", "GENCOW_TEMPLATE_", "GENCOW_WARM_"];
+export function isReservedTenantRuntimeEnvKey(key) {
+    const normalized = key.trim();
+    return (RESERVED_TENANT_RUNTIME_ENV_KEYS.has(normalized) ||
+        RESERVED_TENANT_RUNTIME_ENV_PREFIXES.some((prefix) => normalized.startsWith(prefix)));
+}
+export function filterTenantRuntimeEnvVars(vars) {
+    const allowed = {};
+    const rejectedKeys = [];
+    for (const [key, value] of Object.entries(vars)) {
+        if (isReservedTenantRuntimeEnvKey(key)) {
+            rejectedKeys.push(key);
+            continue;
+        }
+        allowed[key] = value;
+    }
+    return { allowed, rejectedKeys };
+}

package/dist/search-types.d.ts

@@ -0,0 +1,83 @@
+export type SearchPrimitive = string | number | boolean;
+export type SearchScope = {
+    corpus: string;
+    visibility: "private" | "shared" | "public";
+    ownerUserId?: string;
+};
+export type SearchFilter = {
+    eq?: Record<string, SearchPrimitive>;
+    in?: Record<string, SearchPrimitive[]>;
+    range?: Record<string, {
+        gte?: string | number;
+        lte?: string | number;
+    }>;
+};
+export type SearchOptions = {
+    fields: [string, ...string[]];
+    limit?: number;
+    offset?: number;
+    filters?: SearchFilter;
+    scope: SearchScope;
+};
+export type VectorSearchTuning = {
+    minScore?: number;
+};
+export type VectorSearchOptions = Omit<SearchOptions, "fields"> & {
+    vector: number[];
+    vectorField?: string;
+    tuning?: VectorSearchTuning;
+};
+export type HybridSearchFusionTuning = {
+    mode?: "rrf";
+    rrfK?: number;
+    keywordWeight?: number;
+    vectorWeight?: number;
+};
+export type HybridSearchTuning = {
+    keywordCandidateLimit?: number;
+    vectorCandidateLimit?: number;
+    minFusedScore?: number;
+    fusion?: HybridSearchFusionTuning;
+};
+export type HybridSearchOptions = SearchOptions & {
+    vector: number[];
+    vectorField?: string;
+    fusion?: "rrf";
+    keywordCandidateLimit?: number;
+    vectorCandidateLimit?: number;
+    tuning?: HybridSearchTuning;
+};
+export type SearchHit = {
+    id: string | number;
+    row: Record<string, unknown>;
+    score: number;
+    scores?: {
+        keyword?: number;
+        vector?: number;
+        fused?: number;
+    };
+    matchedBy: Array<"keyword" | "vector">;
+};
+export type SearchResponse = {
+    items: SearchHit[];
+    meta: {
+        engine: "tsvector" | "pgroonga";
+        tier: "free" | "pro" | "scale";
+        limit: number;
+        offset: number;
+        nextOffset?: number;
+        fusion?: "rrf";
+        mode?: "keyword" | "vector" | "hybrid";
+    };
+};
+export type SearchTierConfig = {
+    plan: "free" | "pro" | "scale";
+    engine: "tsvector" | "pgroonga";
+    hybridSearch: boolean;
+    locale: "english" | "multilingual";
+    extensions: {
+        vector: boolean;
+        pgroonga: boolean;
+    };
+    degradedReason?: string;
+};

package/dist/search-types.js

@@ -0,0 +1 @@
+export {};

package/dist/server.d.ts

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

package/dist/server.js

@@ -7,4 +7,3 @@
  */
 export { createStorage, storageRoutes } from "./storage.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";
-export { authMiddleware, authRoutes, getUsers } from "./auth.js";

package/dist/storage-metering.d.ts

@@ -0,0 +1,13 @@
+export interface StorageImageTransformMetric {
+    transformCount: number;
+    sourceBytes: number;
+    outputBytes: number;
+    format: string;
+    autoWebp: boolean;
+}
+export interface StorageMeteringOptions {
+    onImageTransform?: (metric: StorageImageTransformMetric) => void | Promise<void>;
+}
+export declare function recordStorageImageTransform(options: StorageMeteringOptions | undefined, cachePath: string, metric: Omit<StorageImageTransformMetric, "transformCount" | "outputBytes">): Promise<{
+    size: number;
+}>;

package/dist/storage-metering.js

@@ -0,0 +1,18 @@
+import * as fs from "fs/promises";
+export async function recordStorageImageTransform(options, cachePath, metric) {
+    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/dist/storage-shared.d.ts

@@ -0,0 +1,36 @@
+/** 파일 업로드 최대 크기: 50MB (하드코딩 — 사용자가 오버라이드 불가) */
+export declare const MAX_FILE_SIZE: number;
+/** 기본 스토리지 쿼터: 1GB */
+export declare const DEFAULT_STORAGE_QUOTA: number;
+export interface StorageFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    path: string;
+}
+export interface StoredFile {
+    id: string;
+    name: string;
+    size: number;
+    type: string;
+    buffer: Buffer;
+}
+export interface StorageOptions {
+    rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>;
+    storageQuota?: number;
+}
+export interface Storage {
+    store(file: File | Blob, filename?: string): Promise<string>;
+    storeBuffer(buffer: Buffer, filename: string, type?: string): Promise<string>;
+    get(storageId: string): Promise<StoredFile | null>;
+    getUrl(storageId: string): string;
+    getMeta(storageId: string): Promise<StorageFile | null>;
+    delete(storageId: string): Promise<void>;
+}
+export declare function formatBytes(bytes: number): string;
+export declare function loadStorageMeta(params: {
+    storageId: string;
+    dir: string;
+    metaStore: Map<string, StorageFile>;
+}): Promise<StorageFile | null>;

package/dist/storage-shared.js

@@ -0,0 +1,39 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+/** 파일 업로드 최대 크기: 50MB (하드코딩 — 사용자가 오버라이드 불가) */
+export const MAX_FILE_SIZE = 50 * 1024 * 1024;
+/** 기본 스토리지 쿼터: 1GB */
+export const DEFAULT_STORAGE_QUOTA = 1024 * 1024 * 1024;
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}
+export async function loadStorageMeta(params) {
+    const cached = params.metaStore.get(params.storageId);
+    if (cached) {
+        return cached;
+    }
+    const filePath = path.join(params.dir, params.storageId);
+    try {
+        const raw = await fs.readFile(`${filePath}.meta`, "utf-8");
+        const parsed = JSON.parse(raw);
+        const stat = await fs.stat(filePath);
+        const meta = {
+            id: params.storageId,
+            name: typeof parsed.name === "string" ? parsed.name : params.storageId,
+            size: typeof parsed.size === "number" ? parsed.size : stat.size,
+            type: typeof parsed.type === "string" ? parsed.type : "application/octet-stream",
+            path: filePath,
+        };
+        params.metaStore.set(params.storageId, meta);
+        return meta;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/storage.d.ts

@@ -1,28 +1,7 @@
-interface StorageFile {
-    id: string;
-    name: string;
-    size: number;
-    type: string;
-    path: string;
-}
-export interface StorageOptions {
-    /** Raw SQL 실행 함수 — DB 자동 기록 + 쿼터 검증에 필요 */
-    rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>;
-    /** 앱별 스토리지 쿼터 (bytes). 0 = 무제한. 기본: 1GB */
-    storageQuota?: number;
-}
-export interface Storage {
-    /** Store a file and return a storageId — Convex의 ctx.storage.store() */
-    store(file: File | Blob, filename?: string): Promise<string>;
-    /** Store from raw buffer */
-    storeBuffer(buffer: Buffer, filename: string, type?: string): Promise<string>;
-    /** Get a serving URL for the file — Convex의 ctx.storage.getUrl() */
-    getUrl(storageId: string): string;
-    /** Get file metadata */
-    getMeta(storageId: string): Promise<StorageFile | null>;
-    /** Delete a stored file — Convex의 ctx.storage.delete() */
-    delete(storageId: string): Promise<void>;
-}
+import type { Storage, StorageOptions } from "./storage-shared.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";
 /**
  * Create a storage instance — Convex storage 패턴 재현
  *
@@ -66,7 +45,7 @@ export interface StorageImageTierConfig {
  * - 디스크 캐시: uploads/.cache/{uuid}_{params}.{ext}
  * - 원본 보존: 원본 파일은 절대 수정하지 않음
  */
-export declare function storageRoutes(storage: ReturnType<typeof createStorage>, rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>, storageDir?: string, tierConfig?: StorageImageTierConfig): (c: {
+export declare function storageRoutes(storage: ReturnType<typeof createStorage>, rawSql?: (sql: string, params?: unknown[]) => Promise<unknown[]>, storageDir?: string, tierConfig?: StorageImageTierConfig, meteringOptions?: StorageMeteringOptions): (c: {
     req: {
         param: (key: string) => string;
         query: (key: string) => string | undefined;
@@ -75,4 +54,3 @@ export declare function storageRoutes(storage: ReturnType<typeof createStorage>,
     json: (data: unknown, status?: number) => Response;
     body: (data: unknown, status: number, headers: Record<string, string>) => Response;
 }) => Promise<Response>;
-export {};

package/dist/storage.js

@@ -2,20 +2,8 @@ import * as fs from "fs/promises";
 import * as fsSync from "fs";
 import * as path from "path";
 import * as crypto from "crypto";
-// ─── Constants ──────────────────────────────────────────
-/** 파일 업로드 최대 크기: 50MB (하드코딩 — 사용자가 오버라이드 불가) */
-const MAX_FILE_SIZE = 50 * 1024 * 1024;
-/** 기본 스토리지 쿼터: 1GB */
-const DEFAULT_STORAGE_QUOTA = 1024 * 1024 * 1024;
-function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes}B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)}KB`;
-    if (bytes < 1024 * 1024 * 1024)
-        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
-}
+import { DEFAULT_STORAGE_QUOTA, MAX_FILE_SIZE, formatBytes, loadStorageMeta, } from "./storage-shared.js";
+import { recordStorageImageTransform } from "./storage-metering.js";
 // ─── Implementation ─────────────────────────────────────
 const metaStore = new Map();
 /**
@@ -55,6 +43,7 @@ async function ensureFilesTable(rawSql) {
 async function checkStorageQuota(rawSql, newFileSize, quota) {
     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]?.total || "0");
     const projectedUsage = currentUsage + newFileSize;
@@ -166,8 +155,25 @@ export function createStorage(dir = "./uploads", options) {
         getUrl(storageId) {
             return `/api/storage/${storageId}`;
         },
+        async get(storageId) {
+            const meta = await loadStorageMeta({ storageId, dir, metaStore });
+            if (!meta) {
+                return null;
+            }
+            const buffer = await fs.readFile(meta.path).catch(() => null);
+            if (!buffer) {
+                return null;
+            }
+            return {
+                id: meta.id,
+                name: meta.name,
+                size: meta.size,
+                type: meta.type,
+                buffer,
+            };
+        },
         async getMeta(storageId) {
-            return metaStore.get(storageId) || null;
+            return loadStorageMeta({ storageId, dir, metaStore });
         },
         async delete(storageId) {
             const meta = metaStore.get(storageId);
@@ -339,7 +345,7 @@ async function getCacheEntryCount(cacheDir) {
  * - 디스크 캐시: uploads/.cache/{uuid}_{params}.{ext}
  * - 원본 보존: 원본 파일은 절대 수정하지 않음
  */
-export function storageRoutes(storage, rawSql, storageDir, tierConfig) {
+export function storageRoutes(storage, rawSql, storageDir, tierConfig, meteringOptions) {
     const baseTierConfig = {
         autoWebp: tierConfig?.autoWebp ?? true,
         autoMaxWidth: tierConfig?.autoMaxWidth ?? 0, // 0 = 제한 없음
@@ -557,14 +563,16 @@ export function storageRoutes(storage, rawSql, storageDir, tierConfig) {
                 }
                 // 변환 실행 → 캐시에 저장
                 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/dist/wake-app-result.d.ts

@@ -0,0 +1,22 @@
+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 declare const DEFAULT_WAKE_RETRY_AFTER_SEC = 30;
+export declare function buildWakeAppSuccessResult(status: WakeAppSuccessStatus, port: number): WakeAppSuccessResult;
+export declare function buildWakeAppBootFailedResult(error: unknown): WakeAppBootFailedResult;
+export declare function isWakeAppDeferredResult(result: WakeAppResult): result is WakeAppDeferredResult;

package/dist/wake-app-result.js

@@ -0,0 +1,11 @@
+export const DEFAULT_WAKE_RETRY_AFTER_SEC = 30;
+export function buildWakeAppSuccessResult(status, port) {
+    return { ok: true, status, port };
+}
+export function buildWakeAppBootFailedResult(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, status: "boot_failed", error: message };
+}
+export function isWakeAppDeferredResult(result) {
+    return !result.ok && (result.status === "capacity_rejected" || result.status === "queue_timeout");
+}

package/dist/workflow-types.d.ts

@@ -1,4 +1,5 @@
-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";
 export type WorkflowStatus = "pending" | "running" | "completed" | "failed";
 export type WorkflowDuration = number | string;
@@ -11,6 +12,7 @@ export interface WorkflowSummary {
     derivedStatus: WorkflowDerivedStatus;
     currentStep: string | null;
     error: string | null;
+    errorCode: string | null;
     retryCount: number;
     maxRetries: number;
     maxDurationMs: number;
@@ -53,9 +55,13 @@ export interface WorkflowSignalResult {
 export interface WorkflowResumePayload {
     workflowId: string;
 }
-export interface WorkflowCtx extends GencowCtx {
+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>;
     waitForEvent<TPayload = unknown>(name: string, timeout?: WorkflowDuration): Promise<TPayload>;
@@ -67,7 +73,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>;
 }
@@ -75,7 +85,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/dist/workflow.d.ts

@@ -1,4 +1,4 @@
-import type { MutationDef } from "./reactive.js";
+import type { MutationDef } from "./reactive-mutation-types.js";
 import type { WorkflowDef, WorkflowDuration, WorkflowOptions, WorkflowStartResult } from "./workflow-types.js";
 declare global {
     var __gencow_workflowRegistry: Map<string, WorkflowDef<any, any>>;