alchemy 2.0.0-beta.84 → 2.0.0-beta.85

package/src/Util/Node.ts

@@ -1,5 +1,14 @@
 import * as NodeNet from "node:net";
+import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+import * as SemVer from "effect/SemVer";
+import * as SemVerRange from "effect/SemVerRange";
+
+export class NodeOperationFailed extends Data.TaggedError("NodeOperationFailed")<{
+  readonly message: string;
+  readonly cause?: unknown;
+}> {}
 
 /**
  * The process's working directory, captured ONCE at module load.
@@ -91,15 +100,16 @@ export const nodeLoaderArgs = (entry: string): string[] => [
  * before any `.ts` can load. Keep the two in sync.
  */
 export const isRegisterHooksSupported = (version = process.versions.node): boolean => {
-  const [major = 0, minor = 0, patch = 0] = version.split(".").map(Number);
+  const parsed = Result.getOrUndefined(SemVer.parse(version));
   return (
-    (major === 22 && (minor > 22 || (minor === 22 && patch >= 3))) ||
-    (major === 24 && (minor > 11 || (minor === 11 && patch >= 1))) ||
-    (major === 25 && minor >= 1) ||
-    major >= 26
+    parsed !== undefined && SemVerRange.matches(REGISTER_HOOKS, parsed, { includePrerelease: true })
   );
 };
 
+const REGISTER_HOOKS = SemVerRange.parseUnsafe(
+  ">=22.22.3 <23.0.0-0 || >=24.11.1 <25.0.0-0 || >=25.1.0",
+);
+
 /**
  * Ask the OS for an unused TCP port, release it, and return its number.
  *
@@ -121,7 +131,11 @@ export const findAvailablePort = (host = "127.0.0.1") =>
         } else if (port !== undefined) {
           resume(Effect.succeed(port));
         } else {
-          resume(Effect.fail(new Error("Failed to allocate an available port")));
+          resume(
+            Effect.fail(
+              new NodeOperationFailed({ message: "Failed to allocate an available port" }),
+            ),
+          );
         }
       });
     });

package/src/Util/PlatformServices.ts

@@ -1,4 +1,5 @@
-import type { Crypto } from "effect/Crypto";
+import * as Digest from "effect/crypto/Digest";
+import * as SecureRandom from "effect/crypto/SecureRandom";
 import type { Input as DurationInput } from "effect/Duration";
 import * as Effect from "effect/Effect";
 import type { FileSystem } from "effect/FileSystem";
@@ -47,9 +48,13 @@ export const platformLayer = <A, E, R>(constructors: {
     }),
   );
 
+// effect 4.1 dropped crypto from the platform `*Services` bundles.
+const WebCryptoServices = Layer.mergeAll(SecureRandom.layerWebCrypto, Digest.layerWebCrypto);
+
 export type PlatformServices =
   | ChildProcessSpawner
-  | Crypto
+  | Digest.Digest
+  | SecureRandom.SecureRandom
   | FileSystem
   | Path
   | Stdio
@@ -63,7 +68,11 @@ export const PlatformServices: Layer.Layer<PlatformServices> = platformLayer({
       importPlatformPeer("@effect/platform-bun", () => import("@effect/platform-bun/BunServices")),
       importPlatformPeer("@effect/platform-bun", () => import("@effect/platform-bun/BunSocket")),
     ]);
-    return Layer.merge(BunServices.layer, BunSocket.layerWebSocketConstructor);
+    return Layer.mergeAll(
+      BunServices.layer,
+      BunSocket.layerWebSocketConstructor,
+      WebCryptoServices,
+    );
   },
   node: async () => {
     const [NodeServices, NodeSocket] = await Promise.all([
@@ -73,7 +82,11 @@ export const PlatformServices: Layer.Layer<PlatformServices> = platformLayer({
       ),
       importPlatformPeer("@effect/platform-node", () => import("@effect/platform-node/NodeSocket")),
     ]);
-    return Layer.merge(NodeServices.layer, NodeSocket.layerWebSocketConstructor);
+    return Layer.mergeAll(
+      NodeServices.layer,
+      NodeSocket.layerWebSocketConstructor,
+      WebCryptoServices,
+    );
   },
 });
 

package/src/Util/ResourceOutput.ts

@@ -1,7 +1,7 @@
 import { stripVTControlCharacters } from "node:util";
-import type * as ConsoleService from "effect/Console";
 import * as Effect from "effect/Effect";
 import { makeLineBuffer } from "./LineBuffer.ts";
+import { logChildLine } from "./LogRecord.ts";
 import { ANSI_RESET, ansiFg, colorsEnabled } from "./Terminal.ts";
 import { theme } from "./Theme.ts";
 
@@ -40,32 +40,33 @@ export const stripChildEffectPrefix = (line: string): string => {
 };
 
 /**
- * The single terminal-output pipeline for resource-owned processes. Dev
- * servers, local workers, and deploy-time builders all use the same line
- * splitting, resource prefix, color policy, and stdout/stderr severity.
+ * Log one line a resource-owned process wrote, as a structured record: the
+ * child's text (with any pretty Effect prefix removed) plus the resource and
+ * stream it came from. The record keeps the text as written; the renderer
+ * draws the resource tag and strips styling when colors are off. A JSON line from an alchemy child is replayed as-is.
+ *
+ * stderr is a process transport, not a semantic failure: Vite and many other
+ * tools write warnings, progress, and ordinary diagnostics there, so both
+ * streams log at Info and carry the stream as data.
  */
