@alchemy.run/fly 0.0.0 → 2.0.0-beta.85

package/lib/hosted.d.ts

@@ -0,0 +1,171 @@
+import type { Docker } from "@alchemy.run/docker/Docker";
+import type { FlyMachineService } from "@distilled.cloud/fly-io/machines";
+import * as machines from "@distilled.cloud/fly-io/machines";
+import * as Bundle from "alchemy/Bundle/Bundle";
+import { type PackageInstall } from "alchemy/Bundle/InstalledPackages";
+import type { ResourceBinding } from "alchemy/Resource";
+import { type HostRuntimeContext } from "alchemy/Runtime/Process";
+import { extraFileDestination, type ExtraFile } from "alchemy/Util/extraFiles";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import type * as rolldown from "rolldown";
+import type { BoundTarget, DiskSpec, ServiceBinding } from "./MountVolume.ts";
+export type FlyHostRuntimeContext = HostRuntimeContext;
+/**
+ * Container runtime context for Fly hosts. It also serves the program's RPC
+ * methods to bound callers (see {@link serveFlyRpc}) and boots the HTTP
+ * server for a program that exposes methods but no `fetch`.
+ */
+export declare const createFlyHostRuntimeContext: (type: string) => (id: string) => HostRuntimeContext;
+export declare const FLY_REGISTRY = "registry.fly.io";
+export declare const DEFAULT_BASE_IMAGE = "node:26-slim";
+export declare const DEFAULT_PORT = 3000;
+export declare const MACHINE_PLATFORM = "linux/amd64";
+export interface FlyBuildOptions extends Bundle.BundleConfig {
+    /**
+     * Native or Node-only packages to install into the Machine image with
+     * `npm install` instead of bundling them. Same `build.install` shape as
+     * Lambda.
+     *
+     * @example
+     * ```typescript
+     * build: { install: ["sharp"] }
+     * ```
+     */
+    readonly install?: PackageInstall;
+    /**
+     * Build the image on Fly's remote builders (Depot), as `fly deploy` does,
+     * instead of with the local Docker engine. Only the build context is
+     * uploaded; the builder pulls the base image and pushes the result to
+     * `registry.fly.io` next to it. Set `false` to build and push locally.
+     * Either way, the local `docker buildx` client drives the build.
+     *
+     * @default true
+     */
+    readonly remote?: boolean;
+}
+export type { ExtraFile };
+export interface HostedProgramProps {
+    main: string;
+    handler?: string;
+    port?: number;
+    image?: string;
+    env?: Record<string, any>;
+    isExternal?: boolean;
+    build?: FlyBuildOptions;
+    /**
+     * Extra host directories baked into the image (framework client
+     * assets, Next.js `.next`, …). Hashed into `code.hash` so asset
+     * changes rebuild the image.
+     */
+    extraFiles?: ReadonlyArray<ExtraFile>;
+}
+export { extraFileDestination };
+declare const DeployTokenMissing_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: "Fly.DeployTokenMissing";
+} & Readonly<A>;
+export declare class DeployTokenMissing extends DeployTokenMissing_base<{
+    appName: string;
+}> {
+}
+/** Unwrap env inputs while preserving serialized RuntimeContext markers. */
+export declare const plainEnvValue: (value: unknown) => string | undefined;
+export declare const toEnvRecord: (env: Record<string, any> | undefined) => Record<string, string>;
+export declare const collectBindingState: (bindings: readonly ResourceBinding<ServiceBinding>[]) => {
+    env: Record<string, string>;
+    mounts: DiskSpec[];
+    redis: {
+        name: string;
+        id?: string;
+    }[];
+    buckets: {
+        name: string;
+        id?: string;
+        values?: Record<string, string>;
+    }[];
+    postgres: {
+        clusterId: string;
+        variableName?: string;
+    }[];
+    targets: BoundTarget[];
+};
+/**
+ * HTTP 80 → HTTPS redirect plus HTTPS 443 for public Services. Private
+ * (Flycast-only) Services publish plain HTTP on 80: Fly issues no
+ * certificate for `.flycast`, so a redirect to HTTPS would break callers.
+ */
+export declare const defaultHttpServices: (port: number, count?: number, isPublic?: boolean) => FlyMachineService[];
+export declare const createFlyHostedSupport: ({ stackName, stage, virtualEntryPlugin, docker, dotAlchemy, }: {
+    stackName: string;
+    stage: string;
+    virtualEntryPlugin: (content: (importPath: string) => string) => rolldown.Plugin;
+    docker: Docker["Service"];
+    dotAlchemy: string;
+}) => {
+    alchemyEnv: {
+        ALCHEMY_STACK_NAME: string;
+        ALCHEMY_STAGE: string;
+        ALCHEMY_PHASE: string;
+        HOST: string;
+    };
+    bundleProgram: (props: HostedProgramProps) => Effect.Effect<{
+        files: {
+            path: string;
+            content: Uint8Array<ArrayBufferLike>;
+        }[];
+        hash: string;
+    }, Bundle.BundleError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+    computeCodeHash: (props: HostedProgramProps) => Effect.Effect<{
+        bundled: {
+            files: {
+                path: string;
+                content: Uint8Array<ArrayBufferLike>;
+            }[];
+            hash: string;
+        };
+        dockerfile: string;
+        codeHash: string;
+        packageJson: string | undefined;
+        entryRel: string | undefined;
+    }, Bundle.BundleError | import("effect/PlatformError").PlatformError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+    resolveImage: (input: {
+        id: string;
+        appName: string;
+        props: HostedProgramProps;
+        previousHash?: string;
+        session?: {
+            note: (message: string) => Effect.Effect<void>;
+        };
+    }) => Effect.Effect<{
+        imageRef: string;
+        codeHash: string;
+    }, any, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path | import("alchemy/Stack").Stack | import("alchemy/Stage").Stage | machines.FlyIoOpContext>;
+    hash: (props: HostedProgramProps) => Effect.Effect<string, Bundle.BundleError | import("effect/PlatformError").PlatformError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path>;
+};
+/**
+ * Bundle a Sprite program the same way {@link createFlyHostedSupport}
+ * bundles a Service — rolldown + Node bootstrap — without building a
+ * Docker image. The provider writes the files onto the Sprite.
+ */
+export declare const createSpriteHostedSupport: ({ stackName, stage, virtualEntryPlugin, }: {
+    stackName: string;
+    stage: string;
+    virtualEntryPlugin: (content: (importPath: string) => string) => rolldown.Plugin;
+}) => {
+    alchemyEnv: {
+        ALCHEMY_STACK_NAME: string;
+        ALCHEMY_STAGE: string;
+        ALCHEMY_PHASE: string;
+        HOST: string;
+    };
+    bundleProgram: (props: HostedProgramProps) => Effect.Effect<{
+        files: {
+            path: string;
+            content: Uint8Array<ArrayBufferLike>;
+        }[];
+        hash: string;
+    }, Bundle.BundleError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+    hash: (props: HostedProgramProps) => Effect.Effect<string, Bundle.BundleError | import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
+};
+//# sourceMappingURL=hosted.d.ts.map

