@devdogsuga/devtools 0.1.25 → 0.1.27

package/dist/completions.d.ts

@@ -1,4 +0,0 @@
-type Shell = "bash" | "zsh";
-export declare function generateCompletions(shell: Shell): string;
-export declare function runCompletions(argv: string[]): number;
-export {};

package/dist/completions.js

@@ -1,110 +0,0 @@
-import { allPaths } from "./commands.js";
-/**
- * Groups all paths by their parent prefix to build per-parent completion lists.
- *
- * e.g. ["env", "pull"] contributes "pull" to the group keyed "env".
- */
-function buildGroups() {
-    const groups = new Map();
-    for (const path of allPaths()) {
-        const parent = path.slice(0, -1).join(" ");
-        const name = path[path.length - 1];
-        const existing = groups.get(parent) ?? [];
-        existing.push(name);
-        groups.set(parent, existing);
-    }
-    return groups;
-}
-function generateBash() {
-    const groups = buildGroups();
-    const topLevel = (groups.get("") ?? []).join(" ");
-    const cases = [];
-    for (const [parent, children] of groups) {
-        if (!parent)
-            continue;
-        // Match "devtools <parent>" — the last typed word before cursor is a subcommand
-        cases.push(`        "${parent}") words="${children.join(" ")}" ;;`);
-    }
-    return [
-        "# devtools bash completion",
-        "# Source this file or add it to /etc/bash_completion.d/",
-        '#   eval "$(pnpm devtools completions --shell bash)"',
-        "_devtools_complete() {",
-        '    local cur="${COMP_WORDS[COMP_CWORD]}"',
-        '    local prev="${COMP_WORDS[COMP_CWORD-1]}"',
-        '    local words=""',
-        "",
-        "    # Build the command path from all words except the last",
-        '    local cmd=""',
-        "    for ((i=1; i<COMP_CWORD; i++)); do",
-        '        local w="${COMP_WORDS[$i]}"',
-        '        if [[ "$w" != --* ]]; then',
-        '            cmd="${cmd:+$cmd }$w"',
-        "        fi",
-        "    done",
-        "",
-        '    case "$cmd" in',
-        ...cases,
-        `        "") words="${topLevel}" ;;`,
-        "    esac",
-        "",
-        '    COMPREPLY=($(compgen -W "$words" -- "$cur"))',
-        "}",
-        "complete -F _devtools_complete devtools",
-        "",
-    ].join("\n");
-}
-function generateZsh() {
-    const groups = buildGroups();
-    const topLevel = (groups.get("") ?? []).join(" ");
-    const cases = [];
-    for (const [parent, children] of groups) {
-        if (!parent)
-            continue;
-        cases.push(`        "${parent}") candidates=(${children.join(" ")}) ;;`);
-    }
-    return [
-        "#compdef devtools",
-        "# devtools zsh completion",
-        "# Add to your .zshrc:",
-        '#   eval "$(pnpm devtools completions --shell zsh)"',
-        "_devtools() {",
-        "    local state",
-        `    local -a top_level=(${topLevel})`,
-        "",
-        "    # Build the command path from all words except the last",
-        '    local cmd=""',
-        "    local -i i",
-        "    for ((i=2; i<CURRENT; i++)); do",
-        '        local w="${words[$i]}"',
-        '        if [[ "$w" != --* ]]; then',
-        '            cmd="${cmd:+$cmd }$w"',
-        "        fi",
-        "    done",
-        "",
-        '    local -a candidates=("${top_level[@]}")',
-        '    case "$cmd" in',
-        ...cases,
-        "        *) ;;",
-        "    esac",
-        "",
-        "    compadd -a candidates",
-        "}",
-        "_devtools",
-        "",
-    ].join("\n");
-}
-export function generateCompletions(shell) {
-    return shell === "zsh" ? generateZsh() : generateBash();
-}
-export function runCompletions(argv) {
-    const shellIdx = argv.indexOf("--shell");
-    const shell = shellIdx !== -1 ? argv[shellIdx + 1] : undefined;
-    if (shell !== "bash" && shell !== "zsh") {
-        process.stderr.write("devtools completions: --shell must be bash or zsh.\n" +
-            "Example: pnpm devtools completions --shell bash\n");
-        return 1;
-    }
-    process.stdout.write(generateCompletions(shell));
-    return 0;
-}

