zitejs 0.9.120 → 0.9.121

package/dist/cjs/vite/domTagNames.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.domTagNames = void 0;
+exports.domTagNames = new Set([
+    "a",
+    "abbr",
+    "acronym",
+    "address",
+    "altGlyph",
+    "altGlyphDef",
+    "altGlyphItem",
+    "animate",
+    "animateColor",
+    "animateMotion",
+    "animateTransform",
+    "annotation",
+    "annotation-xml",
+    "applet",
+    "area",
+    "article",
+    "aside",
+    "audio",
+    "b",
+    "base",
+    "basefont",
+    "bdi",
+    "bdo",
+    "bgsound",
+    "big",
+    "blink",
+    "blockquote",
+    "body",
+    "br",
+    "button",
+    "canvas",
+    "caption",
+    "center",
+    "circle",
+    "cite",
+    "clipPath",
+    "code",
+    "col",
+    "colgroup",
+    "color-profile",
+    "command",
+    "content",
+    "cursor",
+    "data",
+    "datalist",
+    "dd",
+    "defs",
+    "del",
+    "desc",
+    "details",
+    "dfn",
+    "dialog",
+    "dir",
+    "discard",
+    "div",
+    "dl",
+    "dt",
+    "ellipse",
+    "em",
+    "embed",
+    "feBlend",
+    "feColorMatrix",
+    "feComponentTransfer",
+    "feComposite",
+    "feConvolveMatrix",
+    "feDiffuseLighting",
+    "feDisplacementMap",
+    "feDistantLight",
+    "feDropShadow",
+    "feFlood",
+    "feFuncA",
+    "feFuncB",
+    "feFuncG",
+    "feFuncR",
+    "feGaussianBlur",
+    "feImage",
+    "feMerge",
+    "feMergeNode",
+    "feMorphology",
+    "feOffset",
+    "fePointLight",
+    "feSpecularLighting",
+    "feSpotLight",
+    "feTile",
+    "feTurbulence",
+    "fieldset",
+    "figcaption",
+    "figure",
+    "filter",
+    "font",
+    "font-face",
+    "font-face-format",
+    "font-face-name",
+    "font-face-src",
+    "font-face-uri",
+    "footer",
+    "foreignObject",
+    "form",
+    "frame",
+    "frameset",
+    "g",
+    "glyph",
+    "glyphRef",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "head",
+    "header",
+    "hgroup",
+    "hkern",
+    "hr",
+    "html",
+    "i",
+    "iframe",
+    "image",
+    "img",
+    "input",
+    "ins",
+    "isindex",
+    "kbd",
+    "keygen",
+    "label",
+    "legend",
+    "li",
+    "line",
+    "linearGradient",
+    "link",
+    "listing",
+    "maction",
+    "main",
+    "map",
+    "mark",
+    "marker",
+    "marquee",
+    "mask",
+    "math",
+    "menu",
+    "menuitem",
+    "merror",
+    "meta",
+    "metadata",
+    "meter",
+    "mfrac",
+    "mi",
+    "missing-glyph",
+    "mmultiscripts",
+    "mn",
+    "mo",
+    "mover",
+    "mpadded",
+    "mpath",
+    "mphantom",
+    "mprescripts",
+    "mroot",
+    "mrow",
+    "ms",
+    "mspace",
+    "msqrt",
+    "mstyle",
+    "msub",
+    "msubsup",
+    "msup",
+    "mtable",
+    "mtd",
+    "mtext",
+    "mtr",
+    "multicol",
+    "munder",
+    "munderover",
+    "nav",
+    "nextid",
+    "nobr",
+    "noembed",
+    "noframes",
+    "noscript",
+    "object",
+    "ol",
+    "optgroup",
+    "option",
+    "output",
+    "p",
+    "param",
+    "path",
+    "pattern",
+    "picture",
+    "plaintext",
+    "polygon",
+    "polyline",
+    "pre",
+    "progress",
+    "q",
+    "radialGradient",
+    "rb",
+    "rbc",
+    "rect",
+    "rp",
+    "rt",
+    "rtc",
+    "ruby",
+    "s",
+    "samp",
+    "script",
+    "search",
+    "section",
+    "select",
+    "semantics",
+    "set",
+    "shadow",
+    "slot",
+    "small",
+    "source",
+    "spacer",
+    "span",
+    "stop",
+    "strike",
+    "strong",
+    "style",
+    "sub",
+    "summary",
+    "sup",
+    "svg",
+    "switch",
+    "symbol",
+    "table",
+    "tbody",
+    "td",
+    "template",
+    "text",
+    "textPath",
+    "textarea",
+    "tfoot",
+    "th",
+    "thead",
+    "time",
+    "title",
+    "tr",
+    "track",
+    "tref",
+    "tspan",
+    "tt",
+    "u",
+    "ul",
+    "use",
+    "var",
+    "video",
+    "view",
+    "vkern",
+    "wbr",
+    "xmp",
+]);

