@alchemy.run/modal 0.0.0 → 2.0.0-beta.86

package/lib/Function.d.ts

@@ -0,0 +1,236 @@
+import type * as functions from "@distilled.cloud/modal/functions";
+import { Platform, type Main, type MainRpc } from "alchemy/Platform";
+import * as Provider from "alchemy/Provider";
+import type { Resource } from "alchemy/Resource";
+import type { HostRuntimeContext, ServerHost } from "alchemy/Runtime/Process";
+import type { ContainerProps } from "./Container.ts";
+import { type RuntimeAttributes } from "./internal/Runtime.ts";
+import type { MountContract } from "./Mounts.ts";
+import type { Providers } from "./Providers.ts";
+import type { DurationInput } from "./SandboxClient.ts";
+/** Serve the function on the web at a `*.modal.run` URL. */
+export interface WebEndpointOptions {
+    /**
+     * Label in the URL (`https://<workspace>--<label>.modal.run`).
+     * @default "<app>-<function>"
+     */
+    label?: string;
+    /**
+     * Require Modal's proxy auth headers (`Modal-Key` / `Modal-Secret`, from a
+     * `Modal.WebhookToken`) on every request.
+     * @default false
+     */
+    requiresProxyAuth?: boolean;
+    /** Custom domains (verified `Modal.Domain`s) that also serve the endpoint. */
+    customDomains?: string[];
+}
+/** Run the function on a schedule: a cron expression, or a fixed period. */
+export type FunctionSchedule = {
+    /** Cron expression (`"0 9 * * 1-5"`). */
+    readonly cron: string;
+    /** IANA time zone the expression is read in. @default "UTC" */
+    readonly timezone?: string;
+} | {
+    /** Time between runs (`"1 hour"`, or seconds). */
+    readonly period: DurationInput;
+};
+/** Retry failed calls. */
+export interface FunctionRetries {
+    /** Retries after the first failure. */
+    readonly maxRetries: number;
+    /** Delay multiplier per retry; `1` is a fixed delay. @default 2 */
+    readonly backoffCoefficient?: number;
+    /** Delay before the first retry. @default 1 second */
+    readonly initialDelay?: DurationInput;
+    /** Longest delay between retries, at most 60 seconds. @default 60 seconds */
+    readonly maxDelay?: DurationInput;
+}
+export interface FunctionProps extends ContainerProps {
+    /**
+     * Serve the program's `fetch` handler on the web instead of taking calls.
+     * The URL is the `url` attribute.
+     */
+    web?: boolean | WebEndpointOptions;
+    /**
+     * Run on a schedule. Each tick arrives at the program's `fetch` handler
+     * as `POST /__modal/schedule`.
+     */
+    schedule?: FunctionSchedule;
+    /** Retry failed calls: a count, or a backoff policy. Not for web functions. */
+    retries?: number | FunctionRetries;
+    /** Most inputs one container handles at once. @default 1 */
+    maxConcurrentInputs?: number;
+    /** Inputs per container the autoscaler aims for (at most `maxConcurrentInputs`). */
+    targetConcurrentInputs?: number;
+    /** Shut each container down after it handles one input. */
+    singleUseContainers?: boolean;
+}
+export interface FunctionAttributes extends RuntimeAttributes {
+    /** The web endpoint's URL, for a function with `web`. */
+    url: string | undefined;
+    /** The program's RPC methods, which `Modal.InvokeFunction` calls. */
+    methods: string[];
+}
+declare const FunctionRpcConflict_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Modal.FunctionRpcConflict";
+} & Readonly<A>;
+/** A Function's program returns RPC methods and also asks for `web` or a `schedule`. */
+export declare class FunctionRpcConflict extends FunctionRpcConflict_base<{
+    readonly message: string;
+}> {
+}
+export type Function = Resource<"Modal.Function", FunctionProps, FunctionAttributes, {
+    env?: Record<string, any>;
+    mounts?: MountContract;
+    rpcCallers?: string[];
+}, Providers>;
+export type FunctionServices = ServerHost;
+/**
+ * What the program returns: `fetch` for HTTP, and any other functions,
+ * its RPC methods.
+ */
+export type FunctionShape = Main<FunctionServices> | (Exclude<Main<FunctionServices>, void> & MainRpc<FunctionServices>);
+export type FunctionRuntimeContext = HostRuntimeContext;
+/**
+ * A Modal Function running your program: Modal scales its containers with
+ * demand (to zero when idle), and the function takes calls, runs on a
+ * schedule, or serves the web.
+ *
+ * Alchemy bundles `main`, builds it into an image on Modal's builder (no
+ * Docker), and deploys the function into its `Modal.App`. Modal starts each
+ * container with its Python entrypoint; Alchemy's entrypoint starts your
+ * program and hands it work:
+ *
+ * - the program's RPC methods (every function it returns besides `fetch`)
+ *   become the function's methods: `Modal.InvokeFunction` calls them with
+ *   typed arguments and results, and Modal queues, retries and autoscales
+ *   the calls;
+ * - with `web`, Modal routes the function's `*.modal.run` URL to the
+ *   program's `fetch` handler;
+ * - a `schedule` tick arrives at `fetch` as `POST /__modal/schedule`.
+ *
+ * A function serves one of these. To serve methods next to `fetch`, use a
+ * `Modal.Server`. The program's env, including the credentials its
+ * bindings need, goes into a Modal Secret, never into the image.
+ *
+ * ### Effect program
+ * **Example:** A function other runtimes call
+ * ```typescript
+ * // src/Embed.ts
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import { Inference } from "./Inference.ts";
+ *
+ * export default class Embed extends Modal.Function<Embed>()(
+ *   "Embed",
+ *   { main: import.meta.url, app: Inference },
+ *   Effect.gen(function* () {
+ *     return {
+ *       embed: Effect.fn(function* (text: string) {
+ *         return { tokens: text.split(/\s+/).length };
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * **Example:** Call it from a Cloudflare Worker
+ * ```typescript
+ * const embed = yield* Modal.InvokeFunction(Embed);
+ * const { tokens } = yield* embed.embed("hello modal");
+ * ```
+ *
+ * ### Async program
+ * **Example:** A plain HTTP server, no Effect (it runs on Bun)
+ * ```typescript
+ * // src/Embed.ts
+ * import * as Modal from "@alchemy.run/modal";
+ * import { Inference } from "./Inference.ts";
+ *
+ * export const Embed = Modal.Function("Embed", {
+ *   main: "./src/embed-server.ts",
+ *   app: Inference,
+ *   env: { MODEL: "small" },
+ * });
+ * export type EmbedEnv = Modal.InferEnv<typeof Embed>;
+ * ```
+ *
+ * ```typescript
+ * // src/embed-server.ts
+ * import type { EmbedEnv } from "./Embed.ts";
+ *
+ * const env = process.env as unknown as EmbedEnv;
+ *
+ * Bun.serve({
+ *   port: Number(process.env.PORT),
+ *   async fetch(request) {
+ *     const { args } = (await request.json()) as { args: [string] };
+ *     return Response.json({ model: env.MODEL, tokens: args[0].split(/\s+/).length });
+ *   },
+ * });
+ * ```
+ *
+ * ### Web endpoints
+ * **Example:** Serve `fetch` at a `*.modal.run` URL
+ * ```typescript
+ * export default class Api extends Modal.Function<Api>()(
+ *   "Api",
+ *   { main: import.meta.url, app: Inference, web: true },
+ *   Effect.gen(function* () {
+ *     return { fetch: Effect.succeed(HttpServerResponse.text("hello from Modal")) };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * **Example:** Behind Modal's proxy auth
+ * ```typescript
+ * export default class Admin extends Modal.Function<Admin>()(
+ *   "Admin",
+ *   { main: import.meta.url, app: Inference, web: { requiresProxyAuth: true, label: "admin" } },
+ *   program,
+ * ) {}
+ * ```
+ *
+ * ### Schedules
+ * **Example:** Run every morning
+ * ```typescript
+ * export default class Digest extends Modal.Function<Digest>()(
+ *   "Digest",
+ *   { main: import.meta.url, app: Inference, schedule: { cron: "0 9 * * *", timezone: "Europe/London" } },
+ *   Effect.gen(function* () {
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         yield* Effect.log("sending the digest");
+ *         return yield* HttpServerResponse.json(null);
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * ### GPUs, volumes and scaling
+ * **Example:** A warm GPU function reading weights from a volume
+ * ```typescript
+ * export default class Generate extends Modal.Function<Generate>()(
+ *   "Generate",
+ *   {
+ *     main: import.meta.url,
+ *     app: Inference,
+ *     gpu: "L4",
+ *     mounts: [{ volume: Weights, path: "/models" }],
+ *     minContainers: 1,
+ *     scaledownWindow: 300,
+ *     maxConcurrentInputs: 8,
+ *     timeout: "10 minutes",
+ *   },
+ *   program,
+ * ) {}
+ * ```
+ *
+ * @resource
+ * @product Function
+ */
+export declare const Function: Platform<Function, FunctionServices, FunctionShape, FunctionRuntimeContext>;
+export declare const FunctionProvider: () => import("effect/Layer").Layer<Provider.Provider<Function>, never, import("effect/FileSystem").FileSystem | import("effect/Path").Path | import("alchemy/Stack").Stack | import("alchemy/Stage").Stage | functions.ModalOpContext>;
+export {};
+//# sourceMappingURL=Function.d.ts.map

