zitejs 0.9.52 → 0.9.54

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

@@ -21,16 +21,22 @@ type SchemaLike<T> = {
     _output: T;
     parse: (data: unknown) => T;
 };
-export interface EndpointConfig<TInput = unknown, TOutput = unknown> {
+export type ZiteStreamInterface = {
+    write: (data: unknown) => Promise<void>;
+    forward: (asyncIterable: AsyncIterable<string>) => Promise<string>;
+};
+export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false> {
     description?: string;
     inputSchema?: SchemaLike<TInput>;
     outputSchema?: SchemaLike<TOutput>;
-    stream?: boolean;
+    stream?: TStream;
     authenticated?: boolean;
     execute: (params: {
         input: TInput;
         context: ZiteRequestContext | ZiteScheduledContext;
-    }) => Promise<TOutput> | TOutput;
+    } & (TStream extends true ? {
+        stream: ZiteStreamInterface;
+    } : {})) => Promise<TOutput> | TOutput;
 }
-export declare function createEndpoint<TInput = unknown, TOutput = unknown>(config: EndpointConfig<TInput, TOutput>): EndpointConfig<TInput, TOutput>;
+export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false>(config: EndpointConfig<TInput, TOutput, TStream>): EndpointConfig<TInput, TOutput, TStream>;
 export {};

package/dist/cjs/backend/index.js

@@ -6,7 +6,7 @@ class ZiteError extends Error {
     statusCode;
     constructor(message, options) {
         super(message);
-        this.name = 'ZiteError';
+        this.name = "ZiteError";
         this.statusCode = options?.statusCode ?? 500;
     }
 }

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

@@ -4,4 +4,10 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown> {
         context: unknown;
     }) => Promise<TOutput> | TOutput;
 }
+export declare function createCaller<TInput, TOutput>(name: string, flowId?: string): (input: TInput) => Promise<TOutput>;
 export declare function createCaller<TInput, TOutput>(endpoint: EndpointConfig<TInput, TOutput>, name: string, flowId?: string): (input: TInput) => Promise<TOutput>;
+export type StreamingResponse<T> = {
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+    result: Promise<T>;
+};
+export declare function createStreamingCaller<TInput, TOutput>(name: string): (input: TInput) => StreamingResponse<TOutput>;

package/dist/cjs/caller/index.js

