zitejs 0.9.119 → 0.9.121

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);
     }

package/dist/esm/dev/index.js

@@ -1,8 +1,9 @@
 import { watch } from "fs";
 import { existsSync, readdirSync, readFileSync, writeFileSync, mkdirSync, } from "fs";
 import { join } from "path";
+import { listSourceDirs } from "../sourceRoots.js";
 import { runSync } from "../sync/index.js";
-import { generateDbTs, generateApiTs, generateBackendWrapperTs, generateAirtableTs, generateEmailSdk, } from "../sync/lib.js";
+import { generateDbTs, generateApiTs, generateBackendWrapperTs, generateAirtableTs, findEmailIntegrationId, generateEmailSdk, } from "../sync/lib.js";
 const debounceTimers = new Map();
 function debounce(key, fn, ms) {
     const existing = debounceTimers.get(key);
@@ -10,17 +11,9 @@ function debounce(key, fn, ms) {
         clearTimeout(existing);
     debounceTimers.set(key, setTimeout(fn, ms));
 }
-function findAppDirs() {
-    const appsDir = "apps";
-    if (!existsSync(appsDir))
-        return [];
-    return readdirSync(appsDir, { withFileTypes: true })
-        .filter((d) => d.isDirectory())
-        .map((d) => d.name);
-}
 function getFlowId(appDir) {
     try {
-        const configPath = join("apps", appDir, "zite.config.json");
+        const configPath = join(appDir.path, "zite.config.json");
         if (existsSync(configPath)) {
             const config = JSON.parse(readFileSync(configPath, "utf-8"));
             return config.id;
@@ -29,28 +22,22 @@ function getFlowId(appDir) {
     catch { }
     return undefined;
 }
-/**
- * Find the connected email integration's key in an app's zite.config.json,
- * if any. The key is the integrationId used by the runtime SDK bridge.
- */
-function getEmailIntegrationId(appDir) {
+const readJsonFile = (path) => {
     try {
-        const configPath = join("apps", appDir, "zite.config.json");
-        if (!existsSync(configPath))
-            return undefined;
-        const config = JSON.parse(readFileSync(configPath, "utf-8"));
-        const integrations = config.integrations ?? {};
-        for (const [id, int] of Object.entries(integrations)) {
-            if (int?.type === "email")
-                return id;
-        }
+        return existsSync(path)
+            ? JSON.parse(readFileSync(path, "utf-8"))
+            : undefined;
     }
-    catch { }
-    return undefined;
+    catch {
+        return undefined;
+    }
+};
+function getEmailIntegrationId(appDir) {
+    return findEmailIntegrationId(readJsonFile(join(appDir.path, "zite.config.json")), readJsonFile("zite.config.json"));
 }
 function getDeclaredEnvVarNames(appDir) {
     try {
-        const configPath = join("apps", appDir, "zite.config.json");
+        const configPath = join(appDir.path, "zite.config.json");
         if (!existsSync(configPath))
             return [];
         const config = JSON.parse(readFileSync(configPath, "utf-8"));
@@ -61,7 +48,7 @@ function getDeclaredEnvVarNames(appDir) {
     }
 }
 function regenerateAppTypedWrappers(appDir) {
-    const outDir = join("apps", appDir, ".zite");
+    const outDir = join(appDir.path, ".zite");
     mkdirSync(outDir, { recursive: true });
     // user.ts and auth.ts no longer generated — User type is fixed in zitejs/auth
     // Email integration: generate the Email client at .zite/integrations/email.ts.
@@ -76,7 +63,7 @@ function regenerateAppTypedWrappers(appDir) {
     writeFileSync(join(outDir, "backend.ts"), generateBackendWrapperTs(getDeclaredEnvVarNames(appDir)));
 }
 function regenerateAppApiTs(appDir) {
-    const apiDir = join("apps", appDir, "src", "api");
+    const apiDir = join(appDir.path, "src", "api");
     if (!existsSync(apiDir))
         return;
     // Sorted because `readdir` order is unspecified — it is whatever the
@@ -96,14 +83,14 @@ function regenerateAppApiTs(appDir) {
     }));
     const content = generateApiTs(endpointFiles);
     if (content) {
-        const outDir = join("apps", appDir, ".zite");
+        const outDir = join(appDir.path, ".zite");
         mkdirSync(outDir, { recursive: true });
         writeFileSync(join(outDir, "api.ts"), content);
-        console.log(`Updated apps/${appDir}/.zite/api.ts`);
+        console.log(`Updated ${appDir.path}/.zite/api.ts`);
     }
 }
 function regenerateAppAirtableSdk(appDir) {
-    const lockPath = join("apps", appDir, "zite.lock");
+    const lockPath = join(appDir.path, "zite.lock");
     console.log(`[airtable-sdk] Checking ${lockPath} exists: ${existsSync(lockPath)}`);
     if (!existsSync(lockPath))
         return;
@@ -124,15 +111,15 @@ function regenerateAppAirtableSdk(appDir) {
             };
             const content = generateAirtableTs(airtableLock);
             if (content) {
-                const outDir = join("apps", appDir, ".zite", "integrations");
+                const outDir = join(appDir.path, ".zite", "integrations");
                 mkdirSync(outDir, { recursive: true });
                 writeFileSync(join(outDir, "airtable.ts"), content);
-                console.log(`Updated apps/${appDir}/.zite/integrations/airtable.ts`);
+                console.log(`Updated ${appDir.path}/.zite/integrations/airtable.ts`);
             }
         }
     }
     catch (err) {
-        console.error(`[airtable-sdk] Error processing lock for ${appDir}:`, err);
+        console.error(`[airtable-sdk] Error processing lock for ${appDir.path}:`, err);
     }
 }
 export async function runGenerate() {
@@ -156,8 +143,8 @@ export async function runGenerate() {
     catch (err) {
         console.warn("DB SDK generation failed:", err instanceof Error ? err.message : err);
     }
-    // 2. Find all apps and regenerate their .zite/ files
-    const appDirs = findAppDirs();
+    // 2. Find every app and automation and regenerate their .zite/ files
+    const appDirs = listSourceDirs();
     for (const app of appDirs) {
         regenerateAppApiTs(app);
         regenerateAppTypedWrappers(app);
@@ -177,33 +164,33 @@ export async function runDev() {
         console.warn("Initial sync failed (continuing with watcher):", err instanceof Error ? err.message : err);
     }
     console.log("");
-    // 2. Find all apps and regenerate their .zite/ files
-    const appDirs = findAppDirs();
+    // 2. Find every app and automation and regenerate their .zite/ files
+    const appDirs = listSourceDirs();
     for (const app of appDirs) {
         regenerateAppApiTs(app);
         regenerateAppTypedWrappers(app);
     }
-    // 3. Watch each app's src/api/ for endpoint changes
+    // 3. Watch each dir's src/api/ for endpoint changes
     let watchingAny = false;
     for (const app of appDirs) {
-        const apiDir = join("apps", app, "src", "api");
+        const apiDir = join(app.path, "src", "api");
         if (!existsSync(apiDir))
             continue;
         watchingAny = true;
-        console.log(`Watching apps/${app}/src/api/ for endpoint changes...`);
+        console.log(`Watching ${app.path}/src/api/ for endpoint changes...`);
         watch(apiDir, { recursive: true }, (_event, filename) => {
             if (!filename)
                 return;
             if (!filename.endsWith(".ts") && !filename.endsWith(".js"))
                 return;
-            debounce(app, () => {
-                console.log(`Endpoint changed in ${app}: ${filename}`);
+            debounce(app.path, () => {
+                console.log(`Endpoint changed in ${app.path}: ${filename}`);
                 regenerateAppApiTs(app);
             }, 200);
         });
     }
     if (!watchingAny) {
-        console.log("No apps with src/api/ found.");
+        console.log("No apps or automations with src/api/ found.");
     }
     // 4. Watch zite.schema.json for schema drift
     if (existsSync("zite.schema.json")) {

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

@@ -0,0 +1,14 @@
+export type ZiteProjectUser = {
+    uuid: string;
+    firstName: string | null;
+    lastName: string | null;
+    email: string;
+    profilePictureUrl: string | null;
+};
+export type MetaListUsersResult = {
+    users: ZiteProjectUser[];
+};
+export declare class ZiteMeta {
+    static listUsers(): Promise<MetaListUsersResult>;
+}
+export declare const Meta: typeof ZiteMeta;

package/dist/esm/meta/index.js

@@ -0,0 +1,8 @@
+import { getSdkCall } from '../internal/sdkCall.js';
+const META_SDK_INTEGRATION_ID = '__meta__';
+export class ZiteMeta {
+    static listUsers() {
+        return getSdkCall()(META_SDK_INTEGRATION_ID, 'ZiteMeta', 'listUsers', {});
+    }
+}
+export const Meta = ZiteMeta;

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

@@ -0,0 +1,25 @@
+export interface NotificationLink {
+    path?: string;
+    params?: Record<string, string>;
+}
+export type NotificationsCreateParams = {
+    recipients: string[];
+    title: string;
+    body?: string;
+    link?: NotificationLink;
+    path?: string;
+    params?: Record<string, string>;
+    payload?: Record<string, unknown>;
+    idempotencyKey?: string;
+};
+export type NotificationsCreateResult = {
+    created: number;
+} | {
+    created: 0;
+    preview: true;
+    wouldCreate: number;
+};
+export declare class ZiteNotifications {
+    static create(params: NotificationsCreateParams): Promise<NotificationsCreateResult>;
+}
+export declare const Notifications: typeof ZiteNotifications;

package/dist/esm/notifications/index.js

@@ -0,0 +1,8 @@
+import { getSdkCall } from '../internal/sdkCall.js';
+const NOTIFICATIONS_SDK_INTEGRATION_ID = '__notifications__';
+export class ZiteNotifications {
+    static create(params) {
+        return getSdkCall()(NOTIFICATIONS_SDK_INTEGRATION_ID, 'ZiteNotifications', 'create', params);
+    }
+}
+export const Notifications = ZiteNotifications;

package/dist/esm/sourceRoots.d.ts

@@ -0,0 +1,19 @@
+/**
+ * The repo-root directories a project's own source lives under: `apps/` for
+ * apps and `automations/` for automations (endpoints with no frontend). The
+ * backend keeps the same list; a dir name is unique across both roots, so a
+ * bare name still identifies one dir.
+ */
+export declare const SOURCE_ROOTS: readonly ["apps", "automations"];
+export type SourceRoot = (typeof SOURCE_ROOTS)[number];
+export interface SourceDir {
+    root: SourceRoot;
+    /** The bare directory name. */
+    dir: string;
+    /** `<root>/<dir>`, relative to the repo root. */
+    path: string;
+}
+/** Every source dir under every root, in root order then name order. */
+export declare function listSourceDirs(cwd?: string): SourceDir[];
+/** The source dir with this bare name, under whichever root holds it. */
+export declare function findSourceDir(name: string, cwd?: string): SourceDir | undefined;

package/dist/esm/sourceRoots.js

@@ -0,0 +1,28 @@
+import { existsSync, readdirSync } from "fs";
+import { join } from "path";
+/**
+ * The repo-root directories a project's own source lives under: `apps/` for
+ * apps and `automations/` for automations (endpoints with no frontend). The
+ * backend keeps the same list; a dir name is unique across both roots, so a
+ * bare name still identifies one dir.
+ */
+export const SOURCE_ROOTS = ["apps", "automations"];
+/** Every source dir under every root, in root order then name order. */
+export function listSourceDirs(cwd = ".") {
+    const dirs = [];
+    for (const root of SOURCE_ROOTS) {
+        const rootPath = join(cwd, root);
+        if (!existsSync(rootPath))
+            continue;
+        for (const entry of readdirSync(rootPath, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            dirs.push({ root, dir: entry.name, path: join(root, entry.name) });
+        }
+    }
+    return dirs;
+}
+/** The source dir with this bare name, under whichever root holds it. */
+export function findSourceDir(name, cwd = ".") {
+    return listSourceDirs(cwd).find((d) => d.dir === name);
+}

package/dist/esm/sync/lib.d.ts

@@ -82,6 +82,12 @@ export declare function normalizeAirtableLockNames(lock: AirtableLock): {
 };
 export declare function generateAirtableTs(inputLock: AirtableLock): string | null;
 export declare function generateBackendWrapperTs(envVarNames?: string[]): string;
+/**
+ * The key of the email integration an app sends through, which is the
+ * integrationId the runtime SDK bridge dispatches on. The app's own entry wins;
+ * otherwise it is the workspace email the app has `integrationSettings` for.
+ */
+export declare function findEmailIntegrationId(appConfig: unknown, workspaceConfig: unknown): string | undefined;
 /**
  * Generate `.zite/integrations/email.ts` — the `Email` client for an app with
  * an email integration connected. Mirrors the airtable SDK generation: a thin

package/dist/esm/sync/lib.js

@@ -1333,6 +1333,18 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "",
     ].join("\n");
 }
+/**
+ * The key of the email integration an app sends through, which is the
+ * integrationId the runtime SDK bridge dispatches on. The app's own entry wins;
+ * otherwise it is the workspace email the app has `integrationSettings` for.
+ */
+export function findEmailIntegrationId(appConfig, workspaceConfig) {
+    const app = (appConfig ?? {});
+    const workspace = (workspaceConfig ?? {});
+    const isEmail = (config, id) => config.integrations?.[id]?.type === "email";
+    return (Object.keys(app.integrations ?? {}).find((id) => isEmail(app, id)) ??
+        Object.keys(app.integrationSettings ?? {}).find((id) => isEmail(workspace, id)));
+}
 /**
  * Generate `.zite/integrations/email.ts` — the `Email` client for an app with
  * an email integration connected. Mirrors the airtable SDK generation: a thin

package/dist/esm/sync/lib.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import ts from 'typescript';
-import { generateAirtableTs, generateApiTs, generateBackendWrapperTs, generateDbTs, generateEmailSdk, } from './lib.js';
+import { findEmailIntegrationId, generateAirtableTs, generateApiTs, generateBackendWrapperTs, generateDbTs, generateEmailSdk, } from './lib.js';
 /**
  * Syntax errors in the emitted source. `.zite/db.ts` sits at the repo root and
  * every app imports it, so anything unparseable here fails typecheck for the
@@ -380,3 +380,31 @@ describe('generateBackendWrapperTs', () => {
         expect(output).toContain('ZiteError');
     });
 });
+describe('findEmailIntegrationId', () => {
+    const workspace = {
+        integrations: {
+            slack: { type: 'slack' },
+            'team-email': { type: 'email' },
+        },
+    };
+    it('finds the app\'s own email entry', () => {
+        expect(findEmailIntegrationId({ integrations: { mail: { type: 'email' } } }, workspace)).toBe('mail');
+    });
+    it('finds the workspace email the app has settings for', () => {
+        expect(findEmailIntegrationId({ integrationSettings: { slack: {}, 'team-email': { fromName: 'Ops' } } }, workspace)).toBe('team-email');
+    });
+    // An app that never opted in generates no client, so `zitejs/email` stays
+    // unresolved there instead of sending as a sender it never chose.
+    it('ignores a workspace email the app has no settings for', () => {
+        expect(findEmailIntegrationId({}, workspace)).toBeUndefined();
+    });
+    it('prefers the app\'s own entry over a workspace one', () => {
+        expect(findEmailIntegrationId({
+            integrations: { mail: { type: 'email' } },
+            integrationSettings: { 'team-email': {} },
+        }, workspace)).toBe('mail');
+    });
+    it('tolerates missing configs', () => {
+        expect(findEmailIntegrationId(undefined, undefined)).toBeUndefined();
+    });
+});

package/dist/esm/upload/index.js

@@ -106,6 +106,25 @@ async function performUpload(data, filename) {
     if (!putRes.ok) {
         throw new FileUploadError('Upload failed');
     }
+    // Gateways that predate the storage ledger omit the token. The file is
+    // already at fileUrl, so those uploads still succeed.
+    if (session.completionToken) {
+        const completeRes = await fetch(getApiUrl() +
+            '/v1/zite/public/' +
+            flowId +
+            '/complete-upload?mode=' +
+            mode, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...authHeaders(),
+            },
+            body: JSON.stringify({ completionToken: session.completionToken }),
+        });
+        if (!completeRes.ok) {
+            throw new FileUploadError(await readErrorMessage(completeRes, 'Upload failed'));
+        }
+    }
     return session.fileUrl;
 }
 export async function uploadFile({ data, filename, }) {

package/dist/esm/upload/index.test.js

@@ -23,7 +23,7 @@ describe('toUploadBlob', () => {
     });
 });
 describe('uploadFile', () => {
-    it('requests a session then PUTs the bytes to the presigned URL', async () => {
+    it('requests a session, PUTs the bytes, then completes the upload', async () => {
         const file = new File(['hello-world'], 'hello.txt', { type: 'text/plain' });
         fetchMock
             .mockResolvedValueOnce({
@@ -33,12 +33,14 @@ describe('uploadFile', () => {
                 presignedUrl: 'https://s3.example.com/put',
                 fileUrl: 'https://uploads.zite.com/orgid-1/zite-uploads/app_123/hello.txt',
                 contentType: 'text/plain',
+                completionToken: 'signed-token',
             }),
         })
-            .mockResolvedValueOnce({ ok: true });
+            .mockResolvedValueOnce({ ok: true })
+            .mockResolvedValueOnce({ ok: true, json: async () => ({ success: true }) });
         const result = await uploadFile({ data: file, filename: 'hello.txt' });
         expect(result.fileUrl).toContain('hello.txt');
-        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(fetchMock).toHaveBeenCalledTimes(3);
         expect(fetchMock.mock.calls[0][0]).toBe('https://api.example.com/v1/zite/public/app_123/upload-session?mode=live');
         const sessionInit = fetchMock.mock.calls[0][1];
         expect(JSON.parse(sessionInit.body)).toEqual({
@@ -48,6 +50,31 @@ describe('uploadFile', () => {
         });
         expect(fetchMock.mock.calls[1][0]).toBe('https://s3.example.com/put');
         expect(fetchMock.mock.calls[1][1].method).toBe('PUT');
+        expect(fetchMock.mock.calls[2][0]).toBe('https://api.example.com/v1/zite/public/app_123/complete-upload?mode=live');
+        const completeInit = fetchMock.mock.calls[2][1];
+        expect(completeInit.method).toBe('POST');
+        expect(JSON.parse(completeInit.body)).toEqual({
+            completionToken: 'signed-token',
+        });
+    });
+    it('skips completion when the gateway does not issue a token', async () => {
+        fetchMock
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({
+                success: true,
+                presignedUrl: 'https://s3.example.com/put',
+                fileUrl: 'https://uploads.zite.com/orgid-1/zite-uploads/app_123/hello.txt',
+                contentType: 'text/plain',
+            }),
+        })
+            .mockResolvedValueOnce({ ok: true });
+        const result = await uploadFile({
+            data: new File(['hello-world'], 'hello.txt', { type: 'text/plain' }),
+            filename: 'hello.txt',
+        });
+        expect(result.fileUrl).toContain('hello.txt');
+        expect(fetchMock).toHaveBeenCalledTimes(2);
     });
     it('surfaces the plan-limit message from the session endpoint', async () => {
         fetchMock.mockResolvedValueOnce({

package/dist/esm/vite/domTagNames.d.ts

@@ -0,0 +1 @@
+export declare const domTagNames: ReadonlySet<string>;