package/dist/cron/commands.d.ts

@@ -1,47 +0,0 @@
-import { type AppCronMap, type CronTier, type WranglerConfig } from "./discovery.js";
-/**
- * Whether *something* answers at `url`'s origin. Any HTTP reply — even 404 or
- * 405 — means a server is listening; only a transport failure (ECONNREFUSED, a
- * dead host, a DNS miss) counts as unreachable. The short timeout keeps a
- * black-hole host from hanging the command; a refused connection returns
- * immediately regardless.
- */
-export declare function originReachable(url: string, timeoutMs?: number): Promise<boolean>;
-export interface CronListRow {
-    app: string;
-    tier: string;
-    expr: string;
-    human: string;
-    label: string;
-    kind: "route" | "workflow";
-    /** Routes fired (route kind); empty for a workflow row. */
-    routes: string[];
-    /** Workflows binding started (workflow kind). */
-    binding?: string;
-    /** The tier's wrangler workflow name for that binding, when declared. */
-    workflowName?: string;
-    status: "ok" | "never-fires" | "fires-nothing" | "misconfigured";
-}
-/**
- * Reconciles one app's `CRON_ROUTES` + `WORKFLOW_CRONS` against its Worker and
- * Workflow schedules for each tier. Pure — it takes the already-read wrangler
- * config — so the table is unit-tested without touching the filesystem.
- *
- * A workflow schedule is `ok` only when the tier declares the binding named by
- * the map and that binding natively schedules the expression.
- */
-export declare function reconcileMap(map: AppCronMap, config: WranglerConfig, tiers: readonly CronTier[]): CronListRow[];
-export declare function runCronList(argv: readonly string[]): Promise<number>;
-export interface CronChoice {
-    app: string;
-    expr: string;
-    label: string;
-    routes: string[];
-    scheduled: boolean;
-}
-/** Runnable route schedules, including intentionally unscheduled manual jobs. */
-export declare function cronChoices(maps: readonly AppCronMap[], configs: ReadonlyMap<string, WranglerConfig>, tier: CronTier, app?: string): CronChoice[];
-export declare function runCronRun(argv: readonly string[]): Promise<number>;
-/** Resolve the selected app's origin without assuming every app uses port 3000. */
-export declare function resolveBaseUrl(app: string | undefined, tier: CronTier, config: WranglerConfig | undefined, tierEnv: Record<string, string>): string;
-export declare function devServerHint(app: string | undefined, baseUrl: string): string;

package/dist/cron/commands.js