package/lib/Function.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Function.d.ts","sources":["../src/Function.ts"],"names":[],"mappings":"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"}

package/lib/Function.js

@@ -0,0 +1,273 @@
+import { Platform } from "alchemy/Platform";
+import * as Provider from "alchemy/Provider";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import { seconds } from "./internal.js";
+import { ENTRYPOINT, RPC_SERVE_ENV } from "./internal/Entrypoint.js";
+import { createModalRuntimeContext, rpcMethodNamesOf } from "./internal/Rpc.js";
+import { resolveContainerProps, runtimeLifecycle, } from "./internal/Runtime.js";
+/** A Function's program returns RPC methods and also asks for `web` or a `schedule`. */
+export class FunctionRpcConflict extends Data.TaggedError("Modal.FunctionRpcConflict") {
+}
+/**
+ * A Modal Function running your program: Modal scales its containers with
+ * demand (to zero when idle), and the function takes calls, runs on a
+ * schedule, or serves the web.
+ *
+ * Alchemy bundles `main`, builds it into an image on Modal's builder (no
+ * Docker), and deploys the function into its `Modal.App`. Modal starts each
+ * container with its Python entrypoint; Alchemy's entrypoint starts your
+ * program and hands it work:
+ *
+ * - the program's RPC methods (every function it returns besides `fetch`)
+ *   become the function's methods: `Modal.InvokeFunction` calls them with
+ *   typed arguments and results, and Modal queues, retries and autoscales
+ *   the calls;
+ * - with `web`, Modal routes the function's `*.modal.run` URL to the
+ *   program's `fetch` handler;
+ * - a `schedule` tick arrives at `fetch` as `POST /__modal/schedule`.
+ *
+ * A function serves one of these. To serve methods next to `fetch`, use a
+ * `Modal.Server`. The program's env, including the credentials its
+ * bindings need, goes into a Modal Secret, never into the image.
+ *
+ * ### Effect program
+ * **Example:** A function other runtimes call
+ * ```typescript
+ * // src/Embed.ts
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import { Inference } from "./Inference.ts";
+ *
+ * export default class Embed extends Modal.Function<Embed>()(
+ *   "Embed",
+ *   { main: import.meta.url, app: Inference },
+ *   Effect.gen(function* () {
+ *     return {
+ *       embed: Effect.fn(function* (text: string) {
+ *         return { tokens: text.split(/\s+/).length };
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * **Example:** Call it from a Cloudflare Worker
+ * ```typescript
+ * const embed = yield* Modal.InvokeFunction(Embed);
+ * const { tokens } = yield* embed.embed("hello modal");
+ * ```
+ *
+ * ### Async program
+ * **Example:** A plain HTTP server, no Effect (it runs on Bun)
+ * ```typescript
+ * // src/Embed.ts
+ * import * as Modal from "@alchemy.run/modal";
+ * import { Inference } from "./Inference.ts";
+ *
+ * export const Embed = Modal.Function("Embed", {
+ *   main: "./src/embed-server.ts",
+ *   app: Inference,
+ *   env: { MODEL: "small" },
+ * });
+ * export type EmbedEnv = Modal.InferEnv<typeof Embed>;
+ * ```
+ *
+ * ```typescript
+ * // src/embed-server.ts
+ * import type { EmbedEnv } from "./Embed.ts";
+ *
+ * const env = process.env as unknown as EmbedEnv;
+ *
+ * Bun.serve({
+ *   port: Number(process.env.PORT),
+ *   async fetch(request) {
+ *     const { args } = (await request.json()) as { args: [string] };
+ *     return Response.json({ model: env.MODEL, tokens: args[0].split(/\s+/).length });
+ *   },
+ * });
+ * ```
+ *
+ * ### Web endpoints
+ * **Example:** Serve `fetch` at a `*.modal.run` URL
+ * ```typescript
+ * export default class Api extends Modal.Function<Api>()(
+ *   "Api",
+ *   { main: import.meta.url, app: Inference, web: true },
+ *   Effect.gen(function* () {
+ *     return { fetch: Effect.succeed(HttpServerResponse.text("hello from Modal")) };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * **Example:** Behind Modal's proxy auth
+ * ```typescript
+ * export default class Admin extends Modal.Function<Admin>()(
+ *   "Admin",
+ *   { main: import.meta.url, app: Inference, web: { requiresProxyAuth: true, label: "admin" } },
+ *   program,
+ * ) {}
+ * ```
+ *
+ * ### Schedules
+ * **Example:** Run every morning
+ * ```typescript
+ * export default class Digest extends Modal.Function<Digest>()(
+ *   "Digest",
+ *   { main: import.meta.url, app: Inference, schedule: { cron: "0 9 * * *", timezone: "Europe/London" } },
+ *   Effect.gen(function* () {
+ *     return {
+ *       fetch: Effect.gen(function* () {
+ *         yield* Effect.log("sending the digest");
+ *         return yield* HttpServerResponse.json(null);
+ *       }),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * ### GPUs, volumes and scaling
+ * **Example:** A warm GPU function reading weights from a volume
+ * ```typescript
+ * export default class Generate extends Modal.Function<Generate>()(
+ *   "Generate",
+ *   {
+ *     main: import.meta.url,
+ *     app: Inference,
+ *     gpu: "L4",
+ *     mounts: [{ volume: Weights, path: "/models" }],
+ *     minContainers: 1,
+ *     scaledownWindow: 300,
+ *     maxConcurrentInputs: 8,
+ *     timeout: "10 minutes",
+ *   },
+ *   program,
+ * ) {}
+ * ```
+ *
+ * @resource
+ * @product Function
+ */
+export const Function = Platform("Modal.Function", {
+    createRuntimeContext: createModalRuntimeContext("Modal.Function"),
+    transformProps: resolveContainerProps,
+});
+const bootstrapEntry = (handler) => (importPath) => `
+import { bootstrap } from "@alchemy.run/modal/Bootstrap";
+import { ${handler} as entrypoint } from ${JSON.stringify(importPath)};
+
+await bootstrap(entrypoint);
+`;
+const scheduleOf = (schedule) => schedule === undefined
+    ? undefined
+    : "cron" in schedule
+        ? { cron: { cronString: schedule.cron, timezone: schedule.timezone ?? "UTC" } }
+        : { period: { seconds: seconds(schedule.period) } };
+const retriesOf = (retries) => retries === undefined
+    ? undefined
+    : typeof retries === "number"
+        ? { retries, backoffCoefficient: 1, initialDelayMs: 1000, maxDelayMs: 60_000 }
+        : {
+            retries: retries.maxRetries,
+            backoffCoefficient: retries.backoffCoefficient ?? 2,
+            initialDelayMs: Math.round((seconds(retries.initialDelay) ?? 1) * 1000),
+            maxDelayMs: Math.round((seconds(retries.maxDelay) ?? 60) * 1000),
+        };
+/** How a Function differs from the other runtimes: a call, schedule or web function. */
+const definitionOf = (props, context) => {
+    const methods = rpcMethodNamesOf(props.env);
+    if (methods.length > 0) {
+        // One method per RPC method: callers send its name as the input's
+        // `method_name`, and the entrypoint's `Rpc` class forwards it to the
+        // program's `/__rpc__/<method>`.
+        const formats = ["DATA_FORMAT_PICKLE", "DATA_FORMAT_CBOR"];
+        return {
+            implementationName: ENTRYPOINT.rpc,
+            isClass: true,
+            methodDefinitions: Object.fromEntries(methods.map((name) => [
+                name,
+                {
+                    functionName: name,
+                    functionType: "FUNCTION_TYPE_FUNCTION",
+                    supportedInputFormats: formats,
+                    supportedOutputFormats: formats,
+                },
+            ])),
+            supportedInputFormats: formats,
+            supportedOutputFormats: formats,
+            retryPolicy: retriesOf(props.retries),
+            maxConcurrentInputs: props.maxConcurrentInputs ?? 0,
+            targetConcurrentInputs: props.targetConcurrentInputs ?? 0,
+            singleUseContainers: props.singleUseContainers,
+            maxInputs: props.singleUseContainers ? 1 : 0,
+        };
+    }
+    if (props.web) {
+        const web = props.web === true ? {} : props.web;
+        return {
+            implementationName: ENTRYPOINT.web,
+            webhookConfig: {
+                type: "WEBHOOK_TYPE_WEB_SERVER",
+                webServerPort: context.port,
+                webServerStartupTimeout: context.startupTimeout,
+                requestedSuffix: web.label,
+                requiresProxyAuth: web.requiresProxyAuth,
+                customDomains: web.customDomains?.map((name) => ({ name })),
+            },
+            supportedInputFormats: ["DATA_FORMAT_ASGI"],
+            supportedOutputFormats: ["DATA_FORMAT_ASGI", "DATA_FORMAT_GENERATOR_DONE"],
+            schedule: scheduleOf(props.schedule),
+            maxConcurrentInputs: props.maxConcurrentInputs ?? 0,
+            targetConcurrentInputs: props.targetConcurrentInputs ?? 0,
+            singleUseContainers: props.singleUseContainers,
+            maxInputs: props.singleUseContainers ? 1 : 0,
+        };
+    }
+    return {
+        implementationName: props.schedule ? ENTRYPOINT.schedule : ENTRYPOINT.call,
+        supportedInputFormats: ["DATA_FORMAT_PICKLE", "DATA_FORMAT_CBOR"],
+        supportedOutputFormats: ["DATA_FORMAT_PICKLE", "DATA_FORMAT_CBOR"],
+        schedule: scheduleOf(props.schedule),
+        retryPolicy: retriesOf(props.retries),
+        maxConcurrentInputs: props.maxConcurrentInputs ?? 0,
+        targetConcurrentInputs: props.targetConcurrentInputs ?? 0,
+        singleUseContainers: props.singleUseContainers,
+        maxInputs: props.singleUseContainers ? 1 : 0,
+    };
+};
+export const FunctionProvider = () => Provider.effect(Function, Effect.gen(function* () {
+    const lifecycle = yield* runtimeLifecycle({
+        type: "Modal.Function",
+        definition: definitionOf,
+        bootstrap: bootstrapEntry,
+        // Modal authenticates every call of a class function, so its
+        // program serves RPC (see `createModalRuntimeContext`).
+        env: (props) => rpcMethodNamesOf(props.env).length > 0 ? { [RPC_SERVE_ENV]: "1" } : {},
+    });
+    return {
+        stables: lifecycle.stables,
+        diff: lifecycle.diff,
+        read: Effect.fn(function* ({ output }) {
+            const found = yield* lifecycle.read({ output });
+            return found === undefined ? undefined : output;
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output, session, bindings }) {
+            const methods = rpcMethodNamesOf(news.env);
+            if (methods.length > 0 && (news.web || news.schedule)) {
+                return yield* new FunctionRpcConflict({
+                    message: `${id} returns RPC methods (${methods.join(", ")}) and sets ${news.web ? "web" : "schedule"}: a Modal.Function serves calls to its methods, a web endpoint or a schedule. Serve methods next to fetch with a Modal.Server.`,
+                });
+            }
+            const { attributes, metadata } = yield* lifecycle.reconcile({
+                id,
+                news,
+                output,
+                session,
+                bindings,
+            });
+            return { ...attributes, url: news.web ? metadata?.webUrl : undefined, methods };
+        }),
+        delete: lifecycle.delete,
+    };
+}));
+//# sourceMappingURL=Function.js.map

