alchemy 2.0.0-beta.65 → 2.0.0-beta.67

package/src/Test/Alchemy.ts

@@ -264,7 +264,9 @@ export const make = <ROut = any>(options: MakeOptions<ROut>): TestApi => {
   // closes it. We defer registration to a microtask so it runs AFTER any
   // user-registered `afterAll` (including `destroy(Stack)`); the runner
   // executes afterAll hooks in registration order, and file collection
-  // flushes microtasks before sealing the file's suite tree.
+  // flushes microtasks before sealing the file's suite tree. (Files are
+  // collected in parallel, but the microtask carries the AsyncLocalStorage
+  // context of this file's import, so the hook lands on the right suite.)
   queueMicrotask(() => {
     registerHook("afterAll", {
       body: () => closeScope,

package/src/Test/Core.ts

@@ -288,14 +288,7 @@ export const scratchStack = <ROut>(
     plan: ((effect: Effect.Effect<any, any, any>) =>
       buildPlan(effect)) as ScratchStack<ROut>["plan"],
     destroy: () =>
-      Plan.make({
-        name: stackName,
-        stage,
-        resources: {},
-        bindings: {},
-        actions: {},
-        output: {},
-      }).pipe(
+      Plan.destroy({ name: stackName, stage }).pipe(
         Effect.flatMap(apply),
         Effect.asVoid,
         Effect.provide(stateLayer),

package/src/Util/Clank.ts

@@ -14,16 +14,15 @@ export const retryIfCancelled = Effect.retry({
  *
  * Returns `undefined` if the user cancels (Ctrl+C / Escape).
  *
- * Uses `Effect.callback` so fiber interruption propagates via the abort
- * signal to any async resources we own; the clack prompt itself is left
- * to resolve — its result is ignored after interruption.
+ * Uses `Effect.callback` so fiber interruption propagates to the clack
+ * prompt through its abort signal, releasing stdin and restoring the cursor.
  */
 export const prompt = <T>(
-  fn: () => Promise<T | symbol>,
+  fn: (signal: AbortSignal) => Promise<T | symbol>,
 ): Effect.Effect<T, PromptCancelled> =>
   Effect.callback<T, PromptCancelled>((resume, signal) => {
     let settled = false;
-    fn().then(
+    fn(signal).then(
       (result) => {
         if (settled || signal.aborted) return;
         settled = true;
@@ -45,15 +44,42 @@ export const success = (str: string) => Effect.sync(() => p.log.success(str));
 export const warn = (str: string) => Effect.sync(() => p.log.warn(str));
 export const error = (str: string) => Effect.sync(() => p.log.error(str));
 export const info = (str: string) => Effect.sync(() => p.log.info(str));
-export const text = (opts: p.TextOptions) => prompt(() => p.text(opts));
-export const password = (opts: p.PasswordOptions) =>
-  prompt(() => p.password(opts));
+type TextOptions = Omit<p.TextOptions, "validate"> & {
+  validate?: (value: string) => string | Error | undefined;
+};
+
+type PasswordOptions = Omit<p.PasswordOptions, "validate"> & {
+  validate?: (value: string) => string | Error | undefined;
+};
+
+export const text = (opts: TextOptions) => {
+  const validate = opts.validate;
+  return prompt<string>((signal) =>
+    p.text({
+      ...opts,
+      signal,
+      validate:
+        validate === undefined ? undefined : (value) => validate(value ?? ""),
+    }),
+  );
+};
+export const password = (opts: PasswordOptions) => {
+  const validate = opts.validate;
+  return prompt<string>((signal) =>
+    p.password({
+      ...opts,
+      signal,
+      validate:
+        validate === undefined ? undefined : (value) => validate(value ?? ""),
+    }),
+  );
+};
 export const select = <Value>(opts: p.SelectOptions<Value>) =>
-  prompt(() => p.select<Value>(opts));
+  prompt((signal) => p.select<Value>({ ...opts, signal }));
 export const confirm = (opts: p.ConfirmOptions) =>
-  prompt(() => p.confirm(opts));
+  prompt((signal) => p.confirm({ ...opts, signal }));
 export const multiselect = <Value>(opts: p.MultiSelectOptions<Value>) =>
-  prompt(() => p.multiselect<Value>(opts));
+  prompt((signal) => p.multiselect<Value>({ ...opts, signal }));
 
 /**
  * Open a URL in the user's default browser.

package/src/Util/zip.ts

@@ -3,6 +3,11 @@ import * as Effect from "effect/Effect";
 export interface ZipFile {
   path: string;
   content: string | Uint8Array<ArrayBufferLike>;
+  /**
+   * Unix file mode to record in the archive entry (e.g. `0o755` to keep an
+   * executable bit). Omit to use the archiver's default.
+   */
+  mode?: number;
 }
 
 export const zipCode = Effect.fn(function* (
@@ -25,3 +30,37 @@ export const zipCode = Effect.fn(function* (
     }),
   );
 });
+
+/**
+ * Package `files` into a deterministic zip archive: entries are sorted by
+ * path and stamped with a fixed timestamp so identical inputs always produce
+ * identical bytes.
+ */
+export const zipFiles = Effect.fn(function* (files: ReadonlyArray<ZipFile>) {
+  // Create a zip buffer in memory
+  const zip = new (yield* Effect.promise(() => import("jszip"))).default();
+  const date = new Date("1980-01-01T00:00:00.000Z");
+  for (const file of [...files].sort((a, b) => (a.path < b.path ? -1 : 1))) {
+    zip.file(file.path, file.content, {
+      date,
+      unixPermissions: file.mode,
+    });
+  }
+  // Nested paths make JSZip synthesize the intermediate folder entries, and
+  // those are stamped with `new Date()` rather than the per-file `date`
+  // above. Left alone, two archives built from identical bytes seconds apart
+  // differ — which reads downstream as a content change.
+  yield* Effect.sync(() => {
+    for (const entry of Object.values(zip.files)) {
+      entry.date = date;
+    }
+  });
+
+  return yield* Effect.promise(() =>
+    zip.generateAsync({
+      type: "nodebuffer",
+      compression: "DEFLATE",
+      platform: "UNIX",
+    }),
+  );
+});

package/src/index.ts

@@ -25,6 +25,8 @@ export { ALCHEMY_DEV, ALCHEMY_PHASE, type AlchemyPhase } from "./Phase.ts";
 export * from "./PhysicalName.ts";
 export * as Plan from "./Plan.ts";
 export { Provider, ProviderCollection } from "./Provider.ts";
+export * as ProviderMode from "./ProviderMode.ts";
+export { remote } from "./ProviderMode.ts";
 export * from "./Random.ts";
 export * from "./Ref.ts";
 export * as RemovalPolicy from "./RemovalPolicy.ts";
@@ -36,6 +38,7 @@ export { Stack } from "./Stack.ts";
 export * from "./Stage.ts";
 export { inMemoryState, localState } from "./State/index.ts";
 export * as Sync from "./Sync.ts";
+export * as Telemetry from "./Telemetry.ts";
 
 // Re-export internal types so they can be portably named in
 // downstream `.d.ts` emissions (fixes TS2883 in user files).