@gencow/core 0.1.24 → 0.1.25

package/src/rls.ts

@@ -8,10 +8,10 @@ import { pgPolicy, type AnyPgColumn, type PgTable } from "drizzle-orm/pg-core";
 // WeakMap이므로 테이블이 GC되면 메타데이터도 자동 해제.
 
 export interface OwnerRlsMeta {
-    /** userId 컬럼의 DB 이름 (e.g. "user_id") */
-    columnName: string;
-    /** true면 SELECT에 userId 필터 생략 (누구나 읽기 가능) */
-    readPublic: boolean;
+  /** userId 컬럼의 DB 이름 (e.g. "user_id") */
+  columnName: string;
+  /** true면 SELECT에 userId 필터 생략 (누구나 읽기 가능) */
+  readPublic: boolean;
 }
 
 const _ownerRlsRegistry = new WeakMap<PgTable, OwnerRlsMeta>();
@@ -21,7 +21,7 @@ const _ownerRlsRegistry = new WeakMap<PgTable, OwnerRlsMeta>();
  * ownerRls()가 호출되지 않은 테이블은 undefined를 반환.
  */
 export function getOwnerRlsMeta(table: PgTable): OwnerRlsMeta | undefined {
-    return _ownerRlsRegistry.get(table);
+  return _ownerRlsRegistry.get(table);
 }
 
 /**
@@ -30,7 +30,7 @@ export function getOwnerRlsMeta(table: PgTable): OwnerRlsMeta | undefined {
  * 임시 프록시 객체가 전달될 수 있음 → registerOwnerRls()로 사후 등록.
  */
 export function registerOwnerRls(table: PgTable, meta: OwnerRlsMeta): void {
-    _ownerRlsRegistry.set(table, meta);
+  _ownerRlsRegistry.set(table, meta);
 }
 
 // ─── ownerRls — DB-level RLS 정책 선언 + 앱 레벨 메타데이터 등록 ──
