effect-pulumi 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Piers Karsenbarg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,283 @@
+# effect-pulumi
+
+[![CI](https://github.com/pierskarsenbarg/effect-pulumi/actions/workflows/ci.yml/badge.svg)](https://github.com/pierskarsenbarg/effect-pulumi/actions/workflows/ci.yml)
+
+Gives Pulumi programs Effect's composability — typed errors, sequenced
+dependent resources, and structured result inspection — without hand-wrapping
+every resource constructor.
+
+## Why
+
+Mixing Effect and Pulumi by hand means wrapping every constructor and every
+data-source call yourself:
+
+```ts
+const bucket = yield* Effect.try({
+  try: () => new aws.s3.Bucket("assets", { forceDestroy: true }),
+  catch: (cause) => new InfraError({ cause }),
+});
+const ami = yield* Effect.tryPromise({
+  try: () => aws.ec2.getAmi({ mostRecent: true, owners: ["amazon"] }),
+  catch: (cause) => new InfraError({ cause }),
+});
+```
+
+`effectify` wraps the provider package once, and both collapse to plain calls
+with a shared, typed error channel:
+
+```ts
+const eaws = effectify(aws);
+
+const bucket = yield* eaws.s3.Bucket("assets", { forceDestroy: true });
+const ami = yield* eaws.ec2.getAmi({ mostRecent: true, owners: ["amazon"] });
+```
+
+## Install
+
+```sh
+npm install effect-pulumi
+```
+
+Requires Node.js ≥ 22 (the floor `@pulumi/pulumi` itself sets). The peer
+ranges are `@pulumi/pulumi ^3.0.0` and `effect ^3.0.0`, currently verified
+against `@pulumi/pulumi` 3.255 and `effect` 3.22.
+
+`@pulumi/pulumi` and `effect` are peer dependencies — this library extends
+your Pulumi and Effect runtimes, so it must use the same copies you do rather
+than bundle its own. npm 7+ installs peers automatically; on pnpm or Yarn you
+may need them explicitly:
+
+```sh
+npm install @pulumi/pulumi effect
+```
+
+Ships as dual ESM + CommonJS, so it works from a conventional CJS Pulumi
+program as well as an ESM one:
+
+```ts
+import { effectify } from "effect-pulumi";   // ESM
+const { effectify } = require("effect-pulumi"); // CJS
+```
+
+## Quick start
+
+```ts
+import * as aws from "@pulumi/aws";
+import { Effect } from "effect";
+import { effectify, fromOutput, fromOutputs } from "effect-pulumi";
+
+const eaws = effectify(aws); // wrap the provider package once
+
+const program = Effect.gen(function* () {
+  const bucket = yield* eaws.s3.Bucket("assets", { forceDestroy: true });
+  //    ^ Effect<aws.s3.Bucket, PulumiError> — no Effect.sync / Effect.try
+
+  const object = yield* eaws.s3.BucketObject("readme", {
+    bucket: fromOutput(bucket.id), // an Effect in an args slot, auto-resolved
+    key: "readme.txt",
+    content: "hello",
+  });
+
+  return yield* fromOutputs({ id: bucket.id, key: object.key });
+});
+
+// In a classic (ESM) Pulumi project this is the whole entrypoint: run the
+// Effect at module load and export the results as stack outputs.
+export const { id, key } = await Effect.runPromise(program);
+```
+
+Alternatively, hand `program` to the [Automation API](#automation-api) as an
+inline program and deploy it from the same process.
+
+The full version of the program above lives in
+[`test/s3-bucket-program.ts`](test/s3-bucket-program.ts). It sits in `test/`
+rather than `examples/` because it is a fixture rather than a project you can
+run — its only consumer today is the mocked suite in `npm test`, exercising a
+real `@pulumi/aws` package under Pulumi's mocks, no cloud account involved.
+
+For examples you can actually deploy, see [`examples/`](examples/) — those use
+`@pulumi/random`, whose resources take no inputs from one another, so they
+don't show `fromOutput` or an Effect in an args slot. For that, see
+[`test/random-password-file-program.ts`](test/random-password-file-program.ts):
+a `RandomPassword`'s Output flows into a `local.File`'s args, and it's
+deployed for real by `npm run test:live` — no cloud credentials needed, since
+`@pulumi/local` only touches the local filesystem.
+
+## What `effectify` does
+
+`effectify(mod)` returns a lazy, memoized proxy over a provider package:
+
+| Export kind | Result |
+| --- | --- |
+| `CustomResource` subclass | `(name, args, opts?) => Effect<R, PulumiError>`, and any **top-level** args field may additionally be an `Effect` (several resolve concurrently) |
+| `ComponentResource` subclass | `(name, args, opts?) => Effect<R, PulumiError>`, args passed through verbatim — never auto-lifted |
+| Namespace object (`aws.s3`) | Recursively proxied, lazily |
+| Invoke function (`aws.s3.getBucket`) | Returns `Effect<R, PulumiError>` instead of `Promise<R>` |
+| `*Output` invoke variant (`getBucketOutput`) | Passed through untouched (returns an `Output`, as upstream) |
+| Enums, plain values, sync functions | Passed through untouched |
+
+Semantics worth knowing:
+
+- **Outputs still work exactly as in vanilla Pulumi.** `effectify` only
+  *additionally* accepts `Effect`s; passing a bare `Output<T>` or `Input<T>`
+  needs no unwrapping or rewrapping.
+- **Statics survive the wrapping.** `eaws.s3.Bucket.get(name, id)` (adopt an
+  existing resource), `isInstance`, and any other codegen'd static forward to
+  the original class — `instanceof` works too — so the wrapped package can be
+  the only import a program needs.
+- **Component args are never lifted.** Component args aren't guaranteed to be
+  `Input<T>`-shaped the way codegen'd `CustomResource` args are — a component
+  may do synchronous work on a bare primitive in its constructor — so passing
+  an `Effect` where a component expects a primitive is a type error. See
+  [Component resources](#component-resources) for the patterns this implies.
+- **Invokes start when you call them.** Whether a function is async is only
+  knowable by calling it, so `eaws.getAmi(args)` fires the invoke immediately
+  and hands back an Effect that resolves the already-in-flight call — the
+  failure still lands in the typed error channel, but `Effect.retry` re-awaits
+  the same call rather than re-invoking. To re-invoke per attempt, defer the
+  call site: `Effect.suspend(() => eaws.getAmi(args))`.
+
+Resource registration stays synchronous under the hood; `Effect.try` runs its
+thunk immediately. This removes wrapper boilerplate, not Pulumi's execution
+model.
+
+## Component resources
+
+Component resources are fully supported as *consumers*: `effectify` detects
+any class extending `pulumi.ComponentResource` — your own, or those in a
+component-based package like `@pulumi/awsx` — and wraps its constructor into
+an Effect factory, exactly like a custom resource. Construction errors land
+in the typed error channel, and the component sequences with `yield*` like
+everything else.
+
+What differs is the args object. Custom resource args can carry `Effect`
+fields because codegen guarantees they are all `Input<T>`-shaped, so
+substituting a resolved value is always legal. Component args are
+hand-authored: a component may take a bare `replicas: number` and do
+synchronous arithmetic on it inside its constructor, and an `Effect` silently
+swapped in there would break it. So for components, `effectify` refuses at
+the type level instead of guessing — resolve your Effects first, then
+construct with plain values:
+
+```ts
+const eawsx = effectify(awsx);
+
+const program = Effect.gen(function* () {
+  // ✗ type error — component args are never auto-lifted:
+  //   eawsx.ecs.Cluster("app", { vpcId: fromOutput(vpc.id) })
+
+  // ✓ resolve first, then pass a plain value (or just pass the Output —
+  //   Input<T>-typed component args accept those as in vanilla Pulumi):
+  const vpcId = yield* fromOutput(vpc.id);
+  const cluster = yield* eawsx.ecs.Cluster("app", { vpcId });
+});
+```
+
+*Authoring* a component is different: a `ComponentResource` constructor is
+synchronous, so you cannot `yield*` inside it. Write a component's internals
+in plain Pulumi — its children are ordinary constructor calls — and use
+`effectify` at the program level, where composition actually happens. The
+wrapped and unwrapped worlds interoperate freely: a component built from raw
+Pulumi children can itself be constructed through an effectified package,
+and its `Output` properties flow into `fromOutput`/`fromOutputs` like any
+other resource's.
+
+## Automation API
+
+`deploy` runs `createOrSelectStack` → config → `up` as one pipeline, returning
+the stack handle alongside the result so callers can tear down without
+re-selecting.
+
+```ts
+const exit = await Effect.runPromiseExit(
+  deploy({
+    stackName,
+    projectName,
+    program: inlineProgram("dev"),
+    up: { onOutput: (out) => process.stdout.write(out) },
+  })
+);
+// Exit/Cause instead of a thrown, stringified error
+```
+
+Every operation forwards the matching Pulumi options type — `UpOptions`,
+`PreviewOptions`, `RefreshOptions`, `DestroyOptions`, `RemoveOptions`. Pass
+`onOutput` to stream the CLI's progress; without it a multi-minute deploy
+prints nothing until it finishes. Stacks can be inline programs
+(`projectName` + `program`) or an existing project on disk (`workDir`).
+
+Previewing is opt-in via `preview: true` (or a `PreviewOptions` object), and
+its result comes back on `DeployResult.preview`. It is off by default because
+a preview is a full engine run against the provider, so previewing and then
+immediately upping does the work twice — and `up` surfaces the same failures.
+
+Teardown is two steps. `destroyStack` removes the resources but leaves the
+stack registered with the backend; `teardownStack` destroys and then deletes
+it, which is what you want for per-run stacks. `RemoveOptions.force` deletes a
+stack while leaving its resources alive and billing — it is reachable, but it
+orphans them.
+
+## Handling failures
+
+Failures are values with types, not stringified stack traces. `PulumiError`
+covers resource construction and Output resolution; `AutomationError` adds
+the lifecycle `stage` it came from. Both derive `.message` from the
+underlying cause, so they read well even outside Effect.
+
+```ts
+import { Effect } from "effect";
+import { deploy } from "effect-pulumi";
+
+const guarded = deploy({ stackName, projectName, program }).pipe(
+  // Transient engine failures during `up` are worth another attempt; a
+  // failure creating the stack or setting config is not.
+  Effect.retry({ times: 2, while: (error) => error.stage === "up" }),
+  Effect.catchTag("AutomationError", (error) =>
+    Effect.fail(new Error(`deploy failed at ${error.stage}: ${error.message}`))
+  )
+);
+```
+
+The same works inside a program: `Effect.catchTag("PulumiError", …)` around a
+resource, or `Effect.exit` / `runPromiseExit` at the edge to inspect the full
+`Cause`.
+
+## API
+
+| Export | What it does |
+| --- | --- |
+| `effectify(mod)` | Wrap a provider package (or any namespace) once; see the table above |
+| `fromOutput(output)` | `Output<T>` → `Effect<T, PulumiError>`; resolves to the unknown sentinel during `preview` instead of throwing |
+| `fromOutputs(record)` | Record of Outputs → `Effect` of the resolved record |
+| `deploy(opts)` | Select/create stack → apply config → optional preview → `up`; returns `{ stack, result, preview? }` |
+| `createOrSelectStack(opts)` | Inline (`projectName` + `program`) or local (`workDir`) stack |
+| `setStackConfig(stack, config)` | Apply a whole config map in one `setAllConfig` round-trip |
+| `previewStack(stack, opts?)` | `pulumi preview`, returning the `PreviewResult` |
+| `upStack(stack, opts?)` | `pulumi up`, returning the `UpResult` |
+| `refreshStack(stack, opts?)` | Re-sync state from the actual cloud resources |
+| `stackOutputs(stack)` | Read current outputs without running an update |
+| `destroyStack(stack, opts?)` | Destroy resources; the stack stays registered |
+| `removeStack(stack, opts?)` | Delete the stack from the backend |
+| `teardownStack(stack, opts?)` | Destroy then remove — skips the remove if the destroy failed |
+| `PulumiError` | Construction / Output-resolution failure; carries `cause` |
+| `AutomationError` | Lifecycle failure; carries `stage` and `cause` |
+
+## Scripts
+
+| Command | What it does |
+| --- | --- |
+| `npm run build` | Build dual ESM + CJS (`tsup`) with declarations to `dist/` |
+| `npm run typecheck` | Type-check everything, including tests and examples |
+| `npm run lint` | Lint with `oxlint` (`npm run lint:fix` applies safe fixes) |
+| `npm run format` | Format with `oxfmt` (`npm run format:check` asserts instead) |
+| `npm run check` | `typecheck` + `lint` + `format:check`, the pre-commit sweep |
+| `npm test` | Unit + mocked-provider tests. No credentials needed |
+| `npm run test:package` | Builds, packs a tarball and consumes it from ESM and CJS projects |
+| `npm run test:live` | Deploys `test/s3-bucket-program.ts` against real AWS, then destroys it |
+
+`npm test` never runs the live harness: it's excluded in `vitest.config.ts`
+and additionally gated on `EFFECT_PULUMI_RUN_LIVE_TESTS=1`. The live harness
+picks up credentials from the environment the normal way each provider expects
+(e.g. `AWS_PROFILE` / `AWS_ACCESS_KEY_ID`), and uses
+`Effect.acquireRelease` + `Effect.scoped` so the stack is destroyed even when
+an assertion fails.

package/dist/index.cjs

@@ -0,0 +1,247 @@
+'use strict';
+
+var effect = require('effect');
+var pulumi2 = require('@pulumi/pulumi');
+var index_js = require('@pulumi/pulumi/automation/index.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var pulumi2__namespace = /*#__PURE__*/_interopNamespace(pulumi2);
+
+// src/errors.ts
+var describeCause = (cause) => cause instanceof Error ? cause.message : String(cause);
+var PulumiError = class extends effect.Data.TaggedError("PulumiError") {
+  /** Derived so anything reading `.message` — plain logging, test failure
+   * output, non-Effect error handling — sees the underlying failure instead
+   * of an empty string. */
+  get message() {
+    return describeCause(this.cause);
+  }
+};
+var AutomationError = class extends effect.Data.TaggedError("AutomationError") {
+  /** `"<stage> failed: <cause>"` — the stage is included because the cause
+   * alone rarely says which operation produced it. */
+  get message() {
+    return `${this.stage} failed: ${describeCause(this.cause)}`;
+  }
+};
+var fromOutput = (output) => effect.Effect.tryPromise({
+  try: () => output.promise(true),
+  catch: (cause) => new PulumiError({ cause })
+});
+var fromOutputs = (outputs) => fromOutput(pulumi2__namespace.all(outputs));
+var isResourceConstructor = (value) => typeof value === "function" && (value === pulumi2__namespace.Resource || value.prototype instanceof pulumi2__namespace.Resource);
+var isComponentResourceConstructor = (Ctor) => Ctor === pulumi2__namespace.ComponentResource || Ctor.prototype instanceof pulumi2__namespace.ComponentResource;
+var isNamespace = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isArgsObject = (value) => isNamespace(value);
+var isPromiseLike = (value) => typeof value === "object" && value !== null && typeof value.then === "function";
+var proxyCache = /* @__PURE__ */ new WeakMap();
+var isEffect = (value) => effect.Effect.isEffect(value);
+function resolveLiftedArgs(args) {
+  if (!isArgsObject(args)) {
+    return effect.Effect.succeed(args);
+  }
+  const effectEntries = Object.entries(args).filter(([, v]) => isEffect(v));
+  if (effectEntries.length === 0) {
+    return effect.Effect.succeed(args);
+  }
+  return effect.Effect.map(
+    effect.Effect.all(
+      effectEntries.map(
+        ([key, effectValue]) => effect.Effect.map(
+          effectValue,
+          (resolved) => [key, resolved]
+        )
+      ),
+      { concurrency: "unbounded" }
+    ),
+    (resolved) => ({ ...args, ...Object.fromEntries(resolved) })
+  );
+}
+function wrapCustomResourceCtor(Ctor) {
+  return (name, args, opts) => effect.Effect.gen(function* () {
+    const resolvedArgs = yield* resolveLiftedArgs(args);
+    return yield* effect.Effect.try({
+      try: () => new Ctor(name, resolvedArgs, opts),
+      catch: (cause) => new PulumiError({ cause })
+    });
+  });
+}
+function wrapComponentResourceCtor(Ctor) {
+  return (name, args, opts) => effect.Effect.try({
+    try: () => new Ctor(name, args, opts),
+    catch: (cause) => new PulumiError({ cause })
+  });
+}
+var withStatics = (factory, Ctor) => new Proxy(factory, {
+  get: (target, prop, receiver) => Reflect.has(target, prop) ? Reflect.get(target, prop, receiver) : Reflect.get(Ctor, prop),
+  has: (target, prop) => Reflect.has(target, prop) || Reflect.has(Ctor, prop)
+});
+function wrapResourceCtor(Ctor) {
+  const factory = isComponentResourceConstructor(Ctor) ? wrapComponentResourceCtor(Ctor) : wrapCustomResourceCtor(
+    Ctor
+  );
+  return withStatics(factory, Ctor);
+}
+function wrapInvokeLike(fn) {
+  return new Proxy(fn, {
+    apply(target, thisArg, args) {
+      const result = Reflect.apply(target, thisArg, args);
+      if (!isPromiseLike(result)) {
+        return result;
+      }
+      result.then(void 0, () => {
+      });
+      return effect.Effect.tryPromise({
+        try: () => result,
+        catch: (cause) => new PulumiError({ cause })
+      });
+    }
+  });
+}
+var wrapperCache = /* @__PURE__ */ new WeakMap();
+function effectifyValue(value) {
+  if (isResourceConstructor(value)) {
+    const cached = wrapperCache.get(value);
+    if (cached) return cached;
+    const wrapped = wrapResourceCtor(value);
+    wrapperCache.set(value, wrapped);
+    return wrapped;
+  }
+  if (typeof value === "function") {
+    const cached = wrapperCache.get(value);
+    if (cached) return cached;
+    const wrapped = wrapInvokeLike(value);
+    wrapperCache.set(value, wrapped);
+    return wrapped;
+  }
+  if (isNamespace(value)) {
+    return effectifyInner(value);
+  }
+  return value;
+}
+function effectifyInner(mod) {
+  const cached = proxyCache.get(mod);
+  if (cached) return cached;
+  const proxy = new Proxy(/* @__PURE__ */ Object.create(null), {
+    get(_target, prop) {
+      return effectifyValue(Reflect.get(mod, prop));
+    },
+    has(_target, prop) {
+      return Reflect.has(mod, prop);
+    },
+    ownKeys() {
+      return Reflect.ownKeys(mod);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);
+      if (!descriptor) return void 0;
+      return {
+        value: effectifyValue(Reflect.get(mod, prop)),
+        enumerable: descriptor.enumerable,
+        configurable: true,
+        writable: true
+      };
+    },
+    set() {
+      return false;
+    }
+  });
+  proxyCache.set(mod, proxy);
+  return proxy;
+}
+function effectify(mod) {
+  return effectifyInner(mod);
+}
+var isLocal = (opts) => "workDir" in opts;
+var createOrSelectStack = (opts) => effect.Effect.tryPromise({
+  try: () => isLocal(opts) ? index_js.LocalWorkspace.createOrSelectStack(
+    { stackName: opts.stackName, workDir: opts.workDir },
+    opts.workspaceOptions
+  ) : index_js.LocalWorkspace.createOrSelectStack(
+    {
+      stackName: opts.stackName,
+      projectName: opts.projectName,
+      program: opts.program
+    },
+    opts.workspaceOptions
+  ),
+  catch: (cause) => new AutomationError({ stage: "createOrSelectStack", cause })
+});
+var setStackConfig = (stack, config) => !config || Object.keys(config).length === 0 ? effect.Effect.void : effect.Effect.tryPromise({
+  try: () => stack.setAllConfig(config),
+  catch: (cause) => new AutomationError({ stage: "setConfig", cause })
+});
+var previewStack = (stack, opts) => effect.Effect.tryPromise({
+  try: () => stack.preview(opts),
+  catch: (cause) => new AutomationError({ stage: "preview", cause })
+});
+var upStack = (stack, opts) => effect.Effect.tryPromise({
+  try: () => stack.up(opts),
+  catch: (cause) => new AutomationError({ stage: "up", cause })
+});
+var refreshStack = (stack, opts) => effect.Effect.tryPromise({
+  try: () => stack.refresh(opts),
+  catch: (cause) => new AutomationError({ stage: "refresh", cause })
+});
+var stackOutputs = (stack) => effect.Effect.tryPromise({
+  try: () => stack.outputs(),
+  catch: (cause) => new AutomationError({ stage: "outputs", cause })
+});
+var destroyStack = (stack, opts) => effect.Effect.tryPromise({
+  try: () => stack.destroy(opts),
+  catch: (cause) => new AutomationError({ stage: "destroy", cause })
+});
+var removeStack = (stack, opts) => effect.Effect.tryPromise({
+  try: () => stack.workspace.removeStack(stack.name, opts),
+  catch: (cause) => new AutomationError({ stage: "removeStack", cause })
+});
+var teardownStack = (stack, opts) => effect.Effect.gen(function* () {
+  const result = yield* destroyStack(stack, opts?.destroy);
+  yield* removeStack(stack, opts?.remove);
+  return result;
+});
+var deploy = (opts) => effect.Effect.gen(function* () {
+  const stack = yield* createOrSelectStack(opts);
+  yield* setStackConfig(stack, opts.config);
+  const preview = opts.preview ? yield* previewStack(
+    stack,
+    typeof opts.preview === "boolean" ? void 0 : opts.preview
+  ) : void 0;
+  const result = yield* upStack(stack, opts.up);
+  return { stack, result, preview };
+});
+
+exports.AutomationError = AutomationError;
+exports.PulumiError = PulumiError;
+exports.createOrSelectStack = createOrSelectStack;
+exports.deploy = deploy;
+exports.destroyStack = destroyStack;
+exports.effectify = effectify;
+exports.fromOutput = fromOutput;
+exports.fromOutputs = fromOutputs;
+exports.previewStack = previewStack;
+exports.refreshStack = refreshStack;
+exports.removeStack = removeStack;
+exports.setStackConfig = setStackConfig;
+exports.stackOutputs = stackOutputs;
+exports.teardownStack = teardownStack;
+exports.upStack = upStack;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/errors.ts","../src/output-bridge.ts","../src/effectify.ts","../src/automation.ts"],"names":["Data","Effect","pulumi","pulumi2","LocalWorkspace"],"mappings":"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","file":"index.cjs","sourcesContent":["import { Data } from \"effect\";\n\nconst describeCause = (cause: unknown): string =>\n  cause instanceof Error ? cause.message : String(cause);\n\n/**\n * Any synchronous failure constructing a resource (bad args, provider\n * validation, etc.), or a failure resolving an Output's promise.\n *\n * Tagged `\"PulumiError\"`, so it can be matched by tag rather than by\n * `instanceof`:\n *\n * @example\n * ```ts\n * program.pipe(\n *   Effect.catchTag(\"PulumiError\", (e) => Effect.logError(e.message))\n * );\n * ```\n */\nexport class PulumiError extends Data.TaggedError(\"PulumiError\")<{\n  /** The original thrown value or rejection reason, unwrapped and unmodified.\n   * Not necessarily an `Error`. */\n  readonly cause: unknown;\n}> {\n  /** Derived so anything reading `.message` — plain logging, test failure\n   * output, non-Effect error handling — sees the underlying failure instead\n   * of an empty string. */\n  get message(): string {\n    return describeCause(this.cause);\n  }\n}\n\n/**\n * Failure from an Automation API lifecycle call (up/preview/destroy/select).\n *\n * `stage` says which call failed, which matters most in the composite\n * operations: a failed `deploy` could have died selecting the stack, applying\n * config, or running the update, and the three want different responses.\n *\n * @example\n * ```ts\n * deploy(opts).pipe(\n *   Effect.catchTag(\"AutomationError\", (e) =>\n *     e.stage === \"createOrSelectStack\"\n *       ? Effect.fail(new BackendUnreachable())\n *       : Effect.logError(e.message)\n *   )\n * );\n * ```\n */\nexport class AutomationError extends Data.TaggedError(\"AutomationError\")<{\n  /** Which Automation API call failed. Named for the wrapper that raised it,\n   * so `deploy`'s failures still report the underlying stage. */\n  readonly stage:\n    | \"createOrSelectStack\"\n    | \"setConfig\"\n    | \"up\"\n    | \"preview\"\n    | \"refresh\"\n    | \"outputs\"\n    | \"destroy\"\n    | \"removeStack\";\n  /** The rejection reason from the Automation API. For a failed update this is\n   * usually a `CommandError` carrying the CLI's stdout and stderr. */\n  readonly cause: unknown;\n}> {\n  /** `\"<stage> failed: <cause>\"` — the stage is included because the cause\n   * alone rarely says which operation produced it. */\n  get message(): string {\n    return `${this.stage} failed: ${describeCause(this.cause)}`;\n  }\n}\n","import * as pulumi from \"@pulumi/pulumi\";\nimport { Effect } from \"effect\";\nimport { PulumiError } from \"./errors.js\";\n\n/** `Output.promise()` is how the Pulumi runtime itself gets a settled value out\n * of an Output, but it is not part of the public `Output<T>` surface. */\ninterface PromisableOutput<T> {\n  promise(withUnknowns?: boolean): Promise<T>;\n}\n\n/**\n * Lift a single Output into an Effect.\n *\n * `withUnknowns: true` matters during `pulumi preview`, where a not-yet-created\n * resource's outputs have no value: it resolves to Pulumi's unknown sentinel\n * instead of throwing, so a program that reads outputs still previews cleanly.\n *\n * @param output - The Output to resolve.\n * @returns An Effect yielding the settled value, failing with\n * {@link PulumiError} if the underlying promise rejects.\n *\n * @example\n * ```ts\n * const bucket = yield* eaws.s3.Bucket(\"assets\", {});\n * const id = yield* fromOutput(bucket.id); // string\n * ```\n *\n * @remarks Reading an Output only makes sense inside a running Pulumi program.\n * During `preview` the value may be the unknown sentinel rather than real data,\n * so don't branch on it to decide what to create.\n */\nexport const fromOutput = <T>(\n  output: pulumi.Output<T>\n): Effect.Effect<T, PulumiError> =>\n  Effect.tryPromise({\n    try: () => (output as unknown as PromisableOutput<T>).promise(true),\n    catch: (cause) => new PulumiError({ cause }),\n  });\n\n/**\n * Lift a record of Outputs into a single Effect of the resolved record — use\n * this right after constructing a resource to grab several fields at once.\n *\n * Resolves them together via `pulumi.all`, so it costs one await rather than\n * one per field.\n *\n * @param outputs - A record whose values are all Outputs. Interfaces work as\n * well as object literals; the constraint is self-referential rather than\n * `Record<string, Output<any>>` precisely so interface-typed bags are accepted.\n * @returns An Effect yielding the same record with each value unwrapped.\n *\n * @example\n * ```ts\n * const bucket = yield* eaws.s3.Bucket(\"assets\", {});\n * const { id, arn } = yield* fromOutputs({ id: bucket.id, arn: bucket.arn });\n * ```\n */\nexport const fromOutputs = <T extends { [K in keyof T]: pulumi.Output<any> }>(\n  outputs: T\n): Effect.Effect<{ [K in keyof T]: pulumi.Unwrap<T[K]> }, PulumiError> =>\n  fromOutput(pulumi.all(outputs) as pulumi.Output<any>);\n","/**\n * effectify — auto-wrap a Pulumi provider package (e.g. @pulumi/aws,\n * @pulumi/cloudflare) so every resource constructor becomes an\n * Effect-returning factory, without the caller ever writing `Effect.sync`.\n *\n * Usage:\n *\n *   import * as aws from \"@pulumi/aws\";\n *   const eaws = effectify(aws);\n *\n *   const program = Effect.gen(function* () {\n *     const bucket = yield* eaws.s3.Bucket(\"my-bucket\", { forceDestroy: true });\n *     //    ^ Effect<aws.s3.Bucket, PulumiError> — no manual wrapping\n *   });\n *\n * How it works:\n *  - Every Pulumi resource class extends `pulumi.Resource` under the hood\n *    (via CustomResource / ComponentResource). That's the runtime marker\n *    used to tell \"this export is a resource constructor\" apart from \"this\n *    export is a namespace object\" (e.g. `aws.s3`) or \"this export is an\n *    invoke function\" (e.g. `aws.s3.getBucket`).\n *  - Namespace objects get recursively proxied (lazily, memoized).\n *  - CustomResource constructors get wrapped so any field in their args\n *    object may *additionally* be an Effect — resolved (concurrently, they\n *    are independent by construction) before construction. This is safe\n *    because codegen guarantees CustomResource args are always\n *    Record<string, Input<T>>.\n *  - Wrapped constructors keep their static members: `Bucket.get(...)`,\n *    `Bucket.isInstance(...)` and friends forward to the original class, so\n *    the wrapped package can be the only import a program needs.\n *  - ComponentResource constructors get wrapped with no arg-lifting — args\n *    pass through exactly as declared, since component args aren't\n *    guaranteed to be Input<T>-shaped (hand-authored, may do synchronous\n *    work on a bare primitive inside the constructor).\n *  - Invoke functions (`aws.s3.getBucket`) return an Effect instead of a\n *    Promise. There is no runtime marker for \"this function is async\", so\n *    the wrapper calls the function and inspects the result: a thenable\n *    becomes an Effect, anything else is returned as-is. That means the\n *    invoke *starts* at the call site (see the caveat on `wrapInvokeLike`);\n *    `*Output` invoke variants return an Output, which is not thenable, so\n *    they pass through untouched — matching the type-level mapping, which\n *    only rewrites Promise-returning signatures.\n *  - Everything else (enums, plain values, non-resource classes) passes\n *    through untouched.\n *\n * Resource registration remains synchronous under the hood — Effect.try\n * runs its thunk immediately. This only removes hand-written wrapper\n * boilerplate, not Pulumi's execution model.\n */\n\nimport * as pulumi from \"@pulumi/pulumi\";\nimport { Effect } from \"effect\";\nimport { PulumiError } from \"./errors.js\";\n\n// ---------------------------------------------------------------------------\n// Runtime type guards\n// ---------------------------------------------------------------------------\n\nconst isResourceConstructor = (\n  value: unknown\n): value is new (...args: any[]) => pulumi.Resource =>\n  typeof value === \"function\" &&\n  (value === (pulumi.Resource as unknown) ||\n    value.prototype instanceof pulumi.Resource);\n\nconst isComponentResourceConstructor = (\n  Ctor: Function\n): Ctor is new (...args: any[]) => pulumi.ComponentResource =>\n  Ctor === (pulumi.ComponentResource as unknown) ||\n  Ctor.prototype instanceof pulumi.ComponentResource;\n\n/** An object whose string-keyed properties we only ever *read*. Distinct from\n * `Record<string, unknown>`, which additionally claims the properties are\n * writable and that the object declares an index signature — neither is true\n * of a codegen'd `BucketArgs`, and neither is something this module relies on. */\ntype UnknownProps = { readonly [key: string]: unknown };\n\n/** Is this a namespace to recurse into? The narrowed type is only ever handed\n * to `effectifyInner`, which takes `object` — so claim exactly that and no\n * more. */\nconst isNamespace = (value: unknown): value is object =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\n/** Is this an args object whose entries we can scan for Effects? Same runtime\n * check as `isNamespace`, but a different question, so it gets the narrowing\n * that question needs: `object` would make `Object.entries` infer `any` values\n * and silently drop the `isEffect` filter's type safety. */\nconst isArgsObject = (value: unknown): value is UnknownProps =>\n  isNamespace(value);\n\n/** Note: `pulumi.Output` is deliberately not thenable, so `*Output` invoke\n * variants fail this check and pass through unwrapped — keeping the runtime\n * behaviour aligned with the type mapping, which only rewrites\n * Promise-returning signatures. */\nconst isPromiseLike = (value: unknown): value is PromiseLike<unknown> =>\n  typeof value === \"object\" &&\n  value !== null &&\n  typeof (value as { then?: unknown }).then === \"function\";\n\n// ---------------------------------------------------------------------------\n// Type-level mapping\n// ---------------------------------------------------------------------------\n\n/** Allow any field of a CustomResource args object to *additionally* be an\n * Effect. Homomorphic, so optional fields stay optional and plain\n * `Input<T>`/`Output<T>` values keep working untouched. */\ntype LiftedArgs<A> = A extends object\n  ? { [K in keyof A]: A[K] | Effect.Effect<A[K], PulumiError> }\n  : A;\n\n/** Apply `LiftedArgs` to the second constructor parameter (the args object),\n * leaving `name` and `opts` alone. Mapping over the parameter tuple\n * homomorphically preserves labels and optionality, so constructors whose\n * args are optional stay callable as `Bucket(\"name\")`. */\ntype LiftArgsParam<P extends readonly unknown[]> = {\n  [K in keyof P]: K extends \"1\" ? LiftedArgs<P[K]> : P[K];\n};\n\n/** The class's static side, minus `prototype`: `keyof` on a constructor type\n * yields exactly the statics (own and inherited, e.g. codegen'd `get` and\n * `isInstance`), which the runtime wrapper forwards to the original class. */\ntype StaticMembers<T> = Omit<T, \"prototype\">;\n\n/**\n * The type of {@link effectify}'s result: `T` with every resource constructor\n * and every `Promise`-returning invoke rewritten, and everything else left\n * alone.\n *\n * The cases, in the order they are tried:\n *\n * | Input                       | Becomes                                        |\n * | --------------------------- | ---------------------------------------------- |\n * | `ComponentResource` class   | factory returning `Effect`, args **not** lifted |\n * | `CustomResource` class      | factory returning `Effect`, args lifted         |\n * | other class                 | unchanged                                       |\n * | `(...) => Promise<R>`       | `(...) => Effect<R, PulumiError>`               |\n * | other function              | unchanged (includes `*Output` invokes)          |\n * | object                      | mapped recursively                              |\n * | anything else               | unchanged                                       |\n *\n * Statics survive on the wrapped constructors, so `Bucket.get` and\n * `Bucket.isInstance` remain callable.\n */\nexport type Effectify<T> = T extends abstract new (\n  ...params: infer P\n) => infer R\n  ? R extends pulumi.ComponentResource\n    ? ((...params: P) => Effect.Effect<R, PulumiError>) & StaticMembers<T>\n    : R extends pulumi.CustomResource\n      ? ((...params: LiftArgsParam<P>) => Effect.Effect<R, PulumiError>) &\n          StaticMembers<T>\n      : T\n  : T extends (...args: infer A) => Promise<infer R>\n    ? (...args: A) => Effect.Effect<R, PulumiError>\n    : T extends (...args: any[]) => any\n      ? T\n      : T extends object\n        ? { [K in keyof T]: Effectify<T[K]> }\n        : T;\n\n// ---------------------------------------------------------------------------\n// Runtime implementation\n// ---------------------------------------------------------------------------\n\nconst proxyCache = new WeakMap<object, unknown>();\n\nconst isEffect = (value: unknown): value is Effect.Effect<unknown, unknown> =>\n  Effect.isEffect(value);\n\nfunction resolveLiftedArgs(args: unknown): Effect.Effect<unknown, PulumiError> {\n  if (!isArgsObject(args)) {\n    return Effect.succeed(args);\n  }\n\n  const effectEntries = Object.entries(args).filter(([, v]) => isEffect(v));\n\n  if (effectEntries.length === 0) {\n    return Effect.succeed(args);\n  }\n\n  // The arg Effects are independent of one another, so resolve them\n  // concurrently — it matters when several of them await slow Outputs.\n  return Effect.map(\n    Effect.all(\n      effectEntries.map(([key, effectValue]) =>\n        Effect.map(\n          effectValue as Effect.Effect<unknown, PulumiError>,\n          (resolved) => [key, resolved] as const\n        )\n      ),\n      { concurrency: \"unbounded\" }\n    ),\n    (resolved) => ({ ...args, ...Object.fromEntries(resolved) })\n  );\n}\n\nfunction wrapCustomResourceCtor(\n  Ctor: new (...args: any[]) => pulumi.CustomResource\n) {\n  return (name: string, args?: unknown, opts?: unknown) =>\n    Effect.gen(function* () {\n      const resolvedArgs = yield* resolveLiftedArgs(args);\n      return yield* Effect.try({\n        try: () => new Ctor(name, resolvedArgs, opts),\n        catch: (cause) => new PulumiError({ cause }),\n      });\n    });\n}\n\nfunction wrapComponentResourceCtor(\n  Ctor: new (...args: any[]) => pulumi.ComponentResource\n) {\n  return (name: string, args?: unknown, opts?: unknown) =>\n    Effect.try({\n      try: () => new Ctor(name, args, opts),\n      catch: (cause) => new PulumiError({ cause }),\n    });\n}\n\n/** Forward static members (codegen'd `get`, `isInstance`, …) from the class\n * onto the factory. The factory's own and inherited properties (`name`,\n * `length`, `call`, …) win; anything else falls through to the class, so new\n * statics keep working without being enumerated here. A bonus of forwarding\n * `prototype` is that `x instanceof wrapped` still works. */\nconst withStatics = <F extends object>(factory: F, Ctor: Function): F =>\n  new Proxy(factory, {\n    get: (target, prop, receiver) =>\n      Reflect.has(target, prop)\n        ? Reflect.get(target, prop, receiver)\n        : Reflect.get(Ctor, prop),\n    has: (target, prop) => Reflect.has(target, prop) || Reflect.has(Ctor, prop),\n  });\n\nfunction wrapResourceCtor(Ctor: new (...args: any[]) => pulumi.Resource) {\n  const factory = isComponentResourceConstructor(Ctor)\n    ? wrapComponentResourceCtor(Ctor)\n    : wrapCustomResourceCtor(\n        Ctor as new (...args: any[]) => pulumi.CustomResource\n      );\n  return withStatics(factory, Ctor);\n}\n\n/** Turn a Promise-returning invoke into an Effect-returning one, leaving\n * synchronous functions' behaviour untouched.\n *\n * A Proxy over the original function (rather than a new function) so `name`,\n * `length`, own properties and prototype all survive; only the call itself is\n * intercepted.\n *\n * Caveat, stated openly: whether a function is async is only knowable by\n * calling it, so the invoke *starts* when the factory is called — the Effect\n * resolves an already-in-flight Promise rather than deferring the call. Two\n * consequences:\n *  - `Effect.retry` re-awaits the same call instead of re-invoking. To\n *    re-invoke per attempt, wrap the call site: `Effect.suspend(() =>\n *    eaws.getAmi(args))`.\n *  - A discarded Effect must not surface as an unhandled rejection, so the\n *    rejection is pre-observed on a side branch before the Effect awaits it.\n */\nfunction wrapInvokeLike(fn: Function): Function {\n  return new Proxy(fn, {\n    apply(target, thisArg, args) {\n      const result = Reflect.apply(target, thisArg, args);\n      if (!isPromiseLike(result)) {\n        return result;\n      }\n      result.then(undefined, () => {});\n      return Effect.tryPromise({\n        try: () => result as Promise<unknown>,\n        catch: (cause) => new PulumiError({ cause }),\n      });\n    },\n  });\n}\n\n/** Wrapped constructors are cached so repeated reads of the same property\n * hand back the same function — identity checks like\n * `eaws.s3.Bucket === eaws.s3.Bucket` hold, and the `get` and\n * `getOwnPropertyDescriptor` traps agree on a property's value. */\nconst wrapperCache = new WeakMap<object, unknown>();\n\nfunction effectifyValue(value: unknown): unknown {\n  if (isResourceConstructor(value)) {\n    const cached = wrapperCache.get(value);\n    if (cached) return cached;\n    const wrapped = wrapResourceCtor(value);\n    wrapperCache.set(value, wrapped);\n    return wrapped;\n  }\n\n  if (typeof value === \"function\") {\n    const cached = wrapperCache.get(value);\n    if (cached) return cached;\n    const wrapped = wrapInvokeLike(value);\n    wrapperCache.set(value, wrapped);\n    return wrapped;\n  }\n\n  if (isNamespace(value)) {\n    return effectifyInner(value);\n  }\n\n  return value; // plain value, enum member, type-only export\n}\n\nfunction effectifyInner<T extends object>(mod: T): Effectify<T> {\n  const cached = proxyCache.get(mod);\n  if (cached) return cached as Effectify<T>;\n\n  // The proxy target is a fresh plain object rather than `mod` itself: ES\n  // module namespace objects (and @pulumi/aws's lazily-defined namespace\n  // getters) expose non-configurable own properties, and a `get` trap that\n  // returns a wrapper instead of the real value would violate the proxy\n  // invariants for those. Forwarding to `mod` from a closure sidesteps that\n  // entirely while keeping the lazy-loading behaviour intact.\n  const proxy = new Proxy(Object.create(null) as T, {\n    get(_target, prop) {\n      return effectifyValue(Reflect.get(mod, prop));\n    },\n    has(_target, prop) {\n      return Reflect.has(mod, prop);\n    },\n    ownKeys() {\n      return Reflect.ownKeys(mod);\n    },\n    getOwnPropertyDescriptor(_target, prop) {\n      const descriptor = Reflect.getOwnPropertyDescriptor(mod, prop);\n      if (!descriptor) return undefined;\n      // Must be reported as configurable — the target does not actually have\n      // the property, so claiming otherwise breaks the proxy invariants.\n      return {\n        value: effectifyValue(Reflect.get(mod, prop)),\n        enumerable: descriptor.enumerable,\n        configurable: true,\n        writable: true,\n      };\n    },\n    set() {\n      return false; // the wrapper is read-only\n    },\n  }) as Effectify<T>;\n\n  proxyCache.set(mod, proxy);\n  return proxy;\n}\n\n/**\n * Wrap a provider package (or any namespace) once, turning every resource\n * constructor into an `Effect`-returning factory and every `Promise`-returning\n * invoke into an `Effect`-returning function.\n *\n * Call this once per package at module scope and export the result — the\n * wrapper is cached, so repeated calls and repeated property reads hand back\n * the same objects, but there is no reason to re-wrap.\n *\n * @param mod - The provider package, or any namespace within one. Not mutated;\n * the result is a read-only proxy that forwards to it.\n * @returns A same-shaped view of `mod`, typed by {@link Effectify}.\n *\n * @example Constructing a resource\n * ```ts\n * import * as aws from \"@pulumi/aws\";\n * const eaws = effectify(aws);\n *\n * const program = Effect.gen(function* () {\n *   const bucket = yield* eaws.s3.Bucket(\"assets\", { forceDestroy: true });\n *   return bucket.id;\n * });\n * ```\n *\n * @example Passing an Effect as an argument\n * A `CustomResource`'s args may hold Effects, which are resolved concurrently\n * before the resource is constructed:\n * ```ts\n * yield* eaws.s3.BucketObject(\"readme\", {\n *   bucket: bucketIdEffect,\n *   content: \"hello\",\n * });\n * ```\n *\n * @throws Nothing. Failures surface in the returned Effect's error channel as\n * {@link PulumiError} — including synchronous throws from the constructor.\n *\n * @see {@link Effectify} for the type-level mapping.\n */\nexport function effectify<T extends object>(mod: T): Effectify<T> {\n  return effectifyInner(mod);\n}\n","import type {\n  ConfigMap,\n  DestroyOptions,\n  DestroyResult,\n  LocalWorkspaceOptions,\n  OutputMap,\n  PreviewOptions,\n  PreviewResult,\n  PulumiFn,\n  RefreshOptions,\n  RefreshResult,\n  RemoveOptions,\n  Stack,\n  UpOptions,\n  UpResult,\n} from \"@pulumi/pulumi/automation/index.js\";\nimport { LocalWorkspace } from \"@pulumi/pulumi/automation/index.js\";\nimport { Effect } from \"effect\";\nimport { AutomationError } from \"./errors.js\";\n\n// ---------------------------------------------------------------------------\n// Primitives\n//\n// Each wraps one Automation API call, tagging failures with the stage they\n// came from. They are exported individually so callers can assemble their own\n// lifecycle — `deploy` below is only the common path.\n//\n// Every operation takes the matching Pulumi options type. That includes\n// `onOutput`: pass it to stream the CLI's progress as it happens. Without it\n// nothing is printed during what may be a multi-minute operation (the text is\n// still captured on the result's `stdout`, and on the error when one is\n// thrown, but only once the operation has finished).\n// ---------------------------------------------------------------------------\n\n/** Arguments for an inline program — the Pulumi program is a function in this\n * process, with no `Pulumi.yaml` on disk. */\nexport interface InlineStackOptions {\n  /** Stack to select, created if absent. */\n  readonly stackName: string;\n  /** Project name to register the stack under. Chosen freely here, since\n   * there is no `Pulumi.yaml` to take it from — but it is part of the stack's\n   * identity in the backend, so changing it later points at a different\n   * stack. */\n  readonly projectName: string;\n  /** The program itself. Runs in this process, so it needs no separate Node\n   * runtime and can close over values from the caller. */\n  readonly program: PulumiFn;\n  readonly workspaceOptions?: LocalWorkspaceOptions;\n}\n\n/** Arguments for a local program — an existing Pulumi project on disk. */\nexport interface LocalStackOptions {\n  /** Stack to select, created if absent. */\n  readonly stackName: string;\n  /** Directory holding the project's `Pulumi.yaml`. Its `name:` supplies the\n   * project name, which is why there is no `projectName` here. */\n  readonly workDir: string;\n  readonly workspaceOptions?: LocalWorkspaceOptions;\n}\n\n/** Either flavour of stack. Discriminated at runtime by the presence of\n * `workDir`, so the two are not interchangeable: an inline program needs\n * `projectName`, a local one takes it from `Pulumi.yaml`. */\nexport type StackOptions = InlineStackOptions | LocalStackOptions;\n\nconst isLocal = (opts: StackOptions): opts is LocalStackOptions =>\n  \"workDir\" in opts;\n\n/** Select the stack, creating it if it does not exist, and return the handle\n * every other operation here takes.\n *\n * Creating the workspace is itself work — it may write files and shell out to\n * the CLI — so hold on to the returned `Stack` rather than re-selecting before\n * each operation. */\nexport const createOrSelectStack = (\n  opts: StackOptions\n): Effect.Effect<Stack, AutomationError> =>\n  Effect.tryPromise({\n    try: () =>\n      isLocal(opts)\n        ? LocalWorkspace.createOrSelectStack(\n            { stackName: opts.stackName, workDir: opts.workDir },\n            opts.workspaceOptions\n          )\n        : LocalWorkspace.createOrSelectStack(\n            {\n              stackName: opts.stackName,\n              projectName: opts.projectName,\n              program: opts.program,\n            },\n            opts.workspaceOptions\n          ),\n    catch: (cause) =>\n      new AutomationError({ stage: \"createOrSelectStack\", cause }),\n  });\n\n/** Apply the whole config map in one `setAllConfig` call — a single CLI\n * round-trip, where per-key `setConfig` costs one `pulumi config set`\n * invocation each. */\nexport const setStackConfig = (\n  stack: Stack,\n  config: ConfigMap | undefined\n): Effect.Effect<void, AutomationError> =>\n  !config || Object.keys(config).length === 0\n    ? Effect.void\n    : Effect.tryPromise({\n        try: () => stack.setAllConfig(config),\n        catch: (cause) => new AutomationError({ stage: \"setConfig\", cause }),\n      });\n\n/** Compute the plan without applying it.\n *\n * A preview is a full engine run against the provider, not a cheap check — see\n * {@link DeployOptions.preview} before pairing one with an `up`. */\nexport const previewStack = (\n  stack: Stack,\n  opts?: PreviewOptions\n): Effect.Effect<PreviewResult, AutomationError> =>\n  Effect.tryPromise({\n    try: () => stack.preview(opts),\n    catch: (cause) => new AutomationError({ stage: \"preview\", cause }),\n  });\n\n/** Apply the program: create, update and delete resources to match it.\n *\n * The result carries the stack's outputs and a summary; pass `onOutput` to\n * watch progress while it runs. */\nexport const upStack = (\n  stack: Stack,\n  opts?: UpOptions\n): Effect.Effect<UpResult, AutomationError> =>\n  Effect.tryPromise({\n    try: () => stack.up(opts),\n    catch: (cause) => new AutomationError({ stage: \"up\", cause }),\n  });\n\n/** Refresh the stack's state from the actual cloud resources, without\n * changing them — what to run when state may have drifted (manual console\n * edits, a crashed update) before deciding what to do about it. */\nexport const refreshStack = (\n  stack: Stack,\n  opts?: RefreshOptions\n): Effect.Effect<RefreshResult, AutomationError> =>\n  Effect.tryPromise({\n    try: () => stack.refresh(opts),\n    catch: (cause) => new AutomationError({ stage: \"refresh\", cause }),\n  });\n\n/** Read the stack's current outputs without running an update. */\nexport const stackOutputs = (\n  stack: Stack\n): Effect.Effect<OutputMap, AutomationError> =>\n  Effect.tryPromise({\n    try: () => stack.outputs(),\n    catch: (cause) => new AutomationError({ stage: \"outputs\", cause }),\n  });\n\n/** Destroy the stack's resources. The stack itself remains registered with\n * the backend — see `removeStack` / `teardownStack` to delete it too. */\nexport const destroyStack = (\n  stack: Stack,\n  opts?: DestroyOptions\n): Effect.Effect<DestroyResult, AutomationError> =>\n  Effect.tryPromise({\n    try: () => stack.destroy(opts),\n    catch: (cause) => new AutomationError({ stage: \"destroy\", cause }),\n  });\n\n/** Delete the stack and its configuration and history from the backend.\n *\n * This does not destroy resources — run `destroyStack` first, or use\n * `teardownStack`. Pulumi refuses to remove a stack that still has resources\n * unless `RemoveOptions.force` is set, and forcing it orphans them: they keep\n * existing and billing with nothing tracking them. */\nexport const removeStack = (\n  stack: Stack,\n  opts?: RemoveOptions\n): Effect.Effect<void, AutomationError> =>\n  Effect.tryPromise({\n    try: () => stack.workspace.removeStack(stack.name, opts),\n    catch: (cause) => new AutomationError({ stage: \"removeStack\", cause }),\n  });\n\n/** Full teardown: destroy the resources, then delete the stack.\n *\n * `destroyStack` alone leaves an empty stack behind, so anything creating\n * stacks per-run (ephemeral environments, tests naming stacks by timestamp)\n * accumulates them in the backend. */\nexport const teardownStack = (\n  stack: Stack,\n  opts?: { readonly destroy?: DestroyOptions; readonly remove?: RemoveOptions }\n): Effect.Effect<DestroyResult, AutomationError> =>\n  Effect.gen(function* () {\n    const result = yield* destroyStack(stack, opts?.destroy);\n    yield* removeStack(stack, opts?.remove);\n    return result;\n  });\n\n// ---------------------------------------------------------------------------\n// Convenience lifecycle\n// ---------------------------------------------------------------------------\n\n/** {@link deploy}'s arguments: the stack to target, plus what to do with it. */\nexport type DeployOptions = StackOptions & {\n  /** Config to apply before the update, in one `setAllConfig` call. Keys are\n   * fully qualified (`\"my-project:myKey\"`). */\n  readonly config?: ConfigMap;\n  /** Options forwarded to the update — `onOutput` to stream progress,\n   * `parallel`, `target`, and so on. */\n  readonly up?: UpOptions;\n  /** Run `preview` before `up`, returning its result.\n   *\n   * Off by default: a preview is a full engine run against the provider, so\n   * previewing and then immediately upping does the work twice. `up` reports\n   * the same failures, so this earns its cost only when you want the plan\n   * itself. */\n  readonly preview?: PreviewOptions | boolean;\n};\n\n/** What {@link deploy} hands back. */\nexport interface DeployResult {\n  /** The selected stack, so teardown needs no second `createOrSelectStack`. */\n  readonly stack: Stack;\n  /** The update's result — `outputs` and `summary` live here. */\n  readonly result: UpResult;\n  /** Present only when `preview` was requested. */\n  readonly preview?: PreviewResult;\n}\n\n/**\n * Select or create the stack, apply config, optionally preview, then up.\n *\n * The common path, assembled from the primitives above. Anything more\n * involved — refreshing first, inspecting the plan before deciding, retrying a\n * stage — should compose those directly rather than grow options here.\n *\n * @param opts - Which stack, and what to do with it.\n * @returns The stack handle alongside the results, so callers can tear down\n * afterwards without re-selecting.\n *\n * @example Deploy, use the outputs, then always tear down\n * ```ts\n * Effect.scoped(\n *   Effect.gen(function* () {\n *     const { result } = yield* Effect.acquireRelease(\n *       deploy({ stackName, projectName, program, up: { onOutput } }),\n *       ({ stack }) => teardownStack(stack).pipe(Effect.ignore)\n *     );\n *     return result.outputs.bucketId?.value;\n *   })\n * );\n * ```\n */\nexport const deploy = (\n  opts: DeployOptions\n): Effect.Effect<DeployResult, AutomationError> =>\n  Effect.gen(function* () {\n    const stack = yield* createOrSelectStack(opts);\n    yield* setStackConfig(stack, opts.config);\n\n    const preview = opts.preview\n      ? yield* previewStack(\n          stack,\n          typeof opts.preview === \"boolean\" ? undefined : opts.preview\n        )\n      : undefined;\n\n    const result = yield* upStack(stack, opts.up);\n    return { stack, result, preview };\n  });\n"]}