alchemy 2.0.0-beta.59 → 2.0.0-beta.60

package/src/Planetscale/Postgres/PostgresRole.ts

@@ -113,8 +113,10 @@ export interface PostgresRoleAttributes {
   database: string;
   /** The Postgres database name inside the branch. */
   databaseName: string;
-  /** Parsed connection components ready to feed into Cloudflare Hyperdrive. */
+  /** Parsed direct (port 5432) connection components ready to feed into Cloudflare Hyperdrive. */
   origin: PostgresOrigin;
+  /** Parsed pooled (PSBouncer, port 6432) connection components, e.g. for a Hyperdrive `dev` origin. */
+  pooledOrigin: PostgresOrigin;
   /** Direct connection URL for the database (Redacted). */
   connectionUrl: Redacted.Redacted<string>;
   /** Pooled connection URL via PSBouncer (port 6432, Redacted). */
@@ -532,6 +534,14 @@ const buildAttributes = (
       user: role.username,
       password,
     },
+    pooledOrigin: {
+      scheme: "postgres",
+      host: role.access_host_url,
+      port: 6432,
+      database: role.database_name,
+      user: role.username,
+      password,
+    },
     branch: context.branch,
     ttl: role.ttl,
   };

package/src/Platform.ts

@@ -1,3 +1,5 @@
+/** @effect-diagnostics anyUnknownInErrorContext:off */
+
 import type { NodeServices } from "@effect/platform-node/NodeServices";
 import * as ConfigError from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
@@ -11,6 +13,7 @@ import type { Scope } from "effect/Scope";
 import type * as Stream from "effect/Stream";
 import type { HttpClient } from "effect/unstable/http/HttpClient";
 import type { HttpServerRequest } from "effect/unstable/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse";
 import type { Dependencies } from "./Dependencies.ts";
 import type { ExecutionContext } from "./ExecutionContext.ts";
 import type { HttpEffect } from "./Http.ts";
@@ -28,6 +31,7 @@ import {
   type BaseRuntimeContext,
 } from "./RuntimeContext.ts";
 import { Self } from "./Self.ts";
+import { ServerHost, type ProcessContext } from "./Server/Process.ts";
 import type { Stack, StackServices } from "./Stack.ts";
 import type { Stage } from "./Stage.ts";
 import { effectClass } from "./Util/effect.ts";
