@rebasepro/server 0.24.0 → 0.24.1-canary.gcb918fc

package/dist/contract-routes-Ey6ftnKH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-routes-Ey6ftnKH.js","names":[],"sources":["../../types/src/types/collection_contract.ts","../../types/src/types/schema_version.ts","../src/api/contract-routes.ts"],"sourcesContent":["import type { CollectionConfig } from \"./collections\";\n\n/**\n * Serializing collections so they survive a network hop.\n *\n * A collection definition is not plain data. Relations point at their target\n * with a *function* (`target: () => usersCollection`) so two collections can\n * reference each other without an import cycle, and collections also carry\n * callbacks, custom views and component references. `JSON.stringify` silently\n * drops every one of those, which matters because the SDK generator *calls*\n * `relation.target()` to decide whether a foreign key is a string or a number.\n * Serialize naively and remote SDK generation produces subtly wrong types\n * instead of failing — the worst possible outcome.\n *\n * So relation targets are resolved to a slug reference on the way out and\n * rebuilt into functions on the way in. Everything else that cannot cross a wire\n * is dropped deliberately: an SDK is generated from the *shape* of the data, and\n * server-side behaviour is neither useful to a client nor safe to publish.\n */\n\n/** Marker replacing a relation's `target` function in serialized form. */\nexport interface SerializedCollectionRef {\n    __collectionRef: string;\n}\n\nexport function isSerializedCollectionRef(value: unknown): value is SerializedCollectionRef {\n    return typeof value === \"object\"\n        && value !== null\n        && typeof (value as SerializedCollectionRef).__collectionRef === \"string\";\n}\n\n/** Depth limit for the walk — deep enough for real configs, finite for cyclic ones. */\nconst MAX_DEPTH = 64;\n\n/**\n * Resolve whatever a `target` thunk returns down to a collection.\n *\n * A target may be the collection, a module namespace (when the authoring file\n * used `import * as`), or a default-export wrapper. All three appear in real\n * projects, and the SDK generator already unwraps them the same way.\n */\nfunction unwrapTarget(value: unknown): CollectionConfig | undefined {\n    if (!value || typeof value !== \"object\") return undefined;\n    const candidate = value as { default?: unknown; __esModule?: boolean; properties?: unknown };\n    if (candidate.default || candidate.__esModule) {\n        const inner = candidate.default;\n        if (inner && typeof inner === \"object\") return inner as CollectionConfig;\n    }\n    if (candidate.properties) return value as CollectionConfig;\n    return undefined;\n}\n\n/** The identity a serialized reference uses. Slug first — it is the routing key. */\nfunction refFor(collection: CollectionConfig | undefined): string | undefined {\n    if (!collection) return undefined;\n    const withPath = collection as CollectionConfig & { path?: string };\n    return collection.slug || withPath.path || collection.name;\n}\n\n/**\n * Deep-copy a value into something JSON can carry.\n *\n * `target` keys are special-cased into refs. Other functions vanish, cycles are\n * cut, and everything else is copied structurally.\n */\n/** Shared walk state: the memo, plus a count of depth-cap hits. */\ninterface WalkState {\n    memo: WeakMap<object, unknown>;\n    /**\n     * How many times the walk has truncated a subtree — by hitting the depth\n     * cap, or by cutting a cycle.\n     *\n     * Either kind of truncation makes a result valid only at the *position* it\n     * was produced at, so caching it and serving it elsewhere silently drops\n     * content that would have been included. Comparing this counter before and\n     * after a node's children tells us whether its result is position-\n     * independent and therefore safe to memoize.\n     *\n     * The cycle case is the subtle one: with `a.b = b` and `b.a = a`, serializing\n     * `{ first: b, second: a }` visits `a` beneath `b` — where the cycle back to\n     * `b` is cut — and would then reuse that truncated `a` for `second`, where\n     * nothing needed cutting.\n     */\n    truncations: number;\n}\n\nfunction toSerializable(\n    value: unknown,\n    seen: WeakSet<object>,\n    depth: number,\n    state: WalkState,\n    key?: string\n): unknown {\n    if (depth > MAX_DEPTH) {\n        state.truncations++;\n        return undefined;\n    }\n\n    if (typeof value === \"function\") {\n        // Only a relation target carries information a client needs. Calling it\n        // is safe here — this runs on the server, where the target module is\n        // already loaded — and a throwing target simply yields no reference,\n        // which degrades the generated FK type rather than failing the request.\n        if (key === \"target\") {\n            try {\n                const resolved = unwrapTarget((value as () => unknown)());\n                const ref = refFor(resolved);\n                return ref ? { __collectionRef: ref } : undefined;\n            } catch {\n                return undefined;\n            }\n        }\n        return undefined;\n    }\n\n    if (value === null || typeof value !== \"object\") {\n        return value;\n    }\n\n    if (value instanceof Date) return value.toISOString();\n    if (value instanceof RegExp) return value.source;\n\n    if (seen.has(value as object)) {\n        state.truncations++;\n        return undefined;\n    }\n\n    // A shared (non-cyclic) subgraph is reachable by many paths, and `seen` is a\n    // *path* set — released in the `finally` below so a node referenced twice in\n    // different branches is emitted twice rather than dropped as a false cycle.\n    // Without memoization that makes the walk exponential in depth: a diamond\n    // graph 20 levels deep took ~400ms, and each further level doubled it. The\n    // result is a plain data tree, so handing back the same converted object for\n    // a repeat visit is indistinguishable after JSON.stringify.\n    const cached = state.memo.get(value as object);\n    if (cached !== undefined) return cached;\n\n    seen.add(value as object);\n    const truncationsBefore = state.truncations;\n    const memoize = (result: unknown): unknown => {\n        // Only cache a result that nothing was cut from.\n        if (result !== undefined && state.truncations === truncationsBefore) {\n            state.memo.set(value as object, result);\n        }\n        return result;\n    };\n\n    try {\n        if (Array.isArray(value)) {\n            const items = value\n                .map(item => toSerializable(item, seen, depth + 1, state))\n                .filter(item => item !== undefined);\n            // A container that had content, none of which can be represented, is\n            // itself unrepresentable — see the note below.\n            return memoize(value.length > 0 && items.length === 0 ? undefined : items);\n        }\n\n        // A React element or component reference has no meaning to a client and\n        // will not survive JSON anyway.\n        if (\"$$typeof\" in (value as Record<string, unknown>)) return undefined;\n\n        const entries = Object.entries(value as Record<string, unknown>);\n        const out: Record<string, unknown> = {};\n        for (const [k, v] of entries) {\n            const converted = toSerializable(v, seen, depth + 1, state, k);\n            if (converted !== undefined) out[k] = converted;\n        }\n\n        // Drop a container whose entire content was dropped.\n        //\n        // `callbacks: { beforeSave() {…} }` would otherwise serialize to\n        // `callbacks: {}` — an empty husk that carries no information but is not\n        // *nothing*, so it lands in the payload and, worse, in the schema hash.\n        // Editing a hook would then change every client's schema version and\n        // report perfectly current SDKs as stale.\n        //\n        // A container that started empty stays empty: `properties: {}` is a\n        // deliberate statement, not a casualty.\n        if (entries.length > 0 && Object.keys(out).length === 0) return undefined;\n\n        return memoize(out);\n    } finally {\n        // Released so a collection referenced twice in different branches is\n        // emitted twice rather than being dropped as a false cycle.\n        seen.delete(value as object);\n    }\n}\n\n/**\n * Serialize collections for transport over the contract endpoint.\n *\n * Sorted by slug so the output — and therefore the schema hash computed from it\n * — does not depend on filesystem ordering.\n */\nexport function serializeCollections(collections: CollectionConfig[]): unknown[] {\n    return [...collections]\n        .sort((a, b) => String(a.slug ?? \"\").localeCompare(String(b.slug ?? \"\")))\n        .map(collection => toSerializable(withoutAdminBlock(collection), new WeakSet(), 0, {\n            memo: new WeakMap(),\n            truncations: 0\n        }))\n        .filter((c): c is Record<string, unknown> => c !== undefined);\n}\n\n/**\n * Drop the admin block before the walk.\n *\n * Nothing downstream of serialization is an admin panel. The contract endpoint\n * feeds remote SDK generation, and `rebase build` writes the result into a bundle\n * manifest that only the backend runtime reads. The block would survive the walk\n * as a husk anyway — its React elements and component functions are dropped\n * individually — and that husk has two costs worth avoiding: it puts every custom\n * component's *file path* on an endpoint whose job is to describe data shapes, and\n * it grows a payload that is fetched and cached per project.\n *\n * Removing it here rather than at each call site means one chokepoint, so a future\n * consumer of `serializeCollections` cannot forget.\n *\n * Child collections carry their own block, so this recurses — stripping only the\n * top level was the mistake `stripNonClientFields` in the contract routes already\n * had to fix once for security rules.\n */\nfunction withoutAdminBlock(collection: CollectionConfig): CollectionConfig {\n    const { admin: _admin, ...rest } = collection as CollectionConfig & Record<string, unknown>;\n    const nested = rest as Record<string, unknown>;\n    if (Array.isArray(nested.subcollections)) {\n        nested.subcollections = nested.subcollections.map(\n            (child) => withoutAdminBlock(child as CollectionConfig)\n        );\n    }\n    return rest as CollectionConfig;\n}\n\n/**\n * Rebuild collections received from a contract endpoint.\n *\n * Relation refs become real thunks resolving through the returned set, so\n * downstream consumers — the SDK generator above all — see exactly the shape\n * they would have seen had the collections been imported from source.\n *\n * A ref naming a collection that is not in the payload resolves to `undefined`\n * rather than throwing: the generator already tolerates an unresolvable target\n * by falling back to a permissive key type, and a partial contract should still\n * produce a usable SDK.\n */\nexport function deserializeCollections(payload: unknown[]): CollectionConfig[] {\n    const collections = payload\n        .filter((c): c is Record<string, unknown> => typeof c === \"object\" && c !== null)\n        .map(c => ({ ...c })) as unknown as CollectionConfig[];\n\n    const bySlug = new Map<string, CollectionConfig>();\n    for (const collection of collections) {\n        const ref = refFor(collection);\n        if (ref) bySlug.set(ref, collection);\n    }\n\n    const rehydrate = (value: unknown, depth: number): void => {\n        if (depth > MAX_DEPTH || !value || typeof value !== \"object\") return;\n\n        if (Array.isArray(value)) {\n            for (const item of value) rehydrate(item, depth + 1);\n            return;\n        }\n\n        const record = value as Record<string, unknown>;\n        for (const [key, child] of Object.entries(record)) {\n            if (key === \"target\" && isSerializedCollectionRef(child)) {\n                const slug = child.__collectionRef;\n                record.target = () => bySlug.get(slug);\n                continue;\n            }\n            rehydrate(child, depth + 1);\n        }\n    };\n\n    for (const collection of collections) rehydrate(collection, 0);\n    return collections;\n}\n","import type { CollectionConfig } from \"./collections\";\nimport { serializeCollections } from \"./collection_contract\";\n\n/**\n * The schema version stamp.\n *\n * One function, used in three places that must agree or the whole drift-detection\n * story is noise: `rebase build` writes it into a bundle manifest, the runtime\n * serves it from the contract endpoint, and a generated SDK records the value it\n * was built from. If any two of those computed it differently, every client would\n * look permanently out of date.\n *\n * It covers **collections only** — the client's contract is the shape of the\n * data, so editing a hook or a server function must not invalidate every SDK in\n * every repository. That is a deliberate narrowing, not an oversight.\n */\n\n/** Stable stringify: object keys sorted at every level, so key order cannot alter the hash. */\nfunction canonicalize(value: unknown): string {\n    if (value === null || typeof value !== \"object\") {\n        return JSON.stringify(value) ?? \"null\";\n    }\n    if (Array.isArray(value)) {\n        return `[${value.map(canonicalize).join(\",\")}]`;\n    }\n    const entries = Object.entries(value as Record<string, unknown>)\n        .filter(([, v]) => v !== undefined)\n        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n    return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalize(v)}`).join(\",\")}}`;\n}\n\n/**\n * Reduce a collection to the parts a generated client is actually built from.\n *\n * The version answers one question — \"is this SDK stale?\" — so it must change\n * exactly when the generated types could change, and never otherwise. Hashing a\n * whole collection fails both halves of that:\n *\n * - Security rules, callbacks, icons, groups and UI settings do not appear in a\n *   generated client, so including them reports perfectly current SDKs as stale.\n * - Worse, they are not stable *inputs*. The runtime applies default security\n *   rules when it loads collections, so the same source hashed before and after\n *   loading produced two different answers — a build-time stamp that could never\n *   match the server that served it.\n *\n * Codegen reads the slug (for the `Database` key and type names), the properties,\n * and the relations. That is the projection.\n */\nfunction projectForCodegen(collection: CollectionConfig): Record<string, unknown> {\n    const source = collection as CollectionConfig & {\n        relations?: unknown;\n        subcollections?: CollectionConfig[];\n        path?: string;\n        engine?: unknown;\n        dataSource?: unknown;\n    };\n\n    return {\n        slug: collection.slug ?? source.path,\n        properties: collection.properties,\n        relations: source.relations,\n        // The engine decides whether relations are resolved at all: codegen asks\n        // `getDataSourceCapabilities(collection.engine).supportsRelations`, and an\n        // engine that answers no drops every foreign-key column from the\n        // generated Row/Insert/Update types. Moving a collection to such an\n        // engine is a real change to the generated types, so it has to move the\n        // version. `dataSource` is what resolves to `engine`, so it counts too.\n        engine: source.engine,\n        dataSource: source.dataSource,\n        subcollections: source.subcollections?.map(projectForCodegen)\n    };\n}\n\n/**\n * Compute the canonical string a schema version hashes.\n *\n * Exposed separately so the hashing itself can differ by environment: Node has\n * `crypto`, and callers without it can still compare canonical forms directly.\n */\nexport function canonicalSchemaPayload(collections: CollectionConfig[]): string {\n    const projected = serializeCollections(collections)\n        .map(collection => projectForCodegen(collection as CollectionConfig));\n    return canonicalize(projected);\n}\n\n/**\n * A short, non-cryptographic digest of the canonical payload.\n *\n * FNV-1a style, 64 bits, as two 32-bit halves. This is an identity, not a\n * security boundary: nothing trusts a schema version to prove anything, it only\n * answers \"is this the same schema as before\". A hand-rolled hash keeps this\n * module free of `node:crypto`, so the identical function runs in the browser,\n * in the CLI, and in the runtime — which is the property that actually matters.\n */\nexport function computeSchemaVersion(collections: CollectionConfig[]): string {\n    const payload = canonicalSchemaPayload(collections);\n\n    let h1 = 0x811c9dc5;\n    let h2 = 0x01000193;\n\n    for (let i = 0; i < payload.length; i++) {\n        const code = payload.charCodeAt(i);\n        h1 ^= code;\n        // Multiply by the FNV prime using shifts to stay in 32-bit integer math.\n        h1 = (h1 + ((h1 << 1) + (h1 << 4) + (h1 << 7) + (h1 << 8) + (h1 << 24))) >>> 0;\n        h2 ^= code + i;\n        h2 = (h2 + ((h2 << 1) + (h2 << 5) + (h2 << 9) + (h2 << 15) + (h2 << 24))) >>> 0;\n    }\n\n    const hex = (n: number): string => n.toString(16).padStart(8, \"0\");\n    return `v1:${hex(h1)}${hex(h2)}`;\n}\n","import { Hono } from \"hono\";\nimport {\n    RUNTIME_CONTRACT_VERSION,\n    SCHEMA_VERSION_HEADER,\n    computeSchemaVersion,\n    serializeCollections,\n    type CollectionConfig,\n    type RebaseProjectContract\n} from \"@rebasepro/types\";\nimport type { HonoEnv } from \"./types\";\nimport { logger } from \"../utils/logger\";\n\n/**\n * The project contract endpoint.\n *\n * This is what makes a repository able to build against a project it does not\n * contain. Without it, a typed client can only be generated from local\n * collection *source*, which means every frontend must live in the same\n * repository as the backend. Serving the contract turns that around: an app\n * asks the project what its shape is, so a web app, a second web app and a\n * mobile app can each live wherever they like and none of them needs to know\n * about the others.\n *\n * Admin-gated. Collection definitions describe every table, column and relation\n * in the project, including ones no security rule would ever expose — that is a\n * map of the database, not public API documentation.\n */\n\nexport interface ContractRoutesConfig {\n    collectionRegistry: { getRawCollections(): CollectionConfig[] };\n    /**\n     * The schema version recorded at build time.\n     *\n     * Preferred over recomputing, so that what a client is told matches exactly\n     * what the bundle claims. It is recomputed only when a bundle did not record\n     * one — a `baas`-mode project derives its collections from the live database\n     * at boot, so there was nothing to hash when it was built.\n     */\n    schemaVersion?: string;\n    /** Runtime package version, surfaced so a client can report what it built against. */\n    runtimeVersion?: string;\n}\n\n/**\n * Strip everything a client does not need from a serialized collection.\n *\n * The generator reads the slug, the properties and the relations. It never reads\n * a security rule — but `securityRules` carries the raw SQL of every RLS\n * predicate guarding the project, which is a description of the authorization\n * model rather than of the data shape. Publishing it to anyone who can generate\n * an SDK gives away more than the endpoint is for, so it is removed here rather\n * than trusted not to matter.\n */\nfunction stripNonClientFields(collection: unknown): unknown {\n    if (!collection || typeof collection !== \"object\") return collection;\n    const {\n        securityRules: _securityRules,\n        callbacks: _callbacks,\n        ...rest\n    } = collection as Record<string, unknown>;\n\n    // Subcollections are collections, and carry their own rules. Stripping only\n    // the top level published every nested policy — the leak this exists to\n    // prevent, just one level down.\n    if (Array.isArray(rest.subcollections)) {\n        rest.subcollections = rest.subcollections.map(stripNonClientFields);\n    }\n\n    return rest;\n}\n\nexport function createContractRoutes(config: ContractRoutesConfig): Hono<HonoEnv> {\n    const router = new Hono<HonoEnv>();\n\n    // Computing a version walks and canonicalizes every collection, and\n    // `/schema-version` is deliberately unauthenticated and meant to be polled.\n    // Recomputing per request would make a CI convenience into a CPU\n    // amplification anyone could aim at the server. Collections do not change\n    // after boot, so once is enough.\n    let cachedVersion: string | undefined;\n    const schemaVersionOf = (collections: CollectionConfig[]): string => {\n        if (config.schemaVersion) return config.schemaVersion;\n        if (cachedVersion === undefined) cachedVersion = computeSchemaVersion(collections);\n        return cachedVersion;\n    };\n\n    router.get(\"/contract\", (c) => {\n        const collections = config.collectionRegistry.getRawCollections();\n        const serialized = serializeCollections(collections).map(stripNonClientFields);\n\n        // In `baas` mode the collections are whatever introspection found at\n        // boot, so the version has to be computed from them rather than taken\n        // from a build that never saw them.\n        const schemaVersion = schemaVersionOf(collections);\n\n        const contract: RebaseProjectContract = {\n            schemaVersion,\n            runtime: {\n                version: config.runtimeVersion ?? \"unknown\",\n                contract: RUNTIME_CONTRACT_VERSION\n            },\n            collections: serialized,\n            collectionSlugs: collections\n                .map(collection => collection.slug)\n                .filter((slug): slug is string => Boolean(slug))\n                .sort(),\n            generatedAt: new Date().toISOString()\n        };\n\n        c.header(SCHEMA_VERSION_HEADER, schemaVersion);\n        return c.json(contract);\n    });\n\n    /**\n     * Cheap drift check.\n     *\n     * Deliberately unauthenticated and deliberately tiny: two version stamps\n     * and nothing else. A CI job that only wants to know whether its generated\n     * SDK is stale should not need admin credentials, and a version stamp\n     * reveals nothing about the schema it stands for.\n     *\n     * `runtime` is here as well as on `/contract` because the two answer\n     * different questions and only one of them was reachable. Which runtime a\n     * project is on decides whether a client's wire format is understood at\n     * all, and it was published solely on the admin-gated route — so a CLI or\n     * an SDK, the two callers that actually need to know, could not ask. That\n     * is the same shape as the header this route echoes: a documented signal\n     * with no reachable sender. `contract` is the number that matters for\n     * compatibility; `version` names the release a human should quote.\n     */\n    router.get(\"/schema-version\", (c) => {\n        const schemaVersion = schemaVersionOf(config.collectionRegistry.getRawCollections());\n        c.header(SCHEMA_VERSION_HEADER, schemaVersion);\n        return c.json({\n            schemaVersion,\n            runtime: {\n                version: config.runtimeVersion ?? \"unknown\",\n                contract: RUNTIME_CONTRACT_VERSION\n            }\n        });\n    });\n\n    logger.debug(\"Contract routes mounted\");\n    return router;\n}\n"],"mappings":"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"}

