zitejs 0.10.0-start.4 → 0.10.0-start.6

package/dist/cjs/start/entries.d.ts

@@ -1,8 +1,12 @@
 import type { SourceDir } from "../sourceRoots.js";
 export declare const START_SERVER_ENTRY = ".zite/server.ts";
 export declare const START_INSTANCE_ENTRY = ".zite/start.ts";
-/** The server entry every Start app builds with. Platform-owned: regenerated, never edited. */
-export declare const renderStartServerEntry: () => string;
+export type StartTarget = "cloudflare" | "node";
+/**
+ * The server entry every Start app builds with. Platform-owned: regenerated,
+ * never edited. On Workers it's an entrypoint the host can also call over RPC.
+ */
+export declare const renderStartServerEntry: (target?: StartTarget) => string;
 /** The start instance: the platform's middleware, then the app's own `src/start.ts` when it has one. */
 export declare const renderStartInstance: (hasAppStart: boolean) => string;
 export declare const hasAppStart: (appDir: string) => boolean;

package/dist/cjs/start/entries.js

@@ -8,8 +8,19 @@ const node_path_1 = require("node:path");
 exports.START_SERVER_ENTRY = ".zite/server.ts";
 exports.START_INSTANCE_ENTRY = ".zite/start.ts";
 const APP_START_FILES = ["src/start.ts", "src/start.tsx"];
-/** The server entry every Start app builds with. Platform-owned: regenerated, never edited. */
-const renderStartServerEntry = () => `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+/**
+ * The server entry every Start app builds with. Platform-owned: regenerated,
+ * never edited. On Workers it's an entrypoint the host can also call over RPC.
+ */
+const renderStartServerEntry = (target = "cloudflare") => target === "cloudflare"
+    ? `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+import handler from '@tanstack/react-start/server-entry';
+import { createZiteWorker } from 'zitejs/start/worker';
+import { getRouter } from '../src/router';
+
+export default createZiteWorker({ handler, getRouter });
+`
+    : `// Generated by zitejs for TanStack Start apps. The platform owns this file.
 import handler, { createServerEntry } from '@tanstack/react-start/server-entry';
 import { createZiteFetch } from 'zitejs/start/server';
 import { getRouter } from '../src/router';

package/dist/esm/start/describe.d.ts

