zitejs 0.10.0-start.13 → 0.10.0-start.14

package/dist/cjs/internal/appMode.d.ts

@@ -0,0 +1,3 @@
+export declare const keepRenderedMode: (mode: string | undefined) => void;
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+export declare const platformMode: () => string | undefined;

package/dist/cjs/internal/appMode.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformMode = exports.keepRenderedMode = void 0;
+// Classic's upload client reads this too, so it imports nothing of Start: the
+// request's host comes through the key src/start/host.ts reads it under.
+const HOST_STORE_KEY = Symbol.for("zitejs:host-context");
+// What a Start page was rendered with, kept in the browser when it hydrates.
+const RENDERED_MODE = Symbol.for("zitejs:rendered-mode");
+const keepRenderedMode = (mode) => {
+    globalThis[RENDERED_MODE] = mode;
+};
+exports.keepRenderedMode = keepRenderedMode;
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+const platformMode = () => globalThis[HOST_STORE_KEY]?.getStore()?.mode ?? globalThis[RENDERED_MODE];
+exports.platformMode = platformMode;

package/dist/cjs/upload/index.js

@@ -6,6 +6,7 @@ exports.uploadFile = uploadFile;
 exports.useUpload = useUpload;
 const react_1 = require("react");
 const config_js_1 = require("../auth/config.js");
+const appMode_js_1 = require("../internal/appMode.js");
 const constants_js_1 = require("../auth/constants.js");
 class FileUploadError extends Error {
     constructor(message) {
@@ -14,7 +15,16 @@ class FileUploadError extends Error {
     }
 }
 exports.FileUploadError = FileUploadError;
-function getZiteAppMode(hostname) {
+/** As the platform served the page or request; a classic app's from its hostname. */
+function getZiteAppMode() {
+    const served = (0, appMode_js_1.platformMode)();
+    if (served)
+        return served === 'preview' || served === 'validate' ? 'preview' : 'live';
+    // On a server, outside any request the platform served: there's no telling a preview from live.
+    if (typeof window === 'undefined') {
+        throw new FileUploadError('Upload from a page, or from a request the platform is serving');
+    }
+    const { hostname } = window.location;
     const maybeId = hostname.split('.')[0];
     if (maybeId?.startsWith(constants_js_1.ZITE_APP_EDITOR_HOSTNAME_PREFIX))
         return 'preview';
@@ -82,7 +92,7 @@ function authHeaders() {
 }
 async function performUpload(data, filename) {
     const blob = toUploadBlob(data);
-    const mode = getZiteAppMode(window.location.hostname);
+    const mode = getZiteAppMode();
     const flowId = (0, config_js_1.getFlowId)();
     const sessionRes = await fetch((0, config_js_1.getApiUrl)() + '/v1/zite/public/' + flowId + '/upload-session?mode=' + mode, {
         method: 'POST',

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const vitest_1 = require("vitest");
+const node_async_hooks_1 = require("node:async_hooks");
+const appMode_js_1 = require("../internal/appMode.js");
 const index_js_1 = require("./index.js");
 vitest_1.vi.mock('../auth/config.js', () => ({
     getApiUrl: () => 'https://api.example.com',
@@ -93,3 +95,40 @@ const fetchMock = vitest_1.vi.fn();
         await (0, vitest_1.expect)(upload).rejects.toThrow('File size exceeds maximum of 20 MB');
     });
 });
+// SDK-10: a Start app's mode is the platform's, never guessed from where the page is served.
+(0, vitest_1.describe)('the mode an upload goes under', () => {
+    const sessionUrl = async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ success: true, presignedUrl: 'https://s3.example.com/put', fileUrl: 'https://uploads.zite.com/f.txt' }),
+        });
+        fetchMock.mockResolvedValueOnce({ ok: true });
+        await (0, index_js_1.uploadFile)({ data: 'hi', filename: 'f.txt' });
+        return String(fetchMock.mock.calls[0][0]);
+    };
+    (0, vitest_1.afterEach)(() => (0, appMode_js_1.keepRenderedMode)(undefined));
+    (0, vitest_1.it)('is the one the page was rendered in, on any host', async () => {
+        (0, appMode_js_1.keepRenderedMode)('preview');
+        (0, vitest_1.expect)(await sessionUrl()).toContain('mode=preview');
+    });
+    (0, vitest_1.it)("is the request's own on the server, where there's no page", async () => {
+        vitest_1.vi.stubGlobal('window', undefined);
+        const store = new node_async_hooks_1.AsyncLocalStorage();
+        globalThis[Symbol.for('zitejs:host-context')] = store;
+        try {
+            (0, vitest_1.expect)(await store.run({ mode: 'validate' }, sessionUrl)).toContain('mode=preview');
+        }
+        finally {
+            delete globalThis[Symbol.for('zitejs:host-context')];
+        }
+    });
+    (0, vitest_1.it)('is refused on a server outside any request the platform served, never guessed as live', async () => {
+        vitest_1.vi.stubGlobal('window', undefined);
+        await (0, vitest_1.expect)((0, index_js_1.uploadFile)({ data: 'hi', filename: 'f.txt' })).rejects.toThrow(index_js_1.FileUploadError);
+        (0, vitest_1.expect)(fetchMock).not.toHaveBeenCalled();
+    });
+    (0, vitest_1.it)("is a classic app's from its hostname, as before", async () => {
+        vitest_1.vi.stubGlobal('window', { location: { hostname: 'zite-editor-app_123.zite.so' } });
+        (0, vitest_1.expect)(await sessionUrl()).toContain('mode=preview');
+    });
+});

