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

package/src/ScaleFunction.ts

@@ -0,0 +1,70 @@
+import type * as functions from "@distilled.cloud/modal/functions";
+import * as Binding from "alchemy/Binding";
+import type { RuntimeContext } from "alchemy/RuntimeContext";
+import type * as Effect from "effect/Effect";
+import type { FunctionLookupError } from "./FunctionTarget.ts";
+import type { OpError } from "./internal.ts";
+import type { FunctionTarget } from "./InvokeFunction.ts";
+import type { ScaleFunctionOps } from "./ScaleFunctionHttp.ts";
+import type { Server } from "./Server.ts";
+
+/** Autoscaler settings to override; unset fields keep their value. */
+export interface AutoscalerOverride {
+  /** Containers kept running regardless of demand. */
+  readonly minContainers?: number;
+  /** Most containers running at once. */
+  readonly maxContainers?: number;
+  /** Idle containers kept on top of demand while busy. */
+  readonly bufferContainers?: number;
+  /** Seconds of sustained demand before scaling up. */
+  readonly scaleupWindow?: number;
+  /** Seconds a container may stay idle before it scales down. */
+  readonly scaledownWindow?: number;
+  /** A Server's target concurrent requests per container (fractional allowed). */
+  readonly targetConcurrency?: number;
+}
+
+/** Change a function's autoscaler at runtime. */
+export interface FunctionScaler {
+  /** The settings in effect. */
+  autoscaler(): Effect.Effect<
+    functions.AutoscalerSettings | undefined,
+    FunctionLookupError | OpError<ScaleFunctionOps, "schedulingParams">,
+    RuntimeContext
+  >;
+  /**
+   * Override settings until the next deploy, which restores the declared
+   * ones. Returns the settings now in effect.
+   */
+  update(
+    settings: AutoscalerOverride,
+  ): Effect.Effect<
+    functions.AutoscalerSettings | undefined,
+    FunctionLookupError | OpError<ScaleFunctionOps, "schedulingParams" | "updateSchedulingParams">,
+    RuntimeContext
+  >;
+}
+
+/**
+ * Scale a Modal Function or Server from a running program: keep containers
+ * warm ahead of a launch, or cap them at night. Overrides last until the
+ * next deploy; use the resource's own props (or `Modal.FunctionAutoscaler`
+ * for a function deployed outside the Stack) for the steady state.
+ *
+ * ### Warm up ahead of traffic
+ * **Example:** From a scheduled Worker
+ * ```typescript
+ * const generate = yield* Modal.ScaleFunction(Generate);
+ * yield* generate.update({ minContainers: 4, bufferContainers: 2 });
+ * ```
+ *
+ * @binding
+ * @product Function
+ */
+export interface ScaleFunction extends Binding.Service<
+  ScaleFunction,
+  "Modal.ScaleFunction",
+  (target: FunctionTarget | Server) => Effect.Effect<FunctionScaler>
+> {}
+
+export const ScaleFunction = Binding.Service<ScaleFunction>("Modal.ScaleFunction");

package/src/ScaleFunctionHttp.ts

@@ -0,0 +1,54 @@
+import * as functions from "@distilled.cloud/modal/functions";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { makeFunctionBinding } from "./FunctionTarget.ts";
+import { operations } from "./internal.ts";
+import type { FunctionTarget } from "./InvokeFunction.ts";
+import { ScaleFunction, type FunctionScaler } from "./ScaleFunction.ts";
+import type { Server } from "./Server.ts";
+
+/** The operations the client calls, resolved by `ModalBindings.withCredentials`. */
+const ScaleFunctionOps = operations({
+  schedulingParams: functions.functionGetSchedulingParams,
+  updateSchedulingParams: functions.functionUpdateSchedulingParams,
+});
+
+export type ScaleFunctionOps = Effect.Success<typeof ScaleFunctionOps>;
+
+/**
+ * {@link ScaleFunction} over Modal's API. Grants the host's identity (a scoped
+ * `Modal.ServiceUser`) the `contributor` role on the function's environment.
+ *
+ * @layer
+ * @product Function
+ * @provides Modal.ScaleFunction
+ */
+export const ScaleFunctionHttp = Layer.effect(
+  ScaleFunction,
+  makeFunctionBinding({
+    tag: "Modal.ScaleFunction",
+    operations: ScaleFunctionOps,
+    role: "contributor",
+    make: ({ functionId }, ops, _target: FunctionTarget | Server) =>
+      Effect.succeed({
+        autoscaler: () =>
+          Effect.flatMap(functionId, (id) => ops.schedulingParams({ functionId: id })).pipe(
+            Effect.map((response) => response.autoscalerConfiguration?.settings),
+          ),
+        update: (settings) =>
+          Effect.flatMap(functionId, (id) =>
+            ops.updateSchedulingParams({
+              functionId: id,
+              settings: {
+                minContainers: settings.minContainers,
+                maxContainers: settings.maxContainers,
+                bufferContainers: settings.bufferContainers,
+                scaleupWindow: settings.scaleupWindow,
+                scaledownWindow: settings.scaledownWindow,
+                targetConcurrencyFloat: settings.targetConcurrency,
+              },
+            }),
+          ).pipe(Effect.map((response) => response.currentSettings)),
+      } satisfies FunctionScaler),
+  }),
+);