package/lib/Function.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Function.js","sources":["../src/Function.ts"],"names":[],"mappings":"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"}

package/lib/FunctionAutoscaler.d.ts

@@ -0,0 +1,99 @@
+import * as functions from "@distilled.cloud/modal/functions";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Effect from "effect/Effect";
+import { type EnvironmentInput } from "./internal.ts";
+import type { Providers } from "./Providers.ts";
+declare const FunctionAutoscalerUnexpectedResponse_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "Modal.FunctionAutoscalerUnexpectedResponse";
+} & Readonly<A>;
+export declare class FunctionAutoscalerUnexpectedResponse extends FunctionAutoscalerUnexpectedResponse_base<{
+    readonly message: string;
+}> {
+}
+export interface FunctionAutoscalerProps {
+    /** Name of the deployed App that defines the function. */
+    app: string;
+    /**
+     * The function's name in the App (`"f"` for `@app.function() def f`, or
+     * `"Model.*"` for a class). Changing it, the app or the environment
+     * replaces this resource.
+     */
+    function: string;
+    /**
+     * Environment the App is deployed in.
+     * @default the workspace's default environment
+     */
+    environment?: EnvironmentInput;
+    /** Containers kept running even with no inputs (`min_containers`). */
+    minContainers?: number;
+    /** Most containers the function runs at once (`max_containers`). */
+    maxContainers?: number;
+    /** Extra idle containers kept ready while the function is busy (`buffer_containers`). */
+    bufferContainers?: number;
+    /** How long an idle container stays up before scaling down (`scaledown_window`). */
+    scaledownWindow?: number | string;
+    /** Sustained demand needed before scaling up (`scaleup_window`). */
+    scaleupWindow?: number | string;
+    /** Inputs each container handles at once before more are added. */
+    targetConcurrency?: number;
+}
+/** The autoscaler settings Modal stores for a function. */
+export interface AutoscalerSettingsState {
+    minContainers?: number;
+    maxContainers?: number;
+    bufferContainers?: number;
+    scaledownWindow?: number;
+    scaleupWindow?: number;
+    targetConcurrency?: number;
+}
+export interface FunctionAutoscalerAttributes {
+    /** Function ID (`fu-…`). */
+    functionId: string;
+    /** The settings in effect after the last deploy. */
+    settings: AutoscalerSettingsState;
+    /** The settings found before the first deploy, restored on destroy. */
+    original: AutoscalerSettingsState;
+}
+/**
+ * Autoscaling settings for a Modal Function deployed with Modal's Python
+ * client (`modal deploy`): warm containers, a container cap, buffer
+ * containers and scale-down timing, changed without redeploying the app.
+ *
+ * For a `Modal.Function` or `Modal.Server` of the Stack, set these on the
+ * resource itself. This resource adjusts a function deployed outside the
+ * Stack, and restores
+ * the settings it found when destroyed. Modal resets overrides like these
+ * when the app is redeployed, so redeploying the app and then this stack
+ * applies them again.
+ *
+ * ### Keeping containers warm
+ * **Example:** Two warm containers during business hours
+ * ```typescript
+ * import * as Modal from "@alchemy.run/modal";
+ *
+ * export const Warm = Modal.FunctionAutoscaler("Warm", {
+ *   app: "inference",
+ *   function: "Model.*",
+ *   minContainers: 2,
+ *   bufferContainers: 1,
+ *   scaledownWindow: "5 minutes",
+ * });
+ * ```
+ *
+ * @resource
+ * @product Function
+ */
+export declare const FunctionAutoscaler: import("alchemy/Resource").ResourceConstructor<FunctionAutoscaler, Providers> & Effect.Effect<import("alchemy/Resource").ResourceConstructor<FunctionAutoscaler, never>, never, never> & {
+    Self: import("alchemy/Self").Self<FunctionAutoscaler>;
+    Provider: Provider.Provider<FunctionAutoscaler>;
+    Aliases: readonly string[] | undefined;
+    ref(id: string, options?: {
+        stage?: string;
+        stack?: string;
+    }): Effect.Effect<FunctionAutoscaler, never, never>;
+} & ((id: string, props: import("./internal/Declared.ts").DeclaredProps<FunctionAutoscalerProps>) => Effect.Effect<FunctionAutoscaler, never, Providers>);
+export type FunctionAutoscaler = Resource<"Modal.FunctionAutoscaler", FunctionAutoscalerProps, FunctionAutoscalerAttributes, never, Providers>;
+export declare const FunctionAutoscalerProvider: () => import("effect/Layer").Layer<Provider.Provider<FunctionAutoscaler>, never, functions.ModalOpContext>;
+export {};
+//# sourceMappingURL=FunctionAutoscaler.d.ts.map