package/dist/esm/internal/appMode.d.ts

@@ -0,0 +1,3 @@
+export declare const keepRenderedMode: (mode: string | undefined) => void;
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+export declare const platformMode: () => string | undefined;

package/dist/esm/internal/appMode.js

@@ -0,0 +1,10 @@
+// Classic's upload client reads this too, so it imports nothing of Start: the
+// request's host comes through the key src/start/host.ts reads it under.
+const HOST_STORE_KEY = Symbol.for("zitejs:host-context");
+// What a Start page was rendered with, kept in the browser when it hydrates.
+const RENDERED_MODE = Symbol.for("zitejs:rendered-mode");
+export const keepRenderedMode = (mode) => {
+    globalThis[RENDERED_MODE] = mode;
+};
+/** The mode the platform served this request or page in; undefined outside a Start app. */
+export const platformMode = () => globalThis[HOST_STORE_KEY]?.getStore()?.mode ?? globalThis[RENDERED_MODE];

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

@@ -1,6 +1,6 @@
 import { type AirtableSettings } from "./dispatch.js";
 import type { PlatformSession, ZiteRequestContext } from "../types.js";
-/** The build's Airtable integration `integrationId`, or undefined when it isn't one, or the host can't say. */
+/** The build's Airtable integration `integrationId`, or undefined when it isn't one. */
 export declare const airtableSettingsOf: (session: PlatformSession, integrationId: string) => Promise<AirtableSettings | undefined>;
 /** One generated Airtable table call, run here with the connection's token, which the outbound fetch refreshes on a 401. */
 export declare function runAirtableCall(host: ZiteRequestContext, session: PlatformSession, integrationId: string, settings: AirtableSettings, methodName: string, params: unknown, access: "signedIn" | "anyone" | "webhook" | "workflow"): Promise<unknown>;

package/dist/esm/start/airtable/index.js

@@ -5,44 +5,29 @@ import { rememberConnection } from "../outbound.js";
 const AIRTABLE_API = "https://api.airtable.com";
 // A build's integrations don't change, so per isolate: only answers, never a pending call.
 const settingsHeld = new Map();
