zitejs 0.10.0-start.1 → 0.10.0-start.12

package/dist/cjs/auth/index.d.ts

@@ -67,7 +67,7 @@ export declare const signIn: {
     }, FetchOptions["throw"] extends true ? true : false>>;
 } & {
     social: <FetchOptions extends import("@better-auth/core").ClientFetchOption<Partial<{
-        provider: "salesforce" | "slack" | "linear" | "notion" | "linkedin" | "github" | "dropbox" | (string & {}) | "huggingface" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "spotify" | "twitch" | "twitter" | "kick" | "gitlab" | "tiktok" | "reddit" | "roblox" | "vk" | "zoom" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
+        provider: "salesforce" | "slack" | "linear" | "notion" | "linkedin" | "github" | "dropbox" | "line" | (string & {}) | "huggingface" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "spotify" | "twitch" | "twitter" | "kick" | "gitlab" | "tiktok" | "reddit" | "roblox" | "vk" | "zoom" | "kakao" | "naver" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
         callbackURL?: string | undefined;
         newUserCallbackURL?: string | undefined;
         errorCallbackURL?: string | undefined;
@@ -91,7 +91,7 @@ export declare const signIn: {
         loginHint?: string | undefined;
         additionalData?: Record<string, any> | undefined;
     }> & Record<string, any>, Partial<Record<string, any>> & Record<string, any>, Record<string, any> | undefined>>(data_0: import("better-auth/react").Prettify<{
-        provider: "salesforce" | "slack" | "linear" | "notion" | "linkedin" | "github" | "dropbox" | (string & {}) | "huggingface" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "spotify" | "twitch" | "twitter" | "kick" | "gitlab" | "tiktok" | "reddit" | "roblox" | "vk" | "zoom" | "kakao" | "naver" | "line" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
+        provider: "salesforce" | "slack" | "linear" | "notion" | "linkedin" | "github" | "dropbox" | "line" | (string & {}) | "huggingface" | "apple" | "atlassian" | "cognito" | "discord" | "facebook" | "figma" | "microsoft" | "google" | "spotify" | "twitch" | "twitter" | "kick" | "gitlab" | "tiktok" | "reddit" | "roblox" | "vk" | "zoom" | "kakao" | "naver" | "paybin" | "paypal" | "polar" | "railway" | "vercel" | "wechat";
         callbackURL?: string | undefined;
         newUserCallbackURL?: string | undefined;
         errorCallbackURL?: string | undefined;

package/dist/cjs/auth/index.test.js

@@ -187,3 +187,33 @@ function redirectParamOf(href) {
         (0, vitest_1.expect)(params.get('usageToken')).toBeNull();
     });
 });
+// AUTH-03: what the platform's auth routes receive from the client, on the app's own origin.
+(0, vitest_1.describe)("the client's calls", () => {
+    const calls = () => {
+        const sent = [];
+        vitest_1.vi.stubGlobal('fetch', vitest_1.vi.fn(async (input, init) => {
+            const request = new Request(new URL(String(input instanceof Request ? input.url : input), 'https://app.zite.so'), init);
+            sent.push({
+                path: new URL(request.url).pathname,
+                method: request.method,
+                body: request.method === 'POST' ? await request.json().catch(() => null) : null,
+            });
+            return Response.json({});
+        }));
+        return sent;
+    };
+    (0, vitest_1.it)('sign in by link, sign out and edit the profile on /api/auth', async () => {
+        const sent = calls();
+        // The client takes its fetch when the module loads.
+        vitest_1.vi.resetModules();
+        const { signIn, signOut, updateProfile } = await Promise.resolve().then(() => __importStar(require('./index.js')));
+        await signIn.magicLink({ email: 'ada@x.co' });
+        await signOut();
+        await updateProfile({ firstName: 'Ada' });
+        (0, vitest_1.expect)(sent).toEqual([
+            { path: '/api/auth/sign-in/magic-link', method: 'POST', body: vitest_1.expect.objectContaining({ email: 'ada@x.co' }) },
+            { path: '/api/auth/sign-out', method: 'POST', body: vitest_1.expect.anything() },
+            { path: '/api/auth/update-user', method: 'POST', body: { firstName: 'Ada' } },
+        ]);
+    });
+});

package/dist/cjs/backend/index.d.ts

@@ -23,6 +23,8 @@ export type ZiteTrigger = {
     paused?: boolean;
     every?: never;
     events?: never;
+    table?: never;
+    form?: never;
 } | {
     /**
      * The connection's name in `zite.config.json`, for a provider whose
@@ -37,6 +39,8 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     every?: never;
+    table?: never;
+    form?: never;
 } | {
     /** `<n>m` (1–59) or `<n>h` (1–23). What makes the trigger a poll. */
     every: string;
@@ -46,6 +50,78 @@ export type ZiteTrigger = {
     label?: string;
     paused?: boolean;
     events?: never;
+    table?: never;
+    form?: never;
+} | {
+    /**
+     * A table in the project's own database, as `zite.<table>` names it.
+     * Every write to it reaches the trigger, from apps, forms, imports, the
+     * database view and other automations; nothing is registered.
+     */
+    table: string;
+    on: ZiteDatabaseTriggerEvent[];
+    /** Narrows `"updated"` to updates that changed one of these fields. */
+    fields?: string[];
+    /** The sentence the editor shows, e.g. "When an order ships". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    form?: never;
+} | {
+    /**
+     * One of the project's own Fillout forms, by its name as the project
+     * lists it, or its id. Each finished live submission fires the
+     * endpoint; nothing is registered.
+     */
+    form: string;
+    on: "submitted"[];
+    /** The sentence the editor shows, e.g. "When someone fills in the intake form". */
+    label?: string;
+    paused?: boolean;
+    integration?: never;
+    every?: never;
+    events?: never;
+    table?: never;
+};
+/**
+ * What a form trigger's run gets as `input`: one submission. `answers` is
+ * keyed by question name, `answersById` by question id; `submission` is the
+ * whole export, as the Fillout API returns it (`questions`, `calculations`,
+ * `urlParameters`, …). Two questions with the same label are named
+ * `Email` and `Email (1)` in an order the form doesn't show, so read those by
+ * id.
+ */
+export type ZiteFormTriggerInput = {
+    event: "submitted";
+    form: string;
+    formId: string;
+    submissionId: string;
+    submittedAt: string | null;
+    answers: Record<string, unknown>;
+    answersById: Record<string, unknown>;
+    submission: Record<string, unknown> & {
+        submissionId: string;
+    };
+};
+export type ZiteDatabaseTriggerEvent = "created" | "updated" | "deleted";
+/**
+ * What a database trigger's run gets as `input`: one changed record. Field
+ * keys are the SDK's, as `zite.<table>.findOne` returns them; cast `record`
+ * and `previous` to the table's generated `<Table>RecordType` from
+ * `zitejs/db` to type their fields.
+ */
+export type ZiteDatabaseTriggerInput<TRecord extends Record<string, unknown> = Record<string, unknown>> = {
+    event: ZiteDatabaseTriggerEvent;
+    table: string;
+    recordId: string;
+    /** Null if it was deleted before the run read it; on `"deleted"`, the record as it was. */
+    record: TRecord | null;
+    /** The record before an `"updated"`; null otherwise, and on a very large bulk write. */
+    previous: TRecord | null;
+    /** What an `"updated"` changed. */
+    changedFields: string[];
 };
 /**
  * What a provider trigger's `subscribe` export receives. Write it as
@@ -115,10 +191,20 @@ export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
 export type ZiteTriggerContext<TTrigger> = TTrigger extends {
     every: string;
 } ? ZiteTriggerRun : TTrigger extends {
+    table: string;
+} | {
+    form: string;
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
     events: string[];
 } ? ZiteTriggerDeliveryInfo : TTrigger extends {
     integration: string;
 } ? ZiteTriggerDeliveryRun : never;
+/** A database or form trigger's runs get the change or submission as `input`. */
+export type ZiteEndpointInput<TInput, TTrigger> = TTrigger extends {
+    table: string;
+} ? ZiteDatabaseTriggerInput : TTrigger extends {
+    form: string;
+} ? ZiteFormTriggerInput : TInput;
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -215,13 +301,15 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TInput;
+        input: ZiteEndpointInput<TInput, TTrigger>;
         /**
          * Durable steps. `step.run(name, fn)` runs `fn` once per logical run:
          * its result is saved before anything after it executes, and when a
          * failed run is resumed, completed steps return their saved results
          * instead of re-running their side effects. Names must be unique within
-         * a run, and results must be plain JSON data under 256KB.
+         * a run, and results must be plain JSON data under 256KB. In a run
+         * fired by a schedule, webhook or trigger, `step.sleep` pauses the run
+         * and a failed step is tried again.
          */
         step: ZiteStep;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
@@ -240,8 +328,32 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
  * it would matter, and give a step inside a loop the item's id in its name.
  */
 export interface ZiteStep {
-    run<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+    /**
+     * In a run fired by a schedule, webhook or trigger, a step that throws is
+     * tried again `retries` more times (default 3, at most 10), 30 seconds,
+     * 2 minutes, then 10 minutes apart. Elsewhere its error fails the request.
+     */
+    run<T>(name: string, fn: () => Promise<T> | T, options?: ZiteStepOptions): Promise<T>;
+    /**
+     * Pause the run for `duration`: `"30s"`, `"15m"`, `"2h"`, `"3d"`, `"1w"`,
+     * or milliseconds, at most 30 days. Only a run fired by a schedule, webhook
+     * or trigger can wait; an editor test run goes straight past, and a request
+     * from the app throws.
+     *
+     * The run continues in a later call, which runs `execute` again from the
+     * top: finished steps return their saved results, and code outside a step
+     * runs again, so keep side effects inside steps.
+     */
+    sleep(name: string, duration: ZiteStepDuration): Promise<void>;
+    /** Pause the run until `when`, at most 30 days ahead. See {@link ZiteStep.sleep}. */
+    sleepUntil(name: string, when: Date | string): Promise<void>;
+}
+export interface ZiteStepOptions {
+    /** How many more times to try the step after it throws: 0 to 10, default 3. */
+    retries?: number;
 }
+/** Milliseconds, or a number with a unit: `ms`, `s`, `m`, `h`, `d` or `w`. */
+export type ZiteStepDuration = number | `${number}${"ms" | "s" | "m" | "h" | "d" | "w"}`;
 /**
  * Create an endpoint definition, parsing `input` against `inputSchema` before
  * `execute` runs. Nothing downstream parses it — the worker calls `execute` on

package/dist/cjs/backend/index.test.js

@@ -8,6 +8,8 @@ const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
 // Direct execute() calls need the step surface the runtime always provides.
 const stepStub = {
     run: async (_name, fn) => await fn(),
+    sleep: async () => { },
+    sleepUntil: async () => { },
 };
 (0, vitest_1.afterEach)(() => {
     vitest_1.vi.unstubAllGlobals();
@@ -207,6 +209,62 @@ const stepStub = {
                 return params.trigger;
             },
         });
+        (0, index_js_1.createEndpoint)({
+            trigger: { table: "orders", on: ["updated"], fields: ["status"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a database change has no cursor API
+                trigger?.advance("x");
+                const status = input.record?.status;
+                return { status, changed: input.changedFields, at: input.event };
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error a database trigger names its table, not a connection
+            trigger: { table: "orders", on: ["created"], integration: "x" },
+            execute: async () => 1,
+        });
+        (0, index_js_1.createEndpoint)({
+            trigger: { form: "Intake form", on: ["submitted"] },
+            execute: async ({ input, trigger }) => {
+                // @ts-expect-error a form submission has no cursor API
+                trigger?.advance("x");
+                return {
+                    email: input.answers.Email,
+                    workEmail: input.answersById["wWorkEmail"],
+                    id: input.submissionId,
+                };
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error a form trigger watches submissions only
+            trigger: { form: "Intake form", on: ["updated"] },
+            execute: async () => 1,
+        });
+        (0, index_js_1.createEndpoint)({
+            // @ts-expect-error only created, updated and deleted
+            trigger: { table: "orders", on: ["archived"] },
+            execute: async () => 1,
+        });
+    });
+    (0, vitest_1.it)("hands a database trigger its change without parsing it against the input schema", async () => {
+        const endpoint = (0, index_js_1.createEndpoint)({
+            inputSchema: zod_1.z.object({ orderId: zod_1.z.string() }),
+            trigger: { table: "orders", on: ["created"] },
+            execute: async ({ input }) => input.recordId,
+        });
+        await (0, vitest_1.expect)(endpoint.execute({
+            step: stepStub,
+            input: {
+                event: "created",
+                table: "orders",
+                recordId: "rec_1",
+                record: { id: "rec_1" },
+                previous: null,
+                changedFields: [],
+            },
+            context: { user: null },
+            trigger: { headers: {}, deliveryId: "db:e1:rec_1" },
+        })).resolves.toBe("rec_1");
     });
     (0, vitest_1.it)("types a trigger's registration exports and checks what subscribe returns", async () => {
         const subscribe = (async (input) => ({

package/dist/cjs/check/index.d.ts

@@ -1 +1,33 @@
-export declare function runCheck(): Promise<void>;
+import { type Problem } from './start/problem.js';
+type Step = {
+    name: string;
+    ok: boolean;
+    output?: string;
+};
+/** One app's check, as `--json` reports it. */
+export type AppCheck = {
+    path: string;
+    runtime: 'classic' | 'start';
+    ok: boolean;
+    steps: Step[];
+    problems: Problem[];
+};
+/**
+ * While `--json` checks, stdout carries only the report: app code that logs as
+ * it's described in-process goes to stderr instead.
+ */
+export declare const withStdoutOnStderr: <T>(run: () => Promise<T>) => Promise<T>;
+/** Prints as it goes, or with `--json` stays quiet and reports everything at the end. */
+export declare class Reporter {
+    private readonly json;
+    readonly apps: AppCheck[];
+    constructor(json: boolean);
+    app(path: string, runtime: AppCheck['runtime'], heading: boolean): AppCheck;
+    step(app: AppCheck, name: string, result: {
+        ok: boolean;
+        output?: string;
+    }): boolean;
+    problems(app: AppCheck, problems: Problem[]): void;
+}
+export declare function runCheck(args?: string[]): Promise<void>;
+export {};

package/dist/cjs/check/index.js

@@ -1,10 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reporter = exports.withStdoutOnStderr = void 0;
 exports.runCheck = runCheck;
 const child_process_1 = require("child_process");
 const fs_1 = require("fs");
 const path_1 = require("path");
 const sourceRoots_js_1 = require("../sourceRoots.js");
+const problem_js_1 = require("./start/problem.js");
 /**
  * An argument array, not a command string, so no shell is involved.
  *
@@ -58,73 +93,166 @@ function bundleFailures(output) {
     }
     return failures;
 }
-async function runCheck() {
-    const appDirs = (0, sourceRoots_js_1.listSourceDirs)();
-    if (appDirs.length === 0) {
-        console.error('No apps or automations found under apps/ or automations/.');
-        process.exit(1);
+const indent = (output) => output.trim().split('\n').map(l => `    ${l}`).join('\n');
+/**
+ * While `--json` checks, stdout carries only the report: app code that logs as
+ * it's described in-process goes to stderr instead.
+ */
+const withStdoutOnStderr = async (run) => {
+    const write = process.stdout.write;
+    process.stdout.write = process.stderr.write.bind(process.stderr);
+    try {
+        return await run();
     }
-    let allPassed = true;
-    for (const { root, dir: app, path: appPath } of appDirs) {
-        console.log(`\n── ${appPath} ──`);
-        // Only tsconfig.app.json compiles anything. The app's tsconfig.json is a
-        // solution-style config — `"files": []` plus a reference — so
-        // `tsc --noEmit -p tsconfig.json` type-checks zero files and exits 0. It
-        // used to be the fallback, which meant an app missing tsconfig.app.json
-        // reported a passing typecheck it never ran.
-        const tsconfigAppPath = (0, path_1.join)(appPath, 'tsconfig.app.json');
-        if (!(0, fs_1.existsSync)(tsconfigAppPath)) {
-            console.log(`  tsc --noEmit ... ✗ (no ${tsconfigAppPath})`);
-            allPassed = false;
-        }
-        else {
-            process.stdout.write('  tsc --noEmit ... ');
-            const tsc = run('npx', ['tsc', '--noEmit', '-p', tsconfigAppPath], '.');
-            if (tsc.ok) {
-                console.log('✓');
-            }
-            else {
-                console.log('✗');
-                console.log(tsc.output.trim().split('\n').map(l => `    ${l}`).join('\n'));
-                allPassed = false;
-            }
+    finally {
+        process.stdout.write = write;
+    }
+};
+exports.withStdoutOnStderr = withStdoutOnStderr;
+/** Prints as it goes, or with `--json` stays quiet and reports everything at the end. */
+class Reporter {
+    json;
+    apps = [];
+    constructor(json) {
+        this.json = json;
+    }
+    app(path, runtime, heading) {
+        const app = { path, runtime, ok: true, steps: [], problems: [] };
+        this.apps.push(app);
+        if (heading && !this.json)
+            console.log(`\n── ${path} ──`);
+        return app;
+    }
+    step(app, name, result) {
+        const output = result.output?.trim();
+        app.steps.push({ name, ok: result.ok, ...(output && !result.ok && { output }) });
+        if (!result.ok)
+            app.ok = false;
+        if (!this.json) {
+            console.log(`  ${name} ... ${result.ok ? '✓' : '✗'}`);
+            if (!result.ok && output)
+                console.log(indent(output));
         }
-        // Endpoints never reach vite — they are bundled separately for the lambda,
-        // against a different resolver. tsc and vite both pass on an endpoint whose
-        // `zitejs/*` alias has no generated file behind it; only the bundler knows.
-        if ((0, sourceRoots_js_1.listEndpointNames)(root, appPath).length > 0) {
-            process.stdout.write('  bundle endpoints ... ');
-            const bundle = run('npx', ['zitejs', 'bundle', '--app', app], '.');
-            const failures = bundle.ok ? bundleFailures(bundle.output) : [bundle.output];
-            if (failures.length === 0) {
-                console.log('✓');
-            }
-            else {
-                console.log('✗');
-                console.log(failures.map(l => `    ${l}`).join('\n'));
-                allPassed = false;
-            }
+        return result.ok;
+    }
+    problems(app, problems) {
+        app.problems.push(...problems);
+        if (problems.some(p => p.severity === 'error'))
+            app.ok = false;
+        if (!this.json && problems.length)
+            console.log(problems.map(p => `    ${(0, problem_js_1.formatProblem)(p)}`).join('\n'));
+    }
+}
+exports.Reporter = Reporter;
+const SKIPPED_DIRS = new Set(['node_modules', 'dist', '.output', '.tanstack', '.wrangler']);
+/** The app's own source, by app-relative path. */
+function readAppSources(appPath) {
+    const sources = {};
+    const visit = (dir) => {
+        for (const entry of (0, fs_1.readdirSync)(dir, { withFileTypes: true })) {
+            if (SKIPPED_DIRS.has(entry.name))
+                continue;
+            const full = (0, path_1.join)(dir, entry.name);
+            if (entry.isDirectory())
+                visit(full);
+            else if (/\.[cm]?[jt]sx?$/.test(entry.name))
+                sources[(0, path_1.relative)(appPath, full)] = (0, fs_1.readFileSync)(full, 'utf-8');
         }
-        const viteConfig = (0, path_1.join)(appPath, 'vite.config.ts');
-        if ((0, fs_1.existsSync)(viteConfig)) {
-            process.stdout.write('  vite build ... ');
-            const vite = run('npx', ['vite', 'build'], appPath);
-            if (vite.ok) {
-                console.log('✓');
+    };
+    const src = (0, path_1.join)(appPath, 'src');
+    if ((0, fs_1.existsSync)(src))
+        visit(src);
+    return sources;
+}
+const isInternalApp = (appPath) => {
+    try {
+        return JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(appPath, 'zite.config.json'), 'utf-8'))?.accessMode === 'internal';
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * A Start app: `vite build` first, since it regenerates the route tree tsc
+ * reads, then tsc, then describe, which reports what the platform's build
+ * refuses, read the same way, then the source hints.
+ */
+async function checkStartApp(reporter, app, appPath) {
+    if (!reporter.step(app, 'vite build', run('npx', ['vite', 'build'], appPath)))
+        return;
+    // --pretty for `file:line:col - error` lines, the shape the platform re-roots.
+    reporter.step(app, 'tsc --noEmit', run('npx', ['tsc', '--noEmit', '--pretty', '-p', 'tsconfig.app.json'], appPath));
+    const { describedProblems } = await Promise.resolve().then(() => __importStar(require('./start/describeRules.js')));
+    const { sourceProblems } = await Promise.resolve().then(() => __importStar(require('./start/sourceRules.js')));
+    try {
+        const { describeBuiltApp } = await Promise.resolve().then(() => __importStar(require('../start/describeBuilt.js')));
+        const description = (await describeBuiltApp(appPath));
+        const problems = describedProblems(description, { internal: isInternalApp(appPath) });
+        reporter.step(app, 'describe', { ok: !problems.some(p => p.severity === 'error') });
+        reporter.problems(app, problems);
+    }
+    catch (err) {
+        reporter.step(app, 'describe', { ok: false, output: err instanceof Error ? err.message : String(err) });
+    }
+    const hints = sourceProblems(readAppSources(appPath));
+    reporter.step(app, 'source', { ok: !hints.some(p => p.severity === 'error') });
+    reporter.problems(app, hints);
+}
+function checkClassicApp(reporter, app, root, dir, appPath) {
+    // Only tsconfig.app.json compiles anything. The app's tsconfig.json is a
+    // solution-style config — `"files": []` plus a reference — so
+    // `tsc --noEmit -p tsconfig.json` type-checks zero files and exits 0. It
+    // used to be the fallback, which meant an app missing tsconfig.app.json
+    // reported a passing typecheck it never ran.
+    const tsconfigAppPath = (0, path_1.join)(appPath, 'tsconfig.app.json');
+    reporter.step(app, 'tsc --noEmit', (0, fs_1.existsSync)(tsconfigAppPath)
+        ? run('npx', ['tsc', '--noEmit', '-p', tsconfigAppPath], '.')
+        : { ok: false, output: `no ${tsconfigAppPath}` });
+    // Endpoints never reach vite — they are bundled separately for the lambda,
+    // against a different resolver. tsc and vite both pass on an endpoint whose
+    // `zitejs/*` alias has no generated file behind it; only the bundler knows.
+    if ((0, sourceRoots_js_1.listEndpointNames)(root, appPath).length > 0) {
+        const bundle = run('npx', ['zitejs', 'bundle', '--app', dir], '.');
+        const failures = bundle.ok ? bundleFailures(bundle.output) : [bundle.output];
+        reporter.step(app, 'bundle endpoints', { ok: failures.length === 0, output: failures.join('\n') });
+    }
+    if ((0, fs_1.existsSync)((0, path_1.join)(appPath, 'vite.config.ts'))) {
+        reporter.step(app, 'vite build', run('npx', ['vite', 'build'], appPath));
+    }
+}
+async function runCheck(args = process.argv.slice(3)) {
+    const json = args.includes('--json');
+    const reporter = new Reporter(json);
+    const { isStartAppDir } = await Promise.resolve().then(() => __importStar(require('../start/entries.js')));
+    // Run inside a Start app, its own zitejs checks just that app: the workspace
+    // root's is a classic release that doesn't know Start.
+    const inStartApp = isStartAppDir('.');
+    const appDirs = inStartApp ? [] : (0, sourceRoots_js_1.listSourceDirs)();
+    if (!inStartApp && appDirs.length === 0) {
+        console.error('No apps or automations found under apps/ or automations/.');
+        process.exit(1);
+    }
+    const checkAll = async () => {
+        if (inStartApp)
+            await checkStartApp(reporter, reporter.app('.', 'start', false), '.');
+        for (const { root, dir, path: appPath } of appDirs) {
+            if (isStartAppDir(appPath)) {
+                await checkStartApp(reporter, reporter.app(appPath, 'start', true), appPath);
             }
             else {
-                console.log('✗');
-                console.log(vite.output.trim().split('\n').map(l => `    ${l}`).join('\n'));
-                allPassed = false;
+                checkClassicApp(reporter, reporter.app(appPath, 'classic', true), root, dir, appPath);
             }
         }
-    }
-    console.log('');
-    if (allPassed) {
-        console.log('All apps pass.');
+    };
+    await (json ? (0, exports.withStdoutOnStderr)(checkAll) : checkAll());
+    const allPassed = reporter.apps.every(app => app.ok);
+    if (json) {
+        process.stdout.write(`${JSON.stringify({ ok: allPassed, apps: reporter.apps })}\n`);
     }
     else {
-        console.log('Some apps failed.');
-        process.exit(1);
+        console.log('');
+        console.log(allPassed ? 'All apps pass.' : 'Some apps failed.');
     }
+    if (!allPassed)
+        process.exit(1);
 }

package/dist/cjs/check/start/describeRules.d.ts

@@ -0,0 +1,35 @@
+import type { Problem } from "./problem.js";
+type Access = {
+    kind: string;
+    roles?: string[];
+};
+export type CheckedDescription = {
+    functions: Array<{
+        id: string;
+        name?: string;
+        file?: string;
+        access: Access;
+        input?: unknown;
+        problems: string[];
+    }>;
+    routes: Array<{
+        path: string;
+        file?: string;
+        description?: string;
+        methods: Record<string, Access>;
+        problems: string[];
+    }>;
+    pages?: Array<{
+        path: string;
+        file?: string;
+    }>;
+    workflows?: Array<{
+        id: string;
+        file: string;
+        problems: string[];
+    }>;
+};
+export declare function describedProblems(description: CheckedDescription, { internal }: {
+    internal: boolean;
+}): Problem[];
+export {};