@@ -1,372 +0,0 @@
-/**
- * `devtools cron list` and `devtools cron run`.
- *
- * `cron list` reconciles each app's Worker `triggers.crons` and native
- * `workflows[].schedules` (per tier) against its `CRON_ROUTES` and
- * `WORKFLOW_CRONS` exports and surfaces every
- * failure shape:
- *   - a Worker cron matching no route map → fires nothing
- *   - a CRON_ROUTES / WORKFLOW_CRONS key no tier schedules → never fires
- *   - a WORKFLOW_CRONS key whose binding that tier's wrangler never declares →
- *     misconfigured
- *
- * `cron run` selects route-backed schedules from the same maps and sends their
- * authenticated GETs sequentially, mirroring `cloudflare/scheduled.ts`.
- * Workflow-backed schedules stay visible in the audit but are triggered by the
- * separate `devtools workflows` command, which reads Wrangler bindings directly.
- *
- * The local run path pre-flights the target origin and, if nothing is
- * listening, prints a tailored hint rather than a raw ECONNREFUSED.
- */
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { confirm, select } from "@clack/prompts";
-import { parse as parseEnv } from "dotenv";
-import { loadEnvLoad } from "../repo/peers.js";
-import { findRepoRoot } from "../repo/root.js";
-import { positionals } from "../args.js";
-import { resolveTier } from "../tier.js";
-import { unwrap } from "../ui.js";
-import { CRON_TIERS, cronsForTier, discoverCronMaps, discoverWranglerConfigs, isCronTier, workflowsForTier, } from "./discovery.js";
-// ── origin reachability ───────────────────────────────────────────────────────
-/**
- * Whether *something* answers at `url`'s origin. Any HTTP reply — even 404 or
- * 405 — means a server is listening; only a transport failure (ECONNREFUSED, a
- * dead host, a DNS miss) counts as unreachable. The short timeout keeps a
- * black-hole host from hanging the command; a refused connection returns
- * immediately regardless.
- */
-export async function originReachable(url, timeoutMs = 2500) {
-    try {
-        const origin = new URL(url).origin;
-        await fetch(origin, {
-            method: "HEAD",
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-// ── Human-readable schedule translator ───────────────────────────────────────
-function describeExpr(expr) {
-    let m;
-    if (/^0 0 \* \* \*$/.test(expr))
-        return "daily at midnight UTC";
-    if ((m = /^\*\/(\d+) \* \* \* \*$/.exec(expr)))
-        return `every ${m[1]} minutes (UTC)`;
-    if ((m = /^(\d+) (\d+) \* \* \*$/.exec(expr))) {
-        const hh = m[2].padStart(2, "0");
-        const mm = m[1].padStart(2, "0");
-        return `daily at ${hh}:${mm} UTC`;
-    }
-    return expr;
-}
-/**
- * Reconciles one app's `CRON_ROUTES` + `WORKFLOW_CRONS` against its Worker and
- * Workflow schedules for each tier. Pure — it takes the already-read wrangler
- * config — so the table is unit-tested without touching the filesystem.
- *
- * A workflow schedule is `ok` only when the tier declares the binding named by
- * the map and that binding natively schedules the expression.
- */
-export function reconcileMap(map, config, tiers) {
-    const rows = [];
-    const routeExprs = new Set(Object.keys(map.routes));
-    const workflowExprs = new Set(Object.keys(map.workflows));
-    for (const tier of tiers) {
-        const workerScheduled = new Set(cronsForTier(config, tier));
-        const boundWorkflows = new Map(workflowsForTier(config, tier).map((w) => [w.binding, w]));
-        for (const expr of routeExprs) {
-            const entry = map.routes[expr];
-            rows.push({
-                app: map.app,
-                tier,
-                expr,
-                human: describeExpr(expr),
-                label: entry.label,
-                kind: "route",
-                routes: entry.routes,
-                status: workerScheduled.has(expr) ? "ok" : "never-fires",
-            });
-        }
-        for (const expr of workflowExprs) {
-            const entry = map.workflows[expr];
-            const workflow = boundWorkflows.get(entry.binding);
-            const workflowName = workflow?.name;
-            const status = workflow === undefined
-                ? "misconfigured"
-                : workflow.schedules?.includes(expr)
-                    ? "ok"
-                    : "never-fires";
-            rows.push({
-                app: map.app,
-                tier,
-                expr,
-                human: describeExpr(expr),
-                label: entry.label,
-                kind: "workflow",
-                routes: [],
-                binding: entry.binding,
-                workflowName,
-                status,
-            });
-        }
-        for (const expr of workerScheduled) {
-            if (!routeExprs.has(expr)) {
-                rows.push({
-                    app: map.app,
-                    tier,
-                    expr,
-                    human: describeExpr(expr),
-                    label: "(no CRON_ROUTES or WORKFLOW_CRONS entry)",
-                    kind: "route",
-                    routes: [],
-                    status: "fires-nothing",
-                });
-            }
-        }
-    }
-    return rows;
-}
-export async function runCronList(argv) {
-    const opts = parseCronListOptions(argv);
-    if (opts.tier && !isCronTier(opts.tier)) {
-        process.stderr.write(`devtools cron list: unknown tier "${opts.tier}". Expected: ${CRON_TIERS.join(", ")}.\n`);
-        return 1;
-    }
-    const maps = await discoverCronMaps();
-    const configs = new Map(discoverWranglerConfigs().map(({ app, config }) => [app, config]));
-    const appMaps = opts.app ? maps.filter((m) => m.app === opts.app) : maps;
-    if (opts.app && appMaps.length === 0) {
-        process.stderr.write(`devtools cron list: no cron map found for app "${opts.app}".\n`);
-        return 1;
-    }
-    const tiers = opts.tier
-        ? [opts.tier]
-        : [...CRON_TIERS];
-    const rows = appMaps.flatMap((map) => {
-        const config = configs.get(map.app);
-        if (!config)
-            throw new Error(`${map.app}: wrangler.jsonc is missing`);
-        return reconcileMap(map, config, tiers);
-    });
-    if (opts.json) {
-        console.log(JSON.stringify(rows, null, 2));
-        return 0;
-    }
-    renderCronList(rows);
-    return 0;
-}
-function renderCronList(rows) {
-    let currentApp = "";
-    let currentTier = "";
-    for (const row of rows) {
-        if (row.app !== currentApp || row.tier !== currentTier) {
-            currentApp = row.app;
-            currentTier = row.tier;
-            console.log(`\n${row.app}  [${row.tier}]`);
-        }
-        const warn = row.status === "never-fires"
-            ? "  ⚠  never fires (no wrangler schedule)"
-            : row.status === "fires-nothing"
-                ? "  ⚠  fires nothing (no CRON_ROUTES or WORKFLOW_CRONS entry)"
-                : row.status === "misconfigured"
-                    ? `  ⚠  misconfigured (no "${row.binding}" workflow bound in this tier)`
-                    : "";
-        console.log(`  ${row.expr.padEnd(18)}  ${row.human}`);
-        console.log(`    ${row.label}${warn}`);
-        if (row.kind === "workflow") {
-            const named = row.workflowName ? ` (${row.workflowName})` : "";
-            console.log(`    → workflow: ${row.binding}${named}`);
-        }
-        for (const route of row.routes)
-            console.log(`    ${route}`);
-    }
-    if (rows.length === 0)
-        console.log("(no cron maps found)");
-}
-function parseCronListOptions(argv) {
-    const opts = {};
-    for (let i = 0; i < argv.length; i++) {
-        if (argv[i] === "--app")
-            opts.app = argv[i + 1];
-        else if (argv[i] === "--tier")
-            opts.tier = argv[i + 1];
-        else if (argv[i] === "--json")
-            opts.json = true;
-    }
-    return opts;
-}
-/** Runnable route schedules, including intentionally unscheduled manual jobs. */
-export function cronChoices(maps, configs, tier, app) {
-    return maps
-        .filter((map) => !app || map.app === app)
-        .flatMap((map) => {
-        const scheduled = new Set(cronsForTier(configs.get(map.app) ?? {}, tier));
-        return Object.entries(map.routes).map(([expr, entry]) => ({
-            app: map.app,
-            expr,
-            label: entry.label,
-            routes: entry.routes,
-            scheduled: scheduled.has(expr),
-        }));
-    })
-        .sort((a, b) => a.app.localeCompare(b.app) || a.expr.localeCompare(b.expr));
-}
-async function confirmDeployed(tier, choice, yes) {
-    if (tier === "development" || yes)
-        return true;
-    if (!process.stdin.isTTY) {
-        process.stderr.write(`devtools cron run: --yes is required to fire a job on ${tier}.\n`);
-        return false;
-    }
-    return unwrap(await confirm({
-        message: `Fire ${choice?.label ?? "this cron job"} on ${tier}?`,
-        initialValue: false,
-    }));
-}
-export async function runCronRun(argv) {
-    const opts = parseCronRunOptions(argv);
-    const route = positionals(argv)[0];
-    const tier = await resolveTier(opts.tier, "Which tier should receive the cron job?", { label: "devtools cron run" });
-    if (!tier)
-        return 1;
-    const maps = await discoverCronMaps();
-    const discovered = discoverWranglerConfigs();
-    const configs = new Map(discovered.map(({ app, config }) => [app, config]));
-    const choices = cronChoices(maps, configs, tier, opts.app);
-    let choice;
-    if (opts.cron) {
-        const matches = choices.filter((item) => item.expr === opts.cron);
-        if (matches.length > 1 && !opts.app) {
-            process.stderr.write(`devtools cron run: "${opts.cron}" exists in more than one app; pass --app.\n`);
-            return 1;
-        }
-        choice = matches[0];
-    }
-    else if (!route) {
-        if (choices.length === 0) {
-            process.stderr.write("devtools cron run: no route cron jobs were discovered.\n");
-            return 1;
-        }
-        if (!process.stdin.isTTY) {
-            process.stderr.write("devtools cron run: pass --cron <expr> (and --app when needed) when no terminal is available.\n");
-            return 1;
-        }
-        choice = unwrap(await select({
-            message: "Which cron job should run?",
-            options: choices.map((item) => ({
-                value: item,
-                label: `${item.app} · ${item.label}`,
-                hint: `${item.expr} · ${item.scheduled ? "scheduled" : `manual only on ${tier}`}`,
-            })),
-        }));
-    }
-    if (!route && !choice) {
-        const workflow = maps.some((map) => (!opts.app || map.app === opts.app) && map.workflows[opts.cron]);
-        process.stderr.write(workflow
-            ? `devtools cron run: "${opts.cron}" starts a Workflow; use devtools workflows run.\n`
-            : `devtools cron run: no route job found for "${opts.cron}".\n`);
-        return 1;
-    }
-    if (!(await confirmDeployed(tier, choice, opts.yes ?? false)))
-        return 1;
-    const app = choice?.app ?? opts.app;
-    let tierEnv;
-    const envLoad = await loadEnvLoad();
-    try {
-        // override: true because `devtools cron run` itself runs under `with-env`
-        // (development), so process.env already holds development's values; the
-        // tier picked here — development, staging or production, `resolveTier`
-        // above refuses anything else — must win over whatever this process
-        // inherited.
-        tierEnv = (await envLoad.loadEnvironment(tier, { override: true })).env;
-    }
-    catch (err) {
-        if (err instanceof envLoad.MissingEnvFileError) {
-            process.stderr.write(`devtools cron run: ${err.message}\n`);
-            return 1;
-        }
-        throw err;
-    }
-    const baseUrl = resolveBaseUrl(app, tier, configs.get(app ?? ""), tierEnv);
-    const cronSecret = tierEnv["CRON_SECRET"] ?? "";
-    const routes = choice?.routes ?? [route];
-    // Pre-flight: on a local tier, a refused connection means the dev server
-    // isn't up — not that a route is broken. Say so, with the command to start
-    // it, instead of failing every route with a raw ECONNREFUSED.
-    if (tier === "development" && !(await originReachable(baseUrl))) {
-        process.stderr.write(devServerHint(app, baseUrl));
-        return 1;
-    }
-    let failed = false;
-    for (const r of routes) {
-        const url = new URL(r, `${baseUrl.replace(/\/+$/, "")}/`).toString();
-        process.stdout.write(`→ ${url}\n`);
-        try {
-            const response = await fetch(url, {
-                headers: { Authorization: `Bearer ${cronSecret}` },
-            });
-            if (!response.ok) {
-                process.stderr.write(`  ${r}: HTTP ${response.status}\n`);
-                failed = true;
-            }
-            else {
-                process.stdout.write(`  ${r}: OK\n`);
-            }
-        }
-        catch (err) {
-            process.stderr.write(`  ${r}: ${err instanceof Error ? err.message : String(err)}\n`);
-            failed = true;
-        }
-    }
-    return failed ? 1 : 0;
-}
-function readEnvFile(path) {
-    return existsSync(path) ? parseEnv(readFileSync(path, "utf8")) : {};
-}
-/** Resolve the selected app's origin without assuming every app uses port 3000. */
-export function resolveBaseUrl(app, tier, config, tierEnv) {
-    if (tier === "development" && app) {
-        const appRoot = join(findRepoRoot(), "apps", app);
-        const local = {
-            ...readEnvFile(join(appRoot, ".dev.vars.example")),
-            ...readEnvFile(join(appRoot, ".dev.vars")),
-        };
-        if (local["BASE_URL"])
-            return local["BASE_URL"];
-    }
-    if (tier !== "development" && config) {
-        const route = (config.env?.[tier]?.routes ?? []).find((candidate) => {
-            const pattern = typeof candidate === "string" ? candidate : candidate.pattern;
-            return Boolean(pattern && !pattern.includes("*"));
-        });
-        const pattern = typeof route === "string" ? route : route?.pattern;
-        if (pattern)
-            return `https://${pattern.replace(/\/\*$/, "")}`;
-    }
-    return tierEnv["BASE_URL"] ?? "http://localhost:3000";
-}
-// ── not-running hints ─────────────────────────────────────────────────────────
-export function devServerHint(app, baseUrl) {
-    const filter = app ? `--filter ${app}` : "--filter <app>";
-    return (`devtools cron run: nothing is listening at ${new URL(baseUrl).origin}.\n` +
-        "The dev server doesn't appear to be running. Start it, then re-run:\n" +
-        `  pnpm ${filter} dev\n`);
-}
-function parseCronRunOptions(argv) {
-    const opts = {};
-    for (let i = 0; i < argv.length; i++) {
-        if (argv[i] === "--app")
-            opts.app = argv[i + 1];
-        else if (argv[i] === "--tier")
-            opts.tier = argv[i + 1];
-        else if (argv[i] === "--cron")
-            opts.cron = argv[i + 1];
-        else if (argv[i] === "--yes")
-            opts.yes = true;
-    }
-    return opts;
-}

package/dist/cron/discovery.d.ts

@@ -1,55 +0,0 @@
-import { type CronRoutes as CronRoutesType, type WorkflowCrons as WorkflowCronsType } from "./schema.js";
-export declare const CRON_TIERS: readonly ["development", "staging", "production"];
-export type CronTier = (typeof CRON_TIERS)[number];
-export interface WranglerWorkflow {
-    binding: string;
-    name: string;
-    class_name?: string;
-    schedules?: readonly string[];
-}
-export interface WranglerRoute {
-    pattern?: string;
-    custom_domain?: boolean;
-}
-export interface WranglerTierBlock {
-    name?: string;
-    triggers?: {
-        crons?: readonly string[];
-    };
-    workflows?: readonly WranglerWorkflow[];
-    routes?: readonly (string | WranglerRoute)[];
-}
-export interface WranglerConfig extends WranglerTierBlock {
-    env?: Record<string, WranglerTierBlock | undefined>;
-}
-export interface AppWranglerConfig {
-    app: string;
-    path: string;
-    config: WranglerConfig;
-}
-export declare function isCronTier(value: string): value is CronTier;
-/** Parse JSONC with TypeScript's production parser, preserving `//` in strings. */
-export declare function parseWrangler(path: string): WranglerConfig;
-export declare function blockForTier(config: WranglerConfig, tier: CronTier): WranglerTierBlock;
-export declare function cronsForTier(config: WranglerConfig, tier: CronTier): string[];
-export declare function workflowsForTier(config: WranglerConfig, tier: CronTier): WranglerWorkflow[];
-/** Every app that actually carries a Wrangler configuration. */
-export declare function discoverWranglerConfigs(): AppWranglerConfig[];
-export interface AppCronMap {
-    app: string;
-    /** Absolute path to the scheduled.ts file. */
-    path: string;
-    routes: CronRoutesType;
-    /**
-     * Workflow-backed schedules. `{}` for an app that exports no `WORKFLOW_CRONS`
-     * (the common case — only schedule-builder has one today).
-     */
-    workflows: WorkflowCronsType;
-}
-/**
- * Imports every app's `cloudflare/scheduled.ts` and returns the parsed
- * `CRON_ROUTES` for each app that has one.
- *
- * `apps/sandbox` has no scheduled.ts and no crons; absent is not an error.
- */
-export declare function discoverCronMaps(): Promise<AppCronMap[]>;

package/dist/cron/discovery.js

@@ -1,85 +0,0 @@
-/**
- * Discovers each app's `CRON_ROUTES` (and optional `WORKFLOW_CRONS`) export by
- * dynamically importing its `cloudflare/scheduled.ts`. Mirrors the
- * env-discovery pattern: found by known path, zod-validated at the boundary. An
- * app without the file has no crons and is skipped; an app whose export fails
- * validation throws with the path.
- */
-import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { flattenDiagnosticMessageText, parseConfigFileTextToJson, } from "typescript";
-import { findRepoRoot } from "../repo/root.js";
-import { CronRoutes, WorkflowCrons, } from "./schema.js";
-export const CRON_TIERS = ["development", "staging", "production"];
-export function isCronTier(value) {
-    return CRON_TIERS.includes(value);
-}
-/** Parse JSONC with TypeScript's production parser, preserving `//` in strings. */
-export function parseWrangler(path) {
-    const result = parseConfigFileTextToJson(path, readFileSync(path, "utf8"));
-    if (result.error) {
-        throw new Error(`${path}: ${flattenDiagnosticMessageText(result.error.messageText, "\n")}`);
-    }
-    return result.config;
-}
-export function blockForTier(config, tier) {
-    return tier === "development" ? config : (config.env?.[tier] ?? {});
-}
-export function cronsForTier(config, tier) {
-    return [...(blockForTier(config, tier).triggers?.crons ?? [])];
-}
-export function workflowsForTier(config, tier) {
-    return [...(blockForTier(config, tier).workflows ?? [])];
-}
-/** Every app that actually carries a Wrangler configuration. */
-export function discoverWranglerConfigs() {
-    const appsRoot = join(findRepoRoot(), "apps");
-    return readdirSync(appsRoot, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .flatMap((entry) => {
-        const path = join(appsRoot, entry.name, "wrangler.jsonc");
-        return existsSync(path)
-            ? [{ app: entry.name, path, config: parseWrangler(path) }]
-            : [];
-    })
-        .sort((a, b) => a.app.localeCompare(b.app));
-}
-/**
- * Imports every app's `cloudflare/scheduled.ts` and returns the parsed
- * `CRON_ROUTES` for each app that has one.
- *
- * `apps/sandbox` has no scheduled.ts and no crons; absent is not an error.
- */
-export async function discoverCronMaps() {
-    const results = [];
-    for (const { app } of discoverWranglerConfigs()) {
-        const scheduledPath = join(findRepoRoot(), "apps", app, "cloudflare", "scheduled.ts");
-        if (!existsSync(scheduledPath))
-            continue;
-        const mod = (await import(pathToFileURL(scheduledPath).href));
-        const parsed = CronRoutes.safeParse(mod.CRON_ROUTES);
-        if (!parsed.success) {
-            throw new Error(`${scheduledPath}: CRON_ROUTES does not match the required shape.\n` +
-                parsed.error.issues
-                    .map((i) => `  ${i.path.join(".")}: ${i.message}`)
-                    .join("\n"));
-        }
-        // Optional: an app with no Workflow schedules omits the export entirely,
-        // which parses as `{}`. A present-but-malformed export still fails closed.
-        const parsedWorkflows = WorkflowCrons.safeParse(mod.WORKFLOW_CRONS ?? {});
-        if (!parsedWorkflows.success) {
-            throw new Error(`${scheduledPath}: WORKFLOW_CRONS does not match the required shape.\n` +
-                parsedWorkflows.error.issues
-                    .map((i) => `  ${i.path.join(".")}: ${i.message}`)
-                    .join("\n"));
-        }
-        results.push({
-            app,
-            path: scheduledPath,
-            routes: parsed.data,
-            workflows: parsedWorkflows.data,
-        });
-    }
-    return results;
-}