@@ -242,7 +246,12 @@ export const Platform = <
   type: R["Type"],
   hooks: {
     createRuntimeContext: (id: string) => BaseRuntimeContext;
-    onCreate?: (resource: R, props: any) => Effect.Effect<void>;
+    // `onCreate` runs inside the resource-construction context, which already
+    // carries the Stack's providers — so the hook may yield child resources
+    // (e.g. an async Worker registering a `WorkflowResource` for a bound
+    // Workflow). Allow an ambient requirement (`any`) rather than forcing
+    // `never`; it is discharged by the surrounding provider context.
+    onCreate?: (resource: R, props: any) => Effect.Effect<void, never, any>;
   },
   methods?: { [key: string]: any },
 ): any => {
@@ -372,17 +381,34 @@ export const Platform = <
               );
 
               yield* impl.pipe(
-                Effect.flatMap((impl) =>
-                  impl?.fetch
-                    ? // Hand the full impl to `serve` so the runtime can
-                      // expose any non-handler methods on the impl shape
-                      // (e.g. RPC methods on a Cloudflare Worker) alongside
-                      // the standard `fetch` handler.
-                      (runtimeContext.serve?.(impl.fetch, {
-                        shape: impl as Record<string, unknown>,
-                      }) ?? Effect.die("No serve handler"))
-                    : Effect.void,
-                ),
+                Effect.flatMap((impl) => {
+                  if (!impl) return Effect.void;
+                  const shape = impl as Record<string, unknown>;
+                  // Serve when there's a `fetch` handler OR any RPC shape
+                  // methods. A pure-RPC impl (methods, no `fetch`) still needs
+                  // the server to boot — hand `serveRpc` a default 404 fallback
+                  // so `/__rpc__/*` is dispatched to the shape methods and
+                  // everything else 404s.
+                  // May be an `HttpEffect` or an Effect resolving to one (the
+                  // `Main.fetch` shape); `serve` accepts both.
+                  const fetch = shape.fetch as any;
+                  const hasRpcMethods = Object.keys(shape).some(
+                    (key) => key !== "fetch",
+                  );
+                  if (!fetch && !hasRpcMethods) return Effect.void;
+                  // Hand the full impl to `serve` so the runtime can expose any
+                  // non-handler methods on the impl shape (RPC methods)
+                  // alongside the standard `fetch` handler.
+                  return (
+                    runtimeContext.serve?.(
+                      fetch ??
+                        Effect.succeed(
+                          HttpServerResponse.text("Not Found", { status: 404 }),
+                        ),
+                      { shape },
+                    ) ?? Effect.die("No serve handler")
+                  );
+                }),
                 Effect.provide(
                   Layer.effect(
                     ConfigProvider.ConfigProvider,
@@ -432,6 +458,18 @@ export const Platform = <
                         Layer.succeed(Platform.Platform, runtimeContext),
                         Layer.succeed(PlatformContext, runtimeContext),
                         Layer.succeed(RuntimeContext, runtimeContext),
+                        // Host contexts (EC2 instances, ECS tasks, processes)
+                        // carry a `run` for registering long-running loops.
+                        // Expose it as `ServerHost` so an inline program can
+                        // `yield* ServerHost` during plan/deploy without the
+                        // caller providing the layer itself.
+                        "run" in runtimeContext &&
+                          typeof (runtimeContext as { run?: unknown }).run ===
+                            "function"
+                          ? Layer.succeed(ServerHost, {
+                              run: (runtimeContext as ProcessContext).run,
+                            })
+                          : Layer.empty,
                         Layer.succeed(resource.Self, instance),
                         Layer.succeed(Platform.Self, instance),
                         Layer.succeed(Self, instance),

package/src/Provider.ts

@@ -276,7 +276,7 @@ export const effect = <
   >
 > =>
   // @ts-expect-error
-  Layer.effect(Provider(cls.Type), eff);
+  Layer.effect(Provider(cls.Type), eff) as any;
 
 export const succeed = <
   R extends ResourceLike,

package/src/Resource.ts

@@ -1,5 +1,6 @@
 import * as Effect from "effect/Effect";
 import * as Effectable from "effect/Effectable";
+import * as Layer from "effect/Layer";
 import * as Option from "effect/Option";
 import type { Pipeable } from "effect/Pipeable";
 import { AdoptPolicy } from "./AdoptPolicy.ts";
@@ -283,9 +284,14 @@ export function Resource<R extends ResourceLike>(
             : new Output.PropExpr<any, string>(Output.of(Resource), prop),
       })) as R;
       Resource.Props = Effect.isEffect(props)
-        ? yield* props.pipe(
-            Effect.provideService(Self, Resource),
-            Effect.provideService(Self(type), Resource),
+        ? // @effect-diagnostics-next-line anyUnknownInErrorContext:off
+          yield* props.pipe(
+            Effect.provide(
+              Layer.mergeAll(
+                Layer.succeed(Self, Resource),
+                Layer.succeed(Self(type), Resource),
+              ),
+            ),
           )
         : props;
       return Resource;

package/src/Rpc.ts

@@ -18,7 +18,7 @@ export type Rpc<Shape> = {
 
 /**
  * Recover the user's RPC `Shape` from any of the forms a caller might pass
- * to {@link toPromiseApi}:
+ * to {@link toRpcAsync}:
  *
  *   - the Worker class value's type, e.g. `typeof Backend`, which extends
  *     `Effect.Effect<Worker & Rpc<Shape>, …>`

package/src/Server/Process.ts

@@ -1,3 +1,4 @@
+import * as Config from "effect/Config";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import { FileSystem } from "effect/FileSystem";
@@ -5,6 +6,9 @@ import type { Path } from "effect/Path";
 import type { Stdio } from "effect/Stdio";
 import type { Terminal } from "effect/Terminal";
 import type { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner";
+import type { HttpEffect } from "../Http.ts";
+import * as Http from "../Http.ts";
+import * as Output from "../Output.ts";
 import type { BaseRuntimeContext } from "../RuntimeContext.ts";
 
 export type ProcessServices =
@@ -22,9 +26,86 @@ export interface ProcessContext extends BaseRuntimeContext {
 
 /**
  * Long-running host loop registration (`run`). Provided by `Platform` when the
- * execution context implements {@link ProcessContext}.
+ * execution context implements {@link ProcessContext} (i.e. carries `run`).
+ *
+ * `Platform` wires this automatically for every host runtime context that
+ * implements `run` (EC2 instances, ECS tasks, processes), so an inline program
+ * can `yield* ServerHost` and call `host.run(...)` during plan/deploy without
+ * the caller providing the layer itself.
  */
 export class ServerHost extends Context.Service<
   ServerHost,
   Pick<ProcessContext, "run">
 >()("Alchemy::ServerHost") {}
+
+/**
+ * Deploy-time / plan-time host context for platforms that bundle a long-lived
+ * program. It collects background work registered via `run` and HTTP handlers
+ * registered via `serve` into a single `exports.program` effect that the
+ * generated container/instance entrypoint runs.
+ */
+export interface HostRuntimeContext extends ProcessContext {
+  serve: <Req = never>(
+    handler: HttpEffect<Req> | Effect.Effect<HttpEffect<Req>>,
+    options?: { shape?: Record<string, unknown> },
+  ) => Effect.Effect<void, never, Req>;
+  exports: Effect.Effect<{
+    readonly program: Effect.Effect<void, never, any>;
+  }>;
+}
+
+/**
+ * Build a {@link HostRuntimeContext} for a hosted platform of the given
+ * resource `type`. Both `run` (background loops) and `serve` (HTTP handlers)
+ * append to a single list of runners; `exports.program` runs them all
+ * concurrently. This is the shared host context used by `AWS.EC2.Instance` and
+ * `AWS.ECS.Task`.
+ */
+export const createHostRuntimeContext =
+  (type: string) =>
+  (id: string): HostRuntimeContext => {
+    const runners: Effect.Effect<void, never, any>[] = [];
+    const env: Record<string, any> = {};
+
+    return {
+      Type: type,
+      id,
+      env,
+      set: (bindingId: string, output: Output.Output) =>
+        Effect.sync(() => {
+          const key = bindingId.replaceAll(/[^a-zA-Z0-9]/g, "_");
+          env[key] = output.pipe(Output.map((value) => JSON.stringify(value)));
+          return key;
+        }),
+      get: <T>(key: string) =>
+        Config.string(key).pipe(
+          Effect.flatMap((value) =>
+            Effect.try({
+              try: () => JSON.parse(value) as T,
+              catch: (error) => error as Error,
+            }),
+          ),
+          Effect.catch((cause) =>
+            Effect.die(
+              new Error(`Failed to get environment variable: ${key}`, {
+                cause,
+              }),
+            ),
+          ),
+        ),
+      run: (effect: Effect.Effect<void, never, any>) =>
+        Effect.sync(() => {
+          runners.push(effect);
+        }),
+      serve: ((handler) =>
+        Effect.sync(() => {
+          // Register the HTTP handler as a runner. At container runtime the
+          // ambient `HttpServer` (if provided) serves it; `Http.serve` is a
+          // no-op when no server is bound, so this never crashes plan/deploy.
+          runners.push(Http.serve(handler as HttpEffect<any>));
+        })) as HostRuntimeContext["serve"],
+      exports: Effect.sync(() => ({
+        program: Effect.all(runners, { concurrency: "unbounded" }),
+      })),
+    } satisfies HostRuntimeContext;
+  };

package/src/Stack.ts

@@ -48,7 +48,8 @@ export type ProviderServices =
   | ProviderCollectionLike
   | Provider<any>
   | EnvironmentLike
-  | CredentialsLike;
+  | CredentialsLike
+  | DockerLike;
 
 // tagged type to allow types like AWSEnvironment/AWS Region to bubble through
 export interface EnvironmentLike {
@@ -60,6 +61,10 @@ export interface CredentialsLike {
   readonly kind: "Credentials";
 }
 
+export interface DockerLike {
+  readonly key: "@alchemy/Docker";
+}
+
 export type StackEffect<A, Err = never, Req = never> = Effect.Effect<
   A,
   Err,
@@ -352,10 +357,13 @@ export const evalStack = <A, B, StackErr, Err, Req>(
         Effect.serviceOption(AuthProviders).pipe(
           Effect.map(Option.getOrElse(() => ({}))),
         ),
+      ).pipe(
+        Layer.provideMerge(Layer.succeed(Stage, options.stage)),
+        Layer.provideMerge(
+          Layer.provideMerge(alchemy({ dev: options.dev }), platform),
+        ),
       ),
     ),
-    Effect.provide(Layer.succeed(Stage, options.stage)),
-    Effect.provide(Layer.provideMerge(alchemy({ dev: options.dev }), platform)),
   );
 
   return options.scope === undefined

package/src/Tags.ts

@@ -48,6 +48,18 @@ export const createInternalTags = Effect.fn(function* (id: string) {
   };
 });
 
+/**
+ * Strips the internal `alchemy::*` ownership tags from a tag/label map, leaving
+ * only the user-facing entries. Useful when diffing observed cloud state (which
+ * carries the internal branding) against the user's desired tags.
+ */
+export const stripInternalTags = (
+  tags: Record<string, string> | null | undefined,
+): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(tags ?? {}).filter(([key]) => !key.startsWith("alchemy::")),
+  );
+
 /**
  * Creates AWS-compatible tag filters for finding resources by alchemy tags.
  * Use with AWS describe APIs that accept Filter parameters.

package/src/Telemetry/Attributes.ts

@@ -36,10 +36,9 @@ export interface TelemetryAttributes {
 }
 
 const tryRead = (path: string): Effect.Effect<string | null> =>
-  Effect.tryPromise({
-    try: () => fs.readFile(path, "utf-8").then((s) => s.trim()),
-    catch: () => null as never,
-  }).pipe(Effect.catch(() => Effect.succeed(null)));
+  Effect.tryPromise(() =>
+    fs.readFile(path, "utf-8").then((s) => s.trim()),
+  ).pipe(Effect.orElseSucceed(() => null));
 
 const sha256Hex = (input: string): string =>
   crypto.createHash("sha256").update(input).digest("hex");
@@ -146,18 +145,16 @@ export const isTelemetryDisabled: Effect.Effect<boolean> = Effect.gen(
  * Persists an opt-out so future invocations skip telemetry without needing
  * an env var.
  */