package/lib/hosted.d.ts.map

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

package/lib/hosted.js

@@ -0,0 +1,458 @@
+import * as machines from "@distilled.cloud/fly-io/machines";
+import * as Bundle from "alchemy/Bundle/Bundle";
+import { matchesPackageRoot, normalizeInstallTargets, resolvePackageInstallIdentity, } from "alchemy/Bundle/InstalledPackages";
+import { findCwdForBundle, getStableContextDir, resolveMainPath } from "alchemy/Bundle/TempRoot";
+import { safeHttpEffect } from "alchemy/Http";
+import { createContainerRuntimeContext } from "alchemy/Runtime/Process";
+import { copyExtraFiles, contextRootOf, extraFileDestination, hashExtraFiles, isContextRootDest, posixRelUnder, resolveExtraSource, } from "alchemy/Util/extraFiles";
+import { sha256, sha256Object } from "alchemy/Util/sha256";
+import * as Data from "effect/Data";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Path from "effect/Path";
+import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
+import { buildOnRemoteBuilder } from "./internal/RemoteBuilder.js";
+import { rpcMethodsOf, serveFlyRpc } from "./rpc.js";
+/**
+ * Container runtime context for Fly hosts. It also serves the program's RPC
+ * methods to bound callers (see {@link serveFlyRpc}) and boots the HTTP
+ * server for a program that exposes methods but no `fetch`.
+ */
+export const createFlyHostRuntimeContext = (type) => (id) => {
+    const base = createContainerRuntimeContext(type)(id);
+    const serveBase = base.serve;
+    const serve = (handler, options) => {
+        const shape = options?.shape;
+        const methods = rpcMethodsOf(shape);
+        // `safeHttpEffect` also resolves a `fetch` given as an Effect that
+        // builds the handler.
+        const wrapped = serveFlyRpc(methods, safeHttpEffect(handler));
+        const boots = shape === undefined || shape.fetch !== undefined || Object.keys(methods).length > 0;
+        return serveBase(wrapped, boots ? { shape: { ...shape, fetch: shape?.fetch ?? wrapped } } : options);
+    };
+    return Object.assign(base, { serve });
+};
+export const FLY_REGISTRY = "registry.fly.io";
+export const DEFAULT_BASE_IMAGE = "node:26-slim";
+export const DEFAULT_PORT = 3000;
+export const MACHINE_PLATFORM = "linux/amd64";
+export { extraFileDestination };
+const matchesConfiguredExternal = (external, moduleId, parentId, isResolved) => {
+    if (external === undefined)
+        return false;
+    if (typeof external === "function") {
+        return external(moduleId, parentId, isResolved) === true;
+    }
+    const matchers = Array.isArray(external) ? external : [external];
+    return matchers.some((matcher) => typeof matcher === "string" ? matcher === moduleId : matcher.test(moduleId));
+};
+export class DeployTokenMissing extends Data.TaggedError("Fly.DeployTokenMissing") {
+}
+/**
+ * The generated entry for `Fly.Service` / `Fly.Sprite` machines: a shim
+ * importing only `@alchemy.run/fly/Bootstrap` plus the user's `main` —
+ * see that module for why the entry never imports alchemy's own
+ * dependencies. The runtime flag is raised BEFORE the user's module is
+ * evaluated (hence the dynamic import) so its module-scope code sees it.
+ */
+const makeBunBootstrap = (handler) => (importPath) => `
+import { bootstrap } from "@alchemy.run/fly/Bootstrap";
+
+globalThis.__ALCHEMY_RUNTIME__ = true;
+const { ${handler}: entrypoint } = await import(${JSON.stringify(importPath)});
+
+await bootstrap(entrypoint);
+`;
+/** Unwrap env inputs while preserving serialized RuntimeContext markers. */
+export const plainEnvValue = (value) => {
+    if (value === undefined || value === null)
+        return undefined;
+    if (Redacted.isRedacted(value))
+        return value.pipe(Redacted.value, plainEnvValue);
+    if (typeof value === "string") {
+        return value.length > 0 ? value : undefined;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return undefined;
+};
+export const toEnvRecord = (env) => Object.fromEntries(Object.entries(env ?? {}).flatMap(([key, value]) => {
+    const raw = plainEnvValue(value);
+    return raw === undefined ? [] : [[key, raw]];
+}));
+const coerceBindingName = (value) => {
+    const direct = plainEnvValue(value);
+    if (direct !== undefined)
+        return direct;
+    if (value != null && typeof value === "object") {
+        const record = value;
+        return (coerceBindingName(record.name) ??
+            coerceBindingName(record.id) ??
+            coerceBindingName(record.addOnId));
+    }
+    return undefined;
+};
+export const collectBindingState = (bindings) => {
+    const active = bindings.filter((binding) => binding.action !== "delete");
+    const env = toEnvRecord(active
+        .map((binding) => binding?.data?.env)
+        .reduce((acc, value) => ({ ...acc, ...value }), {}));
+    const mounts = [];
+    const seen = new Set();
+    const redis = [];
+    const buckets = [];
+    const postgres = [];
+    const targets = [];
+    for (const binding of active) {
+        const target = binding?.data?.target;
+        if (target !== undefined)
+            targets.push(target);
+        for (const mount of binding?.data?.mounts ?? []) {
+            if (seen.has(mount.path))
+                continue;
+            seen.add(mount.path);
+            mounts.push(mount);
+        }
+        const attached = binding?.data?.redis;
+        const redisName = coerceBindingName(attached?.name);
+        const redisId = coerceBindingName(attached?.id);
+        if (redisName !== undefined || redisId !== undefined) {
+            redis.push({ name: redisName ?? "", id: redisId });
+        }
+        const bucket = binding?.data?.bucket;
+        const bucketName = coerceBindingName(bucket?.name);
+        const bucketId = coerceBindingName(bucket?.id) ?? coerceBindingName(bucket?.addOnId);
+        if (bucketName !== undefined || bucketId !== undefined) {
+            // The bound Bucket's attributes carry the create-time Tigris
+            // credentials, which Fly's add-on lookup often returns empty.
+            const values = {};
+            for (const [key, value] of [
+                ["BUCKET_NAME", bucket?.bucketName],
+                ["AWS_ACCESS_KEY_ID", bucket?.accessKeyId],
+                ["AWS_SECRET_ACCESS_KEY", bucket?.secretAccessKey],
+                ["AWS_ENDPOINT_URL_S3", bucket?.endpoint],
+                ["AWS_REGION", bucket?.region],
+            ]) {
+                const plain = plainEnvValue(value);
+                if (plain !== undefined)
+                    values[key] = plain;
+            }
+            buckets.push({ name: bucketName ?? "", id: bucketId, values });
+        }
+        const pg = binding?.data?.postgres;
+        const clusterId = coerceBindingName(pg?.clusterId);
+        if (clusterId !== undefined) {
+            postgres.push({
+                clusterId,
+                variableName: typeof pg?.variableName === "string" && pg.variableName.length > 0
+                    ? pg.variableName
+                    : undefined,
+            });
+        }
+    }
+    return { env, mounts, redis, buckets, postgres, targets };
+};
+/**
+ * HTTP 80 → HTTPS redirect plus HTTPS 443 for public Services. Private
+ * (Flycast-only) Services publish plain HTTP on 80: Fly issues no
+ * certificate for `.flycast`, so a redirect to HTTPS would break callers.
+ */
+export const defaultHttpServices = (port, count = 1, isPublic = true) => [
+    {
+        protocol: "tcp",
+        internal_port: port,
+        autostart: true,
+        autostop: "off",
+        min_machines_running: count,
+        ports: isPublic
+            ? [
+                { port: 80, handlers: ["http"], force_https: true },
+                { port: 443, handlers: ["tls", "http"] },
+            ]
+            : [{ port: 80, handlers: ["http"] }],
+        // Wait until the process is listening before the proxy sends traffic.
+        // Without this, fly.dev hangs (status 0) while Node is still booting.
+        checks: [{ type: "tcp", port, interval: "10s", timeout: "2s", grace_period: "30s" }],
+    },
+];
+const sanitizeImageRepo = (id) => {
+    const lowered = id
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return lowered.length === 0 ? "service" : lowered;
+};
+const generateDockerfile = (props, hasChunks, install, entryRel) => {
+    const port = props.port ?? DEFAULT_PORT;
+    const lines = [`FROM ${props.image ?? DEFAULT_BASE_IMAGE}`, `WORKDIR /app`];
+    if (install !== undefined && Object.keys(install).length > 0) {
+        lines.push(`COPY package.json /app/package.json`, `RUN npm install --omit=dev --no-fund --no-audit`);
+    }
+    if (props.isExternal === true) {
+        lines.push(`COPY . /app`);
+        const entry = entryRel !== undefined && entryRel.length > 0 ? entryRel : "serve-node.mjs";
+        lines.push(`ENV PORT=${String(port)}`, `ENV HOST=0.0.0.0`, `EXPOSE ${String(port)}`, `ENTRYPOINT ["node", ${JSON.stringify(`/app/${entry}`)}]`);
+        return `${lines.join("\n")}\n`;
+    }
+    lines.push(`COPY index.mjs /app/index.mjs`);
+    if (hasChunks) {
+        lines.push(`COPY *.js /app/`);
+    }
+    const seen = new Set();
+    for (const extra of props.extraFiles ?? []) {
+        const dest = extraFileDestination(extra.dest);
+        if (isContextRootDest(dest) || seen.has(dest))
+            continue;
+        seen.add(dest);
+        lines.push(`COPY ${dest} /app/${dest}`);
+    }
+    lines.push(`ENV PORT=${String(port)}`, `ENV HOST=0.0.0.0`, `EXPOSE ${String(port)}`, `ENTRYPOINT ["node", "/app/index.mjs"]`);
+    return `${lines.join("\n")}\n`;
+};
+const installManifest = (dependencies) => `${JSON.stringify({ private: true, type: "module", dependencies }, null, 2)}\n`;
+export const createFlyHostedSupport = ({ stackName, stage, virtualEntryPlugin, docker, dotAlchemy, }) => {
+    const alchemyEnv = {
+        ALCHEMY_STACK_NAME: stackName,
+        ALCHEMY_STAGE: stage,
+        ALCHEMY_PHASE: "runtime",
+        HOST: "0.0.0.0",
+    };
+    const bundleProgram = Effect.fn(function* (props) {
+        const handler = props.handler ?? "default";
+        const realMain = yield* resolveMainPath(props.main);
+        const cwd = yield* findCwdForBundle(realMain);
+        const bootstrap = makeBunBootstrap(handler);
+        const requested = yield* normalizeInstallTargets(props.build?.install);
+        const installRoots = new Set(Object.keys(requested));
+        const configuredExternal = props.build?.input?.external;
+        const buildBundle = Effect.fn(function* (entry, plugins) {
+            return yield* Bundle.build({
+                ...props.build?.input,
+                input: entry,
+                cwd,
+                platform: "node",
+                external: (moduleId, parentId, isResolved) => {
+                    if (moduleId === "bun" || moduleId.startsWith("bun:"))
+                        return true;
+                    for (const root of installRoots) {
+                        if (matchesPackageRoot(moduleId, root))
+                            return true;
+                    }
+                    return matchesConfiguredExternal(configuredExternal, moduleId, parentId, isResolved);
+                },
+                resolve: {
+                    conditionNames: [...Bundle.NODE_CONDITION_NAMES],
+                    ...props.build?.input?.resolve,
+                },
+                plugins: [props.build?.input?.plugins, plugins],
+            }, {
+                ...props.build?.output,
+                format: "esm",
+                sourcemap: props.build?.output?.sourcemap ?? false,
+                entryFileNames: "index.mjs",
+                strictExecutionOrder: true,
+                keepNames: true,
+            }, props.build);
+        });
+        if (props.isExternal === true) {
+            const fs = yield* FileSystem.FileSystem;
+            const path = yield* Path.Path;
+            const bytes = yield* fs.readFile(realMain);
+            const hash = yield* sha256(bytes);
+            return { files: [{ path: path.basename(realMain), content: bytes }], hash };
+        }
+        const bundleOutput = yield* buildBundle(realMain, virtualEntryPlugin(bootstrap));
+        const files = bundleOutput.files.map((file) => ({
+            path: file.path,
+            content: typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content,
+        }));
+        return { files, hash: bundleOutput.hash };
+    });
+    const computeCodeHash = Effect.fn(function* (props) {
+        const bundled = yield* bundleProgram(props);
+        const realMain = yield* resolveMainPath(props.main);
+        const cwd = yield* findCwdForBundle(realMain);
+        const path = yield* Path.Path;
+        const requested = yield* normalizeInstallTargets(props.build?.install);
+        const identity = Object.keys(requested).length > 0
+            ? yield* resolvePackageInstallIdentity({ cwd, requested })
+            : undefined;
+        const install = identity !== undefined && Object.keys(identity.resolved).length > 0
+            ? identity.resolved
+            : undefined;
+        const packageJson = install === undefined ? undefined : installManifest(install);
+        const extras = (props.extraFiles ?? []).map((file) => ({
+            source: file.source,
+            dest: file.dest,
+        }));
+        const root = contextRootOf(realMain, extras, path, (source) => resolveExtraSource(source, path));
+        const entryRel = props.isExternal === true
+            ? (posixRelUnder(root, realMain, path) ?? path.basename(realMain))
+            : undefined;
+        const dockerfile = generateDockerfile(props, bundled.files.length > 1, install, entryRel);
+        const extraFiles = yield* hashExtraFiles(props.extraFiles);
+        const codeHash = (yield* sha256Object({
+            bundleHash: bundled.hash,
+            dockerfile,
+            packageJson,
+            extraFiles,
+            extraFilesIncludesNodeModules: true,
+        })).slice(0, 16);
+        return { bundled, dockerfile, codeHash, packageJson, entryRel };
+    });
+    const imageExists = (imageRef) => docker.image.inspect(imageRef).pipe(Effect.map(() => true), Effect.catchReason("PlatformError", "NotFound", () => Effect.succeed(false)));
+    const pushBackoff = Schedule.exponential("2 seconds");
+    /**
+     * Bundle `main`, content-hash the image, build it when missing, and
+     * push to `registry.fly.io/{appName}:{logicalId}-{hash}` using an
+     * app deploy token. When `previousHash` matches, skip build and push.
+     *
+     * Fly's registry is app-scoped (`/v2/{app}/...`). A nested
+     * `{app}/{image}` repository 404s on blob upload.
+     */
+    const resolveImage = Effect.fn(function* (input) {
+        const note = input.session?.note ?? ((_message) => Effect.void);
+        yield* note(`Bundling ${input.id} program...`);
+        const { bundled, dockerfile, codeHash, packageJson } = yield* computeCodeHash(input.props);
+        yield* note(`Hashed ${input.id} (${codeHash})`);
+        const repo = sanitizeImageRepo(input.id);
+        const imageRef = `${FLY_REGISTRY}/${input.appName}:${repo}-${codeHash}`;
+        if (input.previousHash === codeHash) {
+            return { imageRef, codeHash };
+        }
+        const minted = yield* machines.createAppDeployToken({ app_name: input.appName });
+        const token = minted.token === undefined || Redacted.isRedacted(minted.token)
+            ? minted.token
+            : Redacted.make(minted.token);
+        if (token === undefined || Redacted.value(token).length === 0) {
+            return yield* new DeployTokenMissing({ appName: input.appName });
+        }
+        const registry = { server: FLY_REGISTRY, username: "x", password: token };
+        const materialize = Effect.gen(function* () {
+            const realMain = yield* resolveMainPath(input.props.main);
+            const contextDir = yield* getStableContextDir(realMain, dotAlchemy, `${input.id}-image`);
+            const fs = yield* FileSystem.FileSystem;
+            const path = yield* Path.Path;
+            const files = input.props.isExternal === true
+                ? packageJson !== undefined
+                    ? [{ path: "package.json", content: new TextEncoder().encode(packageJson) }]
+                    : []
+                : [
+                    ...bundled.files.map((file, index) => ({
+                        path: index === 0 ? "index.mjs" : file.path,
+                        content: file.content,
+                    })),
+                    ...(packageJson !== undefined
+                        ? [{ path: "package.json", content: new TextEncoder().encode(packageJson) }]
+                        : []),
+                ];
+            yield* docker.materialize({ context: contextDir, dockerfile, files });
+            yield* copyExtraFiles(contextDir, input.props.extraFiles);
+            if (input.props.isExternal === true) {
+                const extras = (input.props.extraFiles ?? []).map((file) => ({
+                    source: file.source,
+                    dest: file.dest,
+                }));
+                const root = contextRootOf(realMain, extras, path, (source) => resolveExtraSource(source, path));
+                const entryRel = posixRelUnder(root, realMain, path) ?? path.basename(realMain);
+                const dest = path.join(contextDir, entryRel);
+                if (!(yield* fs.exists(dest).pipe(Effect.orElseSucceed(() => false)))) {
+                    yield* fs.makeDirectory(path.dirname(dest), { recursive: true });
+                    yield* fs.copy(realMain, dest, { overwrite: true });
+                }
+            }
+            return contextDir;
+        });
+        if (input.props.build?.remote !== false) {
+            const contextDir = yield* materialize;
+            yield* note(`Building ${imageRef} on a Fly remote builder...`);
+            yield* buildOnRemoteBuilder({
+                docker,
+                appName: input.appName,
+                contextDir,
+                imageRef,
+                platform: MACHINE_PLATFORM,
+                registry,
+                note,
+            });
+            yield* note(`Pushed ${imageRef}`);
+            return { imageRef, codeHash };
+        }
+        if (!(yield* imageExists(imageRef))) {
+            const contextDir = yield* materialize;
+            yield* note(`Building container image ${imageRef}...`);
+            yield* docker.image.build({ context: contextDir, tag: imageRef, platform: MACHINE_PLATFORM });
+            yield* note(`Built ${imageRef}`);
+        }
+        yield* note(`Pushing ${imageRef}...`);
+        yield* docker.image
+            .push(imageRef, registry)
+            .pipe(Effect.retry({ times: 3, schedule: pushBackoff }));
+        yield* note(`Pushed ${imageRef}`);
+        return { imageRef, codeHash };
+    });
+    const hash = Effect.fn(function* (props) {
+        const { codeHash } = yield* computeCodeHash(props);
+        return codeHash;
+    });
+    return { alchemyEnv, bundleProgram, computeCodeHash, resolveImage, hash };
+};
+/**
+ * Bundle a Sprite program the same way {@link createFlyHostedSupport}
+ * bundles a Service — rolldown + Node bootstrap — without building a
+ * Docker image. The provider writes the files onto the Sprite.
+ */
+export const createSpriteHostedSupport = ({ stackName, stage, virtualEntryPlugin, }) => {
+    const alchemyEnv = {
+        ALCHEMY_STACK_NAME: stackName,
+        ALCHEMY_STAGE: stage,
+        ALCHEMY_PHASE: "runtime",
+        HOST: "0.0.0.0",
+    };
+    const bundleProgram = Effect.fn(function* (props) {
+        const handler = props.handler ?? "default";
+        const realMain = yield* resolveMainPath(props.main);
+        const cwd = yield* findCwdForBundle(realMain);
+        const bootstrap = makeBunBootstrap(handler);
+        const buildBundle = Effect.fn(function* (entry, plugins) {
+            return yield* Bundle.build({
+                ...props.build?.input,
+                input: entry,
+                cwd,
+                platform: "node",
+                external: [
+                    "bun",
+                    "bun:*",
+                    ...(props.build?.input?.external ?? []),
+                ],
+                resolve: {
+                    conditionNames: [...Bundle.NODE_CONDITION_NAMES],
+                    ...props.build?.input?.resolve,
+                },
+                plugins: [props.build?.input?.plugins, plugins],
+            }, {
+                ...props.build?.output,
+                format: "esm",
+                sourcemap: props.build?.output?.sourcemap ?? false,
+                minify: props.build?.output?.minify ?? false,
+                entryFileNames: "index.mjs",
+            }, props.build);
+        });
+        const bundleOutput = props.isExternal
+            ? yield* buildBundle(realMain)
+            : yield* buildBundle(realMain, virtualEntryPlugin(bootstrap));
+        const files = bundleOutput.files.map((file) => ({
+            path: file.path,
+            content: typeof file.content === "string" ? new TextEncoder().encode(file.content) : file.content,
+        }));
+        return { files, hash: bundleOutput.hash };
+    });
+    const hash = Effect.fn(function* (props) {
+        const bundled = yield* bundleProgram(props);
+        return (yield* sha256Object({ bundleHash: bundled.hash })).slice(0, 16);
+    });
+    return { alchemyEnv, bundleProgram, hash };
+};
+//# sourceMappingURL=hosted.js.map