@every-app/sdk 0.3.0-rc.1 → 0.3.0-rc.11

package/dist/cloudflare/sentinel.js

@@ -16,18 +16,40 @@ export const BUILD_SENTINEL = Object.freeze({
     // and a string rewrite of it can't hit anything else.
     workerName: "every-hosted--sentinel",
     organizationId: "everyapp-hosted-deploy-sentinel",
+    /**
+     * The Cloudflare account the app is installed in (an AI Gateway's URL
+     * holds it). Starts with the Worker name's placeholder, so an install
+     * rewrites it before that one.
+     */
+    accountId: "every-hosted--sentinel-account",
     /** The gateway's URL, and so the identity issuer. */
     gatewayUrl: "https://every-hosted--sentinel.invalid",
     publicKey: "-----BEGIN PUBLIC KEY-----\nEVERYAPPHOSTEDDEPLOYSENTINEL\n-----END PUBLIC KEY-----\n",
 });
+/** Runtime-independent resource names used by both release installers. */
+export function helperWorkerName(appWorker, helper) {
+    const name = `${appWorker}--${helper}`;
+    if (name.length > 63)
+        throw new Error(`Helper Worker ${name} is longer than Cloudflare's 63 characters; shorten its name in everyapp.config.ts.`);
+    return name;
+}
+export function workflowNameFor(workerName, binding) {
+    return `${workerName}--${binding.toLowerCase().replaceAll("_", "-")}`;
+}
 /**
  * A manifest binding's placeholder: a D1 database's name and id, an R2
- * bucket's name, a KV namespace's or Hyperdrive config's id. The installer
- * rewrites each by its binding name; the value only has to be recognizable.
+ * bucket's, queue's or Vectorize index's name, a KV namespace's, Hyperdrive
+ * config's or AI Gateway's id, a Secrets Store secret's store id and name.
+ * The installer rewrites each by its binding name; the value only has to
+ * be recognizable.
  */
 export function resourceSentinel(binding) {
     return `${BUILD_SENTINEL.workerName}--${binding}`;
 }
