gencow 0.1.146 → 0.1.148

package/bin/gencow.mjs

@@ -39,6 +39,7 @@ import {
   updateEnvLocalUrl,
 } from "../lib/cli-project-runtime.mjs";
 import { createCodegenCommand } from "../lib/codegen-command.mjs";
+import { maybeCheckCliVersion } from "../lib/cli-version-check.mjs";
 import { updateComponentReadme } from "../lib/component-readme.mjs";
 import { createConfigCommand } from "../lib/config-command.mjs";
 import { createCorsCommand } from "../lib/cors-command.mjs";
@@ -81,6 +82,8 @@ import {
 import { platformFetch, requireCreds, rpcMutation, rpcQuery } from "../lib/platform-client.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const CLI_PACKAGE_JSON = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf8"));
+const CLI_VERSION = CLI_PACKAGE_JSON.version || "0.0.0";
 const _drizzleKitCmd = (subcmd, options = {}) => buildDrizzleKitCommand(subcmd, options);
 const generateApiTs = createApiCodegenRuntime({});
 const runAddCommand = createAddCommand({
@@ -282,6 +285,7 @@ const commands = {
   help() {
     log(`
 ${BOLD}${CYAN}Gencow CLI${RESET}  ${DIM}— AI Backend Engine${RESET}
+${DIM}Version: ${CLI_VERSION}${RESET}
 
 ${BOLD}Usage:${RESET}
   gencow <command>
@@ -382,6 +386,10 @@ ${BOLD}Examples:${RESET}
 `);
   },
 
+  version() {
+    log(CLI_VERSION);
+  },
+
   // ── login/logout/whoami ───────────────────────────────
   login: runLoginCommand,
   logout: runLogoutCommand,
@@ -455,7 +463,15 @@ ${BOLD}Examples:${RESET}
 
 // ─── updateReadme: gencow/ 폴더 스캔 → README에 컴포넌트 문서 자동 추가 ────
 
-const [, , cmd = "help", ...args] = process.argv;
+const [, , rawCmd = "help", ...args] = process.argv;
+const cmd = rawCmd === "--help" || rawCmd === "-h" ? "help" : rawCmd === "--version" || rawCmd === "-v" ? "version" : rawCmd;
+maybeCheckCliVersion({
+  command: cmd,
+  currentVersion: CLI_VERSION,
+  errorImpl: error,
+  processEnv: process.env,
+  warnImpl: warn,
+});
 
 if (commands[cmd]) {
   Promise.resolve(commands[cmd](...args)).catch((e) => {

package/core/index.js

@@ -3258,49 +3258,57 @@ async function withRlsConnection(session, rls, reuseOuterConnection, fn) {
 }
 function wrapPreparedQuery(pq, session, rls, reuseOuterConnection) {
   const origExecute = pq.execute.bind(pq);
-  const origAll = pq.all.bind(pq);
+  const origAll = typeof pq.all === "function" ? pq.all.bind(pq) : null;
+  const swapClient = (client) => {
+    const prevPq = pq.client;
+    const prevSession = session.client;
+    pq.client = client;
+    session.client = client;
+    return () => {
+      pq.client = prevPq;
+      session.client = prevSession;
+    };
+  };
   pq.execute = async (placeholderValues) => {
     const active = rlsExecClient.getStore();
     if (active) {
-      const prev = pq.client;
-      pq.client = active;
+      const restore = swapClient(active);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     }
     return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
+      const restore = swapClient(client);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     });
   };
-  pq.all = async (placeholderValues) => {
-    const active = rlsExecClient.getStore();
-    if (active) {
-      const prev = pq.client;
-      pq.client = active;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
-      }
-    }
-    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
+  if (origAll) {
+    pq.all = async (placeholderValues) => {
+      const active = rlsExecClient.getStore();
+      if (active) {
+        const restore = swapClient(active);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
       }
-    });
-  };
+      return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+        const restore = swapClient(client);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
+      });
+    };
+  }
 }
 function wrapSession(session, rls, reuseOuterConnection) {
   return new Proxy(session, {

package/lib/add-command.mjs

@@ -5,7 +5,7 @@ import { dirname, relative, resolve } from "path";
 export const ADD_COMPONENTS = {
   ai: {
     label: "AI Engine",
-    deps: ["ai", "@ai-sdk/openai"],
+    deps: ["ai", "@ai-sdk/openai", "@ai-sdk/provider-utils"],
     files: [{ src: "ai.ts", dest: "gencow/ai.ts" }],
     env: { OPENAI_API_KEY: "" },
     requires: [],

package/lib/cli-artifact-guard.mjs

@@ -0,0 +1,70 @@
+export const REQUIRED_CLI_TARBALL_FILES = Object.freeze([
+  "bin/gencow.mjs",
+  "bin/gencow-mcp.mjs",
+  "lib/readme-codegen.mjs",
+  "lib/deploy-auditor.mjs",
+  "lib/cron-manifest.mjs",
+  "lib/dev-cloud-bundle.mjs",
+  "lib/codegen/index.mjs",
+  "server/index.js",
+  "core/index.js",
+  "dashboard/index.html",
+]);
+
+const FORBIDDEN_CODEGEN_CORE_IMPORTS = Object.freeze([
+  {
+    id: "server-only-procedure-route-collector",
+    pattern: /(?:import\s*{[^}]*\bcollectProcedureRouteMaps\b[^}]*}\s*from\s*["']@gencow\/core["']|collectProcedureRouteMaps[\s\S]{0,240}from\s*["']@gencow\/core["'])/,
+    message: "@gencow/core에서 server-only procedure route collector를 import합니다",
+  },
+]);
+
+export function validateCliTarballFiles(files, requiredFiles = REQUIRED_CLI_TARBALL_FILES) {
+  const fileSet = new Set(files);
+  const errors = [];
+  const forbiddenSourceFiles = files.filter((path) => path === "src" || path.startsWith("src/"));
+
+  for (const path of forbiddenSourceFiles) {
+    errors.push({
+      code: "forbidden-source-file",
+      path,
+      message: "packages/cli/src 는 npm tarball에 포함되면 안 됩니다",
+    });
+  }
+
+  for (const path of requiredFiles) {
+    if (!fileSet.has(path)) {
+      errors.push({
+        code: "missing-required-file",
+        path,
+        message: "필수 CLI artifact가 npm tarball에 없습니다",
+      });
+    }
+  }
+
+  return {
+    ok: errors.length === 0,
+    errors,
+  };
+}
+
+export function validateGeneratedCodegenBundle(source) {
+  const errors = [];
+  for (const rule of FORBIDDEN_CODEGEN_CORE_IMPORTS) {
+    if (rule.pattern.test(source)) {
+      errors.push({
+        code: rule.id,
+        path: "lib/codegen/index.mjs",
+        message: rule.message,
+      });
+    }
+  }
+  return {
+    ok: errors.length === 0,
+    errors,
+  };
+}
+
+export function formatArtifactGuardErrors(errors) {
+  return errors.map((error) => `  ❌ ${error.path} — ${error.message}`).join("\n");
+}

package/lib/cli-dev-runtime.mjs

@@ -8,7 +8,6 @@ import {
   resolveCodegenConfig,
   resolveCodegenPublishDir,
 } from "./codegen-command.mjs";
-import { generateAuthSchema } from "./codegen/index.mjs";
 import { updateComponentReadme } from "./component-readme.mjs";
 import { buildReadmeMarkdown, extractComponentsBlock } from "./readme-codegen.mjs";
 import { CYAN, DIM, RED, RESET, YELLOW, error, info, log, success, warn } from "./output.mjs";
@@ -146,7 +145,7 @@ export function createApiCodegenRuntime(options = {}) {
     resolvePathImpl = resolve,
     successImpl = success,
     updateComponentReadmeImpl = updateComponentReadme,
-    generateAuthSchemaImpl = generateAuthSchema,
+    generateAuthSchemaImpl,
     warnImpl = warn,
     writeFileSyncImpl = writeFileSync,
   } = options;
@@ -176,6 +175,7 @@ export function createApiCodegenRuntime(options = {}) {
       if (typeof bundled.createNodeProcessRunner !== "function") {
         throw new Error("Invalid codegen bundle: createNodeProcessRunner export not found");
       }
+      const generateAuthSchema = generateAuthSchemaImpl ?? bundled.generateAuthSchema;
 
       const result = await bundled.runCodegen({
         projectRoot: cwd,
@@ -185,7 +185,7 @@ export function createApiCodegenRuntime(options = {}) {
         finalOutDir: publishDir,
         authSchema: {
           enabled: resolveCodegenConfig(config).authSchema,
-          generate: generateAuthSchemaImpl,
+          generate: generateAuthSchema,
         },
       });
       if (result.authSchema?.changed) {

package/lib/cli-version-check.mjs

@@ -0,0 +1,146 @@
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+
+const DEFAULT_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_NPM_TIMEOUT_MS = 1500;
+
+function isEnabled(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+
+export function parseCliSemver(version) {
+  const match = String(version ?? "").trim().match(/^v?(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  };
+}
+
+export function compareCliSemver(left, right) {
+  const a = typeof left === "string" ? parseCliSemver(left) : left;
+  const b = typeof right === "string" ? parseCliSemver(right) : right;
+  if (!a || !b) return 0;
+  for (const key of ["major", "minor", "patch"]) {
+    if (a[key] > b[key]) return 1;
+    if (a[key] < b[key]) return -1;
+  }
+  return 0;
+}
+
+export function shouldWarnForStaleCli({ currentVersion, latestVersion }) {
+  return compareCliSemver(latestVersion, currentVersion) > 0;
+}
+
+export function resolveVersionCheckCachePath({ homeDir = homedir(), processEnv = process.env } = {}) {
+  return processEnv.GENCOW_VERSION_CHECK_CACHE || resolve(homeDir, ".gencow", "version-check.json");
+}
+
+function readCache(cachePath, { existsSyncImpl = existsSync, readFileSyncImpl = readFileSync } = {}) {
+  try {
+    if (!existsSyncImpl(cachePath)) return {};
+    return JSON.parse(readFileSyncImpl(cachePath, "utf8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeCache(cachePath, cache, { mkdirSyncImpl = mkdirSync, writeFileSyncImpl = writeFileSync } = {}) {
+  try {
+    mkdirSyncImpl(dirname(cachePath), { recursive: true });
+    writeFileSyncImpl(cachePath, JSON.stringify(cache, null, 2) + "\n");
+  } catch {
+    /* version check cache must never break CLI commands */
+  }
+}
+
+function isFresh(timestamp, now, maxAgeMs) {
+  return typeof timestamp === "number" && now - timestamp >= 0 && now - timestamp < maxAgeMs;
+}
+
+function fetchLatestVersion({ execFileSyncImpl = execFileSync, timeoutMs = DEFAULT_NPM_TIMEOUT_MS } = {}) {
+  return String(
+    execFileSyncImpl("npm", ["view", "gencow", "version", "--silent"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: timeoutMs,
+    }),
+  ).trim();
+}
+
+export function formatStaleCliWarning({ currentVersion, latestVersion, command }) {
+  const suffix = command ? ` ${command}` : "";
+  return [
+    `Gencow CLI is older than npm latest (current ${currentVersion}, latest ${latestVersion}).`,
+    `Use project-local/latest CLI for verification: bunx gencow@latest${suffix}`,
+    "If this came from a global install, check: which gencow && gencow --version",
+    "Skip this check with GENCOW_SKIP_VERSION_CHECK=true.",
+  ].join("\n");
+}
+
+export function maybeCheckCliVersion({
+  cacheMaxAgeMs = DEFAULT_CACHE_MAX_AGE_MS,
+  command,
+  currentVersion,
+  errorImpl = console.error,
+  execFileSyncImpl = execFileSync,
+  exitImpl = (code) => process.exit(code),
+  existsSyncImpl = existsSync,
+  homeDirImpl = homedir,
+  mkdirSyncImpl = mkdirSync,
+  nowImpl = () => Date.now(),
+  processEnv = process.env,
+  readFileSyncImpl = readFileSync,
+  warnImpl = console.warn,
+  writeFileSyncImpl = writeFileSync,
+} = {}) {
+  if (isEnabled(processEnv.GENCOW_SKIP_VERSION_CHECK)) {
+    return { status: "skipped" };
+  }
+  if (command === "help" || command === "version") {
+    return { status: "skipped" };
+  }
+
+  const requireLatest = isEnabled(processEnv.GENCOW_REQUIRE_LATEST_CLI);
+  const now = nowImpl();
+  const cachePath = resolveVersionCheckCachePath({ homeDir: homeDirImpl(), processEnv });
+  const cache = readCache(cachePath, { existsSyncImpl, readFileSyncImpl });
+  let latestVersion = cache.latestVersion;
+
+  if (!latestVersion || !isFresh(cache.checkedAt, now, cacheMaxAgeMs)) {
+    try {
+      latestVersion = fetchLatestVersion({ execFileSyncImpl });
+      cache.latestVersion = latestVersion;
+      cache.checkedAt = now;
+      writeCache(cachePath, cache, { mkdirSyncImpl, writeFileSyncImpl });
+    } catch (caught) {
+      return { status: "unverified", error: caught };
+    }
+  }
+
+  if (!shouldWarnForStaleCli({ currentVersion, latestVersion })) {
+    return { status: "fresh", latestVersion };
+  }
+
+  const message = formatStaleCliWarning({ currentVersion, latestVersion, command });
+  if (requireLatest) {
+    errorImpl(message);
+    exitImpl(1);
+    return { status: "blocked", latestVersion };
+  }
+
+  const warnedRecently =
+    cache.warnedForVersion === latestVersion && isFresh(cache.warnedAt, now, cacheMaxAgeMs);
+  if (!warnedRecently) {
+    warnImpl(message);
+    cache.warnedAt = now;
+    cache.warnedForVersion = latestVersion;
+    writeCache(cachePath, cache, { mkdirSyncImpl, writeFileSyncImpl });
+    return { status: "warned", latestVersion };
+  }
+
+  return { status: "stale-suppressed", latestVersion };
+}

package/lib/codegen/index.mjs

@@ -6557,49 +6557,57 @@ async function withRlsConnection(session, rls, reuseOuterConnection, fn) {
 }
 function wrapPreparedQuery(pq, session, rls, reuseOuterConnection) {
   const origExecute = pq.execute.bind(pq);
-  const origAll = pq.all.bind(pq);
+  const origAll = typeof pq.all === "function" ? pq.all.bind(pq) : null;
+  const swapClient = (client) => {
+    const prevPq = pq.client;
+    const prevSession = session.client;
+    pq.client = client;
+    session.client = client;
+    return () => {
+      pq.client = prevPq;
+      session.client = prevSession;
+    };
+  };
   pq.execute = async (placeholderValues) => {
     const active = rlsExecClient.getStore();
     if (active) {
-      const prev = pq.client;
-      pq.client = active;
+      const restore = swapClient(active);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     }
     return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
+      const restore = swapClient(client);
       try {
         return await origExecute(placeholderValues);
       } finally {
-        pq.client = prev;
+        restore();
       }
     });
   };
-  pq.all = async (placeholderValues) => {
-    const active = rlsExecClient.getStore();
-    if (active) {
-      const prev = pq.client;
-      pq.client = active;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
-      }
-    }
-    return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
-      const prev = pq.client;
-      pq.client = client;
-      try {
-        return await origAll(placeholderValues);
-      } finally {
-        pq.client = prev;
+  if (origAll) {
+    pq.all = async (placeholderValues) => {
+      const active = rlsExecClient.getStore();
+      if (active) {
+        const restore = swapClient(active);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
       }
-    });
-  };
+      return withRlsConnection(session, rls, reuseOuterConnection, async (client) => {
+        const restore = swapClient(client);
+        try {
+          return await origAll(placeholderValues);
+        } finally {
+          restore();
+        }
+      });
+    };
+  }
 }
 function wrapSession(session, rls, reuseOuterConnection) {
   return new Proxy(session, {

package/lib/codegen-command.mjs

@@ -1,6 +1,5 @@
 import { existsSync } from "fs";
 import { resolve, relative } from "path";
-import { generateAuthSchema } from "./codegen/index.mjs";
 
 export function resolveCodegenConfig(config = {}) {
   const outDir =
@@ -85,6 +84,7 @@ export function createCodegenCommand(deps) {
       if (typeof bundled.runCodegen !== "function") {
         throw new Error("Invalid codegen bundle: runCodegen export not found");
       }
+      const generateAuthSchema = deps.generateAuthSchemaImpl ?? bundled.generateAuthSchema;
       const result = await bundled.runCodegen({
         projectRoot: cwd,
         functionsDir: config.functionsDir,
@@ -93,7 +93,7 @@ export function createCodegenCommand(deps) {
         finalOutDir: publishDir,
         authSchema: {
           enabled: codegen.authSchema,
-          generate: deps.generateAuthSchemaImpl ?? generateAuthSchema,
+          generate: generateAuthSchema,
         },
       });
       if (result.authSchema?.changed) {

package/lib/cron-manifest.mjs

@@ -0,0 +1,142 @@
+import { createHash } from "crypto";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { pathToFileURL } from "url";
+
+export const CRON_MANIFEST_RELATIVE_PATH = ".gencow/cron-jobs.json";
+
+function resolveCronDefinitionsFile({ cwd, functionsDir, existsSyncImpl, resolvePathImpl }) {
+  const cronsTs = resolvePathImpl(cwd, functionsDir, "crons.ts");
+  const cronsJs = resolvePathImpl(cwd, functionsDir, "crons.js");
+  if (existsSyncImpl(cronsTs)) return cronsTs;
+  if (existsSyncImpl(cronsJs)) return cronsJs;
+  return null;
+}
+
+function readNonEmptyString(value, field) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new Error(`cron job ${field} must be a non-empty string`);
+  }
+  return value;
+}
+
+function normalizeCronJobs(rawJobs) {
+  if (!Array.isArray(rawJobs)) throw new Error("crons.getJobs() must return an array");
+
+  const jobs = [];
+  const skipped = [];
+  rawJobs.forEach((job, index) => {
+    if (!job || typeof job !== "object" || Array.isArray(job)) {
+      throw new Error(`cron job ${index} must be an object`);
+    }
+    if (typeof job.action !== "string") {
+      skipped.push({
+        name: typeof job.name === "string" && job.name.trim() ? job.name : `jobs[${index}]`,
+        reason: "inline action is not supported in cloud cron manifest",
+      });
+      return;
+    }
+    jobs.push({
+      name: readNonEmptyString(job.name, `${index}.name`),
+      pattern: readNonEmptyString(job.pattern, `${index}.pattern`),
+      action: readNonEmptyString(job.action, `${index}.action`),
+    });
+  });
+
+  return { jobs, skipped, skippedInlineCount: skipped.length };
+}
+
+function writeFallbackCoreShim(coreTarget, mkdirSyncImpl, writeFileSyncImpl) {
+  mkdirSyncImpl(coreTarget, { recursive: true });
+  writeFileSyncImpl(
+    resolve(coreTarget, "package.json"),
+    JSON.stringify({ name: "@gencow/core", type: "module", main: "index.js" }, null, 2),
+  );
+  writeFileSyncImpl(
+    resolve(coreTarget, "index.js"),
+    [
+      "export function cronJobs() {",
+      "  const jobs = [];",
+      "  const builder = {",
+      "    interval(name, options, action) {",
+      "      if (options?.seconds) jobs.push({ name, pattern: `*/${options.seconds} * * * * *`, action });",
+      "      else if (options?.minutes) jobs.push({ name, pattern: `*/${options.minutes} * * * *`, action });",
+      "      else if (options?.hours) jobs.push({ name, pattern: `0 */${options.hours} * * *`, action });",
+      "      else throw new Error(\"interval cron requires seconds, minutes, or hours\");",
+      "      return builder;",
+      "    },",
+      "    daily(name, options, action) { jobs.push({ name, pattern: `${options.minute ?? 0} ${options.hour} * * *`, action }); return builder; },",
+      "    weekly(name, options, action) { jobs.push({ name, pattern: `${options.minute ?? 0} ${options.hour} * * ${options.dayOfWeek}`, action }); return builder; },",
+      "    cron(name, pattern, action) { jobs.push({ name, pattern, action }); return builder; },",
+      "    getJobs() { return [...jobs]; },",
+      "  };",
+      "  return builder;",
+      "}",
+      "",
+    ].join("\n"),
+  );
+}
+
+function installCronCoreShim({ workDir, mkdirSyncImpl, resolvePathImpl, writeFileSyncImpl }) {
+  const coreTarget = resolvePathImpl(workDir, "node_modules", "@gencow", "core");
+  mkdirSyncImpl(dirname(coreTarget), { recursive: true });
+  writeFallbackCoreShim(coreTarget, mkdirSyncImpl, writeFileSyncImpl);
+}
+
+export async function writeCronManifestForProject({
+  cwd,
+  functionsDir = "gencow",
+  cpSyncImpl = cpSync,
+  existsSyncImpl = existsSync,
+  mkdirSyncImpl = mkdirSync,
+  readFileSyncImpl = readFileSync,
+  resolvePathImpl = resolve,
+  rmSyncImpl = rmSync,
+  writeFileSyncImpl = writeFileSync,
+} = {}) {
+  if (!cwd) throw new Error("cwd is required to write cron manifest");
+
+  const cronsFile = resolveCronDefinitionsFile({ cwd, functionsDir, existsSyncImpl, resolvePathImpl });
+  const manifestPath = resolvePathImpl(cwd, CRON_MANIFEST_RELATIVE_PATH);
+  if (!cronsFile) {
+    rmSyncImpl(manifestPath, { force: true });
+    return null;
+  }
+
+  const workDir = resolvePathImpl(cwd, ".gencow", "cron-manifest-workdir");
+  const stagedFunctionsDir = resolvePathImpl(workDir, functionsDir);
+  rmSyncImpl(workDir, { recursive: true, force: true });
+  mkdirSyncImpl(dirname(stagedFunctionsDir), { recursive: true });
+
+  try {
+    cpSyncImpl(resolvePathImpl(cwd, functionsDir), stagedFunctionsDir, { recursive: true });
+    installCronCoreShim({ workDir, mkdirSyncImpl, resolvePathImpl, writeFileSyncImpl });
+
+    const cronsFileName = cronsFile.endsWith(".js") ? "crons.js" : "crons.ts";
+    const stagedCronsFile = resolvePathImpl(stagedFunctionsDir, cronsFileName);
+    const importUrl = `${pathToFileURL(stagedCronsFile).href}?v=${Date.now()}-${Math.random()}`;
+    const module = await import(importUrl);
+    const builder = module.default ?? module.crons;
+    if (!builder || typeof builder.getJobs !== "function") {
+      throw new Error("crons.ts must export default cronJobs() builder");
+    }
+
+    const { jobs, skipped, skippedInlineCount } = normalizeCronJobs(builder.getJobs());
+    const sourceHash = createHash("sha256").update(readFileSyncImpl(cronsFile)).digest("hex");
+    const manifest = {
+      version: 1,
+      generatedAt: new Date().toISOString(),
+      source: `${functionsDir}/${cronsFileName}`,
+      sourceHash: `sha256:${sourceHash}`,
+      skipped,
+      skippedInlineCount,
+      jobs,
+    };
+
+    mkdirSyncImpl(dirname(manifestPath), { recursive: true });
+    writeFileSyncImpl(manifestPath, JSON.stringify(manifest, null, 2));
+    return { manifestPath, manifest };
+  } finally {
+    rmSyncImpl(workDir, { recursive: true, force: true });
+  }
+}

package/lib/deploy-dependency-compat.mjs

@@ -10,7 +10,7 @@ export const DEPENDENCY_COMPAT_MATRIX = Object.freeze([
   },
   {
     packageName: "drizzle-orm",
-    expectedRange: "workspace:* || ^1.0.0-beta || ^1.0.0",
+    expectedRange: "workspace:* || ^1.0.0-beta || ^1.0.0-rc || ^1.0.0",
     installRange: "drizzle-orm@^1.0.0",
     policy: "block",
   },
@@ -145,10 +145,7 @@ function clausesCompatible(current, expected) {
 
   if (expectedVersion.major === 0) {
     if (currentVersion.major !== 0 || currentVersion.minor !== expectedVersion.minor) return false;
-    if (currentVersion.operator === "exact") {
-      return compareVersions(currentVersion, expectedVersion) >= 0;
-    }
-    return true;
+    return compareVersions(currentVersion, expectedVersion) >= 0;
   }
 
   if (currentVersion.major !== expectedVersion.major) return false;