package/dist/cjs/vite/index.js

@@ -8,7 +8,9 @@ const parser_1 = require("@babel/parser");
 const magic_string_1 = __importDefault(require("magic-string"));
 const path_1 = __importDefault(require("path"));
 const estree_walker_1 = require("estree-walker");
+const domTagNames_js_1 = require("./domTagNames.js");
 const validExtensions = new Set([".jsx", ".tsx"]);
+const fragmentNames = new Set(["Fragment", "React.Fragment"]);
 function getComponentName(elementName) {
     if (elementName.type === "JSXIdentifier") {
         return elementName.name;
@@ -20,8 +22,17 @@ function getComponentName(elementName) {
     }
     return null;
 }
-function isNativeElement(name) {
-    return /^[a-z]/.test(name) && !name.includes(".");
+function classifyElement(name) {
+    if (fragmentNames.has(name)) {
+        return null;
+    }
+    if (!/^[a-z]/.test(name) || name.includes(".")) {
+        return "component";
+    }
+    if (domTagNames_js_1.domTagNames.has(name) || name.includes("-")) {
+        return "dom";
+    }
+    return null;
 }
 function ziteId() {
     const cwd = process.cwd();
@@ -46,21 +57,19 @@ function ziteId() {
                         if (node.type === "JSXElement") {
                             const openingElement = node.openingElement;
                             const children = node.children;
-                            const elementName = openingElement.name;
-                            const isFragment = (elementName.type === "JSXMemberExpression" &&
-                                elementName.object.name === "React" &&
-                                elementName.property.name === "Fragment") ||
-                                (elementName.type === "JSXIdentifier" &&
-                                    elementName.name === "Fragment");
-                            if (isFragment) {
+                            const componentName = getComponentName(openingElement.name);
+                            if (!componentName) {
+                                return;
+                            }
+                            const kind = classifyElement(componentName);
+                            if (!kind) {
                                 return;
                             }
                             const line = openingElement.loc?.start?.line ?? 0;
                             const col = openingElement.loc?.start?.column ?? 0;
                             const dataComponentId = `${relativePath}|${line}|${col}`;
                             let attributes = ` data-zite-id="${dataComponentId}"`;
-                            const componentName = getComponentName(openingElement.name);
-                            if (componentName && !isNativeElement(componentName)) {
+                            if (kind === "component") {
                                 attributes += ` data-zite-component="${componentName}"`;
                             }
                             if (children.length === 1 &&

package/dist/cjs/vite/index.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const vitest_1 = require("vitest");
+const index_js_1 = require("./index.js");
+async function transform(code) {
+    const plugin = (0, index_js_1.ziteId)();
+    const handler = plugin.transform;
+    const result = await handler(code, path_1.default.join(process.cwd(), 'src/App.tsx'));
+    if (!result) {
+        throw new Error('transform returned null');
+    }
+    return result.code;
+}
+(0, vitest_1.describe)('ziteId', () => {
+    (0, vitest_1.it)('tags html and svg elements without a component name', async () => {
+        const code = await transform('const a = <div><svg><path d="M0" /></svg><p>Hello</p></div>;');
+        (0, vitest_1.expect)(code).toContain('<div data-zite-id="src/App.tsx|1|10">');
+        (0, vitest_1.expect)(code).toContain('<svg data-zite-id="src/App.tsx|1|15">');
+        (0, vitest_1.expect)(code).toContain('<path data-zite-id="src/App.tsx|1|20" d="M0" />');
+        (0, vitest_1.expect)(code).toContain('<p data-zite-id="src/App.tsx|1|41" data-zite-editable="true">');
+        (0, vitest_1.expect)(code).not.toContain('data-zite-component');
+    });
+    (0, vitest_1.it)('tags components with their name', async () => {
+        const code = await transform('const a = <><Card /><motion.div /><_Private /></>;');
+        (0, vitest_1.expect)(code).toContain('<Card data-zite-id="src/App.tsx|1|12" data-zite-component="Card" />');
+        (0, vitest_1.expect)(code).toContain('<motion.div data-zite-id="src/App.tsx|1|20" data-zite-component="motion.div" />');
+        (0, vitest_1.expect)(code).toContain('<_Private data-zite-id="src/App.tsx|1|34" data-zite-component="_Private" />');
+    });
+    (0, vitest_1.it)('tags MathML elements', async () => {
+        const code = await transform('const a = <math><mi>x</mi></math>;');
+        (0, vitest_1.expect)(code).toBe('const a = <math data-zite-id="src/App.tsx|1|10"><mi data-zite-id="src/App.tsx|1|16" data-zite-editable="true">x</mi></math>;');
+    });
+    (0, vitest_1.it)('tags custom elements', async () => {
+        const code = await transform('const a = <my-widget />;');
+        (0, vitest_1.expect)(code).toBe('const a = <my-widget data-zite-id="src/App.tsx|1|10" />;');
+    });
+    (0, vitest_1.it)('leaves non-DOM intrinsic elements untouched', async () => {
+        const source = 'const a = <group><mesh position-x={1} /><ambientLight intensity={0.5} /></group>;';
+        (0, vitest_1.expect)(await transform(source)).toBe(source);
+    });
+    (0, vitest_1.it)('tags DOM elements nested inside non-DOM intrinsics', async () => {
+        const code = await transform('const a = <group><Html><div /></Html></group>;');
+        (0, vitest_1.expect)(code).toBe('const a = <group><Html data-zite-id="src/App.tsx|1|17" data-zite-component="Html"><div data-zite-id="src/App.tsx|1|23" /></Html></group>;');
+    });
+    (0, vitest_1.it)('leaves fragments untouched', async () => {
+        const source = 'const a = <Fragment><React.Fragment key="a" /></Fragment>;';
+        (0, vitest_1.expect)(await transform(source)).toBe(source);
+    });
+});

package/dist/esm/auth/config.d.ts

@@ -2,3 +2,6 @@ export declare function getFlowId(): string;
 export declare function getApiUrl(): string;
 export declare function getAuthPageUrl(): string;
 export declare function getDbToken(): string;
+/** Undefined for apps built before the platform sent this — treat as unknown,
+ *  never as a default side. */
+export declare function getAccessMode(): 'internal' | 'external' | undefined;

package/dist/esm/auth/config.js

@@ -30,3 +30,9 @@ export function getAuthPageUrl() {
 export function getDbToken() {
     return getEnv('ZITE_DB_TOKEN', 'VITE_ZITE_DB_TOKEN') ?? '';
 }
+/** Undefined for apps built before the platform sent this — treat as unknown,
+ *  never as a default side. */
+export function getAccessMode() {
+    const mode = getEnv('ZITE_ACCESS_MODE', 'VITE_ZITE_ACCESS_MODE');
+    return mode === 'internal' || mode === 'external' ? mode : undefined;
+}

package/dist/esm/auth/index.js

@@ -1,6 +1,8 @@
+import { useEffect } from 'react';
 import { createAuthClient } from 'better-auth/react';
 import { magicLinkClient, inferAdditionalFields, } from 'better-auth/client/plugins';
 import { USAGE_TOKEN_QUERY_PARAM } from './constants.js';
+import { getAccessMode } from './config.js';
 const authClient = createAuthClient({
     baseURL: '',
     plugins: [
@@ -14,6 +16,22 @@ const authClient = createAuthClient({
     ],
 });
 export const useSession = authClient.useSession;
+/**
+ * An internal app has no signed-out state — SSO runs before the bundle — so an
+ * empty session means it died underneath the app. Only `internal`: elsewhere a
+ * signed-out visitor is legitimate.
+ */
+function shouldRedirectSignedOut(isPending, hasUser) {
+    if (isPending || hasUser)
+        return false;
+    if (getAccessMode() !== 'internal')
+        return false;
+    if (typeof window === 'undefined')
+        return false;
+    // `loginWithRedirect` won't navigate from an auth page, so claiming a
+    // redirect here would hang `isLoading` forever.
+    return !window.location.pathname.startsWith('/auth/');
+}
 /**
  * `loginWithRedirect` and `logout` are returned as well as exported. The
  * pre-monorepo `useAuth()` returned them, so app code that destructures them
@@ -22,9 +40,17 @@ export const useSession = authClient.useSession;
  */
 export function useAuth() {
     const { data, isPending } = useSession();
+    const user = data?.user ?? null;
+    const redirecting = shouldRedirectSignedOut(isPending, user !== null);
+    useEffect(() => {
+        if (redirecting)
+            loginWithRedirect();
+    }, [redirecting]);
     return {
-        user: data?.user ?? null,
-        isLoading: isPending,
+        user,
+        // Loading, not signed out: the signed-out branch is the empty screen this
+        // exists to prevent.
+        isLoading: isPending || redirecting,
         loginWithRedirect,
         logout,
     };

package/dist/esm/auth/useAuth.test.js

@@ -1,16 +1,6 @@
 import { describe, it, expect, afterEach, beforeEach, vi } from 'vitest';
-/**
- * The signed-out redirect on internal apps.
- *
- * A separate file from `index.test.ts` because it has to replace
- * `better-auth/react` wholesale to drive `useSession`, and that would strip the
- * real client the export tests next door assert against.
- *
- * The value here is entirely in WHICH signed-out renders it reacts to. An
- * external app has a real logged-out state, and an app built before the
- * platform sent an access mode tells us nothing — redirecting either turns a
- * working public page into a forced sign-in.
- */
+// Separate from index.test.ts: driving `useSession` means replacing
+// `better-auth/react`, which would strip the real client asserted against there.
 const { useSessionMock } = vi.hoisted(() => ({ useSessionMock: vi.fn() }));
 vi.mock('better-auth/react', () => ({
     createAuthClient: () => ({
@@ -25,8 +15,7 @@ vi.mock('better-auth/client/plugins', () => ({
     magicLinkClient: () => ({}),
     inferAdditionalFields: () => ({}),
 }));
-// `useAuth` takes only `useEffect` from React. Running it inline is the whole
-// of what a render would do here, and avoids pulling in a renderer.
+// `useAuth` uses only `useEffect`; running it inline avoids pulling in a renderer.
 vi.mock('react', () => ({ useEffect: (fn) => fn() }));
 import { useAuth } from './index.js';
 const APP_URL = 'https://app.zite.so/dashboard';
@@ -55,8 +44,6 @@ describe('useAuth signed-out handling', () => {
     it('sends a signed-out visitor on an internal app to sign-in', () => {
         const { result, location } = render(signedOut, { accessMode: 'internal' });
         expect(location.href.startsWith('/auth/login')).toBe(true);
-        // Reported as loading rather than signed out: the signed-out branch of an
-        // internal app is the empty screen this exists to prevent.
         expect(result.isLoading).toBe(true);
     });
     it('leaves a signed-out visitor on an external app alone', () => {
@@ -65,7 +52,7 @@ describe('useAuth signed-out handling', () => {
         expect(result.isLoading).toBe(false);
         expect(result.user).toBe(null);
     });
-    // Every app published before the platform started sending an access mode.
+    // i.e. every app published before the platform sent an access mode.
     it('leaves an app that never declared an access mode alone', () => {
         const { result, location } = render(signedOut);
         expect(location.href).toBe(APP_URL);
@@ -82,8 +69,7 @@ describe('useAuth signed-out handling', () => {
         expect(result.isLoading).toBe(false);
         expect(result.user).toMatchObject({ id: 'u1' });
     });
-    // `loginWithRedirect` refuses to navigate away from an auth page, so claiming
-    // a redirect here would hang the caller on `isLoading` forever.
+    // Claiming a redirect it can't make would hang `isLoading` forever.
     it('does not claim to be loading on an auth page it cannot leave', () => {
         const { result } = render(signedOut, {
             accessMode: 'internal',

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

@@ -3,6 +3,27 @@ export type { ZiteSchedule };
 export type ZiteWebhook = {
     paused?: boolean;
 };
+/**
+ * A provider trigger: what should fire the endpoint, declared as a literal.
+ * The platform registers it with the provider at publish, verifies each
+ * delivery and queues it; the endpoint only sees the payload. A `poll`
+ * trigger runs the endpoint on a cadence with `input.__poll.cursor` from the
+ * previous run, and the endpoint returns `{ cursor }` to advance it.
+ */
+export type ZiteTrigger = {
+    /**
+     * The connection's name in `zite.config.json`. Registered with the
+     * provider by `src/triggers/<endpointId>/subscribe.ts` and taken down
+     * by `unsubscribe.ts`, which the platform runs at publish and teardown.
+     */
+    integration: string;
+    paused?: boolean;
+} | {
+    provider: "poll";
+    /** `<n>m` (1–59) or `<n>h` (1–23) */
+    every: string;
+    paused?: boolean;
+};
 export interface ZiteRequestContext {
     user: {
         id: string;
@@ -58,7 +79,7 @@ export type ZiteStreamInterface = {
     write: (data: unknown) => Promise<void>;
     forward: (asyncIterable: AsyncIterable<string>) => Promise<string>;
 };
-export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput> {
+export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput, TTrigger extends ZiteTrigger | undefined = undefined> {
     description?: string;
     inputSchema?: SchemaLike<TInput, TRawInput>;
     /**
@@ -82,6 +103,12 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      * `{ user: null }` for a webhook fire exactly as it does for a cron one.
      */
     webhook?: TWebhook;
+    /**
+     * When set, the platform fires this endpoint from the named provider. Like
+     * `schedule` and `webhook`, this widens `context`: a provider delivery has
+     * no signed-in user.
+     */
+    trigger?: TTrigger;
     /**
      * Set by {@link createEndpoint}, not by hand. The worker validates
      * `inputSchema` for bundles built before this did, and skips ones that
@@ -90,7 +117,7 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
     validatesInput?: boolean;
     execute: (params: {
         input: TInput;
-        context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
+        context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
     } : {})) => Promise<TOutput> | TOutput;
@@ -102,4 +129,4 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
  * field could be missing and the endpoint ran anyway. Parsing here is also what
  * makes `TRawInput` -> `TInput` (defaults, transforms) true at runtime.
  */
-export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput>(config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput>;
+export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false, TSchedule extends ZiteSchedule | undefined = undefined, TWebhook extends ZiteWebhook | undefined = undefined, TRawInput = TInput, TTrigger extends ZiteTrigger | undefined = undefined>(config: EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput, TTrigger>): EndpointConfig<TInput, TOutput, TStream, TSchedule, TWebhook, TRawInput, TTrigger>;

package/dist/esm/backend/index.js

@@ -27,7 +27,7 @@ export class ZiteError extends Error {
     }
 }
 /** Injected by the runner on a platform-fired run — see `isPlatformTriggeredInput`. */
-const PLATFORM_TRIGGER_KEYS = ["__cron", "__webhook"];
+const PLATFORM_TRIGGER_KEYS = ["__cron", "__webhook", "__poll"];
 function isPlatformTriggeredInput(input) {
     if (typeof input !== "object" || input === null)
         return false;
@@ -55,7 +55,7 @@ function describeIssues(error) {
  */
 export function createEndpoint(config) {
     const { inputSchema, execute } = config;
-    const firesWithoutARequest = Boolean(config.schedule || config.webhook);
+    const firesWithoutARequest = Boolean(config.schedule || config.webhook || config.trigger);
     // An `inputSchema` that isn't a validator stays inert, as it was.
     if (!inputSchema || typeof inputSchema.parse !== "function")
         return config;

package/dist/esm/bundle/index.d.ts

@@ -8,7 +8,7 @@
  *
  * Usage:
  *   npx zitejs bundle                     # bundle all endpoints
- *   npx zitejs bundle --app admin-panel   # bundle endpoints for a specific app
+ *   npx zitejs bundle --app admin-panel   # bundle endpoints for one app or automation, by dir name
  *   npx zitejs bundle --script <path>     # bundle a one-off script
  *
  * Output: JSON to stdout

package/dist/esm/bundle/index.js

@@ -8,7 +8,7 @@
  *
  * Usage:
  *   npx zitejs bundle                     # bundle all endpoints
- *   npx zitejs bundle --app admin-panel   # bundle endpoints for a specific app
+ *   npx zitejs bundle --app admin-panel   # bundle endpoints for one app or automation, by dir name
  *   npx zitejs bundle --script <path>     # bundle a one-off script
  *
  * Output: JSON to stdout
@@ -24,6 +24,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import { parse } from '@babel/parser';
 import { builtinModules } from 'node:module';
+import { findSourceDir } from '../sourceRoots.js';
 // workerd's `nodejs_compat` does not provide these. Left external they bundle
 // fine and then kill the worker at load time with `No such module`; excluded,
 // esbuild fails the one endpoint with a resolvable error instead. Pinned by
@@ -578,7 +579,10 @@ export async function runBundle() {
     const appFlag = args.indexOf('--app');
     let baseDir = process.cwd();
     if (appFlag !== -1 && args[appFlag + 1]) {
-        baseDir = path.resolve(baseDir, 'apps', args[appFlag + 1]);
+        const name = args[appFlag + 1];
+        // A dir that exists under no root still resolves under `apps/`, so the
+        // error names the path a caller expects rather than "not found".
+        baseDir = path.resolve(baseDir, findSourceDir(name, baseDir)?.path ?? path.join('apps', name));
     }
     // If explicit endpoint names passed, use those; otherwise find all.
     // Skipping `--app`'s VALUE as well as the flag: it is a positional arg, so

package/dist/esm/check/index.js

@@ -1,14 +1,7 @@
 import { execFileSync } from 'child_process';
-import { existsSync, readdirSync } from 'fs';
+import { existsSync } from 'fs';
 import { join } from 'path';
-function findAppDirs() {
-    const appsDir = 'apps';
-    if (!existsSync(appsDir))
-        return [];
-    return readdirSync(appsDir, { withFileTypes: true })
-        .filter(d => d.isDirectory())
-        .map(d => d.name);
-}
+import { listSourceDirs } from '../sourceRoots.js';
 /**
  * An argument array, not a command string, so no shell is involved.
  *
@@ -63,15 +56,14 @@ function bundleFailures(output) {
     return failures;
 }
 export async function runCheck() {
-    const appDirs = findAppDirs();
+    const appDirs = listSourceDirs();
     if (appDirs.length === 0) {
-        console.error('No apps found in apps/ directory.');
+        console.error('No apps or automations found under apps/ or automations/.');
         process.exit(1);
     }
     let allPassed = true;
-    for (const app of appDirs) {
-        const appPath = join('apps', app);
-        console.log(`\n── ${app} ──`);
+    for (const { 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

package/dist/esm/cli.js

@@ -38,8 +38,8 @@ async function main() {
             console.error('Commands:');
             console.error('  sync      Generate .zite/db.ts from database schema (single-app)');
             console.error('  dev       Run sync then watch for changes (like npx convex dev)');
-            console.error('  generate  One-shot sync + regenerate all apps .zite/ files (monorepo)');
-            console.error('  check   Run tsc --noEmit and vite build for all apps');
+            console.error('  generate  Regenerate every app and automation .zite/ (monorepo)');
+            console.error('  check   Run tsc --noEmit (and vite build where there is one) for every app and automation');
             console.error('  bundle  Bundle src/api/*.ts endpoints for cloudflare-lambda');
             process.exit(1);
     }