package/src/Secret.ts

@@ -0,0 +1,296 @@
+import * as secret from "@distilled.cloud/modal/secret";
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Provider from "alchemy/Provider";
+import { Resource } from "alchemy/Resource";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+import {
+  type EnvironmentInput,
+  envNameOf,
+  environmentNames,
+  environmentOf,
+  isGeneratedName,
+  listAll,
+  objectName,
+} from "./internal.ts";
+import { declarable } from "./internal/Declared.ts";
+import type { Providers } from "./Providers.ts";
+import { isRuntimeName } from "./RuntimeOwner.ts";
+
+export class SecretUnexpectedResponse extends Data.TaggedError("Modal.SecretUnexpectedResponse")<{
+  readonly message: string;
+}> {}
+
+export interface SecretProps {
+  /**
+   * Secret name, unique per environment. If omitted, a unique name is
+   * generated from the stack, stage and logical ID. Changing it replaces the
+   * secret.
+   */
+  name?: string;
+  /**
+   * Environment the secret lives in. Changing it replaces the secret.
+   * @default the workspace's default environment
+   */
+  environment?: EnvironmentInput;
+  /**
+   * The secret's environment variables. Containers that attach the secret
+   * see each entry as an environment variable; an outbound header
+   * replacement can inject one into requests instead, so the container never
+   * sees it. Every deploy writes the full set.
+   */
+  env: Record<string, string | Redacted.Redacted<string>>;
+}
+
+export interface SecretAttributes {
+  /** Secret ID (`st-…`). */
+  secretId: string;
+  /** Secret name. */
+  name: string;
+  /** Environment name, or `undefined` for the workspace default. */
+  environment: string | undefined;
+  /** The secret's variable names (values are never returned by Modal). */
+  keys: string[];
+}
+
+/**
+ * A Modal Secret: a named set of environment variables stored by Modal and
+ * attached to Sandboxes and Functions by reference.
+ *
+ * A Sandbox can see a secret two ways: as environment variables
+ * (`secrets: [OpenAI]`), or through an outbound header replacement
+ * (`outboundPolicy`), where Modal adds the value to matching HTTPS requests
+ * on their way out and the sandbox never holds it. Prefer the second for
+ * credentials an agent's code shouldn't be able to read.
+ *
+ * Modal never returns secret values, so every deploy overwrites the full
+ * `env` map. Modal secrets have no tags; ownership is inferred from Alchemy
+ * state.
+ *
+ * ### Creating a Secret
+ * **Example:** An API key from your Alchemy secrets
+ * ```typescript
+ * import * as Alchemy from "alchemy";
+ * import * as Modal from "@alchemy.run/modal";
+ *
+ * export const OpenAI = Modal.Secret("OpenAI", {
+ *   env: { OPENAI_API_KEY: Alchemy.Secret("OPENAI_API_KEY") },
+ * });
+ * ```
+ *
+ * ### Using a Secret in a Sandbox
+ * **Example:** As environment variables
+ * ```typescript
+ * // construction phase: read the Secret's id
+ * const openaiId = yield* (yield* OpenAI).secretId;
+ * // in a handler
+ * const openai = { secretId: yield* openaiId };
+ * const sandbox = yield* sandboxes.create({ secrets: [openai] });
+ * ```
+ *
+ * **Example:** Injected into outbound requests only
+ * ```typescript
+ * // construction phase: read the Secret's id
+ * const openaiId = yield* (yield* OpenAI).secretId;
+ * // in a handler
+ * const openai = { secretId: yield* openaiId };
+ * const sandbox = yield* sandboxes.create({
+ *   outboundPolicy: {
+ *     routes: [
+ *       {
+ *         https: {
+ *           domains: ["api.openai.com"],
+ *           headerReplacements: [{ secret: openai, headers: { Authorization: "Bearer $OPENAI_API_KEY" } }],
+ *         },
+ *       },
+ *       { any: {} },
+ *     ],
+ *   },
+ * });
+ * ```
+ *
+ * ### Rotating a Secret at runtime
+ * **Example:** Bind write access
+ * ```typescript
+ * const openai = yield* Modal.WriteSecret(OpenAI);
+ * yield* openai.put({ OPENAI_API_KEY: newKey });
+ * ```
+ *
+ * ### Looking up an existing secret
+ * `Secret.lookup` references a secret Alchemy doesn't manage (created with
+ * the Modal CLI or by another stack). It is read during plan/deploy, never
+ * created, updated or deleted. Its values are never read; `keys` lists their
+ * names.
+ *
+ * **Example:** Reference an existing secret
+ * ```typescript
+ * const openai = Modal.Secret.lookup({ name: "openai" });
+ * ```
+ *
+ * @resource
+ * @product Secret
+ */
+export const Secret = declarable<Secret>()(Resource<Secret>("Modal.Secret"));
+
+export type Secret = Resource<
+  "Modal.Secret",
+  SecretProps,
+  SecretAttributes,
+  never,
+  Providers,
+  SecretLookup
+>;
+
+/**
+ * Props for {@link Secret.lookup}: find a secret this stack
+ * doesn't manage by its name.
+ */
+export interface SecretLookup {
+  /** Secret name. */
+  name: string;
+  /**
+   * Modal environment the object lives in.
+   * @default the workspace's default environment
+   */
+  environment?: string;
+}
+
+const plainEnv = (env: Record<string, string | Redacted.Redacted<string>>) =>
+  Object.fromEntries(
+    Object.entries(env).map(([key, value]) => [
+      key,
+      Redacted.isRedacted(value) ? Redacted.value(value) : value,
+    ]),
+  );
+
+/** A secret by name, or `undefined` when missing. */
+export const lookupSecret = Effect.fn(function* (
+  getOrCreate: Effect.Success<typeof secret.secretGetOrCreate>,
+  name: string,
+  env: string | undefined,
+) {
+  const found = yield* getOrCreate({
+    deploymentName: name,
+    environmentName: environmentOf(env),
+    objectCreationType: "OBJECT_CREATION_TYPE_UNSPECIFIED",
+  }).pipe(Effect.catchTag("SecretNotFound", () => Effect.undefined));
+  if (!found?.secretId) return undefined;
+  return {
+    secretId: found.secretId,
+    name,
+    environment: env,
+    keys: found.metadata?.keys ?? [],
+  } satisfies SecretAttributes;
+});
+
+/**
+ * Create or overwrite a secret by name: the one implementation behind
+ * {@link Secret}'s reconcile and the runtime {@link CreateSecret} and
+ * {@link WriteSecret} clients.
+ */
+export const putSecret = Effect.fn(function* (
+  getOrCreate: Effect.Success<typeof secret.secretGetOrCreate>,
+  name: string,
+  env: string | undefined,
+  values: Record<string, string | Redacted.Redacted<string>>,
+) {
+  const written = yield* getOrCreate({
+    deploymentName: name,
+    environmentName: environmentOf(env),
+    objectCreationType: "OBJECT_CREATION_TYPE_CREATE_OVERWRITE_IF_EXISTS",
+    envDict: plainEnv(values),
+  });
+  if (!written.secretId) {
+    return yield* new SecretUnexpectedResponse({
+      message: `Modal returned no id for secret ${name}`,
+    });
+  }
+  return {
+    secretId: written.secretId,
+    name,
+    environment: env,
+    keys: written.metadata?.keys ?? Object.keys(values).sort(),
+  } satisfies SecretAttributes;
+});
+
+export const SecretProvider = () =>
+  Provider.effect(
+    Secret,
+    Effect.gen(function* () {
+      return {
+        // An overwrite gives the secret a new id, so only its name is stable.
+        stables: ["name", "environment"],
+        diff: Effect.fn(function* ({ id, news, olds, output }) {
+          if (!isResolved(news)) return undefined;
+          if (envNameOf(news.environment) !== envNameOf(olds?.environment))
+            return { action: "replace" } as const;
+          const name = yield* objectName(id, news.name);
+          if (output !== undefined && name !== output.name) return { action: "replace" } as const;
+          return undefined;
+        }),
+        lookup: Effect.fn(function* ({ name, environment }) {
+          return yield* lookupSecret(yield* secret.secretGetOrCreate, name, environment);
+        }),
+
+        read: Effect.fn(function* ({ id, olds, output }) {
+          const name = output?.name ?? (yield* objectName(id, olds?.name));
+          const observed = yield* lookupSecret(
+            yield* secret.secretGetOrCreate,
+            name,
+            output?.environment ?? envNameOf(olds?.environment),
+          );
+          if (!observed) return undefined;
+          return output !== undefined || olds?.name === undefined ? observed : Unowned(observed);
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output, session }) {
+          const name = output?.name ?? (yield* objectName(id, news.name));
+          // Values can't be observed, so overwriting is the sync: Modal
+          // replaces the secret atomically, under a new secret id.
+          yield* session.note(`Writing secret ${name}...`);
+          return yield* putSecret(
+            yield* secret.secretGetOrCreate,
+            name,
+            envNameOf(news.environment),
+            news.env,
+          );
+        }),
+        delete: Effect.fn(function* ({ output }) {
+          yield* secret
+            .deleteSecret({ secretId: output.secretId })
+            .pipe(Effect.catchTag("SecretNotFound", () => Effect.void));
+        }),
+        list: Effect.fn(function* () {
+          const envs = yield* environmentNames;
+          const all: SecretAttributes[] = [];
+          for (const env of envs) {
+            const items = yield* listAll(
+              (pagination) =>
+                secret
+                  .listSecret({ environmentName: env, pagination })
+                  .pipe(Effect.map((response) => response.items ?? [])),
+              (item) => item.createdAt,
+            );
+            for (const item of items) {
+              if (
+                !item.secretId ||
+                !(
+                  isGeneratedName(item.label ?? item.metadata?.name) ||
+                  isRuntimeName(item.label ?? item.metadata?.name)
+                )
+              )
+                continue;
+              all.push({
+                secretId: item.secretId,
+                name: item.label ?? item.metadata?.name ?? "",
+                environment: env,
+                keys: item.metadata?.keys ?? [],
+              });
+            }
+          }
+          return all;
+        }),
+      };
+    }),
+  );