-export const makeResourceOutput = (id: string, console: Pick<ConsoleService.Console, "log">) => {
-  const prefix = formatResourceTag(id);
-  // stderr is a process transport, not a semantic failure: Vite and many
-  // other tools write warnings, progress, and ordinary diagnostics there.
-  // Sending it through Console.error makes CLIKit prepend an error glyph to
-  // every line. Both streams therefore enter the renderer as plain resource
-  // output; the child text retains its own ANSI severity styling.
-  const writeLine = (line: string) => console.log(`${prefix} ${stripChildEffectPrefix(line)}`);
-  return {
-    stdout: makeLineBuffer(writeLine),
-    stderr: makeLineBuffer(writeLine),
-  };
-};
+export const logResourceLine = (id: string, channel: OutputChannel, line: string) =>
+  logChildLine(stripChildEffectPrefix(line), { stream: channel, resource: id });
+
+/**
+ * Line-buffered output for resource-owned child processes whose streams
+ * arrive as chunks outside an Effect (workerd output pumps, stream mirrors).
+ * Captures the caller's services so each line goes through its loggers.
+ */
+export const makeResourceOutput = Effect.fn(function* (id: string) {
+  const context = yield* Effect.context<never>();
+  const writer = (channel: OutputChannel) =>
+    makeLineBuffer((line) => Effect.runSyncWith(context)(logResourceLine(id, channel, line)));
+  return { stdout: writer("stdout"), stderr: writer("stderr") };
+});
 
 /**
  * Effect-native output for resource-owned child processes whose streams are
- * already consumed inside an Effect. Both process channels are transport
- * details, not semantic severity, so they enter the configured logger at the
- * info level. The logger remains responsible for terminal and file sinks.
+ * already consumed inside an Effect.
  */
-export const makeResourceLogger = (id: string) => {
-  const prefix = formatResourceTag(id);
-  return (_channel: OutputChannel, line: string) =>
-    Effect.logInfo(`${prefix} ${stripChildEffectPrefix(line)}`);
-};
+export const makeResourceLogger = (id: string) => (channel: OutputChannel, line: string) =>
+  logResourceLine(id, channel, line);

package/src/Util/Shutdown.ts