@@ -1,3 +1,4 @@
+import type { ZiteTrigger } from "../backend/index.js";
 import type { LoadedWorkflow } from "./workflowRun.js";
 import type { WorkflowConfig } from "./workflow.js";
 export type Access = {
@@ -26,7 +27,13 @@ export type DescribedWorkflow = {
     file: string;
     description?: string;
     schedule?: WorkflowConfig["schedule"];
-    trigger?: WorkflowConfig["trigger"];
+    /** As declared, without a provider trigger's `subscribe` and `unsubscribe`. */
+    trigger?: ZiteTrigger;
+    /** A provider trigger's: whether it can be taken down, and a hash of both functions' code, so publish registers it again when they change. */
+    registration?: {
+        unsubscribe: boolean;
+        hash: string;
+    };
     problems: string[];
 };
 export type Description = {

package/dist/esm/start/describe.js

@@ -123,6 +123,19 @@ export function describeRoutes(routesById) {
     }
     return out;
 }
+// cyrb53: enough to tell when the code changed, which is all publish asks.
+const sourceHash = (text) => {
+    let h1 = 0xdeadbeef;
+    let h2 = 0x41c6ce57;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text.charCodeAt(i);
+        h1 = Math.imul(h1 ^ ch, 2654435761);
+        h2 = Math.imul(h2 ^ ch, 1597334677);
+    }
+    h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+    h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+    return (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16).padStart(14, "0");
+};
 // A workflow's id is its export name: what the host invokes it by and the editor shows.
 export function describeWorkflows(workflows) {
     return workflows.map(({ id, file, workflow }) => {
@@ -133,7 +146,21 @@ export function describeWorkflows(workflows) {
         if (elsewhere)
             problems.push(`duplicate-workflow: ${id} is also exported from ${elsewhere.file}`);
         const { description, schedule, trigger } = workflow.config;
-        return { id, file, description, ...(schedule ? { schedule } : { trigger }), problems };
+        if (schedule)
+            return { id, file, description, schedule, problems };
+        if (!trigger || trigger.every !== undefined || trigger.events !== undefined) {
+            return { id, file, description, trigger, problems };
+        }
+        const { subscribe, unsubscribe, ...declared } = trigger;
+        if (typeof subscribe !== "function") {
+            problems.push("workflow-trigger-unregistered: a provider trigger needs `subscribe` to register it with the provider");
+            return { id, file, description, trigger: declared, problems };
+        }
+        const registration = {
+            unsubscribe: typeof unsubscribe === "function",
+            hash: sourceHash(`${String(subscribe)}\n${typeof unsubscribe === "function" ? String(unsubscribe) : ""}`),
+        };
+        return { id, file, description, trigger: declared, registration, problems };
     });
 }
 export async function describeApp(opts) {

package/dist/esm/start/entries.d.ts

@@ -1,8 +1,12 @@
 import type { SourceDir } from "../sourceRoots.js";
 export declare const START_SERVER_ENTRY = ".zite/server.ts";
 export declare const START_INSTANCE_ENTRY = ".zite/start.ts";
-/** The server entry every Start app builds with. Platform-owned: regenerated, never edited. */
-export declare const renderStartServerEntry: () => string;
+export type StartTarget = "cloudflare" | "node";
+/**
+ * The server entry every Start app builds with. Platform-owned: regenerated,
+ * never edited. On Workers it's an entrypoint the host can also call over RPC.
+ */
+export declare const renderStartServerEntry: (target?: StartTarget) => string;
 /** The start instance: the platform's middleware, then the app's own `src/start.ts` when it has one. */
 export declare const renderStartInstance: (hasAppStart: boolean) => string;
 export declare const hasAppStart: (appDir: string) => boolean;

package/dist/esm/start/entries.js

@@ -3,8 +3,19 @@ import { dirname, join, relative } from "node:path";
 export const START_SERVER_ENTRY = ".zite/server.ts";
 export const START_INSTANCE_ENTRY = ".zite/start.ts";
 const APP_START_FILES = ["src/start.ts", "src/start.tsx"];
-/** The server entry every Start app builds with. Platform-owned: regenerated, never edited. */
-export const renderStartServerEntry = () => `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+/**
+ * The server entry every Start app builds with. Platform-owned: regenerated,
+ * never edited. On Workers it's an entrypoint the host can also call over RPC.
+ */
+export const renderStartServerEntry = (target = "cloudflare") => target === "cloudflare"
+    ? `// Generated by zitejs for TanStack Start apps. The platform owns this file.
+import handler from '@tanstack/react-start/server-entry';
+import { createZiteWorker } from 'zitejs/start/worker';
+import { getRouter } from '../src/router';
+
+export default createZiteWorker({ handler, getRouter });
+`
+    : `// Generated by zitejs for TanStack Start apps. The platform owns this file.
 import handler, { createServerEntry } from '@tanstack/react-start/server-entry';
 import { createZiteFetch } from 'zitejs/start/server';
 import { getRouter } from '../src/router';

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

@@ -1,9 +1,9 @@
 import type { User } from "./types.js";
 export type { User, ZiteRequestContext } from "./types.js";
 export { createZiteRouter, type ZiteRouterContext } from "./router.js";
-export { createWorkflow, type Workflow, type WorkflowArgs, type WorkflowConfig } from "./workflow.js";
+export { createWorkflow, type StartProviderTrigger, type StartTrigger, type Workflow, type WorkflowArgs, type WorkflowConfig, } from "./workflow.js";
 export type { ZiteSchedule } from "../schedules/index.js";
-export type { ZiteTrigger } from "../backend/index.js";
+export type { ZiteTrigger, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput, } from "../backend/index.js";
 declare module "@tanstack/start-client-core" {
     interface ServerFnOptions {
         /** What this function does, in a sentence. Shown in the editor. */

package/dist/esm/start/index.js

@@ -4,7 +4,7 @@ import { USAGE_TOKEN_QUERY_PARAM } from "../auth/constants.js";
 import { currentHost } from "./host.js";
 import { getHost, inScope, runInScope } from "./scope.js";
 export { createZiteRouter } from "./router.js";
-export { createWorkflow } from "./workflow.js";
+export { createWorkflow, } from "./workflow.js";
 const STATUS = {
     BAD_REQUEST: 400,
     INVALID_INPUT: 400,

package/dist/esm/start/registration.d.ts

@@ -0,0 +1,13 @@
+import type { LoadedWorkflow } from "./workflowRun.js";
+export type RegistrationResult = {
+    ok: true;
+    output: unknown;
+} | {
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/** Undefined when the workflow has no such function. */
+export declare function runRegistration(workflows: LoadedWorkflow[], name: string, op: unknown, input: unknown): Promise<RegistrationResult | undefined>;

package/dist/esm/start/registration.js

@@ -0,0 +1,21 @@
+// Server-only: a provider trigger's `subscribe` or `unsubscribe`, which the host
+// runs at publish. Not a run: nothing is logged, since what `subscribe` returns
+// carries the provider's signing secret.
+import { errorOf } from "./runLog.js";
+import { runInScope } from "./scope.js";
+/** Undefined when the workflow has no such function. */
+export async function runRegistration(workflows, name, op, input) {
+    const trigger = workflows.find((w) => w.id === name)?.workflow.config.trigger;
+    if (!trigger || !("subscribe" in trigger))
+        return undefined;
+    const fn = op === "subscribe" ? trigger.subscribe : op === "unsubscribe" ? trigger.unsubscribe : undefined;
+    if (typeof fn !== "function")
+        return undefined;
+    try {
+        const output = await runInScope({ kind: "workflow", user: null }, () => fn(input));
+        return { ok: true, output: output ?? null };
+    }
+    catch (error) {
+        return { ok: false, error: errorOf(error) };
+    }
+}

package/dist/esm/start/server.d.ts

@@ -1,7 +1,7 @@
-import type { HostProps, PlatformBinding, ZiteRequestContext } from "./types.js";
+import type { HostProps, PlatformBinding, RenderWatch, ZiteRequestContext } from "./types.js";
 export { runWithHost } from "./scope.js";
 export { describeApp } from "./describe.js";
-export type { HostProps, PlatformBinding, PlatformCallInput, PlatformCallResult, PlatformSession, RunRecord } from "./types.js";
+export type { HostProps, PlatformBinding, PlatformCallInput, PlatformCallResult, PlatformSession, RenderWatch, RunRecord } from "./types.js";
 /**
  * Routes every zitejs data, integration and email call to this request's
  * platform, on one session, and only inside an access scope. The access kind
@@ -22,16 +22,30 @@ export declare const builtFunctionIds: () => string[];
 /** Each server function's `description` option, written in by `zite()` at build. */
 export declare const builtFunctionDescriptions: () => Record<string, string>;
 type Fetch = (request: Request, ...rest: unknown[]) => Promise<Response> | Response;
-/**
- * The fetch handler of a Start app's server entry. A request the host
- * dispatched carries its identity and platform in props; anything else (describe
- * under `vite preview`, tests) reads `x-zite-*` headers and uses `platform`
- * if one is given.
- */
-export declare function createZiteFetch(options: {
+type WorkerContext = {
+    waitUntil(promise: Promise<unknown>): void;
+};
+export type ZiteServerOptions = {
     handler: {
         fetch: Fetch;
     };
     getRouter: () => unknown;
     platform?: PlatformBinding;
-}): Fetch;
+};
+type HostedContext = WorkerContext & {
+    props?: Partial<HostProps>;
+};
+export type ZiteHandlers = {
+    fetch: Fetch;
+    /** A page the host may cache: as `fetch`, with every read and outbound fetch reported to `watch`. */
+    render(request: Request, ctx: HostedContext, watch: RenderWatch): Promise<Response>;
+};
+/**
+ * The handlers of a Start app's server entry. A request the host dispatched
+ * carries its identity and platform in props; anything else (describe under
+ * `vite preview`, tests) reads `x-zite-*` headers and uses `platform` if one
+ * is given.
+ */
+export declare function createZiteHandlers(options: ZiteServerOptions): ZiteHandlers;
+/** The fetch handler alone, for entries that take no RPC. */
+export declare function createZiteFetch(options: ZiteServerOptions): Fetch;

package/dist/esm/start/server.js

@@ -1,5 +1,6 @@
 import { ZiteError, ZITE_ERROR_STATUS } from "./index.js";
 import { describeApp } from "./describe.js";
+import { runRegistration } from "./registration.js";
 import { preview } from "./runLog.js";
 import { getHost, requireScope, runWithHost } from "./scope.js";
 import { loadWorkflows, loggedInput, runWorkflow } from "./workflowRun.js";
@@ -18,7 +19,7 @@ export function installPlatformTransport() {
         // Fails closed: no platform means no platform access, never a fallback.
         if (!host?.platform)
             throw new Error("The Zite platform binding is missing");
-        host.session ??= Promise.resolve(host.platform.session());
+        host.session ??= Promise.resolve(host.watch ? host.platform.session(host.watch) : host.platform.session());
         const result = await (await host.session).call({ integrationId, className, methodName, params, access: scope.kind });
         if ("value" in result)
             return result.value;
@@ -26,9 +27,33 @@ export function installPlatformTransport() {
         throw new ZiteError(code in ZITE_ERROR_STATUS ? code : "INTERNAL_ERROR", message);
     };
     globalThis.__wrapSdkCall = sdkCall;
+    watchOutboundFetches();
 }
+let fetchesWatched = false;
+const fetchedHost = (input) => {
+    try {
+        return new URL(input instanceof Request ? input.url : input).host;
+    }
+    catch {
+        return "?";
+    }
+};
+// A page that fetched depends on more than the reads the host saw, so the host
+// must hear of it before the fetch goes out. Next patches fetch for the same reason.
+const watchOutboundFetches = () => {
+    if (fetchesWatched)
+        return;
+    fetchesWatched = true;
+    const nativeFetch = globalThis.fetch.bind(globalThis);
+    globalThis.fetch = async (input, init) => {
+        const watch = getHost()?.watch;
+        if (watch)
+            await watch.uncacheable(`fetch ${fetchedHost(input)}`);
+        return nativeFetch(input, init);
+    };
+};
 const decodeUser = (value) => JSON.parse(new TextDecoder().decode(Uint8Array.from(atob(value.replace(/-/g, "+").replace(/_/g, "/")), (c) => c.charCodeAt(0))));
-const INVOKE_KINDS = new Set(["webhook", "describe", "workflow", "warm"]);
+const INVOKE_KINDS = new Set(["webhook", "describe", "workflow", "register", "warm"]);
 /** What the host dispatched this request with. Headers are ignored: props are the only thing it alone can set. */
 export function hostContextFromProps(request, props) {
     return {
@@ -105,6 +130,19 @@ async function invokeWorkflow(request, host, workflows) {
     });
     return Response.json(result, { status: result.ok ? 200 : 500 });
 }
+// The host sends `{ op, input }`: `subscribe` with the platform's notification
+// URL and secret, or `unsubscribe` with what `subscribe` returned.
+async function invokeRegistration(request, host, workflows) {
+    if (request.method !== "POST" || new URL(request.url).pathname !== INVOKE_PATH)
+        return new Response("Not found", { status: 404 });
+    const name = host.invoke?.name ?? "";
+    const body = (await request.json().catch(() => null));
+    const result = await runRegistration(workflows, name, body?.op, body?.input);
+    if (!result) {
+        return Response.json({ ok: false, error: { code: "NOT_FOUND", message: `${name} has no ${String(body?.op)}` } }, { status: 404 });
+    }
+    return Response.json(result, { status: result.ok ? 200 : 500 });
+}
 const isZiteError = (error) => error instanceof Error && error.name === "ZiteError" && error.code in ZITE_ERROR_STATUS;
 // TanStack renders any loader error as a 500. A page refused with a ZiteError
 // (a missing role, a record that isn't there) answers with that error's status.
@@ -114,21 +152,22 @@ const pageStatus = (host) => {
     return isZiteError(failed) ? ZITE_ERROR_STATUS[failed.code] : undefined;
 };
 /**
- * The fetch handler of a Start app's server entry. A request the host
- * dispatched carries its identity and platform in props; anything else (describe
- * under `vite preview`, tests) reads `x-zite-*` headers and uses `platform`
- * if one is given.
+ * The handlers of a Start app's server entry. A request the host dispatched
+ * carries its identity and platform in props; anything else (describe under
+ * `vite preview`, tests) reads `x-zite-*` headers and uses `platform` if one
+ * is given.
  */
-export function createZiteFetch(options) {
+export function createZiteHandlers(options) {
     installPlatformTransport();
     // Loaded on first use, so a page request never pays for importing workflow modules.
     let workflows;
     const loadedWorkflows = () => (workflows ??= loadWorkflows());
-    return async (request, ...rest) => {
-        const ctx = rest[1];
+    const serve = async (request, ctx, watch) => {
         const host = ctx?.props?.platform
             ? hostContextFromProps(request, ctx.props)
             : hostContextFromRequest(request, options.platform);
+        if (watch)
+            host.watch = watch;
         // Starting this isolate was the point: the platform warms a build before its
         // first visitors, and no app code runs.
         if (host.invoke?.kind === "warm")
@@ -142,7 +181,11 @@ export function createZiteFetch(options) {
                 workflows: await loadedWorkflows(),
             }));
         }
-        let response = await runWithHost(host, async () => host.invoke?.kind === "workflow" ? invokeWorkflow(request, host, await loadedWorkflows()) : options.handler.fetch(request));
+        let response = await runWithHost(host, async () => host.invoke?.kind === "workflow"
+            ? invokeWorkflow(request, host, await loadedWorkflows())
+            : host.invoke?.kind === "register"
+                ? invokeRegistration(request, host, await loadedWorkflows())
+                : options.handler.fetch(request));
         const status = response.status === 500 ? pageStatus(host) : undefined;
         if (status)
             response = new Response(response.body, { status, headers: response.headers });
@@ -161,4 +204,12 @@ export function createZiteFetch(options) {
             ctx?.waitUntil(flushed);
         });
     };
+    return {
+        fetch: (request, ...rest) => serve(request, rest[1]),
+        render: (request, ctx, watch) => serve(request, ctx, watch),
+    };
+}
+/** The fetch handler alone, for entries that take no RPC. */
+export function createZiteFetch(options) {
+    return createZiteHandlers(options).fetch;
 }

package/dist/esm/start/types.d.ts

@@ -47,10 +47,17 @@ export type PlatformSession = {
         runs: RunRecord[];
     }): Promise<void>;
 };
+/**
+ * The host's ear on a page render it may cache, from `render()`. Reports can
+ * only make the page less cacheable, so an app gains nothing by sending them.
+ */
+export type RenderWatch = {
+    uncacheable(reason: string): Promise<void>;
+};
 /** What the host hands each request: its platform, already scoped to the app, build, request and user. */
 export type PlatformBinding = {
-    /** Every platform call of one request goes through one session. */
-    session(): PlatformSession | Promise<PlatformSession>;
+    /** Every platform call of one request goes through one session. A render's session reports what it read to `watch`. */
+    session(watch?: RenderWatch): PlatformSession | Promise<PlatformSession>;
     /** One batch per request, after its response has ended. */
     runs(batch: {
         runs: RunRecord[];
@@ -58,7 +65,7 @@ export type PlatformBinding = {
 };
 export type HostMode = "live" | "preview" | "validate";
 export type HostInvoke = {
-    kind: "webhook" | "describe" | "workflow" | "warm";
+    kind: "webhook" | "describe" | "workflow" | "register" | "warm";
     name: string;
 };
 /** The per-request props the host dispatches with. Only the host can set them. */
@@ -80,6 +87,8 @@ export type ZiteRequestContext = {
     runs: RunRecord[];
     platform?: PlatformBinding;
     session?: Promise<PlatformSession>;
+    /** Set when the host renders a page it may cache. */
+    watch?: RenderWatch;
     /** This request's router, so a page's status can follow the error it rendered. */
     router?: unknown;
 };

package/dist/esm/start/vite.js

@@ -32,8 +32,9 @@ export function zite(options = {}) {
     // Platform-owned, so they're rewritten whenever they differ. Sandboxes run the
     // image's zitejs for `generate`, which may predate Start; the plugin can't.
     const appDir = process.cwd();
-    if (!options.serverEntry)
-        writeIfChanged(appDir, START_SERVER_ENTRY, renderStartServerEntry());
+    if (!options.serverEntry) {
+        writeIfChanged(appDir, START_SERVER_ENTRY, renderStartServerEntry(options.cloudflare === false ? "node" : "cloudflare"));
+    }
     writeIfChanged(appDir, START_INSTANCE_ENTRY, renderStartInstance(hasAppStart(appDir)));
     // Every server function TanStack's compiler found, from its own hook, by id.
     const ids = new Map();
@@ -125,7 +126,7 @@ export function zite(options = {}) {
                 behavior: "error",
                 client: {
                     // Appended to TanStack's own.
-                    specifiers: ["zitejs/start/server", "zitejs/start/describe", "zitejs/runtime"],
+                    specifiers: ["zitejs/start/server", "zitejs/start/worker", "zitejs/start/describe", "zitejs/runtime"],
                     // Replaces TanStack's list, so its `**/*.server.*` is restated. File
                     // patterns also catch `zitejs/db` and `zitejs/integrations`, which the
                     // aliases above rewrite before specifiers are matched.

package/dist/esm/start/worker.d.ts

@@ -0,0 +1,11 @@
+import { type ZiteServerOptions } from "./server.js";
+import type { RenderWatch } from "./types.js";
+export type ZiteWorker = new (ctx: unknown, env: unknown) => {
+    fetch(request: Request): Promise<Response>;
+    render(request: Request, watch: RenderWatch): Promise<Response>;
+};
+/**
+ * A Start app's Worker. The host sends most requests to `fetch`, and a page it
+ * may cache to `render` over RPC, with a watch for what the page depends on.
+ */
+export declare function createZiteWorker(options: ZiteServerOptions): ZiteWorker;

package/dist/esm/start/worker.js

@@ -0,0 +1,20 @@
+// For the generated server entry of a Workers build only. Apps never import this.
+import { WorkerEntrypoint } from "cloudflare:workers";
+import { createZiteHandlers } from "./server.js";
+/**
+ * A Start app's Worker. The host sends most requests to `fetch`, and a page it
+ * may cache to `render` over RPC, with a watch for what the page depends on.
+ */
+export function createZiteWorker(options) {
+    const handlers = createZiteHandlers(options);
+    return class extends WorkerEntrypoint {
+        async fetch(request) {
+            return handlers.fetch(request, this.env, this.ctx);
+        }
+        // An argument's stubs are disposed when the call returns, and a streamed
+        // page can still read after that.
+        async render(request, watch) {
+            return handlers.render(request, this.ctx, watch.dup?.() ?? watch);
+        }
+    };
+}

package/dist/esm/start/workflow.d.ts

@@ -1,6 +1,20 @@
-import type { ZiteTrigger, ZiteTriggerContext } from "../backend/index.js";
+import type { ZiteTrigger, ZiteTriggerContext, ZiteTriggerSubscribe, ZiteTriggerUnsubscribe } from "../backend/index.js";
 import type { ZiteSchedule } from "../schedules/index.js";
 declare const WORKFLOW: unique symbol;
+type ProviderTriggerBase = Extract<ZiteTrigger, {
+    every?: never;
+    events?: never;
+}>;
+/**
+ * A provider trigger, registered with the provider by its `subscribe` when the
+ * app is published and taken down by its `unsubscribe` when it no longer is.
+ * Both run on the platform with only the trigger's own connection.
+ */
+export type StartProviderTrigger = ProviderTriggerBase & {
+    subscribe: ZiteTriggerSubscribe;
+    unsubscribe?: ZiteTriggerUnsubscribe;
+};
+export type StartTrigger = Exclude<ZiteTrigger, ProviderTriggerBase> | StartProviderTrigger;
 export type WorkflowConfig = {
     /** What this workflow does, in a sentence. Shown in the editor. */
     description?: string;
@@ -8,7 +22,7 @@ export type WorkflowConfig = {
     schedule: ZiteSchedule;
     trigger?: never;
 } | {
-    trigger: ZiteTrigger;
+    trigger: StartTrigger;
     schedule?: never;
 });
 /** What a workflow's handler gets. A trigger adds `trigger`, typed by the kind it declares. */

package/dist/esm/start/workflow.test-d.js

@@ -13,10 +13,25 @@ describe("createWorkflow handler args", () => {
         createWorkflow({ trigger: { integration: "slack", events: ["message.channels"] } }).handler(({ trigger }) => {
             expectTypeOf(trigger).toEqualTypeOf();
         });
-        createWorkflow({ trigger: { integration: "asana" } }).handler(({ trigger }) => {
+        createWorkflow({
+            trigger: { integration: "asana", subscribe: async () => ({ externalId: "w1" }), unsubscribe: async () => { } },
+        }).handler(({ trigger }) => {
             expectTypeOf(trigger).toEqualTypeOf();
         });
     });
+    it("registers a provider trigger with subscribe", () => {
+        // @ts-expect-error nothing would register it with the provider
+        createWorkflow({ trigger: { integration: "asana" } });
+        createWorkflow({
+            trigger: {
+                integration: "github",
+                subscribe: (input) => {
+                    expectTypeOf(input.notificationUrl).toEqualTypeOf();
+                    return { externalId: "1", secret: input.secret };
+                },
+            },
+        });
+    });
     it("takes a schedule or a trigger, not both", () => {
         // @ts-expect-error a workflow runs on one or the other
         createWorkflow({ schedule: { scheduleType: "oneTime", fireAt: "x", timezone: "UTC" }, trigger: { every: "5m" } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.10.0-start.4",
+  "version": "0.10.0-start.6",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "sideEffects": false,
@@ -101,6 +101,11 @@
       "import": "./dist/esm/start/server.js",
       "default": "./dist/esm/start/server.js"
     },
+    "./start/worker": {
+      "types": "./dist/esm/start/worker.d.ts",
+      "import": "./dist/esm/start/worker.js",
+      "default": "./dist/esm/start/worker.js"
+    },
     "./start/instance": {
       "types": "./dist/esm/start/instance.d.ts",
       "import": "./dist/esm/start/instance.js",