@@ -1,15 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCaller = createCaller;
+exports.createStreamingCaller = createStreamingCaller;
 const env_js_1 = require("../internal/env.js");
 const ENVIRONMENTS = {
-    production: 'https://workflows.zite.com',
-    staging: 'https://workflows.zitestaging.com',
-    local: 'http://localhost:2506',
+    production: "https://workflows.zite.com",
+    staging: "https://workflows.zitestaging.com",
+    local: "http://localhost:2506",
 };
 function getRunnerUrl() {
-    const env = (0, env_js_1.getEnv)('ZITE_ENV', 'VITE_ZITE_ENV') ?? 'production';
-    return (0, env_js_1.getEnv)('ZITE_RUNNER_URL', 'VITE_ZITE_RUNNER_URL') ?? ENVIRONMENTS[env] ?? ENVIRONMENTS.production;
+    const env = (0, env_js_1.getEnv)("ZITE_ENV", "VITE_ZITE_ENV") ?? "production";
+    return ((0, env_js_1.getEnv)("ZITE_RUNNER_URL", "VITE_ZITE_RUNNER_URL") ??
+        ENVIRONMENTS[env] ??
+        ENVIRONMENTS.production);
 }
 /**
  * Get the user's usage token for endpoint auth.
@@ -17,35 +20,132 @@ function getRunnerUrl() {
  * In external mode: stored in localStorage by the auth flow
  */
 function getUsageToken() {
-    if (typeof window !== 'undefined') {
+    if (typeof window !== "undefined") {
         const win = window;
-        if (typeof win._ziteUsageToken === 'string')
+        if (typeof win._ziteUsageToken === "string")
             return win._ziteUsageToken;
     }
     // Fallback to stored auth token (external mode)
-    if (typeof localStorage !== 'undefined') {
-        const stored = localStorage.getItem('zite.auth.token');
+    if (typeof localStorage !== "undefined") {
+        const stored = localStorage.getItem("zite.auth.token");
         if (stored)
             return stored;
     }
-    return '';
+    return "";
 }
-function createCaller(endpoint, name, flowId) {
-    return async (input) => {
-        const appId = flowId ?? (0, env_js_1.getEnv)('ZITE_FLOW_ID', 'VITE_ZITE_FLOW_ID') ?? '';
-        const token = getUsageToken();
-        const res = await fetch(getRunnerUrl() + '/public/' + appId + '/api/' + name, {
-            method: 'POST',
+function buildFetchOptions(name, input, extra) {
+    const appId = (0, env_js_1.getEnv)("ZITE_FLOW_ID", "VITE_ZITE_FLOW_ID") ?? "";
+    const token = getUsageToken();
+    const ziteAuthToken = typeof localStorage !== "undefined"
+        ? localStorage.getItem("zite.auth.token")
+        : null;
+    return {
+        url: getRunnerUrl() + "/public/" + appId + "/api/" + name,
+        init: {
+            method: "POST",
             headers: {
                 ...(token ? { Authorization: `Bearer ${token}` } : {}),
-                'Content-Type': 'application/json',
+                "Content-Type": "application/json",
             },
-            body: JSON.stringify({ inputs: input, mode: 'preview', usageToken: token }),
-        });
+            body: JSON.stringify({
+                inputs: input,
+                mode: "preview",
+                usageToken: token,
+                ...(ziteAuthToken ? { ziteAuthToken } : {}),
+                ...extra,
+            }),
+        },
+    };
+}
+function createCaller(endpointOrName, nameOrFlowId, flowId) {
+    const name = typeof endpointOrName === "string" ? endpointOrName : nameOrFlowId;
+    return async (input) => {
+        const { url, init } = buildFetchOptions(name, input);
+        const res = await fetch(url, init);
         if (!res.ok) {
-            const text = await res.text().catch(() => '');
+            const text = await res.text().catch(() => "");
             throw new Error(`API call failed (${res.status}): ${text}`);
         }
         return res.json();
     };
 }
+function createStreamingCaller(name) {
+    return (input) => {
+        let resultResolve;
+        let resultReject;
+        const resultPromise = new Promise((resolve, reject) => {
+            resultResolve = resolve;
+            resultReject = reject;
+        });
+        const { url, init } = buildFetchOptions(name, input, { stream: true });
+        const fetchPromise = fetch(url, init);
+        return {
+            async *[Symbol.asyncIterator]() {
+                try {
+                    const response = await fetchPromise;
+                    if (!response.ok) {
+                        const errorData = await response.json().catch(() => ({}));
+                        const error = new Error(errorData.message ||
+                            `Error with endpoint ${name}: ${response.status}`);
+                        resultReject(error);
+                        throw error;
+                    }
+                    if (!response.body) {
+                        const error = new Error("No response body for streaming endpoint");
+                        resultReject(error);
+                        throw error;
+                    }
+                    const reader = response.body
+                        .pipeThrough(new TextDecoderStream())
+                        .getReader();
+                    let buffer = "";
+                    while (true) {
+                        const { value, done } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += value;
+                        while (buffer.includes("\n\n")) {
+                            const eventEnd = buffer.indexOf("\n\n");
+                            const eventBlock = buffer.substring(0, eventEnd);
+                            buffer = buffer.substring(eventEnd + 2);
+                            const eventTypeMatch = eventBlock.match(/^event: (.+)$/m);
+                            const dataMatch = eventBlock.match(/^data: (.+)$/m);
+                            const eventType = eventTypeMatch?.[1];
+                            const dataStr = dataMatch?.[1];
+                            if (eventType === "data" && dataStr) {
+                                try {
+                                    yield JSON.parse(dataStr);
+                                }
+                                catch {
+                                    yield dataStr;
+                                }
+                            }
+                            else if (eventType === "result" && dataStr) {
+                                try {
+                                    resultResolve(JSON.parse(dataStr));
+                                }
+                                catch {
+                                    resultResolve(dataStr);
+                                }
+                            }
+                            else if (eventType === "error" && dataStr) {
+                                try {
+                                    const errorData = JSON.parse(dataStr);
+                                    resultReject(new Error(errorData.message || "Streaming error"));
+                                }
+                                catch {
+                                    resultReject(new Error(dataStr || "Streaming error"));
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    resultReject(error);
+                    throw error;
+                }
+            },
+            result: resultPromise,
+        };
+    };
+}

package/dist/cjs/dev/index.js

@@ -44,7 +44,12 @@ function regenerateAppApiTs(appDir) {
     const apiDir = (0, path_1.join)("apps", appDir, "src", "api");
     if (!(0, fs_2.existsSync)(apiDir))
         return;
-    const endpointFiles = (0, fs_2.readdirSync)(apiDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const endpointFiles = (0, fs_2.readdirSync)(apiDir)
+        .filter((f) => f.endsWith(".ts") || f.endsWith(".js"))
+        .map((f) => ({
+        fileName: f,
+        content: (0, fs_2.readFileSync)((0, path_1.join)(apiDir, f), "utf-8"),
+    }));
     const content = (0, lib_js_1.generateApiTs)(endpointFiles);
     if (content) {
         const outDir = (0, path_1.join)("apps", appDir, ".zite");

package/dist/cjs/sync/index.js

@@ -27,9 +27,7 @@ const DB_ENVIRONMENTS = {
     local: "http://localhost:2507/api/v1",
 };
 const env = process.env.ZITE_ENV ?? "production";
-const BASE_URL = process.env.ZITE_DB_URL ??
-    DB_ENVIRONMENTS[env] ??
-    DB_ENVIRONMENTS.production;
+const BASE_URL = process.env.ZITE_DB_URL ?? DB_ENVIRONMENTS[env] ?? DB_ENVIRONMENTS.production;
 const TOKEN = process.env.ZITE_DB_TOKEN ?? "";
 async function fetchDatabase(baseId) {
     const url = `${BASE_URL}/bases/${encodeURIComponent(baseId)}`;
@@ -88,7 +86,12 @@ function regenerateApiTs() {
     const apiDir = (0, path_1.join)("src", "api");
     if (!(0, fs_1.existsSync)(apiDir))
         return;
-    const endpointFiles = (0, fs_1.readdirSync)(apiDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const endpointFiles = (0, fs_1.readdirSync)(apiDir)
+        .filter((f) => f.endsWith(".ts") || f.endsWith(".js"))
+        .map((f) => ({
+        fileName: f,
+        content: (0, fs_1.readFileSync)((0, path_1.join)(apiDir, f), "utf-8"),
+    }));
     const apiTs = (0, lib_js_1.generateApiTs)(endpointFiles);
     if (apiTs) {
         (0, fs_1.mkdirSync)(".zite", { recursive: true });

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

@@ -30,7 +30,11 @@ export declare function generateSchema(database: Database, existingSchema?: Zite
  * Pure function — no external data needed beyond what's in the schema file.
  */
 export declare function generateDbTs(schema: ZiteSchema): string;
-export declare function generateApiTs(endpointFiles: string[]): string | null;
+export type EndpointFileInfo = {
+    fileName: string;
+    content?: string;
+};
+export declare function generateApiTs(endpointFiles: (string | EndpointFileInfo)[]): string | null;
 export declare function generateUserTs(usersTableFields?: Array<{
     name: string;
     type: string;

package/dist/cjs/sync/lib.js

@@ -9,6 +9,7 @@ exports.generateUserTs = generateUserTs;
 exports.generateAuthWrapperTs = generateAuthWrapperTs;
 exports.generateAirtableTs = generateAirtableTs;
 exports.generateBackendWrapperTs = generateBackendWrapperTs;
+const parser_1 = require("@babel/parser");
 const FIELD_TYPE_MAP = {
     single_line_text: "string",
     long_text: "string",
@@ -269,36 +270,80 @@ function generateDbTs(schema) {
     lines.push("");
     return lines.join("\n");
 }
+function detectStreamEnabled(source) {
+    try {
+        const ast = (0, parser_1.parse)(source, {
+            sourceType: "module",
+            plugins: ["typescript"],
+        });
+        const defaultExport = ast.program.body.find((n) => n.type === "ExportDefaultDeclaration" &&
+            n.declaration.type === "CallExpression");
+        if (!defaultExport || defaultExport.type !== "ExportDefaultDeclaration")
+            return false;
+        const call = defaultExport.declaration;
+        if (call.type !== "CallExpression" || call.arguments.length === 0)
+            return false;
+        const arg = call.arguments[0];
+        if (arg.type !== "ObjectExpression")
+            return false;
+        const streamProp = arg.properties.find((p) => p.type === "ObjectProperty" &&
+            ((p.key.type === "Identifier" && p.key.name === "stream") ||
+                (p.key.type === "StringLiteral" && p.key.value === "stream")));
+        if (!streamProp || streamProp.type !== "ObjectProperty")
+            return false;
+        return (streamProp.value.type === "BooleanLiteral" &&
+            streamProp.value.value === true);
+    }
+    catch {
+        return false;
+    }
+}
 function generateApiTs(endpointFiles) {
     if (!endpointFiles || endpointFiles.length === 0)
         return null;
+    const endpoints = [];
+    for (const file of endpointFiles) {
+        const fileName = typeof file === "string" ? file : file.fileName;
+        const content = typeof file === "string" ? undefined : file.content;
+        const name = fileName.replace(/\.(ts|js)$/, "");
+        const camelName = toCamelCase(name);
+        const pascal = toPascalCase(camelName);
+        const stream = content ? detectStreamEnabled(content) : false;
+        endpoints.push({ camelName, pascal, stream });
+    }
+    const hasStreaming = endpoints.some((e) => e.stream);
     const lines = [
         "// Auto-generated by zitejs sync. Do not edit manually.",
         "",
-        "import { createCaller } from 'zitejs/caller';",
+        hasStreaming
+            ? "import { createCaller, createStreamingCaller } from 'zitejs/caller';"
+            : "import { createCaller } from 'zitejs/caller';",
         "",
     ];
-    const endpointNames = [];
-    for (const file of endpointFiles) {
-        const name = file.replace(/\.(ts|js)$/, "");
-        const camelName = toCamelCase(name);
-        lines.push(`import ${camelName}Endpoint from '../src/api/${name}';`);
-        endpointNames.push(camelName);
-    }
-    lines.push("");
-    for (const name of endpointNames) {
-        lines.push(`export const ${name} = createCaller(${name}Endpoint, '${name}');`);
+    for (const { pascal, camelName } of endpoints) {
+        const name = camelName.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const rawName = endpointFiles[endpoints.findIndex((e) => e.camelName === camelName)];
+        const fileName = typeof rawName === "string" ? rawName : rawName.fileName;
+        const baseName = fileName.replace(/\.(ts|js)$/, "");
+        lines.push(`import type { default as _${pascal}Ep } from '../src/api/${baseName}';`);
     }
     lines.push("");
-    for (const name of endpointNames) {
-        const pascal = toPascalCase(name);
-        lines.push(`export type ${pascal}InputType = Parameters<typeof ${name}Endpoint.execute>[0]['input'];`);
-        lines.push(`export type ${pascal}OutputType = Awaited<ReturnType<typeof ${name}Endpoint.execute>>;`);
+    for (const { camelName, pascal, stream } of endpoints) {
+        lines.push(`type _${pascal}Cfg = typeof _${pascal}Ep;`);
+        lines.push(`export type ${pascal}InputType = Parameters<_${pascal}Cfg['execute']>[0]['input'];`);
+        lines.push(`export type ${pascal}OutputType = Awaited<ReturnType<_${pascal}Cfg['execute']>>;`);
+        if (stream) {
+            lines.push(`export const ${camelName} = createStreamingCaller<${pascal}InputType, ${pascal}OutputType>('${camelName}');`);
+        }
+        else {
+            lines.push(`export const ${camelName} = createCaller<${pascal}InputType, ${pascal}OutputType>('${camelName}');`);
+        }
+        lines.push("");
     }
     lines.push("");
     lines.push("export const api = {");
-    for (const name of endpointNames) {
-        lines.push(`  ${name},`);
+    for (const { camelName } of endpoints) {
+        lines.push(`  ${camelName},`);
     }
     lines.push("};");
     lines.push("");

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

@@ -21,16 +21,22 @@ type SchemaLike<T> = {
     _output: T;
     parse: (data: unknown) => T;
 };
-export interface EndpointConfig<TInput = unknown, TOutput = unknown> {
+export type ZiteStreamInterface = {
+    write: (data: unknown) => Promise<void>;
+    forward: (asyncIterable: AsyncIterable<string>) => Promise<string>;
+};
+export interface EndpointConfig<TInput = unknown, TOutput = unknown, TStream extends boolean = false> {
     description?: string;
     inputSchema?: SchemaLike<TInput>;
     outputSchema?: SchemaLike<TOutput>;
-    stream?: boolean;
+    stream?: TStream;
     authenticated?: boolean;
     execute: (params: {
         input: TInput;
         context: ZiteRequestContext | ZiteScheduledContext;
-    }) => Promise<TOutput> | TOutput;
+    } & (TStream extends true ? {
+        stream: ZiteStreamInterface;
+    } : {})) => Promise<TOutput> | TOutput;
 }
-export declare function createEndpoint<TInput = unknown, TOutput = unknown>(config: EndpointConfig<TInput, TOutput>): EndpointConfig<TInput, TOutput>;
+export declare function createEndpoint<TInput = unknown, TOutput = unknown, TStream extends boolean = false>(config: EndpointConfig<TInput, TOutput, TStream>): EndpointConfig<TInput, TOutput, TStream>;
 export {};

package/dist/esm/backend/index.js

@@ -2,7 +2,7 @@ export class ZiteError extends Error {
     statusCode;
     constructor(message, options) {
         super(message);
-        this.name = 'ZiteError';
+        this.name = "ZiteError";
         this.statusCode = options?.statusCode ?? 500;
     }
 }

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

@@ -4,4 +4,10 @@ export interface EndpointConfig<TInput = unknown, TOutput = unknown> {
         context: unknown;
     }) => Promise<TOutput> | TOutput;
 }
+export declare function createCaller<TInput, TOutput>(name: string, flowId?: string): (input: TInput) => Promise<TOutput>;
 export declare function createCaller<TInput, TOutput>(endpoint: EndpointConfig<TInput, TOutput>, name: string, flowId?: string): (input: TInput) => Promise<TOutput>;
+export type StreamingResponse<T> = {
+    [Symbol.asyncIterator](): AsyncIterator<string>;
+    result: Promise<T>;
+};
+export declare function createStreamingCaller<TInput, TOutput>(name: string): (input: TInput) => StreamingResponse<TOutput>;

package/dist/esm/caller/index.js

@@ -1,12 +1,14 @@
-import { getEnv } from '../internal/env.js';
+import { getEnv } from "../internal/env.js";
 const ENVIRONMENTS = {
-    production: 'https://workflows.zite.com',
-    staging: 'https://workflows.zitestaging.com',
-    local: 'http://localhost:2506',
+    production: "https://workflows.zite.com",
+    staging: "https://workflows.zitestaging.com",
+    local: "http://localhost:2506",
 };
 function getRunnerUrl() {
-    const env = getEnv('ZITE_ENV', 'VITE_ZITE_ENV') ?? 'production';
-    return getEnv('ZITE_RUNNER_URL', 'VITE_ZITE_RUNNER_URL') ?? ENVIRONMENTS[env] ?? ENVIRONMENTS.production;
+    const env = getEnv("ZITE_ENV", "VITE_ZITE_ENV") ?? "production";
+    return (getEnv("ZITE_RUNNER_URL", "VITE_ZITE_RUNNER_URL") ??
+        ENVIRONMENTS[env] ??
+        ENVIRONMENTS.production);
 }
 /**
  * Get the user's usage token for endpoint auth.
@@ -14,35 +16,132 @@ function getRunnerUrl() {
  * In external mode: stored in localStorage by the auth flow
  */
 function getUsageToken() {
-    if (typeof window !== 'undefined') {
+    if (typeof window !== "undefined") {
         const win = window;
-        if (typeof win._ziteUsageToken === 'string')
+        if (typeof win._ziteUsageToken === "string")
             return win._ziteUsageToken;
     }
     // Fallback to stored auth token (external mode)
-    if (typeof localStorage !== 'undefined') {
-        const stored = localStorage.getItem('zite.auth.token');
+    if (typeof localStorage !== "undefined") {
+        const stored = localStorage.getItem("zite.auth.token");
         if (stored)
             return stored;
     }
-    return '';
+    return "";
 }
-export function createCaller(endpoint, name, flowId) {
-    return async (input) => {
-        const appId = flowId ?? getEnv('ZITE_FLOW_ID', 'VITE_ZITE_FLOW_ID') ?? '';
-        const token = getUsageToken();
-        const res = await fetch(getRunnerUrl() + '/public/' + appId + '/api/' + name, {
-            method: 'POST',
+function buildFetchOptions(name, input, extra) {
+    const appId = getEnv("ZITE_FLOW_ID", "VITE_ZITE_FLOW_ID") ?? "";
+    const token = getUsageToken();
+    const ziteAuthToken = typeof localStorage !== "undefined"
+        ? localStorage.getItem("zite.auth.token")
+        : null;
+    return {
+        url: getRunnerUrl() + "/public/" + appId + "/api/" + name,
+        init: {
+            method: "POST",
             headers: {
                 ...(token ? { Authorization: `Bearer ${token}` } : {}),
-                'Content-Type': 'application/json',
+                "Content-Type": "application/json",
             },
-            body: JSON.stringify({ inputs: input, mode: 'preview', usageToken: token }),
-        });
+            body: JSON.stringify({
+                inputs: input,
+                mode: "preview",
+                usageToken: token,
+                ...(ziteAuthToken ? { ziteAuthToken } : {}),
+                ...extra,
+            }),
+        },
+    };
+}
+export function createCaller(endpointOrName, nameOrFlowId, flowId) {
+    const name = typeof endpointOrName === "string" ? endpointOrName : nameOrFlowId;
+    return async (input) => {
+        const { url, init } = buildFetchOptions(name, input);
+        const res = await fetch(url, init);
         if (!res.ok) {
-            const text = await res.text().catch(() => '');
+            const text = await res.text().catch(() => "");
             throw new Error(`API call failed (${res.status}): ${text}`);
         }
         return res.json();
     };
 }
+export function createStreamingCaller(name) {
+    return (input) => {
+        let resultResolve;
+        let resultReject;
+        const resultPromise = new Promise((resolve, reject) => {
+            resultResolve = resolve;
+            resultReject = reject;
+        });
+        const { url, init } = buildFetchOptions(name, input, { stream: true });
+        const fetchPromise = fetch(url, init);
+        return {
+            async *[Symbol.asyncIterator]() {
+                try {
+                    const response = await fetchPromise;
+                    if (!response.ok) {
+                        const errorData = await response.json().catch(() => ({}));
+                        const error = new Error(errorData.message ||
+                            `Error with endpoint ${name}: ${response.status}`);
+                        resultReject(error);
+                        throw error;
+                    }
+                    if (!response.body) {
+                        const error = new Error("No response body for streaming endpoint");
+                        resultReject(error);
+                        throw error;
+                    }
+                    const reader = response.body
+                        .pipeThrough(new TextDecoderStream())
+                        .getReader();
+                    let buffer = "";
+                    while (true) {
+                        const { value, done } = await reader.read();
+                        if (done)
+                            break;
+                        buffer += value;
+                        while (buffer.includes("\n\n")) {
+                            const eventEnd = buffer.indexOf("\n\n");
+                            const eventBlock = buffer.substring(0, eventEnd);
+                            buffer = buffer.substring(eventEnd + 2);
+                            const eventTypeMatch = eventBlock.match(/^event: (.+)$/m);
+                            const dataMatch = eventBlock.match(/^data: (.+)$/m);
+                            const eventType = eventTypeMatch?.[1];
+                            const dataStr = dataMatch?.[1];
+                            if (eventType === "data" && dataStr) {
+                                try {
+                                    yield JSON.parse(dataStr);
+                                }
+                                catch {
+                                    yield dataStr;
+                                }
+                            }
+                            else if (eventType === "result" && dataStr) {
+                                try {
+                                    resultResolve(JSON.parse(dataStr));
+                                }
+                                catch {
+                                    resultResolve(dataStr);
+                                }
+                            }
+                            else if (eventType === "error" && dataStr) {
+                                try {
+                                    const errorData = JSON.parse(dataStr);
+                                    resultReject(new Error(errorData.message || "Streaming error"));
+                                }
+                                catch {
+                                    resultReject(new Error(dataStr || "Streaming error"));
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (error) {
+                    resultReject(error);
+                    throw error;
+                }
+            },
+            result: resultPromise,
+        };
+    };
+}

package/dist/esm/dev/index.js

@@ -40,7 +40,12 @@ function regenerateAppApiTs(appDir) {
     const apiDir = join("apps", appDir, "src", "api");
     if (!existsSync(apiDir))
         return;
-    const endpointFiles = readdirSync(apiDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const endpointFiles = readdirSync(apiDir)
+        .filter((f) => f.endsWith(".ts") || f.endsWith(".js"))
+        .map((f) => ({
+        fileName: f,
+        content: readFileSync(join(apiDir, f), "utf-8"),
+    }));
     const content = generateApiTs(endpointFiles);
     if (content) {
         const outDir = join("apps", appDir, ".zite");

package/dist/esm/sync/index.js

@@ -9,9 +9,7 @@ const DB_ENVIRONMENTS = {
     local: "http://localhost:2507/api/v1",
 };
 const env = process.env.ZITE_ENV ?? "production";
-const BASE_URL = process.env.ZITE_DB_URL ??
-    DB_ENVIRONMENTS[env] ??
-    DB_ENVIRONMENTS.production;
+const BASE_URL = process.env.ZITE_DB_URL ?? DB_ENVIRONMENTS[env] ?? DB_ENVIRONMENTS.production;
 const TOKEN = process.env.ZITE_DB_TOKEN ?? "";
 async function fetchDatabase(baseId) {
     const url = `${BASE_URL}/bases/${encodeURIComponent(baseId)}`;
@@ -70,7 +68,12 @@ export function regenerateApiTs() {
     const apiDir = join("src", "api");
     if (!existsSync(apiDir))
         return;
-    const endpointFiles = readdirSync(apiDir).filter((f) => f.endsWith(".ts") || f.endsWith(".js"));
+    const endpointFiles = readdirSync(apiDir)
+        .filter((f) => f.endsWith(".ts") || f.endsWith(".js"))
+        .map((f) => ({
+        fileName: f,
+        content: readFileSync(join(apiDir, f), "utf-8"),
+    }));
     const apiTs = generateApiTs(endpointFiles);
     if (apiTs) {
         mkdirSync(".zite", { recursive: true });

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

@@ -30,7 +30,11 @@ export declare function generateSchema(database: Database, existingSchema?: Zite
  * Pure function — no external data needed beyond what's in the schema file.
  */
 export declare function generateDbTs(schema: ZiteSchema): string;
-export declare function generateApiTs(endpointFiles: string[]): string | null;
+export type EndpointFileInfo = {
+    fileName: string;
+    content?: string;
+};
+export declare function generateApiTs(endpointFiles: (string | EndpointFileInfo)[]): string | null;
 export declare function generateUserTs(usersTableFields?: Array<{
     name: string;
     type: string;

package/dist/esm/sync/lib.js

@@ -1,3 +1,4 @@
+import { parse } from "@babel/parser";
 const FIELD_TYPE_MAP = {
     single_line_text: "string",
     long_text: "string",
@@ -258,36 +259,80 @@ export function generateDbTs(schema) {
     lines.push("");
     return lines.join("\n");
 }
+function detectStreamEnabled(source) {
+    try {
+        const ast = parse(source, {
+            sourceType: "module",
+            plugins: ["typescript"],
+        });
+        const defaultExport = ast.program.body.find((n) => n.type === "ExportDefaultDeclaration" &&
+            n.declaration.type === "CallExpression");
+        if (!defaultExport || defaultExport.type !== "ExportDefaultDeclaration")
+            return false;
+        const call = defaultExport.declaration;
+        if (call.type !== "CallExpression" || call.arguments.length === 0)
+            return false;
+        const arg = call.arguments[0];
+        if (arg.type !== "ObjectExpression")
+            return false;
+        const streamProp = arg.properties.find((p) => p.type === "ObjectProperty" &&
+            ((p.key.type === "Identifier" && p.key.name === "stream") ||
+                (p.key.type === "StringLiteral" && p.key.value === "stream")));
+        if (!streamProp || streamProp.type !== "ObjectProperty")
+            return false;
+        return (streamProp.value.type === "BooleanLiteral" &&
+            streamProp.value.value === true);
+    }
+    catch {
+        return false;
+    }
+}
 export function generateApiTs(endpointFiles) {
     if (!endpointFiles || endpointFiles.length === 0)
         return null;
+    const endpoints = [];
+    for (const file of endpointFiles) {
+        const fileName = typeof file === "string" ? file : file.fileName;
+        const content = typeof file === "string" ? undefined : file.content;
+        const name = fileName.replace(/\.(ts|js)$/, "");
+        const camelName = toCamelCase(name);
+        const pascal = toPascalCase(camelName);
+        const stream = content ? detectStreamEnabled(content) : false;
+        endpoints.push({ camelName, pascal, stream });
+    }
+    const hasStreaming = endpoints.some((e) => e.stream);
     const lines = [
         "// Auto-generated by zitejs sync. Do not edit manually.",
         "",
-        "import { createCaller } from 'zitejs/caller';",
+        hasStreaming
+            ? "import { createCaller, createStreamingCaller } from 'zitejs/caller';"
+            : "import { createCaller } from 'zitejs/caller';",
         "",
     ];
-    const endpointNames = [];
-    for (const file of endpointFiles) {
-        const name = file.replace(/\.(ts|js)$/, "");
-        const camelName = toCamelCase(name);
-        lines.push(`import ${camelName}Endpoint from '../src/api/${name}';`);
-        endpointNames.push(camelName);
-    }
-    lines.push("");
-    for (const name of endpointNames) {
-        lines.push(`export const ${name} = createCaller(${name}Endpoint, '${name}');`);
+    for (const { pascal, camelName } of endpoints) {
+        const name = camelName.replace(/([A-Z])/g, "-$1").toLowerCase();
+        const rawName = endpointFiles[endpoints.findIndex((e) => e.camelName === camelName)];
+        const fileName = typeof rawName === "string" ? rawName : rawName.fileName;
+        const baseName = fileName.replace(/\.(ts|js)$/, "");
+        lines.push(`import type { default as _${pascal}Ep } from '../src/api/${baseName}';`);
     }
     lines.push("");
-    for (const name of endpointNames) {
-        const pascal = toPascalCase(name);
-        lines.push(`export type ${pascal}InputType = Parameters<typeof ${name}Endpoint.execute>[0]['input'];`);
-        lines.push(`export type ${pascal}OutputType = Awaited<ReturnType<typeof ${name}Endpoint.execute>>;`);
+    for (const { camelName, pascal, stream } of endpoints) {
+        lines.push(`type _${pascal}Cfg = typeof _${pascal}Ep;`);
+        lines.push(`export type ${pascal}InputType = Parameters<_${pascal}Cfg['execute']>[0]['input'];`);
+        lines.push(`export type ${pascal}OutputType = Awaited<ReturnType<_${pascal}Cfg['execute']>>;`);
+        if (stream) {
+            lines.push(`export const ${camelName} = createStreamingCaller<${pascal}InputType, ${pascal}OutputType>('${camelName}');`);
+        }
+        else {
+            lines.push(`export const ${camelName} = createCaller<${pascal}InputType, ${pascal}OutputType>('${camelName}');`);
+        }
+        lines.push("");
     }
     lines.push("");
     lines.push("export const api = {");
-    for (const name of endpointNames) {
-        lines.push(`  ${name},`);
+    for (const { camelName } of endpoints) {
+        lines.push(`  ${camelName},`);
     }
     lines.push("};");
     lines.push("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.9.52",
+  "version": "0.9.54",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "main": "./dist/cjs/index.js",