@@ -0,0 +1,52 @@
+import * as Clock from "effect/Clock";
+import * as Effect from "effect/Effect";
+
+/**
+ * Time this process's shutdown in the run log: a Debug record when SIGINT or
+ * SIGTERM arrives, and one when `effect` has finished (finalizers included),
+ * with the time since the signal. Silent when the process ends on its own.
+ */
+export const logShutdown =
+  (name: string) =>
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.gen(function* () {
+      const context = yield* Effect.context<never>();
+      const clock = yield* Clock.Clock;
+      let signalled: { readonly signal: string; readonly at: number } | undefined;
+      const onSignal = (signal: NodeJS.Signals) => {
+        if (signalled !== undefined) return;
+        signalled = { signal, at: clock.currentTimeMillisUnsafe() };
+        Effect.runForkWith(context)(Effect.logDebug(`shutdown: ${name} received ${signal}`));
+      };
+      // Ahead of the runtime's own handler, which interrupts this fiber and
+      // can run its whole teardown synchronously before later listeners.
+      process.prependListener("SIGINT", onSignal);
+      process.prependListener("SIGTERM", onSignal);
+      return yield* effect.pipe(
+        Effect.onExit(() =>
+          Effect.flatMap(Clock.currentTimeMillis, (now) => {
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+            return signalled === undefined
+              ? Effect.void
+              : Effect.logDebug(
+                  `shutdown: ${name} finished ${now - signalled.at}ms after ${signalled.signal}`,
+                );
+          }),
+        ),
+      );
+    });
+
+/** Run `effect` and log how long it took, as a step of a shutdown. */
+export const timedShutdownStep =
+  (step: string) =>
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.flatMap(Clock.currentTimeMillis, (start) =>
+      effect.pipe(
+        Effect.onExit(() =>
+          Effect.flatMap(Clock.currentTimeMillis, (end) =>
+            Effect.logDebug(`shutdown: ${step} in ${end - start}ms`),
+          ),
+        ),
+      ),
+    );

package/src/Util/Terminal.ts

@@ -1,11 +1,5 @@
-import {
-  setClipboard,
-  setTerminalProgress,
-  stringWidth,
-  tmuxPassthrough,
-  type TerminalProgressState,
-} from "@alchemy.run/sigil/ansi";
-/** Terminal-emulator features shared by CliKit components. */
+import { setClipboard, stringWidth, tmuxPassthrough } from "@alchemy.run/sigil/ansi";
+/** Terminal-emulator features shared by CLI components. */
 import { detectColorLevel, detectUnicodeSupport } from "@alchemy.run/sigil/capabilities";
 
 export const ANSI_RESET = "\u001B[0m";
