zitejs 0.9.133 → 0.9.135

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

@@ -7,8 +7,8 @@ export type ZiteWebhook = {
  * 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.
+ * trigger runs the endpoint on a cadence. Either way `execute` gets `trigger`
+ * ({@link ZiteTriggerContext}) to read the cursor and record what it handled.
  */
 export type ZiteTrigger = {
     /**
@@ -86,49 +86,47 @@ export type ZiteTriggerUnsubscribeInput = {
 };
 export type ZiteTriggerSubscribe = (input: ZiteTriggerSubscribeInput) => Promise<ZiteTriggerSubscribeResult> | ZiteTriggerSubscribeResult;
 export type ZiteTriggerUnsubscribe = (input: ZiteTriggerUnsubscribeInput) => Promise<void> | void;
-/**
- * What a poll-triggered run receives as `input.__poll`. Only on a fire from
- * the poll's schedule; a request call to the same endpoint carries none.
- */
-export type ZitePollInput = {
-    /** What the previous successful run returned as `cursor`; null on the first run. */
-    cursor: string | null;
-    /** Ids earlier runs returned as `handled`, newest last. Skip these. */
-    seen: string[];
-};
-/**
- * What a provider trigger's delivery carries as `input.__webhook`, beside the
- * provider's own body. `cursor` and `seen` work as they do for a poll: for a
- * provider whose notification only says that something changed, `subscribe`
- * returns a starting `cursor` and each delivery returns the next one. A
- * trigger that keeps a cursor gets one delivery at a time.
- */
-export type ZiteTriggerDelivery = {
+/** Where a provider delivery came from; app event triggers get only this. */
+export type ZiteTriggerDeliveryInfo = {
+    /** The delivery's headers, lowercased. */
     headers: Record<string, string>;
     /** The provider's id for this delivery; redeliveries share it. */
     deliveryId?: string;
     provider?: string;
-    /** What `subscribe` or the previous successful delivery returned as `cursor`. */
-    cursor: string | null;
-    /** Ids earlier deliveries returned as `handled`, newest last. Skip these. */
-    seen: string[];
 };
-/** What an app event trigger's run carries as `input.__webhook`: one event, no cursor. */
-export type ZiteAppEventDelivery = Omit<ZiteTriggerDelivery, "cursor" | "seen">;
 /**
- * What a poll-triggered run, or a provider trigger's delivery, returns for
- * the platform to keep: its new `cursor`, and the id of every item it acted
- * on, so the next run's `seen` includes them even if the cursor hands them
- * back.
+ * What a poll run, or a provider trigger's delivery, gets as `trigger`. Record
+ * each item acted on with `handled` as you go: it is kept even if the run
+ * later throws, so the next run skips it. The cursor staged with `advance` is
+ * committed only when the run succeeds.
  */
-export type ZitePollResult = {
-    cursor?: string;
-    handled?: string[];
+export type ZiteTriggerRun = {
+    /** The last committed cursor: what `subscribe` returned, or the last successful run's `advance`. Null when there is none yet. */
+    cursor: string | null;
+    /** Whether an earlier run, or this one, recorded `id` as handled. */
+    seen(id: string): boolean;
+    /** Record an item as acted on (1 to 512 characters). */
+    handled(id: string): void;
+    /** Stage the next cursor (at most 4096 characters). The last call wins. */
+    advance(cursor: string): void;
 };
+export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
+/** The `trigger` param for an endpoint declaring `TTrigger`. */
+export type ZiteTriggerContext<TTrigger> = TTrigger extends {
+    every: string;
+} ? ZiteTriggerRun : TTrigger extends {
+    events: string[];
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
+    integration: string;
+} ? ZiteTriggerDeliveryRun : never;
 export interface ZiteRequestContext {
     user: {
         id: string;
         email: string;
+        roles: Array<{
+            id: string;
+            name: string;
+        }>;
         [key: string]: unknown;
     };
     userId?: string;
@@ -217,22 +215,12 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TTrigger extends {
-            every: string;
-        } ? TInput & {
-            __poll?: ZitePollInput;
-        } : TTrigger extends {
-            events: string[];
-        } ? TInput & {
-            __webhook?: ZiteAppEventDelivery;
-        } : TTrigger extends {
-            integration: string;
-        } ? TInput & {
-            __webhook?: ZiteTriggerDelivery;
-        } : TInput;
+        input: TInput;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
+    } : {}) & (TTrigger extends ZiteTrigger ? {
+        trigger?: ZiteTriggerContext<TTrigger>;
     } : {})) => Promise<TOutput> | TOutput;
 }
 /**

package/dist/cjs/backend/index.js

@@ -74,6 +74,10 @@ function createEndpoint(config) {
             // request callers doesn't describe them.
             if (isPlatformTriggeredInput(params.input))
                 return execute(params);
+            // A trigger's run carries the provider's body, not a request's input.
+            if (params.trigger !== undefined) {
+                return execute(params);
+            }
             // Same, for a fire with no input object to hold the sentinel: the runner
             // only merges `__cron` into a plain object.
             if (firesWithoutARequest && params.input === undefined) {

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

@@ -4,7 +4,7 @@ const vitest_1 = require("vitest");
 const zod_1 = require("zod");
 const index_js_1 = require("./index.js");
 const index_js_2 = require("../runtime/index.js");
-const requestContext = { user: { id: "u1", email: "a@b.c" } };
+const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
 (0, vitest_1.afterEach)(() => {
     vitest_1.vi.unstubAllGlobals();
 });
@@ -133,28 +133,51 @@ const requestContext = { user: { id: "u1", email: "a@b.c" } };
         });
         await (0, vitest_1.expect)(endpoint.execute({ input: undefined, context: requestContext })).rejects.toMatchObject({ code: "BAD_REQUEST" });
     });
-    (0, vitest_1.it)("hands a poll its cursor and seen ids, typed", async () => {
+    (0, vitest_1.it)("hands a poll a typed trigger and skips the input schema for it", async () => {
+        const handled = [];
         const endpoint = (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({}),
+            inputSchema: zod_1.z.object({ required: zod_1.z.string() }),
             trigger: { every: "5m", integration: "stripe" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__poll?.seen);
-                const items = ["a", "b"].filter((id) => !seen.has(id));
-                return { cursor: input.__poll?.cursor ?? "start", handled: items };
+            execute: async ({ trigger }) => {
+                if (!trigger)
+                    return { ran: 0 };
+                const fresh = ["a", "b"].filter((id) => !trigger.seen(id));
+                for (const id of fresh)
+                    trigger.handled(id);
+                trigger.advance("c2");
+                return { ran: fresh.length, from: trigger.cursor };
             },
         });
+        const seen = new Set(["a"]);
         await (0, vitest_1.expect)(endpoint.execute({
-            input: { __poll: { cursor: "c1", seen: ["a"] } },
+            input: {},
             context: { user: null },
-        })).resolves.toEqual({ cursor: "c1", handled: ["b"] });
+            trigger: {
+                cursor: "c1",
+                seen: (id) => seen.has(id),
+                handled: (id) => void handled.push(id),
+                advance: () => { },
+            },
+        })).resolves.toEqual({ ran: 1, from: "c1" });
+        (0, vitest_1.expect)(handled).toEqual(["b"]);
     });
-    (0, vitest_1.it)("gives __poll only to poll triggers", () => {
+    (0, vitest_1.it)("types trigger by the declared kind", () => {
         (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({ action: zod_1.z.string() }),
             trigger: { integration: "github" },
-            execute: async ({ input }) => {
-                // @ts-expect-error a provider trigger's input has no __poll
-                return input.__poll;
+            execute: async ({ trigger }) => trigger?.deliveryId ?? trigger?.cursor,
+        });
+        (0, index_js_1.createEndpoint)({
+            trigger: { integration: "team-slack", events: ["message.channels"] },
+            execute: async ({ trigger }) => {
+                // @ts-expect-error an app event has no cursor API
+                trigger?.advance("x");
+                return trigger?.headers;
+            },
+        });
+        (0, index_js_1.createEndpoint)({
+            execute: async (params) => {
+                // @ts-expect-error a plain endpoint gets no trigger
+                return params.trigger;
             },
         });
     });
@@ -184,40 +207,28 @@ const requestContext = { user: { id: "u1", email: "a@b.c" } };
             endpointId: "onPush",
         });
     });
-    (0, vitest_1.it)("hands a provider trigger's delivery its cursor and seen ids, typed", async () => {
+    (0, vitest_1.it)("hands a provider delivery its body as input and the cursor API on trigger", async () => {
         const endpoint = (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({}),
+            inputSchema: zod_1.z.object({ required: zod_1.z.string() }),
             trigger: { integration: "googleCalendar" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__webhook?.seen);
-                const changed = ["e1", "e2"].filter((id) => !seen.has(id));
-                return { cursor: `${input.__webhook?.cursor}+1`, handled: changed };
-            },
+            execute: async ({ input, trigger }) => ({
+                body: input,
+                cursor: trigger?.cursor,
+                delivery: trigger?.deliveryId,
+            }),
         });
         await (0, vitest_1.expect)(endpoint.execute({
-            input: {
-                __webhook: { headers: {}, cursor: "sync1", seen: ["e1"] },
-            },
+            input: { kind: "sync" },
             context: { user: null },
-        })).resolves.toEqual({ cursor: "sync1+1", handled: ["e2"] });
-    });
-    (0, vitest_1.it)("types an app event trigger's run as one event, with no cursor to keep", async () => {
-        const endpoint = (0, index_js_1.createEndpoint)({
-            inputSchema: zod_1.z.object({ event: zod_1.z.object({ text: zod_1.z.string() }) }),
-            trigger: { integration: "team-slack", events: ["message.channels"] },
-            execute: async ({ input }) => {
-                // @ts-expect-error an app event delivery has no cursor
-                void input.__webhook?.cursor;
-                return { id: input.__webhook?.deliveryId ?? null };
-            },
-        });
-        await (0, vitest_1.expect)(endpoint.execute({
-            input: {
-                event: { text: "hi" },
-                __webhook: { headers: {}, deliveryId: "slack:Ev1" },
+            trigger: {
+                cursor: "sync1",
+                seen: () => false,
+                handled: () => { },
+                advance: () => { },
+                headers: {},
+                deliveryId: "chan:2",
             },
-            context: { user: null },
-        })).resolves.toEqual({ id: "slack:Ev1" });
+        })).resolves.toEqual({ body: { kind: "sync" }, cursor: "sync1", delivery: "chan:2" });
     });
     (0, vitest_1.it)("refuses events on a trigger that also polls", () => {
         (0, index_js_1.createEndpoint)({

package/dist/cjs/sync/lib.js

@@ -1232,13 +1232,13 @@ function generateBackendWrapperTs(envVarNames = []) {
         "// Auto-generated type-narrowing wrapper. Do not edit manually.",
         "// Re-exports createEndpoint with context.user typed to the app User.",
         "",
-        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteTrigger, ZiteTriggerDelivery, ZiteAppEventDelivery, ZitePollInput, ZiteWebhook } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteTrigger, ZiteWebhook };",
         // A trigger's registration exports are typed against these, and they
         // only reach app code through this file.
-        "export type { ZiteAppEventDelivery, ZitePollInput, ZitePollResult, ZiteTriggerDelivery, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
+        "export type { ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
         // The pre-monorepo SDK put this in scope for every endpoint, so migrated
         // code can name it. `createEndpoint` infers the same thing without it.
         "export type InferSchemaType<T> = T extends { _output: infer U } ? U : T;",
@@ -1302,7 +1302,8 @@ function generateBackendWrapperTs(envVarNames = []) {
         "  User,",
         "  'name' | 'emailVerified' | 'image' | 'createdAt' | 'updatedAt'",
         "> &",
-        "  Pick<User, 'id' | 'email'>;",
+        "  Pick<User, 'id' | 'email'> &",
+        "  Pick<_ZiteRequestContext['user'], 'roles'>;",
         "",
         'export interface ZiteRequestContext extends Omit<_ZiteRequestContext, "user"> {',
         "  user: ZiteEndpointUser;",
@@ -1329,11 +1330,10 @@ function generateBackendWrapperTs(envVarNames = []) {
         "  trigger?: TTrigger;",
         "  execute: (",
         "    params: {",
-        // Mirrors the base module: a poll's run carries `__poll`, a provider
-        // trigger's delivery `__webhook`.
-        "      input: TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput } : TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery } : TTrigger extends { integration: string } ? TInput & { __webhook?: ZiteTriggerDelivery } : TInput;",
+        "      input: TInput;",
         "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
-        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}),",
+        // Mirrors the base module: a trigger's run gets `trigger`.
+        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}) & (TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {}),",
         "  ) => Promise<TOutput> | TOutput;",
         "}",
         "",
@@ -1343,6 +1343,14 @@ function generateBackendWrapperTs(envVarNames = []) {
         "  return config;",
         "}",
         "",
+        "/**",
+        " * Checks if a user has a specific role. Returns true if the user has the role, false",
+        " * otherwise. If the user is not logged in, returns false.",
+        " */",
+        "export const hasRole = (context: ZiteRequestContext, roleId: string) => {",
+        "  return context.user?.roles?.some((r) => r.id === roleId);",
+        "};",
+        "",
         // Declared in the wrapper (not a standalone .d.ts) so the merge is
         // guaranteed to be in the program — every endpoint imports this file,
         // while tsconfig `include` does not reliably pick up dot-directories.

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

@@ -390,9 +390,9 @@ const duplicateIdentifierErrorsIn = (source) => {
     (0, vitest_1.it)('passes the trigger registration types and trigger inputs through to app code', () => {
         (0, vitest_1.expect)(output).toContain('ZiteTriggerSubscribe, ZiteTriggerSubscribeInput');
         (0, vitest_1.expect)(output).toContain('ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput');
-        (0, vitest_1.expect)(output).toContain("TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput }");
-        (0, vitest_1.expect)(output).toContain('TInput & { __webhook?: ZiteTriggerDelivery }');
-        (0, vitest_1.expect)(output).toContain("TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery }");
+        (0, vitest_1.expect)(output).toContain('ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun');
+        (0, vitest_1.expect)(output).toContain('(TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {})');
+        (0, vitest_1.expect)(output).not.toContain('__poll');
         (0, vitest_1.expect)(output).not.toContain('src/triggers/');
     });
     (0, vitest_1.it)('exports ZiteError', () => {

package/dist/cjs/vite/index.js

@@ -11,6 +11,41 @@ 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"]);
+// react-three-fiber reads a dashed prop as a path into the three.js object, so
+// any data-zite-* prop that reaches one throws. Components from the three
+// ecosystem (drei, react-spring's `animated`) spread their props onto three
+// objects, and anything rendered in a scene may be a three object too. So a
+// component is only tagged where it is known to render DOM: under a DOM
+// element or drei's <Html>. In files that import the three ecosystem, a JSX
+// tree's root is not assumed to be DOM, since scene components live there.
+const threeIntrinsicDomNames = new Set(["audio", "line", "path", "source"]);
+function isThreeModule(source) {
+    return (source.startsWith("@react-three/") || source === "@react-spring/three");
+}
+/** Local binding name -> imported name ("*" for a namespace import). */
+function getThreeImports(ast) {
+    const imports = new Map();
+    for (const statement of ast.program.body) {
+        if (statement.type === "ImportDeclaration" &&
+            isThreeModule(statement.source.value)) {
+            for (const specifier of statement.specifiers) {
+                imports.set(specifier.local.name, specifier.type === "ImportSpecifier"
+                    ? specifier.imported.name ?? specifier.imported.value
+                    : "*");
+            }
+        }
+    }
+    return imports;
+}
+/** The three-ecosystem name an element refers to, if it comes from one. */
+function getThreeName(componentName, threeImports) {
+    const segments = componentName.split(".");
+    const imported = threeImports.get(segments[0]);
+    if (imported === undefined) {
+        return null;
+    }
+    return imported === "*" ? segments[segments.length - 1] : imported;
+}
 function getComponentName(elementName) {
     if (elementName.type === "JSXIdentifier") {
         return elementName.name;
@@ -51,18 +86,52 @@ function ziteId() {
                     plugins: ["jsx", "typescript"],
                 });
                 const magicString = new magic_string_1.default(code);
+                const threeImports = getThreeImports(ast);
+                const rootContext = threeImports.size > 0 ? "unknown" : "dom";
+                // The render context each open JSXElement gives its children.
+                const contextStack = [];
                 (0, estree_walker_1.walk)(ast, {
+                    leave(_node) {
+                        if (_node.type === "JSXElement") {
+                            contextStack.pop();
+                        }
+                    },
                     enter(_node) {
                         const node = _node;
                         if (node.type === "JSXElement") {
                             const openingElement = node.openingElement;
                             const children = node.children;
+                            const context = contextStack[contextStack.length - 1] ?? rootContext;
                             const componentName = getComponentName(openingElement.name);
-                            if (!componentName) {
+                            const kind = componentName ? classifyElement(componentName) : null;
+                            const threeName = componentName
+                                ? getThreeName(componentName, threeImports)
+                                : null;
+                            let childContext = context;
+                            if (threeName === "Html") {
+                                childContext = "dom";
+                            }
+                            else if (threeName !== null) {
+                                childContext = "scene";
+                            }
+                            else if (kind === "dom") {
+                                childContext = "dom";
+                            }
+                            else if (componentName &&
+                                kind === null &&
+                                !fragmentNames.has(componentName)) {
+                                childContext = "scene";
+                            }
+                            contextStack.push(childContext);
+                            if (!componentName || !kind) {
                                 return;
                             }
-                            const kind = classifyElement(componentName);
-                            if (!kind) {
+                            const isTagged = kind === "component"
+                                ? threeName === "Canvas" ||
+                                    (threeName === null && context === "dom")
+                                : !threeIntrinsicDomNames.has(componentName) ||
+                                    context === "dom";
+                            if (!isTagged) {
                                 return;
                             }
                             const line = openingElement.loc?.start?.line ?? 0;

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

@@ -42,9 +42,65 @@ async function transform(code) {
         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 () => {
+    (0, vitest_1.it)('tags DOM but not components 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.expect)(code).toBe('const a = <group><Html><div data-zite-id="src/App.tsx|1|23" /></Html></group>;');
+    });
+    (0, vitest_1.describe)('react-three scenes', () => {
+        const scene = (jsx) => transform("import { Canvas } from '@react-three/fiber';\n" +
+            "import { Html, Text } from '@react-three/drei';\n" +
+            "import { Button } from './Button';\n" +
+            `const a = ${jsx};`);
+        (0, vitest_1.it)('skips three components, nested components and three.js intrinsics', async () => {
+            const code = await scene('<Canvas><Text>Hi</Text><Button /><line /></Canvas>');
+            (0, vitest_1.expect)(code).toContain('<Text>Hi</Text>');
+            (0, vitest_1.expect)(code).toContain('<Button />');
+            (0, vitest_1.expect)(code).toContain('<line />');
+        });
+        (0, vitest_1.it)('tags the Canvas container and UI next to it', async () => {
+            const code = await scene('<div><Canvas /><Button>Start</Button></div>');
+            (0, vitest_1.expect)(code).toMatch(/<Canvas data-zite-id="[^"]+" data-zite-component="Canvas" \/>/);
+            (0, vitest_1.expect)(code).toMatch(/<Button data-zite-id="[^"]+" data-zite-component="Button" data-zite-editable="true">/);
+        });
+        (0, vitest_1.it)('tags DOM and components inside an <Html> overlay again', async () => {
+            const code = await scene('<Canvas><Html><Button /><div /></Html></Canvas>');
+            (0, vitest_1.expect)(code).toContain('<Html>');
+            (0, vitest_1.expect)(code).toMatch(/<Button data-zite-id="[^"]+" data-zite-component="Button" \/>/);
+            (0, vitest_1.expect)(code).toMatch(/<div data-zite-id="[^"]+" \/>/);
+        });
+        (0, vitest_1.it)('skips the root of a scene component in the same file', async () => {
+            const code = await scene('<><Button position={[0, 0, 0]} /></>');
+            (0, vitest_1.expect)(code).toContain('<Button position={[0, 0, 0]} />');
+        });
+        (0, vitest_1.it)('skips children of three wrapper components', async () => {
+            const code = await transform("import { Float } from '@react-three/drei';\nimport { Box } from './Box';\nconst a = <Float><Box /></Float>;");
+            (0, vitest_1.expect)(code).toContain('<Float><Box /></Float>');
+        });
+        (0, vitest_1.it)('recognises aliased and namespaced three imports', async () => {
+            const code = await transform("import { Canvas as C } from '@react-three/fiber';\nimport * as Drei from '@react-three/drei';\n" +
+                "import { Box, Card } from './ui';\nconst a = <C><Box /><Drei.Html><Card /></Drei.Html></C>;");
+            (0, vitest_1.expect)(code).toMatch(/<C data-zite-id="[^"]+" data-zite-component="C">/);
+            (0, vitest_1.expect)(code).toContain('<Box />');
+            (0, vitest_1.expect)(code).toContain('<Drei.Html>');
+            (0, vitest_1.expect)(code).toMatch(/<Card data-zite-id="[^"]+" data-zite-component="Card" \/>/);
+        });
+        (0, vitest_1.it)('tags SVG lines and paths in DOM next to a scene', async () => {
+            const code = await scene('<div><svg><line /><path /></svg></div>');
+            (0, vitest_1.expect)(code).toMatch(/<line data-zite-id="[^"]+" \/>/);
+            (0, vitest_1.expect)(code).toMatch(/<path data-zite-id="[^"]+" \/>/);
+        });
+        (0, vitest_1.it)("skips react-spring's animated three elements", async () => {
+            const code = await transform("import { animated } from '@react-spring/three';\nconst a = <animated.mesh />;");
+            (0, vitest_1.expect)(code).toContain('<animated.mesh />');
+        });
+        (0, vitest_1.it)('skips components nested in a scene element in a file without three imports', async () => {
+            const code = await transform("import { Tree } from './Tree';\nconst a = <group><Tree /></group>;");
+            (0, vitest_1.expect)(code).toContain('<Tree />');
+        });
+    });
+    (0, vitest_1.it)('keeps tagging components in files that do not import react-three', async () => {
+        const code = await transform("import { Card } from './Card';\nconst a = <Card />;");
+        (0, vitest_1.expect)(code).toContain('<Card data-zite-id="src/App.tsx|2|10" data-zite-component="Card" />');
     });
     (0, vitest_1.it)('leaves fragments untouched', async () => {
         const source = 'const a = <Fragment><React.Fragment key="a" /></Fragment>;';

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

@@ -7,8 +7,8 @@ export type ZiteWebhook = {
  * 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.
+ * trigger runs the endpoint on a cadence. Either way `execute` gets `trigger`
+ * ({@link ZiteTriggerContext}) to read the cursor and record what it handled.
  */
 export type ZiteTrigger = {
     /**
@@ -86,49 +86,47 @@ export type ZiteTriggerUnsubscribeInput = {
 };
 export type ZiteTriggerSubscribe = (input: ZiteTriggerSubscribeInput) => Promise<ZiteTriggerSubscribeResult> | ZiteTriggerSubscribeResult;
 export type ZiteTriggerUnsubscribe = (input: ZiteTriggerUnsubscribeInput) => Promise<void> | void;
-/**
- * What a poll-triggered run receives as `input.__poll`. Only on a fire from
- * the poll's schedule; a request call to the same endpoint carries none.
- */
-export type ZitePollInput = {
-    /** What the previous successful run returned as `cursor`; null on the first run. */
-    cursor: string | null;
-    /** Ids earlier runs returned as `handled`, newest last. Skip these. */
-    seen: string[];
-};
-/**
- * What a provider trigger's delivery carries as `input.__webhook`, beside the
- * provider's own body. `cursor` and `seen` work as they do for a poll: for a
- * provider whose notification only says that something changed, `subscribe`
- * returns a starting `cursor` and each delivery returns the next one. A
- * trigger that keeps a cursor gets one delivery at a time.
- */
-export type ZiteTriggerDelivery = {
+/** Where a provider delivery came from; app event triggers get only this. */
+export type ZiteTriggerDeliveryInfo = {
+    /** The delivery's headers, lowercased. */
     headers: Record<string, string>;
     /** The provider's id for this delivery; redeliveries share it. */
     deliveryId?: string;
     provider?: string;
-    /** What `subscribe` or the previous successful delivery returned as `cursor`. */
-    cursor: string | null;
-    /** Ids earlier deliveries returned as `handled`, newest last. Skip these. */
-    seen: string[];
 };
-/** What an app event trigger's run carries as `input.__webhook`: one event, no cursor. */
-export type ZiteAppEventDelivery = Omit<ZiteTriggerDelivery, "cursor" | "seen">;
 /**
- * What a poll-triggered run, or a provider trigger's delivery, returns for
- * the platform to keep: its new `cursor`, and the id of every item it acted
- * on, so the next run's `seen` includes them even if the cursor hands them
- * back.
+ * What a poll run, or a provider trigger's delivery, gets as `trigger`. Record
+ * each item acted on with `handled` as you go: it is kept even if the run
+ * later throws, so the next run skips it. The cursor staged with `advance` is
+ * committed only when the run succeeds.
  */
-export type ZitePollResult = {
-    cursor?: string;
-    handled?: string[];
+export type ZiteTriggerRun = {
+    /** The last committed cursor: what `subscribe` returned, or the last successful run's `advance`. Null when there is none yet. */
+    cursor: string | null;
+    /** Whether an earlier run, or this one, recorded `id` as handled. */
+    seen(id: string): boolean;
+    /** Record an item as acted on (1 to 512 characters). */
+    handled(id: string): void;
+    /** Stage the next cursor (at most 4096 characters). The last call wins. */
+    advance(cursor: string): void;
 };
+export type ZiteTriggerDeliveryRun = ZiteTriggerRun & ZiteTriggerDeliveryInfo;
+/** The `trigger` param for an endpoint declaring `TTrigger`. */
+export type ZiteTriggerContext<TTrigger> = TTrigger extends {
+    every: string;
+} ? ZiteTriggerRun : TTrigger extends {
+    events: string[];
+} ? ZiteTriggerDeliveryInfo : TTrigger extends {
+    integration: string;
+} ? ZiteTriggerDeliveryRun : never;
 export interface ZiteRequestContext {
     user: {
         id: string;
         email: string;
+        roles: Array<{
+            id: string;
+            name: string;
+        }>;
         [key: string]: unknown;
     };
     userId?: string;
@@ -217,22 +215,12 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream ext
      */
     validatesInput?: boolean;
     execute: (params: {
-        input: TTrigger extends {
-            every: string;
-        } ? TInput & {
-            __poll?: ZitePollInput;
-        } : TTrigger extends {
-            events: string[];
-        } ? TInput & {
-            __webhook?: ZiteAppEventDelivery;
-        } : TTrigger extends {
-            integration: string;
-        } ? TInput & {
-            __webhook?: ZiteTriggerDelivery;
-        } : TInput;
+        input: TInput;
         context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;
     } & (TStream extends true ? {
         stream: ZiteStreamInterface;
+    } : {}) & (TTrigger extends ZiteTrigger ? {
+        trigger?: ZiteTriggerContext<TTrigger>;
     } : {})) => Promise<TOutput> | TOutput;
 }
 /**

package/dist/esm/backend/index.js

@@ -69,6 +69,10 @@ export function createEndpoint(config) {
             // request callers doesn't describe them.
             if (isPlatformTriggeredInput(params.input))
                 return execute(params);
+            // A trigger's run carries the provider's body, not a request's input.
+            if (params.trigger !== undefined) {
+                return execute(params);
+            }
             // Same, for a fire with no input object to hold the sentinel: the runner
             // only merges `__cron` into a plain object.
             if (firesWithoutARequest && params.input === undefined) {

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

@@ -2,7 +2,7 @@ import { describe, it, expect, afterEach, vi } from "vitest";
 import { z } from "zod";
 import { createEndpoint, ZiteError, } from "./index.js";
 import { createTableClient } from "../runtime/index.js";
-const requestContext = { user: { id: "u1", email: "a@b.c" } };
+const requestContext = { user: { id: "u1", email: "a@b.c", roles: [] } };
 afterEach(() => {
     vi.unstubAllGlobals();
 });
@@ -131,28 +131,51 @@ describe("platform-triggered runs", () => {
         });
         await expect(endpoint.execute({ input: undefined, context: requestContext })).rejects.toMatchObject({ code: "BAD_REQUEST" });
     });
-    it("hands a poll its cursor and seen ids, typed", async () => {
+    it("hands a poll a typed trigger and skips the input schema for it", async () => {
+        const handled = [];
         const endpoint = createEndpoint({
-            inputSchema: z.object({}),
+            inputSchema: z.object({ required: z.string() }),
             trigger: { every: "5m", integration: "stripe" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__poll?.seen);
-                const items = ["a", "b"].filter((id) => !seen.has(id));
-                return { cursor: input.__poll?.cursor ?? "start", handled: items };
+            execute: async ({ trigger }) => {
+                if (!trigger)
+                    return { ran: 0 };
+                const fresh = ["a", "b"].filter((id) => !trigger.seen(id));
+                for (const id of fresh)
+                    trigger.handled(id);
+                trigger.advance("c2");
+                return { ran: fresh.length, from: trigger.cursor };
             },
         });
+        const seen = new Set(["a"]);
         await expect(endpoint.execute({
-            input: { __poll: { cursor: "c1", seen: ["a"] } },
+            input: {},
             context: { user: null },
-        })).resolves.toEqual({ cursor: "c1", handled: ["b"] });
+            trigger: {
+                cursor: "c1",
+                seen: (id) => seen.has(id),
+                handled: (id) => void handled.push(id),
+                advance: () => { },
+            },
+        })).resolves.toEqual({ ran: 1, from: "c1" });
+        expect(handled).toEqual(["b"]);
     });
-    it("gives __poll only to poll triggers", () => {
+    it("types trigger by the declared kind", () => {
         createEndpoint({
-            inputSchema: z.object({ action: z.string() }),
             trigger: { integration: "github" },
-            execute: async ({ input }) => {
-                // @ts-expect-error a provider trigger's input has no __poll
-                return input.__poll;
+            execute: async ({ trigger }) => trigger?.deliveryId ?? trigger?.cursor,
+        });
+        createEndpoint({
+            trigger: { integration: "team-slack", events: ["message.channels"] },
+            execute: async ({ trigger }) => {
+                // @ts-expect-error an app event has no cursor API
+                trigger?.advance("x");
+                return trigger?.headers;
+            },
+        });
+        createEndpoint({
+            execute: async (params) => {
+                // @ts-expect-error a plain endpoint gets no trigger
+                return params.trigger;
             },
         });
     });
@@ -182,40 +205,28 @@ describe("platform-triggered runs", () => {
             endpointId: "onPush",
         });
     });
-    it("hands a provider trigger's delivery its cursor and seen ids, typed", async () => {
+    it("hands a provider delivery its body as input and the cursor API on trigger", async () => {
         const endpoint = createEndpoint({
-            inputSchema: z.object({}),
+            inputSchema: z.object({ required: z.string() }),
             trigger: { integration: "googleCalendar" },
-            execute: async ({ input }) => {
-                const seen = new Set(input.__webhook?.seen);
-                const changed = ["e1", "e2"].filter((id) => !seen.has(id));
-                return { cursor: `${input.__webhook?.cursor}+1`, handled: changed };
-            },
+            execute: async ({ input, trigger }) => ({
+                body: input,
+                cursor: trigger?.cursor,
+                delivery: trigger?.deliveryId,
+            }),
         });
         await expect(endpoint.execute({
-            input: {
-                __webhook: { headers: {}, cursor: "sync1", seen: ["e1"] },
-            },
+            input: { kind: "sync" },
             context: { user: null },
-        })).resolves.toEqual({ cursor: "sync1+1", handled: ["e2"] });
-    });
-    it("types an app event trigger's run as one event, with no cursor to keep", async () => {
-        const endpoint = createEndpoint({
-            inputSchema: z.object({ event: z.object({ text: z.string() }) }),
-            trigger: { integration: "team-slack", events: ["message.channels"] },
-            execute: async ({ input }) => {
-                // @ts-expect-error an app event delivery has no cursor
-                void input.__webhook?.cursor;
-                return { id: input.__webhook?.deliveryId ?? null };
-            },
-        });
-        await expect(endpoint.execute({
-            input: {
-                event: { text: "hi" },
-                __webhook: { headers: {}, deliveryId: "slack:Ev1" },
+            trigger: {
+                cursor: "sync1",
+                seen: () => false,
+                handled: () => { },
+                advance: () => { },
+                headers: {},
+                deliveryId: "chan:2",
             },
-            context: { user: null },
-        })).resolves.toEqual({ id: "slack:Ev1" });
+        })).resolves.toEqual({ body: { kind: "sync" }, cursor: "sync1", delivery: "chan:2" });
     });
     it("refuses events on a trigger that also polls", () => {
         createEndpoint({

package/dist/esm/sync/lib.js

@@ -1217,13 +1217,13 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "// Auto-generated type-narrowing wrapper. Do not edit manually.",
         "// Re-exports createEndpoint with context.user typed to the app User.",
         "",
-        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteTrigger, ZiteTriggerDelivery, ZiteAppEventDelivery, ZitePollInput, ZiteWebhook } from 'zitejs/backend/base';",
+        "import type { ZiteRequestContext as _ZiteRequestContext, ZiteScheduledContext, ZiteErrorCode, ZiteSchedule, ZiteStreamInterface, ZiteTrigger, ZiteTriggerContext, ZiteWebhook } from 'zitejs/backend/base';",
         "import type { User } from 'zitejs/auth';",
         "",
         "export type { ZiteErrorCode, ZiteSchedule, ZiteScheduledContext, ZiteStreamInterface, ZiteTrigger, ZiteWebhook };",
         // A trigger's registration exports are typed against these, and they
         // only reach app code through this file.
-        "export type { ZiteAppEventDelivery, ZitePollInput, ZitePollResult, ZiteTriggerDelivery, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
+        "export type { ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun, ZiteTriggerSubscribe, ZiteTriggerSubscribeInput, ZiteTriggerSubscribeResult, ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput } from 'zitejs/backend/base';",
         // The pre-monorepo SDK put this in scope for every endpoint, so migrated
         // code can name it. `createEndpoint` infers the same thing without it.
         "export type InferSchemaType<T> = T extends { _output: infer U } ? U : T;",
@@ -1287,7 +1287,8 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "  User,",
         "  'name' | 'emailVerified' | 'image' | 'createdAt' | 'updatedAt'",
         "> &",
-        "  Pick<User, 'id' | 'email'>;",
+        "  Pick<User, 'id' | 'email'> &",
+        "  Pick<_ZiteRequestContext['user'], 'roles'>;",
         "",
         'export interface ZiteRequestContext extends Omit<_ZiteRequestContext, "user"> {',
         "  user: ZiteEndpointUser;",
@@ -1314,11 +1315,10 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "  trigger?: TTrigger;",
         "  execute: (",
         "    params: {",
-        // Mirrors the base module: a poll's run carries `__poll`, a provider
-        // trigger's delivery `__webhook`.
-        "      input: TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput } : TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery } : TTrigger extends { integration: string } ? TInput & { __webhook?: ZiteTriggerDelivery } : TInput;",
+        "      input: TInput;",
         "      context: TSchedule extends ZiteSchedule ? ZiteRequestContext | ZiteScheduledContext : TWebhook extends ZiteWebhook ? ZiteRequestContext | ZiteScheduledContext : TTrigger extends ZiteTrigger ? ZiteRequestContext | ZiteScheduledContext : ZiteRequestContext;",
-        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}),",
+        // Mirrors the base module: a trigger's run gets `trigger`.
+        "    } & (TStream extends true ? { stream: ZiteStreamInterface } : {}) & (TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {}),",
         "  ) => Promise<TOutput> | TOutput;",
         "}",
         "",
@@ -1328,6 +1328,14 @@ export function generateBackendWrapperTs(envVarNames = []) {
         "  return config;",
         "}",
         "",
+        "/**",
+        " * Checks if a user has a specific role. Returns true if the user has the role, false",
+        " * otherwise. If the user is not logged in, returns false.",
+        " */",
+        "export const hasRole = (context: ZiteRequestContext, roleId: string) => {",
+        "  return context.user?.roles?.some((r) => r.id === roleId);",
+        "};",
+        "",
         // Declared in the wrapper (not a standalone .d.ts) so the merge is
         // guaranteed to be in the program — every endpoint imports this file,
         // while tsconfig `include` does not reliably pick up dot-directories.

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

@@ -385,9 +385,9 @@ describe('generateBackendWrapperTs', () => {
     it('passes the trigger registration types and trigger inputs through to app code', () => {
         expect(output).toContain('ZiteTriggerSubscribe, ZiteTriggerSubscribeInput');
         expect(output).toContain('ZiteTriggerUnsubscribe, ZiteTriggerUnsubscribeInput');
-        expect(output).toContain("TTrigger extends { every: string } ? TInput & { __poll?: ZitePollInput }");
-        expect(output).toContain('TInput & { __webhook?: ZiteTriggerDelivery }');
-        expect(output).toContain("TTrigger extends { events: string[] } ? TInput & { __webhook?: ZiteAppEventDelivery }");
+        expect(output).toContain('ZiteTriggerContext, ZiteTriggerDeliveryInfo, ZiteTriggerDeliveryRun, ZiteTriggerRun');
+        expect(output).toContain('(TTrigger extends ZiteTrigger ? { trigger?: ZiteTriggerContext<TTrigger> } : {})');
+        expect(output).not.toContain('__poll');
         expect(output).not.toContain('src/triggers/');
     });
     it('exports ZiteError', () => {

package/dist/esm/vite/index.js

@@ -5,6 +5,41 @@ import { walk } from "estree-walker";
 import { domTagNames } from "./domTagNames.js";
 const validExtensions = new Set([".jsx", ".tsx"]);
 const fragmentNames = new Set(["Fragment", "React.Fragment"]);
+// react-three-fiber reads a dashed prop as a path into the three.js object, so
+// any data-zite-* prop that reaches one throws. Components from the three
+// ecosystem (drei, react-spring's `animated`) spread their props onto three
+// objects, and anything rendered in a scene may be a three object too. So a
+// component is only tagged where it is known to render DOM: under a DOM
+// element or drei's <Html>. In files that import the three ecosystem, a JSX
+// tree's root is not assumed to be DOM, since scene components live there.
+const threeIntrinsicDomNames = new Set(["audio", "line", "path", "source"]);
+function isThreeModule(source) {
+    return (source.startsWith("@react-three/") || source === "@react-spring/three");
+}
+/** Local binding name -> imported name ("*" for a namespace import). */
+function getThreeImports(ast) {
+    const imports = new Map();
+    for (const statement of ast.program.body) {
+        if (statement.type === "ImportDeclaration" &&
+            isThreeModule(statement.source.value)) {
+            for (const specifier of statement.specifiers) {
+                imports.set(specifier.local.name, specifier.type === "ImportSpecifier"
+                    ? specifier.imported.name ?? specifier.imported.value
+                    : "*");
+            }
+        }
+    }
+    return imports;
+}
+/** The three-ecosystem name an element refers to, if it comes from one. */
+function getThreeName(componentName, threeImports) {
+    const segments = componentName.split(".");
+    const imported = threeImports.get(segments[0]);
+    if (imported === undefined) {
+        return null;
+    }
+    return imported === "*" ? segments[segments.length - 1] : imported;
+}
 function getComponentName(elementName) {
     if (elementName.type === "JSXIdentifier") {
         return elementName.name;
@@ -45,18 +80,52 @@ export function ziteId() {
                     plugins: ["jsx", "typescript"],
                 });
                 const magicString = new MagicString(code);
+                const threeImports = getThreeImports(ast);
+                const rootContext = threeImports.size > 0 ? "unknown" : "dom";
+                // The render context each open JSXElement gives its children.
+                const contextStack = [];
                 walk(ast, {
+                    leave(_node) {
+                        if (_node.type === "JSXElement") {
+                            contextStack.pop();
+                        }
+                    },
                     enter(_node) {
                         const node = _node;
                         if (node.type === "JSXElement") {
                             const openingElement = node.openingElement;
                             const children = node.children;
+                            const context = contextStack[contextStack.length - 1] ?? rootContext;
                             const componentName = getComponentName(openingElement.name);
-                            if (!componentName) {
+                            const kind = componentName ? classifyElement(componentName) : null;
+                            const threeName = componentName
+                                ? getThreeName(componentName, threeImports)
+                                : null;
+                            let childContext = context;
+                            if (threeName === "Html") {
+                                childContext = "dom";
+                            }
+                            else if (threeName !== null) {
+                                childContext = "scene";
+                            }
+                            else if (kind === "dom") {
+                                childContext = "dom";
+                            }
+                            else if (componentName &&
+                                kind === null &&
+                                !fragmentNames.has(componentName)) {
+                                childContext = "scene";
+                            }
+                            contextStack.push(childContext);
+                            if (!componentName || !kind) {
                                 return;
                             }
-                            const kind = classifyElement(componentName);
-                            if (!kind) {
+                            const isTagged = kind === "component"
+                                ? threeName === "Canvas" ||
+                                    (threeName === null && context === "dom")
+                                : !threeIntrinsicDomNames.has(componentName) ||
+                                    context === "dom";
+                            if (!isTagged) {
                                 return;
                             }
                             const line = openingElement.loc?.start?.line ?? 0;

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

@@ -37,9 +37,65 @@ describe('ziteId', () => {
         const source = 'const a = <group><mesh position-x={1} /><ambientLight intensity={0.5} /></group>;';
         expect(await transform(source)).toBe(source);
     });
-    it('tags DOM elements nested inside non-DOM intrinsics', async () => {
+    it('tags DOM but not components nested inside non-DOM intrinsics', async () => {
         const code = await transform('const a = <group><Html><div /></Html></group>;');
-        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>;');
+        expect(code).toBe('const a = <group><Html><div data-zite-id="src/App.tsx|1|23" /></Html></group>;');
+    });
+    describe('react-three scenes', () => {
+        const scene = (jsx) => transform("import { Canvas } from '@react-three/fiber';\n" +
+            "import { Html, Text } from '@react-three/drei';\n" +
+            "import { Button } from './Button';\n" +
+            `const a = ${jsx};`);
+        it('skips three components, nested components and three.js intrinsics', async () => {
+            const code = await scene('<Canvas><Text>Hi</Text><Button /><line /></Canvas>');
+            expect(code).toContain('<Text>Hi</Text>');
+            expect(code).toContain('<Button />');
+            expect(code).toContain('<line />');
+        });
+        it('tags the Canvas container and UI next to it', async () => {
+            const code = await scene('<div><Canvas /><Button>Start</Button></div>');
+            expect(code).toMatch(/<Canvas data-zite-id="[^"]+" data-zite-component="Canvas" \/>/);
+            expect(code).toMatch(/<Button data-zite-id="[^"]+" data-zite-component="Button" data-zite-editable="true">/);
+        });
+        it('tags DOM and components inside an <Html> overlay again', async () => {
+            const code = await scene('<Canvas><Html><Button /><div /></Html></Canvas>');
+            expect(code).toContain('<Html>');
+            expect(code).toMatch(/<Button data-zite-id="[^"]+" data-zite-component="Button" \/>/);
+            expect(code).toMatch(/<div data-zite-id="[^"]+" \/>/);
+        });
+        it('skips the root of a scene component in the same file', async () => {
+            const code = await scene('<><Button position={[0, 0, 0]} /></>');
+            expect(code).toContain('<Button position={[0, 0, 0]} />');
+        });
+        it('skips children of three wrapper components', async () => {
+            const code = await transform("import { Float } from '@react-three/drei';\nimport { Box } from './Box';\nconst a = <Float><Box /></Float>;");
+            expect(code).toContain('<Float><Box /></Float>');
+        });
+        it('recognises aliased and namespaced three imports', async () => {
+            const code = await transform("import { Canvas as C } from '@react-three/fiber';\nimport * as Drei from '@react-three/drei';\n" +
+                "import { Box, Card } from './ui';\nconst a = <C><Box /><Drei.Html><Card /></Drei.Html></C>;");
+            expect(code).toMatch(/<C data-zite-id="[^"]+" data-zite-component="C">/);
+            expect(code).toContain('<Box />');
+            expect(code).toContain('<Drei.Html>');
+            expect(code).toMatch(/<Card data-zite-id="[^"]+" data-zite-component="Card" \/>/);
+        });
+        it('tags SVG lines and paths in DOM next to a scene', async () => {
+            const code = await scene('<div><svg><line /><path /></svg></div>');
+            expect(code).toMatch(/<line data-zite-id="[^"]+" \/>/);
+            expect(code).toMatch(/<path data-zite-id="[^"]+" \/>/);
+        });
+        it("skips react-spring's animated three elements", async () => {
+            const code = await transform("import { animated } from '@react-spring/three';\nconst a = <animated.mesh />;");
+            expect(code).toContain('<animated.mesh />');
+        });
+        it('skips components nested in a scene element in a file without three imports', async () => {
+            const code = await transform("import { Tree } from './Tree';\nconst a = <group><Tree /></group>;");
+            expect(code).toContain('<Tree />');
+        });
+    });
+    it('keeps tagging components in files that do not import react-three', async () => {
+        const code = await transform("import { Card } from './Card';\nconst a = <Card />;");
+        expect(code).toContain('<Card data-zite-id="src/App.tsx|2|10" data-zite-component="Card" />');
     });
     it('leaves fragments untouched', async () => {
         const source = 'const a = <Fragment><React.Fragment key="a" /></Fragment>;';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.133",
+  "version": "0.9.135",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "sideEffects": false,