@@ -61,39 +61,36 @@ export function registerOwnerRls(table: PgTable, meta: OwnerRlsMeta): void {
  * }, (t) => ownerRls(t.userId, { read: "public" }));
  * ```
  */
-export function ownerRls(
-    userIdColumn: AnyPgColumn,
-    options?: { read?: "public" },
-) {
-    // S3 방어: userIdColumn.name 미존재 시 명확한 에러
-    const colName = (userIdColumn as any).name;
-    if (!colName) {
-        throw new Error(
-            "[ownerRls] userIdColumn must have a .name property. " +
-            "Ensure you pass a valid Drizzle column reference (e.g. t.userId)."
-        );
-    }
+export function ownerRls(userIdColumn: AnyPgColumn, options?: { read?: "public" }) {
+  // S3 방어: userIdColumn.name 미존재 시 명확한 에러
+  const colName = (userIdColumn as any).name;
+  if (!colName) {
+    throw new Error(
+      "[ownerRls] userIdColumn must have a .name property. " +
+        "Ensure you pass a valid Drizzle column reference (e.g. t.userId).",
+    );
+  }
 
-    /** `missing_ok` avoids errors before first `set_config` and matches PG custom GUC behavior in PGlite. */
-    const isOwner = sql`${userIdColumn} = current_setting('app.current_user_id', true)`;
+  /** `missing_ok` avoids errors before first `set_config` and matches PG custom GUC behavior in PGlite. */
+  const isOwner = sql`${userIdColumn} = current_setting('app.current_user_id', true)`;
 
-    // ── 앱 레벨 메타데이터: crud()가 런타임에 읽음 ──
-    const meta: OwnerRlsMeta = {
-        columnName: colName,
-        readPublic: options?.read === "public",
-    };
+  // ── 앱 레벨 메타데이터: crud()가 런타임에 읽음 ──
+  const meta: OwnerRlsMeta = {
+    columnName: colName,
+    readPublic: options?.read === "public",
+  };
 
-    const policies = [
-        pgPolicy("rls-select", { for: "select", using: options?.read === "public" ? sql`true` : isOwner }),
-        pgPolicy("rls-insert", { for: "insert", withCheck: isOwner }),
-        pgPolicy("rls-update", { for: "update", using: isOwner, withCheck: isOwner }),
-        pgPolicy("rls-delete", { for: "delete", using: isOwner }),
-    ];
+  const policies = [
+    pgPolicy("rls-select", { for: "select", using: options?.read === "public" ? sql`true` : isOwner }),
+    pgPolicy("rls-insert", { for: "insert", withCheck: isOwner }),
+    pgPolicy("rls-update", { for: "update", using: isOwner, withCheck: isOwner }),
+    pgPolicy("rls-delete", { for: "delete", using: isOwner }),
+  ];
 
-    // N2 정리: non-enumerable _ownerRlsMeta 마커 제거 (dead code).
-    // ownerRls()는 pgTable extraConfig 콜백에서 호출되며, 이 시점에서는
-    // 테이블 참조가 프록시이므로 WeakMap 등록 불가능.
-    // 실제 메타데이터 등록은 crud()의 detectOwnerMeta() fallback에서 수행.
+  // N2 정리: non-enumerable _ownerRlsMeta 마커 제거 (dead code).
+  // ownerRls()는 pgTable extraConfig 콜백에서 호출되며, 이 시점에서는
+  // 테이블 참조가 프록시이므로 WeakMap 등록 불가능.
+  // 실제 메타데이터 등록은 crud()의 detectOwnerMeta() fallback에서 수행.
 
-    return policies;
+  return policies;
 }

package/src/scheduler.ts

@@ -6,17 +6,17 @@ type ActionHandler = (args: any) => Promise<any>;
 
 /** runAfter/runAt 옵션 — onError dead-letter 콜백 지원 */
 export interface ScheduleOptions {
-    /** 실패 시 호출할 action 이름 (dead-letter 패턴) */
-    onError?: string;
+  /** 실패 시 호출할 action 이름 (dead-letter 패턴) */
+  onError?: string;
 }
 
 /** scheduled job의 DB 영속화를 위한 콜백 */
 export interface ScheduledJobRecord {
-    id: string;
-    action: string;
-    args: unknown;
-    runAt: Date;
-    onErrorAction?: string;
+  id: string;
+  action: string;
+  args: unknown;
+  runAt: Date;
+  onErrorAction?: string;
 }
 
 /**
@@ -28,34 +28,36 @@ export interface ScheduledJobRecord {
  * 콜백 미설정 시 기존 인메모리 setTimeout 동작 유지 (로컬 dev).
  */
 export interface CreateSchedulerOptions {
-    /** Job을 DB에 영속화 (INSERT) */
-    persistJob?: (job: ScheduledJobRecord) => Promise<void>;
-    /** Job을 DB에서 제거 (DELETE) — cancel/완료 시 */
-    removeJob?: (jobId: string) => Promise<boolean>;
+  /** Job을 DB에 영속화 (INSERT) */
+  persistJob?: (job: ScheduledJobRecord) => Promise<void>;
+  /** Job을 DB에서 제거 (DELETE) — cancel/완료 시 */
+  removeJob?: (jobId: string) => Promise<boolean>;
 }
 
 /** 실패한 작업의 기록 */
 export interface FailedJob {
-    id: string;
-    action: string;
-    args: any;
-    error: string;
-    failedAt: string;
+  id: string;
+  action: string;
+  args: any;
+  error: string;
+  failedAt: string;
 }
 
 export interface Scheduler {
-    /** Schedule a function to run after a delay — Convex의 ctx.scheduler.runAfter() */
-    runAfter(ms: number, action: string, args?: any, options?: ScheduleOptions): string;
-    /** Schedule a function at a specific time — Convex의 ctx.scheduler.runAt() */
-    runAt(timestamp: number | Date, action: string, args?: any, options?: ScheduleOptions): string;
-    /** Cancel a scheduled function */
-    cancel(jobId: string): boolean;
-    /** Register a cron job — Convex의 cronJobs() */
-    cron(name: string, pattern: string, handler: () => Promise<void>): void;
-    /** Register an action handler */
-    registerAction(name: string, handler: ActionHandler): void;
-    /** Execute a registered action by name — 선언적 crons.ts 문자열 액션 실행용 */
-    executeAction(name: string, args?: any): Promise<void>;
+  /** Schedule a function to run after a delay — Convex의 ctx.scheduler.runAfter() */
+  runAfter(ms: number, action: string, args?: any, options?: ScheduleOptions): string;
+  /** Schedule a function at a specific time — Convex의 ctx.scheduler.runAt() */
+  runAt(timestamp: number | Date, action: string, args?: any, options?: ScheduleOptions): string;
+  /** Cancel a scheduled function */
+  cancel(jobId: string): boolean;
+  /** Register a cron job — Convex의 cronJobs() */
+  cron(name: string, pattern: string, handler: () => Promise<void>): void;
+  /** Register an action handler */
+  registerAction(name: string, handler: ActionHandler): void;
+  /** Execute a registered action and propagate errors to the caller */
+  executeActionStrict(name: string, args?: any): Promise<void>;
+  /** Execute a registered action by name — 선언적 crons.ts 문자열 액션 실행용 */
+  executeAction(name: string, args?: any): Promise<void>;
 }
 
 // ─── Implementation ─────────────────────────────────────
@@ -90,216 +92,240 @@ export interface Scheduler {
 // query/mutation 레지스트리(globalThis.__gencow_*)와 동일 패턴.
 // @gencow/core가 다중 resolve되어도 단일 배열 공유.
 
-interface CronInfoEntry { name: string; pattern: string; registeredAt: string }
+interface CronInfoEntry {
+  name: string;
+  pattern: string;
+  registeredAt: string;
+}
 interface PendingJobEntry {
-    id: string;
-    action: string;
-    scheduledAt: string;
-    status?: "pending" | "running" | "completed" | "failed";
+  id: string;
+  action: string;
+  scheduledAt: string;
+  status?: "pending" | "running" | "completed" | "failed";
 }
 
-const _cronInfo: CronInfoEntry[] =
-    (globalThis as any).__gencow_cronInfo ??= [];
-const _pendingJobs: PendingJobEntry[] =
-    (globalThis as any).__gencow_pendingJobs ??= [];
-const _failedJobs: FailedJob[] =
-    (globalThis as any).__gencow_failedJobs ??= [];
+const _cronInfo: CronInfoEntry[] = ((globalThis as any).__gencow_cronInfo ??= []);
+const _pendingJobs: PendingJobEntry[] = ((globalThis as any).__gencow_pendingJobs ??= []);
+const _failedJobs: FailedJob[] = ((globalThis as any).__gencow_failedJobs ??= []);
 
 /** 최대 보관할 실패 작업 수 (메모리 보호) */
 const MAX_FAILED_JOBS = 100;
 
 export function getSchedulerInfo() {
-    return {
-        crons: _cronInfo,
-        pendingJobs: _pendingJobs,
-        failedJobs: _failedJobs,
-    };
+  return {
+    crons: _cronInfo,
+    pendingJobs: _pendingJobs,
+    failedJobs: _failedJobs,
+  };
 }
 
 export function createScheduler(options?: CreateSchedulerOptions): Scheduler {
-    const timers = new Map<string, NodeJS.Timeout>();
-    const isDurable = !!(options?.persistJob && options?.removeJob);
-    const cronJobs = new Map<string, cron.ScheduledTask>();
-    const actions = new Map<string, ActionHandler>();
+  const timers = new Map<string, NodeJS.Timeout>();
+  const isDurable = !!(options?.persistJob && options?.removeJob);
+  const cronJobs = new Map<string, cron.ScheduledTask>();
+  const actions = new Map<string, ActionHandler>();
 
-    let jobCounter = 0;
+  let jobCounter = 0;
 
-    function generateId(): string {
-        return `job_${++jobCounter}_${Date.now()}`;
-    }
+  function generateId(): string {
+    return `job_${++jobCounter}_${Date.now()}`;
+  }
 
-    /** 실패 기록 추가 (dead-letter 레지스트리) */
-    function recordFailure(id: string, action: string, args: any, error: Error): void {
-        _failedJobs.push({
-            id,
-            action,
-            args,
-            error: error.message,
-            failedAt: new Date().toISOString(),
-        });
-        // 메모리 보호: 오래된 실패 기록 정리
-        while (_failedJobs.length > MAX_FAILED_JOBS) {
-            _failedJobs.shift();
-        }
+  /** 실패 기록 추가 (dead-letter 레지스트리) */
+  function recordFailure(id: string, action: string, args: any, error: Error): void {
+    _failedJobs.push({
+      id,
+      action,
+      args,
+      error: error.message,
+      failedAt: new Date().toISOString(),
+    });
+    // 메모리 보호: 오래된 실패 기록 정리
+    while (_failedJobs.length > MAX_FAILED_JOBS) {
+      _failedJobs.shift();
     }
+  }
 
-    async function executeAction(action: string, args: any): Promise<void> {
-        const handler = actions.get(action);
-        if (!handler) {
-            console.error(`[scheduler] Action "${action}" not registered`);
-            throw new Error(`Action "${action}" not registered`);
-        }
-        await handler(args);
-        console.log(`[scheduler] Action "${action}" completed`);
+  async function executeAction(action: string, args: any): Promise<void> {
+    const handler = actions.get(action);
+    if (!handler) {
+      console.error(`[scheduler] Action "${action}" not registered`);
+      throw new Error(`Action "${action}" not registered`);
     }
+    await handler(args);
+    console.log(`[scheduler] Action "${action}" completed`);
+  }
 
-    /** @internal 인메모리 setTimeout 기반 스케줄링 (로컬 dev + durable fallback) */
-    function scheduleInMemory(id: string, ms: number, action: string, args: any, scheduleOpts: ScheduleOptions | undefined, jobEntry: PendingJobEntry): void {
-        const timer = setTimeout(async () => {
-            jobEntry.status = "running";
-            try {
-                await executeAction(action, args);
-                jobEntry.status = "completed";
-            } catch (error) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                jobEntry.status = "failed";
-                console.error(`[scheduler] Action "${action}" failed (job: ${id}):`, err.message);
+  /** @internal 인메모리 setTimeout 기반 스케줄링 (로컬 dev + durable fallback) */
+  function scheduleInMemory(
+    id: string,
+    ms: number,
+    action: string,
+    args: any,
+    scheduleOpts: ScheduleOptions | undefined,
+    jobEntry: PendingJobEntry,
+  ): void {
+    const timer = setTimeout(async () => {
+      jobEntry.status = "running";
+      try {
+        await executeAction(action, args);
+        jobEntry.status = "completed";
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        jobEntry.status = "failed";
+        console.error(`[scheduler] Action "${action}" failed (job: ${id}):`, err.message);
 
-                // 실패 기록 보관 (dead-letter)
-                recordFailure(id, action, args, err);
+        // 실패 기록 보관 (dead-letter)
+        recordFailure(id, action, args, err);
 
-                // onError 콜백 실행 — 다른 action에 에러 정보 전달
-                if (scheduleOpts?.onError) {
-                    try {
-                        await executeAction(scheduleOpts.onError, {
-                            failedAction: action,
-                            failedJobId: id,
-                            error: err.message,
-                            originalArgs: args,
-                        });
-                        console.log(`[scheduler] onError handler "${scheduleOpts.onError}" completed for "${action}"`);
-                    } catch (onErrorErr) {
-                        console.error(`[scheduler] onError handler "${scheduleOpts.onError}" also failed:`, onErrorErr);
-                    }
-                }
-            } finally {
-                timers.delete(id);
-                // completed/failed 기록은 잠시 유지 후 정리 (status 조회 가능하도록)
-                setTimeout(() => {
-                    const idx = _pendingJobs.findIndex((j) => j.id === id);
-                    if (idx >= 0) _pendingJobs.splice(idx, 1);
-                }, 60_000); // 1분 후 정리
-            }
-        }, ms);
-        timers.set(id, timer);
-        console.log(
-            `[scheduler] Scheduled "${action}" to run after ${ms}ms (id: ${id})${scheduleOpts?.onError ? ` [onError: ${scheduleOpts.onError}]` : ""}`
-        );
-    }
-
-    return {
-        runAfter(ms: number, action: string, args?: any, scheduleOpts?: ScheduleOptions): string {
-            const id = generateId();
-            const jobEntry: PendingJobEntry = { id, action, scheduledAt: new Date().toISOString(), status: "pending" };
-            _pendingJobs.push(jobEntry);
+        // onError 콜백 실행 — 다른 action에 에러 정보 전달
+        if (scheduleOpts?.onError) {
+          try {
+            await executeAction(scheduleOpts.onError, {
+              failedAction: action,
+              failedJobId: id,
+              error: err.message,
+              originalArgs: args,
+            });
+            console.log(`[scheduler] onError handler "${scheduleOpts.onError}" completed for "${action}"`);
+          } catch (onErrorErr) {
+            console.error(`[scheduler] onError handler "${scheduleOpts.onError}" also failed:`, onErrorErr);
+          }
+        }
+      } finally {
+        timers.delete(id);
+        // completed/failed 기록은 잠시 유지 후 정리 (status 조회 가능하도록)
+        setTimeout(() => {
+          const idx = _pendingJobs.findIndex((j) => j.id === id);
+          if (idx >= 0) _pendingJobs.splice(idx, 1);
+        }, 60_000); // 1분 후 정리
+      }
+    }, ms);
+    timers.set(id, timer);
+    console.log(
+      `[scheduler] Scheduled "${action}" to run after ${ms}ms (id: ${id})${scheduleOpts?.onError ? ` [onError: ${scheduleOpts.onError}]` : ""}`,
+    );
+  }
 
-            // ── Durable mode: DB에 영속화, 실행은 외부 폴러에 위임 ──
-            if (isDurable) {
-                const runAt = new Date(Date.now() + ms);
-                options!.persistJob!({
-                    id,
-                    action,
-                    args: args ?? {},
-                    runAt,
-                    onErrorAction: scheduleOpts?.onError,
-                }).then(() => {
-                    console.log(
-                        `[scheduler] Persisted "${action}" to run at ${runAt.toISOString()} (id: ${id}, durable)` +
-                        `${scheduleOpts?.onError ? ` [onError: ${scheduleOpts.onError}]` : ""}`
-                    );
-                }).catch((err) => {
-                    console.error(`[scheduler] Failed to persist job ${id}:`, err instanceof Error ? err.message : err);
-                    // DB persist 실패 → 인메모리 fallback
-                    scheduleInMemory(id, ms, action, args, scheduleOpts, jobEntry);
-                });
-                return id;
-            }
+  return {
+    runAfter(ms: number, action: string, args?: any, scheduleOpts?: ScheduleOptions): string {
+      const id = generateId();
+      const jobEntry: PendingJobEntry = {
+        id,
+        action,
+        scheduledAt: new Date().toISOString(),
+        status: "pending",
+      };
+      _pendingJobs.push(jobEntry);
 
-            // ── 인메모리 mode: 기존 setTimeout 동작 ──
+      // ── Durable mode: DB에 영속화, 실행은 외부 폴러에 위임 ──
+      if (isDurable) {
+        const runAt = new Date(Date.now() + ms);
+        options!.persistJob!({
+          id,
+          action,
+          args: args ?? {},
+          runAt,
+          onErrorAction: scheduleOpts?.onError,
+        })
+          .then(() => {
+            console.log(
+              `[scheduler] Persisted "${action}" to run at ${runAt.toISOString()} (id: ${id}, durable)` +
+                `${scheduleOpts?.onError ? ` [onError: ${scheduleOpts.onError}]` : ""}`,
+            );
+          })
+          .catch((err) => {
+            console.error(
+              `[scheduler] Failed to persist job ${id}:`,
+              err instanceof Error ? err.message : err,
+            );
+            // DB persist 실패 → 인메모리 fallback
             scheduleInMemory(id, ms, action, args, scheduleOpts, jobEntry);
-            return id;
-        },
+          });
+        return id;
+      }
 
-        runAt(timestamp: number | Date, action: string, args?: any, options?: ScheduleOptions): string {
-            const target =
-                timestamp instanceof Date ? timestamp.getTime() : timestamp;
-            const ms = Math.max(0, target - Date.now());
-            return this.runAfter(ms, action, args, options);
-        },
+      // ── 인메모리 mode: 기존 setTimeout 동작 ──
+      scheduleInMemory(id, ms, action, args, scheduleOpts, jobEntry);
+      return id;
+    },
 
-        cancel(jobId: string): boolean {
-            // ── Durable mode: DB에서도 제거 ──
-            if (isDurable) {
-                const idx = _pendingJobs.findIndex((j) => j.id === jobId);
-                if (idx >= 0) {
-                    _pendingJobs.splice(idx, 1);
-                    options!.removeJob!(jobId).catch((err) => {
-                        console.error(`[scheduler] Failed to remove persisted job ${jobId}:`, err instanceof Error ? err.message : err);
-                    });
-                    console.log(`[scheduler] Cancelled job ${jobId} (durable)`);
-                    return true;
-                }
-                // pendingJobs에 없어도 DB에는 있을 수 있으므로 삭제 시도
-                options!.removeJob!(jobId).catch(() => {});
-                return false;
-            }
+    runAt(timestamp: number | Date, action: string, args?: any, options?: ScheduleOptions): string {
+      const target = timestamp instanceof Date ? timestamp.getTime() : timestamp;
+      const ms = Math.max(0, target - Date.now());
+      return this.runAfter(ms, action, args, options);
+    },
 
-            // ── 인메모리 mode ──
-            const timer = timers.get(jobId);
-            if (timer) {
-                clearTimeout(timer);
-                timers.delete(jobId);
-                const idx = _pendingJobs.findIndex((j) => j.id === jobId);
-                if (idx >= 0) _pendingJobs.splice(idx, 1);
-                console.log(`[scheduler] Cancelled job ${jobId}`);
-                return true;
-            }
-            return false;
-        },
+    cancel(jobId: string): boolean {
+      // ── Durable mode: DB에서도 제거 ──
+      if (isDurable) {
+        const idx = _pendingJobs.findIndex((j) => j.id === jobId);
+        if (idx >= 0) {
+          _pendingJobs.splice(idx, 1);
+          options!.removeJob!(jobId).catch((err) => {
+            console.error(
+              `[scheduler] Failed to remove persisted job ${jobId}:`,
+              err instanceof Error ? err.message : err,
+            );
+          });
+          console.log(`[scheduler] Cancelled job ${jobId} (durable)`);
+          return true;
+        }
+        // pendingJobs에 없어도 DB에는 있을 수 있으므로 삭제 시도
+        options!.removeJob!(jobId).catch(() => {});
+        return false;
+      }
 
-        cron(name: string, pattern: string, handler: () => Promise<void>): void {
-            if (cronJobs.has(name)) {
-                cronJobs.get(name)!.stop();
-            }
-            const task = cron.schedule(pattern, async () => {
-                console.log(`[scheduler] Cron "${name}" triggered`);
-                try {
-                    await handler();
-                } catch (error) {
-                    const err = error instanceof Error ? error : new Error(String(error));
-                    console.error(`[scheduler] Cron "${name}" failed:`, err.message);
-                    // cron 실패도 dead-letter에 기록
-                    recordFailure(`cron_${name}_${Date.now()}`, `cron:${name}`, {}, err);
-                }
-            });
-            cronJobs.set(name, task);
-            _cronInfo.push({ name, pattern, registeredAt: new Date().toISOString() });
-            console.log(`[scheduler] Registered cron "${name}" with pattern "${pattern}"`);
-        },
+      // ── 인메모리 mode ──
+      const timer = timers.get(jobId);
+      if (timer) {
+        clearTimeout(timer);
+        timers.delete(jobId);
+        const idx = _pendingJobs.findIndex((j) => j.id === jobId);
+        if (idx >= 0) _pendingJobs.splice(idx, 1);
+        console.log(`[scheduler] Cancelled job ${jobId}`);
+        return true;
+      }
+      return false;
+    },
+
+    cron(name: string, pattern: string, handler: () => Promise<void>): void {
+      if (cronJobs.has(name)) {
+        cronJobs.get(name)!.stop();
+      }
+      const task = cron.schedule(pattern, async () => {
+        console.log(`[scheduler] Cron "${name}" triggered`);
+        try {
+          await handler();
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          console.error(`[scheduler] Cron "${name}" failed:`, err.message);
+          // cron 실패도 dead-letter에 기록
+          recordFailure(`cron_${name}_${Date.now()}`, `cron:${name}`, {}, err);
+        }
+      });
+      cronJobs.set(name, task);
+      _cronInfo.push({ name, pattern, registeredAt: new Date().toISOString() });
+      console.log(`[scheduler] Registered cron "${name}" with pattern "${pattern}"`);
+    },
+
+    registerAction(name: string, handler: ActionHandler): void {
+      actions.set(name, handler);
+    },
 
-        registerAction(name: string, handler: ActionHandler): void {
-            actions.set(name, handler);
-        },
+    async executeActionStrict(name: string, args?: any): Promise<void> {
+      await executeAction(name, args);
+    },
 
-        async executeAction(name: string, args?: any): Promise<void> {
-            try {
-                await executeAction(name, args);
-            } catch (error) {
-                // 공개 API는 에러를 삼긴다 (호출자 크래시 방지)
-                // handler 에러도 로깅 (내부 함수는 미등록만 로깅, handler 에러는 미로깅)
-                const msg = error instanceof Error ? error.message : String(error);
-                console.error(`[scheduler] executeAction("${name}") failed: ${msg}`);
-            }
-        },
-    };
+    async executeAction(name: string, args?: any): Promise<void> {
+      try {
+        await executeAction(name, args);
+      } catch (error) {
+        // 공개 API는 에러를 삼긴다 (호출자 크래시 방지)
+        // handler 에러도 로깅 (내부 함수는 미등록만 로깅, handler 에러는 미로깅)
+        const msg = error instanceof Error ? error.message : String(error);
+        console.error(`[scheduler] executeAction("${name}") failed: ${msg}`);
+      }
+    },
+  };
 }

package/src/server.ts

@@ -5,7 +5,6 @@
  * executing server. Excluded from client-side core (`index.ts`) so they aren't
  * bundled into user functions which run in Firecracker.
  */
-export { createDb } from "./db.js";
 export { createStorage, storageRoutes } from "./storage.js";
 export type { StorageImageTierConfig } from "./storage.js";
 export { createScheduler, getSchedulerInfo } from "./scheduler.js";