package/src/Server.ts

@@ -0,0 +1,285 @@
+import * 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 * as Effect from "effect/Effect";
+import * as Schedule from "effect/Schedule";
+import type { ContainerProps } from "./Container.ts";
+import { environmentOf, seconds } from "./internal.ts";
+import { ENTRYPOINT, RPC_SERVE_ENV } from "./internal/Entrypoint.ts";
+import { createModalRuntimeContext } from "./internal/Rpc.ts";
+import {
+  resolveContainerProps,
+  runtimeLifecycle,
+  type RuntimeAttributes,
+} from "./internal/Runtime.ts";
+import type { MountContract } from "./Mounts.ts";
+import type { Providers } from "./Providers.ts";
+import type { DurationInput } from "./SandboxClient.ts";
+
+export interface ServerProps extends ContainerProps {
+  /**
+   * Region requests are routed through (`"us-east"`, `"us-west"`, `"eu-west"`,
+   * `"ap-south"`, ...). Containers run near it.
+   * @default "us-east"
+   */
+  routingRegion?: string;
+  /**
+   * Serve without Modal's proxy auth. By default every request needs the
+   * `Modal-Key` / `Modal-Secret` headers of a `Modal.WebhookToken`.
+   * @default false
+   */
+  unauthenticated?: boolean;
+  /** Serve HTTP/2 to the program. */
+  h2?: boolean;
+  /**
+   * Time in-flight requests get to finish when a container shuts down, at
+   * most an hour.
+   * @default 0
+   */
+  exitGracePeriod?: DurationInput;
+  /**
+   * Concurrent requests per container the autoscaler aims for; may be
+   * fractional (`1.5`). `0` turns autoscaling off.
+   */
+  targetConcurrency?: number;
+  /**
+   * Most concurrent requests per container; more get `429`.
+   * @default unlimited
+   */
+  maxConcurrency?: number;
+  /**
+   * Sticky sessions: each session is pinned to one container
+   * (`server.sessions.start()` in Modal's clients).
+   * @default false
+   */
+  sessioned?: boolean;
+}
+
+export interface ServerAttributes extends RuntimeAttributes {
+  /** The Server's URL. */
+  url: string | undefined;
+  /** Region requests are routed through. */
+  routingRegion: string;
+  /** Whether requests skip Modal's proxy auth. */
+  unauthenticated: boolean;
+}
+
+export type Server = Resource<
+  "Modal.Server",
+  ServerProps,
+  ServerAttributes,
+  { env?: Record<string, any>; mounts?: MountContract; rpcCallers?: string[] },
+  Providers
+>;
+
+export type ServerServices = ServerHost;
+/**
+ * What the program returns: `fetch` for HTTP, and any other functions,
+ * its RPC methods.
+ */
+export type ServerShape =
+  | Main<ServerServices>
+  | (Exclude<Main<ServerServices>, void> & MainRpc<ServerServices>);
+export type ServerRuntimeContext = HostRuntimeContext;
+
+/**
+ * A Modal Server: your program as a long-running HTTP server on Modal, with
+ * low-latency routing through one region and autoscaling on concurrent
+ * requests. Use it for APIs, model servers and anything that keeps
+ * connections open; use `Modal.Function` with `web` for simple endpoints.
+ *
+ * Alchemy bundles `main`, builds it into an image on Modal's builder (no
+ * Docker) and deploys the Server into its `Modal.App`. Each container starts
+ * the program, and Modal routes the Server's URL to its `fetch` handler.
+ * Requests need Modal's proxy auth headers unless `unauthenticated` is set:
+ * bind `Modal.FetchServer(server)` to call it from another runtime.
+ *
+ * ### Effect program
+ * **Example:** An API server
+ * ```typescript
+ * // src/Api.ts
+ * import * as Modal from "@alchemy.run/modal";
+ * import * as Effect from "effect/Effect";
+ * import * as HttpServerResponse from "effect/http/HttpServerResponse";
+ * import { Backend } from "./Backend.ts";
+ *
+ * export default class Api extends Modal.Server<Api>()(
+ *   "Api",
+ *   { main: import.meta.url, app: Backend, routingRegion: "us-east" },
+ *   Effect.gen(function* () {
+ *     return {
+ *       fetch: Effect.succeed(HttpServerResponse.text("ok")),
+ *     };
+ *   }),
+ * ) {}
+ * ```
+ *
+ * ### Async program
+ * **Example:** A plain HTTP server, no Effect (it runs on Bun)
+ * ```typescript
+ * // src/Api.ts
+ * import * as Modal from "@alchemy.run/modal";
+ * import { Backend } from "./Backend.ts";
+ *
+ * export const Api = Modal.Server("Api", {
+ *   main: "./src/api-server.ts",
+ *   app: Backend,
+ *   unauthenticated: true,
+ *   env: { GREETING: "hello" },
+ * });
+ * export type ApiEnv = Modal.InferEnv<typeof Api>;
+ * ```
+ *
+ * ```typescript
+ * // src/api-server.ts
+ * import type { ApiEnv } from "./Api.ts";
+ *
+ * const env = process.env as unknown as ApiEnv;
+ *
+ * Bun.serve({ port: Number(process.env.PORT), fetch: () => new Response(env.GREETING) });
+ * ```
+ *
+ * ### Calling it
+ * **Example:** From a Cloudflare Worker, with proxy auth
+ * ```typescript
+ * const api = yield* Modal.FetchServer(Api);
+ * const response = yield* api.fetch(HttpClientRequest.get("/"));
+ * ```
+ *
+ * ### Scaling
+ * **Example:** Two warm containers, 20 requests each
+ * ```typescript
+ * export default class Api extends Modal.Server<Api>()(
+ *   "Api",
+ *   {
+ *     main: import.meta.url,
+ *     app: Backend,
+ *     minContainers: 2,
+ *     targetConcurrency: 20,
+ *     maxConcurrency: 50,
+ *     exitGracePeriod: "30 seconds",
+ *   },
+ *   program,
+ * ) {}
+ * ```
+ *
+ * @resource
+ * @product Server
+ */
+export const Server: Platform<Server, ServerServices, ServerShape, ServerRuntimeContext> = Platform(
+  "Modal.Server",
+  {
+    createRuntimeContext: createModalRuntimeContext("Modal.Server"),
+    transformProps: resolveContainerProps,
+  },
+);
+
+const bootstrapEntry =
+  (handler: string) =>
+  (importPath: string): string =>
+    `
+import { bootstrap } from "@alchemy.run/modal/Bootstrap";
+import { ${handler} as entrypoint } from ${JSON.stringify(importPath)};
+
+await bootstrap(entrypoint);
+`;
+
+const DEFAULT_REGION = "us-east";
+
+const definitionOf = (
+  props: ServerProps,
+  context: { readonly port: number; readonly startupTimeout: number },
+): functions.Function => {
+  const region = props.routingRegion ?? DEFAULT_REGION;
+  return {
+    implementationName: ENTRYPOINT.server,
+    isServer: true,
+    isSessioned: props.sessioned ?? false,
+    routingRegion: region,
+    httpConfig: {
+      port: context.port,
+      proxyRegions: [region],
+      startupTimeout: Math.round(context.startupTimeout),
+      exitGracePeriod: Math.round(seconds(props.exitGracePeriod) ?? 0),
+      h2Enabled: props.h2 ?? false,
+      unauthenticated: props.unauthenticated ?? false,
+    },
+    maxConcurrentInputs: props.maxConcurrency ?? 0,
+    supportedInputFormats: [],
+    supportedOutputFormats: [],
+  };
+};
+
+export const ServerProvider = () =>
+  Provider.effect(
+    Server,
+    Effect.gen(function* () {
+      const lifecycle = yield* runtimeLifecycle<ServerProps>({
+        type: "Modal.Server",
+        definition: (props, context) => {
+          const definition = definitionOf(props, context);
+          return props.targetConcurrency === undefined
+            ? definition
+            : {
+                ...definition,
+                autoscalerSettings: { targetConcurrencyFloat: props.targetConcurrency },
+              };
+        },
+        bootstrap: bootstrapEntry,
+        // Behind proxy auth Modal authenticates every request, so the
+        // program serves RPC; an unauthenticated Server never does.
+        env: (props): Record<string, string> =>
+          props.unauthenticated ? {} : { [RPC_SERVE_ENV]: "1" },
+      });
+
+      /** The Server's URL: Modal assigns it once the App is published. */
+      const urlOf = Effect.fn(function* (
+        attributes: RuntimeAttributes,
+        published: ReadonlyArray<string> | undefined,
+      ) {
+        if (published?.[0]) return published[0];
+        const found = yield* functions
+          .getFunction({
+            appName: attributes.appName ?? "",
+            objectTag: attributes.name,
+            environmentName: environmentOf(attributes.environment),
+          })
+          .pipe(
+            Effect.map((response) => response.handleMetadata?.ExperimentalFlashUrls?.[0]),
+            Effect.repeat({
+              schedule: Schedule.spaced("2 seconds"),
+              until: (url) => url !== undefined,
+              times: 10,
+            }),
+          );
+        return found;
+      });
+
+      return {
+        stables: lifecycle.stables,
+        diff: lifecycle.diff,
+        read: Effect.fn(function* ({ output }) {
+          const found = yield* lifecycle.read({ output });
+          return found === undefined ? undefined : (output as ServerAttributes);
+        }),
+        reconcile: Effect.fn(function* ({ id, news, output, session, bindings }) {
+          const { attributes, metadata } = yield* lifecycle.reconcile({
+            id,
+            news,
+            output,
+            session,
+            bindings,
+          });
+          return {
+            ...attributes,
+            url: yield* urlOf(attributes, metadata?.ExperimentalFlashUrls),
+            routingRegion: news.routingRegion ?? DEFAULT_REGION,
+            unauthenticated: news.unauthenticated ?? false,
+          };
+        }),
+        delete: lifecycle.delete,
+      };
+    }),
+  );