+/** Where an AI Gateway takes requests: `https://gateway.ai.cloudflare.com/v1/<account>/<id>`. */
+export function aiGatewayUrl(accountId, id) {
+    return `https://gateway.ai.cloudflare.com/v1/${accountId}/${id}`;
+}
 /** The target every production build is made for: placeholders throughout. */
 export function sentinelDeployTarget(manifest) {
     const byBinding = (bindings, value) => Object.fromEntries((bindings ?? []).map((binding) => [
@@ -38,6 +60,7 @@ export function sentinelDeployTarget(manifest) {
     return {
         workerName: BUILD_SENTINEL.workerName,
         organizationId: BUILD_SENTINEL.organizationId,
+        accountId: BUILD_SENTINEL.accountId,
         gatewayUrl: BUILD_SENTINEL.gatewayUrl,
         identityPublicKeys: [BUILD_SENTINEL.publicKey],
         resources: {
@@ -45,6 +68,18 @@ export function sentinelDeployTarget(manifest) {
             kv: byBinding(resources?.kv, (id) => ({ id })),
             hyperdrive: byBinding(resources?.hyperdrive?.map((config) => config.name), (id) => ({ id })),
             r2: byBinding(resources?.r2, (name) => ({ name })),
+            ...(resources?.queues?.length
+                ? {
+                    queues: byBinding(resources.queues.map((queue) => queue.name), (name) => ({ name, id: name })),
+                }
+                : {}),
+            vectorize: byBinding(resources?.vectorize?.map((index) => index.name), (name) => ({ name })),
+            aiGateway: byBinding(resources?.aiGateway?.map((gateway) => gateway.name), (id) => ({
+                id,
+                accountId: BUILD_SENTINEL.accountId,
+                url: aiGatewayUrl(BUILD_SENTINEL.accountId, id),
+            })),
+            secretsStore: byBinding(resources?.secretsStore?.map((secret) => secret.name), (placeholder) => ({ storeId: placeholder, secretName: placeholder })),
         },
     };
 }

package/dist/cloudflare/worker.d.ts

@@ -1,3 +1,6 @@
+import { DEV_GATEWAY_KEYS } from "./catalogSettings.generated.js";
+import { type AiGatewayValue } from "./sentinel.js";
+export { helperWorkerName, workflowNameFor } from "./sentinel.js";
 /** A Durable Object or Workflow class, and the helper Worker defining it. */
 interface ClassResource {
     readonly name: string;
@@ -13,6 +16,62 @@ interface HyperdriveResource {
     /** Whether Hyperdrive caches its reads (the deploy's concern; "off" by default). */
     readonly caching?: "off" | "default";
 }
+/**
+ * How a queue's consumer takes its messages (`@cloudflare/config`'s
+ * `QueueConsumerTriggerOptions` but the name), and the helper Worker that
+ * consumes, when not the app's own.
+ */
+interface QueueConsumerSettings {
+    /** A helper Worker (`workers`) that consumes; the app's own when unset. */
+    readonly worker?: string;
+    readonly maxBatchSize?: number;
+    readonly maxBatchTimeout?: number;
+    readonly maxRetries?: number;
+    readonly maxConcurrency?: number | null;
+    readonly retryDelay?: number;
+    readonly visibilityTimeoutMs?: number;
+    /** Another of the manifest's queue bindings, which takes the messages that ran out of retries. */
+    readonly deadLetterQueue?: string;
+}
+/** A queue every Worker of the app produces to, and the Worker that consumes it. */
+interface QueueResource {
+    readonly name: string;
+    /** `true`: the app's own Worker consumes; settings, maybe naming a helper Worker. */
+    readonly consumer?: true | QueueConsumerSettings;
+}
+/**
+ * A Vectorize index: `dimensions` and `metric`, or a `preset` (the
+ * deploy's concern; the Worker only binds it by name).
+ */
+interface VectorizeResource {
+    readonly name: string;
+    readonly dimensions?: number;
+    readonly metric?: string;
+    readonly preset?: string;
+}
+/** An AI Gateway of the app's own, which every one of its Workers binds. */
+interface AiGatewayResource {
+    readonly name: string;
+    /** Whether the gateway logs each request (the deploy's concern; on by default). */
+    readonly collectLogs?: boolean;
+    /** How long the gateway caches a response, in seconds (the deploy's concern; 0 by default). */
+    readonly cacheTtl?: number;
+}
+/**
+ * A Cloudflare `send_email` binding and the addresses it may use: the
+ * senders, and one destination or a list of them (never both).
+ */
+interface SendEmailResource {
+    readonly name: string;
+    readonly allowedSenderAddresses?: readonly string[];
+    readonly destinationAddress?: string;
+    readonly allowedDestinationAddresses?: readonly string[];
+}
+/** An Analytics Engine dataset, by binding, and its name when not the default. */
+interface AnalyticsEngineResource {
+    readonly name: string;
+    readonly dataset?: string;
+}
 /** Cloudflare's limits for one of the app's Workers. */
 interface WorkerLimits {
     readonly cpuMs?: number;
@@ -33,6 +92,74 @@ export interface EveryAppWorkerManifest {
         workflows?: readonly ClassResource[];
         /** Hyperdrive configs, named `<app worker>--<binding>` by the deploy. */
         hyperdrive?: readonly HyperdriveResource[];
+        /**
+         * Cloudflare Queues, named `<app worker>--<binding>`: every Worker of
+         * the app binds each one to produce, and the consumer's Worker gets
+         * its trigger.
+         */
+        queues?: readonly QueueResource[];
+        /**
+         * Workers AI, by binding (`["AI"]`), which every one of the app's
+         * Workers binds: nothing to create, billed to the account. In
+         * development it reaches the account only once the app's Vite config
+         * turns `remoteBindings` on (see {@link AiBinding}).
+         */
+        ai?: readonly string[];
+        /**
+         * Browser Rendering, by binding (`["BROWSER"]`), which every one of the
+         * app's Workers binds: nothing to create (Workers Paid). Local in
+         * development (see {@link BrowserBinding}).
+         */
+        browser?: readonly string[];
+        /**
+         * Cloudflare Images, by binding (`["IMAGES"]`), which every one of the
+         * app's Workers binds: nothing to create. Local in development (see
+         * {@link ImagesBinding}).
+         */
+        images?: readonly string[];
+        /**
+         * Vectorize indexes every one of the app's Workers binds, named
+         * `<app worker>--<binding>`. Cloudflare has no local Vectorize: in
+         * development each binding reaches the account's index (`dev.remote`),
+         * once the Vite plugin's `remoteBindings` is on and `cf auth login` ran.
+         */
+        vectorize?: readonly VectorizeResource[];
+        /**
+         * AI Gateways of the app's own, each `<app worker>-<binding>` in the
+         * account, bound on every Worker as `{ id, accountId, url }`.
+         */
+        aiGateway?: readonly AiGatewayResource[];
+        /**
+         * Cloudflare `send_email` bindings every one of the app's Workers
+         * gets, with their addresses; nothing is made in the account.
+         */
+        sendEmail?: readonly SendEmailResource[];
+        /**
+         * Secrets Store secrets, by binding (`[{ name: "STRIPE_KEY" }]`), which
+         * every one of the app's Workers binds: each a secret in the account's
+         * store named `<app worker>--<binding>`, made by the deploy (see
+         * {@link SecretsStoreSecretBinding}).
+         */
+        secretsStore?: readonly {
+            readonly name: string;
+        }[];
+        /**
+         * Analytics Engine datasets every one of the app's Workers writes to, by
+         * binding: `dataset` as written, else `<app worker>--<binding>`.
+         * Nothing to create; `writeDataPoint()` does nothing in development.
+         */
+        analyticsEngine?: readonly AnalyticsEngineResource[];
+        /**
+         * Cloudflare Artifacts, by binding (`[{ name: "MEMORY" }]`), which every
+         * one of the app's Workers binds: git repos in the namespace
+         * `<app worker>--<binding>`, nothing to create. Cloudflare has no local
+         * Artifacts: in development each binding reaches the account's
+         * namespace of the dev Worker's name (`dev.remote`), once the Vite
+         * plugin's `remoteBindings` is on and `cf auth login` ran.
+         */
+        artifacts?: readonly {
+            readonly name: string;
+        }[];
     };
     /**
      * Helper Workers deployed beside the app's Worker as
@@ -86,6 +213,20 @@ export interface EveryAppWorkerManifest {
     secrets?: ReadonlyArray<string | {
         readonly name: string;
     }>;
+    /**
+     * The app's plain settings: values that aren't secrets and differ per
+     * install (a PostHog host, a region), as `{ name, why, type, values,
+     * default, optional }`. A deployed Worker holds them like its secrets
+     * (`everyapp configure <app>` sets them; the deploy writes each
+     * default nobody has set), so production builds don't declare them. In
+     * development each one set locally (`.dev.vars`, `.env`, as for
+     * secrets) is declared as a secret, and one that isn't, but has a
+     * default, as text with its default.
+     */
+    settings?: ReadonlyArray<{
+        readonly name: string;
+        readonly default?: string;
+    }>;
 }
 /** The context cf passes to a `defineConfig((ctx) => …)` factory. */
 export interface EveryAppConfigContext {
@@ -141,6 +282,121 @@ export interface HyperdriveBinding {
         connectionString?: string;
     };
 }
+/** A producer binding to one of the app's queues. */
+export interface QueueBinding {
+    type: "queue";
+    name: string;
+}
+/** A JSON value the Worker reads as it is: `env.<NAME>` is `value`. */
+export interface JsonBinding<T = unknown> {
+    type: "json";
+    value: T;
+}
+/**
+ * An AI Gateway of the app's own (`resources.aiGateway`): its id, account
+ * and URL, which the Worker reads as `env.<NAME>.id` and `env.<NAME>.url`.
+ */
+export type AiGatewayBinding = JsonBinding<AiGatewayValue>;
+/**
+ * Workers AI (`env.AI.run()`), which cf types as `Ai`. Deployed, it calls
+ * the account's Workers AI. Miniflare has none locally: in development the
+ * binding is marked remote, so it reaches the account once the app's Vite
+ * config sets `remoteBindings: true` (the starter sets it false) and
+ * `cf auth login` has run; until then every call throws `Binding AI needs
+ * to be run remotely`.
+ */
+export interface AiBinding {
+    type: "ai";
+    dev?: {
+        remote?: boolean;
+    };
+}
+/**
+ * Browser Rendering (`env.BROWSER`, for `@cloudflare/puppeteer` or
+ * `@cloudflare/playwright`), which cf types as `BrowserRun`. Deployed, it
+ * drives a headless Chrome on Cloudflare (Workers Paid). In development
+ * the same binding reaches Miniflare's local stand-in: the first session
+ * downloads a Chrome into the global `.wrangler` cache and starts it.
+ */
+export interface BrowserBinding {
+    type: "browser";
+}
+/**
+ * Cloudflare Images (`env.IMAGES.input(stream).transform(…).output(…)`,
+ * `env.IMAGES.info(stream)`), which cf types as the runtime's
+ * `ImagesBinding`. Deployed, it runs on Cloudflare and bills the account's
+ * Images transformations. In development Miniflare answers it locally with
+ * sharp, which ships with it.
+ */
+export interface ImagesBinding {
+    type: "images";
+}
+/**
+ * A Vectorize index, by name. `dev.remote` sends development calls to the
+ * account's index: Cloudflare has no local Vectorize.
+ */
+export interface VectorizeBinding {
+    type: "vectorize";
+    name: string;
+    dev?: {
+        remote?: boolean;
+    };
+}
+/**
+ * A `send_email` binding (cf's `SendEmailBindingOptions`): one destination,
+ * a list of them, or neither, and the senders it may use.
+ */
+type SendEmailDestination = {
+    destinationAddress: string;
+    allowedDestinationAddresses?: never;
+} | {
+    destinationAddress?: never;
+    allowedDestinationAddresses: string[];
+} | {
+    destinationAddress?: never;
+    allowedDestinationAddresses?: never;
+};
+export type SendEmailBinding = SendEmailDestination & {
+    type: "send-email";
+    allowedSenderAddresses?: string[];
+};
+/**
+ * A Secrets Store secret (`await env.STRIPE_KEY.get()`), which cf types as
+ * `SecretsStoreSecret`. Deployed, the secret the deploy made in the
+ * account's store; in development, the local store `local` that Miniflare
+ * keeps under `.cloudflare/state`, where `get()` throws `Secret "<name>"
+ * not found` until the secret is seeded there (`.dev.vars` doesn't reach
+ * this binding).
+ */
+export interface SecretsStoreSecretBinding {
+    type: "secrets-store-secret";
+    storeId: string;
+    secretName: string;
+}
+/**
+ * An Analytics Engine dataset (`env.EVENTS.writeDataPoint({ blobs,
+ * doubles, indexes })`), which cf types as `AnalyticsEngineDataset`.
+ * Deployed, the dataset exists once written to. In development Miniflare
+ * accepts every write and keeps none. cf's shape takes no `dev` options.
+ */
+export interface AnalyticsEngineDatasetBinding {
+    type: "analytics-engine-dataset";
+    name: string;
+}
+/**
+ * Cloudflare Artifacts (`await env.MEMORY.create("notes")`,
+ * `env.MEMORY.get("notes")`), which cf types as `Artifacts`: git repos in
+ * the namespace `<app worker>--<binding>`. The app mints each repo's git
+ * tokens itself, and owns their scope and TTL. `dev.remote` sends
+ * development calls to the account: Cloudflare has no local Artifacts.
+ */
+export interface ArtifactsBinding {
+    type: "artifacts";
+    namespace: string;
+    dev?: {
+        remote?: boolean;
+    };
+}
 /**
  * The app's own Worker, as the bindings of the Durable Objects it defines
  * name it when its entrypoint is a `cf-worker` module import. cf reads each
@@ -184,7 +440,15 @@ export interface ServiceBinding {
 export interface VersionMetadataBinding {
     type: "version-metadata";
 }
-export type EveryAppBinding = TextBinding | SecretBinding | D1Binding | KvBinding | R2Binding | HyperdriveBinding | DurableObjectBinding<string | EveryAppWorkerReference<object>> | WorkflowBinding | GatewayBinding | ServiceBinding | VersionMetadataBinding;
+/**
+ * A binding of any Worker these helpers build, each one `InputWorkerConfig`
+ * accepts, so a helper Worker's definition passes as the Vite plugin's
+ * `auxiliaryWorkers` config. A Durable Object binding names its Worker by
+ * name; only the app's own Worker names itself by definition (see
+ * {@link EveryAppWorkerReference}), in its typed `env`, which
+ * `defineConfig()` takes.
+ */
+export type EveryAppBinding = TextBinding | SecretBinding | D1Binding | KvBinding | R2Binding | HyperdriveBinding | QueueBinding | AiBinding | BrowserBinding | ImagesBinding | VectorizeBinding | AiGatewayBinding | JsonBinding<JsonValue> | SendEmailBinding | SecretsStoreSecretBinding | AnalyticsEngineDatasetBinding | ArtifactsBinding | DurableObjectBinding | WorkflowBinding | GatewayBinding | ServiceBinding | VersionMetadataBinding;
 export interface DurableObjectExport {
     type: "durable-object";
     storage: "sqlite";
@@ -208,6 +472,49 @@ type R2Names<M> = M extends {
         r2: readonly (infer B)[];
     };
 } ? B & string : never;
+type AiNames<M> = M extends {
+    resources: {
+        ai: readonly (infer B)[];
+    };
+} ? B & string : never;
+type BrowserNames<M> = M extends {
+    resources: {
+        browser: readonly (infer B)[];
+    };
+} ? B & string : never;
+type ImagesNames<M> = M extends {
+    resources: {
+        images: readonly (infer B)[];
+    };
+} ? B & string : never;
+type VectorizeNames<M> = M extends {
+    resources: {
+        vectorize: readonly (infer V)[];
+    };
+} ? V extends {
+    name: infer N extends string;
+} ? N : never : never;
+type AiGatewayNames<M> = M extends {
+    resources: {
+        aiGateway: readonly (infer G)[];
+    };
+} ? G extends {
+    name: infer N extends string;
+} ? N : never : never;
+type AnalyticsEngineNames<M> = M extends {
+    resources: {
+        analyticsEngine: readonly (infer A)[];
+    };
+} ? A extends {
+    name: infer N extends string;
+} ? N : never : never;
+type ArtifactsNames<M> = M extends {
+    resources: {
+        artifacts: readonly (infer A)[];
+    };
+} ? A extends {
+    name: infer N extends string;
+} ? N : never : never;
 type DurableObjects<M> = M extends {
     resources: {
         durableObjects: readonly (infer D)[];
@@ -218,6 +525,27 @@ type Workflows<M> = M extends {
         workflows: readonly (infer W)[];
     };
 } ? W : never;
+type QueueNames<M> = M extends {
+    resources: {
+        queues: readonly (infer Q)[];
+    };
+} ? Q extends {
+    name: infer N extends string;
+} ? N : never : never;
+type SendEmailNames<M> = M extends {
+    resources: {
+        sendEmail: readonly (infer S)[];
+    };
+} ? S extends {
+    name: infer N extends string;
+} ? N : never : never;
+type SecretsStoreNames<M> = M extends {
+    resources: {
+        secretsStore: readonly (infer S)[];
+    };
+} ? S extends {
+    name: infer N extends string;
+} ? N : never : never;
 type HelperWorkers<M> = M extends {
     workers: readonly (infer H)[];
 } ? H : never;
@@ -236,46 +564,6 @@ type DatabaseEnv<M> = M extends {
 } ? {
     DATABASE_PROVIDER: TextBinding;
 } : unknown;
-/**
- * The gateway secrets holding the keys of the AI providers and capabilities
- * an app may ask for, with the settings a provider needs besides its key
- * (Workers AI's account). With no gateway in development, the SDK reaches
- * them with the developer's own values under the same names. A copy of the
- * tables in ../internal, which the Worker loads: the Vite plugin hides
- * whatever cloudflare.config.ts imports from the Worker. A test keeps them
- * in step.
- */
-declare const DEV_GATEWAY_KEYS: {
-    readonly providers: {
-        readonly openai: readonly ["OPENAI_API_KEY"];
-        readonly openrouter: readonly ["OPENROUTER_API_KEY"];
-        readonly "workers-ai": readonly ["WORKERS_AI_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID"];
-    };
-    readonly capabilities: {
-        readonly dataforseo: readonly ["DATAFORSEO_API_KEY"];
-        readonly context: readonly ["CONTEXT_API_KEY"];
-        readonly email: readonly ["EMAIL_FROM", "EMAIL_FROM_NAME", "EMAIL_REST_API_TOKEN", "CLOUDFLARE_ACCOUNT_ID", "RESEND_API_KEY", "EMAIL_PROVIDER"];
-        readonly members: readonly [];
-        readonly linkedin: readonly ["LINKEDIN_CLIENT_ID", "LINKEDIN_CLIENT_SECRET"];
-        readonly facebook: readonly ["FACEBOOK_APP_ID", "FACEBOOK_APP_SECRET"];
-        readonly instagram: readonly ["INSTAGRAM_APP_ID", "INSTAGRAM_APP_SECRET"];
-        readonly threads: readonly ["THREADS_APP_ID", "THREADS_APP_SECRET"];
-        readonly youtube: readonly ["YOUTUBE_CLIENT_ID", "YOUTUBE_CLIENT_SECRET"];
-        readonly tiktok: readonly ["TIKTOK_CLIENT_ID", "TIKTOK_CLIENT_SECRET"];
-        readonly "tiktok-business": readonly ["TIKTOK_BUSINESS_CLIENT_ID", "TIKTOK_BUSINESS_CLIENT_SECRET"];
-        readonly reddit: readonly ["REDDIT_CLIENT_ID", "REDDIT_CLIENT_SECRET"];
-        readonly pinterest: readonly ["PINTEREST_CLIENT_ID", "PINTEREST_CLIENT_SECRET"];
-        readonly discord: readonly ["DISCORD_CLIENT_ID", "DISCORD_CLIENT_SECRET"];
-        readonly slack: readonly ["SLACK_CLIENT_ID", "SLACK_CLIENT_SECRET"];
-        readonly mastodon: readonly ["MASTODON_CLIENT_ID", "MASTODON_CLIENT_SECRET", "MASTODON_URL"];
-        readonly kick: readonly ["KICK_CLIENT_ID", "KICK_CLIENT_SECRET"];
-        readonly twitch: readonly ["TWITCH_CLIENT_ID", "TWITCH_CLIENT_SECRET"];
-        readonly tumblr: readonly ["TUMBLR_CLIENT_ID", "TUMBLR_CLIENT_SECRET"];
-        readonly dribbble: readonly ["DRIBBBLE_CLIENT_ID", "DRIBBBLE_CLIENT_SECRET"];
-        readonly "google-workspace": readonly ["GOOGLE_WORKSPACE_CLIENT_ID", "GOOGLE_WORKSPACE_CLIENT_SECRET"];
-        readonly "microsoft-365": readonly ["MICROSOFT_365_CLIENT_ID", "MICROSOFT_365_CLIENT_SECRET"];
-    };
-};
 type DevProviderKeys = typeof DEV_GATEWAY_KEYS.providers;
 type DevCapabilityKeys = typeof DEV_GATEWAY_KEYS.capabilities;
 /** The gateway keys a developer may set locally for the manifest's providers and capabilities. */
@@ -301,6 +589,26 @@ type ResourceEnv<M, TEntrypoint> = {
     [B in KvNames<M>]: KvBinding;
 } & {
     [B in R2Names<M>]: R2Binding;
+} & {
+    [B in QueueNames<M>]: QueueBinding;
+} & {
+    [B in AiNames<M>]: AiBinding;
+} & {
+    [B in BrowserNames<M>]: BrowserBinding;
+} & {
+    [B in ImagesNames<M>]: ImagesBinding;
+} & {
+    [B in VectorizeNames<M>]: VectorizeBinding;
+} & {
+    [B in AiGatewayNames<M>]: AiGatewayBinding;
+} & {
+    [B in SendEmailNames<M>]: SendEmailBinding;
+} & {
+    [B in SecretsStoreNames<M>]: SecretsStoreSecretBinding;
+} & {
+    [B in AnalyticsEngineNames<M>]: AnalyticsEngineDatasetBinding;
+} & {
+    [B in ArtifactsNames<M>]: ArtifactsBinding;
 } & {
     [D in DurableObjects<M> as D extends {
         name: infer N extends string;
@@ -314,9 +622,19 @@ type ResourceEnv<M, TEntrypoint> = {
         binding: infer B extends string;
     } ? B : never]: ServiceBinding;
 };
-type SharedEnv = {
+/** A JSON value, as cf's JSON bindings take one. */
+type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** `M` without `readonly`, as cf's JSON bindings take their value. */
+type JsonValueOf<M> = M extends readonly (infer E)[] ? JsonValueOf<E>[] : M extends object ? {
+    -readonly [K in keyof M]: JsonValueOf<M[K]>;
+} : M;
+type SharedEnv<M> = {
     EVERYAPP_APP_ID: TextBinding;
+    EVERYAPP_MANIFEST: JsonBinding<JsonValueOf<M>>;
     CF_VERSION_METADATA: VersionMetadataBinding;
+    GATEWAY_URL: TextBinding | SecretBinding;
 };
 /**
  * Hyperdrive in production; in development only where a local connection
@@ -337,23 +655,27 @@ type DevEmailEnv<M> = M extends {
  * Bindings in development: the well-known dev identity, as plain text, and
  * the developer's own gateway keys (when set).
  */
-export type EveryAppDevEnv<M, TEntrypoint = string> = ResourceEnv<M, TEntrypoint> & SharedEnv & DatabaseEnv<M> & DevEmailEnv<M> & {
+export type EveryAppDevEnv<M, TEntrypoint = string> = ResourceEnv<M, TEntrypoint> & SharedEnv<M> & DatabaseEnv<M> & DevEmailEnv<M> & {
     EVERYAPP_DEV: TextBinding;
     EVERYAPP_DEV_CAPABILITIES: TextBinding;
     /** The specs in `.everyapp/providers/*.json`, when the app has any: providers registered on a gateway, for integrationFetch()'s dev fallback. */
     EVERYAPP_DEV_PROVIDERS?: TextBinding;
+    /** Under `everyapp dev --gateway` (linked dev): the gateway-lite's forwarder and the run's nonce, which the SDK's services call the real Gateway through. */
+    EVERYAPP_LINKED_DEV_URL?: TextBinding;
+    EVERYAPP_LINKED_DEV_NONCE?: TextBinding;
     EVERYAPP_IDENTITY_PUBLIC_KEYS: TextBinding;
     EVERYAPP_IDENTITY_ISSUER: TextBinding;
+    /** The stub dev gateway's organization (`dev-org`), so `withOrganization(env.EVERY_APP_ORG_ID, …)` works in development as deployed. */
+    EVERY_APP_ORG_ID: TextBinding;
 } & {
     [K in DevGatewayKeys<M>]: SecretBinding;
 };
 /** Bindings in production: the deployed identity and the gateway binding. */
-export type EveryAppDeployEnv<M, TEntrypoint = string> = ResourceEnv<M, TEntrypoint> & SharedEnv & DatabaseEnv<M> & HyperdriveEnv<M> & {
+export type EveryAppDeployEnv<M, TEntrypoint = string> = ResourceEnv<M, TEntrypoint> & SharedEnv<M> & DatabaseEnv<M> & HyperdriveEnv<M> & {
     EVERYAPP_AUDIENCE: TextBinding;
     EVERYAPP_IDENTITY_PUBLIC_KEYS: TextBinding;
     EVERYAPP_IDENTITY_ISSUER: TextBinding;
     EVERY_APP_GATEWAY: GatewayBinding;
-    GATEWAY_URL: SecretBinding;
     /**
      * The owning organization. The build always declares it; installing a
      * shared app, which serves every organization, drops it.
@@ -401,6 +723,23 @@ export interface ScheduledTrigger {
     type: "scheduled";
     schedule: string;
 }
+/**
+ * Structural copy of cf's queue consumer trigger: the Worker consumes the
+ * named queue (its `queue(batch, env)` handler), with these settings.
+ */
+export interface QueueConsumerTrigger {
+    type: "queue";
+    name: string;
+    deadLetterQueue?: string;
+    maxBatchSize?: number;
+    maxBatchTimeout?: number;
+    maxConcurrency?: number | null;
+    maxRetries?: number;
+    retryDelay?: number;
+    visibilityTimeoutMs?: number;
+}
+/** A trigger one of the app's Workers may have: its crons, the queues it consumes. */
+export type EveryAppTrigger = ScheduledTrigger | QueueConsumerTrigger;
 export interface EveryAppWorkerConfig<M, TEntrypoint> {
     name: string;
     entrypoint: TEntrypoint;
@@ -408,8 +747,8 @@ export interface EveryAppWorkerConfig<M, TEntrypoint> {
     compatibilityFlags: string[];
     workersDev: false;
     previewUrls: false;
-    /** The `crons` option's schedules; absent without any. */
-    triggers?: ScheduledTrigger[];
+    /** The `crons` option's schedules and the queues it consumes; absent without any. */
+    triggers?: EveryAppTrigger[];
     /** Near the manifest's `database.region`, once deployed. */
     placement?: EveryAppPlacement;
     /** The manifest's `limits`. */
@@ -456,7 +795,7 @@ export interface EveryAppAuxiliaryWorkerConfig<TEntrypoint> {
     compatibilityFlags: string[];
     workersDev: false;
     previewUrls: false;
-    triggers?: ScheduledTrigger[];
+    triggers?: EveryAppTrigger[];
     placement?: EveryAppPlacement;
     limits?: {
         cpuMs?: number;
@@ -469,7 +808,10 @@ export interface EveryAppAuxiliaryWorkerConfig<TEntrypoint> {
  * Build the definition of one of the app's helper Workers (the manifest's
  * `workers`), e.g. one that runs a memory-hungry job away from the app's
  * Worker. It is named `<app worker>--<worker>`, is private like the app, and
- * binds the app's D1 databases, KV namespaces and R2 buckets, the classes it defines, and
+ * binds the app's  and Analytics Engine datasets, the classes it defines, and
+ * binds the app's D1 databases, KV namespaces, R2 buckets, Workers AI,
+ * Browser Rendering, Images, Vectorize indexes, AI Gateways, `send_email`
+ * bindings and Secrets Store secrets, the classes it defines, and
  * the gateway (with the app's identity, for capabilities). Only the app's
  * Worker reaches it. Pass it to the Vite plugin:
  *
@@ -480,19 +822,6 @@ export interface EveryAppAuxiliaryWorkerConfig<TEntrypoint> {
  *   })
  */
 export declare function everyAppAuxiliaryWorker<const M extends EveryAppWorkerManifest, TEntrypoint extends string | object>(options: EveryAppAuxiliaryWorkerOptions<M, TEntrypoint>): EveryAppAuxiliaryWorkerConfig<TEntrypoint>;
-/**
- * A helper Worker's name: `<app worker>--<name>`, within Cloudflare's
- * limit. New app ids can't contain `--`, so it is never another app's
- * Worker name.
- */
-export declare function helperWorkerName(appWorker: string, helper: string): string;
-/**
- * The Workflow a binding defines, named after the app's Worker:
- * `every-acme-seo` and `RANK_CHECK` → `every-acme-seo--rank-check`.
- * Workflow names are unique in the account, and new app ids can't contain
- * `--`, so one app's Workflow is never named like another app's.
- */
-export declare function workflowNameFor(workerName: string, binding: string): string;
 /**
  * The local D1 database id for a binding: a 32-hex string, because
  * `cf d1 … --local` rejects names. The everyapp CLI computes the same id to
@@ -507,5 +836,4 @@ export declare function localD1Id(workerName: string, binding: string): string;
  * the file after that object's id. `databaseId` is the {@link localD1Id}.
  */
 export declare function localD1Path(root: string, databaseId: string): string;
-export {};
 //# sourceMappingURL=worker.d.ts.map