@@ -22,7 +16,7 @@ export const ansiFg = (hex: string) => {
 
 /**
  * The canonical color-support decision, shared by raw terminal strings and
- * CliKit capability detection so the two can never disagree.
+ * terminal capability detection so the two can never disagree.
  */
 export const colorsEnabled = (
   stream: Pick<NodeJS.WriteStream, "isTTY"> = process.stdout,
@@ -49,17 +43,6 @@ export const copyToClipboard = (
   stdout.write(sequence);
 };
 
-export const setNativeProgress = (
-  state: TerminalProgressState,
-  value?: number,
-  stdout: Pick<NodeJS.WriteStream, "write" | "isTTY"> = process.stdout,
-): void => {
-  if (stdout.isTTY !== true) return;
-  let sequence = setTerminalProgress(state, value);
-  if (process.env.TMUX !== undefined) sequence = tmuxPassthrough(sequence);
-  stdout.write(sequence);
-};
-
 const truncateSegmenter = new Intl.Segmenter();
 
 /** Display-width-aware truncation (wide CJK/emoji count by rendered cells). */

package/src/Util/TraceParent.ts

@@ -0,0 +1,70 @@
+import * as Effect from "effect/Effect";
+import * as Hex from "effect/encoding/Hex";
+import * as Option from "effect/Option";
+import * as Stream from "effect/Stream";
+import * as Tracer from "effect/Tracer";
+
+/**
+ * The span a child process or RPC call runs under, so its records and spans
+ * join the caller's trace instead of starting their own.
+ */
+export interface TraceParent {
+  readonly traceId: string;
+  readonly spanId: string;
+}
+
+/** Set on alchemy child processes to the trace they report under. */
+export const TRACE_PARENT_ENV = "ALCHEMY_TRACE_PARENT";
+
+const fromEnv = (): TraceParent | undefined => {
+  const [traceId, spanId] = (process.env[TRACE_PARENT_ENV] ?? "").split("-");
+  return traceId && spanId ? { traceId, spanId } : undefined;
+};
+
+/**
+ * This process's trace, for records logged outside any span (startup,
+ * shutdown, finalizers): the parent's when it passed one in
+ * {@link TRACE_PARENT_ENV}, otherwise a new one. It ties a process's
+ * untraced records together and to its parent's, without a span that would
+ * stay open for the life of the process.
+ */
+export const processTrace: TraceParent = fromEnv() ?? {
+  traceId: Hex.random(32),
+  spanId: Hex.random(16),
+};
+
+/** The caller's current span, if it is in one. */
+export const currentTraceParent: Effect.Effect<TraceParent | undefined> = Effect.map(
+  Effect.option(Effect.currentParentSpan),
+  Option.match({
+    onNone: () => undefined,
+    onSome: (span) => ({ traceId: span.traceId, spanId: span.spanId }),
+  }),
+);
+
+/**
+ * {@link TRACE_PARENT_ENV} for a child process: the current span, or this
+ * process's trace outside one.
+ */
+export const traceParentEnv: Effect.Effect<Record<string, string>> = Effect.map(
+  currentTraceParent,
+  (parent = processTrace): Record<string, string> => ({
+    [TRACE_PARENT_ENV]: `${parent.traceId}-${parent.spanId}`,
+  }),
+);
+
+const spanOf = (parent: TraceParent) => Tracer.externalSpan({ ...parent, sampled: true });
+
+/** Run `effect` as a child of `parent`, when there is one. */
+export const withTraceParent =
+  (parent: TraceParent | undefined) =>
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    parent === undefined ? effect : Effect.withParentSpan(effect, spanOf(parent));
+
+/** Run `stream` (its whole execution, not just its construction) as a child of `parent`. */
+export const withStreamTraceParent =
+  (parent: TraceParent | undefined) =>
+  <A, E, R>(stream: Stream.Stream<A, E, R>): Stream.Stream<A, E, R> =>
+    parent === undefined
+      ? stream
+      : Stream.provideService(stream, Tracer.ParentSpan, spanOf(parent));

package/src/Util/base64.ts

@@ -0,0 +1,22 @@
+/**
+ * Base64 for byte arrays, on the native `toBase64`/`fromBase64` when the
+ * runtime has them and `btoa`/`atob` otherwise.
+ */
+export const bytesToBase64 = (bytes: Uint8Array): string => {
+  const encode = (bytes as Uint8Array & { toBase64?: () => string }).toBase64;
+  if (typeof encode === "function") return encode.call(bytes);
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+};
+
+export const base64ToBytes = (b64: string): Uint8Array => {
+  const decode = (
+    Uint8Array as Uint8ArrayConstructor & { fromBase64?: (value: string) => Uint8Array }
+  ).fromBase64;
+  if (typeof decode === "function") return decode.call(Uint8Array, b64);
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+};

package/src/Util/cached-function.ts

@@ -41,35 +41,46 @@ export const cachedFunction = <A extends Array<any>, B, E, R>(
   fn: (...args: A) => Effect.Effect<B, E, R>,
   options?: CachedFunctionOptions<A>,
 ): Effect.Effect<(...args: A) => Effect.Effect<B, E, R>> =>
-  Effect.sync(() => {
-    const keyFn = options?.key ?? JSON.stringify;
-    const cache = new Map<string, Deferred.Deferred<B, E>>();
+  Effect.sync(() => makeCachedFunction(fn, options));
 
-    return (...args: A): Effect.Effect<B, E, R> =>
-      Effect.suspend(() => {
-        const cacheKey = keyFn(args);
-        const existing = cache.get(cacheKey);
+/**
+ * {@link cachedFunction} for callers that own the cache's lifetime outside an
+ * Effect, such as a `Context.Reference` default.
+ */
+export const makeCachedFunction = <A extends Array<any>, B, E, R>(
+  fn: (...args: A) => Effect.Effect<B, E, R>,
+  options?: CachedFunctionOptions<A>,
+): ((...args: A) => Effect.Effect<B, E, R>) => {
+  const keyFn = options?.key ?? JSON.stringify;
+  const cache = new Map<string, Deferred.Deferred<B, E>>();
+
+  return (...args: A): Effect.Effect<B, E, R> =>
+    Effect.suspend(() => {
+      const cacheKey = keyFn(args);
+      const existing = cache.get(cacheKey);
 
-        // If there's already a deferred for this key, wait on it
-        if (existing) {
-          return Deferred.await(existing);
-        }
+      // If there's already a deferred for this key, wait on it
+      if (existing) {
+        return Deferred.await(existing);
+      }
 
-        // Create a new deferred and store it
-        return Effect.gen(function* () {
+      // Create a new deferred and store it. Only the call itself is
+      // interruptible, so an interrupted first caller still settles its
+      // waiters and evicts the key instead of leaving it pending forever.
+      return Effect.uninterruptibleMask((restore) =>
+        Effect.gen(function* () {
           const deferred = yield* Deferred.make<B, E>();
           cache.set(cacheKey, deferred);
 
-          // Execute the effect and complete the deferred
-          const exit = yield* Effect.exit(fn(...args));
+          const exit = yield* Effect.exit(restore(fn(...args)));
           yield* Deferred.done(deferred, exit);
 
           if (exit._tag === "Failure") {
             cache.delete(cacheKey);
           }
 
-          // Return the result
           return yield* exit;
-        });
-      });
-  });
+        }),
+      );
+    });
+};

package/src/Util/data.ts

@@ -2,7 +2,7 @@ import * as Predicate from "effect/Predicate";
 import * as EffectRecord from "effect/Record";
 import * as Redacted from "effect/Redacted";
 
-export type Primitive = never | undefined | null | boolean | number | string | bigint | symbol;
+export type Primitive = undefined | null | boolean | number | string | bigint | symbol;
 
 export const isPrimitive = (value: any): value is Primitive =>
   value === undefined ||
@@ -92,7 +92,7 @@ type UnwrapRedacted<T> =
 
 export const unwrapRedacted = <T>(value: T): UnwrapRedacted<T> => {
   if (Redacted.isRedacted(value)) {
-    return unwrapRedacted(Redacted.value(value)) as UnwrapRedacted<T>;
+    return value.pipe(Redacted.value, unwrapRedacted) as UnwrapRedacted<T>;
   }
   if (Array.isArray(value)) {
     return value.map(unwrapRedacted) as UnwrapRedacted<T>;

package/src/Util/equal.ts

@@ -30,8 +30,9 @@ export const arrayEqualsUnordered = <T extends string | number>(
   if (a === b) return true;
   if (a === undefined || b === undefined) return false;
   if (a.length !== b.length) return false;
-  const as = [...a].sort();
-  const bs = [...b].sort();
+  const compare = (x: T, y: T) => (x < y ? -1 : x > y ? 1 : 0);
+  const as = [...a].sort(compare);
+  const bs = [...b].sort(compare);
   for (let i = 0; i < as.length; i++) {
     if (as[i] !== bs[i]) return false;
   }

package/src/Util/extraFiles.ts

@@ -119,8 +119,9 @@ export const hashExtraFiles = Effect.fn(function* (
   const path = yield* Path.Path;
   const runtimeBase = process.cwd();
   const dotAlchemy = yield* dotAlchemyDirectory;
-  const entries = yield* Effect.all(
-    (extraFiles ?? []).map((extra) =>
+  const entries = yield* Effect.forEach(
+    extraFiles ?? [],
+    (extra) =>
       Effect.gen(function* () {
         const dest = extraFileDestination(extra.dest);
         const source = resolveExtraSource(extra.source, path);
@@ -139,7 +140,6 @@ export const hashExtraFiles = Effect.fn(function* (
             : yield* sha256(yield* fs.readFile(source));
         return [dest, hash] as const;
       }),
-    ),
     { concurrency: ioConcurrency },
   );
   return Object.fromEntries(entries) as Record<string, string>;
@@ -204,8 +204,9 @@ export const copyExtraFiles = Effect.fn(function* (
 ) {
   const fs = yield* FileSystem.FileSystem;
   const path = yield* Path.Path;
-  yield* Effect.all(
-    (extraFiles ?? []).map((extra) =>
+  yield* Effect.forEach(
+    extraFiles ?? [],
+    (extra) =>
       Effect.gen(function* () {
         const source = resolveExtraSource(extra.source, path);
         const destName = extraFileDestination(extra.dest);
@@ -220,8 +221,9 @@ export const copyExtraFiles = Effect.fn(function* (
           const stat = yield* fs.stat(source);
           if (stat.type === "Directory") {
             const names = yield* fs.readDirectory(source);
-            yield* Effect.all(
-              names.map((name) => copyTree(path.join(source, name), path.join(contextDir, name))),
+            yield* Effect.forEach(
+              names,
+              (name) => copyTree(path.join(source, name), path.join(contextDir, name)),
               { concurrency: ioConcurrency },
             );
           } else {
@@ -236,7 +238,6 @@ export const copyExtraFiles = Effect.fn(function* (
         yield* fs.makeDirectory(path.dirname(dest), { recursive: true });
         yield* copyTree(source, dest);
       }),
-    ),
     { concurrency: ioConcurrency },
   );
 });

package/src/Util/interactive.ts

@@ -5,7 +5,7 @@ import * as Effect from "effect/Effect";
  * coding agent, CI runner, test runner, or anything else that won't render an
  * interactive TUI / prompt well.
  *
- * This is the process-level source of truth used by CliKit capability
+ * This is the process-level source of truth used by terminal capability
  * detection, auth configuration guards, and spawned-command stdin policy.
  *
  * Kept in `Util` (rather than `Cli`) so `Auth` can depend on it without

package/src/Website/AstroOutput.ts

@@ -0,0 +1,83 @@
+import * as Effect from "effect/Effect";
+import { initialCwd } from "../Util/Node.ts";
+
+export interface AstroOutputProps {
+  /** Project root, relative to the initial working directory. */
+  readonly rootDir?: string | undefined;
+  /** Alternate astro config file, relative to {@link rootDir}. */
+  readonly config?: string | undefined;
+  /** The composite's `astro.output` prop. */
+  readonly output?: "server" | "static" | undefined;
+}
+
+/**
+ * Resolves the Astro `output` a website composite deploys: the
+ * `astro.output` prop, else the `output` declared in the project's
+ * `astro.config.*`, else `"server"`. Composites decide at plan time whether
+ * a site is assets-only, so the config file is read here rather than left
+ * to the build.
+ *
+ * `@alchemy.run/frontend-frameworks` is an optional peer dependency, so it
+ * is imported lazily. When it is missing or the config cannot be loaded the
+ * site falls back to `"server"` (the build reports the real error).
+ */
+export const resolveAstroOutput = Effect.fn("Website.resolveAstroOutput")(function* (
+  props: AstroOutputProps,
+) {
+  if (props.output !== undefined) return props.output;
+  const declared = yield* Effect.tryPromise(
+    () => import("@alchemy.run/frontend-frameworks/astro/config"),
+  ).pipe(
+    Effect.flatMap((astro) =>
+      astro.readConfigOutput({ cwd: initialCwd, rootDir: props.rootDir, config: props.config }),
+    ),
+    Effect.catch((error) =>
+      Effect.logWarning(
+        `Could not read \`output\` from the Astro config in "${props.rootDir ?? "."}"; deploying with "server"`,
+        error,
+      ).pipe(Effect.as(undefined)),
+    ),
+  );
+  return declared ?? "server";
+});
+
+export interface AstroSettings {
+  /** The resolved `output` (see {@link resolveAstroOutput}). */
+  readonly output: "server" | "static";
+  /**
+   * Whether the Astro config routes caching through the Cloudflare cache
+   * provider (`cacheCloudflare()`), so the Worker needs Workers Cache on.
+   */
+  readonly workerCache: boolean;
+}
+
+/**
+ * Resolves the Astro settings a Cloudflare composite deploys from one read
+ * of the project's `astro.config.*`: the `output` (as
+ * {@link resolveAstroOutput}) and whether the config uses the Cloudflare
+ * cache provider. When the config cannot be loaded the site falls back to
+ * `"server"` without Workers Cache (the build reports the real error).
+ */
+export const resolveAstroSettings = Effect.fn("Website.resolveAstroSettings")(function* (
+  props: AstroOutputProps,
+) {
+  const declared = yield* Effect.tryPromise(
+    () => import("@alchemy.run/frontend-frameworks/astro/config"),
+  ).pipe(
+    Effect.flatMap((astro) =>
+      astro.readConfigSettings({ cwd: initialCwd, rootDir: props.rootDir, config: props.config }),
+    ),
+    Effect.catch((error) =>
+      Effect.logWarning(
+        `Could not read the Astro config in "${props.rootDir ?? "."}"; deploying with ${
+          props.output === undefined ? '"server"' : `"${props.output}"`
+        } and without Workers Cache`,
+        error,
+      ).pipe(Effect.as(undefined)),
+    ),
+  );
+  return {
+    output: props.output ?? declared?.output ?? "server",
+    workerCache: declared?.workerCache ?? false,
+  } satisfies AstroSettings;
+});

package/src/Workflows.ts

@@ -10,6 +10,16 @@ import type { RuntimeContext } from "./RuntimeContext.ts";
 
 declare const ImplementedTypeId: unique symbol;
 
+/**
+ * Annotates a workflow with the name an engine stores its runs under, when
+ * that differs from the workflow's own name. An engine that names storage
+ * after the workflow, like Cloudflare's Durable Object engine with one class
+ * per workflow, uses it as given.
+ */
+export class StorageName extends Context.Service<StorageName, string>()(
+  "alchemy/Workflows/StorageName",
+) {}
+
 /**
  * Marks a workflow as runnable here: something in the context implements it.
  * `Workflows.layer` provides it for the workflow it implements, and a remote
@@ -134,6 +144,7 @@ export function layer<
 ): Layer.Layer<
   Implemented<Name>,
   InitE,
+  // oxlint-disable-next-line typescript/no-redundant-type-constituents -- generic in R; only looks like `never` to the linter
   InitR | Exclude<Requirements<ReturnType<typeof workflow.toLayer<R>>>, RuntimeContext>
 >;
 export function layer(

package/src/index.ts

@@ -40,6 +40,7 @@ export * as Telemetry from "./Telemetry.ts";
 // downstream `.d.ts` emissions (fixes TS2883 in user files).
 export { AuthProviders } from "./Auth/AuthProvider.ts";
 export { Cli } from "./Report.ts";
+export * as Events from "./Events.ts";
 export * as Report from "./Report.ts";
 export type { Dependencies } from "./Dependencies.ts";
 export type { Named } from "./Named.ts";

package/lib/Alchemist/Progress.d.ts

@@ -1,16 +0,0 @@
-import type { PlanStatusSession } from "../Report.ts";
-import { type ProgressReporter } from "../Report.ts";
-export { Progress, type ActionPlanned, type ApplyEvent, type NukeEvent, type NukeScanStarted, type NukeProviderScanStarted, type NukePassStarted, type NukeProviderScanned, type NukeResourceDeleted, type NukeResourceFailed, type PlanEvent, type PlanNodeEvent, type PlanPhaseChanged, type PlanningPhase, type ProgressEvent, type ProgressReporter, type ProviderConfigureCompleted, type ProviderConfigureStarted, type ProviderEvent, type ProviderRefreshCompleted, type ProviderRefreshStarted, type ResourceAnnotated, type ResourceDiffStarted, type ResourcePlanned, type ResourceStatusChanged, type StateBootstrapCompleted, type StateBootstrapStarted, type StateEvent, } from "../Report.ts";
-/**
- * Decorate a reporter so a {@link ProgressEvent} with a span-event shape is
- * also recorded on the currently active span before it reaches the
- * renderer. Emission happens inside the engine's instrumented fibers, so
- * apply events land on `apply.resource` / `provider.<op>` spans — giving
- * traces a within-span timeline of status transitions. A no-op when no
- * span is active (tracing disabled), and independent of whether a renderer
- * is attached, so `--yes` and CI runs still produce the events.
- */
-export declare const withSpanEvents: (report: ProgressReporter) => ProgressReporter;
-/** Adapt the ambient reporter to the engine's apply-session contract. */
-export declare const applySession: (report: ProgressReporter) => PlanStatusSession;
-//# sourceMappingURL=Progress.d.ts.map

package/lib/Alchemist/Progress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Progress.d.ts","sourceRoot":"","sources":["../../src/Alchemist/Progress.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAiB,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAMrD,OAAO,EACL,QAAQ,EACR,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,0BAA0B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,aAAa,EAClB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC1B,KAAK,UAAU,GAChB,MAAM,cAAc,CAAC;AAmGtB;;;;;;;;GAQG;AACH,eAAO,MAAM,cAAc,WAChB,gBAAgB,KAAG,gBAa3B,CAAC;AAEJ,yEAAyE;AACzE,eAAO,MAAM,YAAY,WAAY,gBAAgB,KAAG,iBAGtD,CAAC"}