zitejs 0.9.142 → 0.9.144

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

@@ -1,94 +0,0 @@
-export type User = {
-    id: string;
-    email: string;
-    name: string;
-    roles: ReadonlyArray<string>;
-};
-/** One server function call, as the platform's run log shows it. Input and output are truncated JSON. */
-export type RunRecord = {
-    fn: string;
-    name?: string;
-    nested: boolean;
-    startedAt: number;
-    durationMs: number;
-    input?: string;
-    output?: string;
-    error?: {
-        code: string;
-        message: string;
-    };
-};
-export type AccessKind = "signedIn" | "anyone" | "webhook" | "workflow";
-/** One data, integration or email call. Who is calling is the platform's to know, never the app's to say. */
-export type PlatformCallInput = {
-    integrationId: string;
-    className: string;
-    methodName: string;
-    params: unknown;
-    /** The access decision the call ran under; the platform may narrow on it but never widens. */
-    access: AccessKind;
-};
-/**
- * A call's answer. Errors come back as values: Workers RPC keeps a thrown
- * error's message but drops its code.
- */
-export type PlatformCallResult = {
-    value: unknown;
-} | {
-    error: {
-        code: string;
-        message: string;
-    };
-};
-export type PlatformSession = {
-    call(call: PlatformCallInput): Promise<PlatformCallResult>;
-    /** As `PlatformBinding.runs`, on a session the request already holds. Hosts before 0.10.0-start.4 lack it. */
-    runs?(batch: {
-        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. 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[];
-    }): Promise<void>;
-};
-export type HostMode = "live" | "preview" | "validate";
-export type HostInvoke = {
-    kind: "webhook" | "describe" | "workflow" | "register" | "warm";
-    name: string;
-};
-/** The per-request props the host dispatches with. Only the host can set them. */
-export type HostProps = {
-    platform: PlatformBinding;
-    requestId: string;
-    user: User | null;
-    mode: HostMode;
-    invoke: HostInvoke | null;
-};
-/** What the host resolved for this request. Set by the generated server entry, never by the browser. */
-export type ZiteRequestContext = {
-    requestId: string;
-    url: string;
-    user: User | null;
-    mode: HostMode;
-    invoke: HostInvoke | null;
-    /** Filled by run capture, flushed to the platform once the response ends. */
-    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/types.js

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

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

@@ -1,9 +0,0 @@
-import type { PluginOption } from "vite";
-export type ZiteOptions = {
-    /** A server entry the caller owns, relative to the app root. By default zite() writes the platform's. */
-    serverEntry?: string;
-    /** Build for Cloudflare Workers, the target the platform deploys. Defaults to true; false builds for Node. */
-    cloudflare?: boolean;
-};
-/** The one plugin a Zite app's `vite.config.ts` uses. */
-export declare function zite(options?: ZiteOptions): PluginOption[];

package/dist/esm/start/vite.js

@@ -1,144 +0,0 @@
-import path from "node:path";
-import { tanstackStart } from "@tanstack/react-start/plugin/vite";
-import viteReact from "@vitejs/plugin-react";
-import { ziteId } from "../vite/index.js";
-import { factoryDescriptions } from "./descriptions.js";
-import { hasAppStart, renderStartInstance, renderStartServerEntry, renderWorkflowModules, START_INSTANCE_ENTRY, START_SERVER_ENTRY, workflowFiles, writeIfChanged, } from "./entries.js";
-// Must match the literals in ./server.ts, which the build rewrites.
-const FN_IDS_TOKEN = "__ZITE_FN_IDS__";
-const FN_DESCRIPTIONS_LITERAL = /(["'`])__ZITE_FN_DESCRIPTIONS__\1/;
-// zitejs's empty registry, which the build replaces with the app's.
-const WORKFLOW_REGISTRY = /[\\/]zitejs[\\/]dist[\\/]esm[\\/]start[\\/]workflowModules\.js$/;
-// Platform-pinned Worker settings. The deploy uses its own fixed template, so
-// these only have to match it; apps don't carry a wrangler config.
-const WORKER_COMPATIBILITY_DATE = "2026-09-25";
-const WORKER_COMPATIBILITY_FLAGS = ["nodejs_compat"];
-// Resolved from the app at build time; zitejs doesn't depend on it.
-const loadCloudflare = async (main) => {
-    const { cloudflare } = (await import("@cloudflare/vite-plugin"));
-    return cloudflare({
-        viteEnvironment: { name: "ssr" },
-        config: {
-            name: "zite-app",
-            main,
-            compatibility_date: WORKER_COMPATIBILITY_DATE,
-            compatibility_flags: WORKER_COMPATIBILITY_FLAGS,
-        },
-    });
-};
-/** The one plugin a Zite app's `vite.config.ts` uses. */
-export function zite(options = {}) {
-    const serverEntry = options.serverEntry ?? START_SERVER_ENTRY;
-    // 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(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();
-    const compileZitejs = {
-        name: "zite:compile-zitejs",
-        // The factories must go through TanStack's compiler in both environments.
-        // The peer dependency gets zitejs crawled already; this keeps it true if an
-        // install drops that. A Node build bundles everything, so externalized
-        // libraries can't load the root's React 18 renderer.
-        config: (config) => {
-            const root = path.resolve(config.root ?? ".");
-            const src = `${path.join(root, "src")}/`;
-            return {
-                ssr: { noExternal: options.cloudflare === false ? true : ["zitejs"] },
-                optimizeDeps: { exclude: ["zitejs"] },
-                resolve: {
-                    // `@/` as in classic apps and shadcn, `~/` as in TanStack's templates.
-                    alias: [
-                        { find: /^@\//, replacement: src },
-                        { find: /^~\//, replacement: src },
-                        // The workspace SDKs `zitejs generate` writes, as classic apps map them.
-                        { find: /^zitejs\/db$/, replacement: path.join(root, "../../.zite/db.ts") },
-                        { find: /^zitejs\/integrations$/, replacement: path.join(root, ".zite/integrations/index.ts") },
-                        { find: /^zitejs\/email$/, replacement: path.join(root, ".zite/integrations/email.ts") },
-                        { find: /^zitejs\/meta$/, replacement: path.join(root, ".zite/meta.ts") },
-                    ],
-                    // Shared workspace libraries resolve from the root, where classic apps
-                    // keep React 18; recharts 2 needs the app's react-is 19 or drops series.
-                    dedupe: ["react-is"],
-                },
-            };
-        },
-        // Each new isolate loads the whole server bundle, so its size is cold-start
-        // time; Vite leaves SSR output unminified.
-        configEnvironment: (name, config) => name === "ssr" && options.cloudflare !== false && config.build?.minify === undefined ? { build: { minify: true } } : undefined,
-    };
-    // Each server function's `description` option, by name, for the editor.
-    const descriptions = new Map();
-    const srcDir = `${path.join(appDir, "src")}${path.sep}`;
-    const functionIds = {
-        name: "zite:function-ids",
-        apply: "build",
-        transform(code, id) {
-            if (this.environment?.config.consumer !== "server" || !id.startsWith(srcDir) || !code.includes("description"))
-                return;
-            try {
-                for (const [name, text] of factoryDescriptions(this.parse(code)))
-                    descriptions.set(name, text);
-            }
-            catch {
-                // Display-only: an unreadable module just shows no descriptions.
-            }
-        },
-        generateBundle(_, bundle) {
-            const described = Object.fromEntries([...descriptions].filter(([name]) => ids.has(name)));
-            for (const chunk of Object.values(bundle)) {
-                if (chunk.type !== "chunk")
-                    continue;
-                if (chunk.code.includes(FN_IDS_TOKEN))
-                    chunk.code = chunk.code.replace(FN_IDS_TOKEN, [...ids.keys()].join(","));
-                chunk.code = chunk.code.replace(FN_DESCRIPTIONS_LITERAL, () => JSON.stringify(JSON.stringify(described)));
-            }
-        },
-    };
-    const workflowRegistry = {
-        name: "zite:workflow-registry",
-        load: (id) => (WORKFLOW_REGISTRY.test(id.split("?")[0]) ? renderWorkflowModules(appDir, workflowFiles(appDir)) : undefined),
-    };
-    return [
-        tanstackStart({
-            // TanStack resolves these from `src/`.
-            server: { entry: `../${serverEntry.replace(/\.ts$/, "")}` },
-            start: { entry: `../${START_INSTANCE_ENTRY.replace(/\.ts$/, "")}` },
-            serverFns: {
-                generateFunctionId: ({ filename, functionName }) => {
-                    const id = functionName.replace(/_createServerFn_handler$/, "");
-                    if (/(^|\/)node_modules\//.test(filename)) {
-                        throw new Error(`[zite] ${filename} defines server function ${id}; dependencies can't ship server functions`);
-                    }
-                    const existing = ids.get(id);
-                    if (existing && existing !== filename) {
-                        throw new Error(`[zite] server function name ${id} is used in both ${existing} and ${filename}`);
-                    }
-                    ids.set(id, filename);
-                    return id;
-                },
-            },
-            importProtection: {
-                behavior: "error",
-                client: {
-                    // Appended to TanStack's own.
-                    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.
-                    files: ["**/*.server.*", "**/.zite/db.ts", "**/.zite/integrations/**"],
-                },
-            },
-        }),
-        options.cloudflare !== false ? loadCloudflare(serverEntry) : null,
-        viteReact(),
-        ziteId(),
-        compileZitejs,
-        functionIds,
-        workflowRegistry,
-    ];
-}

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

@@ -1,11 +0,0 @@
-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

@@ -1,20 +0,0 @@
-// 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,50 +0,0 @@
-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;
-} & ({
-    schedule: ZiteSchedule;
-    trigger?: never;
-} | {
-    trigger: StartTrigger;
-    schedule?: never;
-});
-/** What a workflow's handler gets. A trigger adds `trigger`, typed by the kind it declares. */
-export type WorkflowArgs<TConfig extends WorkflowConfig> = {
-    input: unknown;
-} & (TConfig extends {
-    trigger: infer T;
-} ? {
-    trigger: ZiteTriggerContext<T>;
-} : unknown);
-export type Workflow<TConfig extends WorkflowConfig = WorkflowConfig> = {
-    readonly [WORKFLOW]: true;
-    readonly config: TConfig;
-    readonly handler: (args: WorkflowArgs<TConfig>) => unknown;
-};
-/**
- * Scheduled or triggered work, in a `*.server.ts` file:
- * `export const nightly = createWorkflow({ schedule }).handler(async () => { ... })`.
- * Only the platform runs it. It has no user and no URL, and reads data like a server function does.
- */
-export declare function createWorkflow<const TConfig extends WorkflowConfig>(config: TConfig): {
-    handler: (fn: (args: WorkflowArgs<TConfig>) => unknown) => Workflow<TConfig>;
-};
-export declare const isWorkflow: (value: unknown) => value is Workflow;
-export {};

package/dist/esm/start/workflow.js

@@ -1,13 +0,0 @@
-// Shared across copies of zitejs in one bundle, like the access scope.
-const WORKFLOW = Symbol.for("zitejs:workflow");
-/**
- * Scheduled or triggered work, in a `*.server.ts` file:
- * `export const nightly = createWorkflow({ schedule }).handler(async () => { ... })`.
- * Only the platform runs it. It has no user and no URL, and reads data like a server function does.
- */
-export function createWorkflow(config) {
-    return {
-        handler: (fn) => ({ [WORKFLOW]: true, config, handler: fn }),
-    };
-}
-export const isWorkflow = (value) => typeof value === "object" && value !== null && value[WORKFLOW] === true;

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

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

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

@@ -1,39 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-import { createWorkflow } from "./workflow.js";
-describe("createWorkflow handler args", () => {
-    it("gives a schedule no trigger", () => {
-        createWorkflow({ schedule: { scheduleType: "oneTime", fireAt: "2026-10-10T03:00:00Z", timezone: "UTC" } }).handler((args) => {
-            expectTypeOf(args).toEqualTypeOf();
-        });
-    });
-    it("types the trigger by the kind it declares", () => {
-        createWorkflow({ trigger: { every: "5m" } }).handler(({ trigger }) => {
-            expectTypeOf(trigger).toEqualTypeOf();
-        });
-        createWorkflow({ trigger: { integration: "slack", events: ["message.channels"] } }).handler(({ trigger }) => {
-            expectTypeOf(trigger).toEqualTypeOf();
-        });
-        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/dist/esm/start/workflowModules.d.ts

@@ -1 +0,0 @@
-export declare const workflowModules: Record<string, () => Promise<Record<string, unknown>>>;

package/dist/esm/start/workflowModules.js

@@ -1,3 +0,0 @@
-// Replaced at build by zite() with a lazy import of every app module that
-// mentions createWorkflow. Empty wherever the plugin didn't build the app.
-export const workflowModules = {};

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

@@ -1,80 +0,0 @@
-import { type Workflow } from "./workflow.js";
-export type TriggerReport = {
-    handled: string[];
-    cursor?: string;
-};
-export type WorkflowRunResult = {
-    ok: true;
-    output: unknown;
-    trigger?: TriggerReport;
-} | {
-    ok: false;
-    error: {
-        code: string;
-        message: string;
-    };
-    trigger?: TriggerReport;
-};
-/**
- * Splits the platform's state out of the input. A poll or a provider delivery
- * with a cursor gets `seen`, `handled` and `advance`. Handled ids are reported
- * whether or not the run throws, so an item acted on is never acted on again;
- * the staged cursor only on success. Only ids the incoming `seen` lacked are
- * reported: billing reads an empty list as a run that found nothing new.
- */
-export declare function triggerContext(workflow: Workflow, rawInput: unknown): {
-    input: unknown;
-    trigger?: undefined;
-    report?: undefined;
-} | {
-    input: {
-        [x: string]: unknown;
-    };
-    trigger: {
-        provider: string;
-        deliveryId?: string | undefined;
-        headers: Record<string, unknown>;
-    } | {
-        headers?: undefined;
-    } | {
-        headers: {};
-    };
-    report?: undefined;
-} | {
-    input: {
-        [x: string]: unknown;
-    };
-    trigger: {
-        provider: string;
-        deliveryId?: string | undefined;
-        headers: Record<string, unknown>;
-        cursor: string | null;
-        seen: (id: string) => boolean;
-        handled: (id: string) => void;
-        advance: (cursor: string) => void;
-    } | {
-        headers?: undefined;
-        cursor: string | null;
-        seen: (id: string) => boolean;
-        handled: (id: string) => void;
-        advance: (cursor: string) => void;
-    } | {
-        headers: {};
-        cursor: string | null;
-        seen: (id: string) => boolean;
-        handled: (id: string) => void;
-        advance: (cursor: string) => void;
-    };
-    report: (succeeded: boolean) => TriggerReport;
-};
-/** Runs the handler in a workflow access scope: no user, and data calls allowed. */
-export declare function runWorkflow(workflow: Workflow, rawInput: unknown): Promise<WorkflowRunResult>;
-export type LoadedWorkflow = {
-    id: string;
-    file: string;
-    workflow: Workflow;
-};
-/** Every exported workflow in the app, by export name. */
-export declare function loadWorkflows(modules?: Record<string, () => Promise<Record<string, unknown>>>): Promise<LoadedWorkflow[]>;
-/** The input as the run log keeps it: a trigger's `seen` list can hold thousands of ids. */
-export declare const loggedInput: (rawInput: unknown) => unknown;

package/dist/esm/start/workflowRun.js

@@ -1,107 +0,0 @@
-// Server-only: runs a workflow the host invoked. Takes the same platform input
-// as classic triggered endpoints (`__cron`, `__poll`, `__webhook`), so the
-// runner's schedules, polls and provider deliveries work unchanged.
-import { errorOf } from "./runLog.js";
-import { runInScope } from "./scope.js";
-import { isWorkflow } from "./workflow.js";
-import { workflowModules } from "./workflowModules.js";
-const asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-const idOf = (id) => {
-    if (typeof id !== "string" && typeof id !== "number")
-        throw new TypeError(`trigger ids must be strings, got ${typeof id}`);
-    const value = String(id);
-    if (value.length === 0 || value.length > 512)
-        throw new TypeError("trigger ids must be 1 to 512 characters");
-    return value;
-};
-/**
- * Splits the platform's state out of the input. A poll or a provider delivery
- * with a cursor gets `seen`, `handled` and `advance`. Handled ids are reported
- * whether or not the run throws, so an item acted on is never acted on again;
- * the staged cursor only on success. Only ids the incoming `seen` lacked are
- * reported: billing reads an empty list as a run that found nothing new.
- */
-export function triggerContext(workflow, rawInput) {
-    const raw = asRecord(rawInput);
-    const { __cron, __poll, __webhook, ...input } = raw ?? {};
-    const declared = workflow.config.trigger;
-    if (!declared)
-        return { input: raw ? input : rawInput };
-    const poll = asRecord(__poll);
-    const webhook = asRecord(__webhook);
-    const delivery = typeof webhook?.provider === "string" ? webhook : null;
-    // A run with no trigger state, such as a manual one, still gets a trigger: an empty one.
-    const info = delivery
-        ? {
-            headers: asRecord(delivery.headers) ?? {},
-            ...(typeof delivery.deliveryId === "string" ? { deliveryId: delivery.deliveryId } : {}),
-            provider: delivery.provider,
-        }
-        : declared.every
-            ? {}
-            : { headers: {} };
-    if (!poll && declared.events)
-        return { input, trigger: info };
-    const state = poll ?? delivery ?? {};
-    const known = new Set(Array.isArray(state.seen) ? state.seen.map(String) : []);
-    const handled = [];
-    let staged;
-    const trigger = {
-        cursor: typeof state.cursor === "string" ? state.cursor : null,
-        seen: (id) => known.has(String(id)),
-        handled: (id) => {
-            const value = idOf(id);
-            if (known.has(value))
-                return;
-            known.add(value);
-            handled.push(value);
-        },
-        advance: (cursor) => {
-            if (typeof cursor !== "string" || cursor.length > 4096) {
-                throw new TypeError("trigger.advance takes a string of at most 4096 characters");
-            }
-            staged = cursor;
-        },
-        ...info,
-    };
-    const report = (succeeded) => ({
-        handled: handled.slice(-2000),
-        ...(succeeded && staged !== undefined ? { cursor: staged } : {}),
-    });
-    return { input, trigger, report };
-}
-/** Runs the handler in a workflow access scope: no user, and data calls allowed. */
-export async function runWorkflow(workflow, rawInput) {
-    const { input, trigger, report } = triggerContext(workflow, rawInput);
-    const args = { input, ...(trigger ? { trigger } : {}) };
-    try {
-        const output = await runInScope({ kind: "workflow", user: null }, () => workflow.handler(args));
-        return { ok: true, output, ...(report ? { trigger: report(true) } : {}) };
-    }
-    catch (error) {
-        return { ok: false, error: errorOf(error), ...(report ? { trigger: report(false) } : {}) };
-    }
-}
-/** Every exported workflow in the app, by export name. */
-export async function loadWorkflows(modules = workflowModules) {
-    const found = [];
-    for (const [file, load] of Object.entries(modules)) {
-        for (const [id, value] of Object.entries(await load()))
-            if (isWorkflow(value))
-                found.push({ id, file, workflow: value });
-    }
-    return found;
-}
-/** The input as the run log keeps it: a trigger's `seen` list can hold thousands of ids. */
-export const loggedInput = (rawInput) => {
-    const raw = asRecord(rawInput);
-    if (!raw)
-        return rawInput;
-    const out = { ...raw };
-    for (const key of ["__poll", "__webhook"]) {
-        const state = asRecord(raw[key]);
-        if (state && Array.isArray(state.seen))
-            out[key] = { ...state, seen: `[${state.seen.length} ids]` };
-    }
-    return out;
-};