alchemy 2.0.0-beta.64 → 2.0.0-beta.66

package/src/AWS/ECS/Task.ts

@@ -19,7 +19,7 @@ import * as Provider from "../../Provider.ts";
 import { Resource, type ResourceBinding } from "../../Resource.ts";
 import type { RuntimeContext } from "../../RuntimeContext.ts";
 import {
-  createHostRuntimeContext,
+  createContainerRuntimeContext,
   type HostRuntimeContext,
   type ServerHost,
 } from "../../Server/Process.ts";
@@ -104,6 +104,17 @@ export interface TaskDefinitionConfig {
    * Additional environment variables for the container.
    */
   env?: Record<string, any>;
+  /**
+   * Environment files to load into the primary container, e.g. `.env`
+   * objects stored in S3:
+   * `[{ value: "arn:aws:s3:::my-bucket/app.env", type: "s3" }]`.
+   *
+   * Variables from `env` (and the container's own `environment`) take
+   * precedence over values loaded from environment files. The execution
+   * role is automatically granted `s3:GetObject` on the referenced objects
+   * and `s3:GetBucketLocation` on their buckets.
+   */
+  environmentFiles?: ecs.EnvironmentFile[];
   /**
    * Command override for the primary container (Docker `CMD`).
    */
@@ -298,37 +309,8 @@ export interface TaskRuntimeContext extends HostRuntimeContext {
   readonly Type: "AWS.ECS.Task";
 }
 
-/**
- * Host runtime context for ECS container platforms: extends the shared
- * process host context so an impl shape's `run` effect is registered as a
- * one-shot runner (the container exits when it completes) and the HTTP
- * server only boots when the impl actually declares a `fetch` handler.
- */
-export const createContainerRuntimeContext =
-  (type: string) =>
-  (id: string): HostRuntimeContext => {
-    const base = createHostRuntimeContext(type)(id);
-    // Capture the host serve BEFORE Object.assign overwrites `base.serve`
-    // with the wrapper below — calling `base.serve` inside the wrapper would
-    // resolve to the wrapper itself (property lookup happens at call time)
-    // and recurse without bound the moment an impl declares `fetch`.
-    const serveBase = base.serve;
-    const serve: HostRuntimeContext["serve"] = (handler, options) =>
-      Effect.gen(function* () {
-        const shape = options?.shape;
-        const run = shape?.run;
-        if (Effect.isEffect(run)) {
-          yield* base.run(run as Effect.Effect<void, never, any>);
-        }
-        // Boot the HTTP server only for an impl that declared `fetch` — a
-        // pure one-shot `{ run }` program must exit when `run` completes
-        // rather than parking behind the 404 fallback server forever.
-        if (shape === undefined || shape.fetch !== undefined) {
-          yield* serveBase(handler, options);
-        }
-      }) as Effect.Effect<void, never, never>;
-    return Object.assign(base, { serve });
-  };
+// Shared with `Docker.Service`; lives beside the host runtime context.
+export { createContainerRuntimeContext } from "../../Server/Process.ts";
 
 /**
  * A Fargate task definition with a container image from one of three
@@ -426,6 +408,16 @@ export const createContainerRuntimeContext =
  *   },
  * });
  * ```
+ *
+ * @example Environment Files from S3
+ * ```typescript
+ * const task = yield* Task("ApiTask", {
+ *   main: import.meta.url,
+ *   environmentFiles: [
+ *     { value: "arn:aws:s3:::my-config-bucket/app.env", type: "s3" },
+ *   ],
+ * });
+ * ```
  */
 export const Task: Platform<Task, TaskServices, TaskShape, TaskRuntimeContext> =
   Platform("AWS.ECS.Task", {
@@ -518,6 +510,56 @@ export const ensureTaskExecutionRole = Effect.fn(function* ({
   return roleArn;
 });
 
+/** Inline policy granting the execution role read access to `environmentFiles`. */
+const ENVIRONMENT_FILES_POLICY_NAME = "alchemy-environment-files";
+
+/**
+ * Sync the execution role's read access to the S3 `environmentFiles`: put
+ * an inline policy granting `s3:GetObject` on the referenced objects (and
+ * `s3:GetBucketLocation` on their buckets), or delete the policy when no
+ * environment files are configured.
+ */
+export const syncEnvironmentFilesPolicy = Effect.fn(function* ({
+  roleName,
+  environmentFiles,
+}: {
+  roleName: string;
+  environmentFiles: ecs.EnvironmentFile[] | undefined;
+}) {
+  const objectArns = (environmentFiles ?? [])
+    .filter((file) => file.type === "s3")
+    .map((file) => file.value);
+  if (objectArns.length === 0) {
+    yield* iam
+      .deleteRolePolicy({
+        RoleName: roleName,
+        PolicyName: ENVIRONMENT_FILES_POLICY_NAME,
+      })
+      .pipe(Effect.catchTag("NoSuchEntityException", () => Effect.void));
+    return;
+  }
+  const bucketArns = [...new Set(objectArns.map((arn) => arn.split("/")[0]))];
+  yield* iam.putRolePolicy({
+    RoleName: roleName,
+    PolicyName: ENVIRONMENT_FILES_POLICY_NAME,
+    PolicyDocument: JSON.stringify({
+      Version: "2012-10-17",
+      Statement: [
+        {
+          Effect: "Allow",
+          Action: ["s3:GetObject"],
+          Resource: objectArns,
+        },
+        {
+          Effect: "Allow",
+          Action: ["s3:GetBucketLocation"],
+          Resource: bucketArns,
+        },
+      ],
+    }),
+  });
+});
+
 /** Ensure the CloudWatch log group the task writes to exists. */
 export const ensureTaskLogGroup = Effect.fn(function* ({
   id,
@@ -655,6 +697,7 @@ export const registerTaskDefinitionRevision = Effect.fn(function* ({
       name,
       value: typeof value === "string" ? value : JSON.stringify(value),
     })),
+    environmentFiles: props.environmentFiles,
     logConfiguration: {
       logDriver: "awslogs",
       options: {
@@ -1137,6 +1180,13 @@ export const TaskProvider = () =>
               );
           }
 
+          // Environment files: the execution role reads the referenced S3
+          // objects at task start.
+          yield* syncEnvironmentFilesPolicy({
+            roleName: executionRoleName,
+            environmentFiles: news.environmentFiles,
+          });
+
           const {
             env: bindingEnv,
             volumes: bindingVolumes,

package/src/AWS/EKS/Addon.ts

@@ -161,7 +161,11 @@ class AddonNotReady extends Data.TaggedError("AddonNotReady")<{
   readonly clusterName: string;
   readonly addonName: string;
   readonly status: string | undefined;
-}> {}
+}> {
+  override get message(): string {
+    return `addon '${this.clusterName}/${this.addonName}' is not ACTIVE (status: ${this.status ?? "absent"})`;
+  }
+}
 
 class AddonStillExists extends Data.TaggedError("AddonStillExists")<{
   readonly clusterName: string;
@@ -233,8 +237,14 @@ export const AddonProvider = () =>
           }
         }),
         read: Effect.fn(function* ({ id, olds }) {
+          const clusterName = olds.clusterName as string | undefined;
+          // A crashed prior run can persist a row before its unresolved
+          // inputs were stripped — nothing observable yet.
+          if (clusterName === undefined || olds.addonName === undefined) {
+            return undefined;
+          }
           const state = yield* readAddon({
-            clusterName: olds.clusterName as string,
+            clusterName,
             addonName: olds.addonName,
           });
           if (!state) return undefined;
@@ -404,11 +414,14 @@ const waitForAddonActive = Effect.fn(function* ({
     }),
     Effect.retry({
       while: (error) => error instanceof AddonNotReady,
-      // Flat 5s polls, ~10 min budget (uncapped exponential sleeps for
+      // Flat 5s polls, ~20 min budget (uncapped exponential sleeps for
       // multi-minute stretches late in the wait — looks like a deadlock).
+      // Node-bound addons (e.g. HyperPod task governance) stay DEGRADED
+      // until nodes join and pull images, which can take most of the
+      // budget when the addon installs alongside its node group.
       schedule: Schedule.max([
         Schedule.spaced("5 seconds"),
-        Schedule.recurs(120),
+        Schedule.recurs(240),
       ]),
     }),
   );

package/src/AWS/EKS/Deployment.ts

@@ -35,6 +35,12 @@ import {
   deleteObjects,
   type KubernetesClusterConnection,
 } from "./internal/client.ts";
+import {
+  hyperpodNamespace,
+  hyperpodNodeSelector,
+  hyperpodWorkloadLabels,
+  type HyperPodWorkloadProps,
+} from "./HyperPod.ts";
 import {
   toKubernetesObjectRef,
   type KubernetesObjectDefinition,
@@ -76,9 +82,17 @@ export interface DeploymentPropsBase extends PlatformProps {
   /**
    * Kubernetes namespace to deploy into. The namespace must already exist
    * (Auto Mode clusters ship a `default` namespace).
-   * @default "default"
+   * @default "default" (or `hyperpod-ns-<team>` when `hyperpod.quota` is set)
    */
   namespace?: string;
+  /**
+   * Run on SageMaker HyperPod nodes attached to this EKS cluster: pin to an
+   * instance group, keep off unhealthy nodes, and optionally submit through
+   * HyperPod task governance by passing the team's
+   * `AWS.SageMaker.ComputeQuota` (which derives the namespace and Kueue
+   * labels).
+   */
+  hyperpod?: HyperPodWorkloadProps;
   /**
    * HTTP port exposed by the container and the Service.
    * @default 3000
@@ -368,6 +382,7 @@ import { BunServices } from "@effect/platform-bun";
 import { BunHttpServer } from "alchemy/Http";
 import { Stack } from "alchemy/Stack";
 import { makeEntrypointLayer, reifyBoundConfigProvider } from "alchemy/Runtime";
+import { provideProcessTelemetry } from "alchemy/Telemetry";
 import * as Context from "effect/Context";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
@@ -400,8 +415,15 @@ const platform = Layer.mergeAll(
 // chain so EKS Pod Identity's container-credentials endpoint
 // (AWS_CONTAINER_CREDENTIALS_FULL_URI + token file) resolves inside the pod.
 const program = tag.pipe(
-  Effect.flatMap((host) => host.RuntimeContext.exports),
-  Effect.flatMap((exports) => exports.program),
+  // Process-lifetime telemetry: built once into the root scope; exporters
+  // batch on their intervals and flush when the scope closes on graceful
+  // shutdown.
+  Effect.flatMap((host) =>
+    host.RuntimeContext.exports.pipe(
+      Effect.flatMap((exports) => exports.program),
+      provideProcessTelemetry(host.RuntimeContext),
+    ),
+  ),
   Effect.provide(
     layer.pipe(Layer.provideMerge(Layer.effect(
       Stack,
@@ -539,9 +561,11 @@ export const DeploymentProvider = () =>
           ) {
             return { action: "replace" } as const;
           }
+          const effectiveNamespace = (props: DeploymentProps) =>
+            props.namespace ?? hyperpodNamespace(props.hyperpod) ?? "default";
           if (
-            olds.namespace !== undefined &&
-            (olds.namespace ?? "default") !== (news.namespace ?? "default")
+            olds.cluster?.clusterName !== undefined &&
+            effectiveNamespace(olds) !== effectiveNamespace(news)
           ) {
             return { action: "replace" } as const;
           }
@@ -585,7 +609,8 @@ export const DeploymentProvider = () =>
         }) {
           const connection = toConnection(news.cluster);
           const clusterName = news.cluster.clusterName;
-          const namespace = news.namespace ?? "default";
+          const namespace =
+            news.namespace ?? hyperpodNamespace(news.hyperpod) ?? "default";
           const port = news.port ?? 3000;
           const serviceType = news.serviceType ?? "LoadBalancer";
 
@@ -651,7 +676,10 @@ export const DeploymentProvider = () =>
           // get no region env var — inject it so the bootstrap's
           // `Region.fromEnv()` resolves inside the pod.
           const { region } = yield* AWSEnvironment.current;
-          const labels = news.labels ?? { "app.kubernetes.io/name": baseName };
+          const labels = {
+            ...(news.labels ?? { "app.kubernetes.io/name": baseName }),
+            ...hyperpodWorkloadLabels(news.hyperpod),
+          };
           const containerEnv = {
             ...bindingEnv,
             ...alchemyEnv,
@@ -670,6 +698,7 @@ export const DeploymentProvider = () =>
               metadata: { labels },
               spec: {
                 serviceAccountName,
+                nodeSelector: hyperpodNodeSelector(news.hyperpod),
                 containers: [
                   {
                     name: baseName,

package/src/AWS/EKS/HyperPod.ts

@@ -0,0 +1,97 @@
+/**
+ * First-class SageMaker HyperPod scheduling for EKS workloads.
+ *
+ * HyperPod nodes are ordinary EKS nodes carrying well-known labels, and
+ * HyperPod task governance rides on Kueue conventions. `AWS.EKS.Job` and
+ * `AWS.EKS.Deployment` accept these props under `hyperpod:` and derive the
+ * node selector, namespace, and Kueue labels — no manual label wiring.
+ */
+
+/** The well-known node label carrying the HyperPod instance-group name. */
+export const HYPERPOD_INSTANCE_GROUP_LABEL =
+  "sagemaker.amazonaws.com/instance-group-name";
+
+/** The well-known node label carrying HyperPod's node health verdict. */
+export const HYPERPOD_NODE_HEALTH_LABEL =
+  "sagemaker.amazonaws.com/node-health-status";
+
+/** Kueue label selecting the task-governance queue. */
+export const KUEUE_QUEUE_NAME_LABEL = "kueue.x-k8s.io/queue-name";
+
+/** Kueue label selecting the task-governance priority class. */
+export const KUEUE_PRIORITY_CLASS_LABEL = "kueue.x-k8s.io/priority-class";
+
+export interface HyperPodWorkloadProps {
+  /**
+   * Pin the workload to a HyperPod instance group (matches the
+   * `sagemaker.amazonaws.com/instance-group-name` node label). Reference
+   * the group through the cluster's attributes —
+   * `hyperpod.instanceGroups.workers` — so the workload is connected to
+   * the cluster through the resource graph. A plain name string also
+   * works.
+   */
+  instanceGroup?: string | { InstanceGroupName?: string };
+  /**
+   * Only schedule onto nodes that passed HyperPod health checks
+   * (`sagemaker.amazonaws.com/node-health-status: Schedulable`).
+   * @default true
+   */
+  healthyNodesOnly?: boolean;
+  /**
+   * Submit through HyperPod task governance under this team's quota — pass
+   * the `AWS.SageMaker.ComputeQuota` resource. Derives the
+   * `hyperpod-ns-<team>` namespace and the Kueue queue label (both
+   * materialized by the quota), and orders the workload after it.
+   */
+  quota?: {
+    /** The quota's team name (`ComputeQuota.teamName`). */
+    teamName: string;
+  };
+  /**
+   * The task-governance priority class (a `PriorityClass` name from the
+   * cluster's `AWS.SageMaker.ClusterSchedulerConfig`).
+   */
+  priorityClass?: string;
+}
+
+/** @internal The `hyperpod-ns-<team>` namespace, when governed. */
+export const hyperpodNamespace = (
+  hyperpod: HyperPodWorkloadProps | undefined,
+): string | undefined =>
+  hyperpod?.quota !== undefined
+    ? `hyperpod-ns-${hyperpod.quota.teamName}`
+    : undefined;
+
+/** @internal Kueue labels for the workload object. */
+export const hyperpodWorkloadLabels = (
+  hyperpod: HyperPodWorkloadProps | undefined,
+): Record<string, string> => ({
+  ...(hyperpod?.quota !== undefined
+    ? {
+        [KUEUE_QUEUE_NAME_LABEL]: `hyperpod-ns-${hyperpod.quota.teamName}-localqueue`,
+      }
+    : {}),
+  ...(hyperpod?.priorityClass !== undefined
+    ? { [KUEUE_PRIORITY_CLASS_LABEL]: `${hyperpod.priorityClass}-priority` }
+    : {}),
+});
+
+/** @internal The instance-group name from either reference form. */
+const instanceGroupName = (
+  group: string | { InstanceGroupName?: string } | undefined,
+): string | undefined =>
+  typeof group === "string" ? group : group?.InstanceGroupName;
+
+/** @internal Node selector pinning pods onto HyperPod nodes. */
+export const hyperpodNodeSelector = (
+  hyperpod: HyperPodWorkloadProps | undefined,
+): Record<string, string> | undefined => {
+  if (hyperpod === undefined) return undefined;
+  const group = instanceGroupName(hyperpod.instanceGroup);
+  return {
+    ...(hyperpod.healthyNodesOnly !== false
+      ? { [HYPERPOD_NODE_HEALTH_LABEL]: "Schedulable" }
+      : {}),
+    ...(group !== undefined ? { [HYPERPOD_INSTANCE_GROUP_LABEL]: group } : {}),
+  };
+};

package/src/AWS/EKS/Job.ts

@@ -35,6 +35,12 @@ import {
 import { AWSEnvironment } from "../Environment.ts";
 import type { PolicyStatement } from "../IAM/Policy.ts";
 import type { Providers } from "../Providers.ts";
+import {
+  hyperpodNamespace,
+  hyperpodNodeSelector,
+  hyperpodWorkloadLabels,
+  type HyperPodWorkloadProps,
+} from "./HyperPod.ts";
 import { reconcileObjects, deleteObjects } from "./internal/client.ts";
 import type {
   KubernetesObjectDefinition,
@@ -75,9 +81,17 @@ export interface JobPropsBase extends PlatformProps {
   /**
    * Kubernetes namespace to run in. The namespace must already exist (Auto
    * Mode clusters ship a `default` namespace).
-   * @default "default"
+   * @default "default" (or `hyperpod-ns-<team>` when `hyperpod.quota` is set)
    */
   namespace?: string;
+  /**
+   * Run on SageMaker HyperPod nodes attached to this EKS cluster: pin to an
+   * instance group, keep off unhealthy nodes, and optionally submit through
+   * HyperPod task governance by passing the team's
+   * `AWS.SageMaker.ComputeQuota` (which derives the namespace and Kueue
+   * labels).
+   */
+  hyperpod?: HyperPodWorkloadProps;
   /**
    * Number of retries before the Job is marked failed (Kubernetes
    * `backoffLimit`).
@@ -343,6 +357,7 @@ export const makeEksJobBootstrap =
 import { BunServices } from "@effect/platform-bun";
 import { Stack } from "alchemy/Stack";
 import { makeEntrypointLayer, reifyBoundConfigProvider } from "alchemy/Runtime";
+import { provideProcessTelemetry } from "alchemy/Telemetry";
 import * as Context from "effect/Context";
 import * as Config from "effect/Config";
 import * as ConfigProvider from "effect/ConfigProvider";
@@ -372,8 +387,15 @@ const platform = Layer.mergeAll(
 // Resolve the bundled program's registered one-shot runners (the shape's
 // \`run\` effect and any host.run work) and execute them to completion.
 const program = tag.pipe(
-  Effect.flatMap((host) => host.RuntimeContext.exports),
-  Effect.flatMap((exports) => exports.program),
+  // Process-lifetime telemetry: built once into the root scope; exporters
+  // batch on their intervals and flush when the scope closes as the
+  // one-shot program completes.
+  Effect.flatMap((host) =>
+    host.RuntimeContext.exports.pipe(
+      Effect.flatMap((exports) => exports.program),
+      provideProcessTelemetry(host.RuntimeContext),
+    ),
+  ),
   Effect.provide(
     layer.pipe(Layer.provideMerge(Layer.effect(
       Stack,
@@ -472,9 +494,11 @@ export const JobProvider = () =>
           ) {
             return { action: "replace" } as const;
           }
+          const effectiveNamespace = (props: JobProps) =>
+            props.namespace ?? hyperpodNamespace(props.hyperpod) ?? "default";
           if (
-            olds.namespace !== undefined &&
-            (olds.namespace ?? "default") !== (news.namespace ?? "default")
+            olds.cluster?.clusterName !== undefined &&
+            effectiveNamespace(olds) !== effectiveNamespace(news)
           ) {
             return { action: "replace" } as const;
           }
@@ -515,7 +539,8 @@ export const JobProvider = () =>
         }) {
           const connection = toConnection(news.cluster);
           const clusterName = news.cluster.clusterName;
-          const namespace = news.namespace ?? "default";
+          const namespace =
+            news.namespace ?? hyperpodNamespace(news.hyperpod) ?? "default";
 
           const baseName = yield* toBaseName(id, news);
           const serviceAccountName = output?.serviceAccountName ?? baseName;
@@ -569,7 +594,10 @@ export const JobProvider = () =>
           });
 
           // Synthesize the Kubernetes objects.
-          const labels = news.labels ?? { "app.kubernetes.io/name": baseName };
+          const labels = {
+            ...(news.labels ?? { "app.kubernetes.io/name": baseName }),
+            ...hyperpodWorkloadLabels(news.hyperpod),
+          };
           const containerEnv = {
             ...bindingEnv,
             ...alchemyEnv,
@@ -586,6 +614,7 @@ export const JobProvider = () =>
               metadata: { labels },
               spec: {
                 serviceAccountName,
+                nodeSelector: hyperpodNodeSelector(news.hyperpod),
                 restartPolicy: news.restartPolicy ?? "Never",
                 containers: [
                   {
@@ -620,9 +649,13 @@ export const JobProvider = () =>
           // hash of the spec, and a spec change applies a NEW Job (which
           // runs) while `reconcileObjects` deletes the previous one.
           // CronJobs are mutable and keep the stable base name.
+          // Kubernetes rejects Job names over 63 characters (the API
+          // stamps the name into the batch.kubernetes.io/job-name pod
+          // label, and label values cap at 63) — truncate the base so the
+          // content-address suffix always fits.
           const jobName = news.schedule
-            ? baseName
-            : `${baseName}-${(yield* sha256Object(jobSpec)).slice(0, 8)}`;
+            ? baseName.slice(0, 52).replace(/-+$/, "")
+            : `${baseName.slice(0, 54).replace(/-+$/, "")}-${(yield* sha256Object(jobSpec)).slice(0, 8)}`;
 
           const workloadObject: KubernetesObjectDefinition = news.schedule
             ? {

package/src/AWS/EKS/internal/client.ts

@@ -10,6 +10,7 @@ import { AwsClient } from "aws4fetch";
 import * as Data from "effect/Data";
 import * as Effect from "effect/Effect";
 import * as Redacted from "effect/Redacted";
+import * as Schedule from "effect/Schedule";
 import * as https from "node:https";
 import { AWSEnvironment } from "../../Environment.ts";
 import {
@@ -30,7 +31,13 @@ export class KubernetesApiError extends Data.TaggedError("KubernetesApiError")<{
   path: string;
   statusCode: number;
   body: string;
-}> {}
+}> {
+  override get message(): string {
+    return `${this.method} ${this.path} responded ${this.statusCode}: ${
+      this.body.length > 0 ? this.body.slice(0, 1000) : "(empty body)"
+    }`;
+  }
+}
 
 export interface KubernetesClusterConnection {
   clusterName: string;
@@ -163,7 +170,20 @@ const requestJson = Effect.fn(function* ({
         : new Error(
             `Failed Kubernetes ${method} ${path}: ${error instanceof Error ? error.message : String(error)}`,
           ),
-  });
+  }).pipe(
+    // Transport-level failures (ECONNREFUSED/ECONNRESET/ETIMEDOUT/DNS)
+    // are transient — a fresh EKS endpoint's NLB can refuse connections
+    // for a short window after the cluster reports ACTIVE. Every request
+    // here is idempotent (GET / SSA PATCH / DELETE), so retry them; HTTP
+    // errors (KubernetesApiError) are handled by the callers.
+    Effect.retry({
+      while: (e): boolean => !(e instanceof KubernetesApiError),
+      schedule: Schedule.max([
+        Schedule.spaced("5 seconds"),
+        Schedule.recurs(8),
+      ]),
+    }),
+  );
 });
 
 // ─────────────────────────────────────────────────────── kind discovery ──
@@ -285,7 +305,24 @@ export const applyObject = Effect.fn(function* ({
     method: "PATCH",
     path,
     body: object,
-  });
+  }).pipe(
+    // A freshly ACTIVE cluster's API server briefly 5xxes while warming
+    // up, and the creator's bootstrap access entry propagates
+    // asynchronously (401/403 in the first minute) — retry transient
+    // failures for ~1 min.
+    Effect.retry({
+      while: (e): boolean =>
+        e instanceof KubernetesApiError &&
+        (e.statusCode >= 500 ||
+          e.statusCode === 429 ||
+          e.statusCode === 401 ||
+          e.statusCode === 403),
+      schedule: Schedule.max([
+        Schedule.spaced("6 seconds"),
+        Schedule.recurs(10),
+      ]),
+    }),
+  );
 });
 
 export const deleteObject = Effect.fn(function* ({