package/dist/cron/cron-loader.d.ts

@@ -1,5 +1,19 @@
 import { type CronJobDefinition, type CronResourceOptions } from "@rebasepro/types";
 import { type ModuleImporter } from "../utils/dynamic-import.js";
+import type { LoadDirectoryOptions } from "../functions/function-loader.js";
+/**
+ * Cron jobs as values: the job id, to its definition.
+ *
+ * `crons: { "nightly-report": nightlyReport }` schedules `nightlyReport` as the
+ * job `nightly-report` — the same thing a file named `crons/nightly-report.ts`
+ * does. {@link loadCrons} returns exactly this shape, so
+ * `crons: await loadCrons(dir)` and `cronsDir: dir` schedule the same jobs.
+ *
+ * A value is what the author wrote — `defineCron({...})` — with no defaults
+ * filled in. The scheduler fills them in when it registers the job.
+ */
+export type CronsRecord = Record<string, CronJobDefinition>;
+/** A job as the scheduler registers it: its id, and its definition with defaults filled in. */
 export interface LoadedCronJob {
     /** Job ID derived from filename (e.g. "cleanup-sessions"). */
     id: string;
@@ -13,34 +27,79 @@ export interface LoadedCronJobs {
     problems: string[];
 }
 /**
- * Auto-discover cron job files from a directory.
+ * Load the cron jobs in a directory, as values.
+ *
+ * Each file default-exports a `CronJobDefinition` — `defineCron({...})`. The
+ * filename without its extension is the record key, which is the job id:
+ * `crons/cleanup-sessions.ts` → `{ "cleanup-sessions": definition }`.
+ *
+ * Loading declares nothing: the definitions come back exactly as written, and
+ * whoever uses them decides what they are for — a backend schedules them, the
+ * build's derive step records them in the resource graph ({@link declareCrons}).
+ *
+ * Never throws for a bad file: it is skipped, logged, and passed to
+ * `options.onSkip`.
+ *
+ * @example
+ * ```ts
+ * const crons = await loadCrons(path.resolve("crons"));
+ * const backend = await createRebaseBackend({ database, crons, provision: true });
+ * ```
+ */
+export declare function loadCrons(directory: string, options?: LoadDirectoryOptions): Promise<CronsRecord>;
+/**
+ * Record each cron in the project's resource graph — what `rebase resources`
+ * lists and a host reads to know a schedule exists, without running it.
  *
- * Each file should default-export a `CronJobDefinition`.
- * The filename (without extension) becomes the job ID:
- *   `crons/cleanup-sessions.ts` → id = "cleanup-sessions"
+ * Keyed by the same id the scheduler, the routes and the Studio use, and built
+ * from the definitions as written: a default the scheduler fills in
+ * (`enabled: true`, `timeoutSeconds: 300`) is this process's, not something the
+ * author declared.
+ */
+export declare function declareCrons(crons: CronsRecord): void;
+/**
+ * The jobs a scheduler registers, from cron values: the definitions with this
+ * process's defaults filled in.
+ *
+ * Spread first, then normalise. Rebuilding the object field by field dropped
+ * `catchUpWindowSeconds` once — and since this is the path every job takes to
+ * the scheduler, catch-up never ran for any job authored the documented way. A
+ * field added to `CronJobDefinition` tomorrow would be dropped the same way.
  *
- * Follows the same discovery pattern as `loadFunctionsFromDirectory` — see
- * {@link loadCronJobsWithDiagnostics} for what happens to the files it cannot
- * load.
+ * @throws when a value has no `schedule` or no `handler`. A file like that is
+ * skipped by the loader with a reason; a value handed over in code is refused,
+ * because the caller is right there to fix it.
+ */
+export declare function cronJobsFrom(crons: CronsRecord): LoadedCronJob[];
+/**
+ * @deprecated Use `loadCrons` instead, which returns the jobs as a record keyed
+ * by id. Will be removed in a future release.
  */
 export declare function loadCronJobsFromDirectory(directory: string, importModule?: ModuleImporter): Promise<LoadedCronJob[]>;
 /**
- * {@link loadCronJobsFromDirectory}, plus the list of files that were skipped.
+ * @deprecated Use `loadCrons` instead, with `onSkip` to collect the files it
+ * skipped — and `declareCrons` where the jobs belong in the resource graph,
+ * which this used to do as a side effect of loading. Will be removed in a
+ * future release.
+ */
+export declare function loadCronJobsWithDiagnostics(directory: string, importModule?: ModuleImporter): Promise<LoadedCronJobs>;
+/**
+ * Read a directory of cron files: the definitions that loaded, keyed by id, and
+ * one `<file> (<reason>)` per file that will NOT be scheduled.
  *
- * A job that does not load does not run, and until now the only trace was one
+ * A job that does not load does not run, and the only trace used to be one
  * `warn` per file in the boot log — next to nothing at 3am when the report that
- * should have been mailed was not. A cron file is written once and then trusted
- * for months, so "it silently never ran" is the failure mode this surface has,
- * and a log line is not a surface.
+ * should have been mailed was not. So the skips are counted, summarised in one
+ * place, and answered by `GET /api/admin/cron`.
  *
- * Never throws, for the same reason `loadFunctionsWithDiagnostics` does not: one
+ * Never throws, for the same reason the function loader does not: one
  * malformed file must not take the server down, and the other jobs in the
- * directory are still worth scheduling. The difference is that the skips are now
- * counted, summarised in one place, and answered by `GET /api/cron` — so the
- * question "why did nothing run?" has an answer that does not require log
- * access.
+ * directory are still worth scheduling.
  */
-export declare function loadCronJobsWithDiagnostics(directory: string, importModule?: ModuleImporter): Promise<LoadedCronJobs>;
+export declare function readCronsDirectory(directory: string, importModule?: ModuleImporter): Promise<{
+    crons: CronsRecord;
+    problems: string[];
+}>;
 /**
  * The declaration a definition makes: every field a host can read without the
  * handler. Spelled once here so the graph and the scheduler cannot disagree

package/dist/cron/cron-routes.d.ts

@@ -7,7 +7,7 @@ import { type CronScheduler } from "./cron-scheduler.js";
  * Routes:
  *   GET    /          → list all cron jobs
  *   GET    /:id       → get a single job's status
- *   POST   /:id/trigger → manually trigger a job
+ *   POST   /:id/trigger → manually trigger a job (`?async=1`: 202 once it has started)
  *   GET    /:id/logs  → get execution logs for a job
  *   PUT    /:id       → update job (enable/disable, or `null` to follow the code)
  *

package/dist/cron/cron-scheduler.d.ts

@@ -30,9 +30,9 @@ export declare function parseCronExpression(expression: string, after: Date, tim
  * The latest slot matching `expression` within the inclusive window
  * `[from, to]`, or `undefined` when the expression has no slot in it.
  *
- * Walks backwards a minute at a time from `to`, so the first hit is already
- * the answer — in the common case (a job that ran normally moments ago) that
- * is a handful of iterations, not a scan of the whole window.
+ * Walks backwards from `to`, so the first hit is already the answer — in the
+ * common case (a job that ran normally moments ago) that is a handful of
+ * steps, not a scan of the whole window.
  *
  * `to`'s own minute is included: an instance booting at 06:00:30 has *not* run
  * the 06:00 slot — `parseCronExpression` already skipped past it to tomorrow —
@@ -43,6 +43,29 @@ export declare function parseCronExpression(expression: string, after: Date, tim
  * ISO string down either path. The claim key depends on that.
  */
 export declare function findMostRecentSlot(expression: string, from: Date, to: Date, timezone?: string): Date | undefined;
+/**
+ * What one run keeps of its `ctx.log` lines: up to 500 lines or 64 KB,
+ * whichever comes first. The lines past that are counted, and one line at the
+ * end says how many there were; every line still reaches the server log.
+ *
+ * Uncapped, a job logging one line per item kept them all — in the 50-run ring
+ * per job, in a `cron_logs` row, and in every history read: a per-minute sync
+ * of 1,000 items held 4 MB per job in memory and wrote 115 MB a day.
+ */
+export declare const MAX_CAPTURED_LOG_LINES = 500;
+export declare const MAX_CAPTURED_LOG_BYTES: number;
+/**
+ * What {@link CronScheduler.startJob} answers: the run began at `startedAt`
+ * (its history entry will carry the same timestamp), or it did not start and
+ * `log` is the skip that says why.
+ */
+export type StartedCronRun = {
+    started: true;
+    startedAt: string;
+} | {
+    started: false;
+    log: CronJobLogEntry;
+};
 /**
  * Whether a log entry records a run that did not happen because one was
  * already executing — on this process, or on another that holds the job's run
@@ -69,6 +92,10 @@ export declare class CronScheduler {
      * ever clear the lease that run took.
      */
     private readonly instanceLabel;
+    /** The hourly claim- and log-retention sweep, while the scheduler is started with a store. */
+    private claimSweepTimer?;
+    private sweepingClaims;
+    private sweepingLogs;
     /**
      * Set the server singleton to make it available to cron job handlers.
      *
@@ -98,6 +125,14 @@ export declare class CronScheduler {
      * Start the scheduler — begins ticking all enabled jobs.
      */
     start(): void;
+    /** Delete slot claims past retention. Failures are logged; the next hour tries again. */
+    private sweepClaims;
+    /**
+     * Delete run history past retention, and count the runs not counted yet.
+     * Failures are logged; the next hour tries again, from where this one
+     * stopped — each batch it finished is committed.
+     */
+    private sweepLogs;
     /**
      * Stop the scheduler: clear every timer, then wait for the runs executing
      * right now — for at most `timeoutMs` when given.
@@ -204,6 +239,22 @@ export declare class CronScheduler {
      * recognises it.
      */
     triggerJob(id: string): Promise<CronJobLogEntry | undefined>;
+    /**
+     * Start a job now and answer as soon as the run has begun, not when it
+     * ends — the manual trigger's `?async=1`.
+     *
+     * The synchronous {@link triggerJob} holds its HTTP request open for the
+     * whole run, and a proxy in front of the server (many stop at 60 s) cuts
+     * a long job's answer while the run carries on. This resolves once the
+     * run lease is held and the handler is about to be called, so a run that
+     * cannot start — already executing here or on the lease holder — is still
+     * answered as the skip it is. The run itself is tracked like any other:
+     * `stop()` waits for it, and its outcome lands in the run history, where
+     * the entry carries `manual: true` and the `startedAt` returned here.
+     *
+     * Returns `undefined` if the job doesn't exist.
+     */
+    startJob(id: string): Promise<StartedCronRun | undefined>;
     /**
      * Record a run that did not happen because the previous one had not
      * finished.
@@ -267,6 +318,21 @@ export declare class CronScheduler {
      * rest as a view for {@link toStatus}. Never throws.
      */
     private readFleet;
+    /**
+     * The next slot of `job` after `now`, for a listing on a process whose
+     * scheduler is not started — the `api` role, which Studio's Cron panel
+     * polls every 15 seconds.
+     *
+     * Cached on the job. The key is the job's schedule and zone (a re-register
+     * replaces the job, and with it the cache); the entry holds while
+     * `computedAt <= now < slot`. That is the same answer, not an
+     * approximation: the search found no matching minute between
+     * `computedAt`'s next minute and `slot`, so from any later instant before
+     * `slot` it lands on `slot` again. A clock that moves back, or reaching the
+     * slot, recomputes. The cache holds a pure function of the schedule, so
+     * there is nothing user- or role-scoped in it.
+     */
+    private listedNextRun;
     /**
      * Warn once at start when the process looks like it is running on a
      * platform that freezes or evicts instances between requests, where the

package/dist/cron/cron-store.d.ts

@@ -11,7 +11,12 @@ import type { DataDriver } from "@rebasepro/types";
  * occurs, and a pause or a trigger's "already executing" is per process.
  */
 export interface CronStore {
-    /** Ensure the backing table exists. Called once on startup. */
+    /**
+     * Ensure the backing tables exist and are locked away from end users. Runs
+     * once per process per database, however many stores ask: concurrent
+     * callers share the attempt in flight, and an attempt that fell short is
+     * made again on the next call.
+     */
     ensureTable(): Promise<void>;
     /** Persist a single log entry after execution. */
     insertLog(entry: CronJobLogEntry): Promise<void>;
@@ -28,7 +33,8 @@ export interface CronStore {
     fetchLogs(jobId: string, limit?: number): Promise<CronJobLogEntry[]>;
     /**
      * Fetch aggregate stats for all jobs (totalRuns, totalFailures, lastRunAt).
-     * Used to seed in-memory counters on startup.
+     * Used to seed in-memory counters on startup. The SQL store reads them from
+     * the all-time counters on `cron_job_state`, not from the history.
      */
     fetchJobStats(): Promise<Map<string, {
         totalRuns: number;
@@ -86,11 +92,33 @@ export interface CronStore {
     /** Release a lease taken with {@link tryAcquireRunLease} — only if `holder` still holds it. */
     releaseRunLease?(jobId: string, holder: string): Promise<void>;
     /**
-     * Run count, failure count and last run of each job, read from
-     * `cron_logs` — every process's runs, where the scheduler's own counters
-     * hold only the ones it made.
+     * Run count, failure count and last run of each job — every process's
+     * runs, where the scheduler's own counters hold only the ones it made. The
+     * SQL store keeps them as all-time counters on `cron_job_state`, so they
+     * outlive the history's retention.
      */
     fetchRunSummaries?(jobIds: readonly string[]): Promise<Map<string, CronJobRunSummary>>;
+    /**
+     * Delete slot claims past retention — all but each job's most recent one —
+     * in batches. Resolves with how many went. The scheduler runs it on a
+     * timer while it is started; a store without it keeps every claim.
+     */
+    sweepClaims?(): Promise<number>;
+    /**
+     * Delete run history past retention, and count into the job counters any
+     * run that is not counted yet — a history written before the counters
+     * existed, or by an older server during a rolling deploy. Both in batches.
+     * The scheduler runs it with {@link sweepClaims}; a store without it keeps
+     * every run.
+     */
+    sweepLogs?(): Promise<CronLogSweep>;
+}
+/** What one {@link CronStore.sweepLogs} did. */
+export interface CronLogSweep {
+    /** History rows deleted past retention. */
+    deleted: number;
+    /** Runs counted into the job counters that were not counted before. */
+    counted: number;
 }
 /** One job's row in `rebase.cron_job_state`, as the scheduler reads it. */
 export interface CronJobPersistedState {

package/dist/cron/define-cron.d.ts

@@ -1,4 +1,4 @@
-import type { CronJobDefinition } from "@rebasepro/types";
+import type { CronJobDefinition, RegisteredDatabase } from "@rebasepro/types";
 /**
  * Typed authoring helper for a cron job file. Identity at runtime —
  * a plain default-exported {@link CronJobDefinition} works identically;
@@ -38,5 +38,9 @@ import type { CronJobDefinition } from "@rebasepro/types";
  *     },
  * });
  * ```
+ *
+ * `ctx.rebase` is typed from the `Database` the project registered on
+ * `Register` (see the typed server data guide), and untyped when it registered
+ * none. `defineCron<Database>({…})` types one job without the registration.
  */
-export declare function defineCron(definition: CronJobDefinition): CronJobDefinition;
+export declare function defineCron<DB = RegisteredDatabase>(definition: CronJobDefinition<DB>): CronJobDefinition<DB>;

package/dist/cron/index.d.ts

@@ -1,8 +1,8 @@
-export { loadCronJobsFromDirectory, loadCronJobsWithDiagnostics } from "./cron-loader.js";
-export type { LoadedCronJob, LoadedCronJobs } from "./cron-loader.js";
+export { loadCrons, declareCrons, cronJobsFrom, loadCronJobsFromDirectory, loadCronJobsWithDiagnostics } from "./cron-loader.js";
+export type { CronsRecord, LoadedCronJob, LoadedCronJobs } from "./cron-loader.js";
 export { defineCron } from "./define-cron.js";
 export { CronScheduler, validateCronExpression } from "./cron-scheduler.js";
 export { createCronRoutes } from "./cron-routes.js";
 export { createCronStore } from "./cron-store.js";
 export { detectFreezableRuntime, buildScaleToZeroWarning, CRON_ALWAYS_ON_ENV } from "./scale-to-zero.js";
-export type { CronStore, CronJobPersistedState, CronRunLease, CronJobRunSummary } from "./cron-store.js";
+export type { CronStore, CronJobPersistedState, CronRunLease, CronJobRunSummary, CronLogSweep } from "./cron-store.js";

package/dist/cron-loader-B-u0snqq.js

@@ -0,0 +1,202 @@
+import { createRequire as __rebaseCreateRequire } from "module";
+import __rebaseProcess from "process";
+globalThis.process ??= __rebaseProcess;
+__rebaseCreateRequire(import.meta.url);
+import { n as __exportAll } from "./rolldown-runtime-dW7B1o5h.js";
+import { x as declareCron } from "./src-D5Y3N-S4.js";
+import { r as logger } from "./logger-D-S-hO5e.js";
+import { i as warnDeprecated, n as describeLoadFailure, r as nativeDynamicImport, t as SYNTAX_ERROR_ADVICE } from "./load-failure-L5hvfDoG.js";
+import * as fs$1 from "fs";
+import * as path$1 from "path";
+import { pathToFileURL } from "url";
+//#region src/cron/cron-loader.ts
+var cron_loader_exports = /* @__PURE__ */ __exportAll({
+	cronJobsFrom: () => cronJobsFrom,
+	cronResourceOptions: () => cronResourceOptions,
+	declareCrons: () => declareCrons,
+	loadCronJobsFromDirectory: () => loadCronJobsFromDirectory,
+	loadCronJobsWithDiagnostics: () => loadCronJobsWithDiagnostics,
+	loadCrons: () => loadCrons,
+	readCronsDirectory: () => readCronsDirectory
+});
+/**
+* Load the cron jobs in a directory, as values.
+*
+* Each file default-exports a `CronJobDefinition` — `defineCron({...})`. The
+* filename without its extension is the record key, which is the job id:
+* `crons/cleanup-sessions.ts` → `{ "cleanup-sessions": definition }`.
+*
+* Loading declares nothing: the definitions come back exactly as written, and
+* whoever uses them decides what they are for — a backend schedules them, the
+* build's derive step records them in the resource graph ({@link declareCrons}).
+*
+* Never throws for a bad file: it is skipped, logged, and passed to
+* `options.onSkip`.
+*
+* @example
+* ```ts
+* const crons = await loadCrons(path.resolve("crons"));
+* const backend = await createRebaseBackend({ database, crons, provision: true });
+* ```
+*/
+async function loadCrons(directory, options = {}) {
+	const { crons, problems } = await readCronsDirectory(directory, options.importModule);
+	if (options.onSkip) for (const problem of problems) options.onSkip(problem);
+	return crons;
+}
+/**
+* Record each cron in the project's resource graph — what `rebase resources`
+* lists and a host reads to know a schedule exists, without running it.
+*
+* Keyed by the same id the scheduler, the routes and the Studio use, and built
+* from the definitions as written: a default the scheduler fills in
+* (`enabled: true`, `timeoutSeconds: 300`) is this process's, not something the
+* author declared.
+*/
+function declareCrons(crons) {
+	for (const [id, definition] of Object.entries(crons)) declareCron(id, cronResourceOptions(definition));
+}
+/**
+* The jobs a scheduler registers, from cron values: the definitions with this
+* process's defaults filled in.
+*
+* Spread first, then normalise. Rebuilding the object field by field dropped
+* `catchUpWindowSeconds` once — and since this is the path every job takes to
+* the scheduler, catch-up never ran for any job authored the documented way. A
+* field added to `CronJobDefinition` tomorrow would be dropped the same way.
+*
+* @throws when a value has no `schedule` or no `handler`. A file like that is
+* skipped by the loader with a reason; a value handed over in code is refused,
+* because the caller is right there to fix it.
+*/
+function cronJobsFrom(crons) {
+	return Object.entries(crons).map(([id, definition]) => {
+		const def = definition;
+		if (!def || typeof def.schedule !== "string" || typeof def.handler !== "function") throw new Error(`crons["${id}"] is not a cron job: it needs a \`schedule\` string and a \`handler\` function. Author it with \`defineCron({ schedule, handler })\`.`);
+		return {
+			id,
+			definition: {
+				...def,
+				schedule: def.schedule,
+				name: def.name || id,
+				enabled: def.enabled !== false,
+				timeoutSeconds: def.timeoutSeconds ?? 300,
+				handler: def.handler
+			}
+		};
+	});
+}
+/**
+* @deprecated Use `loadCrons` instead, which returns the jobs as a record keyed
+* by id. Will be removed in a future release.
+*/
+async function loadCronJobsFromDirectory(directory, importModule = nativeDynamicImport) {
+	warnDeprecated("server.loadCronJobsFromDirectory", "`loadCronJobsFromDirectory` is deprecated; use `loadCrons(dir)`, which returns `{ [id]: definition }`.");
+	return (await legacyLoad(directory, importModule)).jobs;
+}
+/**
+* @deprecated Use `loadCrons` instead, with `onSkip` to collect the files it
+* skipped — and `declareCrons` where the jobs belong in the resource graph,
+* which this used to do as a side effect of loading. Will be removed in a
+* future release.
+*/
+async function loadCronJobsWithDiagnostics(directory, importModule = nativeDynamicImport) {
+	warnDeprecated("server.loadCronJobsWithDiagnostics", "`loadCronJobsWithDiagnostics` is deprecated; use `loadCrons(dir, { onSkip })`, which returns `{ [id]: definition }`, and `declareCrons(crons)` to record them in the resource graph.");
+	return legacyLoad(directory, importModule);
+}
+/**
+* What the deprecated loaders did: load, declare every job in the resource
+* graph, and hand back normalised jobs. A job the graph refuses is skipped as a
+* problem, as it was when the declaration ran inside the loader.
+*/
+async function legacyLoad(directory, importModule) {
+	const { crons, problems } = await readCronsDirectory(directory, importModule);
+	const declared = {};
+	for (const [id, definition] of Object.entries(crons)) try {
+		declareCron(id, cronResourceOptions(definition));
+		declared[id] = definition;
+	} catch (err) {
+		problems.push(describeLoadFailure(id, err));
+	}
+	return {
+		jobs: cronJobsFrom(declared),
+		problems
+	};
+}
+/**
+* Read a directory of cron files: the definitions that loaded, keyed by id, and
+* one `<file> (<reason>)` per file that will NOT be scheduled.
+*
+* A job that does not load does not run, and the only trace used to be one
+* `warn` per file in the boot log — next to nothing at 3am when the report that
+* should have been mailed was not. So the skips are counted, summarised in one
+* place, and answered by `GET /api/admin/cron`.
+*
+* Never throws, for the same reason the function loader does not: one
+* malformed file must not take the server down, and the other jobs in the
+* directory are still worth scheduling.
+*/
+async function readCronsDirectory(directory, importModule = nativeDynamicImport) {
+	const crons = {};
+	const problems = [];
+	if (!fs$1.existsSync(directory)) return {
+		crons,
+		problems
+	};
+	const files = fs$1.readdirSync(directory);
+	for (const file of files) if ((file.endsWith(".ts") || file.endsWith(".js")) && !file.startsWith(".") && !file.includes(".test.") && !file.endsWith(".d.ts") && file !== "index.ts" && file !== "index.js") {
+		const filePath = path$1.join(directory, file);
+		try {
+			const fileUrl = pathToFileURL(filePath).href;
+			const exported = (await importModule(fileUrl)).default;
+			if (!exported || typeof exported !== "object") {
+				problems.push(`${file} (no default export)`);
+				logger.warn(`[cron] ${file}: no valid default export. Skipping.`);
+				continue;
+			}
+			const def = exported;
+			if (typeof def.schedule !== "string" || def.schedule.trim() === "" || typeof def.handler !== "function") {
+				problems.push(`${file} (default export has no 'schedule' or no 'handler')`);
+				logger.warn(`[cron] ${file}: default export missing required 'schedule' or 'handler'. Skipping.`);
+				continue;
+			}
+			const id = path$1.basename(file, path$1.extname(file));
+			const definition = exported;
+			crons[id] = definition;
+			logger.info(`⏰ Loaded cron job: ${id} (${definition.schedule}${definition.timezone ? ` ${definition.timezone}` : " in the process's local time"})`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			problems.push(describeLoadFailure(file, err));
+			logger.debug(`[cron] Failed to load ${file}: ${message}`);
+		}
+	}
+	if (problems.length > 0) {
+		const syntax = problems.some((p) => p.includes("(syntax error"));
+		const other = problems.some((p) => !p.includes("(syntax error"));
+		logger.warn(`[cron] ${problems.length} cron file(s) were skipped and will NOT be scheduled:\n` + problems.map((p) => `  - ${p}`).join("\n") + "\n" + [...syntax ? [SYNTAX_ERROR_ADVICE] : [], ...other ? ["  Fix these or author them with `defineCron(...)` for a typed, compile-checked contract."] : []].join("\n"));
+	}
+	return {
+		crons,
+		problems
+	};
+}
+/**
+* The declaration a definition makes: every field a host can read without the
+* handler. Spelled once here so the graph and the scheduler cannot disagree
+* about what a cron is.
+*/
+function cronResourceOptions(definition) {
+	return {
+		schedule: definition.schedule,
+		...definition.timezone !== void 0 ? { timezone: definition.timezone } : {},
+		...definition.description !== void 0 ? { description: definition.description } : {},
+		...definition.enabled !== void 0 ? { enabled: definition.enabled } : {},
+		...definition.timeoutSeconds !== void 0 ? { timeoutSeconds: definition.timeoutSeconds } : {},
+		...definition.catchUpWindowSeconds !== void 0 ? { catchUpWindowSeconds: definition.catchUpWindowSeconds } : {},
+		...definition.name ? { label: definition.name } : {}
+	};
+}
+//#endregion
+export { loadCrons as a, loadCronJobsWithDiagnostics as i, declareCrons as n, loadCronJobsFromDirectory as r, cron_loader_exports as t };
+
+//# sourceMappingURL=cron-loader-B-u0snqq.js.map

package/dist/cron-loader-B-u0snqq.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-loader-B-u0snqq.js","names":[],"sources":["../src/cron/cron-loader.ts"],"sourcesContent":["import * as fs from \"fs\";\nimport * as path from \"path\";\nimport { pathToFileURL } from \"url\";\nimport { declareCron, type CronJobDefinition, type CronResourceOptions } from \"@rebasepro/types\";\nimport { logger } from \"../utils/logger.js\";\nimport { nativeDynamicImport, type ModuleImporter } from \"../utils/dynamic-import.js\";\nimport { describeLoadFailure, SYNTAX_ERROR_ADVICE } from \"../utils/load-failure.js\";\nimport { warnDeprecated } from \"@rebasepro/common\";\nimport type { LoadDirectoryOptions } from \"../functions/function-loader.js\";\n\n/**\n * Cron jobs as values: the job id, to its definition.\n *\n * `crons: { \"nightly-report\": nightlyReport }` schedules `nightlyReport` as the\n * job `nightly-report` — the same thing a file named `crons/nightly-report.ts`\n * does. {@link loadCrons} returns exactly this shape, so\n * `crons: await loadCrons(dir)` and `cronsDir: dir` schedule the same jobs.\n *\n * A value is what the author wrote — `defineCron({...})` — with no defaults\n * filled in. The scheduler fills them in when it registers the job.\n */\nexport type CronsRecord = Record<string, CronJobDefinition>;\n\n/** A job as the scheduler registers it: its id, and its definition with defaults filled in. */\nexport interface LoadedCronJob {\n    /** Job ID derived from filename (e.g. \"cleanup-sessions\"). */\n    id: string;\n    /** The full definition. */\n    definition: CronJobDefinition;\n}\n\n/** {@link loadCronJobsWithDiagnostics}' answer: what loaded, and what did not. */\nexport interface LoadedCronJobs {\n    jobs: LoadedCronJob[];\n    /** One entry per file that will NOT be scheduled, with the reason. */\n    problems: string[];\n}\n\n/**\n * Load the cron jobs in a directory, as values.\n *\n * Each file default-exports a `CronJobDefinition` — `defineCron({...})`. The\n * filename without its extension is the record key, which is the job id:\n * `crons/cleanup-sessions.ts` → `{ \"cleanup-sessions\": definition }`.\n *\n * Loading declares nothing: the definitions come back exactly as written, and\n * whoever uses them decides what they are for — a backend schedules them, the\n * build's derive step records them in the resource graph ({@link declareCrons}).\n *\n * Never throws for a bad file: it is skipped, logged, and passed to\n * `options.onSkip`.\n *\n * @example\n * ```ts\n * const crons = await loadCrons(path.resolve(\"crons\"));\n * const backend = await createRebaseBackend({ database, crons, provision: true });\n * ```\n */\nexport async function loadCrons(directory: string, options: LoadDirectoryOptions = {}): Promise<CronsRecord> {\n    const { crons, problems } = await readCronsDirectory(directory, options.importModule);\n    if (options.onSkip) for (const problem of problems) options.onSkip(problem);\n    return crons;\n}\n\n/**\n * Record each cron in the project's resource graph — what `rebase resources`\n * lists and a host reads to know a schedule exists, without running it.\n *\n * Keyed by the same id the scheduler, the routes and the Studio use, and built\n * from the definitions as written: a default the scheduler fills in\n * (`enabled: true`, `timeoutSeconds: 300`) is this process's, not something the\n * author declared.\n */\nexport function declareCrons(crons: CronsRecord): void {\n    for (const [id, definition] of Object.entries(crons)) {\n        declareCron(id, cronResourceOptions(definition));\n    }\n}\n\n/**\n * The jobs a scheduler registers, from cron values: the definitions with this\n * process's defaults filled in.\n *\n * Spread first, then normalise. Rebuilding the object field by field dropped\n * `catchUpWindowSeconds` once — and since this is the path every job takes to\n * the scheduler, catch-up never ran for any job authored the documented way. A\n * field added to `CronJobDefinition` tomorrow would be dropped the same way.\n *\n * @throws when a value has no `schedule` or no `handler`. A file like that is\n * skipped by the loader with a reason; a value handed over in code is refused,\n * because the caller is right there to fix it.\n */\nexport function cronJobsFrom(crons: CronsRecord): LoadedCronJob[] {\n    return Object.entries(crons).map(([id, definition]) => {\n        const def = definition as Partial<CronJobDefinition> | undefined;\n        if (!def || typeof def.schedule !== \"string\" || typeof def.handler !== \"function\") {\n            throw new Error(\n                `crons[\"${id}\"] is not a cron job: it needs a \\`schedule\\` string and a \\`handler\\` function. ` +\n                \"Author it with `defineCron({ schedule, handler })`.\"\n            );\n        }\n        return {\n            id,\n            definition: {\n                ...def,\n                schedule: def.schedule,\n                name: def.name || id,\n                enabled: def.enabled !== false,\n                // `??`, not `||`: zero and NaN are values the author wrote, and\n                // the scheduler refuses both by name (they end up under\n                // `rejected`). `|| 300` swallowed them, so a job written with\n                // `0` meaning \"no limit\" ran with five minutes and was listed as\n                // healthy. `Infinity` is \"none\".\n                timeoutSeconds: def.timeoutSeconds ?? 300,\n                handler: def.handler\n            }\n        };\n    });\n}\n\n/**\n * @deprecated Use `loadCrons` instead, which returns the jobs as a record keyed\n * by id. Will be removed in a future release.\n */\nexport async function loadCronJobsFromDirectory(\n    directory: string,\n    importModule: ModuleImporter = nativeDynamicImport\n): Promise<LoadedCronJob[]> {\n    warnDeprecated(\n        \"server.loadCronJobsFromDirectory\",\n        \"`loadCronJobsFromDirectory` is deprecated; use `loadCrons(dir)`, which returns `{ [id]: definition }`.\"\n    );\n    return (await legacyLoad(directory, importModule)).jobs;\n}\n\n/**\n * @deprecated Use `loadCrons` instead, with `onSkip` to collect the files it\n * skipped — and `declareCrons` where the jobs belong in the resource graph,\n * which this used to do as a side effect of loading. Will be removed in a\n * future release.\n */\nexport async function loadCronJobsWithDiagnostics(\n    directory: string,\n    importModule: ModuleImporter = nativeDynamicImport\n): Promise<LoadedCronJobs> {\n    warnDeprecated(\n        \"server.loadCronJobsWithDiagnostics\",\n        \"`loadCronJobsWithDiagnostics` is deprecated; use `loadCrons(dir, { onSkip })`, which returns \" +\n        \"`{ [id]: definition }`, and `declareCrons(crons)` to record them in the resource graph.\"\n    );\n    return legacyLoad(directory, importModule);\n}\n\n/**\n * What the deprecated loaders did: load, declare every job in the resource\n * graph, and hand back normalised jobs. A job the graph refuses is skipped as a\n * problem, as it was when the declaration ran inside the loader.\n */\nasync function legacyLoad(directory: string, importModule: ModuleImporter): Promise<LoadedCronJobs> {\n    const { crons, problems } = await readCronsDirectory(directory, importModule);\n    const declared: CronsRecord = {};\n    for (const [id, definition] of Object.entries(crons)) {\n        try {\n            declareCron(id, cronResourceOptions(definition));\n            declared[id] = definition;\n        } catch (err) {\n            problems.push(describeLoadFailure(id, err));\n        }\n    }\n    return { jobs: cronJobsFrom(declared), problems };\n}\n\n/**\n * Read a directory of cron files: the definitions that loaded, keyed by id, and\n * one `<file> (<reason>)` per file that will NOT be scheduled.\n *\n * A job that does not load does not run, and the only trace used to be one\n * `warn` per file in the boot log — next to nothing at 3am when the report that\n * should have been mailed was not. So the skips are counted, summarised in one\n * place, and answered by `GET /api/admin/cron`.\n *\n * Never throws, for the same reason the function loader does not: one\n * malformed file must not take the server down, and the other jobs in the\n * directory are still worth scheduling.\n */\nexport async function readCronsDirectory(\n    directory: string,\n    importModule: ModuleImporter = nativeDynamicImport\n): Promise<{ crons: CronsRecord; problems: string[] }> {\n    const crons: CronsRecord = {};\n    // Aggregated so a broken job surfaces as one loud summary rather than a\n    // warning buried per-file among the boot noise.\n    const problems: string[] = [];\n\n    if (!fs.existsSync(directory)) {\n        return { crons, problems };\n    }\n\n    const files = fs.readdirSync(directory);\n    for (const file of files) {\n        if (\n            (file.endsWith(\".ts\") || file.endsWith(\".js\")) &&\n            // Dotfiles: notably macOS bsdtar AppleDouble sidecars (`._foo.ts`),\n            // binary blobs that cannot be imported.\n            !file.startsWith(\".\") &&\n            !file.includes(\".test.\") &&\n            !file.endsWith(\".d.ts\") &&\n            file !== \"index.ts\" &&\n            file !== \"index.js\"\n        ) {\n            const filePath = path.join(directory, file);\n            try {\n                const fileUrl = pathToFileURL(filePath).href;\n\n                const mod = await importModule(fileUrl);\n\n                const exported: unknown = mod.default;\n\n                if (!exported || typeof exported !== \"object\") {\n                    problems.push(`${file} (no default export)`);\n                    logger.warn(`[cron] ${file}: no valid default export. Skipping.`);\n                    continue;\n                }\n\n                const def = exported as Record<string, unknown>;\n                if (typeof def.schedule !== \"string\" || def.schedule.trim() === \"\" || typeof def.handler !== \"function\") {\n                    problems.push(`${file} (default export has no 'schedule' or no 'handler')`);\n                    logger.warn(`[cron] ${file}: default export missing required 'schedule' or 'handler'. Skipping.`);\n                    continue;\n                }\n\n                const id = path.basename(file, path.extname(file));\n                const definition = exported as CronJobDefinition;\n                crons[id] = definition;\n                logger.info(\n                    `⏰ Loaded cron job: ${id} (${definition.schedule}` +\n                    `${definition.timezone ? ` ${definition.timezone}` : \" in the process's local time\"})`\n                );\n            } catch (err: unknown) {\n                const message =\n                    err instanceof Error ? err.message : String(err);\n                problems.push(describeLoadFailure(file, err));\n                // At `debug`: the aggregate warning below lists every problem\n                // by file, so this line was the same text a second time — and\n                // when the throw is a Zod error, that text is ten lines of\n                // serialised issues. The reader met it twice before reaching\n                // the sentence that says what to do.\n                logger.debug(`[cron] Failed to load ${file}: ${message}`);\n            }\n        }\n    }\n\n    if (problems.length > 0) {\n        // Advice keyed to what went wrong, as the functions loader does:\n        // `defineCron` is the remedy for a wrong export shape, not for a typo.\n        const syntax = problems.some(p => p.includes(\"(syntax error\"));\n        const other = problems.some(p => !p.includes(\"(syntax error\"));\n        logger.warn(\n            `[cron] ${problems.length} cron file(s) were skipped and will NOT be scheduled:\\n` +\n            problems.map((p) => `  - ${p}`).join(\"\\n\") + \"\\n\" +\n            [\n                ...(syntax ? [SYNTAX_ERROR_ADVICE] : []),\n                ...(other ? [\"  Fix these or author them with `defineCron(...)` for a typed, compile-checked contract.\"] : [])\n            ].join(\"\\n\")\n        );\n    }\n\n    return { crons, problems };\n}\n\n/**\n * The declaration a definition makes: every field a host can read without the\n * handler. Spelled once here so the graph and the scheduler cannot disagree\n * about what a cron is.\n */\nexport function cronResourceOptions(definition: CronJobDefinition): CronResourceOptions {\n    return {\n        schedule: definition.schedule,\n        ...(definition.timezone !== undefined ? { timezone: definition.timezone } : {}),\n        ...(definition.description !== undefined ? { description: definition.description } : {}),\n        ...(definition.enabled !== undefined ? { enabled: definition.enabled } : {}),\n        ...(definition.timeoutSeconds !== undefined ? { timeoutSeconds: definition.timeoutSeconds } : {}),\n        ...(definition.catchUpWindowSeconds !== undefined ? { catchUpWindowSeconds: definition.catchUpWindowSeconds } : {}),\n        ...(definition.name ? { label: definition.name } : {})\n    };\n}\n"],"mappings":"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"}