package/lib/FunctionAutoscaler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionAutoscaler.d.ts","sources":["../src/FunctionAutoscaler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,SAAS,MAAM,kCAAkC,CAAC;AAE9D,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,KAAK,gBAAgB,EAAqC,MAAM,eAAe,CAAC;AAEzF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;;;;AAEhD,qBAAa,oCAAqC,SAAQ,0CAExD;IACA,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;AAEL,MAAM,WAAW,uBAAuB;IACtC,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,gBAAgB,CAAC;IAC/B,sEAAsE;IACtE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,oEAAoE;IACpE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yFAAyF;IACzF,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oFAAoF;IACpF,eAAe,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAClC,oEAAoE;IACpE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAChC,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,2DAA2D;AAC3D,MAAM,WAAW,uBAAuB;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,MAAM,WAAW,4BAA4B;IAC3C,4BAA4B;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,oDAAoD;IACpD,QAAQ,EAAE,uBAAuB,CAAC;IAClC,uEAAuE;IACvE,QAAQ,EAAE,uBAAuB,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;yJAE9B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CACvC,0BAA0B,EAC1B,uBAAuB,EACvB,4BAA4B,EAC5B,KAAK,EACL,SAAS,CACV,CAAC;AA6BF,eAAO,MAAM,0BAA0B,4GA8EpC,CAAC"}