-export const setTelemetryDisabled: Effect.Effect<void> = Effect.tryPromise({
-  try: async () => {
+export const setTelemetryDisabled: Effect.Effect<void> = Effect.tryPromise(
+  async () => {
     await fs.mkdir(ALCHEMY_DIR, { recursive: true });
     await fs.writeFile(DISABLED_PATH, "true");
   },
-  catch: () => null as never,
-}).pipe(Effect.catch(() => Effect.void));
+).pipe(Effect.ignore);
 
-export const setTelemetryEnabled: Effect.Effect<void> = Effect.tryPromise({
-  try: () => fs.rm(DISABLED_PATH, { force: true }),
-  catch: () => null as never,
-}).pipe(Effect.catch(() => Effect.void));
+export const setTelemetryEnabled: Effect.Effect<void> = Effect.tryPromise(() =>
+  fs.rm(DISABLED_PATH, { force: true }),
+).pipe(Effect.ignore);
 
 const collectAttributesUncached: Effect.Effect<TelemetryAttributes> =
   Effect.gen(function* () {

package/src/Test/Bun.ts

@@ -1,3 +1,5 @@
+/** @effect-diagnostics anyUnknownInErrorContext:off */
+
 import bun from "bun:test";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";

package/src/Test/Core.ts

@@ -1,3 +1,5 @@
+/** @effect-diagnostics anyUnknownInErrorContext:off */
+
 import { ConfigProvider } from "effect/ConfigProvider";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
@@ -144,15 +146,18 @@ export const withProviders = <A, E, R, ROut>(
   stackName: string,
 ): Effect.Effect<A, E, Exclude<R, ROut | Stack | Stage>> =>
   effect.pipe(
-    Effect.provide(options.providers as Layer.Layer<any, never, any>),
     Effect.provide(
-      Layer.succeed(Stack, {
-        name: stackName,
-        stage: options.stage ?? "test",
-        resources: {},
-        bindings: {},
-        actions: {},
-      }),
+      (options.providers as Layer.Layer<any, never, any>).pipe(
+        Layer.provideMerge(
+          Layer.succeed(Stack, {
+            name: stackName,
+            stage: options.stage ?? "test",
+            resources: {},
+            bindings: {},
+            actions: {},
+          }),
+        ),
+      ),
     ),
     Effect.provide(Layer.succeed(Stage, options.stage ?? "test")),
   ) as Effect.Effect<A, E, Exclude<R, ROut | Stack | Stage>>;

package/src/Test/Vitest.ts

@@ -1,3 +1,4 @@
+/** @effect-diagnostics anyUnknownInErrorContext:off */
 import { it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";

package/src/Util/effect.ts

@@ -64,7 +64,7 @@ export const isYieldableEffect = (
   value: unknown,
 ): value is Effect.Effect<unknown, unknown, unknown> =>
   Effect.isEffect(value) &&
-  typeof (value as { [Symbol.iterator]?: unknown })[Symbol.iterator] ===
+  typeof (value as any as { [Symbol.iterator]?: unknown })[Symbol.iterator] ===
     "function";
 
 export type YieldableEffectLike<A = unknown, E = unknown, R = unknown> =

package/src/Util/proxy-chain.ts

@@ -1,3 +1,4 @@
+/** @effect-diagnostics anyUnknownInErrorContext:off */
 import * as Effect from "effect/Effect";
 
 type Op =

package/lib/Bundle/Docker.d.ts

@@ -1,75 +0,0 @@
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-declare const DockerCommandError_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: "DockerCommandError";
-} & Readonly<A>;
-export declare class DockerCommandError extends DockerCommandError_base<{
-    readonly command: string;
-    readonly stderr: string;
-    readonly exitCode: number;
-    readonly message: string;
-}> {
-}
-export interface RegistryAuth {
-    readonly username: string;
-    readonly password: string;
-    /**
-     * Registry host only (no `https://`, no path), e.g. `123456789.dkr.ecr.us-east-1.amazonaws.com`.
-     */
-    readonly server: string;
-}
-export interface DockerBuildOptions {
-    /** Image reference passed to `docker build -t`. */
-    readonly tag: string;
-    /** Build context directory (`.` argument to `docker build`). */
-    readonly context: string;
-    readonly platform?: string;
-    readonly target?: string;
-    readonly buildArgs?: Record<string, string>;
-    /** Appended to `docker build` before the final context path. */
-    readonly extraArgs?: ReadonlyArray<string>;
-    readonly env?: Record<string, string | undefined>;
-}
-export declare const materializeDockerfile: (dockerfile: string, dir: string) => Effect.Effect<string, import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
-export declare const writeContextFiles: (dir: string, files: readonly {
-    readonly path: string;
-    readonly content: string | Uint8Array;
-}[]) => Effect.Effect<void, import("effect/PlatformError").PlatformError, FileSystem.FileSystem | Path.Path>;
-export declare const runDockerCommand: (args: readonly string[], options?: {
-    cwd?: string;
-    env?: Record<string, string | undefined>;
-    /** Passed to the process stdin (e.g. for `docker login --password-stdin`). */
-    stdin?: string;
-} | undefined) => Effect.Effect<{
-    stdout: string;
-    stderr: string;
-}, DockerCommandError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/Scope").Scope>;
-/**
- * Run `docker build` with standard flags from {@link DockerBuildOptions}.
- */
-export declare const dockerBuild: (options: DockerBuildOptions) => Effect.Effect<void, DockerCommandError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/Scope").Scope>;
-/**
- * Get the image ID (content-addressable digest) of a locally-built image.
- */
-export declare const getDockerImageId: (tag: string) => Effect.Effect<string, DockerCommandError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/Scope").Scope>;
-/**
- * Tag a local image with a new reference.
- */
-export declare const dockerTag: (source: string, target: string) => Effect.Effect<void, DockerCommandError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/Scope").Scope>;
-/**
- * Log in to a registry using `docker login --password-stdin` (no password on argv).
- */
-export declare const dockerLogin: (auth: RegistryAuth, options?: {
-    env?: Record<string, string | undefined>;
-} | undefined) => Effect.Effect<void, DockerCommandError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/Scope").Scope>;
-/**
- * Push an image ref. When `auth` is set, uses an isolated `DOCKER_CONFIG`
- * directory so concurrent deploys do not race on global docker credentials.
- */
-export declare const pushImage: (imageRef: string, auth?: RegistryAuth | undefined) => Effect.Effect<{
-    stdout: string;
-    stderr: string;
-} | undefined, DockerCommandError | import("effect/PlatformError").PlatformError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | FileSystem.FileSystem | Path.Path | import("effect/Scope").Scope>;
-export {};
-//# sourceMappingURL=Docker.d.ts.map

package/lib/Bundle/Docker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Docker.d.ts","sourceRoot":"","sources":["../../src/Bundle/Docker.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,UAAU,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;;;;AAKpC,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;AAEL,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,kBAAkB;IACjC,mDAAmD;IACnD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5C,gEAAgE;IAChE,QAAQ,CAAC,SAAS,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC3C,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;CACnD;AAED,eAAO,MAAM,qBAAqB,6IAUhC,CAAC;AAEH,eAAO,MAAM,iBAAiB;mBAGX,MAAM;sBACH,MAAM,GAAG,UAAU;4GAcvC,CAAC;AAEH,eAAO,MAAM,gBAAgB;UAGnB,MAAM;UACN,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,8EAA8E;YACtE,MAAM;;;;gIA8ChB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW,oLAmBtB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB,sKAQ3B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,SAAS,uLAEpB,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,WAAW;UAEJ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;mKASpD,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,SAAS;;;+NAyCpB,CAAC"}

package/lib/Bundle/Docker.js

@@ -1,148 +0,0 @@
-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 Stream from "effect/Stream";
-import { ChildProcess } from "effect/unstable/process";
-import { exec } from "../Util/exec.js";
-export class DockerCommandError extends Data.TaggedError("DockerCommandError") {
-}
-export const materializeDockerfile = Effect.fn(function* (dockerfile, dir) {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    yield* fs.makeDirectory(dir, { recursive: true });
-    const target = path.join(dir, "Dockerfile");
-    yield* fs.writeFileString(target, dockerfile);
-    return target;
-});
-export const writeContextFiles = Effect.fn(function* (dir, files) {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    for (const file of files) {
-        const fullPath = path.join(dir, file.path);
-        yield* fs.makeDirectory(path.dirname(fullPath), { recursive: true });
-        if (typeof file.content === "string") {
-            yield* fs.writeFileString(fullPath, file.content);
-        }
-        else {
-            yield* fs.writeFile(fullPath, file.content);
-        }
-    }
-});
-export const runDockerCommand = Effect.fn(function* (args, options) {
-    const command = `docker ${args.join(" ")}`;
-    const env = { ...process.env, ...options?.env };
-    const commandOptions = {
-        env,
-        ...(options?.stdin !== undefined
-            ? {
-                stdin: Stream.succeed(new TextEncoder().encode(options.stdin)),
-            }
-            : {}),
-    };
-    const child = options?.cwd
-        ? ChildProcess.setCwd(ChildProcess.make("docker", args, commandOptions), options.cwd)
-        : ChildProcess.make("docker", args, commandOptions);
-    const { stdout, stderr, exitCode } = yield* exec(child).pipe(Effect.catch((e) => Effect.fail(new DockerCommandError({
-        command,
-        stderr: e instanceof Error ? e.message : String(e),
-        exitCode: 1,
-        message: e instanceof Error ? e.message : String(e),
-    }))));
-    if (exitCode !== 0) {
-        return yield* Effect.fail(new DockerCommandError({
-            command,
-            stderr,
-            exitCode,
-            message: `Docker command failed (${exitCode}): ${command}\n${stderr}`.trim(),
-        }));
-    }
-    return { stdout, stderr };
-});
-/**
- * Run `docker build` with standard flags from {@link DockerBuildOptions}.
- */
-export const dockerBuild = Effect.fn(function* (options) {
-    const args = ["build", "-t", options.tag];
-    if (options.platform) {
-        args.push("--platform", options.platform);
-    }
-    if (options.target) {
-        args.push("--target", options.target);
-    }
-    if (options.buildArgs) {
-        for (const [k, v] of Object.entries(options.buildArgs)) {
-            args.push("--build-arg", `${k}=${v}`);
-        }
-    }
-    if (options.extraArgs?.length) {
-        args.push(...options.extraArgs);
-    }
-    args.push(options.context);
-    yield* runDockerCommand(args, { env: options.env });
-});
-/**
- * Get the image ID (content-addressable digest) of a locally-built image.
- */
-export const getDockerImageId = Effect.fn(function* (tag) {
-    const { stdout } = yield* runDockerCommand([
-        "inspect",
-        "--format",
-        "{{.Id}}",
-        tag,
-    ]);
-    return stdout.trim();
-});
-/**
- * Tag a local image with a new reference.
- */
-export const dockerTag = Effect.fn(function* (source, target) {
-    yield* runDockerCommand(["tag", source, target]);
-});
-/**
- * Log in to a registry using `docker login --password-stdin` (no password on argv).
- */
-export const dockerLogin = Effect.fn(function* (auth, options) {
-    yield* runDockerCommand(["login", "-u", auth.username, "--password-stdin", auth.server], {
-        env: options?.env,
-        stdin: auth.password,
-    });
-});
-/**
- * Push an image ref. When `auth` is set, uses an isolated `DOCKER_CONFIG`
- * directory so concurrent deploys do not race on global docker credentials.
- */
-export const pushImage = Effect.fn(function* (imageRef, auth) {
-    if (auth) {
-        const fs = yield* FileSystem.FileSystem;
-        const path = yield* Path.Path;
-        const configDir = yield* fs.makeTempDirectory({
-            prefix: "alchemy-docker-",
-        });
-        // Write the registry credentials directly into an isolated docker config
-        // as a plaintext `auths` entry and skip `docker login` entirely.
-        //
-        // `docker login` is the wrong tool here: on macOS Docker Desktop it routes
-        // through the shared `osxkeychain`/`desktop` credential helper *regardless*
-        // of an isolated DOCKER_CONFIG, so concurrent deploys either race the system
-        // keychain (`The specified item already exists in the keychain (-25299)`) or
-        // land the credential in the helper — leaving this isolated config without
-        // an `auths` entry, so the subsequent `docker push` fails with "no basic
-        // auth credentials". Embedding the base64 `auth` inline (the same thing
-        // `docker login` would write when no credsStore is configured) makes each
-        // deploy fully self-contained: no credential helper, no keychain, no login
-        // race. Only `push` reads this config; `build`/`pull`/`tag` keep using the
-        // global docker config (buildx builders, `docker context`, etc. intact).
-        const token = yield* Effect.sync(() => Buffer.from(`${auth.username}:${auth.password}`).toString("base64"));
-        const config = JSON.stringify({
-            auths: { [auth.server]: { auth: token } },
-        });
-        yield* fs.writeFileString(path.join(configDir, "config.json"), config);
-        const env = { ...process.env, DOCKER_CONFIG: configDir };
-        return yield* runDockerCommand(["push", imageRef], { env }).pipe(Effect.ensuring(fs
-            .remove(configDir, { recursive: true })
-            .pipe(Effect.catch(() => Effect.void))));
-    }
-    yield* runDockerCommand(["push", imageRef]);
-});
-//# sourceMappingURL=Docker.js.map