-let unsupported = false;
-const NOT_IMPLEMENTED = /does not implement (?:the )?method/i;
-/** The build's Airtable integration `integrationId`, or undefined when it isn't one, or the host can't say. */
+/** The build's Airtable integration `integrationId`, or undefined when it isn't one. */
 export const airtableSettingsOf = async (session, integrationId) => {
-    if (unsupported || !session.integrationSettings)
-        return undefined;
     if (settingsHeld.has(integrationId))
         return settingsHeld.get(integrationId) ?? undefined;
-    try {
-        const answer = await session.integrationSettings(integrationId);
-        const settings = answer?.serviceType === "airtable" && typeof answer.baseId === "string"
-            ? { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null }
-            : null;
-        settingsHeld.set(integrationId, settings);
-        return settings ?? undefined;
-    }
-    catch (error) {
-        if (error instanceof Error && NOT_IMPLEMENTED.test(error.message)) {
-            unsupported = true;
-            return undefined;
-        }
-        throw error;
-    }
+    const answer = await session.integrationSettings(integrationId);
+    const settings = answer?.serviceType === "airtable" && typeof answer.baseId === "string"
+        ? { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null }
+        : null;
+    settingsHeld.set(integrationId, settings);
+    return settings ?? undefined;
 };
 /** One generated Airtable table call, run here with the connection's token, which the outbound fetch refreshes on a 401. */
 export async function runAirtableCall(host, session, integrationId, settings, methodName, params, access) {
     // As classic: a demo reaches no connected account.
     if (host.mode === "demo")
         throw new ZiteError("FORBIDDEN", "This action is not available in demo mode");
-    const connection = host.credentials
-        ? await host.credentials.get(integrationId)
-        : await session.call({
-            integrationId: INTEGRATIONS_PLATFORM_ID,
-            className: "Connections",
-            methodName: "get",
-            params: { name: integrationId },
-            access,
-        });
+    const connection = await session.call({
+        integrationId: INTEGRATIONS_PLATFORM_ID,
+        className: "Connections",
+        methodName: "get",
+        params: { name: integrationId },
+        access,
+    });
     if ("error" in connection) {
         const { code, message, userFacingMessage } = connection.error;
         throw new ZiteError({ code: isZiteErrorCode(code) ? code : "INTERNAL_ERROR", message, userFacingMessage });
@@ -66,5 +51,4 @@ export async function runAirtableCall(host, session, integrationId, settings, me
 /** For tests: forget what this isolate learned. */
 export const resetAirtableSettings = () => {
     settingsHeld.clear();
-    unsupported = false;
 };

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

@@ -1,19 +1,2 @@
-/**
- * Where `integrations.get` reads a connection. In Zite's cloud the host
- * answers it on the request's session; an app run elsewhere names its own
- * source in its server entry: memory or the environment here, a shared cache
- * once one exists.
- */
-import type { PlatformCallInput, PlatformCallResult, PlatformSession } from "./types.js";
-export type CredentialSource = {
-    get(name: string): Promise<PlatformCallResult>;
-    /** After a provider answered 401: the connection refreshed, where the source can. */
-    refresh?(name: string): Promise<PlatformCallResult>;
-};
+/** The platform id `integrations.get` is answered under. */
 export declare const INTEGRATIONS_PLATFORM_ID = "__connections__";
-/** The host's, on the request's session. */
-export declare const sessionCredentials: (session: PlatformSession, access: PlatformCallInput["access"]) => CredentialSource;
-/** Connections held in memory, by name, as `integrations.get` answers them; `refresh` fetches one anew. */
-export declare const memoryCredentials: (connections: Record<string, unknown>, refresh?: (name: string) => Promise<unknown>) => CredentialSource;
-/** Connections from `ZITE_CONNECTIONS`, JSON by name, for an app run outside Zite. */
-export declare const envCredentials: (env?: Record<string, string | undefined>) => CredentialSource;

package/dist/esm/start/credentials.js

@@ -1,30 +1,2 @@
-/**
- * Where `integrations.get` reads a connection. In Zite's cloud the host
- * answers it on the request's session; an app run elsewhere names its own
- * source in its server entry: memory or the environment here, a shared cache
- * once one exists.
- */
+/** The platform id `integrations.get` is answered under. */
 export const INTEGRATIONS_PLATFORM_ID = "__connections__";
-/** The host's, on the request's session. */
-export const sessionCredentials = (session, access) => ({
-    get: (name) => session.call({ integrationId: INTEGRATIONS_PLATFORM_ID, className: "Connections", methodName: "get", params: { name }, access }),
-    ...(session.refreshConnection && { refresh: (name) => session.refreshConnection(name) }),
-});
-const notFound = (name) => ({
-    error: { code: "BAD_REQUEST", message: `Integration ${name} not found` },
-});
-/** Connections held in memory, by name, as `integrations.get` answers them; `refresh` fetches one anew. */
-export const memoryCredentials = (connections, refresh) => ({
-    get: async (name) => (Object.hasOwn(connections, name) ? { value: connections[name] } : notFound(name)),
-    ...(refresh && {
-        refresh: async (name) => {
-            const fresh = await refresh(name);
-            if (fresh === undefined)
-                return notFound(name);
-            connections[name] = fresh;
-            return { value: fresh };
-        },
-    }),
-});
-/** Connections from `ZITE_CONNECTIONS`, JSON by name, for an app run outside Zite. */
-export const envCredentials = (env = process.env) => memoryCredentials(JSON.parse(env.ZITE_CONNECTIONS ?? "{}"));

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

@@ -6,11 +6,8 @@ type Found = {
     baseId: string | null;
     nameMappings: DataNameMappings | null;
 };
-/**
- * The build's data context, or undefined from a host that predates the app's own
- * dispatch, whose `databases` platform call still answers.
- */
-export declare const dataContextOf: (session: PlatformSession) => Promise<Found | undefined>;
+/** The build's base and SDK names, asked of the platform once per isolate. */
+export declare const dataContextOf: (session: PlatformSession) => Promise<Found>;
 /** One `zite.*` call, translated here and sent to base-runner through the platform. */
 export declare function runDataCall(session: PlatformSession, found: Found, mode: HostMode, methodName: string, sent: unknown): Promise<unknown>;
 /** For tests: forget what this isolate learned. */

package/dist/esm/start/data/index.js

@@ -8,7 +8,6 @@ const TABLES_REUSE_MS = 60_000;
 // Only answers are kept, never a pending call: one request's RPC session mustn't hold up another's.
 let context;
 let tables;
-let unsupported = false;
 const tablesOf = async (baseRunner, baseId) => {
     if (tables?.baseId === baseId && Date.now() - tables.at < TABLES_REUSE_MS)
         return tables.tables;
@@ -16,29 +15,13 @@ const tablesOf = async (baseRunner, baseId) => {
     tables = { baseId, tables: base.tables, at: Date.now() };
     return base.tables;
 };
-// What Workers RPC throws for a method the host doesn't have yet.
-const NOT_IMPLEMENTED = /does not implement (?:the )?method/i;
-/**
- * The build's data context, or undefined from a host that predates the app's own
- * dispatch, whose `databases` platform call still answers.
- */
+/** The build's base and SDK names, asked of the platform once per isolate. */
 export const dataContextOf = async (session) => {
-    if (unsupported || !session.dataContext || !session.dataFetch)
-        return undefined;
     if (context)
         return context;
-    try {
-        const answer = await session.dataContext();
-        context = { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null };
-        return context;
-    }
-    catch (error) {
-        if (error instanceof Error && NOT_IMPLEMENTED.test(error.message)) {
-            unsupported = true;
-            return undefined;
-        }
-        throw error;
-    }
+    const answer = await session.dataContext();
+    context = { baseId: answer.baseId, nameMappings: answer.nameMappings ?? null };
+    return context;
 };
 /**
  * The table id classic's generated client sends: its SDK name mapped through the
@@ -72,5 +55,4 @@ export async function runDataCall(session, found, mode, methodName, sent) {
 export const resetDataDispatch = () => {
     context = undefined;
     tables = undefined;
-    unsupported = false;
 };

package/dist/esm/start/outbound.js

@@ -6,7 +6,6 @@
  * host over the app's platform binding.
  */
 import { AI_USAGE_HOSTS, meterAiResponse, withStreamUsage } from "./aiUsage.js";
-import { sessionCredentials } from "./credentials.js";
 import { REDACTED, redactKnown, secretForms } from "./redactSecrets.js";
 import { getHost } from "./scope.js";
 const MAX_FETCHES = 500;
@@ -227,12 +226,6 @@ const sessionOf = async (host) => {
     host.session ??= Promise.resolve(host.watch ? host.platform.session(host.watch) : host.platform.session());
     return host.session;
 };
-const credentialsOf = async (host) => {
-    if (host.credentials)
-        return host.credentials;
-    const session = await sessionOf(host);
-    return session && sessionCredentials(session, "anyone");
-};
 /** The token to send instead of `token`, refreshed once per connection per request. */
 const freshToken = async (host, token, connection) => {
     const known = replacements.get(token);
@@ -242,8 +235,8 @@ const freshToken = async (host, token, connection) => {
     let pending = refreshing.get(connection);
     if (!pending) {
         pending = (async () => {
-            const source = await credentialsOf(host);
-            const result = source?.refresh ? await source.refresh(connection) : undefined;
+            const session = await sessionOf(host);
+            const result = session ? await session.refreshConnection(connection) : undefined;
             if (!result || !("value" in result))
                 return undefined;
             const fresh = result.value;
@@ -351,7 +344,7 @@ export const createOutboundFetch = (nativeFetch) => async (input, init) => {
     if (ai) {
         try {
             const session = await sessionOf(host);
-            if (!session?.aiFetch) {
+            if (!session) {
                 const refused = aiUnavailable();
                 record({ status: refused.status });
                 return refused;

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

@@ -1,6 +1,6 @@
 import { QueryClient } from "@tanstack/react-query";
 import { type AnyRoute, type RouterConstructorOptions, type RouterHistory } from "@tanstack/react-router";
-import type { User } from "./types.js";
+import type { HostMode, User } from "./types.js";
 export declare const QUERY_STALE_TIME_MS = 30000;
 /** The router context every Zite app's root route declares: `createRootRouteWithContext<ZiteRouterContext>()`. */
 export type ZiteRouterContext = {
@@ -9,7 +9,12 @@ export type ZiteRouterContext = {
 };
 type Dehydrated = {
     user: User | null;
+    mode?: HostMode;
 };
+/** @internal What a page carries to the browser beside its queries: the signed-in user, and the mode it was served in. */
+export declare const dehydrateZite: (context: ZiteRouterContext) => Dehydrated;
+/** @internal Takes in what the page carried. */
+export declare const hydrateZite: (context: ZiteRouterContext, dehydrated: Dehydrated) => void;
 type ZiteRouterOptions<TRouteTree extends AnyRoute> = Omit<RouterConstructorOptions<TRouteTree, "never", false, RouterHistory, Dehydrated>, "context" | "dehydrate" | "hydrate">;
 /**
  * @internal Tells the editor's preview the page crashed, as classic's runtime reports an emptied #root: a Start page

package/dist/esm/start/router.js

@@ -5,8 +5,16 @@ import { setupRouterSsrQueryIntegration } from "@tanstack/react-router-ssr-query
 import { isSignInError, toClientError } from "./errors.js";
 import { carryPreviewClaim, PREVIEW_CLAIM_PARAM, previewClaim } from "./previewClaim.js";
 import { currentHost } from "./host.js";
+import { keepRenderedMode } from "../internal/appMode.js";
 // Long enough that a page's queries don't refetch as the browser picks it up, short enough to stay fresh.
 export const QUERY_STALE_TIME_MS = 30_000;
+/** @internal What a page carries to the browser beside its queries: the signed-in user, and the mode it was served in. */
+export const dehydrateZite = (context) => ({ user: context.user, mode: currentHost()?.mode });
+/** @internal Takes in what the page carried. */
+export const hydrateZite = (context, dehydrated) => {
+    context.user = dehydrated.user;
+    keepRenderedMode(dehydrated.mode);
+};
 const ziteWindow = () => (typeof window === "undefined" ? undefined : window);
 const box = { maxWidth: 480, margin: "15vh auto", padding: 24, fontFamily: "system-ui, sans-serif", textAlign: "center" };
 /**
@@ -97,10 +105,8 @@ export function createZiteRouter(options) {
             options.defaultOnCatch?.(error, info);
         },
         context,
-        dehydrate: () => ({ user: context.user }),
-        hydrate: (dehydrated) => {
-            context.user = dehydrated.user;
-        },
+        dehydrate: () => dehydrateZite(context),
+        hydrate: (dehydrated) => hydrateZite(context, dehydrated),
     });
     setupRouterSsrQueryIntegration({ router, queryClient });
     const mark = watchReady(router);

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

@@ -1,4 +1,3 @@
-import { type CredentialSource } from "./credentials.js";
 import type { HostProps, PlatformBinding, RenderWatch, ZiteRequestContext } from "./types.js";
 export { runWithHost } from "./scope.js";
 export { describeApp } from "./describe.js";
@@ -36,12 +35,10 @@ export type ZiteServerOptions = {
     };
     getRouter: () => unknown;
     platform?: PlatformBinding;
-    /** The app's start instance, which a test run of a server function runs under. Entries before 0.10.0-start.11 don't pass it. */
-    startInstance?: {
+    /** The app's start instance, which a test run of a server function runs under. */
+    startInstance: {
         getOptions: () => unknown;
     };
-    /** Where `integrations.get` reads outside Zite; the host's requests always read the host. */
-    credentials?: CredentialSource;
 };
 type HostedContext = WorkerContext & {
     props?: Partial<HostProps>;

package/dist/esm/start/server.js

@@ -29,9 +29,6 @@ export function installPlatformTransport() {
         const host = getHost();
         const getsConnection = integrationId === INTEGRATIONS_PLATFORM_ID && methodName === "get";
         const name = String(params?.name ?? "");
-        // An app run outside Zite reads its connections from its own source, with no platform at all.
-        if (getsConnection && host?.credentials)
-            return connectionAnswer(host, name, await host.credentials.get(name));
         // Fails closed: no platform means no platform access, never a fallback.
         if (!host?.platform)
             throw new Error("The Zite platform binding is missing");
@@ -39,11 +36,9 @@ export function installPlatformTransport() {
         const session = await host.session;
         if (integrationId === DATA_INTEGRATION_ID) {
             const found = await dataContextOf(session);
-            if (found) {
-                return recordCall(host, { integrationId, className, methodName, params }, () => runDataCall(session, found, host.mode, methodName, params));
-            }
+            return recordCall(host, { integrationId, className, methodName, params }, () => runDataCall(session, found, host.mode, methodName, params));
         }
-        else if (!integrationId.startsWith("__")) {
+        if (!integrationId.startsWith("__")) {
             const airtable = await airtableSettingsOf(session, integrationId);
             if (airtable) {
                 return recordCall(host, { integrationId, className, methodName, params }, () => runAirtableCall(host, session, integrationId, airtable, methodName, params, scope.kind));
@@ -231,7 +226,7 @@ async function invokeFunction(request, options) {
     const startContext = {
         request,
         getRouter: options.getRouter,
-        startOptions: (await options.startInstance?.getOptions()) ?? {},
+        startOptions: (await options.startInstance.getOptions()) ?? {},
         executedRequestMiddlewares: new Set(),
         contextAfterGlobalMiddlewares: {},
         handlerType: "serverFn",
@@ -306,7 +301,7 @@ export function createZiteHandlers(options) {
     const serve = async (request, ctx, watch) => {
         const host = ctx?.props?.platform
             ? hostContextFromProps(request, ctx.props)
-            : { ...hostContextFromRequest(request, options.platform), credentials: options.credentials };
+            : hostContextFromRequest(request, options.platform);
         if (watch)
             host.watch = watch;
         setRequestEnv(host);
@@ -354,7 +349,7 @@ export function createZiteHandlers(options) {
                 if (host.fetches?.length)
                     host.session ??= Promise.resolve(platform.session());
                 const session = host.session ? await host.session : undefined;
-                await (session?.runs ? session.runs(batch) : platform.runs(batch));
+                await (session ? session.runs(batch) : platform.runs(batch));
             })().catch((error) => {
                 console.error("[zite] couldn't record runs", error);
             });

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

@@ -1,5 +1,4 @@
 import type { AiUsageRecord } from "./aiUsage.js";
-import type { CredentialSource } from "./credentials.js";
 export type Role = {
     id: string;
     name: string;
@@ -99,29 +98,29 @@ export type FetchRecord = {
 };
 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; before 0.10.0-start.13, `fetches`. */
-    runs?(batch: {
+    /** As `PlatformBinding.runs`, on a session the request already holds, with its data calls and fetches. */
+    runs(batch: {
         runs: RunRecord[];
         calls?: CallRecord[];
         fetches?: FetchRecord[];
     }): Promise<void>;
-    /** After a provider answered 401: the connection refreshed, as `integrations.get` now answers it. Hosts before 0.10.0-start.13 lack it. */
-    refreshConnection?(name: string): Promise<PlatformCallResult>;
-    /** A call on Zite's own AI key, which the host makes with the real key. Hosts before 0.10.0-start.13 lack it. */
-    aiFetch?(request: Request): Promise<Response>;
+    /** After a provider answered 401: the connection refreshed, as `integrations.get` now answers it. */
+    refreshConnection(name: string): Promise<PlatformCallResult>;
+    /** A call on Zite's own AI key, which the host makes with the real key. */
+    aiFetch(request: Request): Promise<Response>;
     /** The build's base and SDK names, which the app's data dispatch translates against. */
-    dataContext?(): Promise<{
+    dataContext(): Promise<{
         baseId: string | null;
         nameMappings: unknown;
     }>;
     /** One base-runner request; the host holds it to the build's base and adds the key and acting user. */
-    dataFetch?(request: {
+    dataFetch(request: {
         method: string;
         path: string;
         body?: string;
     }): Promise<Response>;
     /** An integration's settings as the build declares them; null for one it doesn't, or that runs on the platform. */
-    integrationSettings?(integrationId: string): Promise<{
+    integrationSettings(integrationId: string): Promise<{
         serviceType: string;
         baseId?: string;
         nameMappings?: unknown;
@@ -156,7 +155,7 @@ export type HostProps = {
     user: User | null;
     mode: HostMode;
     invoke: HostInvoke | null;
-    /** The app's live URL, demo included: `process.env.ZITE_APP_URL`. Hosts before 0.10.0-start.7 don't send it. */
+    /** The app's live URL, demo included: `process.env.ZITE_APP_URL`. */
     appUrl?: string;
     /** The app's database: `process.env.ZITE_BASE_ID`. */
     baseId?: string;
@@ -164,9 +163,9 @@ export type HostProps = {
     previewClaim?: string;
     /** `process.env` as classic sets it: connections' vars, then the user's own secrets. */
     env?: Record<string, string>;
-    /** Which connection each token var in `env` holds. Hosts before 0.10.0-start.13 don't send it. */
+    /** Which connection each token var in `env` holds. */
     envConnections?: Record<string, string>;
-    /** A resumed run's first attempt, whose saved steps it replays. Hosts before 0.10.0-start.10 don't send it. */
+    /** A resumed run's first attempt, whose saved steps it replays. */
     runRoot?: string;
 };
 /** What the host resolved for this request. Set by the generated server entry, never by the browser. */
@@ -184,8 +183,6 @@ export type ZiteRequestContext = {
     envConnections?: Record<string, string>;
     /** A resumed run's first attempt, whose saved steps it replays. */
     runRoot?: string;
-    /** Where `integrations.get` reads, when not the host: an entry run outside Zite's names its own. */
-    credentials?: CredentialSource;
     /** The connection each token this request was handed belongs to. */
     connectionTokens?: Map<string, string>;
     /** `integrations.get`'s answers this request, by name. */

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

@@ -1 +1 @@
-export declare const ZITEJS_VERSION = "0.10.0-start.13";
+export declare const ZITEJS_VERSION = "0.10.0-start.14";

package/dist/esm/start/version.js

@@ -1,2 +1,2 @@
 // Written by scripts/write-version.mjs from package.json.
-export const ZITEJS_VERSION = "0.10.0-start.13";
+export const ZITEJS_VERSION = "0.10.0-start.14";

package/dist/esm/upload/index.js

@@ -1,5 +1,6 @@
 import { useCallback, useState } from 'react';
 import { getApiUrl, getFlowId } from '../auth/config.js';
+import { platformMode } from '../internal/appMode.js';
 import { ZITE_APP_ACTION_HOSTNAME_PREFIX, ZITE_APP_EDITOR_HOSTNAME_PREFIX, ZITE_SANDBOX_DOMAINS, } from '../auth/constants.js';
 export class FileUploadError extends Error {
     constructor(message) {
@@ -7,7 +8,16 @@ export class FileUploadError extends Error {
         this.name = 'FileUploadError';
     }
 }
-function getZiteAppMode(hostname) {
+/** As the platform served the page or request; a classic app's from its hostname. */
+function getZiteAppMode() {
+    const served = platformMode();
+    if (served)
+        return served === 'preview' || served === 'validate' ? 'preview' : 'live';
+    // On a server, outside any request the platform served: there's no telling a preview from live.
+    if (typeof window === 'undefined') {
+        throw new FileUploadError('Upload from a page, or from a request the platform is serving');
+    }
+    const { hostname } = window.location;
     const maybeId = hostname.split('.')[0];
     if (maybeId?.startsWith(ZITE_APP_EDITOR_HOSTNAME_PREFIX))
         return 'preview';
@@ -75,7 +85,7 @@ function authHeaders() {
 }
 async function performUpload(data, filename) {
     const blob = toUploadBlob(data);
-    const mode = getZiteAppMode(window.location.hostname);
+    const mode = getZiteAppMode();
     const flowId = getFlowId();
     const sessionRes = await fetch(getApiUrl() + '/v1/zite/public/' + flowId + '/upload-session?mode=' + mode, {
         method: 'POST',

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

@@ -1,4 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { keepRenderedMode } from '../internal/appMode.js';
 import { FileUploadError, toUploadBlob, uploadFile } from './index.js';
 vi.mock('../auth/config.js', () => ({
     getApiUrl: () => 'https://api.example.com',
@@ -91,3 +93,40 @@ describe('uploadFile', () => {
         await expect(upload).rejects.toThrow('File size exceeds maximum of 20 MB');
     });
 });
+// SDK-10: a Start app's mode is the platform's, never guessed from where the page is served.
+describe('the mode an upload goes under', () => {
+    const sessionUrl = async () => {
+        fetchMock.mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ success: true, presignedUrl: 'https://s3.example.com/put', fileUrl: 'https://uploads.zite.com/f.txt' }),
+        });
+        fetchMock.mockResolvedValueOnce({ ok: true });
+        await uploadFile({ data: 'hi', filename: 'f.txt' });
+        return String(fetchMock.mock.calls[0][0]);
+    };
+    afterEach(() => keepRenderedMode(undefined));
+    it('is the one the page was rendered in, on any host', async () => {
+        keepRenderedMode('preview');
+        expect(await sessionUrl()).toContain('mode=preview');
+    });
+    it("is the request's own on the server, where there's no page", async () => {
+        vi.stubGlobal('window', undefined);
+        const store = new AsyncLocalStorage();
+        globalThis[Symbol.for('zitejs:host-context')] = store;
+        try {
+            expect(await store.run({ mode: 'validate' }, sessionUrl)).toContain('mode=preview');
+        }
+        finally {
+            delete globalThis[Symbol.for('zitejs:host-context')];
+        }
+    });
+    it('is refused on a server outside any request the platform served, never guessed as live', async () => {
+        vi.stubGlobal('window', undefined);
+        await expect(uploadFile({ data: 'hi', filename: 'f.txt' })).rejects.toThrow(FileUploadError);
+        expect(fetchMock).not.toHaveBeenCalled();
+    });
+    it("is a classic app's from its hostname, as before", async () => {
+        vi.stubGlobal('window', { location: { hostname: 'zite-editor-app_123.zite.so' } });
+        expect(await sessionUrl()).toContain('mode=preview');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zitejs",
-  "version": "0.10.0-start.13",
+  "version": "0.10.0-start.14",
   "description": "The Zite framework — build apps on Zite Database",
   "type": "module",
   "sideEffects": false,